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 def.h 26 * @ingroup INTERNALAPI 27 * @brief common defines and data types used in all packages of SCIP 28 * @author Tobias Achterberg 29 */ 30 31 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 32 33 #ifndef __SCIP_DEF_H__ 34 #define __SCIP_DEF_H__ 35 36 #ifdef __cplusplus 37 #define __STDC_LIMIT_MACROS 38 #define __STDC_CONSTANT_MACROS 39 #endif 40 41 #include <stdio.h> 42 #include <stdint.h> 43 #include <math.h> 44 #include <limits.h> 45 #include <float.h> 46 #include <assert.h> 47 48 /* 49 * include build configuration flags 50 */ 51 #include "scip/config.h" 52 #include "scip/scip_export.h" 53 54 /* 55 * GNU COMPILER VERSION define 56 */ 57 #ifdef __GNUC__ 58 #ifndef GCC_VERSION 59 #define GCC_VERSION (__GNUC__ * 100 \ 60 + __GNUC_MINOR__ * 10 \ 61 + __GNUC_PATCHLEVEL__) 62 #endif 63 #endif 64 65 /* 66 * define whether compiler allows variadic macros 67 * __STDC_VERSION__ only exists for C code 68 * added the extra check using the GCC_VERSION to enable variadic macros also with C++ code with GCC atleast 69 * 70 */ 71 #if defined(_MSC_VER) || ( __STDC_VERSION__ >= 199901L ) || ( GCC_VERSION >= 480 ) 72 #define SCIP_HAVE_VARIADIC_MACROS 1 73 #endif 74 75 /** get the first parameter and all-but-the-first arguments from variadic arguments 76 * 77 * normally, SCIP_VARARGS_FIRST_ should be sufficient 78 * the SCIP_VARARGS_FIRST_/SCIP_VARARGS_FIRST kludge is to work around a bug in MSVC (https://stackoverflow.com/questions/4750688/how-to-single-out-the-first-parameter-sent-to-a-macro-taking-only-a-variadic-par) 79 */ 80 #define SCIP_VARARGS_FIRST_(firstarg, ...) firstarg 81 #define SCIP_VARARGS_FIRST(args) SCIP_VARARGS_FIRST_ args 82 83 /** get all but the first parameter from variadic arguments */ 84 #define SCIP_VARARGS_REST(firstarg, ...) __VA_ARGS__ 85 86 /* 87 * Boolean values 88 */ 89 90 #ifndef SCIP_Bool 91 #define SCIP_Bool unsigned int /**< type used for Boolean values */ 92 #ifndef TRUE 93 #define TRUE 1 /**< Boolean value TRUE */ 94 #define FALSE 0 /**< Boolean value FALSE */ 95 #endif 96 #endif 97 98 #ifndef SCIP_Shortbool 99 #define SCIP_Shortbool uint8_t /**< type used for Boolean values with less space */ 100 #endif 101 102 /* 103 * Add some macros for differing functions on Windows 104 */ 105 #if defined(_WIN32) || defined(_WIN64) 106 107 #define strcasecmp _stricmp 108 #define strncasecmp _strnicmp 109 #define getcwd _getcwd 110 #endif 111 112 /* 113 * Define the macro SCIP_EXPORT if it is not included from the generated header 114 */ 115 #ifndef SCIP_EXPORT 116 #if defined(_WIN32) 117 #define SCIP_EXPORT __declspec(dllexport) 118 #elif defined(__GNUC__) && __GNUC__ >= 4 119 #define SCIP_EXPORT __attribute__((__visibility__("default"))) 120 #else 121 #define SCIP_EXPORT 122 #endif 123 #endif 124 125 /* define INLINE */ 126 #ifndef INLINE 127 #if defined(_WIN32) || defined(__STDC__) 128 #define INLINE __inline 129 #else 130 #define INLINE inline 131 #endif 132 #endif 133 134 135 136 #include "scip/type_retcode.h" 137 #include "scip/type_message.h" 138 #include "scip/pub_message.h" 139 140 #ifdef __cplusplus 141 extern "C" { 142 #endif 143 144 145 #define SCIP_VERSION (100*SCIP_VERSION_MAJOR + 10*SCIP_VERSION_MINOR + SCIP_VERSION_PATCH) /**< SCIP version number (multiplied by 100 to get integer number) */ 146 #define SCIP_SUBVERSION SCIP_VERSION_SUB /**< SCIP sub version number */ 147 #define SCIP_APIVERSION SCIP_VERSION_API /**< SCIP API version number */ 148 #define SCIP_COPYRIGHT "Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB)" 149 150 151 /* 152 * CIP format variable characters 153 */ 154 155 #define SCIP_VARTYPE_BINARY_CHAR 'B' 156 #define SCIP_VARTYPE_INTEGER_CHAR 'I' 157 #define SCIP_VARTYPE_IMPLINT_CHAR 'M' 158 #define SCIP_VARTYPE_CONTINUOUS_CHAR 'C' 159 160 /* 161 * Long Integer values 162 */ 163 164 #ifndef LLONG_MAX 165 #define LLONG_MAX 9223372036854775807LL 166 #define LLONG_MIN (-LLONG_MAX - 1LL) 167 #endif 168 169 #define SCIP_Longint long long /**< type used for long integer values */ 170 #define SCIP_LONGINT_MAX LLONG_MAX 171 #define SCIP_LONGINT_MIN LLONG_MIN 172 #ifndef SCIP_LONGINT_FORMAT 173 #if defined(_WIN32) || defined(_WIN64) 174 #define SCIP_LONGINT_FORMAT "I64d" 175 #else 176 #define SCIP_LONGINT_FORMAT "lld" 177 #endif 178 #endif 179 180 /* 181 * Floating point values 182 */ 183 184 #define SCIP_Real double /**< type used for floating point values */ 185 #define SCIP_REAL_MAX (SCIP_Real)DBL_MAX 186 #define SCIP_REAL_MIN -(SCIP_Real)DBL_MAX 187 #define SCIP_REAL_FORMAT "lf" 188 189 #define SCIP_DEFAULT_INFINITY 1e+20 /**< default value considered to be infinity */ 190 #define SCIP_DEFAULT_EPSILON 1e-09 /**< default upper bound for floating points to be considered zero */ 191 #define SCIP_DEFAULT_SUMEPSILON 1e-06 /**< default upper bound for sums of floating points to be considered zero */ 192 #define SCIP_DEFAULT_FEASTOL 1e-06 /**< default feasibility tolerance for constraints */ 193 #define SCIP_DEFAULT_CHECKFEASTOLFAC 1.0 /**< default factor to change the feasibility tolerance when testing the best solution for feasibility (after solving process) */ 194 #define SCIP_DEFAULT_LPFEASTOLFACTOR 1.0 /**< default factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver */ 195 #define SCIP_DEFAULT_DUALFEASTOL 1e-07 /**< default feasibility tolerance for reduced costs */ 196 #define SCIP_DEFAULT_BARRIERCONVTOL 1e-10 /**< default convergence tolerance used in barrier algorithm */ 197 #define SCIP_DEFAULT_BOUNDSTREPS 0.05 /**< default minimal relative improve for strengthening bounds */ 198 #define SCIP_DEFAULT_PSEUDOCOSTEPS 1e-01 /**< default minimal variable distance value to use for pseudo cost updates */ 199 #define SCIP_DEFAULT_PSEUDOCOSTDELTA 1e-04 /**< default minimal objective distance value to use for pseudo cost updates */ 200 #define SCIP_DEFAULT_RECOMPFAC 1e+07 /**< default minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update */ 201 #define SCIP_DEFAULT_HUGEVAL 1e+15 /**< values larger than this are considered huge and should be handled separately (e.g., in activity computation) */ 202 #define SCIP_MAXEPSILON 1e-03 /**< maximum value for any numerical epsilon */ 203 #define SCIP_MINEPSILON 1e-20 /**< minimum value for any numerical epsilon */ 204 #define SCIP_INVALID (double)1e+99 /**< floating point value is not valid */ 205 #define SCIP_UNKNOWN (double)1e+98 /**< floating point value is not known (in primal solution) */ 206 #define SCIP_INTERVAL_INFINITY (double)1e+300 /**< infinity value for interval computations */ 207 208 #define REALABS(x) (fabs(x)) 209 #define EPSEQ(x,y,eps) (REALABS((x)-(y)) <= (eps)) 210 #define EPSLT(x,y,eps) ((x)-(y) < -(eps)) 211 #define EPSLE(x,y,eps) ((x)-(y) <= (eps)) 212 #define EPSGT(x,y,eps) ((x)-(y) > (eps)) 213 #define EPSGE(x,y,eps) ((x)-(y) >= -(eps)) 214 #define EPSZ(x,eps) (REALABS(x) <= (eps)) 215 #define EPSP(x,eps) ((x) > (eps)) 216 #define EPSN(x,eps) ((x) < -(eps)) 217 #define EPSFLOOR(x,eps) (floor((x)+(eps))) 218 #define EPSCEIL(x,eps) (ceil((x)-(eps))) 219 #define EPSROUND(x,eps) (ceil((x)-0.5+(eps))) 220 #define EPSFRAC(x,eps) ((x)-EPSFLOOR(x,eps)) 221 #define EPSISINT(x,eps) (EPSFRAC(x,eps) <= (eps)) 222 223 224 #ifndef SQR 225 #define SQR(x) ((x)*(x)) 226 #define SQRT(x) (sqrt(x)) 227 #endif 228 229 /* platform-dependent specification of the log1p, which is numerically more stable around x = 0.0 */ 230 #ifndef LOG1P 231 #if defined(_WIN32) || defined(_WIN64) 232 #define LOG1P(x) (log(1.0+x)) 233 #else 234 #define LOG1P(x) (log1p(x)) 235 #endif 236 #endif 237 238 #ifndef LOG2 239 #if defined(_MSC_VER) && (_MSC_VER < 1800) 240 #define LOG2(x) (log(x) / log(2.0)) 241 #else 242 #define LOG2(x) log2(x) 243 #endif 244 #endif 245 246 #ifndef ABS 247 #define ABS(x) ((x) >= 0 ? (x) : -(x)) 248 #endif 249 250 #ifndef MAX 251 #define MAX(x, y) ((x) >= (y) ? (x) : (y)) /**< returns maximum of x and y */ 252 #endif 253 254 #ifndef MIN 255 #define MIN(x, y) ((x) <= (y) ? (x) : (y)) /**< returns minimum of x and y */ 256 #endif 257 258 #ifndef MAX3 259 #define MAX3(x, y, z) ((x) >= (y) ? MAX(x, z) : MAX(y, z)) /**< returns maximum of x, y, and z */ 260 #endif 261 262 #ifndef MIN3 263 #define MIN3(x, y, z) ((x) <= (y) ? MIN(x, z) : MIN(y, z)) /**< returns minimum of x, y, and z */ 264 #endif 265 266 #ifndef COPYSIGN 267 #if defined(_MSC_VER) && (_MSC_VER < 1800) 268 #define COPYSIGN _copysign 269 #else 270 #define COPYSIGN copysign 271 #endif 272 #endif 273 274 /* 275 * Pointers 276 */ 277 278 #ifndef NULL 279 #define NULL ((void*)0) /**< zero pointer */ 280 #endif 281 282 #ifndef RESTRICT 283 #if defined(_MSC_VER) 284 #define RESTRICT __restrict 285 #else 286 #ifdef __cplusplus 287 #define RESTRICT __restrict__ 288 #elif __STDC_VERSION__ >= 199901L 289 #define RESTRICT restrict 290 #else 291 #define RESTRICT 292 #endif 293 #endif 294 #endif 295 296 /* 297 * Strings 298 */ 299 300 #define SCIP_MAXSTRLEN 1024 /**< maximum string length in SCIP */ 301 #define SCIP_SPACECONTROL " tnvfr" /**< control specifier for escaped spaces */ 302 303 /* 304 * Memory settings 305 */ 306 307 /* we use SIZE_MAX / 2 to detect negative sizes which got a very large value when casting to size_t */ 308 #define SCIP_MAXMEMSIZE (SIZE_MAX/2) /**< maximum size of allocated memory (array) */ 309 310 #define SCIP_HASHSIZE_PARAMS 2048 /**< size of hash table in parameter name tables */ 311 #define SCIP_HASHSIZE_NAMES 500 /**< size of hash table in name tables */ 312 #define SCIP_HASHSIZE_CUTPOOLS 500 /**< size of hash table in cut pools */ 313 #define SCIP_HASHSIZE_CLIQUES 500 /**< size of hash table in clique tables */ 314 #define SCIP_HASHSIZE_NAMES_SMALL 100 /**< size of hash table in name tables for small problems */ 315 #define SCIP_HASHSIZE_CUTPOOLS_SMALL 100 /**< size of hash table in cut pools for small problems */ 316 #define SCIP_HASHSIZE_CLIQUES_SMALL 100 /**< size of hash table in clique tables for small problems */ 317 #define SCIP_HASHSIZE_VBC 500 /**< size of hash map for node -> nodenum mapping used for VBC output */ 318 319 #define SCIP_DEFAULT_MEM_ARRAYGROWFAC 1.2 /**< memory growing factor for dynamically allocated arrays */ 320 #define SCIP_DEFAULT_MEM_ARRAYGROWINIT 4 /**< initial size of dynamically allocated arrays */ 321 322 #define SCIP_MEM_NOLIMIT (SCIP_Longint)(SCIP_LONGINT_MAX >> 20)/**< initial size of dynamically allocated arrays */ 323 324 /* 325 * Tree settings 326 */ 327 328 #define SCIP_MAXTREEDEPTH 1073741822 /**< maximal allowed depth of the branch-and-bound tree */ 329 330 /* 331 * Probing scoring settings 332 */ 333 334 #define SCIP_PROBINGSCORE_PENALTYRATIO 2 /**< ratio for penalizing too small fractionalities in diving heuristics. 335 * if the fractional part of a variable is smaller than a given threshold 336 * the corresponding score gets penalized. due to numerical troubles 337 * we will flip a coin whenever SCIPisEQ(scip, fractionality, threshold) 338 * evaluates to true. this parameter defines the chance that this results 339 * in penalizing the score, i.e., there is 1:2 chance for penalizing. 340 */ 341 342 /* 343 * Global debugging settings 344 */ 345 346 /*#define DEBUG*/ 347 348 349 /* 350 * Defines for handling SCIP return codes 351 */ 352 353 /** this macro is used to stop SCIP in debug mode such that errors can be debugged; 354 * 355 * @note In optimized mode this macro has no effect. That means, in case of an error it has to be ensured that code 356 * terminates with an error code or continues safely. 357 */ 358 #define SCIPABORT() assert(FALSE) /*lint --e{527} */ 359 360 #define SCIP_CALL_ABORT_QUIET(x) do { if( (x) != SCIP_OKAY ) SCIPABORT(); } while( FALSE ) 361 #define SCIP_CALL_QUIET(x) do { SCIP_RETCODE _restat_; if( (_restat_ = (x)) != SCIP_OKAY ) return _restat_; } while( FALSE ) 362 #define SCIP_ALLOC_ABORT_QUIET(x) do { if( NULL == (x) ) SCIPABORT(); } while( FALSE ) 363 #define SCIP_ALLOC_QUIET(x) do { if( NULL == (x) ) return SCIP_NOMEMORY; } while( FALSE ) 364 365 #define SCIP_CALL_ABORT(x) do \ 366 { \ 367 SCIP_RETCODE _restat_; /*lint -e{506,774}*/ \ 368 if( (_restat_ = (x)) != SCIP_OKAY ) \ 369 { \ 370 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \ 371 SCIPABORT(); \ 372 } \ 373 } \ 374 while( FALSE ) 375 376 #define SCIP_ALLOC_ABORT(x) do \ 377 { \ 378 if( NULL == (x) ) \ 379 { \ 380 SCIPerrorMessage("No memory in function call\n"); \ 381 SCIPABORT(); \ 382 } \ 383 } \ 384 while( FALSE ) 385 386 #define SCIP_CALL(x) do \ 387 { \ 388 SCIP_RETCODE _restat_; /*lint -e{506,774}*/ \ 389 if( (_restat_ = (x)) != SCIP_OKAY ) \ 390 { \ 391 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \ 392 return _restat_; \ 393 } \ 394 } \ 395 while( FALSE ) 396 397 #define SCIP_ALLOC(x) do \ 398 { \ 399 if( NULL == (x) ) \ 400 { \ 401 SCIPerrorMessage("No memory in function call\n"); \ 402 return SCIP_NOMEMORY; \ 403 } \ 404 } \ 405 while( FALSE ) 406 407 #define SCIP_CALL_TERMINATE(retcode, x, TERM) do \ 408 { \ 409 if( ((retcode) = (x)) != SCIP_OKAY ) \ 410 { \ 411 SCIPerrorMessage("Error <%d> in function call\n", retcode); \ 412 goto TERM; \ 413 } \ 414 } \ 415 while( FALSE ) 416 417 #define SCIP_ALLOC_TERMINATE(retcode, x, TERM) do \ 418 { \ 419 if( NULL == (x) ) \ 420 { \ 421 SCIPerrorMessage("No memory in function call\n"); \ 422 retcode = SCIP_NOMEMORY; \ 423 goto TERM; \ 424 } \ 425 } \ 426 while( FALSE ) 427 428 #define SCIP_CALL_FINALLY(x, y) do \ 429 { \ 430 SCIP_RETCODE _restat_; \ 431 if( (_restat_ = (x)) != SCIP_OKAY ) \ 432 { \ 433 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \ 434 (y); \ 435 return _restat_; \ 436 } \ 437 } \ 438 while( FALSE ) 439 440 #define SCIP_UNUSED(x) ((void) (x)) 441 442 /* 443 * Define to mark deprecated API functions 444 */ 445 446 #ifndef SCIP_DEPRECATED 447 #if defined(_MSC_VER) 448 # define SCIP_DEPRECATED __declspec(deprecated) 449 #elif defined(__GNUC__) 450 # define SCIP_DEPRECATED __attribute__ ((deprecated)) 451 #else 452 # define SCIP_DEPRECATED 453 #endif 454 #endif 455 456 #ifdef __cplusplus 457 } 458 #endif 459 460 #endif 461