302 * | initial | set this to `TRUE` if you want the constraint to occur in the root problem |
303 * | separate | set this to `TRUE` if you would like the handler to separate, e.g. generate cuts |
304 * | enforce | set this to `TRUE` if you would like the handler to enforce solutions. This means that when the handler declares an LP or pseudo solution as infeasible, it can resolve infeasibility by adding cuts, reducing the domain of a variable, performing a branching, etc. |
305 * | check | set this to `TRUE` if the constraint handler should check solutions |
306 * | propagate | set this to `TRUE` if you want to propagate solutions, this means tighten variables domains based on constraint information |
307 * | local | set this to `TRUE` if the constraint is only locally valid, e.g., generated in a branch and bound node |
308 * | modifiable | set this to `TRUE` if the constraint may be modified during solution process, e.g. new variables may be added (colum generation) |
309 * | dynamic | set this to `TRUE` if this constraint is subject to aging, this means it will be removed after being inactive for a while (you should also say `TRUE` to removable in that case) removable set this to `TRUE` to allow the deletion of the relaxation of the constraint from the LP |
310 * | stickingatnode | set this to `TRUE` if you want the constraint to be kept at the node it was added |
311 *
312 * Variables which are not added at the creation time of the constraint can
313 * be added by calling:
314 *
315 * SCIP_CALL_EXC(SCIPaddCoefLinear(scip, cons, var, 1.0));
316 *
317 * Here “1.0” is the matrix coefficient.
318 *
319 * ### Solving the problem
320 *
321 * When the problem is setup completely we can solve it. This is done by
322 *
323 * SCIP_CALL_EXC(SCIPsolve(scip));
324 *
325 * SCIP then starts transforming and preprocessing the problem. After that
326 * it enters the solving stage where the root LP is solved, heuristics are
327 * run, cuts are generated, and the branching process starts. All plugins
328 * you wrote (heuristics, separators, etc.) will be called by SCIP through
329 * callback functions at this stage.
330 *
331 * ### Accessing results
332 *
333 * Now that the problem is solved, we want to know the solution data.
334 * Whether the problem has been solved to optimality, only feasible
335 * solutions were found, and so on, can be queried by SCIPgetStatus(). We
336 * ignore this in our queens solver and start with the best solution found
337 * so far. This can be accessed by
338 *
339 * SCIP_SOL* sol = SCIPgetBestSol(scip);
340 *
341 * If SCIP did not find a solution `sol` is equal to `0`. Otherwise, you
342 * can get the objective value by SCIPgetSolOrigObj(). In the queens
343 * example we want to know whether a queen is placed on a field or not.
344 * Therefore we need the value of the variable \f$x_{i,j}\f$ which can be
345 * accessed by SCIPgetSolVal(). In the case of an integer or binary
346 * variable, care must be taken, because this functions returns double
347 * values. So if we want to query a binary variable we use the following:
348 *
349 * if (sol == NULL)
350 * {
351 * // output error message here and abort
352 * }
353 * if ( SCIPgetSolVal(scip, sol, var) > 0.5 )
354 * {
355 * // value is one
356 * }
357 * else
358 * {
359 * // value is zero
360 * }
361 *
362 * In this example, we of course use the knowledge that variables have 0/1
363 * values only. There are special SCIP functions for performing numerical
364 * comparisons between values that are not known to be integer. For
365 * instance, you can use `SCIPisFeasEQ(scip, x, y)` for comparing whether
366 * \f$x\f$ is equal to \f$y\f$ within the feasibility tolerance of SCIP. This macro
367 * return `TRUE` if \f$|x - y| < \epsilon\f$, where \f$\epsilon\f$ is the feasibility
368 * tolerance of SCIP (by default \f$\epsilon = 10^{-6}\f$).
369 *
370 * ### Freeing the SCIP environment
371 *
372 * Finally, we must free all the memory SCIP used. When we created the
373 * variables and constraints, the SCIPcreateVar() and SCIPcreateCons()
374 * captured the corresponding variables and constraints. This means that
375 * SCIP knows that we have a pointer to these and will only free the memory
376 * if we tell it that we do not need these pointers anymore. This is done
377 * by the `SCIPrelease` functions. So before we can free the `SCIP`