libs/or-tools-src-ubuntu/include/scip/paramset.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   paramset.h
+ * @ingroup INTERNALAPI
+ * @brief  internal methods for handling parameter settings
+ * @author Tobias Achterberg
+ * @author Timo Berthold
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PARAMSET_H__
+#define __SCIP_PARAMSET_H__
+
+
+#include "scip/def.h"
+#include "blockmemshell/memory.h"
+#include "scip/type_set.h"
+#include "scip/type_retcode.h"
+#include "scip/type_paramset.h"
+#include "scip/pub_paramset.h"
+#include "scip/pub_misc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates parameter set */
+SCIP_RETCODE SCIPparamsetCreate(
+   SCIP_PARAMSET**       paramset,           /**< pointer to store the parameter set */
+   BMS_BLKMEM*           blkmem              /**< block memory */
+   );
+
+/** frees parameter set */
+void SCIPparamsetFree(
+   SCIP_PARAMSET**       paramset,           /**< pointer to the parameter set */
+   BMS_BLKMEM*           blkmem              /**< block memory */
+   );
+
+/** creates a bool parameter, sets it to its default value, and adds it to the parameter set */
+SCIP_RETCODE SCIPparamsetAddBool(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory */
+   const char*           name,               /**< name of the parameter */
+   const char*           desc,               /**< description of the parameter */
+   SCIP_Bool*            valueptr,           /**< pointer to store the current parameter value, or NULL */
+   SCIP_Bool             isadvanced,         /**< is this parameter an advanced parameter? */
+   SCIP_Bool             defaultvalue,       /**< default value of the parameter */
+   SCIP_DECL_PARAMCHGD   ((*paramchgd)),     /**< change information method of parameter */
+   SCIP_PARAMDATA*       paramdata           /**< locally defined parameter specific data */
+   );
+
+/** creates a int parameter, sets it to its default value, and adds it to the parameter set */
+SCIP_RETCODE SCIPparamsetAddInt(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory */
+   const char*           name,               /**< name of the parameter */
+   const char*           desc,               /**< description of the parameter */
+   int*                  valueptr,           /**< pointer to store the current parameter value, or NULL */
+   SCIP_Bool             isadvanced,         /**< is this parameter an advanced parameter? */
+   int                   defaultvalue,       /**< default value of the parameter */
+   int                   minvalue,           /**< minimum value for parameter */
+   int                   maxvalue,           /**< maximum value for parameter */
+   SCIP_DECL_PARAMCHGD   ((*paramchgd)),     /**< change information method of parameter */
+   SCIP_PARAMDATA*       paramdata           /**< locally defined parameter specific data */
+   );
+
+/** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set */
+SCIP_RETCODE SCIPparamsetAddLongint(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory */
+   const char*           name,               /**< name of the parameter */
+   const char*           desc,               /**< description of the parameter */
+   SCIP_Longint*         valueptr,           /**< pointer to store the current parameter value, or NULL */
+   SCIP_Bool             isadvanced,         /**< is this parameter an advanced parameter? */
+   SCIP_Longint          defaultvalue,       /**< default value of the parameter */
+   SCIP_Longint          minvalue,           /**< minimum value for parameter */
+   SCIP_Longint          maxvalue,           /**< maximum value for parameter */
+   SCIP_DECL_PARAMCHGD   ((*paramchgd)),     /**< change information method of parameter */
+   SCIP_PARAMDATA*       paramdata           /**< locally defined parameter specific data */
+   );
+
+/** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set */
+SCIP_RETCODE SCIPparamsetAddReal(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory */
+   const char*           name,               /**< name of the parameter */
+   const char*           desc,               /**< description of the parameter */
+   SCIP_Real*            valueptr,           /**< pointer to store the current parameter value, or NULL */
+   SCIP_Bool             isadvanced,         /**< is this parameter an advanced parameter? */
+   SCIP_Real             defaultvalue,       /**< default value of the parameter */
+   SCIP_Real             minvalue,           /**< minimum value for parameter */
+   SCIP_Real             maxvalue,           /**< maximum value for parameter */
+   SCIP_DECL_PARAMCHGD   ((*paramchgd)),     /**< change information method of parameter */
+   SCIP_PARAMDATA*       paramdata           /**< locally defined parameter specific data */
+   );
+
+/** creates a char parameter, sets it to its default value, and adds it to the parameter set */
+SCIP_RETCODE SCIPparamsetAddChar(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory */
+   const char*           name,               /**< name of the parameter */
+   const char*           desc,               /**< description of the parameter */
+   char*                 valueptr,           /**< pointer to store the current parameter value, or NULL */
+   SCIP_Bool             isadvanced,         /**< is this parameter an advanced parameter? */
+   char                  defaultvalue,       /**< default value of the parameter */
+   const char*           allowedvalues,      /**< array with possible parameter values, or NULL if not restricted */
+   SCIP_DECL_PARAMCHGD   ((*paramchgd)),     /**< change information method of parameter */
+   SCIP_PARAMDATA*       paramdata           /**< locally defined parameter specific data */
+   );
+
+/** creates a string parameter, sets it to its default value, and adds it to the parameter set */
+SCIP_RETCODE SCIPparamsetAddString(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory */
+   const char*           name,               /**< name of the parameter */
+   const char*           desc,               /**< description of the parameter */
+   char**                valueptr,           /**< pointer to store the current parameter value, or NULL */
+   SCIP_Bool             isadvanced,         /**< is this parameter an advanced parameter? */
+   const char*           defaultvalue,       /**< default value of the parameter */
+   SCIP_DECL_PARAMCHGD   ((*paramchgd)),     /**< change information method of parameter */
+   SCIP_PARAMDATA*       paramdata           /**< locally defined parameter specific data */
+   );
+
+/** returns whether an existing parameter is fixed */
+SCIP_Bool SCIPparamsetIsFixed(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name                /**< name of the parameter */
+   );
+
+/** returns the pointer to an existing SCIP parameter */
+SCIP_PARAM* SCIPparamsetGetParam(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name                /**< name of the parameter */
+   );
+
+/** gets the value of an existing SCIP_Bool parameter */
+SCIP_RETCODE SCIPparamsetGetBool(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Bool*            value               /**< pointer to store the parameter */
+   );
+
+/** gets the value of an existing int parameter */
+SCIP_RETCODE SCIPparamsetGetInt(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   int*                  value               /**< pointer to store the parameter */
+   );
+
+/** gets the value of an existing SCIP_Longint parameter */
+SCIP_RETCODE SCIPparamsetGetLongint(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Longint*         value               /**< pointer to store the parameter */
+   );
+
+/** gets the value of an existing SCIP_Real parameter */
+SCIP_RETCODE SCIPparamsetGetReal(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Real*            value               /**< pointer to store the parameter */
+   );
+
+/** gets the value of an existing char parameter */
+SCIP_RETCODE SCIPparamsetGetChar(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   char*                 value               /**< pointer to store the parameter */
+   );
+
+/** gets the value of an existing string parameter */
+SCIP_RETCODE SCIPparamsetGetString(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   char**                value               /**< pointer to store the parameter */
+   );
+
+/** changes the fixing status of an existing parameter */
+SCIP_RETCODE SCIPparamsetFix(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Bool             fixed               /**< new fixing status of the parameter */
+   );
+
+/** changes the value of an existing parameter */
+SCIP_RETCODE SCIPparamsetSet(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   void*                 value               /**< new value of the parameter */
+   );
+
+/** changes the value of an existing SCIP_Bool parameter */
+SCIP_RETCODE SCIPparamsetSetBool(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Bool             value               /**< new value of the parameter */
+   );
+
+/** changes the default value of an existing SCIP_Bool parameter */
+SCIP_RETCODE SCIPparamsetSetDefaultBool(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Bool             defaultvalue        /**< new default value of the parameter */
+   );
+
+/** changes the value of an existing int parameter */
+SCIP_RETCODE SCIPparamsetSetInt(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   int                   value               /**< new value of the parameter */
+   );
+
+/** changes the default value of an existing int parameter */
+SCIP_RETCODE SCIPparamsetSetDefaultInt(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   const char*           name,               /**< name of the parameter */
+   int                   defaultvalue        /**< new default value of the parameter */
+   );
+
+/** changes the value of an existing SCIP_Longint parameter */
+SCIP_RETCODE SCIPparamsetSetLongint(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Longint          value               /**< new value of the parameter */
+   );
+
+/** changes the value of an existing SCIP_Real parameter */
+SCIP_RETCODE SCIPparamsetSetReal(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   SCIP_Real             value               /**< new value of the parameter */
+   );
+
+/** changes the value of an existing char parameter */
+SCIP_RETCODE SCIPparamsetSetChar(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   char                  value               /**< new value of the parameter */
+   );
+
+/** changes the value of an existing string parameter */
+SCIP_RETCODE SCIPparamsetSetString(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           name,               /**< name of the parameter */
+   const char*           value               /**< new value of the parameter */
+   );
+
+/** reads parameters from a file */
+SCIP_RETCODE SCIPparamsetRead(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           filename            /**< file name */
+   );
+
+/** writes all parameters in the parameter set to a file */
+SCIP_RETCODE SCIPparamsetWrite(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           filename,           /**< file name, or NULL for stdout */
+   SCIP_Bool             comments,           /**< should parameter descriptions be written as comments? */
+   SCIP_Bool             onlychanged         /**< should only the parameters been written, that are changed from default? */
+   );
+
+/** installs default values for all parameters */
+SCIP_RETCODE SCIPparamsetSetToDefaults(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr         /**< message handler */
+   );
+
+/** installs default value for a single parameter */
+SCIP_RETCODE SCIPparamsetSetToDefault(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           paramname           /**< name of the parameter */
+   );
+
+/** sets parameters to 
+ *
+ *  - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPparamsetSetToDefault())
+ *  - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
+ *  - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
+ *  - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
+ *  - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
+ *  - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
+ *  - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
+ *  - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
+ *  - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
+ *  - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
+ *  - \ref SCIP_PARAMEMPHASIS_NUMERICS to solve problems which cause numerical issues
+ */
+SCIP_RETCODE SCIPparamsetSetEmphasis(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_PARAMEMPHASIS    paramemphasis,      /**< parameter emphasis */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
+ *  auxiliary SCIP instances to avoid recursion
+ */
+SCIP_RETCODE SCIPparamsetSetToSubscipsOff(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets heuristic parameters values to 
+ *  - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters 
+ *  - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
+ *  - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
+ *  - SCIP_PARAMSETTING_OFF which turn off all heuristics
+ */
+SCIP_RETCODE SCIPparamsetSetHeuristics(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_PARAMSETTING     paramsetting,       /**< parameter settings */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets presolving parameters to 
+ *  - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters 
+ *  - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
+ *  - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
+ *  - SCIP_PARAMSETTING_OFF which turn off all presolving
+ */
+SCIP_RETCODE SCIPparamsetSetPresolving(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_PARAMSETTING     paramsetting,       /**< parameter settings */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets separating parameters to 
+ *  - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters 
+ *  - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
+ *  - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
+ *  - SCIP_PARAMSETTING_OFF which turn off all separating
+ */
+SCIP_RETCODE SCIPparamsetSetSeparating(
+   SCIP_PARAMSET*        paramset,           /**< parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_PARAMSETTING     paramsetting,       /**< parameter settings */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** returns the array of parameters */
+SCIP_PARAM** SCIPparamsetGetParams(
+   SCIP_PARAMSET*        paramset            /**< parameter set */
+   );
+
+/** returns the number of parameters in the parameter set */
+int SCIPparamsetGetNParams(
+   SCIP_PARAMSET*        paramset            /**< parameter set */
+   );
+
+/** copies all parameter values of the source parameter set to the corresponding parameters in the target set */
+SCIP_RETCODE SCIPparamsetCopyParams(
+   SCIP_PARAMSET*        sourceparamset,     /**< source parameter set */
+   SCIP_PARAMSET*        targetparamset,     /**< target parameter set */
+   SCIP_SET*             set,                /**< global SCIP settings of target SCIP */
+   SCIP_MESSAGEHDLR*     messagehdlr         /**< message handler of target SCIP */
+   );
+
+/** checks whether value of SCIP_Bool parameter is valid */
+SCIP_Bool SCIPparamIsValidBool(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_Bool             value               /**< value to check */
+   );
+
+/** checks whether value of integer parameter is valid */
+SCIP_Bool SCIPparamIsValidInt(
+   SCIP_PARAM*           param,              /**< parameter */
+   int                   value               /**< value to check */
+   );
+
+/** checks whether value of SCIP_Longint parameter is valid */
+SCIP_Bool SCIPparamIsValidLongint(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_Longint          value               /**< value to check */
+   );
+
+/** checks whether value of SCIP_Real parameter is valid */
+SCIP_Bool SCIPparamIsValidReal(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_Real             value               /**< value to check */
+   );
+
+/** checks whether value of char parameter is valid */
+SCIP_Bool SCIPparamIsValidChar(
+   SCIP_PARAM*           param,              /**< parameter */
+   const char            value               /**< value to check */
+   );
+
+/** checks whether value of string parameter is valid */
+SCIP_Bool SCIPparamIsValidString(
+   SCIP_PARAM*           param,              /**< parameter */
+   const char*           value               /**< value to check */
+   );
+
+/** sets value of SCIP_Bool parameter */
+SCIP_RETCODE SCIPparamSetBool(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings, or NULL if param change method should not be called */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_Bool             value,              /**< new value of the parameter */
+   SCIP_Bool             initialize,         /**< is this the initialization of the parameter? */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets value of int parameter */
+SCIP_RETCODE SCIPparamSetInt(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings, or NULL if param change method should not be called */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   int                   value,              /**< new value of the parameter */
+   SCIP_Bool             initialize,         /**< is this the initialization of the parameter? */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets value of SCIP_Longint parameter */
+SCIP_RETCODE SCIPparamSetLongint(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings, or NULL if param change method should not be called */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_Longint          value,              /**< new value of the parameter */
+   SCIP_Bool             initialize,         /**< is this the initialization of the parameter? */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets value of SCIP_Real parameter */
+SCIP_RETCODE SCIPparamSetReal(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings, or NULL if param change method should not be called */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   SCIP_Real             value,              /**< new value of the parameter */
+   SCIP_Bool             initialize,         /**< is this the initialization of the parameter? */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets value of char parameter */
+SCIP_RETCODE SCIPparamSetChar(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings, or NULL if param change method should not be called */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   char                  value,              /**< new value of the parameter */
+   SCIP_Bool             initialize,         /**< is this the initialization of the parameter? */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets value of string parameter */
+SCIP_RETCODE SCIPparamSetString(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings, or NULL if param change method should not be called */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           value,              /**< new value of the parameter */
+   SCIP_Bool             quiet               /**< should the parameter be set quiet (no output) */
+   );
+
+/** sets default value of SCIP_Bool parameter */
+void SCIPparamSetDefaultBool(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_Bool             defaultvalue        /**< new default value */
+   );
+
+/** sets default value of int parameter */
+void SCIPparamSetDefaultInt(
+   SCIP_PARAM*           param,              /**< parameter */
+   int                   defaultvalue        /**< new default value */
+   );
+
+/** sets the parameter to its default setting */
+SCIP_RETCODE SCIPparamSetToDefault(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr         /**< message handler */
+   );
+
+/** writes a single parameter to a file */
+SCIP_RETCODE SCIPparamWrite(
+   SCIP_PARAM*           param,              /**< parameter */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   const char*           filename,           /**< file name, or NULL for stdout */
+   SCIP_Bool             comments,           /**< should parameter descriptions be written as comments? */
+   SCIP_Bool             onlychanged         /**< should only the parameters been written, that are changed from default? */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol.h
+ * @ingroup INTERNALAPI
+ * @brief  internal methods for presolvers
+ * @author Tobias Achterberg
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_H__
+#define __SCIP_PRESOL_H__
+
+
+#include "scip/def.h"
+#include "blockmemshell/memory.h"
+#include "scip/type_retcode.h"
+#include "scip/type_result.h"
+#include "scip/type_set.h"
+#include "scip/type_presol.h"
+#include "scip/pub_presol.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** copies the given presolver to a new scip */
+SCIP_RETCODE SCIPpresolCopyInclude(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set                 /**< SCIP_SET of SCIP to copy to */
+   );
+
+/** creates a presolver */
+SCIP_RETCODE SCIPpresolCreate(
+   SCIP_PRESOL**         presol,             /**< pointer to store presolver */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler */
+   BMS_BLKMEM*           blkmem,             /**< block memory for parameter settings */
+   const char*           name,               /**< name of presolver */
+   const char*           desc,               /**< description of presolver */
+   int                   priority,           /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
+   int                   maxrounds,          /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
+   SCIP_PRESOLTIMING     timing,             /**< timing mask of the presolver */
+   SCIP_DECL_PRESOLCOPY  ((*presolcopy)),    /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
+   SCIP_DECL_PRESOLFREE  ((*presolfree)),    /**< destructor of presolver to free user data (called when SCIP is exiting) */
+   SCIP_DECL_PRESOLINIT  ((*presolinit)),    /**< initialization method of presolver (called after problem was transformed) */
+   SCIP_DECL_PRESOLEXIT  ((*presolexit)),    /**< deinitialization method of presolver (called before transformed problem is freed) */
+   SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
+   SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
+   SCIP_DECL_PRESOLEXEC  ((*presolexec)),    /**< execution method of presolver */
+   SCIP_PRESOLDATA*      presoldata          /**< presolver data */
+   );
+
+/** frees memory of presolver */
+SCIP_RETCODE SCIPpresolFree(
+   SCIP_PRESOL**         presol,             /**< pointer to presolver data structure */
+   SCIP_SET*             set                 /**< global SCIP settings */
+   );
+
+/** initializes presolver */
+SCIP_RETCODE SCIPpresolInit(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set                 /**< global SCIP settings */
+   );
+
+/** deinitializes presolver */
+SCIP_RETCODE SCIPpresolExit(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set                 /**< global SCIP settings */
+   );
+
+/** informs presolver that the presolving process is being started */
+SCIP_RETCODE SCIPpresolInitpre(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set                 /**< global SCIP settings */
+   );
+
+/** informs presolver that the presolving process is finished */
+SCIP_RETCODE SCIPpresolExitpre(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set                 /**< global SCIP settings */
+   );
+
+/** executes presolver */
+SCIP_RETCODE SCIPpresolExec(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   SCIP_PRESOLTIMING     timing,             /**< current presolving timing */
+   int                   nrounds,            /**< number of presolving rounds already done */
+   int*                  nfixedvars,         /**< pointer to total number of variables fixed of all presolvers */
+   int*                  naggrvars,          /**< pointer to total number of variables aggregated of all presolvers */
+   int*                  nchgvartypes,       /**< pointer to total number of variable type changes of all presolvers */
+   int*                  nchgbds,            /**< pointer to total number of variable bounds tightened of all presolvers */
+   int*                  naddholes,          /**< pointer to total number of domain holes added of all presolvers */
+   int*                  ndelconss,          /**< pointer to total number of deleted constraints of all presolvers */
+   int*                  naddconss,          /**< pointer to total number of added constraints of all presolvers */
+   int*                  nupgdconss,         /**< pointer to total number of upgraded constraints of all presolvers */
+   int*                  nchgcoefs,          /**< pointer to total number of changed coefficients of all presolvers */
+   int*                  nchgsides,          /**< pointer to total number of changed left/right hand sides of all presolvers */
+   SCIP_RESULT*          result              /**< pointer to store the result of the callback method */
+   );
+
+/** sets priority of presolver */
+void SCIPpresolSetPriority(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_SET*             set,                /**< global SCIP settings */
+   int                   priority            /**< new priority of the presolver */
+   );
+
+/** sets copy method of presolver */
+void SCIPpresolSetCopy(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_DECL_PRESOLCOPY  ((*presolcopy))     /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
+   );
+
+/** sets destructor method of presolver */
+void SCIPpresolSetFree(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_DECL_PRESOLFREE  ((*presolfree))     /**< destructor of presolver */
+   );
+
+/** sets initialization method of presolver */
+void SCIPpresolSetInit(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_DECL_PRESOLINIT  ((*presolinit))     /**< initialize presolver */
+   );
+
+/** sets deinitialization method of presolver */
+void SCIPpresolSetExit(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_DECL_PRESOLEXIT  ((*presolexit))     /**< deinitialize presolver */
+   );
+
+/** sets solving process initialization method of presolver */
+void SCIPpresolSetInitpre(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
+   );
+
+/** sets solving process deinitialization method of presolver */
+void SCIPpresolSetExitpre(
+   SCIP_PRESOL*          presol,             /**< presolver */
+   SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
+   );
+
+/** enables or disables all clocks of \p presol, depending on the value of the flag */
+void SCIPpresolEnableOrDisableClocks(
+   SCIP_PRESOL*          presol,             /**< the presolver for which all clocks should be enabled or disabled */
+   SCIP_Bool             enable              /**< should the clocks of the presolver be enabled? */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_boundshift.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_boundshift.h
+ * @ingroup PRESOLVERS
+ * @brief  presolver that converts integer variables with domain [a,b] to integer variables with domain [0,b-a]
+ * @author Tobias Achterberg
+ * @author Michael Winkler
+ *
+ * This presolver converts all integer variables with domain \f$[a,b]\f$ to integer variables with domain
+ * \f$[0,b-a]\f$. This is done by creating a new integer variable \f$y\f$ which will be aggregated to the old variable
+ * \f$x\f$ such that
+ * \f[
+ * x = y + a
+ * \f]
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_BOUNDSHIFT_H__
+#define __SCIP_PRESOL_BOUNDSHIFT_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the boundshift presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolBoundshift(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_convertinttobin.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_convertinttobin.h
+ * @ingroup PRESOLVERS
+ * @brief  presolver that converts integer variables with domain [a,a+1] to binaries
+ * @author Michael Winkler
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_CONVERTINTTOBIN_H__
+#define __SCIP_PRESOL_CONVERTINTTOBIN_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the convertinttobin presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolConvertinttobin(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_domcol.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_domcol.h
+ * @ingroup PRESOLVERS
+ * @brief  dominated column presolver
+ * @author Dieter Weninger
+ *
+ * This presolver looks for dominance relations between variable pairs.
+ * From a dominance relation and certain bound/clique-constellations
+ * variable fixings mostly at the lower bound of the dominated variable can be derived.
+ * Additionally it is possible to improve bounds by predictive bound strengthening.
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_DOMCOL_H__
+#define __SCIP_PRESOL_DOMCOL_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the dominated column presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolDomcol(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_dualagg.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_dualagg.h
+ * @ingroup PRESOLVERS
+ * @brief  aggregate variables by dual arguments
+ * @author Dieter Weninger
+ *
+ * This presolver looks for variables which could not be handled by
+ * duality fixing because of one up-/downlock.
+ * If the constraint which delivers the up-/downlock has
+ * a specific structure, we can aggregate the corresponding variable.
+ *
+ * In more detail (for a minimization problem and the case of only one uplock):
+ *
+ * Given a variable \f$x_i\f$ with \f$c_i \leq 0\f$ and only one up lock (originating from a constraint c),
+ * we are looking for a binary variable \f$x_j\f$ such that:
+ * 1. if \f$x_j = 0\f$, constraint c can only be fulfilled for \f$x_i = lb_i\f$, and
+ * 2. if \f$x_j = 1\f$, constraint c becomes redundant and \f$x_i\f$ can be dual-fixed to its upper bound \f$ub_i\f$
+ * (or vice versa). Then we can perform the following aggregation: \f$x_i = lb_i + x_j (ub_i - lb_i)\f$.
+ *
+ * Similar arguments apply for the case of only one down lock and \f$c_i \geq 0\f$.
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_DUALAGG_H__
+#define __SCIP_PRESOL_DUALAGG_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the dualagg presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolDualagg(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_dualcomp.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_dualcomp.h
+ * @ingroup PRESOLVERS
+ * @brief  dual compensation presolver
+ * @author Dieter Weninger
+ *
+ * This presolver looks for variables with
+ *         i) objcoef >= 0 and exactly one downlock
+ *        ii) objcoef <= 0 and exactly one uplock
+ * and fixes the variable in case i) at the lower bound and in case ii) at the
+ * upper bound if a combination of singleton continuous variables can compensate
+ * the downlock in case i) and the uplock in case ii).
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_DUALCOMP_H__
+#define __SCIP_PRESOL_DUALCOMP_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the dualcomp presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolDualcomp(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_dualinfer.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_dualinfer.h
+ * @ingroup PRESOLVERS
+ * @brief  dual inference presolver
+ * @author Dieter Weninger
+ * @author Patrick Gemander
+ *
+ * This presolver does bound strengthening on continuous variables (columns) for getting bounds on dual variables y.
+ * The bounds of the dual variables are then used to fix primal variables or change the side of constraints.
+ * For ranged rows one needs to decide which side (rhs or lhs) determines the equality.
+ *
+ * We distinguish two cases concerning complementary slackness:
+ * i)  reduced cost fixing:       c_j - sup_y(y^T A_{.j}) > 0 => x_j = l_j
+ *                                c_j - inf_y(y^T A_{.j}) < 0 => x_j = u_j
+ * ii) positive dual lower bound: y_i > 0 =>  A_{i.}x = b_i
+ *
+ * Further information on this presolving approach are given in
+ * Achterberg et al. "Presolve reductions in mixed integer programming"
+ * and for a two-column extension in
+ * Chen et al. "Two-row and two-column mixed-integer presolve using hasing-based pairing methods".
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_DUALINFER_H__
+#define __SCIP_PRESOL_DUALINFER_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the dual inference presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolDualinfer(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_dualsparsify.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_dualsparsify.h
+ * @brief  cancel nonzeros of the constraint matrix based on the columns
+ * @author Dieter Weninger
+ * @author Leona Gottwald
+ * @author Ambros Gleixner
+ * @author Weikun Chen
+ *
+ * This presolver attempts to cancel non-zero entries of the constraint
+ * matrix by adding scaled columns to other columns.
+ *
+ * In more detail, for two columns A_{j.} and A_{k.}, suppose for a given value s, we have
+ *
+ *                  | A_{j.} | - | A_{j.} - s*A_{k.} | > eta,
+ *
+ * where eta is an nonnegative integer. Then we introduce a new variable y := s*x_j + x_k
+ * and aggregate the variable x_k = y - s*x_j. After aggregation, the column of the variable
+ * x_j is A_{j.} + s*A_{j.} which is sparser than A_{j.}. In the case that x_k is no implied
+ * free variable, we need to add a new constraint l_k <= y - weight*x_j <= u_k into the problem
+ * to keep the bounds constraints of variable x_k.
+ *
+ * Further information can be found in
+ * Chen et al. "Two-row and two-column mixed-integer presolve using hasing-based pairing methods".
+ *
+ * @todo add infrastructure to SCIP for handling aggregated binary variables
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_DUALSPARSIFY_H__
+#define __SCIP_PRESOL_DUALSPARSIFY_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the dual sparsify presolver and includes it in SCIP */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolDualsparsify(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_gateextraction.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_gateextraction.h
+ * @ingroup PRESOLVERS
+ * @brief  gateextraction presolver
+ * @author Michael Winkler
+ */
+
+/* This presolver tries to extract gate-constraints meaning and-constraints and set-partitioning constraints (and could
+ * be expanded to find xor-constraints too). This is done by detecting linearizations or systems of inequalities which
+ * form an and-constraint or a set-partitioning constraint. An example:
+ *
+ * we have a logicor constraint of the form:                x + y + z >= 1
+ *
+ * and we also have the following set-packing constraints: (x + y <= 1 and x + z <= 1) <=> (~x + ~y >= 1 and ~x + ~z >= 1)
+ *
+ * - these three constraints form an and-constraint:        x = ~y * ~z (x = AND(~y,~z))
+ *
+ * if an additional set-packing constraint exists:          y + z <= 1
+ *
+ * - these four constraints form a set-partitioning cons.:  x + y + z = 1
+ *
+ * some information can be found:
+ *
+ *  http://www.cs.ubc.ca/~hutter/earg/papers07/cnf-structure.pdf
+ *  http://www.cadence.com/cn/cadence/cadence_labs/Documents/niklas_SAT_2005_Effective.pdf
+ *
+ * We also do some check for logicor and set-packing/-partitioning constraint with the same variables to upgrade these
+ * both constraints into one. For example:
+ *
+ *  x + y + z >= 1 and x + y + z <= 1 form x + y + z = 1
+ *
+ */
+
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_GATEEXTRACTION_H__
+#define __SCIP_PRESOL_GATEEXTRACTION_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the gateextraction presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolGateextraction(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_implics.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_implics.h
+ * @ingroup PRESOLVERS
+ * @brief  implication graph presolver which checks for aggregations
+ * @author Tobias Achterberg
+ *
+ * This presolver looks for variable implications in \f$x == 0\f$ and \f$x == 1\f$ with the same implied variable.
+ * There are four possible cases:
+ * \f[
+ *  x = 0 \Rightarrow y = lb,\; \mathrm{and}\; x = 1 \Rightarrow y = lb:\; \mathrm{fix}\; y\; \mathrm{to}\; lb
+ * \f]
+ * \f[
+ *  x = 0 \Rightarrow y = lb,\; \mathrm{and}\; x = 1 \Rightarrow y = ub:\; \mathrm{aggregate}\; y == lb + (ub-lb)x
+ * \f]
+ * \f[
+ *  x = 0 \Rightarrow y = ub,\; \mathrm{and}\; x = 1 \Rightarrow y = lb:\; \mathrm{aggregate}\;  y == ub - (ub-lb)x
+ * \f]
+ * \f[
+ *  x = 0 \Rightarrow y = ub,\; \mathrm{and}\; x = 1 \Rightarrow y = ub:\; \mathrm{fix}\; y\; \mathrm{to}\; ub
+ * \f]
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_IMPLICS_H__
+#define __SCIP_PRESOL_IMPLICS_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the implics presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolImplics(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_inttobinary.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_inttobinary.h
+ * @ingroup PRESOLVERS
+ * @brief  presolver that converts integer variables with domain [a,a+1] to binaries
+ * @author Tobias Achterberg
+ *
+ * This presolver converts all integer variables with domain \f$[a,a+1]\f$ to binaries variables. This is done by
+ * creating a new binary variable \f$y\f$ which will be aggregated to the old variable \f$x\f$ such that
+ * \f[
+ *   x = y + a
+ * \f]
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_INTTOBINARY_H__
+#define __SCIP_PRESOL_INTTOBINARY_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the inttobinary presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolInttobinary(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_milp.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_milp.h
+ * @ingroup PRESOLVERS
+ * @brief  MILP presolver that calls the presolve library on the constraint matrix
+ * @author Leona Gottwald
+ *
+ * Calls the presolve library and uses the postsolve information to communicate
+ * fixings, bound changes, and (multi-)aggregations to SCIP
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_MILP_H__
+#define __SCIP_PRESOL_MILP_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the MILP presolver and includes it in SCIP if the presolve library is available
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolMILP(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_qpkktref.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_qpkktref.h
+ * @ingroup PRESOLVERS
+ * @brief  qpkktref presolver
+ * @author Tobias Fischer
+ *
+ * This presolver tries to add the KKT conditions as additional (redundant) constraints to the (mixed-binary) quadratic
+ * program
+ *  \f[
+ *  \begin{array}{ll}
+ *  \min         & x^T Q x + c^T x + d \\
+ *               & A x \leq b, \\
+ *               & x \in \{0, 1\}^{p} \times R^{n-p}.
+ * \end{array}
+ * \f]
+ *
+ * We first check if the structure of the program is like (QP), see the documentation of the function
+ * checkConsQuadraticProblem().
+ *
+ * If the problem is known to be bounded (all variables have finite lower and upper bounds), then we add the KKT
+ * conditions. For a continuous QPs the KKT conditions have the form
+ * \f[
+ *  \begin{array}{ll}
+ *   Q x + c + A^T \mu = 0,\\
+ *   Ax \leq b,\\
+ *   \mu_i \cdot (Ax - b)_i = 0,    & i \in \{1, \dots, m\},\\
+ *   \mu \geq 0.
+ * \end{array}
+ * \f]
+ * where \f$\mu\f$ are the Lagrangian variables. Each of the complementarity constraints \f$\mu_i \cdot (Ax - b)_i = 0\f$
+ * is enforced via an SOS1 constraint for \f$\mu_i\f$ and an additional slack variable \f$s_i = (Ax - b)_i\f$.
+ *
+ * For mixed-binary QPs, the KKT-like conditions are
+ * \f[
+ *  \begin{array}{ll}
+ *   Q x + c + A^T \mu + I_J \lambda = 0,\\
+ *   Ax \leq b,\\
+ *   x_j \in \{0,1\}                    & j \in J,\\
+ *   (1 - x_j) \cdot z_j = 0            & j \in J,\\
+ *   x_j \cdot (z_j - \lambda_j) = 0    & j \in J,\\
+ *   \mu_i \cdot (Ax - b)_i = 0         & i \in \{1, \dots, m\},\\
+ *   \mu \geq 0,
+ * \end{array}
+ * \f]
+ * where \f$J = \{1,\dots, p\}\f$, \f$\mu\f$ and \f$\lambda\f$ are the Lagrangian variables, and \f$I_J\f$ is the
+ * submatrix of the \f$n\times n\f$ identity matrix with columns indexed by \f$J\f$. For the derivation of the KKT-like
+ * conditions, see
+ *
+ *  Branch-And-Cut for Complementarity and Cardinality Constrained Linear Programs,@n
+ *  Tobias Fischer, PhD Thesis (2016)
+ *
+ * Algorithmically:
+ *
+ * - we handle the quadratic term variables of the quadratic constraint like in the method
+ *   presolveAddKKTQuadQuadraticTerms()
+ * - we handle the bilinear term variables of the quadratic constraint like in the method presolveAddKKTQuadBilinearTerms()
+ * - we handle the linear term variables of the quadratic constraint like in the method presolveAddKKTQuadLinearTerms()
+ * - we handle linear constraints in the method presolveAddKKTLinearConss()
+ * - we handle aggregated variables in the method presolveAddKKTAggregatedVars()
+ *
+ * we have a hashmap from each variable to the index of the dual constraint in the KKT conditions.
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_QPKKTREF_H__
+#define __SCIP_PRESOL_QPKKTREF_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the QP KKT reformulation presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolQPKKTref(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_redvub.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_redvub.h
+ * @ingroup PRESOLVERS
+ * @brief  remove redundant variable upper bound constraints
+ * @author Dieter Weninger
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_REDVUB_H__
+#define __SCIP_PRESOL_REDVUB_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the redvub presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolRedvub(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_sparsify.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_sparsify.h
+ * @brief  cancel non-zeros of the constraint matrix
+ * @author Dieter Weninger
+ * @author Leona Gottwald
+ * @author Ambros Gleixner
+ *
+ * This presolver attempts to cancel non-zero entries of the constraint
+ * matrix by adding scaled equalities to other constraints.
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_SPARSIFY_H__
+#define __SCIP_PRESOL_SPARSIFY_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the sparsify presolver and includes it in SCIP */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolSparsify(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_stuffing.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_stuffing.h
+ * @ingroup PRESOLVERS
+ * @brief  fix singleton continuous variables
+ * @author Dieter Weninger
+ *
+ * Investigate singleton continuous variables if one can be fixed at a bound.
+ *
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_STUFFING_H__
+#define __SCIP_PRESOL_STUFFING_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the stuffing presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolStuffing(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_trivial.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_trivial.h
+ * @ingroup PRESOLVERS
+ * @brief  trivial presolver: round fractional bounds on integer variables, fix variables with equal bounds
+ * @author Tobias Achterberg
+ *
+ * This presolver fixes variables with equal bounds to this value. Furthermore, all integral variables, for which the
+ * bounds are fractional, will get rounded new bounds.
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_TRIVIAL_H__
+#define __SCIP_PRESOL_TRIVIAL_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the trivial presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolTrivial(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_tworowbnd.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_tworowbnd.h
+ * @ingroup DEFPLUGINS_PRESOL
+ * @brief  do bound tightening by using two rows
+ * @author Dieter Weninger
+ * @author Patrick Gemander
+ *
+ * Perform bound tightening on two inequalities with some common variables.
+ * Two possible methods are being used.
+ *
+ * 1. LP-bound
+ * Let two constraints be given:
+ * \f{eqnarray*}{
+ *   A_{iR} x_R + A_{iS} x_S              \geq b_i\\
+ *   A_{kR} x_R              + A_{kT} x_T \geq b_k
+ * \f}
+ * with \f$N\f$ the set of variable indexes, \f$R \subseteq N\f$, \f$S \subseteq N\f$, \f$T \subseteq N\f$,
+ * \f$R \cap S = \emptyset\f$, \f$R \cap T = \emptyset\f$, \f$S \cap T = \emptyset\f$ and row indices \f$i \not= k\f$.
+ *
+ * Let \f$\ell\f$ and \f$u\f$ be bound vectors for x and solve the following two LPs
+ * \f{eqnarray*}{
+ *   L = \min \{ A_{kR} x_R : A_{iR} x_R + A_{iS} x_S \geq b_i, \ell \leq x \leq u \}\\
+ *   U = \max \{ A_{kR} x_R : A_{iR} x_R + A_{iS} x_S \geq b_i, \ell \leq x \leq u \}
+ * \f}
+ * and use \f$L\f$ and \f$U\f$ for getting bounds on \f$x_T\f$.
+ *
+ * If \f$L + \mbox{infimum}(A_{kT}x_T) \geq b_k\f$, then the second constraint above is redundant.
+ *
+ * 2. ConvComb with clique-extension
+ * Given two constraints
+ * \f{eqnarray*}{
+ *     A_{i\cdot} x \geq b_i \\
+ *     A_{k\cdot} x \geq b_k \\
+ *     \ell \leq x \leq u \\
+ * \f}
+ * this method determines promising values for \f$\lambda \in (0,1)\f$ and
+ * applies feasibility-based bound tightening to the convex combinations
+ *
+ * \f$(\lambda A_{i\cdot} + (1 - \lambda) A_{k\cdot}) x \geq \lambda b_i + (1 - \lambda) b_k\f$.
+ *
+ * Additionally, cliques drawn from the SCIPcliqueTable are used
+ * to further strengthen the above bound tightening. Full details can be found in
+ *    - Belotti P. "Bound reduction using pairs of linear inequalities"
+ *    - Chen W. et. al "Two-row and two-column mixed-integer presolve using hashing-based pairing methods"
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_TWOROWBND_H__
+#define __SCIP_PRESOL_TWOROWBND_H__
+
+#include "scip/def.h"
+#include "scip/type_retcode.h"
+#include "scip/type_scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the tworowbnd presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolTworowbnd(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/or-tools-src-ubuntu/include/scip/presol_xyz.h

+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                           */
+/*                  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   presol_xyz.h
+ * @ingroup PRESOLVERS
+ * @brief  xyz presolver
+ * @author Tobias Achterberg
+ */
+
+/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
+
+#ifndef __SCIP_PRESOL_XYZ_H__
+#define __SCIP_PRESOL_XYZ_H__
+
+
+#include "scip/scip.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** creates the xyz presolver and includes it in SCIP
+ *
+ * @ingroup PresolverIncludes
+ */
+SCIP_EXPORT
+SCIP_RETCODE SCIPincludePresolXyz(
+   SCIP*                 scip                /**< SCIP data structure */
+   );
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@addtogroup PRESOLVERS
+ *
+ * @{
+ */
+
+/* TODO place other public methods in this group to facilitate navigation through the documentation */
+
+/** @} */
+
+#endif