1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB) */ 7 /* */ 8 /* Licensed under the Apache License, Version 2.0 (the "License"); */ 9 /* you may not use this file except in compliance with the License. */ 10 /* You may obtain a copy of the License at */ 11 /* */ 12 /* http://www.apache.org/licenses/LICENSE-2.0 */ 13 /* */ 14 /* Unless required by applicable law or agreed to in writing, software */ 15 /* distributed under the License is distributed on an "AS IS" BASIS, */ 16 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ 17 /* See the License for the specific language governing permissions and */ 18 /* limitations under the License. */ 19 /* */ 20 /* You should have received a copy of the Apache-2.0 license */ 21 /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */ 22 /* */ 23 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 24 25 /**@file type_prob.h 26 * @ingroup TYPEDEFINITIONS 27 * @brief type definitions for storing and manipulating the main problem 28 * @author Tobias Achterberg 29 */ 30 31 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 32 33 #ifndef __SCIP_TYPE_PROB_H__ 34 #define __SCIP_TYPE_PROB_H__ 35 36 #include "scip/def.h" 37 #include "scip/type_retcode.h" 38 #include "scip/type_scip.h" 39 40 #ifdef __cplusplus 41 extern "C" { 42 #endif 43 44 /** objective sense: minimization or maximization */ 45 enum SCIP_Objsense 46 { 47 SCIP_OBJSENSE_MAXIMIZE = -1, /**< maximization of objective function */ 48 SCIP_OBJSENSE_MINIMIZE = +1 /**< minimization of objective function (the default) */ 49 }; 50 typedef enum SCIP_Objsense SCIP_OBJSENSE; 51 52 typedef struct SCIP_Prob SCIP_PROB; /**< main problem to solve */ 53 typedef struct SCIP_ProbData SCIP_PROBDATA; /**< user problem data set by the reader */ 54 55 56 /** frees user data of original problem (called when the original problem is freed) 57 * 58 * This method should free the user data of the original problem. 59 * 60 * input: 61 * - scip : SCIP main data structure 62 * - probdata : pointer to the user problem data to free 63 */ 64 #define SCIP_DECL_PROBDELORIG(x) SCIP_RETCODE x (SCIP* scip, SCIP_PROBDATA** probdata) 65 66 /** creates user data of transformed problem by transforming the original user problem data 67 * (called after problem was transformed) 68 * 69 * Because the original problem and the user data of the original problem should not be 70 * modified during the solving process, a transformed problem is created as a copy of 71 * the original problem. If the user problem data is never modified during the solving 72 * process anyways, it is enough to simple copy the user data's pointer. This is the 73 * default implementation, which is used when a NULL is given as PROBTRANS method. 74 * If the user data may be modified during the solving process (e.g. during preprocessing), 75 * the PROBTRANS method must be given and has to copy the user problem data to a different 76 * memory location. 77 * 78 * input: 79 * - scip : SCIP main data structure 80 * - sourcedata : source problem data to transform 81 * - targetdata : pointer to store created transformed problem data 82 */ 83 #define SCIP_DECL_PROBTRANS(x) SCIP_RETCODE x (SCIP* scip, SCIP_PROBDATA* sourcedata, SCIP_PROBDATA** targetdata) 84 85 /** frees user data of transformed problem (called when the transformed problem is freed) 86 * 87 * This method has to be implemented, if the PROBTRANS method is not a simple pointer 88 * copy operation like in the default PROBTRANS implementation. It should free the 89 * user data of the transformed problem, that was created in the PROBTRANS method. 90 * 91 * input: 92 * - scip : SCIP main data structure 93 * - probdata : pointer to the user problem data to free 94 */ 95 #define SCIP_DECL_PROBDELTRANS(x) SCIP_RETCODE x (SCIP* scip, SCIP_PROBDATA** probdata) 96 97 /** solving process initialization method of transformed data (called before the branch and bound process begins) 98 * 99 * This method is called before the branch and bound process begins and can be used to initialize user problem 100 * data that depends for example on the number of active problem variables, because these are now fixed. 101 * 102 * input: 103 * - scip : SCIP main data structure 104 * - probdata : user problem data 105 */ 106 #define SCIP_DECL_PROBINITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_PROBDATA* probdata) 107 108 /** solving process deinitialization method of transformed data (called before the branch and bound data is freed) 109 * 110 * This method is called before the branch and bound data is freed and should be used to free all data that 111 * was allocated in the solving process initialization method. The user has to make sure, that all LP rows associated 112 * to the transformed user problem data are released. 113 * 114 * input: 115 * - scip : SCIP main data structure 116 * - probdata : user problem data 117 * - restart : was this exit solve call triggered by a restart? 118 */ 119 #define SCIP_DECL_PROBEXITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_PROBDATA* probdata, SCIP_Bool restart) 120 121 /** copies user data of source SCIP for the target SCIP 122 * 123 * This method should copy the problem data of the source SCIP and create a target problem data for (target) 124 * SCIP. Implementing this callback is optional. If the copying process was successful the target SCIP gets this 125 * problem data assigned. In case the result pointer is set to SCIP_DIDNOTRUN the target SCIP will have no problem data 126 * at all. 127 * 128 * The variable map and the constraint map can be used via the function SCIPgetVarCopy() and SCIPgetConsCopy(), 129 * respectively, to get for certain variables and constraints of the source SCIP the counter parts in the target 130 * SCIP. You should be very carefully in using these two methods since they could lead to an infinite loop due to 131 * recursion. 132 * 133 * input: 134 * - scip : target SCIP data structure 135 * - sourcescip : source SCIP main data structure 136 * - sourcedata : source user problem data 137 * - varmap, : a hashmap which stores the mapping of source variables to corresponding target variables 138 * - consmap, : a hashmap which stores the mapping of source constraints to corresponding target constraints 139 * - targetdata : pointer to the target user problem data to create 140 * - original : copy original or transformed problem? 141 * - global : create a global or a local copy? 142 * 143 * output: 144 * - result : pointer to store the result of the call 145 * 146 * possible return values for *result: 147 * - SCIP_DIDNOTRUN : the copying process was not performed 148 * - SCIP_SUCCESS : the copying process was successfully performed 149 */ 150 #define SCIP_DECL_PROBCOPY(x) SCIP_RETCODE x (SCIP* scip, SCIP* sourcescip, SCIP_PROBDATA* sourcedata, \ 151 SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_PROBDATA** targetdata, SCIP_Bool original, \ 152 SCIP_Bool global, SCIP_RESULT* result) 153 154 #ifdef __cplusplus 155 } 156 #endif 157 158 #endif 159