SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
scip_general.c
Go to the documentation of this file.
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 scip_general.c
26 * @ingroup OTHER_CFILES
27 * @brief general public methods
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 * @author Gerald Gamrath
31 * @author Leona Gottwald
32 * @author Stefan Heinz
33 * @author Gregor Hendel
34 * @author Thorsten Koch
35 * @author Alexander Martin
36 * @author Marc Pfetsch
37 * @author Michael Winkler
38 * @author Kati Wolter
39 *
40 * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
41 */
42
43/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
44
46#include "lpi/lpi.h"
47#include "scip/exprinterpret.h"
48#include "scip/clock.h"
49#include "scip/debug.h"
50#include "scip/dialog.h"
51#include "scip/interrupt.h"
52#include "scip/mem.h"
54#include "scip/nlp.h"
55#include "scip/pub_message.h"
56#include "scip/retcode.h"
57#include "scip/scipbuildflags.h"
59#include "scip/scip_general.h"
60#include "scip/scipgithash.h"
61#include "scip/scip_mem.h"
62#include "scip/scip_message.h"
63#include "scip/scip_numerics.h"
64#include "scip/scip_prob.h"
66#include "scip/set.h"
67#include "scip/solve.h"
68#include "scip/struct_mem.h"
69#include "scip/struct_primal.h"
70#include "scip/struct_prob.h"
71#include "scip/struct_scip.h"
72#include "scip/struct_set.h"
73#include "scip/struct_stat.h"
74#include "scip/syncstore.h"
75
76#include <string.h>
77#if defined(_WIN32) || defined(_WIN64)
78#else
79#include <strings.h> /*lint --e{766}*/
80#endif
81
82#ifdef SCIP_WITH_ZLIB
83#include <zlib.h>
84#endif
85
86/* In debug mode, the following methods are implemented as function calls to ensure
87 * type validity.
88 * In optimized mode, the methods are implemented as defines to improve performance.
89 * However, we want to have them in the library anyways, so we have to undef the defines.
90 */
91
92#undef SCIPgetStage
93#undef SCIPhasPerformedPresolve
94#undef SCIPisStopped
95
96/** returns complete SCIP version number in the format "major . minor tech"
97 *
98 * @return complete SCIP version
99 */
100SCIP_Real SCIPversion(
101 void
102 )
103{
104 return (SCIP_Real)(SCIP_VERSION)/100.0;
105}
106
107/** returns SCIP major version
108 *
109 * @return major SCIP version
110 */
112 void
113 )
114{
115 return SCIP_VERSION/100;
116}
117
118/** returns SCIP minor version
119 *
120 * @return minor SCIP version
121 */
123 void
124 )
125{
126 return (SCIP_VERSION/10) % 10; /*lint !e778*/
127}
128
129/** returns SCIP technical version
130 *
131 * @return technical SCIP version
132 */
134 void
135 )
136{
137 return SCIP_VERSION % 10; /*lint !e778*/
138}
139
140/** returns SCIP sub version number
141 *
142 * @return subversion SCIP version
143 */
145 void
146 )
147{
148 return SCIP_SUBVERSION;
149}
150
151/** prints a version information line to a file stream via the message handler system
152 *
153 * @note If the message handler is set to a NULL pointer nothing will be printed
154 */
156 SCIP* scip, /**< SCIP data structure */
157 FILE* file /**< output file (or NULL for standard output) */
158 )
159{
160 assert( scip != NULL );
161
162 SCIPmessageFPrintInfo(scip->messagehdlr, file, "SCIP version %d.%d.%d",
164#if SCIP_SUBVERSION > 0
165 SCIPmessageFPrintInfo(scip->messagehdlr, file, ".%d", SCIPsubversion());
166#endif
167
168 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [precision: %d byte]", (int)sizeof(SCIP_Real));
169
170#ifndef BMS_NOBLOCKMEM
171 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [memory: block]");
172#else
173 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [memory: standard]");
174#endif
175#ifndef NDEBUG
176 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [mode: debug]");
177#else
178 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [mode: optimized]");
179#endif
180 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [LP solver: %s]", SCIPlpiGetSolverName());
181 SCIPmessageFPrintInfo(scip->messagehdlr, file, " [GitHash: %s]", SCIPgetGitHash());
182 SCIPmessageFPrintInfo(scip->messagehdlr, file, "\n");
183 SCIPmessageFPrintInfo(scip->messagehdlr, file, "%s\n", SCIP_COPYRIGHT);
184}
185
186/** prints detailed information on the compile-time flags
187 *
188 * @note If the message handler is set to a NULL pointer nothing will be printed
189 */
191 SCIP* scip, /**< SCIP data structure */
192 FILE* file /**< output file (or NULL for standard output) */
193 )
194{
195 assert( scip != NULL );
196
197 /* compiler */
198 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Compiler: ");
199#if defined(__INTEL_COMPILER)
200 SCIPmessageFPrintInfo(scip->messagehdlr, file, "Intel %d\n", __INTEL_COMPILER);
201#elif defined(__clang__)
202 SCIPmessageFPrintInfo(scip->messagehdlr, file, "clang %d.%d.%d\n", __clang_major__, __clang_minor__, __clang_patchlevel__);
203#elif defined(_MSC_VER)
204 SCIPmessageFPrintInfo(scip->messagehdlr, file, "microsoft visual c %d\n", _MSC_FULL_VER);
205#elif defined(__GNUC__)
206#if defined(__GNUC_PATCHLEVEL__)
207 SCIPmessageFPrintInfo(scip->messagehdlr, file, "gcc %d.%d.%d\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
208#else
209 SCIPmessageFPrintInfo(scip->messagehdlr, file, "gcc %d.%d\n", __GNUC__, __GNUC_MINOR__);
210#endif
211#else
212 SCIPmessageFPrintInfo(scip->messagehdlr, file, "unknown\n");
213#endif
214
215 /* build flags */
216 SCIPmessageFPrintInfo(scip->messagehdlr, file, "\nBuild options:\n%s", SCIPgetBuildFlags());
217}
218
219/** prints error message for the given SCIP_RETCODE via the error prints method */
221 SCIP_RETCODE retcode /**< SCIP return code causing the error */
222 )
223{
224 SCIPmessagePrintError("SCIP Error (%d): ", retcode);
225 SCIPretcodePrintError(retcode);
227}
228
229/*
230 * general SCIP methods
231 */
232
233/** internal method to create SCIP */
234static
236 SCIP** scip /**< pointer to SCIP data structure */
237 )
238{
239 assert(scip != NULL);
240
242
243 /* all members are initialized to NULL */
245
246 /* create a default message handler */
247 SCIP_CALL( SCIPcreateMessagehdlrDefault(&(*scip)->messagehdlr, TRUE, NULL, FALSE) );
248
249 SCIP_CALL( SCIPmemCreate(&(*scip)->mem) );
250 SCIP_CALL( SCIPsetCreate(&(*scip)->set, (*scip)->messagehdlr, (*scip)->mem->setmem, *scip) );
251 SCIP_CALL( SCIPinterruptCreate(&(*scip)->interrupt) );
252 SCIP_CALL( SCIPdialoghdlrCreate((*scip)->set, &(*scip)->dialoghdlr) );
253 SCIP_CALL( SCIPclockCreate(&(*scip)->totaltime, SCIP_CLOCKTYPE_DEFAULT) );
254 SCIP_CALL( SCIPsyncstoreCreate( &(*scip)->syncstore ) );
255
256 /* include additional core functionality */
258
259 SCIPclockStart((*scip)->totaltime, (*scip)->set);
260
261 SCIP_CALL( SCIPnlpInclude((*scip)->set, SCIPblkmem(*scip)) );
262
263 if( strcmp(SCIPlpiGetSolverName(), "NONE") != 0 )
264 {
266 }
267 if( strcmp(SCIPexprintGetName(), "NONE") != 0 )
268 {
270 }
271
272#ifdef SCIP_WITH_ZLIB
273 SCIP_CALL( SCIPsetIncludeExternalCode((*scip)->set, "ZLIB " ZLIB_VERSION, "General purpose compression library by J. Gailly and M. Adler (zlib.net)") );
274#endif
275
276 return SCIP_OKAY;
277}
278
279/** creates and initializes SCIP data structures
280 *
281 * @note The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own
282 * message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log
283 * file and turn off/on the display output, respectively.
284 *
285 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
286 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
287 *
288 * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_INIT
289 *
290 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
291 */
293 SCIP** scip /**< pointer to SCIP data structure */
294 )
295{
296 assert(scip != NULL);
297
299
300 return SCIP_OKAY;
301}
302
303/** frees SCIP data structures
304 *
305 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
306 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
307 *
308 * @pre This method can be called if @p scip is in one of the following stages:
309 * - \ref SCIP_STAGE_INIT
310 * - \ref SCIP_STAGE_PROBLEM
311 * - \ref SCIP_STAGE_TRANSFORMED
312 * - \ref SCIP_STAGE_INITPRESOLVE
313 * - \ref SCIP_STAGE_PRESOLVING
314 * - \ref SCIP_STAGE_PRESOLVED
315 * - \ref SCIP_STAGE_EXITPRESOLVE
316 * - \ref SCIP_STAGE_SOLVING
317 * - \ref SCIP_STAGE_SOLVED
318 * - \ref SCIP_STAGE_FREE
319 *
320 * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_FREE
321 *
322 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
323 */
325 SCIP** scip /**< pointer to SCIP data structure */
326 )
327{
328 assert(scip != NULL);
329 if( *scip == NULL )
330 return SCIP_OKAY;
331
333
335 assert((*scip)->set->stage == SCIP_STAGE_INIT);
336
337 /* switch stage to FREE */
338 (*scip)->set->stage = SCIP_STAGE_FREE;
339
340 SCIP_CALL( SCIPsyncstoreRelease(&(*scip)->syncstore) );
341 SCIP_CALL( SCIPsetFree(&(*scip)->set, (*scip)->mem->setmem) );
342 SCIP_CALL( SCIPdialoghdlrFree(*scip, &(*scip)->dialoghdlr) );
343 SCIPclockFree(&(*scip)->totaltime);
344 SCIPinterruptFree(&(*scip)->interrupt);
345 SCIP_CALL( SCIPmemFree(&(*scip)->mem) );
346
347 /* release message handler */
348 SCIP_CALL( SCIPmessagehdlrRelease(&(*scip)->messagehdlr) );
349
351
352 return SCIP_OKAY;
353}
354
355#undef SCIPgetStage
356#undef SCIPhasPerformedPresolve
357#undef SCIPisStopped
358
359/** returns current stage of SCIP
360 *
361 * @return the current SCIP stage
362 *
363 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
364 */
366 SCIP* scip /**< SCIP data structure */
367 )
368{
369 assert(scip != NULL);
370 assert(scip->set != NULL);
371
372 return scip->set->stage;
373}
374
375/** outputs SCIP stage and solution status if applicable via the message handler
376 *
377 * @note If the message handler is set to a NULL pointer nothing will be printed
378 *
379 * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
380 * thus may to correspond to the original status.
381 *
382 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
383 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
384 *
385 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
386 */
388 SCIP* scip, /**< SCIP data structure */
389 FILE* file /**< output file (or NULL for standard output) */
390 )
391{
392 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintStage", TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE) );
393
394 switch( scip->set->stage )
395 {
396 case SCIP_STAGE_INIT:
397 SCIPmessageFPrintInfo(scip->messagehdlr, file, "initialization");
398 break;
400 SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem creation / modification");
401 break;
403 SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem transformation");
404 break;
406 SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem transformed");
407 break;
409 SCIPmessageFPrintInfo(scip->messagehdlr, file, "presolving is being initialized");
410 break;
412 if( SCIPsolveIsStopped(scip->set, scip->stat, TRUE) )
413 {
414 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solving was interrupted [");
416 SCIPmessageFPrintInfo(scip->messagehdlr, file, "]");
417 }
418 else
419 SCIPmessageFPrintInfo(scip->messagehdlr, file, "presolving process is running");
420 break;
422 SCIPmessageFPrintInfo(scip->messagehdlr, file, "presolving is being exited");
423 break;
425 if( SCIPsolveIsStopped(scip->set, scip->stat, TRUE) )
426 {
427 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solving was interrupted [");
429 SCIPmessageFPrintInfo(scip->messagehdlr, file, "]");
430 }
431 else
432 SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem is presolved");
433 break;
435 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solving process initialization");
436 break;
438 if( SCIPsolveIsStopped(scip->set, scip->stat, TRUE) )
439 {
440 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solving was interrupted [");
442 SCIPmessageFPrintInfo(scip->messagehdlr, file, "]");
443 }
444 else
445 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solving process is running");
446 break;
448 SCIPmessageFPrintInfo(scip->messagehdlr, file, "problem is solved [");
450 SCIPmessageFPrintInfo(scip->messagehdlr, file, "]");
451
452 /* We output that the objective limit has been reached if no solution respecting the objective limit has been
453 * found (nlimsolsfound == 0) and the primal bound is finite. Note that it still might be that the original
454 * problem is infeasible, even without the objective limit, i.e., we cannot be sure that we actually reached the
455 * objective limit. */
456 if( scip->primal->nlimsolsfound == 0 && !SCIPisInfinity(scip, (SCIP_Real)SCIPgetObjsense(scip) * SCIPgetPrimalbound(scip)) )
457 SCIPmessageFPrintInfo(scip->messagehdlr, file, " (objective limit reached)");
458
459 break;
461 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solving process deinitialization");
462 break;
464 SCIPmessageFPrintInfo(scip->messagehdlr, file, "freeing transformed problem");
465 break;
466 case SCIP_STAGE_FREE:
467 SCIPmessageFPrintInfo(scip->messagehdlr, file, "freeing SCIP");
468 break;
469 default:
470 SCIPerrorMessage("invalid SCIP stage <%d>\n", scip->set->stage);
471 return SCIP_INVALIDDATA;
472 }
473
474 return SCIP_OKAY;
475}
476
477/** gets solution status
478 *
479 * @return SCIP solution status
480 *
481 * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
482 */
484 SCIP* scip /**< SCIP data structure */
485 )
486{
488
489 if( scip->set->stage == SCIP_STAGE_INIT || scip->set->stage == SCIP_STAGE_FREE )
490 return SCIP_STATUS_UNKNOWN;
491 else
492 {
493 assert(scip->stat != NULL);
494
495 return scip->stat->status;
496 }
497}
498
499/** outputs solution status
500 *
501 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
502 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
503 *
504 * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
505 */
507 SCIP* scip, /**< SCIP data structure */
508 FILE* file /**< output file (or NULL for standard output) */
509 )
510{
511 SCIP_CALL( SCIPcheckStage(scip, "SCIPprintStatus", TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE) );
512
513 switch( SCIPgetStatus(scip) )
514 {
516 SCIPmessageFPrintInfo(scip->messagehdlr, file, "unknown");
517 break;
519 SCIPmessageFPrintInfo(scip->messagehdlr, file, "user interrupt");
520 break;
522 SCIPmessageFPrintInfo(scip->messagehdlr, file, "node limit reached");
523 break;
525 SCIPmessageFPrintInfo(scip->messagehdlr, file, "total node limit reached");
526 break;
528 SCIPmessageFPrintInfo(scip->messagehdlr, file, "stall node limit reached");
529 break;
531 SCIPmessageFPrintInfo(scip->messagehdlr, file, "time limit reached");
532 break;
534 SCIPmessageFPrintInfo(scip->messagehdlr, file, "memory limit reached");
535 break;
537 SCIPmessageFPrintInfo(scip->messagehdlr, file, "gap limit reached");
538 break;
540 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solution limit reached");
541 break;
543 SCIPmessageFPrintInfo(scip->messagehdlr, file, "solution improvement limit reached");
544 break;
546 SCIPmessageFPrintInfo(scip->messagehdlr, file, "restart limit reached");
547 break;
549 SCIPmessageFPrintInfo(scip->messagehdlr, file, "optimal solution found");
550 break;
552 SCIPmessageFPrintInfo(scip->messagehdlr, file, "infeasible");
553 break;
555 SCIPmessageFPrintInfo(scip->messagehdlr, file, "unbounded");
556 break;
558 SCIPmessageFPrintInfo(scip->messagehdlr, file, "infeasible or unbounded");
559 break;
561 SCIPmessageFPrintInfo(scip->messagehdlr, file, "termination signal received");
562 break;
563 default:
564 SCIPerrorMessage("invalid status code <%d>\n", SCIPgetStatus(scip));
565 return SCIP_INVALIDDATA;
566 }
567
568 return SCIP_OKAY;
569}
570
571/** returns whether the current stage belongs to the transformed problem space
572 *
573 * @return Returns TRUE if the \SCIP instance is transformed, otherwise FALSE
574 */
576 SCIP* scip /**< SCIP data structure */
577 )
578{
579 assert(scip != NULL);
580
581 return ((int)scip->set->stage >= (int)SCIP_STAGE_TRANSFORMING);
582}
583
584/** returns whether the solution process should be probably correct
585 *
586 * @note This feature is not supported yet!
587 *
588 * @return Returns TRUE if \SCIP is exact solving mode, otherwise FALSE
589 */
591 SCIP* scip /**< SCIP data structure */
592 )
593{
594 assert(scip != NULL);
595 assert(scip->set != NULL);
596
597 return (scip->set->misc_exactsolve);
598}
599
600/** returns whether the presolving process would be finished given no more presolving reductions are found in this
601 * presolving round
602 *
603 * Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current
604 * presolving round suffice to trigger another presolving round.
605 *
606 * @note if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE
607 * @note does not check whether infeasibility or unboundedness was already detected in presolving (which would result
608 * in presolving being stopped although the method returns TRUE)
609 *
610 * @return Returns TRUE if presolving is finished if no further reductions are detected
611 */
613 SCIP* scip /**< SCIP data structure */
614 )
615{
616 int maxnrounds;
617 SCIP_Bool finished;
618
619 assert(scip != NULL);
620 assert(scip->stat != NULL);
621 assert(scip->transprob != NULL);
622
624
625 /* get maximum number of presolving rounds */
626 maxnrounds = scip->set->presol_maxrounds;
627 if( maxnrounds == -1 )
629
630 /* don't abort, if enough changes were applied to the variables */
631 finished = (scip->transprob->nvars == 0
632 || (scip->stat->npresolfixedvars - scip->stat->lastnpresolfixedvars
633 + scip->stat->npresolaggrvars - scip->stat->lastnpresolaggrvars
634 + scip->stat->npresolchgvartypes - scip->stat->lastnpresolchgvartypes
635 + (scip->stat->npresolchgbds - scip->stat->lastnpresolchgbds)/10.0
636 + (scip->stat->npresoladdholes - scip->stat->lastnpresoladdholes)/10.0
637 <= scip->set->presol_abortfac * scip->transprob->nvars)); /*lint !e653*/
638
639 /* don't abort, if enough changes were applied to the constraints */
641 && (scip->transprob->nconss == 0
642 || (scip->stat->npresoldelconss - scip->stat->lastnpresoldelconss
643 + scip->stat->npresoladdconss - scip->stat->lastnpresoladdconss
644 + scip->stat->npresolupgdconss - scip->stat->lastnpresolupgdconss
645 + scip->stat->npresolchgsides - scip->stat->lastnpresolchgsides
646 <= scip->set->presol_abortfac * scip->transprob->nconss));
647
648 /* don't abort, if enough changes were applied to the coefficients (assume a 1% density of non-zero elements) */
650 && (scip->transprob->nvars == 0 || scip->transprob->nconss == 0
651 || (scip->stat->npresolchgcoefs - scip->stat->lastnpresolchgcoefs
652 <= scip->set->presol_abortfac * 0.01 * scip->transprob->nvars * scip->transprob->nconss));
653
654#ifdef SCIP_DISABLED_CODE
655 /* since 2005, we do not take cliques and implications into account when deciding whether to stop presolving */
656 /* don't abort, if enough new implications or cliques were found (assume 100 implications per variable) */
658 && (scip->stat->nimplications - scip->stat->lastnpresolimplications
659 <= scip->set->presol_abortfac * 100 * scip->transprob->nbinvars)
660 && (SCIPcliquetableGetNCliques(scip->cliquetable) - scip->stat->lastnpresolcliques
661 <= scip->set->presol_abortfac * scip->transprob->nbinvars);
662#endif
663
664 /* abort if maximal number of presolving rounds is reached */
665 finished = finished || (scip->stat->npresolrounds + 1 >= maxnrounds);
666
667 return finished;
668}
669
670/** returns whether SCIP has performed presolving during the last solve
671 *
672 * @return Returns TRUE if presolving was performed during the last solve
673 */
675 SCIP* scip /**< SCIP data structure */
676 )
677{
678 assert(scip != NULL);
679 assert(scip->stat != NULL);
680
681 SCIP_CALL_ABORT( SCIPcheckStage(scip, "SCIPhasPerformedPresolve", FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE) );
682
683 return scip->stat->performpresol;
684}
685
686/** returns whether the user pressed CTRL-C to interrupt the solving process
687 *
688 * @return Returns TRUE if Ctrl-C was pressed, otherwise FALSE.
689 */ /*lint -e715*/
691 SCIP* scip /**< SCIP data structure */
692 )
693{
694 return SCIPinterrupted();
695}
696
697/** returns whether the solving process should be / was stopped before proving optimality;
698 * if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields
699 * the reason for the premature abort
700 *
701 * @return Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.
702 */
704 SCIP* scip /**< SCIP data structure */
705 )
706{
708
709 return SCIPsolveIsStopped(scip->set, scip->stat, FALSE);
710}
711
712/** includes information about an external code linked into the SCIP library */
714 SCIP* scip, /**< SCIP data structure */
715 const char* name, /**< name of external code */
716 const char* description /**< description of external code, or NULL */
717 )
718{
719 assert(scip != NULL);
720 assert(name != NULL);
721
722 SCIP_CALL( SCIPcheckStage(scip, "SCIPincludeExternalCodeInformation", TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE) );
723
724 SCIP_CALL( SCIPsetIncludeExternalCode(scip->set, name, description) );
725
726 return SCIP_OKAY;
727}
728
729/** returns an array of names of currently included external codes */
731 SCIP* scip /**< SCIP data structure */
732 )
733{
734 assert(scip != NULL);
735 assert(scip->set != NULL);
736
737 return scip->set->extcodenames;
738}
739
740/** returns an array of the descriptions of currently included external codes
741 *
742 * @note some descriptions may be NULL
743 */
745 SCIP* scip /**< SCIP data structure */
746 )
747{
748 assert(scip != NULL);
749 assert(scip->set != NULL);
750
751 return scip->set->extcodedescs;
752}
753
754/** returns the number of currently included information on external codes */
756 SCIP* scip /**< SCIP data structure */
757 )
758{
759 assert(scip != NULL);
760 assert(scip->set != NULL);
761
762 return scip->set->nextcodes;
763}
764
765/** prints information on external libraries to a file stream via the message handler system
766 *
767 * @note If the message handler is set to a NULL pointer nothing will be printed
768 */
770 SCIP* scip, /**< SCIP data structure */
771 FILE* file /**< output file (or NULL for standard output) */
772 )
773{
774 int i;
775
776 SCIPmessageFPrintInfo(scip->messagehdlr, file, "External libraries: ");
777 if( scip->set->nextcodes == 0 )
778 {
779 SCIPinfoMessage(scip, file, "none\n");
780 return;
781 }
782 SCIPinfoMessage(scip, file, "\n");
783
784 for( i = 0; i < scip->set->nextcodes; ++i )
785 {
786 SCIPinfoMessage(scip, file, " %-20s %s\n", scip->set->extcodenames[i], scip->set->extcodedescs[i] != NULL ? scip->set->extcodedescs[i] : "");
787 }
788}
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
Definition clock.c:290
void SCIPclockFree(SCIP_CLOCK **clck)
Definition clock.c:185
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
Definition clock.c:170
internal methods for clocks and timing issues
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
Definition debug.c:2208
methods for debugging
#define SCIP_SUBVERSION
Definition def.h:148
#define SCIP_COPYRIGHT
Definition def.h:150
#define SCIP_ALLOC(x)
Definition def.h:399
#define TRUE
Definition def.h:95
#define FALSE
Definition def.h:96
#define SCIP_CALL_ABORT(x)
Definition def.h:367
#define SCIP_VERSION
Definition def.h:147
#define SCIP_CALL(x)
Definition def.h:388
#define SCIP_CALL_FINALLY(x, y)
Definition def.h:430
SCIP_RETCODE SCIPdialoghdlrCreate(SCIP_SET *set, SCIP_DIALOGHDLR **dialoghdlr)
Definition dialog.c:336
SCIP_RETCODE SCIPdialoghdlrFree(SCIP *scip, SCIP_DIALOGHDLR **dialoghdlr)
Definition dialog.c:367
internal methods for user interface dialog
methods to interpret (evaluate) an expression "fast"
const char * SCIPexprintGetName(void)
const char * SCIPexprintGetDesc(void)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
SCIP_Bool SCIPhasPerformedPresolve(SCIP *scip)
SCIP_Bool SCIPpressedCtrlC(SCIP *scip)
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_Bool SCIPisExactSolve(SCIP *scip)
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition scip_prob.c:694
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition scip_prob.c:1225
const char * SCIPlpiGetSolverName(void)
Definition lpi_clp.cpp:454
const char * SCIPlpiGetSolverDesc(void)
Definition lpi_clp.cpp:463
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPprintError(SCIP_RETCODE retcode)
int SCIPsubversion(void)
void SCIPprintBuildOptions(SCIP *scip, FILE *file)
int SCIPminorVersion(void)
SCIP_Real SCIPversion(void)
int SCIPtechVersion(void)
void SCIPprintVersion(SCIP *scip, FILE *file)
int SCIPmajorVersion(void)
char ** SCIPgetExternalCodeDescriptions(SCIP *scip)
SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)
int SCIPgetNExternalCodes(SCIP *scip)
void SCIPprintExternalCodes(SCIP *scip, FILE *file)
char ** SCIPgetExternalCodeNames(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
return SCIP_OKAY
assert(minobj< SCIPgetCutoffbound(scip))
int SCIPcliquetableGetNCliques(SCIP_CLIQUETABLE *cliquetable)
Definition implics.c:3506
SCIP_RETCODE SCIPinterruptCreate(SCIP_INTERRUPT **interrupt)
Definition interrupt.c:91
void SCIPinterruptFree(SCIP_INTERRUPT **interrupt)
Definition interrupt.c:104
SCIP_Bool SCIPinterrupted(void)
Definition interrupt.c:163
methods for catching the user CTRL-C interrupt
interface methods for specific LP solvers
#define NULL
Definition lpi_spx1.cpp:161
SCIP_RETCODE SCIPmemCreate(SCIP_MEM **mem)
Definition mem.c:43
SCIP_RETCODE SCIPmemFree(SCIP_MEM **mem)
Definition mem.c:69
methods for block memory pools and memory buffers
memory allocation routines
#define BMSfreeMemory(ptr)
Definition memory.h:147
#define BMSclearMemory(ptr)
Definition memory.h:131
#define BMSallocMemory(ptr)
Definition memory.h:120
void SCIPmessagePrintError(const char *formatstr,...)
Definition message.c:791
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition message.c:618
SCIP_RETCODE SCIPmessagehdlrRelease(SCIP_MESSAGEHDLR **messagehdlr)
Definition message.c:348
SCIP_RETCODE SCIPcreateMessagehdlrDefault(SCIP_MESSAGEHDLR **messagehdlr, SCIP_Bool bufferedoutput, const char *filename, SCIP_Bool quiet)
default message handler
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition scip_mem.c:57
SCIP_RETCODE SCIPnlpInclude(SCIP_SET *set, BMS_BLKMEM *blkmem)
Definition nlp.c:3425
internal methods for NLP management
public methods for message output
#define SCIPerrorMessage
Definition pub_message.h:64
void SCIPretcodePrintError(SCIP_RETCODE retcode)
Definition retcode.c:113
internal methods for return codes for SCIP methods
static SCIP_RETCODE doScipCreate(SCIP **scip)
general public methods
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for global and local (sub)problems
public methods for querying solving statistics
const char * SCIPgetBuildFlags(void)
build flags methods
SCIP_RETCODE SCIPincludeCorePlugins(SCIP *scip)
register additional core functionality that is designed as plugins
const char * SCIPgetGitHash(void)
Definition scipgithash.c:37
git hash methods
SCIP_RETCODE SCIPsetCreate(SCIP_SET **set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP *scip)
Definition set.c:1097
SCIP_RETCODE SCIPsetFree(SCIP_SET **set, BMS_BLKMEM *blkmem)
Definition set.c:2720
SCIP_RETCODE SCIPsetIncludeExternalCode(SCIP_SET *set, const char *name, const char *description)
Definition set.c:5161
internal methods for global SCIP settings
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
Definition solve.c:102
internal methods for main solving loop and node processing
datastructures for block memory pools and memory buffers
datastructures for collecting primal CIP solutions and primal informations
datastructures for storing and manipulating the main problem
SCIP main data structure.
datastructures for global SCIP settings
datastructures for problem statistics
SCIP_RETCODE SCIPsyncstoreRelease(SCIP_SYNCSTORE **syncstore)
Definition syncstore.c:87
SCIP_RETCODE SCIPsyncstoreCreate(SCIP_SYNCSTORE **syncstore)
Definition syncstore.c:66
the function declarations for the synchronization store
@ SCIP_CLOCKTYPE_DEFAULT
Definition type_clock.h:43
@ SCIP_INVALIDDATA
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_PROBLEM
Definition type_set.h:45
@ SCIP_STAGE_INITPRESOLVE
Definition type_set.h:48
@ SCIP_STAGE_SOLVED
Definition type_set.h:54
@ SCIP_STAGE_PRESOLVING
Definition type_set.h:49
@ SCIP_STAGE_TRANSFORMED
Definition type_set.h:47
@ SCIP_STAGE_INITSOLVE
Definition type_set.h:52
@ SCIP_STAGE_EXITPRESOLVE
Definition type_set.h:50
@ SCIP_STAGE_EXITSOLVE
Definition type_set.h:55
@ SCIP_STAGE_INIT
Definition type_set.h:44
@ SCIP_STAGE_FREE
Definition type_set.h:57
@ SCIP_STAGE_FREETRANS
Definition type_set.h:56
@ SCIP_STAGE_SOLVING
Definition type_set.h:53
@ SCIP_STAGE_TRANSFORMING
Definition type_set.h:46
@ SCIP_STAGE_PRESOLVED
Definition type_set.h:51
enum SCIP_Stage SCIP_STAGE
Definition type_set.h:59
@ SCIP_STATUS_OPTIMAL
Definition type_stat.h:61
@ SCIP_STATUS_TOTALNODELIMIT
Definition type_stat.h:45
@ SCIP_STATUS_BESTSOLLIMIT
Definition type_stat.h:57
@ SCIP_STATUS_SOLLIMIT
Definition type_stat.h:54
@ SCIP_STATUS_UNBOUNDED
Definition type_stat.h:63
@ SCIP_STATUS_UNKNOWN
Definition type_stat.h:42
@ SCIP_STATUS_GAPLIMIT
Definition type_stat.h:53
@ SCIP_STATUS_USERINTERRUPT
Definition type_stat.h:43
@ SCIP_STATUS_TERMINATE
Definition type_stat.h:65
@ SCIP_STATUS_INFORUNBD
Definition type_stat.h:64
@ SCIP_STATUS_STALLNODELIMIT
Definition type_stat.h:48
@ SCIP_STATUS_TIMELIMIT
Definition type_stat.h:51
@ SCIP_STATUS_INFEASIBLE
Definition type_stat.h:62
@ SCIP_STATUS_NODELIMIT
Definition type_stat.h:44
@ SCIP_STATUS_MEMLIMIT
Definition type_stat.h:52
@ SCIP_STATUS_RESTARTLIMIT
Definition type_stat.h:60
enum SCIP_Status SCIP_STATUS
Definition type_stat.h:67