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"
(1) Event include_recursion: #include file "/sapmnt/home1/d029903/my_work/SCIPSoPlex_coverity/scip-soplex-9.0.0_rc1/scip/src/scip/pub_message.h" includes itself: pub_message.h -> def.h -> pub_message.h
(2) Event caretline: ^
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