Scippy

SCIP

Solving Constraint Integer Programs

type_nlhdlr.h
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-2024 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file type_nlhdlr.h
26 * @ingroup TYPEDEFINITIONS
27 * @brief type definitions related to nonlinear handlers of nonlinear constraints
28 * @author Ksenia Bestuzheva
29 * @author Benjamin Mueller
30 * @author Felipe Serrano
31 * @author Stefan Vigerske
32 *
33 * This file defines the interface for nonlinear handlers.
34 *
35 * - \ref NLHDLRS "List of available nonlinear handlers"
36 */
37
38/** @defgroup DEFPLUGINS_NLHDLR Default nonlinear handlers
39 * @ingroup DEFPLUGINS
40 * @brief implementation files (.c files) of the default nonlinear handlers of SCIP
41 */
42
43#ifndef SCIP_TYPE_NLHDLR_H_
44#define SCIP_TYPE_NLHDLR_H_
45
46#include "scip/type_expr.h"
47#include "scip/type_cons.h"
48#include "scip/type_misc.h"
49
50#define SCIP_NLHDLR_METHOD_NONE 0x0u /**< no enforcement */
51#define SCIP_NLHDLR_METHOD_SEPABELOW 0x1u /**< separation for expr <= auxvar, thus might estimate expr from below */
52#define SCIP_NLHDLR_METHOD_SEPAABOVE 0x2u /**< separation for expr >= auxvar, thus might estimate expr from above */
53#define SCIP_NLHDLR_METHOD_SEPABOTH (SCIP_NLHDLR_METHOD_SEPABELOW | SCIP_NLHDLR_METHOD_SEPAABOVE) /**< separation for expr == auxvar */
54#define SCIP_NLHDLR_METHOD_ACTIVITY 0x4u /**< activity computation (interval evaluation) and propagation (reverse propagation) */
55#define SCIP_NLHDLR_METHOD_ALL (SCIP_NLHDLR_METHOD_SEPABOTH | SCIP_NLHDLR_METHOD_ACTIVITY) /**< all enforcement methods */
56
57typedef unsigned int SCIP_NLHDLR_METHOD; /**< nlhdlr methods bitflags */
58
59/** nonlinear handler copy callback
60 *
61 * The method includes the nonlinear handler into a nonlinear constraint handler.
62 *
63 * This method is usually called when doing a copy of a nonlinear constraint handler.
64 *
65 * \param[in] targetscip target SCIP main data structure
66 * \param[in] targetconshdlr target nonlinear constraint handler
67 * \param[out] sourceconshdlr nonlinear constraint handler in source SCIP
68 * \param[out] sourcenlhdlr nonlinear handler in source SCIP
69 */
70#define SCIP_DECL_NLHDLRCOPYHDLR(x) SCIP_RETCODE x (\
71 SCIP* targetscip, \
72 SCIP_CONSHDLR* targetconshdlr, \
73 SCIP_CONSHDLR* sourceconshdlr, \
74 SCIP_NLHDLR* sourcenlhdlr)
75
76/** callback to free data of handler
77 *
78 * \param[in] scip SCIP data structure
79 * \param[in] nlhdlr nonlinear handler
80 * \param[in] nlhdlrdata nonlinear handler data to be freed
81 */
82#define SCIP_DECL_NLHDLRFREEHDLRDATA(x) SCIP_RETCODE x (\
83 SCIP* scip, \
84 SCIP_NLHDLR* nlhdlr, \
85 SCIP_NLHDLRDATA** nlhdlrdata)
86
87/** callback to free expression specific data
88 *
89 * \param[in] scip SCIP data structure
90 * \param[in] nlhdlr nonlinear handler
91 * \param[in] expr expression
92 * \param[in] nlhdlrexprdata nonlinear handler expression data to be freed
93 */
94#define SCIP_DECL_NLHDLRFREEEXPRDATA(x) SCIP_RETCODE x (\
95 SCIP* scip, \
96 SCIP_NLHDLR* nlhdlr, \
97 SCIP_EXPR* expr, \
98 SCIP_NLHDLREXPRDATA** nlhdlrexprdata)
99
100/** callback to be called in initialization (called after problem was transformed)
101 *
102 * \param[in] scip SCIP data structure
103 * \param[in] nlhdlr nonlinear handler
104 */
105#define SCIP_DECL_NLHDLRINIT(x) SCIP_RETCODE x (\
106 SCIP* scip, \
107 SCIP_NLHDLR* nlhdlr)
108
109/** callback to be called in deinitialization (called before transformed problem is freed)
110 *
111 * \param[in] scip SCIP data structure
112 * \param[in] nlhdlr nonlinear handler
113 */
114#define SCIP_DECL_NLHDLREXIT(x) SCIP_RETCODE x (\
115 SCIP* scip, \
116 SCIP_NLHDLR* nlhdlr)
117
118/** callback to detect structure in expression
119 *
120 * The nonlinear handler shall analyze the current expression and decide whether it wants to contribute
121 * in enforcing the relation between this expression (`expr`) and its descendants (e.g., children) via
122 * linear under- or overestimation, cut generation, and/or activity computation and propagation.
123 * For linear under- or overestimation and cut generation, an auxiliary variable (`auxvar`) can be assumed to
124 * be associated with `expr` and auxiliary variables may be requested in descendant expressions.
125 *
126 * We distinguish the following enforcement methods:
127 * - \ref SCIP_NLHDLR_METHOD_SEPABELOW : linear underestimation of `expr` or cut generation for the relation `expr` &le; `auxvar` (denoted as "below")
128 * - \ref SCIP_NLHDLR_METHOD_SEPAABOVE : linear overestimation of `expr` or cut generation for the relation `expr` &ge; `auxvar` (denoted as "above")
129 * - \ref SCIP_NLHDLR_METHOD_ACTIVITY : domain propagation (i.e., constant under/overestimation) for the relation `expr` = `auxvar`.
130 *
131 * On input, parameter `enforcing` indicates for any of these methods, whether
132 * - it is not necessary to have such a method, e.g., because no `auxvar` will exist for `expr`, or no one uses or sets activities of this expression,
133 * or because analysis of the expression has shown that a relation like `expr` &ge; `auxvar` is not necessary to be satisfied,
134 * - or there already exists a nonlinear handler that will provide this method in an "enforcement" sense, that is,
135 * it believes that no one else could provide this method in a stronger sense. (This is mainly used by nlhdlr_default to check whether
136 * it should still reach out to the exprhdlr or whether it would be dominated by some nonlinear handler.)
137 *
138 * The DETECT callback shall augment the `enforcing` bitmask by setting the enforcement methods it wants to provide in an "enforcement" sense.
139 *
140 * Additionally, the `participating` bitmask shall be set if the nonlinear handler wants to be called on this expression at all.
141 * Here, it shall set all methods that it wants to provide, which are those set in `enforcing`, but additionally those where it wants
142 * to participate but leave enforcement to another nonlinear handler.
143 * This can be useful for nonlinear handlers that do not implement a complete enforcement, e.g., a handler that only contributes
144 * cutting planes in some situations only.
145 *
146 * A nonlinear handler will be called only for those callbacks that it mentioned in `participating`, which is
147 * - \ref SCIP_DECL_NLHDLRENFO "ENFO" and/or \ref SCIP_DECL_NLHDLRESTIMATE "ESTIMATE" will be called with `overestimate==FALSE` if \ref SCIP_NLHDLR_METHOD_SEPABELOW has been set
148 * - \ref SCIP_DECL_NLHDLRENFO "ENFO" and/or \ref SCIP_DECL_NLHDLRESTIMATE "ESTIMATE" will be called with `overestimate==TRUE` if \ref SCIP_NLHDLR_METHOD_SEPAABOVE has been set
149 * - \ref SCIP_DECL_NLHDLRINTEVAL "INTEVAL" and/or \ref SCIP_DECL_NLHDLRREVERSEPROP "REVERSEPROP" will be called if \ref SCIP_NLHDLR_METHOD_ACTIVITY has been set
150 *
151 * If \ref SCIP_NLHDLR_METHOD_SEPABELOW or \ref SCIP_NLHDLR_METHOD_SEPAABOVE has been set, then at least one of the
152 * callbacks \ref SCIP_DECL_NLHDLRENFO "ENFO" and \ref SCIP_DECL_NLHDLRESTIMATE "ESTIMATE" needs to be implemented.
153 * Also \ref SCIP_DECL_NLHDLREVALAUX "EVALAUX" will be called in this case.
154 * If \ref SCIP_NLHDLR_METHOD_ACTIVITY has been set, then at least one of \ref SCIP_DECL_NLHDLRINTEVAL "INTEVAL" and
155 * \ref SCIP_DECL_NLHDLRREVERSEPROP "REVERSEPROP" needs to be implemented.
156 * If the nonlinear handler chooses not to participate, then it must not set `nlhdlrexprdata` and can leave `participating` at its
157 * initial value (\ref SCIP_NLHDLR_METHOD_NONE).
158 *
159 * Additionally, a nonlinear handler that decides to participate in any of the enforcement methods must call
160 * @ref SCIPregisterExprUsageNonlinear() for every subexpression that it will use and indicate whether
161 * - it will use an auxiliary variable in \ref SCIP_DECL_NLHDLRENFO "ENFO" or \ref SCIP_DECL_NLHDLRESTIMATE "ESTIMATE",
162 * - it will use activity for some subexpressions when computing estimators or cuts, and
163 * - it will use activity for some subexpressions when in \ref SCIP_DECL_NLHDLRINTEVAL "INTEVAL" or \ref SCIP_DECL_NLHDLRREVERSEPROP "REVERSEPROP".
164 *
165 * @note Auxiliary variables do not exist in subexpressions during DETECT and are not created by a call to @ref SCIPregisterExprUsageNonlinear().
166 * They will be available when the \ref SCIP_DECL_NLHDLRINITSEPA "INITSEPA" callback is called.
167 *
168 * \param[in] scip SCIP data structure
169 * \param[in] conshdlr nonlinear constraint handler
170 * \param[in] nlhdlr nonlinear handler
171 * \param[in] expr expression to analyze
172 * \param[in] cons the constraint that expression defines, or NULL when the expr does not define any constraint, that is, when it is not the root of an expression of a constraint
173 * \param[in,out] enforcing enforcement methods that are provided by some nonlinear handler (to be updated by detect callback)
174 * \param[out] participating enforcement methods that this nonlinear handler should be called for (to be set by detect callback), initialized to SCIP_NLHDLR_METHOD_NONE
175 * \param[out] nlhdlrexprdata nlhdlr's expr data to be stored in expr, can only be set to non-NULL if success is set to TRUE
176 */
177#define SCIP_DECL_NLHDLRDETECT(x) SCIP_RETCODE x (\
178 SCIP* scip, \
179 SCIP_CONSHDLR* conshdlr, \
180 SCIP_NLHDLR* nlhdlr, \
181 SCIP_EXPR* expr, \
182 SCIP_CONS* cons, \
183 SCIP_NLHDLR_METHOD* enforcing, \
184 SCIP_NLHDLR_METHOD* participating, \
185 SCIP_NLHDLREXPRDATA** nlhdlrexprdata)
186
187/** auxiliary evaluation callback of nonlinear handler
188 *
189 * Evaluates the expression w.r.t. the auxiliary variables that were introduced by the nonlinear handler (if any).
190 * The method is used to determine the violation of the relation that the nonlinear handler attempts to enforce.
191 * During enforcement, this violation value is used to decide whether estimation/separation callbacks should be called.
192 *
193 * It can be assumed that the expression itself has been evaluated in the given sol.
194 *
195 * \param[in] scip SCIP data structure
196 * \param[in] nlhdlr nonlinear handler
197 * \param[in] expr expression to evaluate
198 * \param[in] nlhdlrexprdata expression specific data of the nonlinear handler
199 * \param[out] auxvalue buffer to store value of expression w.r.t. auxiliary variables
200 * \param[in] sol point to evaluate
201 */
202#define SCIP_DECL_NLHDLREVALAUX(x) SCIP_RETCODE x (\
203 SCIP* scip, \
204 SCIP_NLHDLR* nlhdlr, \
205 SCIP_EXPR* expr, \
206 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
207 SCIP_Real* auxvalue, \
208 SCIP_SOL* sol)
209
210/** nonlinear handler interval evaluation (activity computation) callback
211 *
212 * The method computes an interval that contains the image (range) of the expression.
213 *
214 * \param[in] scip SCIP main data structure
215 * \param[in] nlhdlr nonlinear handler
216 * \param[in] expr expression
217 * \param[in] nlhdlrexprdata expression specific data of the nonlinear handler
218 * \param[in,out] interval buffer where to store interval (on input: current interval for expr, on output: computed interval for expr)
219 * \param[in] intevalvar callback to be called when interval evaluating a variable
220 * \param[in] intevalvardata data to be passed to intevalvar callback
221 */
222#define SCIP_DECL_NLHDLRINTEVAL(x) SCIP_RETCODE x (\
223 SCIP* scip, \
224 SCIP_NLHDLR* nlhdlr, \
225 SCIP_EXPR* expr, \
226 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
227 SCIP_INTERVAL* interval, \
228 SCIP_DECL_EXPR_INTEVALVAR((*intevalvar)), \
229 void* intevalvardata)
230
231/** nonlinear handler callback for reverse propagation
232 *
233 * The method propagates the given bounds over the arguments of an expression.
234 * The arguments of an expression are other expressions and the tighter intervals should be passed
235 * to the corresponding argument (expression) via SCIPtightenExprIntervalNonlinear().
236 *
237 * \param[in] scip SCIP main data structure
238 * \param[in] conshdlr nonlinear constraint handler
239 * \param[in] nlhdlr nonlinear handler
240 * \param[in] expr expression
241 * \param[in] nlhdlrexprdata expression specific data of the nonlinear handler
242 * \param[in] bounds the bounds on the expression that should be propagated
243 * \param[out] infeasible buffer to store whether an expression's bounds were propagated to an empty interval
244 * \param[out] nreductions buffer to store the number of interval reductions of all children
245 */
246#define SCIP_DECL_NLHDLRREVERSEPROP(x) SCIP_RETCODE x (\
247 SCIP* scip, \
248 SCIP_CONSHDLR* conshdlr, \
249 SCIP_NLHDLR* nlhdlr, \
250 SCIP_EXPR* expr, \
251 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
252 SCIP_INTERVAL bounds, \
253 SCIP_Bool* infeasible, \
254 int* nreductions)
255
256/** separation initialization method of a nonlinear handler (called during CONSINITLP)
257 *
258 * The method shall initialize the separation data of the nonlinear handler, if any, and add initial cuts to the LP relaxation.
259 *
260 * \param[in] scip SCIP main data structure
261 * \param[in] conshdlr nonlinear constraint handler
262 * \param[in] cons nonlinear constraint
263 * \param[in] nlhdlr nonlinear handler
264 * \param[in] nlhdlrexprdata exprdata of nonlinear handler
265 * \param[in] expr expression
266 * \param[in] overestimate whether the expression needs to be overestimated
267 * \param[in] underestimate whether the expression needs to be underestimated
268 * \param[out] infeasible buffer to store whether infeasibility was detected while building the LP
269 */
270#define SCIP_DECL_NLHDLRINITSEPA(x) SCIP_RETCODE x (\
271 SCIP* scip, \
272 SCIP_CONSHDLR* conshdlr, \
273 SCIP_CONS* cons, \
274 SCIP_NLHDLR* nlhdlr, \
275 SCIP_EXPR* expr, \
276 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
277 SCIP_Bool overestimate, \
278 SCIP_Bool underestimate, \
279 SCIP_Bool* infeasible)
280
281/** separation deinitialization method of a nonlinear handler (called during CONSEXITSOL)
282 *
283 * The method shall deinitialize the separation data of the nonlinear handler, if any.
284 *
285 * \param[in] scip SCIP main data structure
286 * \param[in] nlhdlr nonlinear handler
287 * \param[in] nlhdlrexprdata exprdata of nonlinear handler
288 * \param[in] expr expression
289 */
290#define SCIP_DECL_NLHDLREXITSEPA(x) SCIP_RETCODE x (\
291 SCIP* scip, \
292 SCIP_NLHDLR* nlhdlr, \
293 SCIP_EXPR* expr, \
294 SCIP_NLHDLREXPRDATA* nlhdlrexprdata)
295
296/** nonlinear handler separation and enforcement callback
297 *
298 * The method tries to separate the given solution from the set defined by either
299 * <pre>
300 * expr - auxvar <= 0 (if !overestimate)
301 * </pre>
302 * or
303 * <pre>
304 * expr - auxvar >= 0 (if overestimate),
305 * </pre>
306 * where `auxvar = SCIPgetExprAuxVarNonlinear(expr)`.
307 *
308 * It can do so by
309 * - separation, i.e., finding an affine hyperplane (a cut) that separates the given point,
310 * - bound tightening, i.e., changing bounds on a variable so that the given point is outside the updated domain,
311 * - adding branching scores to potentially split the current problem into 2 subproblems
312 *
313 * If parameter `inenforcement` is FALSE, then only the first option (separation) is allowed.
314 *
315 * If the nonlinear handler always separates by computing a linear under- or overestimator of expr,
316 * then it could be advantageous to implement the \ref SCIP_DECL_NLHDLRESTIMATE "ESTIMATE" callback instead.
317 *
318 * Note, that the nonlinear handler may also choose to separate for a relaxation of the mentioned sets,
319 * e.g., `expr` &le; upperbound(`auxvar`) or `expr` &ge; lowerbound(`auxvar`).
320 * This is especially useful in situations where `expr` is the root expression of a constraint
321 * and it is sufficient to satisfy `lhs` &le; `expr` &le; `rhs`.
322 * cons_nonlinear ensures that `lhs` &le; lowerbound(`auxvar`) and upperbound(`auxvar`) &le; `rhs`.
323 *
324 * cons_nonlinear may call this callback first with `allowweakcuts` = FALSE and repeat later with
325 * `allowweakcuts` = TRUE, if it didn't succeed to enforce a solution without using weak cuts.
326 * If in enforcement and the nonlinear handler cannot enforce by separation or bound tightening, it should register
327 * branching scores for those expressions where branching may help to compute tighter cuts in children.
328 * If `branchcandonly`, then cons_nonlinear is interested in collecting potential branching candidates only
329 * (in order to decide whether to enforce nonlinear constraints before integrality). Therefore, in this situation,
330 * the nlhdlr should not do anything if it normally (`branchcandonly`=FALSE) were to separate or tighten bounds.
331 * (Since in the normal mode it will only add branching candidates if it does no separation/tightening.)
332 * In other words, with `branchcandonly` = TRUE, the nlhdlr should follow the same logic as for
333 * `branchcandonly` = FALSE, but skip the addition of cuts or bound tightenings.
334 *
335 * The nonlinear handler must set `result` to \ref SCIP_SEPARATED if it added a cut,
336 * to \ref SCIP_REDUCEDDOM if it added a bound change,
337 * to \ref SCIP_CUTOFF if it found the current node infeasible, and
338 * to \ref SCIP_BRANCHED if it added branching scores.
339 * Otherwise, it may set result to \ref SCIP_DIDNOTRUN or \ref SCIP_DIDNOTFIND.
340 * If `branchcandonly`, then SCIP_SEPARATED and SCIP_REDUCEDDOM are not allowed.
341 *
342 * Parameter `cons` gives the constraint that is currently enforced.
343 * Note that `expr` does not need to be the root of this constraint, i.e., `SCIPgetExprNonlinear(cons)==expr` may not hold.
344 * If an expression appears in several constraints, it is not well defined which constraint is given in `cons`.
345 * The main purpose of `cons` is to provide a constraint source for LP rows that are added in this callback.
346 *
347 * \param[in] scip SCIP main data structure
348 * \param[in] conshdlr nonlinear constraint handler
349 * \param[in] cons nonlinear constraint that is currently enforced
350 * \param[in] nlhdlr nonlinear handler
351 * \param[in] expr expression
352 * \param[in] nlhdlrexprdata expression specific data of the nonlinear handler
353 * \param[in] sol solution to be separated (NULL for the LP solution)
354 * \param[in] auxvalue current value of expression w.r.t. auxiliary variables as obtained from \ref SCIP_DECL_NLHDLREVALAUX "EVALAUX"
355 * \param[in] overestimate whether the expression needs to be over- or underestimated
356 * \param[in] allowweakcuts whether we should only look for "strong" cuts, or anything that separates is fine
357 * \param[in] separated whether another nonlinear handler already added a cut for this expression
358 * \param[in] inenforcement whether we are in enforcement, or only in separation
359 * \param[in] branchcandonly whether to generate branching candidates only (no separation or propagation; detecting infeasibility is ok)
360 * \param[out] result pointer to store the result
361 */
362#define SCIP_DECL_NLHDLRENFO(x) SCIP_RETCODE x (\
363 SCIP* scip, \
364 SCIP_CONSHDLR* conshdlr, \
365 SCIP_CONS* cons, \
366 SCIP_NLHDLR* nlhdlr, \
367 SCIP_EXPR* expr, \
368 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
369 SCIP_SOL* sol, \
370 SCIP_Real auxvalue, \
371 SCIP_Bool overestimate, \
372 SCIP_Bool allowweakcuts, \
373 SCIP_Bool separated, \
374 SCIP_Bool addbranchscores, \
375 SCIP_Bool branchcandonly, \
376 SCIP_RESULT* result)
377
378/** nonlinear handler under/overestimation callback
379 *
380 * The method tries to compute linear under- or overestimators of `expr` that are as tight as possible at a given point.
381 * Note that the cons_nonlinear handler adds an auxvar into a rowprep automatically after this callback.
382 * Therefore, the rowprep should only store the estimator in this callback.
383 * If the value of the estimator in the solution is smaller (larger) than `targetvalue`
384 * when underestimating (overestimating), then no estimator needs to be computed.
385 * Note, that `targetvalue` can be infinite if any estimator will be accepted.
386 * If successful, it shall store the estimators in the given `rowpreps` data structure and set the
387 * `rowprep->local` flag accordingly (SCIProwprepSetLocal()).
388 * The sidetype of a rowprep must be set to \ref SCIP_SIDETYPE_LEFT if overestimating and
389 * \ref SCIP_SIDETYPE_RIGHT if underestimating.
390 *
391 * If the callback is required to indicate for which expression a reduction in the local bounds (usually by branching)
392 * would improve the estimator, it shall do so via calls to SCIPaddExprsViolScoreNonlinear().
393 *
394 * \param[in] scip SCIP main data structure
395 * \param[in] conshdlr constraint handler
396 * \param[in] nlhdlr nonlinear handler
397 * \param[in] expr expression
398 * \param[in] nlhdlrexprdata expression data of nonlinear handler
399 * \param[in] sol solution at which to estimate (NULL for the LP solution)
400 * \param[in] auxvalue current value of expression w.r.t. auxiliary variables as obtained from \ref SCIP_DECL_NLHDLREVALAUX "EVALAUX"
401 * \param[in] overestimate whether the expression needs to be over- or underestimated
402 * \param[in] targetvalue a value the estimator shall exceed, can be +/-infinity
403 * \param[in] addbranchscores indicates whether to register branching scores
404 * \param[out] rowpreps an array where to store the estimators
405 * \param[out] success buffer to indicate whether an estimator could be computed
406 * \param[out] addedbranchscores buffer to store whether the branching score callback was successful
407 */
408#define SCIP_DECL_NLHDLRESTIMATE(x) SCIP_RETCODE x (\
409 SCIP* scip, \
410 SCIP_CONSHDLR* conshdlr, \
411 SCIP_NLHDLR* nlhdlr, \
412 SCIP_EXPR* expr, \
413 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
414 SCIP_SOL* sol, \
415 SCIP_Real auxvalue, \
416 SCIP_Bool overestimate, \
417 SCIP_Real targetvalue, \
418 SCIP_Bool addbranchscores, \
419 SCIP_PTRARRAY* rowpreps, \
420 SCIP_Bool* success, \
421 SCIP_Bool* addedbranchscores)
422
423/** nonlinear handler solution linearization callback
424 *
425 * The callback is called when a new feasible solution has been found.
426 * The nonlinear handler may add tight estimates on its nonlinear function to the cut pool of SCIP.
427 *
428 * \param[in] scip SCIP main data structure
429 * \param[in] conshdlr constraint handler
430 * \param[in] cons a nonlinear constraint which includes expression
431 * \param[in] nlhdlr nonlinear handler
432 * \param[in] expr expression
433 * \param[in] nlhdlrexprdata expression data of nonlinear handler
434 * \param[in] sol solution that has been found
435 * \param[in] solisbest whether solution is new best solution (incumbent)
436 * \param[in] overestimate whether the expression needs is overestimated by the nlhdlr
437 * \param[in] underestimate whether the expression needs is underestimated by the nlhdlr
438 */
439#define SCIP_DECL_NLHDLRSOLLINEARIZE(x) SCIP_RETCODE x (\
440 SCIP* scip, \
441 SCIP_CONSHDLR* conshdlr, \
442 SCIP_CONS* cons, \
443 SCIP_NLHDLR* nlhdlr, \
444 SCIP_EXPR* expr, \
445 SCIP_NLHDLREXPRDATA* nlhdlrexprdata, \
446 SCIP_SOL* sol, \
447 SCIP_Bool solisbest, \
448 SCIP_Bool overestimate, \
449 SCIP_Bool underestimate)
450
451typedef struct SCIP_Nlhdlr SCIP_NLHDLR; /**< nonlinear handler */
452typedef struct SCIP_NlhdlrData SCIP_NLHDLRDATA; /**< nonlinear handler data */
453typedef struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA; /**< nonlinear handler data for a specific expression */
454
455#endif /* SCIP_TYPE_NLHDLR_H_ */
SCIP_Nlhdlr
Definition: struct_nlhdlr.h:44
type_cons.h
type definitions for constraints and constraint handlers
type_expr.h
type and macro definitions related to algebraic expressions
type_misc.h
type definitions for miscellaneous datastructures
SCIP_NLHDLRDATA
struct SCIP_NlhdlrData SCIP_NLHDLRDATA
Definition: type_nlhdlr.h:452
SCIP_NLHDLR_METHOD
unsigned int SCIP_NLHDLR_METHOD
Definition: type_nlhdlr.h:57
SCIP_NLHDLREXPRDATA
struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA
Definition: type_nlhdlr.h:453