SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
nlhdlr.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 nlhdlr.c
26 * @ingroup OTHER_CFILES
27 * @brief functions for nonlinearity handlers of nonlinear constraint handler
28 * @author Ksenia Bestuzheva
29 * @author Benjamin Mueller
30 * @author Felipe Serrano
31 * @author Stefan Vigerske
32 */
33
34#include <assert.h>
35
36#include "scip/pub_nlhdlr.h"
37#include "scip/nlhdlr.h"
38#include "scip/struct_nlhdlr.h"
39#include "scip/scip_timing.h"
40#include "scip/scip_mem.h"
41#include "scip/scip_param.h"
42#include "scip/scip_message.h"
43#include "scip/pub_misc.h"
44
45/**@addtogroup PublicNlhdlrInterfaceMethods
46 * @{
47 */
48
49#ifdef NDEBUG
50/* Undo the defines from pub_nlhdlr.h, which exist if NDEBUG is defined. */
51#undef SCIPnlhdlrSetCopyHdlr
52#undef SCIPnlhdlrSetFreeHdlrData
53#undef SCIPnlhdlrSetFreeExprData
54#undef SCIPnlhdlrSetInitExit
55#undef SCIPnlhdlrSetProp
56#undef SCIPnlhdlrSetSepa
57#undef SCIPnlhdlrGetName
58#undef SCIPnlhdlrGetDesc
59#undef SCIPnlhdlrGetDetectPriority
60#undef SCIPnlhdlrGetEnfoPriority
61#undef SCIPnlhdlrIsEnabled
62#undef SCIPnlhdlrGetData
63#undef SCIPnlhdlrHasIntEval
64#undef SCIPnlhdlrHasReverseProp
65#undef SCIPnlhdlrHasInitSepa
66#undef SCIPnlhdlrHasExitSepa
67#undef SCIPnlhdlrHasEnfo
68#undef SCIPnlhdlrHasEstimate
69#endif
70
71/** sets the copy handler callback of a nonlinear handler */
73 SCIP_NLHDLR* nlhdlr, /**< nonlinear handler */
74 SCIP_DECL_NLHDLRCOPYHDLR((*copy)) /**< copy callback (can be NULL) */
75 )
76{
77 assert(nlhdlr != NULL);
78
79 nlhdlr->copyhdlr = copy;
80}
81
82/** sets the nonlinear handler callback to free the nonlinear handler data */
84 SCIP_NLHDLR* nlhdlr, /**< nonlinear handler */
85 SCIP_DECL_NLHDLRFREEHDLRDATA((*freehdlrdata)) /**< handler free callback (can be NULL) */
86 )
87{
88 assert(nlhdlr != NULL);
89
90 nlhdlr->freehdlrdata = freehdlrdata;
91}
92
93/** sets the nonlinear handler callback to free expression specific data of nonlinear handler */
95 SCIP_NLHDLR* nlhdlr, /**< nonlinear handler */
96 SCIP_DECL_NLHDLRFREEEXPRDATA((*freeexprdata)) /**< nonlinear handler expression data free callback
97 * (can be NULL if data does not need to be freed) */
98 )
99{
100 assert(nlhdlr != NULL);
101
102 nlhdlr->freeexprdata = freeexprdata;
103}
104
105/** sets the initialization and deinitialization callback of a nonlinear handler */
107 SCIP_NLHDLR* nlhdlr, /**< nonlinear handler */
108 SCIP_DECL_NLHDLRINIT((*init)), /**< initialization callback (can be NULL) */
109 SCIP_DECL_NLHDLREXIT((*exit_)) /**< deinitialization callback (can be NULL) */
110 )
111{
112 assert(nlhdlr != NULL);
113
114 nlhdlr->init = init;
115 nlhdlr->exit = exit_;
116}
117
118/** sets the propagation callbacks of a nonlinear handler */
120 SCIP_NLHDLR* nlhdlr, /**< nonlinear handler */
121 SCIP_DECL_NLHDLRINTEVAL((*inteval)), /**< interval evaluation callback (can be NULL) */
122 SCIP_DECL_NLHDLRREVERSEPROP((*reverseprop)) /**< reverse propagation callback (can be NULL) */
123 )
124{
125 assert(nlhdlr != NULL);
126
127 nlhdlr->inteval = inteval;
128 nlhdlr->reverseprop = reverseprop;
129}
130
131/** sets the enforcement callbacks of a nonlinear handler */
133 SCIP_NLHDLR* nlhdlr, /**< nonlinear handler */
134 SCIP_DECL_NLHDLRINITSEPA((*initsepa)), /**< separation initialization callback (can be NULL) */
135 SCIP_DECL_NLHDLRENFO((*enfo)), /**< enforcement callback (can be NULL if estimate is not NULL) */
136 SCIP_DECL_NLHDLRESTIMATE((*estimate)), /**< estimation callback (can be NULL if sepa is not NULL) */
137 SCIP_DECL_NLHDLREXITSEPA((*exitsepa)) /**< separation deinitialization callback (can be NULL) */
138 )
139{
140 assert(nlhdlr != NULL);
141 assert(enfo != NULL || estimate != NULL);
142
143 nlhdlr->initsepa = initsepa;
144 nlhdlr->enfo = enfo;
145 nlhdlr->estimate = estimate;
146 nlhdlr->exitsepa = exitsepa;
147}
148
149/** gives name of nonlinear handler */
151 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
152 )
153{
154 assert(nlhdlr != NULL);
155
156 return nlhdlr->name;
157}
158
159/** gives description of nonlinear handler, can be NULL */
161 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
162 )
163{
164 assert(nlhdlr != NULL);
165
166 return nlhdlr->desc;
167}
168
169/** gives detection priority of nonlinear handler */
171 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
172 )
173{
174 assert(nlhdlr != NULL);
175
176 return nlhdlr->detectpriority;
177}
178
179/** gives enforcement priority of nonlinear handler */
181 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
182 )
183{
184 assert(nlhdlr != NULL);
185
186 return nlhdlr->enfopriority;
187}
188
189/** returns whether nonlinear handler is enabled */
191 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
192 )
193{
194 assert(nlhdlr != NULL);
195
196 return nlhdlr->enabled;
197}
198
199/** gives handler data of nonlinear handler */
201 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
202 )
203{
204 assert(nlhdlr != NULL);
205
206 return nlhdlr->data;
207}
208
209/** returns whether nonlinear handler implements the interval evaluation callback */
211 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
212 )
213{
214 return nlhdlr->inteval != NULL;
215}
216
217/** returns whether nonlinear handler implements the reverse propagation callback */
219 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
220 )
221{
222 return nlhdlr->reverseprop != NULL;
223}
224
225/** returns whether nonlinear handler implements the separation initialization callback */
227 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
228 )
229{
230 return nlhdlr->initsepa != NULL;
231}
232
233/** returns whether nonlinear handler implements the separation deinitialization callback */
235 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
236 )
237{
238 return nlhdlr->exitsepa != NULL;
239}
240
241/** returns whether nonlinear handler implements the enforcement callback */
243 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
244 )
245{
246 return nlhdlr->enfo != NULL;
247}
248
249/** returns whether nonlinear handler implements the estimator callback */
251 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
252 )
253{
254 return nlhdlr->estimate != NULL;
255}
256
257/** compares two nonlinear handlers by detection priority
258 *
259 * if handlers have same detection priority, then compare by name
260 */
262{
265
266 assert(elem1 != NULL);
267 assert(elem2 != NULL);
268
269 h1 = (SCIP_NLHDLR*)elem1;
270 h2 = (SCIP_NLHDLR*)elem2;
271
272 if( h1->detectpriority != h2->detectpriority )
273 return h1->detectpriority - h2->detectpriority;
274
275 return strcmp(h1->name, h2->name);
276}
277
278#ifdef SCIP_DISABLED_CODE
279/** compares nonlinear handler by enforcement priority
280 *
281 * if handlers have same enforcement priority, then compare by detection priority, then by name
282 */
284{
287
288 assert(elem1 != NULL);
289 assert(elem2 != NULL);
290
291 h1 = (SCIP_NLHDLR*)elem1;
292 h2 = (SCIP_NLHDLR*)elem2;
293
294 if( h1->enfopriority != h2->enfopriority )
295 return h1->enfopriority - h2->enfopriority;
296
297 if( h1->detectpriority != h2->detectpriority )
298 return h1->detectpriority - h2->detectpriority;
299
300 return strcmp(h1->name, h2->name);
301}
302#endif
303
304/** @} */
305
306/* nlhdlr private API functions from nlhdlr.h */
307
308#ifndef NDEBUG
309#undef SCIPnlhdlrResetNDetectionslast
310#undef SCIPnlhdlrIncrementNCutoffs
311#undef SCIPnlhdlrIncrementNSeparated
312#endif
313
314/** creates a nonlinear handler */
316 SCIP* scip, /**< SCIP data structure */
317 SCIP_NLHDLR** nlhdlr, /**< buffer to store pointer to created nonlinear handler */
318 const char* name, /**< name of nonlinear handler (must not be NULL) */
319 const char* desc, /**< description of nonlinear handler (can be NULL) */
320 int detectpriority, /**< detection priority of nonlinear handler */
321 int enfopriority, /**< enforcement priority of nonlinear handler */
322 SCIP_DECL_NLHDLRDETECT((*detect)), /**< structure detection callback of nonlinear handler */
323 SCIP_DECL_NLHDLREVALAUX((*evalaux)), /**< auxiliary evaluation callback of nonlinear handler */
324 SCIP_NLHDLRDATA* nlhdlrdata /**< data of nonlinear handler (can be NULL) */
325 )
326{
328
329 assert(scip != NULL);
330 assert(nlhdlr != NULL);
331 assert(name != NULL);
332 assert(detect != NULL);
333 assert(evalaux != NULL);
334
336
337 SCIP_CALL( SCIPduplicateMemoryArray(scip, &(*nlhdlr)->name, name, strlen(name)+1) );
338 if( desc != NULL )
339 {
340 SCIP_CALL_FINALLY( SCIPduplicateMemoryArray(scip, &(*nlhdlr)->desc, desc, strlen(desc)+1),
341 SCIPfreeMemoryArray(scip, &(*nlhdlr)->name) );
342 }
343
344 (*nlhdlr)->detectpriority = detectpriority;
345 (*nlhdlr)->enfopriority = enfopriority;
346 (*nlhdlr)->data = nlhdlrdata;
347 (*nlhdlr)->detect = detect;
348 (*nlhdlr)->evalaux = evalaux;
349
350 SCIP_CALL( SCIPcreateClock(scip, &(*nlhdlr)->detecttime) );
351 SCIP_CALL( SCIPcreateClock(scip, &(*nlhdlr)->enfotime) );
352 SCIP_CALL( SCIPcreateClock(scip, &(*nlhdlr)->proptime) );
353 SCIP_CALL( SCIPcreateClock(scip, &(*nlhdlr)->intevaltime) );
354
355 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "nlhdlr/%s/enabled", name);
356 SCIP_CALL( SCIPaddBoolParam(scip, paramname, "should this nonlinear handler be used",
357 &(*nlhdlr)->enabled, FALSE, TRUE, NULL, NULL) );
358
359 return SCIP_OKAY;
360}
361
362/** frees a nonlinear handler */
364 SCIP* scip, /**< SCIP data structure */
365 SCIP_NLHDLR** nlhdlr /**< pointer to nonlinear handler to be freed */
366 )
367{
368 assert(nlhdlr != NULL);
369 assert(*nlhdlr != NULL);
370
371 if( (*nlhdlr)->freehdlrdata != NULL )
372 {
373 SCIP_CALL( (*nlhdlr)->freehdlrdata(scip, *nlhdlr, &(*nlhdlr)->data) );
374 }
375
376 /* free clocks */
377 SCIP_CALL( SCIPfreeClock(scip, &(*nlhdlr)->detecttime) );
378 SCIP_CALL( SCIPfreeClock(scip, &(*nlhdlr)->enfotime) );
379 SCIP_CALL( SCIPfreeClock(scip, &(*nlhdlr)->proptime) );
380 SCIP_CALL( SCIPfreeClock(scip, &(*nlhdlr)->intevaltime) );
381
382 SCIPfreeMemory(scip, &(*nlhdlr)->name);
383 SCIPfreeMemoryNull(scip, &(*nlhdlr)->desc);
384
385 SCIPfreeBlockMemory(scip, nlhdlr);
386
387 return SCIP_OKAY;
388}
389
390/** call the handler copy callback of a nonlinear handler */
392{
393 /* TODO for now just don't copy disabled nlhdlr, a clean way would probably be to first copy and disable then */
394 if( sourcenlhdlr->copyhdlr != NULL && sourcenlhdlr->enabled )
395 {
397 }
398
399 return SCIP_OKAY;
400}
401
402/** call the free expression specific data callback of a nonlinear handler */
404{
405 assert(nlhdlr != NULL);
406 assert(nlhdlrexprdata != NULL);
407 assert(*nlhdlrexprdata != NULL);
408
409 if( nlhdlr->freeexprdata != NULL )
410 {
411 SCIP_CALL( nlhdlr->freeexprdata(scip, nlhdlr, expr, nlhdlrexprdata) );
412 assert(*nlhdlrexprdata == NULL);
413 }
414
415 return SCIP_OKAY;
416}
417
418/** call the initialization callback of a nonlinear handler */
420{
421 assert(nlhdlr != NULL);
422
423 nlhdlr->nenfocalls = 0;
424 nlhdlr->nintevalcalls = 0;
425 nlhdlr->npropcalls = 0;
426 nlhdlr->nseparated = 0;
427 nlhdlr->ncutoffs = 0;
428 nlhdlr->ndomreds = 0;
429 nlhdlr->nbranchscores = 0;
430 nlhdlr->ndetections = 0;
431 nlhdlr->ndetectionslast = 0;
432
437
438 if( nlhdlr->init != NULL )
439 {
440 SCIP_CALL( nlhdlr->init(scip, nlhdlr) );
441 }
442
443 return SCIP_OKAY;
444}
445
446/** call the deinitialization callback of a nonlinear handler */
448{
449 assert(nlhdlr != NULL);
450
451 if( nlhdlr->exit != NULL )
452 {
453 SCIP_CALL( nlhdlr->exit(scip, nlhdlr) );
454 }
455
456 return SCIP_OKAY;
457}
458
459/** call the detect callback of a nonlinear handler */
461{
462 assert(scip != NULL);
463 assert(nlhdlr != NULL);
464 assert(nlhdlr->detect != NULL);
465 assert(nlhdlr->detecttime != NULL);
467
469 SCIP_CALL( nlhdlr->detect(scip, conshdlr, nlhdlr, expr, cons, enforcing, participating, nlhdlrexprdata) );
471
473 {
474 ++nlhdlr->ndetections;
475 ++nlhdlr->ndetectionslast;
476 }
477
478 return SCIP_OKAY;
479}
480
481/** call the auxiliary evaluation callback of a nonlinear handler */
483{
484 assert(nlhdlr != NULL);
485 assert(nlhdlr->evalaux != NULL);
486
487 SCIP_CALL( nlhdlr->evalaux(scip, nlhdlr, expr, nlhdlrexprdata, auxvalue, sol) );
488
489 return SCIP_OKAY;
490}
491
492/** call the interval evaluation callback of a nonlinear handler */
494{
495 assert(scip != NULL);
496 assert(nlhdlr != NULL);
497 assert(nlhdlr->intevaltime != NULL);
498
499 if( nlhdlr->inteval != NULL )
500 {
502 SCIP_CALL( nlhdlr->inteval(scip, nlhdlr, expr, nlhdlrexprdata, interval, intevalvar, intevalvardata) );
504
505 ++nlhdlr->nintevalcalls;
506 }
507
508 return SCIP_OKAY;
509}
510
511/** call the reverse propagation callback of a nonlinear handler */
513{
514 assert(scip != NULL);
515 assert(nlhdlr != NULL);
516 assert(nlhdlr->proptime != NULL);
517 assert(infeasible != NULL);
518 assert(nreductions != NULL);
519
520 if( nlhdlr->reverseprop == NULL )
521 {
522 *infeasible = FALSE;
523 *nreductions = 0;
524
525 return SCIP_OKAY;
526 }
527
529 SCIP_CALL( nlhdlr->reverseprop(scip, conshdlr, nlhdlr, expr, nlhdlrexprdata, bounds, infeasible, nreductions) );
531
532 /* update statistics */
533 nlhdlr->ndomreds += *nreductions;
534 if( *infeasible )
535 ++nlhdlr->ncutoffs;
536 ++nlhdlr->npropcalls;
537
538 return SCIP_OKAY;
539}
540
541/** call the separation initialization callback of a nonlinear handler */
543{
544 assert(scip != NULL);
545 assert(nlhdlr != NULL);
546 assert(nlhdlr->enfotime != NULL);
547 assert(infeasible != NULL);
548
549 if( nlhdlr->initsepa == NULL )
550 {
551 *infeasible = FALSE;
552 return SCIP_OKAY;
553 }
554
556 SCIP_CALL( nlhdlr->initsepa(scip, conshdlr, cons, nlhdlr, expr, nlhdlrexprdata, overestimate, underestimate, infeasible) );
558
559 ++nlhdlr->nenfocalls;
560 if( *infeasible )
561 ++nlhdlr->ncutoffs;
562
563 return SCIP_OKAY;
564}
565
566/** call the separation deinitialization callback of a nonlinear handler */
568{
569 assert(scip != NULL);
570 assert(nlhdlr != NULL);
571 assert(nlhdlr->enfotime != NULL);
572
573 if( nlhdlr->exitsepa != NULL )
574 {
576 SCIP_CALL( nlhdlr->exitsepa(scip, nlhdlr, expr, nlhdlrexprdata) );
578 }
579
580 return SCIP_OKAY;
581}
582
583/** call the enforcement callback of a nonlinear handler */
585{
586 assert(scip != NULL);
587 assert(nlhdlr != NULL);
588 assert(nlhdlr->enfotime != NULL);
589 assert(result != NULL);
590
591 if( nlhdlr->enfo == NULL )
592 {
594 return SCIP_OKAY;
595 }
596
597#ifndef NDEBUG
598 /* check that auxvalue is correct by reevaluating */
599 {
600 SCIP_Real auxvaluetest;
601 SCIP_CALL( SCIPnlhdlrEvalaux(scip, nlhdlr, expr, nlhdlrexprdata, &auxvaluetest, sol) );
602 /* we should get EXACTLY the same value from calling evalaux with the same solution as before */
603 assert(auxvalue == auxvaluetest); /*lint !e777*/
604 }
605#endif
606
608 SCIP_CALL( nlhdlr->enfo(scip, conshdlr, cons, nlhdlr, expr, nlhdlrexprdata, sol, auxvalue,
609 overestimate, allowweakcuts, separated, addbranchscores, result) );
611
612 /* update statistics */
613 ++nlhdlr->nenfocalls;
614 switch( *result )
615 {
616 case SCIP_SEPARATED :
617 ++nlhdlr->nseparated;
618 break;
619 case SCIP_BRANCHED:
620 ++nlhdlr->nbranchscores;
621 break;
622 case SCIP_CUTOFF:
623 ++nlhdlr->ncutoffs;
624 break;
625 case SCIP_REDUCEDDOM:
626 ++nlhdlr->ndomreds;
627 break;
628 default: ;
629 } /*lint !e788*/
630
631 return SCIP_OKAY;
632}
633
634/** call the estimator callback of a nonlinear handler */
636{
637 assert(scip != NULL);
638 assert(nlhdlr != NULL);
639 assert(nlhdlr->enfotime != NULL);
640 assert(success != NULL);
642
643 if( nlhdlr->estimate == NULL )
644 {
645 *success = FALSE;
647 return SCIP_OKAY;
648 }
649
650#ifndef NDEBUG
651 /* check that auxvalue is correct by reevaluating */
652 {
653 SCIP_Real auxvaluetest;
654 SCIP_CALL( SCIPnlhdlrEvalaux(scip, nlhdlr, expr, nlhdlrexprdata, &auxvaluetest, sol) );
655 /* we should get EXACTLY the same value from calling evalaux with the same solution as before */
656 assert(auxvalue == auxvaluetest); /*lint !e777*/
657 }
658#endif
659
661 SCIP_CALL( nlhdlr->estimate(scip, conshdlr, nlhdlr, expr, nlhdlrexprdata, sol, auxvalue, overestimate, targetvalue, addbranchscores, rowpreps, success, addedbranchscores) );
663
664 /* update statistics */
665 ++nlhdlr->nenfocalls;
666
667 return SCIP_OKAY;
668}
669
670/** reset number of detections counter for last round */
672 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
673 )
674{
675 assert(nlhdlr != NULL);
676 nlhdlr->ndetectionslast = 0;
677}
678
679/** increments number of cutoffs in statistics */
681 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
682 )
683{
684 assert(nlhdlr != NULL);
685 ++nlhdlr->ncutoffs;
686}
687
688/** increments number of separations in statistics */
690 SCIP_NLHDLR* nlhdlr /**< nonlinear handler */
691 )
692{
693 assert(nlhdlr != NULL);
694 ++nlhdlr->nseparated;
695}
696
697/** print statistics for nonlinear handlers */
699 SCIP* scip, /**< SCIP data structure */
700 SCIP_NLHDLR** nlhdlrs, /**< nonlinear handlers */
701 int nnlhdlrs, /**< number of nonlinear handlers */
702 FILE* file /**< file handle, or NULL for standard out */
703 )
704{
705 int i;
706
707 SCIPinfoMessage(scip, file, "Nlhdlrs : %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s %10s\n",
708 "Detects", "DetectAll", "DetectTime",
709 "#IntEval", "IntEvalTi",
710 "#RevProp", "RevPropTi", "DomReds", "Cutoffs",
711 "#Enforce", "EnfoTime", "Cuts", "Branching");
712
713 for( i = 0; i < nnlhdlrs; ++i )
714 {
715 /* skip disabled nlhdlr */
716 if( !nlhdlrs[i]->enabled )
717 continue;
718
719 SCIPinfoMessage(scip, file, " %-17s:", nlhdlrs[i]->name);
720 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->ndetectionslast);
721 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->ndetections);
722 SCIPinfoMessage(scip, file, " %10.2f", SCIPgetClockTime(scip, nlhdlrs[i]->detecttime));
723
724 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->nintevalcalls);
725 SCIPinfoMessage(scip, file, " %10.2f", SCIPgetClockTime(scip, nlhdlrs[i]->intevaltime));
726
727 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->npropcalls);
728 SCIPinfoMessage(scip, file, " %10.2f", SCIPgetClockTime(scip, nlhdlrs[i]->proptime));
729 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->ndomreds);
730 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->ncutoffs);
731
732 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->nenfocalls);
733 SCIPinfoMessage(scip, file, " %10.2f", SCIPgetClockTime(scip, nlhdlrs[i]->enfotime));
734 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->nseparated);
735 SCIPinfoMessage(scip, file, " %10lld", nlhdlrs[i]->nbranchscores);
736
737 SCIPinfoMessage(scip, file, "\n");
738 }
739}
#define SCIP_MAXSTRLEN
Definition def.h:302
#define TRUE
Definition def.h:95
#define FALSE
Definition def.h:96
#define SCIP_CALL(x)
Definition def.h:388
#define SCIP_CALL_FINALLY(x, y)
Definition def.h:430
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition scip_param.c:57
#define SCIPallocClearBlockMemory(scip, ptr)
Definition scip_mem.h:91
#define SCIPfreeMemoryNull(scip, ptr)
Definition scip_mem.h:79
#define SCIPduplicateMemoryArray(scip, ptr, source, num)
Definition scip_mem.h:76
#define SCIPfreeMemoryArray(scip, ptr)
Definition scip_mem.h:80
#define SCIPfreeMemory(scip, ptr)
Definition scip_mem.h:78
#define SCIPfreeBlockMemory(scip, ptr)
Definition scip_mem.h:108
void SCIPnlhdlrSetInitExit(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINIT((*init)),)
Definition nlhdlr.c:106
const char * SCIPnlhdlrGetDesc(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:160
SCIP_NLHDLRDATA * SCIPnlhdlrGetData(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:200
void SCIPnlhdlrSetFreeExprData(SCIP_NLHDLR *nlhdlr,)
Definition nlhdlr.c:94
SCIP_Bool SCIPnlhdlrHasIntEval(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:210
SCIP_Bool SCIPnlhdlrHasEnfo(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:242
int SCIPnlhdlrGetDetectPriority(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:170
SCIP_Bool SCIPnlhdlrIsEnabled(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:190
SCIP_Bool SCIPnlhdlrHasReverseProp(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:218
const char * SCIPnlhdlrGetName(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:150
SCIP_Bool SCIPnlhdlrHasEstimate(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:250
void SCIPnlhdlrSetSepa(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINITSEPA((*initsepa)), SCIP_DECL_NLHDLRENFO((*enfo)), SCIP_DECL_NLHDLRESTIMATE((*estimate)),)
Definition nlhdlr.c:132
void SCIPnlhdlrSetFreeHdlrData(SCIP_NLHDLR *nlhdlr,)
Definition nlhdlr.c:83
void SCIPnlhdlrSetCopyHdlr(SCIP_NLHDLR *nlhdlr,)
Definition nlhdlr.c:72
SCIP_Bool SCIPnlhdlrHasInitSepa(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:226
int SCIPnlhdlrGetEnfoPriority(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:180
void SCIPnlhdlrSetProp(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINTEVAL((*inteval)),)
Definition nlhdlr.c:119
SCIP_Bool SCIPnlhdlrHasExitSepa(SCIP_NLHDLR *nlhdlr)
Definition nlhdlr.c:234
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
Definition scip_timing.c:76
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition misc.c:10788
return SCIP_OKAY
static SCIP_SOL * sol
assert(minobj< SCIPgetCutoffbound(scip))
static const char * paramname[]
Definition lpi_msk.c:5096
#define NULL
Definition lpi_spx1.cpp:161
SCIP_RETCODE SCIPnlhdlrFree(SCIP *scip, SCIP_NLHDLR **nlhdlr)
Definition nlhdlr.c:363
SCIP_RETCODE SCIPnlhdlrCreate(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
Definition nlhdlr.c:315
void SCIPnlhdlrPrintStatistics(SCIP *scip, SCIP_NLHDLR **nlhdlrs, int nnlhdlrs, FILE *file)
Definition nlhdlr.c:698
private functions of nonlinear handlers of nonlinear constraints
#define SCIPnlhdlrIncrementNSeparated(nlhdlr)
Definition nlhdlr.h:128
#define SCIPnlhdlrResetNDetectionslast(nlhdlr)
Definition nlhdlr.h:126
#define SCIPnlhdlrIncrementNCutoffs(nlhdlr)
Definition nlhdlr.h:127
public data structures and miscellaneous methods
public functions of nonlinear handlers of nonlinear constraints
public methods for memory management
public methods for message handling
public methods for SCIP parameter handling
public methods for timing
SCIP_Longint ndetections
SCIP_CLOCK * proptime
SCIP_CLOCK * detecttime
SCIP_Bool enabled
SCIP_Longint npropcalls
SCIP_CLOCK * enfotime
SCIP_CLOCK * intevaltime
SCIP_NLHDLRDATA * data
SCIP_Longint ndetectionslast
SCIP_Longint ncutoffs
SCIP_Longint nseparated
SCIP_Longint nenfocalls
SCIP_Longint ndomreds
SCIP_Longint nintevalcalls
SCIP_Longint nbranchscores
structure definitions related to nonlinear handlers of nonlinear constraints
#define SCIP_DECL_SORTPTRCOMP(x)
Definition type_misc.h:188
#define SCIP_DECL_NLHDLREVALAUX(x)
#define SCIP_DECL_NLHDLRESTIMATE(x)
struct SCIP_NlhdlrData SCIP_NLHDLRDATA
#define SCIP_DECL_NLHDLRCOPYHDLR(x)
Definition type_nlhdlr.h:70
#define SCIP_DECL_NLHDLRINIT(x)
#define SCIP_DECL_NLHDLREXIT(x)
#define SCIP_DECL_NLHDLRFREEEXPRDATA(x)
Definition type_nlhdlr.h:94
#define SCIP_DECL_NLHDLRDETECT(x)
#define SCIP_NLHDLR_METHOD_NONE
Definition type_nlhdlr.h:50
#define SCIP_DECL_NLHDLREXITSEPA(x)
#define SCIP_DECL_NLHDLRINITSEPA(x)
#define SCIP_DECL_NLHDLRFREEHDLRDATA(x)
Definition type_nlhdlr.h:82
#define SCIP_DECL_NLHDLRREVERSEPROP(x)
#define SCIP_DECL_NLHDLRENFO(x)
#define SCIP_DECL_NLHDLRINTEVAL(x)
@ SCIP_DIDNOTRUN
Definition type_result.h:42
@ SCIP_CUTOFF
Definition type_result.h:48
@ SCIP_REDUCEDDOM
Definition type_result.h:51
@ SCIP_BRANCHED
Definition type_result.h:54
@ SCIP_SEPARATED
Definition type_result.h:49
enum SCIP_Retcode SCIP_RETCODE