Scippy

SCIP

Solving Constraint Integer Programs

dialog_default.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-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 dialog_default.c
26 * @ingroup OTHER_CFILES
27 * @brief default user interface dialog
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 * @author Gerald Gamrath
31 */
32
33/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34
35#include "blockmemshell/memory.h"
36#include "scip/cons_linear.h"
37#include "scip/dialog_default.h"
38#include "scip/pub_benders.h"
39#include "scip/pub_branch.h"
40#include "scip/pub_compr.h"
41#include "scip/pub_conflict.h"
42#include "scip/pub_cons.h"
43#include "scip/pub_cutsel.h"
44#include "scip/pub_dialog.h"
45#include "scip/pub_disp.h"
46#include "scip/pub_expr.h"
47#include "scip/pub_heur.h"
48#include "scip/pub_message.h"
49#include "scip/pub_misc.h"
50#include "scip/pub_misc_sort.h"
51#include "scip/pub_nodesel.h"
52#include "scip/pub_paramset.h"
53#include "scip/pub_presol.h"
54#include "scip/pub_pricer.h"
55#include "scip/pub_prop.h"
56#include "scip/pub_reader.h"
57#include "scip/pub_relax.h"
58#include "scip/pub_sepa.h"
59#include "scip/pub_sol.h"
60#include "scip/pub_var.h"
61#include "scip/scip_benders.h"
62#include "scip/scip_branch.h"
63#include "scip/scip_compr.h"
64#include "scip/scip_conflict.h"
65#include "scip/scip_cons.h"
66#include "scip/scip_cutsel.h"
67#include "scip/scip_dialog.h"
68#include "scip/scip_disp.h"
69#include "scip/scip_expr.h"
70#include "scip/scip_general.h"
71#include "scip/scip_heur.h"
72#include "scip/scip_lp.h"
73#include "scip/scip_mem.h"
74#include "scip/scip_message.h"
75#include "scip/scip_nlp.h"
76#include "scip/scip_nlpi.h"
77#include "scip/scip_nodesel.h"
78#include "scip/scip_numerics.h"
79#include "scip/scip_param.h"
80#include "scip/scip_presol.h"
81#include "scip/scip_pricer.h"
82#include "scip/scip_prob.h"
83#include "scip/scip_prop.h"
84#include "scip/scip_reader.h"
85#include "scip/scip_relax.h"
86#include "scip/scip_sepa.h"
87#include "scip/scip_sol.h"
88#include "scip/scip_solve.h"
89#include "scip/scip_solvingstats.h"
90#include "scip/scip_validation.h"
91#include "scip/scip_var.h"
92#include <stdlib.h>
93#include <string.h>
94
95
96/** executes a menu dialog */
97static
98SCIP_RETCODE dialogExecMenu(
99 SCIP* scip, /**< SCIP data structure */
100 SCIP_DIALOG* dialog, /**< dialog menu */
101 SCIP_DIALOGHDLR* dialoghdlr, /**< dialog handler */
102 SCIP_DIALOG** nextdialog /**< pointer to store next dialog to execute */
103 )
104{
105 char* command;
106 SCIP_Bool again;
107 SCIP_Bool endoffile;
108 int nfound;
109
110 do
111 {
112 again = FALSE;
113
114 /* get the next word of the command string */
115 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, NULL, &command, &endoffile) );
116 if( endoffile )
117 {
118 *nextdialog = NULL;
119 return SCIP_OKAY;
120 }
121
122 /* exit to the root dialog, if command is empty */
123 if( command[0] == '\0' )
124 {
125 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
126 return SCIP_OKAY;
127 }
128 else if( strcmp(command, "..") == 0 )
129 {
130 *nextdialog = SCIPdialogGetParent(dialog);
131 if( *nextdialog == NULL )
132 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
133 return SCIP_OKAY;
134 }
135
136 /* find command in dialog */
137 nfound = SCIPdialogFindEntry(dialog, command, nextdialog);
138
139 /* check result */
140 if( nfound == 0 )
141 {
142 SCIPdialogMessage(scip, NULL, "command <%s> not available\n", command);
143 SCIPdialoghdlrClearBuffer(dialoghdlr);
144 *nextdialog = dialog;
145 }
146 else if( nfound >= 2 )
147 {
148 SCIPdialogMessage(scip, NULL, "\npossible completions:\n");
149 SCIP_CALL( SCIPdialogDisplayCompletions(dialog, scip, command) );
150 SCIPdialogMessage(scip, NULL, "\n");
151 SCIPdialoghdlrClearBuffer(dialoghdlr);
152 again = TRUE;
153 }
154 }
155 while( again );
156
157 return SCIP_OKAY;
158}
159
160
161/* parse the given string to detect a Boolean value and returns it */
162static
163SCIP_Bool parseBoolValue(
164 SCIP* scip, /**< SCIP data structure */
165 const char* valuestr, /**< string to parse */
166 SCIP_Bool* error /**< pointer to store the error result */
167 )
168{
169 assert( scip != NULL );
170 assert( valuestr != NULL );
171 assert( error != NULL );
172
173 *error = FALSE;
174
175 switch( valuestr[0] )
176 {
177 case 'f':
178 case 'F':
179 case '0':
180 case 'n':
181 case 'N':
182 return FALSE;
183 case 't':
184 case 'T':
185 case '1':
186 case 'y':
187 case 'Y':
188 return TRUE;
189 default:
190 *error = TRUE;
191 break;
192 }
193
194 return FALSE;
195}
196
197
198/* display the reader information */
199static
200void displayReaders(
201 SCIP* scip, /**< SCIP data structure */
202 SCIP_Bool reader, /**< display reader which can read */
203 SCIP_Bool writer /**< display reader which can write */
204 )
205{
206 SCIP_READER** readers;
207 int nreaders;
208 int r;
209
210 assert( scip != NULL );
211
212 readers = SCIPgetReaders(scip);
213 nreaders = SCIPgetNReaders(scip);
214
215 /* display list of readers */
216 SCIPdialogMessage(scip, NULL, "\n");
217 SCIPdialogMessage(scip, NULL, " file reader extension description\n");
218 SCIPdialogMessage(scip, NULL, " ----------- --------- -----------\n");
219 for( r = 0; r < nreaders; ++r )
220 {
221 if( (reader && SCIPreaderCanRead(readers[r])) || (writer && SCIPreaderCanWrite(readers[r])) )
222 {
223 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPreaderGetName(readers[r]));
224 if( strlen(SCIPreaderGetName(readers[r])) > 20 )
225 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
226 SCIPdialogMessage(scip, NULL, "%9s ", SCIPreaderGetExtension(readers[r]));
227 SCIPdialogMessage(scip, NULL, "%s", SCIPreaderGetDesc(readers[r]));
228 SCIPdialogMessage(scip, NULL, "\n");
229 }
230 }
231 SCIPdialogMessage(scip, NULL, "\n");
232}
233
234
235/* writes problem to file */
236static
237SCIP_RETCODE writeProblem(
238 SCIP* scip, /**< SCIP data structure */
239 SCIP_DIALOG* dialog, /**< dialog menu */
240 SCIP_DIALOGHDLR* dialoghdlr, /**< dialog handler */
241 SCIP_DIALOG** nextdialog, /**< pointer to store next dialog to execute */
242 SCIP_Bool transformed, /**< output the transformed problem? */
243 SCIP_Bool genericnames /**< using generic variable and constraint names? */
244 )
245{
246 char* filename;
247 SCIP_Bool endoffile;
248 SCIP_RETCODE retcode;
249
250 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
251 if( endoffile )
252 {
253 *nextdialog = NULL;
254 return SCIP_OKAY;
255 }
256
257 if( filename[0] != '\0' )
258 {
259 char* tmpfilename;
260 char* extension;
261
262 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
263
264 /* copy filename */
265 SCIP_CALL( SCIPduplicateBufferArray(scip, &tmpfilename, filename, (int)strlen(filename)+1) );
266 extension = NULL;
267
268 do
269 {
270 if( transformed )
271 retcode = SCIPwriteTransProblem(scip, tmpfilename, extension, genericnames);
272 else
273 retcode = SCIPwriteOrigProblem(scip, tmpfilename, extension, genericnames);
274
275 if( retcode == SCIP_FILECREATEERROR )
276 {
277 SCIPdialogMessage(scip, NULL, "error creating the file <%s>\n", filename);
278 SCIPdialoghdlrClearBuffer(dialoghdlr);
279 break;
280 }
281 else if(retcode == SCIP_WRITEERROR )
282 {
283 SCIPdialogMessage(scip, NULL, "error writing file <%s>\n", filename);
284 SCIPdialoghdlrClearBuffer(dialoghdlr);
285 break;
286 }
287 else if( retcode == SCIP_PLUGINNOTFOUND )
288 {
289 /* ask user once for a suitable reader */
290 if( extension == NULL )
291 {
292 SCIPdialogMessage(scip, NULL, "no reader for requested output format\n");
293
294 SCIPdialogMessage(scip, NULL, "The following readers are available for writing:\n");
295 displayReaders(scip, FALSE, TRUE);
296
297 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog,
298 "select a suitable reader by extension (or return): ", &extension, &endoffile) );
299
300 if( extension[0] == '\0' )
301 break;
302 }
303 else
304 {
305 SCIPdialogMessage(scip, NULL, "no reader for output in <%s> format\n", extension);
306 extension = NULL;
307 }
308 }
309 else
310 {
311 /* check for unexpected errors */
312 SCIP_CALL( retcode );
313
314 /* print result message if writing was successful */
315 if( transformed )
316 SCIPdialogMessage(scip, NULL, "written transformed problem to file <%s>\n", tmpfilename);
317 else
318 SCIPdialogMessage(scip, NULL, "written original problem to file <%s>\n", tmpfilename);
319 break;
320 }
321 }
322 while( extension != NULL );
323
324 SCIPfreeBufferArray(scip, &tmpfilename);
325 }
326
327 return SCIP_OKAY;
328}
329
330/** copy method for dialog plugins (called when SCIP copies plugins) */
331static
332SCIP_DECL_DIALOGCOPY(dialogCopyDefault)
333{ /*lint --e{715}*/
334 assert(scip != NULL);
335 assert(dialog != NULL);
336
337 /* call inclusion method of basic dialog entries
338 * "set" and "fix" dialog entries will be added when SCIPstartInteraction() is called on target SCIP
339 */
340 SCIP_CALL( SCIPincludeDialogDefaultBasic(scip) );
341
342 return SCIP_OKAY;
343}
344
345/** standard menu dialog execution method, that displays it's help screen if the remaining command line is empty */
346SCIP_DECL_DIALOGEXEC(SCIPdialogExecMenu)
347{ /*lint --e{715}*/
348 /* if remaining command string is empty, display menu of available options */
349 if( SCIPdialoghdlrIsBufferEmpty(dialoghdlr) )
350 {
351 SCIPdialogMessage(scip, NULL, "\n");
352 SCIP_CALL( SCIPdialogDisplayMenu(dialog, scip) );
353 SCIPdialogMessage(scip, NULL, "\n");
354 }
355
356 SCIP_CALL( dialogExecMenu(scip, dialog, dialoghdlr, nextdialog) );
357
358 return SCIP_OKAY;
359}
360
361/** standard menu dialog execution method, that doesn't display it's help screen */
362SCIP_DECL_DIALOGEXEC(SCIPdialogExecMenuLazy)
363{ /*lint --e{715}*/
364 SCIP_CALL( dialogExecMenu(scip, dialog, dialoghdlr, nextdialog) );
365
366 return SCIP_OKAY;
367}
368
369/** dialog execution method for the change add constraint */
370SCIP_DECL_DIALOGEXEC(SCIPdialogExecChangeAddCons)
371{ /*lint --e{715}*/
372 assert( scip != NULL );
373
374 if( SCIPgetStage(scip) > SCIP_STAGE_PROBLEM )
375 SCIPdialogMessage(scip, NULL, "cannot call method after problem was transformed\n");
376 else if( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
377 SCIPdialogMessage(scip, NULL, "cannot call method before problem was created\n");
378 else
379 {
380 SCIP_CONS* cons;
381 SCIP_Bool endoffile;
382 char* str;
383
384 cons = NULL;
385
386 SCIP_CALL( SCIPdialoghdlrGetLine(dialoghdlr, dialog, "write constraint in <cip> format\n", &str, &endoffile) );
387
388 if( str[0] != '\0' )
389 {
390 SCIP_Bool success;
391
392 printf("<%s>\n", str);
393
394 SCIP_CALL( SCIPparseCons(scip, &cons, str, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, &success) );
395
396 if( success )
397 {
398 char consstr[SCIP_MAXSTRLEN];
399
400 /* add and release constraint */
401 SCIP_CALL( SCIPaddCons(scip, cons) );
402 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
403
404 SCIPdialogMessage(scip, NULL, "successfully added constraint\n");
405 SCIPescapeString(consstr, SCIP_MAXSTRLEN, str);
406
407 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, consstr, FALSE) );
408 }
409 else
410 {
411 SCIPdialogMessage(scip, NULL, "constraint was not recognizable\n");
412 }
413 }
414 }
415
416 /* set root dialog as next dialog */
417 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
418
419 return SCIP_OKAY;
420}
421
422/** dialog execution method for the change bounds command */
423SCIP_DECL_DIALOGEXEC(SCIPdialogExecChangeBounds)
424{ /*lint --e{715}*/
425 assert( scip != NULL );
426
427 if( SCIPgetStage(scip) > SCIP_STAGE_PROBLEM )
428 SCIPdialogMessage(scip, NULL, "cannot call method after problem was transformed\n");
429 else if( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
430 SCIPdialogMessage(scip, NULL, "cannot call method before problem was created\n");
431 else
432 {
433 SCIP_VAR* var;
434 SCIP_Bool endoffile;
435 char* varname;
436
437 var = NULL;
438
439 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
440
441 do
442 {
443 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter variable name: ", &varname, &endoffile) );
444
445 /* if we get a return or we reached the end of the file, then we stop */
446 if( varname[0] == '\0' || endoffile )
447 break;
448
449 var = SCIPfindVar(scip, varname);
450
451 if( var == NULL )
452 SCIPdialogMessage(scip, NULL, "variable <%s> does not exist\n", varname);
453 }
454 while( var == NULL );
455
456 if( var != NULL )
457 {
458 do
459 {
460 char* boundstr;
461 char message[SCIP_MAXSTRLEN];
462 SCIP_Real bound;
463
464 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, varname, FALSE) );
465
466 (void)SCIPsnprintf(message, SCIP_MAXSTRLEN, "current lower bound <%.15g> (Return to skip): ", SCIPvarGetLbGlobal(var));
467 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, message, &boundstr, &endoffile) );
468
469 /* if we reached the end of the file, then we stop */
470 if( endoffile )
471 break;
472
473 if( boundstr[0] != '\0' )
474 {
475 char* endptr;
476
477 bound = strtod(boundstr, &endptr);
478 if( endptr == boundstr || *endptr != '\0' )
479 {
480 printf("<%s> <%s>\n", endptr, boundstr);
481 SCIPdialogMessage(scip, NULL, "ignore none value string\n");
482 }
483 else if( SCIPisGT(scip, bound, SCIPvarGetUbGlobal(var)) )
484 {
485 SCIPdialogMessage(scip, NULL, "ignore lower bound <%.15g> since it is larger than the current upper bound <%.15g>\n",
486 bound, SCIPvarGetUbGlobal(var));
487 }
488 else
489 {
490 SCIP_CALL( SCIPchgVarLbGlobal(scip, var, bound) );
491 }
492 }
493
494 (void)SCIPsnprintf(message, SCIP_MAXSTRLEN, "current upper bound <%.15g> (Return to skip): ", SCIPvarGetUbGlobal(var));
495 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, message, &boundstr, &endoffile) );
496
497 /* if we reached the end of the file, then we stop */
498 if( endoffile )
499 break;
500
501 if( boundstr[0] != '\0' )
502 {
503 char* endptr;
504
505 bound = strtod(boundstr, &endptr);
506 if( endptr == boundstr || *endptr != '\0' )
507 {
508 SCIPdialogMessage(scip, NULL, "ignore none value string\n");
509 }
510 else if( SCIPisLT(scip, bound, SCIPvarGetLbGlobal(var)) )
511 {
512 SCIPdialogMessage(scip, NULL, "ignore new upper bound <%.15g> since it is smaller than the current lower bound <%.15g>\n",
513 bound, SCIPvarGetLbGlobal(var));
514 }
515 else
516 {
517 SCIP_CALL( SCIPchgVarUbGlobal(scip, var, bound) );
518 }
519 }
520 }
521 while( FALSE);
522
523 SCIPdialogMessage(scip, NULL, "variable <%s> global bounds [%.15g,%.15g]\n", SCIPvarGetName(var), SCIPvarGetLbGlobal(var), SCIPvarGetUbGlobal(var));
524 }
525 }
526
527 /* set root dialog as next dialog */
528 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
529
530 return SCIP_OKAY;
531}
532
533/** dialog execution method for the freetransproblem command */
534SCIP_DECL_DIALOGEXEC(SCIPdialogExecChangeFreetransproblem)
535{ /*lint --e{715}*/
536 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
537
538 /* free transformed problem */
539 SCIP_CALL( SCIPfreeTransform(scip) );
540
541 /* set root dialog as next dialog */
542 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
543
544 return SCIP_OKAY;
545}
546
547/** dialog execution method for the changing the objective sense */
548SCIP_DECL_DIALOGEXEC(SCIPdialogExecChangeObjSense)
549{ /*lint --e{715}*/
550 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
551
552 if( SCIPgetStage(scip) > SCIP_STAGE_PROBLEM )
553 SCIPdialogMessage(scip, NULL, "cannot call method after problem was transformed\n");
554 else if( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
555 SCIPdialogMessage(scip, NULL, "cannot call method before problem was created\n");
556 else
557 {
558 SCIP_Bool endoffile;
559 char* objsense;
560
561 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "new objective sense {min,max}: ", &objsense, &endoffile) );
562
563 /* if we get a return or we reached the end of the file, then we stop */
564 if( objsense[0] != '\0' && !endoffile )
565 {
566 if( strncmp(objsense, "max", 3) == 0 )
567 {
568 SCIP_CALL( SCIPsetObjsense(scip, SCIP_OBJSENSE_MAXIMIZE) );
569 }
570 else if( strncmp(objsense , "min", 3) == 0 )
571 {
572 SCIP_CALL( SCIPsetObjsense(scip, SCIP_OBJSENSE_MINIMIZE) );
573 }
574 else
575 {
576 SCIPdialogMessage(scip, NULL, "invalid argument <%s>\n", objsense);
577 }
578 }
579 }
580
581 /* set root dialog as next dialog */
582 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
583
584 return SCIP_OKAY;
585}
586
587/** dialog execution method for the checksol command */
588SCIP_DECL_DIALOGEXEC(SCIPdialogExecChecksol)
589{ /*lint --e{715}*/
590 SCIP_SOL* sol;
591 SCIP_Bool feasible;
592
593 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
594
595 SCIPdialogMessage(scip, NULL, "\n");
596 if( SCIPgetStage(scip) >= SCIP_STAGE_TRANSFORMED )
597 sol = SCIPgetBestSol(scip);
598 else
599 sol = NULL;
600
601 if( sol == NULL )
602 SCIPdialogMessage(scip, NULL, "no feasible solution available\n");
603 else
604 {
605 SCIP_Real oldfeastol;
606 SCIP_Real checkfeastolfac;
607 SCIP_Bool dispallviols;
608
609 oldfeastol = SCIPfeastol(scip);
610 SCIP_CALL( SCIPgetRealParam(scip, "numerics/checkfeastolfac", &checkfeastolfac) );
611 SCIP_CALL( SCIPgetBoolParam(scip, "display/allviols", &dispallviols) );
612
613 /* scale feasibility tolerance by set->num_checkfeastolfac */
614 if( !SCIPisEQ(scip, checkfeastolfac, 1.0) )
615 {
616 SCIP_CALL( SCIPchgFeastol(scip, oldfeastol * checkfeastolfac) );
617 }
618
619 SCIPinfoMessage(scip, NULL, "check best solution\n");
620 SCIP_CALL( SCIPcheckSolOrig(scip, sol, &feasible, TRUE, dispallviols) );
621
622 /* restore old feasibilty tolerance */
623 if( !SCIPisEQ(scip, checkfeastolfac, 1.0) )
624 {
625 SCIP_CALL( SCIPchgFeastol(scip, oldfeastol) );
626 }
627
628 if( feasible )
629 SCIPdialogMessage(scip, NULL, "solution is feasible in original problem\n");
630
631 SCIPdialogMessage(scip, NULL, "%-19s: %11s %11s\n", "Violation", "absolute", "relative");
632 SCIPdialogMessage(scip, NULL, "%-19s: %11.5e %11.5e\n", " bounds", SCIPsolGetAbsBoundViolation(sol), SCIPsolGetRelBoundViolation(sol));
633 SCIPdialogMessage(scip, NULL, "%-19s: %11.5e %11s\n", " integrality", SCIPsolGetAbsIntegralityViolation(sol), "-");
634 SCIPdialogMessage(scip, NULL, "%-19s: %11.5e %11.5e\n", " LP rows", SCIPsolGetAbsLPRowViolation(sol), SCIPsolGetRelLPRowViolation(sol));
635 SCIPdialogMessage(scip, NULL, "%-19s: %11.5e %11.5e\n", " constraints", SCIPsolGetAbsConsViolation(sol), SCIPsolGetRelConsViolation(sol));
636 }
637 SCIPdialogMessage(scip, NULL, "\n");
638
639 *nextdialog = SCIPdialogGetParent(dialog);
640
641 return SCIP_OKAY;
642}
643
644/** dialog execution method for the cliquegraph command */
645SCIP_DECL_DIALOGEXEC(SCIPdialogExecCliquegraph)
646{ /*lint --e{715}*/
647 SCIP_RETCODE retcode;
648 SCIP_Bool endoffile;
649 char* filename;
650
651 assert(nextdialog != NULL);
652
653 *nextdialog = NULL;
654
655 if( !SCIPisTransformed(scip) )
656 {
657 SCIPdialogMessage(scip, NULL, "cannot call method before problem was transformed\n");
658 SCIPdialoghdlrClearBuffer(dialoghdlr);
659 }
660 else
661 {
662 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
663 if( endoffile )
664 {
665 *nextdialog = NULL;
666 return SCIP_OKAY;
667 }
668
669 if( filename[0] != '\0' )
670 {
671 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
672
673 retcode = SCIPwriteCliqueGraph(scip, filename, FALSE);
674 if( retcode == SCIP_FILECREATEERROR )
675 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
676 else
677 {
678 SCIP_CALL( retcode );
679 }
680 }
681 }
682
683 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
684
685 return SCIP_OKAY;
686}
687
688/** dialog execution method for the display benders command */
689SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayBenders)
690{ /*lint --e{715}*/
691 SCIP_BENDERS** benders;
692 int nbenders;
693 int i;
694
695 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
696
697 benders = SCIPgetBenders(scip);
698 nbenders = SCIPgetNBenders(scip);
699
700 /* display list of benders */
701 SCIPdialogMessage(scip, NULL, "\n");
702 SCIPdialogMessage(scip, NULL, " benders priority description\n");
703 SCIPdialogMessage(scip, NULL, " ---------- -------- -----------\n");
704 for( i = 0; i < nbenders; ++i )
705 {
706 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPbendersGetName(benders[i]));
707 if( strlen(SCIPbendersGetName(benders[i])) > 20 )
708 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
709 SCIPdialogMessage(scip, NULL, "%8d ", SCIPbendersGetPriority(benders[i]));
710 SCIPdialogMessage(scip, NULL, "%s", SCIPbendersGetDesc(benders[i]));
711 SCIPdialogMessage(scip, NULL, "\n");
712 }
713 SCIPdialogMessage(scip, NULL, "\n");
714
715 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
716
717 return SCIP_OKAY;
718}
719
720/** dialog execution method for the display branching command */
721SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayBranching)
722{ /*lint --e{715}*/
723 SCIP_BRANCHRULE** branchrules;
724 SCIP_BRANCHRULE** sorted;
725 int nbranchrules;
726 int i;
727
728 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
729
730 branchrules = SCIPgetBranchrules(scip);
731 nbranchrules = SCIPgetNBranchrules(scip);
732
733 /* copy branchrules array into temporary memory for sorting */
734 SCIP_CALL( SCIPduplicateBufferArray(scip, &sorted, branchrules, nbranchrules) );
735
736 /* sort the branching rules */
737 SCIPsortPtr((void**)sorted, SCIPbranchruleComp, nbranchrules);
738
739 /* display sorted list of branching rules */
740 SCIPdialogMessage(scip, NULL, "\n");
741 SCIPdialogMessage(scip, NULL, " branching rule priority maxdepth maxbddist description\n");
742 SCIPdialogMessage(scip, NULL, " -------------- -------- -------- --------- -----------\n");
743 for( i = 0; i < nbranchrules; ++i )
744 {
745 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPbranchruleGetName(sorted[i]));
746 if( strlen(SCIPbranchruleGetName(sorted[i])) > 20 )
747 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
748 SCIPdialogMessage(scip, NULL, "%8d %8d %8.1f%% ", SCIPbranchruleGetPriority(sorted[i]),
749 SCIPbranchruleGetMaxdepth(sorted[i]), 100.0 * SCIPbranchruleGetMaxbounddist(sorted[i]));
750 SCIPdialogMessage(scip, NULL, "%s", SCIPbranchruleGetDesc(sorted[i]));
751 SCIPdialogMessage(scip, NULL, "\n");
752 }
753 SCIPdialogMessage(scip, NULL, "\n");
754
755 /* free temporary memory */
756 SCIPfreeBufferArray(scip, &sorted);
757
758 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
759
760 return SCIP_OKAY;
761}
762
763/** dialog execution method for the display relaxators command */
764SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayRelaxators)
765{ /*lint --e{715}*/
766 SCIP_RELAX** relaxs;
767 SCIP_RELAX** sorted;
768 int nrelaxs;
769 int i;
770
771 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
772
773 relaxs = SCIPgetRelaxs(scip);
774 nrelaxs = SCIPgetNRelaxs(scip);
775
776 /* copy relaxs array into temporary memory for sorting */
777 if( nrelaxs != 0 )
778 {
779 SCIP_CALL( SCIPduplicateBufferArray(scip, &sorted, relaxs, nrelaxs) );
780 }
781 else
782 sorted = NULL;
783
784 /* sort the relaxators */
785 SCIPsortPtr((void**)sorted, SCIPrelaxComp, nrelaxs);
786
787 /* display sorted list of relaxators */
788 SCIPdialogMessage(scip, NULL, "\n");
789 SCIPdialogMessage(scip, NULL, " relaxator priority freq description\n");
790 SCIPdialogMessage(scip, NULL, " -------------- -------- ---- -----------\n");
791 for( i = 0; i < nrelaxs; ++i )
792 {
793 assert(sorted != NULL); /* for flexelint */
794 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPrelaxGetName(sorted[i]));
795 if( strlen(SCIPrelaxGetName(sorted[i])) > 20 )
796 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
797 SCIPdialogMessage(scip, NULL, "%8d %4d ", SCIPrelaxGetPriority(sorted[i]),
798 SCIPrelaxGetFreq(sorted[i]));
799 SCIPdialogMessage(scip, NULL, "%s", SCIPrelaxGetDesc(sorted[i]));
800 SCIPdialogMessage(scip, NULL, "\n");
801 }
802 SCIPdialogMessage(scip, NULL, "\n");
803
804 /* free temporary memory */
805 SCIPfreeBufferArrayNull(scip, &sorted);
806
807 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
808
809 return SCIP_OKAY;
810}
811
812/** dialog execution method for the display conflict command */
813SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayConflict)
814{ /*lint --e{715}*/
815 SCIP_CONFLICTHDLR** conflicthdlrs;
816 SCIP_CONFLICTHDLR** sorted;
817 int nconflicthdlrs;
818 int i;
819
820 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
821
822 conflicthdlrs = SCIPgetConflicthdlrs(scip);
823 nconflicthdlrs = SCIPgetNConflicthdlrs(scip);
824
825 /* copy conflicthdlrs array into temporary memory for sorting */
826 SCIP_CALL( SCIPduplicateBufferArray(scip, &sorted, conflicthdlrs, nconflicthdlrs) );
827
828 /* sort the conflict handlers */
829 SCIPsortPtr((void**)sorted, SCIPconflicthdlrComp, nconflicthdlrs);
830
831 /* display sorted list of conflict handlers */
832 SCIPdialogMessage(scip, NULL, "\n");
833 SCIPdialogMessage(scip, NULL, " conflict handler priority description\n");
834 SCIPdialogMessage(scip, NULL, " ---------------- -------- -----------\n");
835 for( i = 0; i < nconflicthdlrs; ++i )
836 {
837 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPconflicthdlrGetName(sorted[i]));
838 if( strlen(SCIPconflicthdlrGetName(sorted[i])) > 20 )
839 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
840 SCIPdialogMessage(scip, NULL, "%8d ", SCIPconflicthdlrGetPriority(sorted[i]));
841 SCIPdialogMessage(scip, NULL, "%s", SCIPconflicthdlrGetDesc(sorted[i]));
842 SCIPdialogMessage(scip, NULL, "\n");
843 }
844 SCIPdialogMessage(scip, NULL, "\n");
845
846 /* free temporary memory */
847 SCIPfreeBufferArray(scip, &sorted);
848
849 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
850
851 return SCIP_OKAY;
852}
853
854/** dialog execution method for the display conshdlrs command */
855SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayConshdlrs)
856{ /*lint --e{715}*/
857 SCIP_CONSHDLR** conshdlrs;
858 int nconshdlrs;
859 int i;
860
861 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
862
863 conshdlrs = SCIPgetConshdlrs(scip);
864 nconshdlrs = SCIPgetNConshdlrs(scip);
865
866 /* display list of constraint handlers */
867 SCIPdialogMessage(scip, NULL, "\n");
868 SCIPdialogMessage(scip, NULL, " Legend:\n");
869 SCIPdialogMessage(scip, NULL, " prestim (presolve timing): 'f'ast, 'm'edium, 'e'xhaustive\n\n");
870 SCIPdialogMessage(scip, NULL, " constraint handler chckprio enfoprio sepaprio sepaf propf eager prestim description\n");
871 SCIPdialogMessage(scip, NULL, " ------------------ -------- -------- -------- ----- ----- ----- ------- -----------\n");
872 for( i = 0; i < nconshdlrs; ++i )
873 {
874 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPconshdlrGetName(conshdlrs[i]));
875 if( strlen(SCIPconshdlrGetName(conshdlrs[i])) > 20 )
876 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
877 SCIPdialogMessage(scip, NULL, "%8d %8d %8d %5d %5d %5d ",
878 SCIPconshdlrGetCheckPriority(conshdlrs[i]),
879 SCIPconshdlrGetEnfoPriority(conshdlrs[i]),
880 SCIPconshdlrGetSepaPriority(conshdlrs[i]),
881 SCIPconshdlrGetSepaFreq(conshdlrs[i]),
882 SCIPconshdlrGetPropFreq(conshdlrs[i]),
883 SCIPconshdlrGetEagerFreq(conshdlrs[i]));
884 SCIPdialogMessage(scip, NULL, " %c", (SCIPconshdlrGetPresolTiming(conshdlrs[i]) & SCIP_PRESOLTIMING_FAST) ? 'f' : ' ');
885 SCIPdialogMessage(scip, NULL, "%c", (SCIPconshdlrGetPresolTiming(conshdlrs[i]) & SCIP_PRESOLTIMING_MEDIUM) ? 'm' : ' ');
886 SCIPdialogMessage(scip, NULL, "%c ", (SCIPconshdlrGetPresolTiming(conshdlrs[i]) & SCIP_PRESOLTIMING_EXHAUSTIVE) ? 'e' : ' ');
887 SCIPdialogMessage(scip, NULL, "%s", SCIPconshdlrGetDesc(conshdlrs[i]));
888 SCIPdialogMessage(scip, NULL, "\n");
889 }
890 SCIPdialogMessage(scip, NULL, "\n");
891
892 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
893
894 return SCIP_OKAY;
895}
896
897/** dialog execution method for the display displaycols command */
898SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayDisplaycols)
899{ /*lint --e{715}*/
900 SCIP_DISP** disps;
901 int ndisps;
902 int i;
903
904 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
905
906 disps = SCIPgetDisps(scip);
907 ndisps = SCIPgetNDisps(scip);
908
909 /* display list of display columns */
910 SCIPdialogMessage(scip, NULL, "\n");
911 SCIPdialogMessage(scip, NULL, " display column header position width priority status description\n");
912 SCIPdialogMessage(scip, NULL, " -------------- ------ -------- ----- -------- ------ -----------\n");
913 for( i = 0; i < ndisps; ++i )
914 {
915 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPdispGetName(disps[i]));
916 if( strlen(SCIPdispGetName(disps[i])) > 20 )
917 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
918 SCIPdialogMessage(scip, NULL, "%-16s ", SCIPdispGetHeader(disps[i]));
919 if( strlen(SCIPdispGetHeader(disps[i])) > 16 )
920 SCIPdialogMessage(scip, NULL, "\n %20s %16s ", "", "-->");
921 SCIPdialogMessage(scip, NULL, "%8d ", SCIPdispGetPosition(disps[i]));
922 SCIPdialogMessage(scip, NULL, "%5d ", SCIPdispGetWidth(disps[i]));
923 SCIPdialogMessage(scip, NULL, "%8d ", SCIPdispGetPriority(disps[i]));
924 switch( SCIPdispGetStatus(disps[i]) )
925 {
926 case SCIP_DISPSTATUS_OFF:
927 SCIPdialogMessage(scip, NULL, "%6s ", "off");
928 break;
929 case SCIP_DISPSTATUS_AUTO:
930 SCIPdialogMessage(scip, NULL, "%6s ", "auto");
931 break;
932 case SCIP_DISPSTATUS_ON:
933 SCIPdialogMessage(scip, NULL, "%6s ", "on");
934 break;
935 default:
936 SCIPdialogMessage(scip, NULL, "%6s ", "?");
937 break;
938 }
939 SCIPdialogMessage(scip, NULL, "%s", SCIPdispGetDesc(disps[i]));
940 SCIPdialogMessage(scip, NULL, "\n");
941 }
942 SCIPdialogMessage(scip, NULL, "\n");
943
944 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
945
946 return SCIP_OKAY;
947}
948
949/** dialog execution method for the display exprhdlrs command */
950SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayExprhdlrs)
951{ /*lint --e{715}*/
952 SCIP_EXPRHDLR **exprhdlrs;
953 int nexprhdlrs;
954 int i;
955
956 SCIP_CALL(SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE));
957
958 exprhdlrs = SCIPgetExprhdlrs(scip);
959 nexprhdlrs = SCIPgetNExprhdlrs(scip);
960
961 /* display list of expression handler */
962 SCIPdialogMessage(scip, NULL, "\n");
963 SCIPdialogMessage(scip, NULL, " expression handler precedence description\n");
964 SCIPdialogMessage(scip, NULL, " ------------------ ---------- -----------\n");
965 for( i = 0; i < nexprhdlrs; ++i )
966 {
967 SCIPdialogMessage(scip, NULL, " %-18s ", SCIPexprhdlrGetName(exprhdlrs[i]));
968 SCIPdialogMessage(scip, NULL, " %10u ", SCIPexprhdlrGetPrecedence(exprhdlrs[i]));
969 SCIPdialogMessage(scip, NULL, " %s", SCIPexprhdlrGetDescription(exprhdlrs[i]));
970 SCIPdialogMessage(scip, NULL, "\n");
971 }
972 SCIPdialogMessage(scip, NULL, "\n");
973
974 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
975
976 return SCIP_OKAY;
977}
978
979/** dialog execution method for the display cutselectors command */
980SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayCutselectors)
981{ /*lint --e{715}*/
982 SCIP_CUTSEL** cutsels;
983 int ncutsels;
984 int i;
985
986 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
987
988 cutsels = SCIPgetCutsels(scip);
989 ncutsels = SCIPgetNCutsels(scip);
990
991 /* display list of cut selectors */
992 SCIPdialogMessage(scip, NULL, "\n");
993 SCIPdialogMessage(scip, NULL, " cut selector priority description\n");
994 SCIPdialogMessage(scip, NULL, " ------------ -------- -----------\n");
995 for( i = 0; i < ncutsels; ++i )
996 {
997 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPcutselGetName(cutsels[i]));
998 if( strlen(SCIPcutselGetName(cutsels[i])) > 20 )
999 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1000 SCIPdialogMessage(scip, NULL, "%8d ", SCIPcutselGetPriority(cutsels[i]));
1001 SCIPdialogMessage(scip, NULL, "%s", SCIPcutselGetDesc(cutsels[i]));
1002 SCIPdialogMessage(scip, NULL, "\n");
1003 }
1004 SCIPdialogMessage(scip, NULL, "\n");
1005
1006 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1007
1008 return SCIP_OKAY;
1009}
1010
1011/** dialog execution method for the display heuristics command */
1012SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayHeuristics)
1013{ /*lint --e{715}*/
1014 SCIP_HEUR** heurs;
1015 SCIP_HEUR** sorted;
1016 int nheurs;
1017 int i;
1018
1019 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1020
1021 heurs = SCIPgetHeurs(scip);
1022 nheurs = SCIPgetNHeurs(scip);
1023
1024 /* copy heurs array into temporary memory for sorting */
1025 SCIP_CALL( SCIPduplicateBufferArray(scip, &sorted, heurs, nheurs) );
1026
1027 /* sort the heuristics */
1028 SCIPsortPtr((void**)sorted, SCIPheurCompPriority, nheurs);
1029
1030 /* display sorted list of primal heuristics */
1031 SCIPdialogMessage(scip, NULL, "\n");
1032 SCIPdialogMessage(scip, NULL, " primal heuristic c priority freq ofs description\n");
1033 SCIPdialogMessage(scip, NULL, " ---------------- - -------- ---- --- -----------\n");
1034 for( i = 0; i < nheurs; ++i )
1035 {
1036 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPheurGetName(sorted[i]));
1037 if( strlen(SCIPheurGetName(sorted[i])) > 20 )
1038 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1039 SCIPdialogMessage(scip, NULL, "%c ", SCIPheurGetDispchar(sorted[i]));
1040 SCIPdialogMessage(scip, NULL, "%8d ", SCIPheurGetPriority(sorted[i]));
1041 SCIPdialogMessage(scip, NULL, "%4d ", SCIPheurGetFreq(sorted[i]));
1042 SCIPdialogMessage(scip, NULL, "%3d ", SCIPheurGetFreqofs(sorted[i]));
1043 SCIPdialogMessage(scip, NULL, "%s", SCIPheurGetDesc(sorted[i]));
1044 SCIPdialogMessage(scip, NULL, "\n");
1045 }
1046 SCIPdialogMessage(scip, NULL, "\n");
1047
1048 /* free temporary memory */
1049 SCIPfreeBufferArray(scip, &sorted);
1050
1051 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1052
1053 return SCIP_OKAY;
1054}
1055
1056/** dialog execution method for the display memory command */
1057SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayMemory)
1058{ /*lint --e{715}*/
1059 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1060
1061 SCIPdialogMessage(scip, NULL, "\n");
1062 SCIPprintMemoryDiagnostic(scip);
1063 SCIPdialogMessage(scip, NULL, "\n");
1064
1065 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1066
1067 return SCIP_OKAY;
1068}
1069
1070/** dialog execution method for the display nlpi command */
1071SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayNlpi)
1072{ /*lint --e{715}*/
1073 SCIP_NLPI** nlpis;
1074 SCIP_NLPI** sorted;
1075 int nnlpis;
1076 int i;
1077
1078 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1079
1080 nlpis = SCIPgetNlpis(scip);
1081 nnlpis = SCIPgetNNlpis(scip);
1082
1083 /* copy nlpis array into temporary memory for sorting */
1084 if( nnlpis != 0 )
1085 {
1086 SCIP_CALL( SCIPduplicateBufferArray(scip, &sorted, nlpis, nnlpis) );
1087 }
1088 else
1089 sorted = NULL;
1090
1091 /* sort the branching rules */
1092 SCIPsortPtr((void**)sorted, SCIPnlpiComp, nnlpis);
1093
1094 /* display sorted list of branching rules */
1095 SCIPdialogMessage(scip, NULL, "\n");
1096 SCIPdialogMessage(scip, NULL, " NLP interface priority description\n");
1097 SCIPdialogMessage(scip, NULL, " ------------- -------- -----------\n");
1098 for( i = 0; i < nnlpis; ++i )
1099 {
1100 assert(sorted != NULL);
1101 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPnlpiGetName(sorted[i]));
1102 if( strlen(SCIPnlpiGetName(sorted[i])) > 20 )
1103 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1104 SCIPdialogMessage(scip, NULL, "%8d ", SCIPnlpiGetPriority(sorted[i]));
1105 SCIPdialogMessage(scip, NULL, "%s", SCIPnlpiGetDesc(sorted[i]));
1106 SCIPdialogMessage(scip, NULL, "\n");
1107 }
1108 SCIPdialogMessage(scip, NULL, "\n");
1109
1110 /* free temporary memory */
1111 if( nnlpis != 0 )
1112 {
1113 SCIPfreeBufferArray(scip, &sorted);
1114 }
1115
1116 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1117
1118 return SCIP_OKAY;
1119}
1120
1121/** dialog execution method for the display nodeselectors command */
1122SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayNodeselectors)
1123{ /*lint --e{715}*/
1124 SCIP_NODESEL** nodesels;
1125 int nnodesels;
1126 int i;
1127
1128 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1129
1130 nodesels = SCIPgetNodesels(scip);
1131 nnodesels = SCIPgetNNodesels(scip);
1132
1133 /* display list of node selectors */
1134 SCIPdialogMessage(scip, NULL, "\n");
1135 SCIPdialogMessage(scip, NULL, " node selector std priority memsave prio description\n");
1136 SCIPdialogMessage(scip, NULL, " ------------- ------------ ------------ -----------\n");
1137 for( i = 0; i < nnodesels; ++i )
1138 {
1139 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPnodeselGetName(nodesels[i]));
1140 if( strlen(SCIPnodeselGetName(nodesels[i])) > 20 )
1141 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1142 SCIPdialogMessage(scip, NULL, "%12d ", SCIPnodeselGetStdPriority(nodesels[i]));
1143 SCIPdialogMessage(scip, NULL, "%12d ", SCIPnodeselGetMemsavePriority(nodesels[i]));
1144 SCIPdialogMessage(scip, NULL, "%s", SCIPnodeselGetDesc(nodesels[i]));
1145 SCIPdialogMessage(scip, NULL, "\n");
1146 }
1147 SCIPdialogMessage(scip, NULL, "\n");
1148
1149 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1150
1151 return SCIP_OKAY;
1152}
1153
1154/** dialog execution method for the display parameters command */
1155SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayParameters)
1156{ /*lint --e{715}*/
1157 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1158
1159 SCIPdialogMessage(scip, NULL, "\n");
1160 SCIPdialogMessage(scip, NULL, "number of parameters = %d\n", SCIPgetNParams(scip));
1161 SCIPdialogMessage(scip, NULL, "non-default parameter settings:\n");
1162 SCIP_CALL( SCIPwriteParams(scip, NULL, FALSE, TRUE) );
1163 SCIPdialogMessage(scip, NULL, "\n");
1164
1165 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1166
1167 return SCIP_OKAY;
1168}
1169
1170/** dialog execution method for the display presolvers command */
1171SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayPresolvers)
1172{ /*lint --e{715}*/
1173 SCIP_PRESOL** presols;
1174 int npresols;
1175 int i;
1176
1177 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1178
1179 presols = SCIPgetPresols(scip);
1180 npresols = SCIPgetNPresols(scip);
1181
1182 /* display list of presolvers */
1183 SCIPdialogMessage(scip, NULL, "\n");
1184 SCIPdialogMessage(scip, NULL, " Legend:\n");
1185 SCIPdialogMessage(scip, NULL, " priority: presolver called before constraint handlers iff priority > 0\n");
1186 SCIPdialogMessage(scip, NULL, " timing: 'f'ast, 'm'edium, 'e'xhaustive\n\n");
1187 SCIPdialogMessage(scip, NULL, " maxrounds: -1: no limit, 0: off, >0: limited number of rounds\n\n");
1188 SCIPdialogMessage(scip, NULL, " presolver priority timing maxrounds description\n");
1189 SCIPdialogMessage(scip, NULL, " --------- -------- ------ --------- -----------\n");
1190 for( i = 0; i < npresols; ++i )
1191 {
1192 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPpresolGetName(presols[i]));
1193 if( strlen(SCIPpresolGetName(presols[i])) > 20 )
1194 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1195 SCIPdialogMessage(scip, NULL, "%8d ", SCIPpresolGetPriority(presols[i]));
1196 SCIPdialogMessage(scip, NULL, " %c", (SCIPpresolGetTiming(presols[i]) & SCIP_PRESOLTIMING_FAST) ? 'f' : ' ');
1197 SCIPdialogMessage(scip, NULL, "%c", (SCIPpresolGetTiming(presols[i]) & SCIP_PRESOLTIMING_MEDIUM) ? 'm' : ' ');
1198 SCIPdialogMessage(scip, NULL, "%c ", (SCIPpresolGetTiming(presols[i]) & SCIP_PRESOLTIMING_EXHAUSTIVE) ? 'e' : ' ');
1199 SCIPdialogMessage(scip, NULL, "%9d ", SCIPpresolGetMaxrounds(presols[i]));
1200 SCIPdialogMessage(scip, NULL, "%s", SCIPpresolGetDesc(presols[i]));
1201 SCIPdialogMessage(scip, NULL, "\n");
1202 }
1203 SCIPdialogMessage(scip, NULL, "\n");
1204
1205 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1206
1207 return SCIP_OKAY;
1208}
1209
1210/** dialog execution method for the display pricer command */
1211SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayPricers)
1212{ /*lint --e{715}*/
1213 SCIP_PRICER** pricers;
1214 int npricers;
1215 int i;
1216
1217 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1218
1219 pricers = SCIPgetPricers(scip);
1220 npricers = SCIPgetNPricers(scip);
1221
1222 /* display list of pricers */
1223 SCIPdialogMessage(scip, NULL, "\n");
1224 SCIPdialogMessage(scip, NULL, " pricer priority description\n");
1225 SCIPdialogMessage(scip, NULL, " ---------- -------- -----------\n");
1226 for( i = 0; i < npricers; ++i )
1227 {
1228 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPpricerGetName(pricers[i]));
1229 if( strlen(SCIPpricerGetName(pricers[i])) > 20 )
1230 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1231 SCIPdialogMessage(scip, NULL, "%8d%c ", SCIPpricerGetPriority(pricers[i]), SCIPpricerIsDelayed(pricers[i]) ? 'd' : ' ');
1232 SCIPdialogMessage(scip, NULL, "%s", SCIPpricerGetDesc(pricers[i]));
1233 SCIPdialogMessage(scip, NULL, "\n");
1234 }
1235 SCIPdialogMessage(scip, NULL, "\n");
1236
1237 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1238
1239 return SCIP_OKAY;
1240}
1241
1242/** dialog execution method for the display problem command */
1243SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayProblem)
1244{ /*lint --e{715}*/
1245 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1246
1247 SCIPdialogMessage(scip, NULL, "\n");
1248
1249 if( SCIPgetStage(scip) >= SCIP_STAGE_PROBLEM )
1250 {
1251 SCIP_CALL( SCIPprintOrigProblem(scip, NULL, "cip", FALSE) );
1252 }
1253 else
1254 SCIPdialogMessage(scip, NULL, "no problem available\n");
1255
1256 SCIPdialogMessage(scip, NULL, "\n");
1257
1258 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1259
1260 return SCIP_OKAY;
1261}
1262
1263/** dialog execution method for the display propagators command */
1264SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayPropagators)
1265{ /*lint --e{715}*/
1266 SCIP_PROP** props;
1267 int nprops;
1268 int i;
1269
1270 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1271
1272 props = SCIPgetProps(scip);
1273 nprops = SCIPgetNProps(scip);
1274
1275 /* display list of propagators */
1276 SCIPdialogMessage(scip, NULL, "\n");
1277 SCIPdialogMessage(scip, NULL, " Legend:\n");
1278 SCIPdialogMessage(scip, NULL, " presprio: propagator presolving called before constraint handlers iff presprio > 0\n");
1279 SCIPdialogMessage(scip, NULL, " prestim (presolve timing): 'f'ast, 'm'edium, 'e'xhaustive\n\n");
1280
1281 SCIPdialogMessage(scip, NULL, " propagator propprio freq presprio prestim description\n");
1282 SCIPdialogMessage(scip, NULL, " ---------- -------- ---- -------- ------- -----------\n");
1283 for( i = 0; i < nprops; ++i )
1284 {
1285 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPpropGetName(props[i]));
1286 if( strlen(SCIPpropGetName(props[i])) > 20 )
1287 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1288 SCIPdialogMessage(scip, NULL, "%8d%c ", SCIPpropGetPriority(props[i]), SCIPpropIsDelayed(props[i]) ? 'd' : ' ');
1289 SCIPdialogMessage(scip, NULL, "%4d ", SCIPpropGetFreq(props[i]));
1290 SCIPdialogMessage(scip, NULL, "%8d ", SCIPpropGetPresolPriority(props[i]));
1291 SCIPdialogMessage(scip, NULL, " %c", (SCIPpropGetPresolTiming(props[i]) & SCIP_PRESOLTIMING_FAST) ? 'f' : ' ');
1292 SCIPdialogMessage(scip, NULL, "%c", (SCIPpropGetPresolTiming(props[i]) & SCIP_PRESOLTIMING_MEDIUM) ? 'm' : ' ');
1293 SCIPdialogMessage(scip, NULL, "%c ", (SCIPpropGetPresolTiming(props[i]) & SCIP_PRESOLTIMING_EXHAUSTIVE) ? 'e' : ' ');
1294 SCIPdialogMessage(scip, NULL, "%s", SCIPpropGetDesc(props[i]));
1295 SCIPdialogMessage(scip, NULL, "\n");
1296 }
1297 SCIPdialogMessage(scip, NULL, "\n");
1298
1299 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1300
1301 return SCIP_OKAY;
1302}
1303
1304/** dialog execution method for the display readers command */
1305SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayReaders)
1306{ /*lint --e{715}*/
1307 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1308
1309 /* print reader information */
1310 displayReaders(scip, TRUE, TRUE);
1311
1312 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1313
1314 return SCIP_OKAY;
1315}
1316
1317/** dialog execution method for the display separators command */
1318SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplaySeparators)
1319{ /*lint --e{715}*/
1320 SCIP_SEPA** sepas;
1321 int nsepas;
1322 int i;
1323
1324 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1325
1326 sepas = SCIPgetSepas(scip);
1327 nsepas = SCIPgetNSepas(scip);
1328
1329 /* display list of separators */
1330 SCIPdialogMessage(scip, NULL, "\n");
1331 SCIPdialogMessage(scip, NULL, " separator priority freq bddist description\n");
1332 SCIPdialogMessage(scip, NULL, " --------- -------- ---- ------ -----------\n");
1333 for( i = 0; i < nsepas; ++i )
1334 {
1335 SCIPdialogMessage(scip, NULL, " %-20s ", SCIPsepaGetName(sepas[i]));
1336 if( strlen(SCIPsepaGetName(sepas[i])) > 20 )
1337 SCIPdialogMessage(scip, NULL, "\n %20s ", "-->");
1338 SCIPdialogMessage(scip, NULL, "%8d%c ", SCIPsepaGetPriority(sepas[i]), SCIPsepaIsDelayed(sepas[i]) ? 'd' : ' ');
1339 SCIPdialogMessage(scip, NULL, "%4d ", SCIPsepaGetFreq(sepas[i]));
1340 SCIPdialogMessage(scip, NULL, "%6.2f ", SCIPsepaGetMaxbounddist(sepas[i]));
1341 SCIPdialogMessage(scip, NULL, "%s", SCIPsepaGetDesc(sepas[i]));
1342 SCIPdialogMessage(scip, NULL, "\n");
1343 }
1344 SCIPdialogMessage(scip, NULL, "\n");
1345
1346 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1347
1348 return SCIP_OKAY;
1349}
1350
1351/** dialog execution method for the display solution command */
1352SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplaySolution)
1353{ /*lint --e{715}*/
1354 SCIP_VAR** fixedvars;
1355 SCIP_VAR* var;
1356 SCIP_Bool printzeros;
1357 int nfixedvars;
1358 int v;
1359
1360 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1361
1362 if( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
1363 SCIPdialogMessage(scip, NULL, "No problem exists. Read (and solve) problem first.\n");
1364 else
1365 {
1366 SCIP_CALL( SCIPgetBoolParam(scip, "write/printzeros", &printzeros) );
1367
1368 SCIPdialogMessage(scip, NULL, "\n");
1369 SCIP_CALL( SCIPprintBestSol(scip, NULL, printzeros) );
1370 SCIPdialogMessage(scip, NULL, "\n");
1371
1372 /* check if there are infinite fixings and print a reference to 'display finitesolution', if needed */
1373 fixedvars = SCIPgetFixedVars(scip);
1374 nfixedvars = SCIPgetNFixedVars(scip);
1375 assert(fixedvars != NULL || nfixedvars == 0);
1376
1377 /* check whether there are variables fixed to an infinite value */
1378 for( v = 0; v < nfixedvars; ++v )
1379 {
1380 var = fixedvars[v]; /*lint !e613*/
1381
1382 /* skip (multi-)aggregated variables */
1383 if( SCIPvarGetStatus(var) != SCIP_VARSTATUS_FIXED )
1384 continue;
1385
1386 if( (SCIPisInfinity(scip, SCIPvarGetLbGlobal(var)) || SCIPisInfinity(scip, -SCIPvarGetLbGlobal(var))) )
1387 {
1388 SCIPdialogMessage(scip, NULL, "The primal solution contains variables fixed to infinite values.\n\
1389If you want SCIP to display an optimal solution without infinite values, use 'display finitesolution'.\n");
1390 SCIPdialogMessage(scip, NULL, "\n");
1391 break;
1392 }
1393 }
1394 }
1395 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1396
1397 return SCIP_OKAY;
1398}
1399
1400/** dialog execution method for the display finitesolution command */
1401SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayFiniteSolution)
1402{ /*lint --e{715}*/
1403 SCIP_SOL* bestsol = SCIPgetBestSol(scip);
1404
1405 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1406
1407 SCIPdialogMessage(scip, NULL, "\n");
1408 if( bestsol != NULL )
1409 {
1410 SCIP_SOL* sol;
1411 SCIP_Bool success;
1412 SCIP_RETCODE retcode;
1413
1414 /* create copy of solution with finite values */
1415 retcode = SCIPcreateFiniteSolCopy(scip, &sol, bestsol, &success);
1416
1417 if( retcode == SCIP_OKAY && success )
1418 {
1419 SCIP_Bool printzeros;
1420
1421 SCIP_CALL( SCIPgetBoolParam(scip, "write/printzeros", &printzeros) );
1422 retcode = SCIPprintSol(scip, sol, NULL, printzeros);
1423 SCIPdialogMessage(scip, NULL, "\n");
1424 }
1425 else
1426 {
1427 SCIPdialogMessage(scip, NULL, "error while creating finite solution\n");
1428 }
1429
1430 /* free solution copy */
1431 if( retcode == SCIP_OKAY && sol != NULL )
1432 {
1433 SCIP_CALL( SCIPfreeSol(scip, &sol) );
1434 }
1435 }
1436 else
1437 {
1438 SCIP_Bool printzeros;
1439
1440 SCIP_CALL( SCIPgetBoolParam(scip, "write/printzeros", &printzeros) );
1441 SCIP_CALL( SCIPprintBestSol(scip, NULL, printzeros) );
1442 SCIPdialogMessage(scip, NULL, "\n");
1443 }
1444
1445 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1446
1447 return SCIP_OKAY;
1448}
1449
1450/** dialog execution method for the display dual solution command */
1451SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayDualSolution)
1452{ /*lint --e{715}*/
1453 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1454
1455 SCIPdialogMessage(scip, NULL, "\n");
1456 SCIP_CALL( SCIPprintDualSol(scip, NULL, FALSE) );
1457 SCIPdialogMessage(scip, NULL, "\n");
1458
1459 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1460
1461 return SCIP_OKAY;
1462}
1463
1464
1465/** dialog execution method for the display of solutions in the pool command */
1466SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplaySolutionPool)
1467{ /*lint --e{715}*/
1468 char prompt[SCIP_MAXSTRLEN];
1469 SCIP_Bool endoffile;
1470 SCIP_SOL** sols;
1471 char* idxstr;
1472 char* endstr;
1473 int nsols;
1474 int idx;
1475
1476 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1477 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1478 SCIPdialogMessage(scip, NULL, "\n");
1479
1480 if ( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
1481 {
1482 SCIPdialogMessage(scip, NULL, "No solution available.\n\n");
1483 return SCIP_OKAY;
1484 }
1485
1486 nsols = SCIPgetNSols(scip);
1487 if ( nsols == 0 )
1488 {
1489 SCIPdialogMessage(scip, NULL, "No solution available.\n\n");
1490 return SCIP_OKAY;
1491 }
1492
1493 /* parse solution number */
1494 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "index of solution [0-%d]: ", nsols-1);
1495
1496 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &idxstr, &endoffile) );
1497
1498 if( endoffile )
1499 {
1500 *nextdialog = NULL;
1501 return SCIP_OKAY;
1502 }
1503
1504 if ( SCIPstrToIntValue(idxstr, &idx, &endstr) )
1505 {
1506 SCIP_Bool printzeros;
1507
1508 if ( idx < 0 || idx >= nsols )
1509 {
1510 SCIPdialogMessage(scip, NULL, "Solution index out of bounds [0-%d].\n", nsols-1);
1511 return SCIP_OKAY;
1512 }
1513
1514 SCIP_CALL( SCIPgetBoolParam(scip, "write/printzeros", &printzeros) );
1515
1516 sols = SCIPgetSols(scip);
1517 assert( sols[idx] != NULL );
1518 SCIP_CALL( SCIPprintSol(scip, sols[idx], NULL, FALSE) );
1519 }
1520 SCIPdialogMessage(scip, NULL, "\n");
1521
1522 return SCIP_OKAY;
1523}
1524
1525/** dialog execution method for the display subproblem command */
1526SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplaySubproblem)
1527{ /*lint --e{715}*/
1528 SCIP_BENDERS** benders;
1529 char prompt[SCIP_MAXSTRLEN];
1530 int nactivebenders;
1531 int nbenders;
1532 SCIP_Bool endoffile;
1533 char* idxstr;
1534 char* endstr;
1535 int count;
1536 int idx;
1537 int subidx;
1538 int i;
1539
1540 idxstr = NULL;
1541 idx = 0;
1542 subidx = 0;
1543
1544 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1545
1546 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1547
1548 SCIPdialogMessage(scip, NULL, "\n");
1549
1550 if(SCIPgetStage(scip) < SCIP_STAGE_TRANSFORMED)
1551 {
1552 SCIPdialogMessage(scip, NULL, "problem must be transformed to display subproblems\n\n");
1553 return SCIP_OKAY;
1554 }
1555
1556 /* if there are no active Benders' decompositions, then there are no subproblem */
1557 nactivebenders = SCIPgetNActiveBenders(scip);
1558 if( nactivebenders == 0 )
1559 {
1560 SCIPdialogMessage(scip, NULL, "no active Benders' decomposition\n\n");
1561 return SCIP_OKAY;
1562 }
1563
1564 nbenders = SCIPgetNBenders(scip);
1565 benders = SCIPgetBenders(scip);
1566
1567 /* if there is only one active Benders decomposition, then there is no need to display the list of Benders */
1568 if( nactivebenders > 1 )
1569 {
1570 SCIPdialogMessage(scip, NULL, "Active Benders' decomposition:\n");
1571 count = 0;
1572 for( i = 0; i < nbenders; i++ )
1573 {
1574 if( SCIPbendersIsActive(benders[i]) )
1575 {
1576 assert(i >= count);
1577 benders[count] = benders[i];
1578 SCIPdialogMessage(scip, NULL, " %d: %s\n", count, SCIPbendersGetName(benders[count]));
1579 count++;
1580 }
1581 }
1582
1583 /* parse decomposition number */
1584 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN-1, "index of decomposition [0-%d]: ", nactivebenders-1);
1585
1586 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &idxstr, &endoffile) );
1587
1588 if( endoffile )
1589 {
1590 *nextdialog = NULL;
1591 return SCIP_OKAY;
1592 }
1593 }
1594 else
1595 idx = 0;
1596
1597 /* coverity[var_deref_model] */
1598 if ( nactivebenders == 1 || SCIPstrToIntValue(idxstr, &idx, &endstr) )
1599 {
1600 int nsubproblems;
1601
1602 if ( idx < 0 || idx >= nactivebenders)
1603 {
1604 SCIPdialogMessage(scip, NULL, "Decomposition index out of bounds [0-%d].\n", nactivebenders-1);
1605 return SCIP_OKAY;
1606 }
1607
1608 nsubproblems = SCIPbendersGetNSubproblems(benders[idx]);
1609
1610 /* if there is only one subproblem, then there is no need to ask for a prompt */
1611 if( nsubproblems > 1 )
1612 {
1613 /* parse subproblem number */
1614 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN-1, "index of subproblem [0-%d] or -1 for all: ", nsubproblems-1);
1615
1616 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &idxstr, &endoffile) );
1617
1618 if( endoffile )
1619 {
1620 *nextdialog = NULL;
1621 return SCIP_OKAY;
1622 }
1623 }
1624 else
1625 subidx = 0;
1626
1627 /* coverity[var_deref_model] */
1628 if ( nsubproblems == 1 || SCIPstrToIntValue(idxstr, &subidx, &endstr) )
1629 {
1630 SCIP* subproblem;
1631 int nsubdisplay;
1632
1633 if ( subidx < -1 || subidx >= nsubproblems)
1634 {
1635 SCIPdialogMessage(scip, NULL, "Subproblem index out of bounds [0-%d] or -1.\n", nsubproblems-1);
1636 return SCIP_OKAY;
1637 }
1638
1639 if( subidx == -1 )
1640 nsubdisplay = nsubproblems;
1641 else
1642 nsubdisplay = 1;
1643
1644 for( i = 0; i < nsubdisplay; i++ )
1645 {
1646 if( nsubdisplay > 1 )
1647 subidx = i;
1648
1649 subproblem = SCIPbendersSubproblem(benders[idx], subidx);
1650
1651 if( subproblem != NULL && SCIPgetStage(subproblem) >= SCIP_STAGE_PROBLEM )
1652 {
1653 SCIPdialogMessage(scip, NULL, "\n");
1654 SCIPdialogMessage(scip, NULL, "Subproblem %d\n", subidx);
1655 SCIP_CALL( SCIPprintOrigProblem(subproblem, NULL, "cip", FALSE) );
1656 SCIPdialogMessage(scip, NULL, "\n");
1657 }
1658 else
1659 SCIPdialogMessage(scip, NULL, "no problem available\n");
1660 }
1661 }
1662 }
1663
1664 SCIPdialogMessage(scip, NULL, "\n");
1665
1666 return SCIP_OKAY;
1667}
1668
1669/** dialog execution method for the display subsolution command */
1670SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplaySubSolution)
1671{ /*lint --e{715}*/
1672 SCIP_BENDERS** benders;
1673 char prompt[SCIP_MAXSTRLEN];
1674 int nactivebenders;
1675 int nbenders;
1676 SCIP_Bool endoffile;
1677 SCIP_Bool printzeros;
1678 char* idxstr;
1679 char* endstr;
1680 int count;
1681 int idx;
1682 int subidx;
1683 int i;
1684
1685 idxstr = NULL;
1686 idx = 0;
1687 subidx = 0;
1688
1689 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1690
1691 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1692
1693 SCIPdialogMessage(scip, NULL, "\n");
1694
1695 if(SCIPgetStage(scip) < SCIP_STAGE_TRANSFORMED)
1696 {
1697 SCIPdialogMessage(scip, NULL, "problem must be transformed to display subproblems\n\n");
1698 return SCIP_OKAY;
1699 }
1700
1701 /* if there are no active Benders' decompositions, then there are no subproblem */
1702 nactivebenders = SCIPgetNActiveBenders(scip);
1703 if( nactivebenders == 0 )
1704 {
1705 SCIPdialogMessage(scip, NULL, "no active Benders' decomposition\n\n");
1706 return SCIP_OKAY;
1707 }
1708
1709 nbenders = SCIPgetNBenders(scip);
1710 benders = SCIPgetBenders(scip);
1711
1712 /* if there is only one active Benders decomposition, then there is no need to display the list of Benders */
1713 if( nactivebenders > 1 )
1714 {
1715 SCIPdialogMessage(scip, NULL, "Active Benders' decomposition:\n");
1716 count = 0;
1717 for( i = 0; i < nbenders; i++ )
1718 {
1719 if( SCIPbendersIsActive(benders[i]) )
1720 {
1721 assert(i >= count);
1722 benders[count] = benders[i];
1723 SCIPdialogMessage(scip, NULL, " %d: %s\n", count, SCIPbendersGetName(benders[count]));
1724 count++;
1725 }
1726 }
1727
1728 /* parse decomposition number */
1729 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN-1, "index of decomposition [0-%d]: ", nactivebenders-1);
1730
1731 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &idxstr, &endoffile) );
1732
1733 if( endoffile )
1734 {
1735 *nextdialog = NULL;
1736 return SCIP_OKAY;
1737 }
1738 }
1739 else
1740 idx = 0;
1741
1742 /* coverity[var_deref_model] */
1743 if ( nactivebenders == 1 || SCIPstrToIntValue(idxstr, &idx, &endstr) )
1744 {
1745 int nsubproblems;
1746
1747 SCIP_CALL( SCIPgetBoolParam(scip, "write/printzeros", &printzeros) );
1748
1749 if ( idx < 0 || idx >= nactivebenders)
1750 {
1751 SCIPdialogMessage(scip, NULL, "Decomposition index out of bounds [0-%d].\n", nactivebenders-1);
1752 return SCIP_OKAY;
1753 }
1754
1755 nsubproblems = SCIPbendersGetNSubproblems(benders[idx]);
1756
1757 /* if there is only one subproblem, then there is no need to ask for a prompt */
1758 if( nsubproblems > 1 )
1759 {
1760 /* parse subproblem number */
1761 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN-1, "index of subproblem [0-%d] or -1 for all: ", nsubproblems-1);
1762
1763 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &idxstr, &endoffile) );
1764
1765 if( endoffile )
1766 {
1767 *nextdialog = NULL;
1768 return SCIP_OKAY;
1769 }
1770 }
1771 else
1772 subidx = 0;
1773
1774 /* coverity[var_deref_model] */
1775 if ( nsubproblems == 1 || SCIPstrToIntValue(idxstr, &subidx, &endstr) )
1776 {
1777 SCIP* subproblem;
1778 SCIP_SOL* bestsol;
1779 int nsubdisplay;
1780 SCIP_Bool infeasible;
1781
1782 if ( subidx < -1 || subidx >= nsubproblems)
1783 {
1784 SCIPdialogMessage(scip, NULL, "Subproblem index out of bounds [0-%d] or -1.\n", nsubproblems-1);
1785 return SCIP_OKAY;
1786 }
1787
1788 bestsol = SCIPgetBestSol(scip);
1789
1790 if( subidx == -1 )
1791 nsubdisplay = nsubproblems;
1792 else
1793 nsubdisplay = 1;
1794
1795 for( i = 0; i < nsubdisplay; i++ )
1796 {
1797 if( nsubdisplay > 1 )
1798 subidx = i;
1799
1800 subproblem = SCIPbendersSubproblem(benders[idx], subidx);
1801
1802 if( subproblem != NULL && SCIPgetStage(subproblem) >= SCIP_STAGE_PROBLEM )
1803 {
1804 /* setting up the subproblem with the best solution to the master problem */
1805 SCIP_CALL( SCIPsetupBendersSubproblem(scip, benders[idx], bestsol, subidx, SCIP_BENDERSENFOTYPE_CHECK) );
1806
1807 /* solving the subproblem using the best solution to the master problem */
1808 SCIP_CALL( SCIPsolveBendersSubproblem(scip, benders[idx], bestsol, subidx, &infeasible,
1809 TRUE, NULL) );
1810
1811 if( infeasible )
1812 SCIPdialogMessage(scip, NULL, "subproblem %d is infeasible.\n", subidx);
1813 else
1814 {
1815 SCIPdialogMessage(scip, NULL, "\n");
1816 SCIPdialogMessage(scip, NULL, "Subproblem %d\n", subidx);
1817 if( SCIPbendersGetSubproblemType(benders[idx], subidx) == SCIP_BENDERSSUBTYPE_CONVEXCONT )
1818 {
1819 /* need to check whether the subproblem is an NLP and solved as an NLP */
1820 if( SCIPisNLPConstructed(subproblem) && SCIPgetNNlpis(subproblem) > 0 )
1821 {
1822 SCIP_SOL* nlpsol;
1823 SCIP_CALL( SCIPcreateNLPSol(subproblem, &nlpsol, NULL) );
1824 SCIP_CALL( SCIPprintSol(subproblem, nlpsol, NULL, FALSE) );
1825 SCIP_CALL( SCIPfreeSol(subproblem, &nlpsol) );
1826 }
1827 else
1828 {
1829 SCIP_CALL( SCIPprintSol(subproblem, NULL, NULL, printzeros) );
1830 }
1831 }
1832 else
1833 SCIP_CALL( SCIPprintBestSol(subproblem, NULL, printzeros) );
1834 SCIPdialogMessage(scip, NULL, "\n");
1835 }
1836
1837 /* freeing the subproblem */
1838 SCIP_CALL( SCIPfreeBendersSubproblem(scip, benders[idx], subidx) );
1839 }
1840 else
1841 SCIPdialogMessage(scip, NULL, "no problem available\n");
1842 }
1843 }
1844 }
1845
1846 SCIPdialogMessage(scip, NULL, "\n");
1847
1848 return SCIP_OKAY;
1849}
1850
1851/** dialog execution method for the display statistics command */
1852SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayStatistics)
1853{ /*lint --e{715}*/
1854 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1855
1856 SCIPdialogMessage(scip, NULL, "\n");
1857 SCIP_CALL( SCIPprintStatistics(scip, NULL) );
1858 SCIPdialogMessage(scip, NULL, "\n");
1859
1860 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1861
1862 return SCIP_OKAY;
1863}
1864
1865/** dialog execution method for the display reoptstatistics command */
1866SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayReoptStatistics)
1867{ /*lint --e{715}*/
1868 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1869
1870 SCIPdialogMessage(scip, NULL, "\n");
1871 SCIP_CALL( SCIPprintReoptStatistics(scip, NULL) );
1872 SCIPdialogMessage(scip, NULL, "\n");
1873
1874 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1875
1876 return SCIP_OKAY;
1877}
1878
1879/** dialog execution method for the display compression command */
1880SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayCompression)
1881{ /*lint --e{715}*/
1882 SCIP_COMPR** comprs;
1883 SCIP_COMPR** sorted;
1884 int ncomprs;
1885 int i;
1886
1887 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1888
1889 comprs = SCIPgetComprs(scip);
1890 ncomprs = SCIPgetNCompr(scip);
1891
1892 /* copy compression array into temporary memory for sorting */
1893 SCIP_CALL( SCIPduplicateBufferArray(scip, &sorted, comprs, ncomprs) );
1894
1895 /* sort the compression t */
1896 SCIPsortPtr((void**)sorted, SCIPcomprComp, ncomprs);
1897
1898 /* display sorted list of branching rules */
1899 SCIPdialogMessage(scip, NULL, "\n");
1900 SCIPdialogMessage(scip, NULL, " compression method priority minnodes description\n");
1901 SCIPdialogMessage(scip, NULL, " ------------------ -------- -------- -----------\n");
1902 for( i = 0; i < ncomprs; ++i )
1903 {
1904 SCIPdialogMessage(scip, NULL, " %-24s ", SCIPcomprGetName(sorted[i]));
1905 if( strlen(SCIPcomprGetName(sorted[i])) > 24 )
1906 SCIPdialogMessage(scip, NULL, "\n %24s ", "-->");
1907 SCIPdialogMessage(scip, NULL, "%8d %8d ", SCIPcomprGetPriority(sorted[i]), SCIPcomprGetMinNodes(sorted[i]));
1908 SCIPdialogMessage(scip, NULL, "%s", SCIPcomprGetDesc(sorted[i]));
1909 SCIPdialogMessage(scip, NULL, "\n");
1910 }
1911 SCIPdialogMessage(scip, NULL, "\n");
1912
1913 /* free temporary memory */
1914 SCIPfreeBufferArray(scip, &sorted);
1915
1916 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1917
1918 return SCIP_OKAY;
1919}
1920
1921/** dialog execution method for the display transproblem command */
1922SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayTransproblem)
1923{ /*lint --e{715}*/
1924 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
1925
1926 SCIPdialogMessage(scip, NULL, "\n");
1927 if(SCIPgetStage(scip) >= SCIP_STAGE_TRANSFORMED)
1928 {
1929 SCIP_CALL( SCIPprintTransProblem(scip, NULL, "cip", FALSE) );
1930 }
1931 else
1932 SCIPdialogMessage(scip, NULL, "no transformed problem available\n");
1933
1934 SCIPdialogMessage(scip, NULL, "\n");
1935
1936 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1937
1938 return SCIP_OKAY;
1939}
1940
1941/** dialog execution method for the display value command */
1942SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayValue)
1943{ /*lint --e{715}*/
1944 SCIP_SOL* sol;
1945 SCIP_VAR* var;
1946 char* varname;
1947 SCIP_Real solval;
1948 SCIP_Bool endoffile;
1949
1950 SCIPdialogMessage(scip, NULL, "\n");
1951
1952 if( SCIPgetStage(scip) >= SCIP_STAGE_TRANSFORMED )
1953 sol = SCIPgetBestSol(scip);
1954 else
1955 sol = NULL;
1956
1957 if( sol == NULL )
1958 {
1959 SCIPdialogMessage(scip, NULL, "no feasible solution available\n");
1960 SCIPdialoghdlrClearBuffer(dialoghdlr);
1961 }
1962 else
1963 {
1964 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter variable name: ", &varname, &endoffile) );
1965 if( endoffile )
1966 {
1967 *nextdialog = NULL;
1968 return SCIP_OKAY;
1969 }
1970
1971 if( varname[0] != '\0' )
1972 {
1973 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, varname, TRUE) );
1974
1975 var = SCIPfindVar(scip, varname);
1976 if( var == NULL )
1977 SCIPdialogMessage(scip, NULL, "variable <%s> not found\n", varname);
1978 else
1979 {
1980 solval = SCIPgetSolVal(scip, sol, var);
1981 SCIPdialogMessage(scip, NULL, "%-32s", SCIPvarGetName(var));
1982 if( SCIPisInfinity(scip, solval) )
1983 SCIPdialogMessage(scip, NULL, " +infinity");
1984 else if( SCIPisInfinity(scip, -solval) )
1985 SCIPdialogMessage(scip, NULL, " -infinity");
1986 else
1987 SCIPdialogMessage(scip, NULL, " %20.15g", solval);
1988 SCIPdialogMessage(scip, NULL, " \t(obj:%.15g)\n", SCIPvarGetObj(var));
1989 }
1990 }
1991 }
1992 SCIPdialogMessage(scip, NULL, "\n");
1993
1994 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
1995
1996 return SCIP_OKAY;
1997}
1998
1999/** dialog execution method for the display varbranchstatistics command */
2000SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayVarbranchstatistics)
2001{ /*lint --e{715}*/
2002 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2003
2004 SCIPdialogMessage(scip, NULL, "\n");
2005 SCIP_CALL( SCIPprintBranchingStatistics(scip, NULL) );
2006 SCIPdialogMessage(scip, NULL, "\n");
2007
2008 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2009
2010 return SCIP_OKAY;
2011}
2012
2013/** dialog execution method for the display LP solution quality command */
2014SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayLPSolutionQuality)
2015{ /*lint --e{715}*/
2016 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2017
2018 SCIPdialogMessage(scip, NULL, "\n");
2019 SCIP_CALL( SCIPprintLPSolutionQuality(scip, NULL) );
2020 SCIPdialogMessage(scip, NULL, "\n");
2021
2022 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2023
2024 return SCIP_OKAY;
2025}
2026
2027/** dialog execution method for the help command */
2028SCIP_DECL_DIALOGEXEC(SCIPdialogExecHelp)
2029{ /*lint --e{715}*/
2030 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2031
2032 SCIPdialogMessage(scip, NULL, "\n");
2033 SCIP_CALL( SCIPdialogDisplayMenu(SCIPdialogGetParent(dialog), scip) );
2034 SCIPdialogMessage(scip, NULL, "\n");
2035
2036 *nextdialog = SCIPdialogGetParent(dialog);
2037
2038 return SCIP_OKAY;
2039}
2040
2041/** dialog execution method for the display transsolution command */
2042SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayTranssolution)
2043{ /*lint --e{715}*/
2044 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2045
2046 SCIPdialogMessage(scip, NULL, "\n");
2047 if( SCIPgetStage(scip) >= SCIP_STAGE_TRANSFORMED )
2048 {
2049 if( SCIPsolIsOriginal(SCIPgetBestSol(scip)) )
2050 {
2051 SCIPdialogMessage(scip, NULL, "best solution exists only in original problem space\n");
2052 }
2053 else
2054 {
2055 SCIP_CALL( SCIPprintBestTransSol(scip, NULL, FALSE) );
2056 }
2057 }
2058 else
2059 SCIPdialogMessage(scip, NULL, "no solution available\n");
2060 SCIPdialogMessage(scip, NULL, "\n");
2061
2062 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2063
2064 return SCIP_OKAY;
2065}
2066
2067/** dialog execution method for the free command */
2068SCIP_DECL_DIALOGEXEC(SCIPdialogExecFree)
2069{ /*lint --e{715}*/
2070 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2071
2072 SCIP_CALL( SCIPfreeProb(scip) );
2073
2074 *nextdialog = SCIPdialogGetParent(dialog);
2075
2076 return SCIP_OKAY;
2077}
2078
2079/** dialog execution method for the newstart command */
2080SCIP_DECL_DIALOGEXEC(SCIPdialogExecNewstart)
2081{ /*lint --e{715}*/
2082 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2083
2084 SCIP_CALL( SCIPfreeSolve(scip, TRUE) );
2085
2086 *nextdialog = SCIPdialogGetParent(dialog);
2087
2088 return SCIP_OKAY;
2089}
2090
2091/** dialog execution method for the transform command */
2092SCIP_DECL_DIALOGEXEC(SCIPdialogExecTransform)
2093{ /*lint --e{715}*/
2094 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2095
2096 SCIPdialogMessage(scip, NULL, "\n");
2097 switch( SCIPgetStage(scip) )
2098 {
2099 case SCIP_STAGE_INIT:
2100 SCIPdialogMessage(scip, NULL, "no problem exists\n");
2101 break;
2102
2103 case SCIP_STAGE_PROBLEM:
2104 SCIP_CALL( SCIPtransformProb(scip) );
2105 break;
2106
2107 case SCIP_STAGE_TRANSFORMED:
2108 SCIPdialogMessage(scip, NULL, "problem is already transformed\n");
2109 break;
2110
2111 case SCIP_STAGE_TRANSFORMING:
2112 case SCIP_STAGE_INITPRESOLVE:
2113 case SCIP_STAGE_PRESOLVING:
2114 case SCIP_STAGE_PRESOLVED:
2115 case SCIP_STAGE_EXITPRESOLVE:
2116 case SCIP_STAGE_INITSOLVE:
2117 case SCIP_STAGE_SOLVING:
2118 case SCIP_STAGE_SOLVED:
2119 case SCIP_STAGE_EXITSOLVE:
2120 case SCIP_STAGE_FREETRANS:
2121 case SCIP_STAGE_FREE:
2122 default:
2123 SCIPerrorMessage("invalid SCIP stage\n");
2124 return SCIP_INVALIDCALL;
2125 }
2126 SCIPdialogMessage(scip, NULL, "\n");
2127
2128 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2129
2130 return SCIP_OKAY;
2131}
2132
2133/** dialog execution method for the concurrentopt command */
2134SCIP_DECL_DIALOGEXEC(SCIPdialogExecConcurrentOpt)
2135{ /*lint --e{715}*/
2136 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2137
2138 SCIPdialogMessage(scip, NULL, "\n");
2139 switch( SCIPgetStage(scip) )
2140 {
2141 case SCIP_STAGE_INIT:
2142 SCIPdialogMessage(scip, NULL, "no problem exists\n");
2143 break;
2144
2145 case SCIP_STAGE_PROBLEM:
2146 case SCIP_STAGE_TRANSFORMED:
2147 case SCIP_STAGE_PRESOLVING:
2148 case SCIP_STAGE_PRESOLVED:
2149 case SCIP_STAGE_SOLVING:
2150 SCIP_CALL( SCIPsolveConcurrent(scip) );
2151 break;
2152
2153 case SCIP_STAGE_SOLVED:
2154 SCIPdialogMessage(scip, NULL, "problem is already solved\n");
2155 break;
2156
2157 case SCIP_STAGE_TRANSFORMING:
2158 case SCIP_STAGE_INITPRESOLVE:
2159 case SCIP_STAGE_EXITPRESOLVE:
2160 case SCIP_STAGE_INITSOLVE:
2161 case SCIP_STAGE_EXITSOLVE:
2162 case SCIP_STAGE_FREETRANS:
2163 case SCIP_STAGE_FREE:
2164 default:
2165 SCIPerrorMessage("invalid SCIP stage\n");
2166 return SCIP_INVALIDCALL;
2167 }
2168 SCIPdialogMessage(scip, NULL, "\n");
2169
2170 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2171
2172 return SCIP_OKAY;
2173}
2174
2175/** dialog execution method for the optimize command */
2176SCIP_DECL_DIALOGEXEC(SCIPdialogExecOptimize)
2177{ /*lint --e{715}*/
2178 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2179
2180 SCIPdialogMessage(scip, NULL, "\n");
2181 switch( SCIPgetStage(scip) )
2182 {
2183 case SCIP_STAGE_INIT:
2184 SCIPdialogMessage(scip, NULL, "no problem exists\n");
2185 break;
2186
2187 case SCIP_STAGE_PROBLEM:
2188 case SCIP_STAGE_TRANSFORMED:
2189 case SCIP_STAGE_PRESOLVING:
2190 case SCIP_STAGE_PRESOLVED:
2191 case SCIP_STAGE_SOLVING:
2192 SCIP_CALL( SCIPsolve(scip) );
2193 break;
2194
2195 case SCIP_STAGE_SOLVED:
2196 SCIPdialogMessage(scip, NULL, "problem is already solved\n");
2197 break;
2198
2199 case SCIP_STAGE_TRANSFORMING:
2200 case SCIP_STAGE_INITPRESOLVE:
2201 case SCIP_STAGE_EXITPRESOLVE:
2202 case SCIP_STAGE_INITSOLVE:
2203 case SCIP_STAGE_EXITSOLVE:
2204 case SCIP_STAGE_FREETRANS:
2205 case SCIP_STAGE_FREE:
2206 default:
2207 SCIPerrorMessage("invalid SCIP stage\n");
2208 return SCIP_INVALIDCALL;
2209 }
2210 SCIPdialogMessage(scip, NULL, "\n");
2211
2212 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2213
2214 return SCIP_OKAY;
2215}
2216
2217/** dialog execution method for the presolve command */
2218SCIP_DECL_DIALOGEXEC(SCIPdialogExecPresolve)
2219{ /*lint --e{715}*/
2220 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2221
2222 SCIPdialogMessage(scip, NULL, "\n");
2223 switch( SCIPgetStage(scip) )
2224 {
2225 case SCIP_STAGE_INIT:
2226 SCIPdialogMessage(scip, NULL, "no problem exists\n");
2227 break;
2228
2229 case SCIP_STAGE_PROBLEM:
2230 case SCIP_STAGE_TRANSFORMED:
2231 case SCIP_STAGE_PRESOLVING:
2232 SCIP_CALL( SCIPpresolve(scip) );
2233 break;
2234
2235 case SCIP_STAGE_PRESOLVED:
2236 case SCIP_STAGE_SOLVING:
2237 SCIPdialogMessage(scip, NULL, "problem is already presolved\n");
2238 break;
2239
2240 case SCIP_STAGE_SOLVED:
2241 SCIPdialogMessage(scip, NULL, "problem is already solved\n");
2242 break;
2243
2244 case SCIP_STAGE_TRANSFORMING:
2245 case SCIP_STAGE_INITPRESOLVE:
2246 case SCIP_STAGE_EXITPRESOLVE:
2247 case SCIP_STAGE_INITSOLVE:
2248 case SCIP_STAGE_EXITSOLVE:
2249 case SCIP_STAGE_FREETRANS:
2250 case SCIP_STAGE_FREE:
2251 default:
2252 SCIPerrorMessage("invalid SCIP stage\n");
2253 return SCIP_INVALIDCALL;
2254 }
2255 SCIPdialogMessage(scip, NULL, "\n");
2256
2257 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2258
2259 return SCIP_OKAY;
2260}
2261
2262/** dialog execution method for the quit command */
2263SCIP_DECL_DIALOGEXEC(SCIPdialogExecQuit)
2264{ /*lint --e{715}*/
2265 SCIPdialogMessage(scip, NULL, "\n");
2266
2267 *nextdialog = NULL;
2268
2269 return SCIP_OKAY;
2270}
2271
2272/** dialog execution method for the read command */
2273SCIP_DECL_DIALOGEXEC(SCIPdialogExecRead)
2274{ /*lint --e{715}*/
2275 SCIP_RETCODE retcode;
2276 char* filename;
2277 SCIP_Bool endoffile;
2278
2279 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
2280 if( endoffile )
2281 {
2282 *nextdialog = NULL;
2283 return SCIP_OKAY;
2284 }
2285
2286 if( filename[0] != '\0' )
2287 {
2288 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
2289
2290 if( SCIPfileExists(filename) )
2291 {
2292 char* tmpfilename;
2293 char* extension;
2294
2295 /* copy filename */
2296 SCIP_CALL( SCIPduplicateBufferArray(scip, &tmpfilename, filename, (int)strlen(filename)+1) );
2297 extension = NULL;
2298
2299 SCIPinfoMessage(scip, NULL, "\n");
2300 SCIPinfoMessage(scip, NULL, "read problem <%s>\n", filename);
2301 SCIPinfoMessage(scip, NULL, "============\n");
2302 SCIPinfoMessage(scip, NULL, "\n");
2303
2304 do
2305 {
2306 retcode = SCIPreadProb(scip, tmpfilename, extension);
2307 if( retcode == SCIP_READERROR || retcode == SCIP_NOFILE )
2308 {
2309 if( extension == NULL )
2310 SCIPdialogMessage(scip, NULL, "error reading file <%s>\n", tmpfilename);
2311 else
2312 SCIPdialogMessage(scip, NULL, "error reading file <%s> using <%s> file format\n",
2313 tmpfilename, extension);
2314
2315 SCIP_CALL( SCIPfreeProb(scip) );
2316 break;
2317 }
2318 else if( retcode == SCIP_PLUGINNOTFOUND )
2319 {
2320 /* ask user once for a suitable reader */
2321 if( extension == NULL )
2322 {
2323 SCIPdialogMessage(scip, NULL, "no reader for input file <%s> available\n", tmpfilename);
2324
2325 SCIPdialogMessage(scip, NULL, "The following readers are available for reading:\n");
2326 displayReaders(scip, TRUE, FALSE);
2327
2328 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog,
2329 "select a suitable reader by extension (or return): ", &extension, &endoffile) );
2330
2331 if( extension[0] == '\0' )
2332 break;
2333 }
2334 else
2335 {
2336 SCIPdialogMessage(scip, NULL, "no reader for file extension <%s> available\n", extension);
2337 extension = NULL;
2338 }
2339 }
2340 else
2341 {
2342 /* check if an unexpected error occurred during the reading process */
2343 SCIP_CALL( retcode );
2344 break;
2345 }
2346 }
2347 while( extension != NULL );
2348
2349 /* free buffer array */
2350 SCIPfreeBufferArray(scip, &tmpfilename);
2351 }
2352 else
2353 {
2354 SCIPdialogMessage(scip, NULL, "file <%s> not found\n", filename);
2355 SCIPdialoghdlrClearBuffer(dialoghdlr);
2356 }
2357 }
2358
2359 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2360
2361 return SCIP_OKAY;
2362}
2363
2364/** dialog execution method for the set default command */
2365SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetDefault)
2366{ /*lint --e{715}*/
2367 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
2368
2369 SCIP_CALL( SCIPresetParams(scip) );
2370 SCIPdialogMessage(scip, NULL, "reset parameters to their default values\n");
2371
2372 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2373
2374 return SCIP_OKAY;
2375}
2376
2377/** dialog execution method for the set load command */
2378SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetLoad)
2379{ /*lint --e{715}*/
2380 char* filename;
2381 SCIP_Bool endoffile;
2382
2383 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
2384 if( endoffile )
2385 {
2386 *nextdialog = NULL;
2387 return SCIP_OKAY;
2388 }
2389
2390 if( filename[0] != '\0' )
2391 {
2392 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
2393
2394 if( SCIPfileExists(filename) )
2395 {
2396 SCIP_CALL( SCIPreadParams(scip, filename) );
2397 SCIPdialogMessage(scip, NULL, "loaded parameter file <%s>\n", filename);
2398 }
2399 else
2400 {
2401 SCIPdialogMessage(scip, NULL, "file <%s> not found\n", filename);
2402 SCIPdialoghdlrClearBuffer(dialoghdlr);
2403 }
2404 }
2405
2406 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2407
2408 return SCIP_OKAY;
2409}
2410
2411/** dialog execution method for the set save command */
2412SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetSave)
2413{ /*lint --e{715}*/
2414 char* filename;
2415 SCIP_Bool endoffile;
2416
2417 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
2418 if( endoffile )
2419 {
2420 *nextdialog = NULL;
2421 return SCIP_OKAY;
2422 }
2423
2424 if( filename[0] != '\0' )
2425 {
2426 SCIP_RETCODE retcode;
2427
2428 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
2429
2430 retcode = SCIPwriteParams(scip, filename, TRUE, FALSE);
2431
2432 if( retcode == SCIP_FILECREATEERROR )
2433 {
2434 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
2435 }
2436 else
2437 {
2438 SCIP_CALL( retcode );
2439 SCIPdialogMessage(scip, NULL, "saved parameter file <%s>\n", filename);
2440 }
2441 }
2442
2443 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2444
2445 return SCIP_OKAY;
2446}
2447
2448/** dialog execution method for the set diffsave command */
2449SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetDiffsave)
2450{ /*lint --e{715}*/
2451 char* filename;
2452 SCIP_Bool endoffile;
2453
2454 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
2455 if( endoffile )
2456 {
2457 *nextdialog = NULL;
2458 return SCIP_OKAY;
2459 }
2460
2461 if( filename[0] != '\0' )
2462 {
2463 SCIP_RETCODE retcode;
2464
2465 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
2466
2467 retcode = SCIPwriteParams(scip, filename, TRUE, TRUE);
2468
2469 if( retcode == SCIP_FILECREATEERROR )
2470 {
2471 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
2472 }
2473 else
2474 {
2475 SCIP_CALL( retcode );
2476 SCIPdialogMessage(scip, NULL, "saved non-default parameter settings to file <%s>\n", filename);
2477 }
2478 }
2479
2480 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2481
2482 return SCIP_OKAY;
2483}
2484
2485/** dialog execution method for the set parameter command */
2486SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetParam)
2487{ /*lint --e{715}*/
2488 SCIP_PARAM* param;
2489 char prompt[SCIP_MAXSTRLEN];
2490 char* valuestr;
2491 SCIP_Bool boolval;
2492 int intval;
2493 SCIP_Longint longintval;
2494 SCIP_Real realval;
2495 char charval;
2496 SCIP_Bool endoffile;
2497 SCIP_Bool error;
2498 SCIP_RETCODE retcode;
2499
2500 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2501
2502 /* get the parameter to set */
2503 param = (SCIP_PARAM*)SCIPdialogGetData(dialog);
2504
2505 /* depending on the parameter type, request a user input */
2506 switch( SCIPparamGetType(param) )
2507 {
2508 case SCIP_PARAMTYPE_BOOL:
2509 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %s, new value (TRUE/FALSE): ",
2510 SCIPparamGetBool(param) ? "TRUE" : "FALSE");
2511 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2512 if( endoffile )
2513 {
2514 *nextdialog = NULL;
2515 return SCIP_OKAY;
2516 }
2517 if( valuestr[0] == '\0' )
2518 return SCIP_OKAY;
2519
2520 boolval = parseBoolValue(scip, valuestr, &error);
2521
2522 if( error )
2523 {
2524 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s> for bool parameter <%s>. Must be <0>, <1>, <FALSE>, or <TRUE>.\n\n",
2525 valuestr, SCIPparamGetName(param));
2526 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2527 }
2528 else
2529 {
2530 assert(SCIPisBoolParamValid(scip, param, boolval));
2531
2532 retcode = SCIPchgBoolParam(scip, param, boolval);
2533 if( retcode == SCIP_PARAMETERWRONGVAL )
2534 {
2535 SCIPdialogMessage(scip, NULL, "\nWrong value <%s> for bool parameter <%s>.\n\n",
2536 valuestr, SCIPparamGetName(param));
2537 }
2538 else
2539 {
2540 SCIP_CALL( retcode );
2541 }
2542
2543 SCIPdialogMessage(scip, NULL, "%s = %s\n", SCIPparamGetName(param), SCIPparamGetBool(param) ? "TRUE" : "FALSE");
2544 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, boolval ? "TRUE" : "FALSE", TRUE) );
2545 }
2546
2547 break;
2548
2549 case SCIP_PARAMTYPE_INT:
2550 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %d, new value [%d,%d]: ",
2551 SCIPparamGetInt(param), SCIPparamGetIntMin(param), SCIPparamGetIntMax(param));
2552 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2553 if( endoffile )
2554 {
2555 *nextdialog = NULL;
2556 return SCIP_OKAY;
2557 }
2558 if( valuestr[0] == '\0' )
2559 return SCIP_OKAY;
2560
2561 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2562
2563 if( sscanf(valuestr, "%d", &intval) != 1 || !SCIPisIntParamValid(scip, param, intval) )
2564 {
2565 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s> for int parameter <%s>. Must be integral in range [%d,%d].\n\n",
2566 valuestr, SCIPparamGetName(param), SCIPparamGetIntMin(param), SCIPparamGetIntMax(param));
2567 }
2568 else
2569 {
2570 retcode = SCIPchgIntParam(scip, param, intval);
2571
2572 if( retcode == SCIP_PARAMETERWRONGVAL )
2573 {
2574 SCIPdialogMessage(scip, NULL, "\nWrong value <%s> for int parameter <%s>.\n\n",
2575 valuestr, SCIPparamGetName(param));
2576 }
2577 else
2578 {
2579 SCIP_CALL( retcode );
2580 }
2581
2582 SCIPdialogMessage(scip, NULL, "%s = %d\n", SCIPparamGetName(param), SCIPparamGetInt(param));
2583 }
2584
2585 break;
2586
2587 case SCIP_PARAMTYPE_LONGINT:
2588 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %" SCIP_LONGINT_FORMAT ", new value [%" SCIP_LONGINT_FORMAT ",%" SCIP_LONGINT_FORMAT "]: ",
2589 SCIPparamGetLongint(param), SCIPparamGetLongintMin(param), SCIPparamGetLongintMax(param));
2590 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2591 if( endoffile )
2592 {
2593 *nextdialog = NULL;
2594 return SCIP_OKAY;
2595 }
2596 if( valuestr[0] == '\0' )
2597 return SCIP_OKAY;
2598
2599 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2600
2601 if( sscanf(valuestr, "%" SCIP_LONGINT_FORMAT, &longintval) != 1 || !SCIPisLongintParamValid(scip, param, longintval) )
2602 {
2603 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s> for longint parameter <%s>. Must be integral in range [%" SCIP_LONGINT_FORMAT ",%" SCIP_LONGINT_FORMAT "].\n\n",
2604 valuestr, SCIPparamGetName(param), SCIPparamGetLongintMin(param), SCIPparamGetLongintMax(param));
2605 }
2606 else
2607 {
2608 retcode = SCIPchgLongintParam(scip, param, longintval);
2609 if( retcode == SCIP_PARAMETERWRONGVAL )
2610 {
2611 SCIPdialogMessage(scip, NULL, "\nWrong value <%s> for longint parameter <%s>.\n\n",
2612 valuestr, SCIPparamGetName(param));
2613 }
2614 else
2615 {
2616 SCIP_CALL( retcode );
2617 }
2618
2619 SCIPdialogMessage(scip, NULL, "%s = %" SCIP_LONGINT_FORMAT "\n", SCIPparamGetName(param),
2620 SCIPparamGetLongint(param));
2621 }
2622 break;
2623
2624 case SCIP_PARAMTYPE_REAL:
2625 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %.15g, new value [%.15g,%.15g]: ",
2626 SCIPparamGetReal(param), SCIPparamGetRealMin(param), SCIPparamGetRealMax(param));
2627 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2628 if( endoffile )
2629 {
2630 *nextdialog = NULL;
2631 return SCIP_OKAY;
2632 }
2633 if( valuestr[0] == '\0' )
2634 return SCIP_OKAY;
2635
2636 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2637
2638 if( sscanf(valuestr, "%" SCIP_REAL_FORMAT, &realval) != 1 || !SCIPisRealParamValid(scip, param, realval) )
2639 {
2640 SCIPdialogMessage(scip, NULL, "\nInvalid real parameter value <%s> for parameter <%s>. Must be in range [%.15g,%.15g].\n\n",
2641 valuestr, SCIPparamGetName(param), SCIPparamGetRealMin(param), SCIPparamGetRealMax(param));
2642 }
2643 else
2644 {
2645 retcode = SCIPchgRealParam(scip, param, realval);
2646 if( retcode == SCIP_PARAMETERWRONGVAL )
2647 {
2648 SCIPdialogMessage(scip, NULL, "\nWrong value <%s> for real parameter <%s>.\n\n",
2649 valuestr, SCIPparamGetName(param));
2650 }
2651 else
2652 {
2653 SCIP_CALL( retcode );
2654 }
2655
2656 SCIPdialogMessage(scip, NULL, "%s = %.15g\n", SCIPparamGetName(param), SCIPparamGetReal(param));
2657 }
2658 break;
2659
2660 case SCIP_PARAMTYPE_CHAR:
2661 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: <%c>, new value: ", SCIPparamGetChar(param));
2662 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2663 if( endoffile )
2664 {
2665 *nextdialog = NULL;
2666 return SCIP_OKAY;
2667 }
2668 if( valuestr[0] == '\0' )
2669 return SCIP_OKAY;
2670
2671 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2672
2673 /* coverity[secure_coding] */
2674 if( sscanf(valuestr, "%c", &charval) != 1 || !SCIPisCharParamValid(scip, param, charval) )
2675 {
2676 SCIPdialogMessage(scip, NULL, "\nInvalid char parameter value <%s>. Must be in set {%s}.\n\n",
2677 valuestr, SCIPparamGetCharAllowedValues(param));
2678 }
2679 else
2680 {
2681 retcode = SCIPchgCharParam(scip, param, charval);
2682 if( retcode == SCIP_PARAMETERWRONGVAL )
2683 {
2684 SCIPdialogMessage(scip, NULL, "\nWrong value <%s> for char parameter <%s>.\n\n",
2685 valuestr, SCIPparamGetName(param));
2686 }
2687 else
2688 {
2689 SCIP_CALL( retcode );
2690 }
2691
2692 SCIPdialogMessage(scip, NULL, "%s = %c\n", SCIPparamGetName(param), SCIPparamGetChar(param));
2693 }
2694 break;
2695
2696 case SCIP_PARAMTYPE_STRING:
2697 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: <%s>, new value: ", SCIPparamGetString(param));
2698 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2699 if( endoffile )
2700 {
2701 *nextdialog = NULL;
2702 return SCIP_OKAY;
2703 }
2704 if( valuestr[0] == '\0' )
2705 return SCIP_OKAY;
2706
2707 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2708
2709 if( !SCIPisStringParamValid(scip, param, valuestr) )
2710 {
2711 SCIPdialogMessage(scip, NULL, "\nInvalid character in string parameter.\n\n");
2712 }
2713 else
2714 {
2715 retcode = SCIPchgStringParam(scip, param, valuestr);
2716 if( retcode == SCIP_PARAMETERWRONGVAL )
2717 {
2718 SCIPdialogMessage(scip, NULL, "\nWrong value <%s> for string parameter <%s>.\n\n",
2719 valuestr, SCIPparamGetName(param));
2720 }
2721 else
2722 {
2723 SCIP_CALL( retcode );
2724 }
2725
2726 SCIPdialogMessage(scip, NULL, "%s = %s\n", SCIPparamGetName(param), SCIPparamGetString(param));
2727 }
2728 break;
2729
2730 default:
2731 SCIPerrorMessage("invalid parameter type\n");
2732 return SCIP_INVALIDDATA;
2733 }
2734
2735 return SCIP_OKAY;
2736}
2737
2738/** dialog description method for the set parameter command */
2739SCIP_DECL_DIALOGDESC(SCIPdialogDescSetParam)
2740{ /*lint --e{715}*/
2741 SCIP_PARAM* param;
2742 char valuestr[SCIP_MAXSTRLEN];
2743
2744 /* get the parameter to set */
2745 param = (SCIP_PARAM*)SCIPdialogGetData(dialog);
2746
2747 /* retrieve parameter's current value */
2748 switch( SCIPparamGetType(param) )
2749 {
2750 case SCIP_PARAMTYPE_BOOL:
2751 if( SCIPparamGetBool(param) )
2752 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "TRUE");
2753 else
2754 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "FALSE");
2755 break;
2756
2757 case SCIP_PARAMTYPE_INT:
2758 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "%d", SCIPparamGetInt(param));
2759 break;
2760
2761 case SCIP_PARAMTYPE_LONGINT:
2762 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "%" SCIP_LONGINT_FORMAT, SCIPparamGetLongint(param));
2763 break;
2764
2765 case SCIP_PARAMTYPE_REAL:
2766 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "%.15g", SCIPparamGetReal(param));
2767 if( strchr(valuestr, '.') == NULL && strchr(valuestr, 'e') == NULL )
2768 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "%.1f", SCIPparamGetReal(param));
2769 break;
2770
2771 case SCIP_PARAMTYPE_CHAR:
2772 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "%c", SCIPparamGetChar(param));
2773 break;
2774
2775 case SCIP_PARAMTYPE_STRING:
2776 (void) SCIPsnprintf(valuestr, SCIP_MAXSTRLEN, "%s", SCIPparamGetString(param));
2777 break;
2778
2779 default:
2780 SCIPerrorMessage("invalid parameter type\n");
2781 return SCIP_INVALIDDATA;
2782 }
2783 valuestr[SCIP_MAXSTRLEN-1] = '\0';
2784
2785 /* display parameter's description */
2786 SCIPdialogMessage(scip, NULL, "%s", SCIPparamGetDesc(param));
2787
2788 /* display parameter's current value */
2789 SCIPdialogMessage(scip, NULL, " [%s]", valuestr);
2790
2791 return SCIP_OKAY;
2792}
2793
2794/** dialog execution method for the fix parameter command */
2795SCIP_DECL_DIALOGEXEC(SCIPdialogExecFixParam)
2796{ /*lint --e{715}*/
2797 SCIP_PARAM* param;
2798 char prompt[SCIP_MAXSTRLEN];
2799 char* valuestr;
2800 SCIP_Bool fix;
2801 SCIP_Bool endoffile;
2802 SCIP_Bool error;
2803
2804 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2805
2806 /* get the parameter to fix */
2807 param = (SCIP_PARAM*)SCIPdialogGetData(dialog);
2808
2809 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current fixing status: %s, new value (TRUE/FALSE): ",
2810 SCIPparamIsFixed(param) ? "TRUE" : "FALSE");
2811 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2812 if( endoffile )
2813 {
2814 *nextdialog = NULL;
2815 return SCIP_OKAY;
2816 }
2817 if( valuestr[0] == '\0' )
2818 return SCIP_OKAY;
2819
2820 fix = parseBoolValue(scip, valuestr, &error);
2821
2822 if( !error )
2823 {
2824 SCIPparamSetFixed(param, fix);
2825 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, (fix ? "TRUE" : "FALSE"), TRUE) );
2826 SCIPdialogMessage(scip, NULL, "<%s> %s\n", SCIPparamGetName(param), (fix ? "fixed" : "unfixed"));
2827 }
2828 else
2829 {
2830 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
2831 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s> for fixing status. Must be <0>, <1>, <FALSE>, or <TRUE>.\n\n",
2832 valuestr);
2833 }
2834
2835 return SCIP_OKAY;
2836}
2837
2838/** dialog description method for the fix parameter command */
2839SCIP_DECL_DIALOGDESC(SCIPdialogDescFixParam)
2840{ /*lint --e{715}*/
2841 SCIP_PARAM* param;
2842
2843 /* get the parameter to set */
2844 param = (SCIP_PARAM*)SCIPdialogGetData(dialog);
2845
2846 /* display parameter's description */
2847 SCIPdialogMessage(scip, NULL, "%s", SCIPparamGetDesc(param));
2848
2849 /* display parameter's current fixing status */
2850 if( SCIPparamIsFixed(param) )
2851 SCIPdialogMessage(scip, NULL, " [fixed]");
2852 else
2853 SCIPdialogMessage(scip, NULL, " [not fixed]");
2854
2855 return SCIP_OKAY;
2856}
2857
2858/** dialog execution method for the set branching direction command */
2859SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetBranchingDirection)
2860{ /*lint --e{715}*/
2861 SCIP_VAR* var;
2862 char prompt[SCIP_MAXSTRLEN];
2863 char* valuestr;
2864 int direction;
2865 SCIP_Bool endoffile;
2866
2867 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2868
2869 /* branching priorities cannot be set, if no problem was created */
2870 if( SCIPgetStage(scip) == SCIP_STAGE_INIT )
2871 {
2872 SCIPdialogMessage(scip, NULL, "cannot set branching directions before problem was created\n");
2873 return SCIP_OKAY;
2874 }
2875
2876 /* get variable name from user */
2877 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "variable name: ", &valuestr, &endoffile) );
2878 if( endoffile )
2879 {
2880 *nextdialog = NULL;
2881 return SCIP_OKAY;
2882 }
2883 if( valuestr[0] == '\0' )
2884 return SCIP_OKAY;
2885
2886 /* find variable */
2887 var = SCIPfindVar(scip, valuestr);
2888 if( var == NULL )
2889 {
2890 SCIPdialogMessage(scip, NULL, "variable <%s> does not exist in problem\n", valuestr);
2891 return SCIP_OKAY;
2892 }
2893
2894 /* get new branching direction from user */
2895 switch( SCIPvarGetBranchDirection(var) )
2896 {
2897 case SCIP_BRANCHDIR_DOWNWARDS:
2898 direction = -1;
2899 break;
2900 case SCIP_BRANCHDIR_AUTO:
2901 direction = 0;
2902 break;
2903 case SCIP_BRANCHDIR_UPWARDS:
2904 direction = +1;
2905 break;
2906 case SCIP_BRANCHDIR_FIXED:
2907 default:
2908 SCIPerrorMessage("invalid preferred branching direction <%d> of variable <%s>\n",
2909 SCIPvarGetBranchDirection(var), SCIPvarGetName(var));
2910 return SCIP_INVALIDDATA;
2911 }
2912 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %d, new value: ", direction);
2913 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2914 if( endoffile )
2915 {
2916 *nextdialog = NULL;
2917 return SCIP_OKAY;
2918 }
2919 SCIPescapeString(prompt, SCIP_MAXSTRLEN, SCIPvarGetName(var));
2920 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "%s %s", prompt, valuestr);
2921 if( valuestr[0] == '\0' )
2922 return SCIP_OKAY;
2923
2924 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, prompt, FALSE) );
2925
2926 /* coverity[secure_coding] */
2927 if( sscanf(valuestr, "%d", &direction) != 1 )
2928 {
2929 SCIPdialogMessage(scip, NULL, "\ninvalid input <%s>\n\n", valuestr);
2930 return SCIP_OKAY;
2931 }
2932 if( direction < -1 || direction > +1 )
2933 {
2934 SCIPdialogMessage(scip, NULL, "\ninvalid input <%d>: direction must be -1, 0, or +1\n\n", direction);
2935 return SCIP_OKAY;
2936 }
2937
2938 /* set new branching direction */
2939 if( direction == -1 )
2940 SCIP_CALL( SCIPchgVarBranchDirection(scip, var, SCIP_BRANCHDIR_DOWNWARDS) );
2941 else if( direction == 0 )
2942 SCIP_CALL( SCIPchgVarBranchDirection(scip, var, SCIP_BRANCHDIR_AUTO) );
2943 else
2944 SCIP_CALL( SCIPchgVarBranchDirection(scip, var, SCIP_BRANCHDIR_UPWARDS) );
2945
2946 SCIPdialogMessage(scip, NULL, "branching direction of variable <%s> set to %d\n", SCIPvarGetName(var), direction);
2947
2948 return SCIP_OKAY;
2949}
2950
2951/** dialog execution method for the set branching priority command */
2952SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetBranchingPriority)
2953{ /*lint --e{715}*/
2954 SCIP_VAR* var;
2955 char prompt[SCIP_MAXSTRLEN];
2956 char* valuestr;
2957 int priority;
2958 SCIP_Bool endoffile;
2959
2960 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
2961
2962 /* branching priorities cannot be set, if no problem was created */
2963 if( SCIPgetStage(scip) == SCIP_STAGE_INIT )
2964 {
2965 SCIPdialogMessage(scip, NULL, "cannot set branching priorities before problem was created\n");
2966 return SCIP_OKAY;
2967 }
2968
2969 /* get variable name from user */
2970 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "variable name: ", &valuestr, &endoffile) );
2971 if( endoffile )
2972 {
2973 *nextdialog = NULL;
2974 return SCIP_OKAY;
2975 }
2976 if( valuestr[0] == '\0' )
2977 return SCIP_OKAY;
2978
2979 /* find variable */
2980 var = SCIPfindVar(scip, valuestr);
2981 if( var == NULL )
2982 {
2983 SCIPdialogMessage(scip, NULL, "variable <%s> does not exist in problem\n", valuestr);
2984 return SCIP_OKAY;
2985 }
2986
2987 /* get new branching priority from user */
2988 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %d, new value: ", SCIPvarGetBranchPriority(var));
2989 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
2990 if( endoffile )
2991 {
2992 *nextdialog = NULL;
2993 return SCIP_OKAY;
2994 }
2995 SCIPescapeString(prompt, SCIP_MAXSTRLEN, SCIPvarGetName(var));
2996 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "%s %s", prompt, valuestr);
2997 if( valuestr[0] == '\0' )
2998 return SCIP_OKAY;
2999
3000 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, prompt, FALSE) );
3001
3002 /* coverity[secure_coding] */
3003 if( sscanf(valuestr, "%d", &priority) != 1 )
3004 {
3005 SCIPdialogMessage(scip, NULL, "\ninvalid input <%s>\n\n", valuestr);
3006 return SCIP_OKAY;
3007 }
3008
3009 /* set new branching priority */
3010 SCIP_CALL( SCIPchgVarBranchPriority(scip, var, priority) );
3011 SCIPdialogMessage(scip, NULL, "branching priority of variable <%s> set to %d\n", SCIPvarGetName(var), SCIPvarGetBranchPriority(var));
3012
3013 return SCIP_OKAY;
3014}
3015
3016/** dialog execution method for the set heuristics aggressive command */
3017SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetHeuristicsAggressive)
3018{ /*lint --e{715}*/
3019 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3020
3021 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3022
3023 SCIP_CALL( SCIPsetHeuristics(scip, SCIP_PARAMSETTING_AGGRESSIVE, FALSE) );
3024
3025 return SCIP_OKAY;
3026}
3027
3028/** dialog execution method for the set heuristics default command */
3029SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetHeuristicsDefault)
3030{ /*lint --e{715}*/
3031 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3032
3033 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3034
3035 SCIP_CALL( SCIPsetHeuristics(scip, SCIP_PARAMSETTING_DEFAULT, FALSE) );
3036
3037 return SCIP_OKAY;
3038}
3039
3040/** dialog execution method for the set heuristics fast command */
3041SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetHeuristicsFast)
3042{ /*lint --e{715}*/
3043 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3044
3045 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3046
3047 SCIP_CALL( SCIPsetHeuristics(scip, SCIP_PARAMSETTING_FAST, FALSE) );
3048
3049 return SCIP_OKAY;
3050}
3051
3052/** dialog execution method for the set heuristics off command */
3053SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetHeuristicsOff)
3054{ /*lint --e{715}*/
3055 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3056
3057 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3058
3059 SCIP_CALL( SCIPsetHeuristics(scip, SCIP_PARAMSETTING_OFF, FALSE) );
3060
3061 return SCIP_OKAY;
3062}
3063
3064/** dialog execution method for the set presolving aggressive command */
3065SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetPresolvingAggressive)
3066{ /*lint --e{715}*/
3067 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3068
3069 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3070
3071 SCIP_CALL( SCIPsetPresolving(scip, SCIP_PARAMSETTING_AGGRESSIVE, FALSE) );
3072
3073 return SCIP_OKAY;
3074}
3075
3076/** dialog execution method for the set presolving default command */
3077SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetPresolvingDefault)
3078{ /*lint --e{715}*/
3079 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3080
3081 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3082
3083 SCIP_CALL( SCIPsetPresolving(scip, SCIP_PARAMSETTING_DEFAULT, FALSE) );
3084
3085 return SCIP_OKAY;
3086}
3087
3088/** dialog execution method for the set presolving fast command */
3089SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetPresolvingFast)
3090{ /*lint --e{715}*/
3091 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3092
3093 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3094
3095 SCIP_CALL( SCIPsetPresolving(scip, SCIP_PARAMSETTING_FAST, FALSE) );
3096
3097 return SCIP_OKAY;
3098}
3099
3100/** dialog execution method for the set presolving off command */
3101SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetPresolvingOff)
3102{ /*lint --e{715}*/
3103 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3104
3105 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3106
3107 SCIP_CALL( SCIPsetPresolving(scip, SCIP_PARAMSETTING_OFF, FALSE) );
3108
3109 return SCIP_OKAY;
3110}
3111
3112/** dialog execution method for the set separating aggressive command */
3113SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetSeparatingAggressive)
3114{ /*lint --e{715}*/
3115 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3116
3117 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3118
3119 SCIP_CALL( SCIPsetSeparating(scip, SCIP_PARAMSETTING_AGGRESSIVE, FALSE) );
3120
3121 return SCIP_OKAY;
3122}
3123
3124/** dialog execution method for the set separating default command */
3125SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetSeparatingDefault)
3126{ /*lint --e{715}*/
3127 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3128
3129 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3130
3131 SCIP_CALL( SCIPsetSeparating(scip, SCIP_PARAMSETTING_DEFAULT, FALSE) );
3132
3133 return SCIP_OKAY;
3134}
3135
3136/** dialog execution method for the set separating fast command */
3137SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetSeparatingFast)
3138{ /*lint --e{715}*/
3139 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3140
3141 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3142
3143 SCIP_CALL( SCIPsetSeparating(scip, SCIP_PARAMSETTING_FAST, FALSE) );
3144
3145 return SCIP_OKAY;
3146}
3147
3148/** dialog execution method for the set separating off command */
3149SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetSeparatingOff)
3150{ /*lint --e{715}*/
3151 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3152
3153 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3154
3155 SCIP_CALL( SCIPsetSeparating(scip, SCIP_PARAMSETTING_OFF, FALSE) );
3156
3157 return SCIP_OKAY;
3158}
3159
3160/** dialog execution method for the set emphasis counter command */
3161SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisCounter)
3162{ /*lint --e{715}*/
3163 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3164
3165 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3166
3167 /* set parameters for counting problems; we do not reset parameters to their default values first, since the user
3168 * should be able to combine emphasis settings in the interactive shell
3169 */
3170 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_COUNTER, FALSE) );
3171
3172 return SCIP_OKAY;
3173}
3174
3175/** dialog execution method for the set emphasis cpsolver command */
3176SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisCpsolver)
3177{ /*lint --e{715}*/
3178 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3179
3180 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3181
3182 /* set parameters for CP like search problems; we do not reset parameters to their default values first, since the
3183 * user should be able to combine emphasis settings in the interactive shell
3184 */
3185 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_CPSOLVER, FALSE) );
3186
3187 return SCIP_OKAY;
3188}
3189
3190/** dialog execution method for the set emphasis easy CIP command */
3191SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisEasycip)
3192{ /*lint --e{715}*/
3193 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3194
3195 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3196
3197 /* set parameters for easy CIP problems; we do not reset parameters to their default values first, since the user
3198 * should be able to combine emphasis settings in the interactive shell
3199 */
3200 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_EASYCIP, FALSE) );
3201
3202 return SCIP_OKAY;
3203}
3204
3205/** dialog execution method for the set emphasis feasibility command */
3206SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisFeasibility)
3207{ /*lint --e{715}*/
3208 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3209
3210 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3211
3212 /* set parameters for feasibility problems; we do not reset parameters to their default values first, since the user
3213 * should be able to combine emphasis settings in the interactive shell
3214 */
3215 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_FEASIBILITY, FALSE) );
3216
3217 return SCIP_OKAY;
3218}
3219
3220/** dialog execution method for the set emphasis hard LP command */
3221SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisHardlp)
3222{ /*lint --e{715}*/
3223 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3224
3225 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3226
3227 /* set parameters for problems with hard LP; we do not reset parameters to their default values first, since the user
3228 * should be able to combine emphasis settings in the interactive shell
3229 */
3230 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_HARDLP, FALSE) );
3231
3232 return SCIP_OKAY;
3233}
3234
3235/** dialog execution method for the set emphasis optimality command */
3236SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisOptimality)
3237{ /*lint --e{715}*/
3238 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3239
3240 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3241
3242 /* set parameters for problems to prove optimality fast; we do not reset parameters to their default values first,
3243 * since the user should be able to combine emphasis settings in the interactive shell
3244 */
3245 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_OPTIMALITY, FALSE) );
3246
3247 return SCIP_OKAY;
3248}
3249
3250/** dialog execution method for the set emphasis numerics command */
3251SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisNumerics)
3252{ /*lint --e{715}*/
3253 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3254
3255 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3256
3257 /* set parameters for problems to prove optimality fast; we do not reset parameters to their default values first,
3258 * since the user should be able to combine emphasis settings in the interactive shell
3259 */
3260 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_NUMERICS, FALSE) );
3261
3262 return SCIP_OKAY;
3263}
3264
3265/** dialog execution method for the set emphasis benchmark command */
3266SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetEmphasisBenchmark)
3267{ /*lint --e{715}*/
3268 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3269
3270 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3271
3272 /* set parameters for problems to run in benchmark mode; we do not reset parameters to their default values first,
3273 * since the user should be able to combine emphasis settings in the interactive shell
3274 */
3275 SCIP_CALL( SCIPsetEmphasis(scip, SCIP_PARAMEMPHASIS_BENCHMARK, FALSE) );
3276
3277 return SCIP_OKAY;
3278}
3279
3280/** dialog execution method for the set limits objective command */
3281SCIP_DECL_DIALOGEXEC(SCIPdialogExecSetLimitsObjective)
3282{ /*lint --e{715}*/
3283 char prompt[SCIP_MAXSTRLEN];
3284 char* valuestr;
3285 SCIP_Real objlim;
3286 SCIP_Bool endoffile;
3287
3288 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3289
3290 /* objective limit cannot be set, if no problem was created */
3291 if( SCIPgetStage(scip) == SCIP_STAGE_INIT )
3292 {
3293 SCIPdialogMessage(scip, NULL, "cannot set objective limit before problem was created\n");
3294 return SCIP_OKAY;
3295 }
3296
3297 /* get new objective limit from user */
3298 (void) SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "current value: %.15g, new value: ", SCIPgetObjlimit(scip));
3299 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &valuestr, &endoffile) );
3300 if( endoffile )
3301 {
3302 *nextdialog = NULL;
3303 return SCIP_OKAY;
3304 }
3305 if( valuestr[0] == '\0' )
3306 return SCIP_OKAY;
3307
3308 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, valuestr, TRUE) );
3309
3310 /* coverity[secure_coding] */
3311 if( sscanf(valuestr, "%" SCIP_REAL_FORMAT, &objlim) != 1 )
3312 {
3313 SCIPdialogMessage(scip, NULL, "\ninvalid input <%s>\n\n", valuestr);
3314 return SCIP_OKAY;
3315 }
3316
3317 /* check, if new objective limit is valid */
3318 if( SCIPgetStage(scip) > SCIP_STAGE_PROBLEM
3319 && SCIPtransformObj(scip, objlim) > SCIPtransformObj(scip, SCIPgetObjlimit(scip)) )
3320 {
3321 SCIPdialogMessage(scip, NULL, "\ncannot relax objective limit from %.15g to %.15g after problem was transformed\n\n",
3322 SCIPgetObjlimit(scip), objlim);
3323 return SCIP_OKAY;
3324 }
3325
3326 /* set new objective limit */
3327 SCIP_CALL( SCIPsetObjlimit(scip, objlim) );
3328 SCIPdialogMessage(scip, NULL, "objective value limit set to %.15g\n", SCIPgetObjlimit(scip));
3329
3330 return SCIP_OKAY;
3331}
3332
3333/** dialog execution method for the write LP command */
3334static
3335SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteLp)
3336{ /*lint --e{715}*/
3337 char* filename;
3338 SCIP_Bool endoffile;
3339
3340 SCIPdialogMessage(scip, NULL, "\n");
3341
3342 /* node relaxations only exist in solving & solved stage */
3343 if( SCIPgetStage(scip) < SCIP_STAGE_SOLVING )
3344 {
3345 SCIPdialogMessage(scip, NULL, "There is no node LP relaxation before solving starts\n");
3346 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3347 return SCIP_OKAY;
3348 }
3349 if( SCIPgetStage(scip) >= SCIP_STAGE_SOLVED )
3350 {
3351 SCIPdialogMessage(scip, NULL, "There is no node LP relaxation after problem was solved\n");
3352 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3353 return SCIP_OKAY;
3354 }
3355
3356 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3357 if( endoffile )
3358 {
3359 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3360 return SCIP_OKAY;
3361 }
3362 if( filename[0] != '\0' )
3363 {
3364 SCIP_RETCODE retcode;
3365
3366 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3367 retcode = SCIPwriteLP(scip, filename);
3368
3369 if( retcode == SCIP_FILECREATEERROR )
3370 {
3371 SCIPdialogMessage(scip, NULL, "error not creating file <%s>\n", filename);
3372 }
3373 else
3374 {
3375 SCIP_CALL( retcode );
3376
3377 SCIPdialogMessage(scip, NULL, "written node LP relaxation to file <%s>\n", filename);
3378 }
3379 }
3380
3381 SCIPdialogMessage(scip, NULL, "\n");
3382
3383 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3384
3385 return SCIP_OKAY;
3386}
3387
3388/** dialog execution method for the write MIP command */
3389static
3390SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteMip)
3391{ /*lint --e{715}*/
3392 char command[SCIP_MAXSTRLEN];
3393 char filename[SCIP_MAXSTRLEN];
3394 SCIP_Bool endoffile;
3395 char* valuestr;
3396 SCIP_Bool offset;
3397 SCIP_Bool generic;
3398 SCIP_Bool lazyconss;
3399 SCIP_Bool error;
3400
3401 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3402
3403 /* node relaxations only exist in solving & solved stage */
3404 if( SCIPgetStage(scip) < SCIP_STAGE_SOLVING )
3405 {
3406 SCIPdialogMessage(scip, NULL, "There is no node MIP relaxation before solving starts\n");
3407 return SCIP_OKAY;
3408 }
3409 if( SCIPgetStage(scip) >= SCIP_STAGE_SOLVED )
3410 {
3411 SCIPdialogMessage(scip, NULL, "There is no node MIP relaxation after problem was solved\n");
3412 return SCIP_OKAY;
3413 }
3414
3415 /* first get file name */
3416 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &valuestr, &endoffile) );
3417 if( endoffile )
3418 {
3419 *nextdialog = NULL;
3420 return SCIP_OKAY;
3421 }
3422 if( valuestr[0] == '\0' )
3423 return SCIP_OKAY;
3424
3425 (void)SCIPstrncpy(filename, valuestr, SCIP_MAXSTRLEN);
3426
3427 /* second ask for generic variable and row names */
3428 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog,
3429 "using generic variable and row names (TRUE/FALSE): ",
3430 &valuestr, &endoffile) );
3431
3432 if( endoffile )
3433 {
3434 *nextdialog = NULL;
3435 return SCIP_OKAY;
3436 }
3437 if( valuestr[0] == '\0' )
3438 return SCIP_OKAY;
3439
3440 generic = parseBoolValue(scip, valuestr, &error);
3441
3442 if( error )
3443 {
3444 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s>. Must be <0>, <1>, <FALSE>, or <TRUE>.\n\n",
3445 valuestr);
3446
3447 return SCIP_OKAY;
3448 }
3449
3450 /* adjust command and add to the history */
3451 SCIPescapeString(command, SCIP_MAXSTRLEN, filename);
3452 (void) SCIPsnprintf(command, SCIP_MAXSTRLEN, "%s %s", command, generic ? "TRUE" : "FALSE");
3453
3454 /* third ask if for adjusting the objective offset */
3455 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog,
3456 "using original objective function (TRUE/FALSE): ",
3457 &valuestr, &endoffile) );
3458
3459 if( endoffile )
3460 {
3461 *nextdialog = NULL;
3462 return SCIP_OKAY;
3463 }
3464 if( valuestr[0] == '\0' )
3465 return SCIP_OKAY;
3466
3467 offset = parseBoolValue(scip, valuestr, &error);
3468
3469 if( error )
3470 {
3471 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s>. Must be <0>, <1>, <FALSE>, or <TRUE>.\n\n",
3472 valuestr);
3473
3474 return SCIP_OKAY;
3475 }
3476
3477 (void) SCIPsnprintf(command, SCIP_MAXSTRLEN, "%s %s", command, offset ? "TRUE" : "FALSE");
3478 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, command, FALSE) );
3479
3480 /* fourth ask for lazy constraints */
3481 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog,
3482 "output removable rows as lazy constraints (TRUE/FALSE): ",
3483 &valuestr, &endoffile) );
3484
3485 if( endoffile )
3486 {
3487 *nextdialog = NULL;
3488 return SCIP_OKAY;
3489 }
3490 if( valuestr[0] == '\0' )
3491 return SCIP_OKAY;
3492
3493 lazyconss = parseBoolValue(scip, valuestr, &error);
3494
3495 if( error )
3496 {
3497 SCIPdialogMessage(scip, NULL, "\nInvalid value <%s>. Must be <0>, <1>, <FALSE>, or <TRUE>.\n\n",
3498 valuestr);
3499
3500 return SCIP_OKAY;
3501 }
3502
3503 /* adjust command and add to the history */
3504 SCIPescapeString(command, SCIP_MAXSTRLEN, filename);
3505 (void) SCIPsnprintf(command, SCIP_MAXSTRLEN, "%s %s", command, lazyconss ? "TRUE" : "FALSE");
3506
3507 /* execute command */
3508 SCIP_CALL( SCIPwriteMIP(scip, filename, generic, offset, lazyconss) );
3509 SCIPdialogMessage(scip, NULL, "written node MIP relaxation to file <%s>\n", filename);
3510
3511 SCIPdialogMessage(scip, NULL, "\n");
3512
3513 return SCIP_OKAY;
3514}
3515
3516
3517/** dialog execution method for the write NLP command */
3518static
3519SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteNlp)
3520{ /*lint --e{715}*/
3521 char* filename;
3522 SCIP_Bool endoffile;
3523
3524 SCIPdialogMessage(scip, NULL, "\n");
3525
3526 /* node relaxations only exist in solving & solved stage */
3527 if( SCIPgetStage(scip) < SCIP_STAGE_SOLVING )
3528 {
3529 SCIPdialogMessage(scip, NULL, "There is no node NLP relaxation before solving starts\n");
3530 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3531 return SCIP_OKAY;
3532 }
3533 if( SCIPgetStage(scip) >= SCIP_STAGE_SOLVED )
3534 {
3535 SCIPdialogMessage(scip, NULL, "There is no node NLP relaxation after problem was solved\n");
3536 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3537 return SCIP_OKAY;
3538 }
3539 if( !SCIPisNLPConstructed(scip) )
3540 {
3541 SCIPdialogMessage(scip, NULL, "There has been no node NLP relaxation constructed\n");
3542 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3543 return SCIP_OKAY;
3544 }
3545
3546 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3547 if( endoffile )
3548 {
3549 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3550 return SCIP_OKAY;
3551 }
3552 if( filename[0] != '\0' )
3553 {
3554 SCIP_RETCODE retcode;
3555
3556 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3557 retcode = SCIPwriteNLP(scip, filename);
3558
3559 if( retcode == SCIP_FILECREATEERROR )
3560 {
3561 SCIPdialogMessage(scip, NULL, "error not creating file <%s>\n", filename);
3562 }
3563 else
3564 {
3565 SCIP_CALL( retcode );
3566
3567 SCIPdialogMessage(scip, NULL, "written node NLP relaxation to file <%s>\n", filename);
3568 }
3569 }
3570
3571 SCIPdialogMessage(scip, NULL, "\n");
3572
3573 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3574
3575 return SCIP_OKAY;
3576}
3577
3578/** dialog execution method for the write problem command */
3579static
3580SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteProblem)
3581{ /*lint --e{715}*/
3582 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3583
3584 if( SCIPgetStage(scip) >= SCIP_STAGE_PROBLEM )
3585 {
3586 SCIP_CALL( writeProblem(scip, dialog, dialoghdlr, nextdialog, FALSE, FALSE) );
3587 }
3588 else
3589 SCIPdialogMessage(scip, NULL, "no problem available\n");
3590
3591 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3592
3593 return SCIP_OKAY;
3594}
3595
3596/** dialog execution method for the write generic problem command */
3597static
3598SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteGenProblem)
3599{ /*lint --e{715}*/
3600 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3601
3602 if( SCIPgetStage(scip) >= SCIP_STAGE_PROBLEM )
3603 {
3604 SCIP_CALL( writeProblem(scip, dialog, dialoghdlr, nextdialog, FALSE, TRUE) );
3605 }
3606 else
3607 SCIPdialogMessage(scip, NULL, "no problem available\n");
3608
3609 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3610
3611 return SCIP_OKAY;
3612}
3613
3614/** dialog execution method for the write solution command */
3615static
3616SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteSolution)
3617{ /*lint --e{715}*/
3618 char* filename;
3619 SCIP_Bool endoffile;
3620
3621 SCIPdialogMessage(scip, NULL, "\n");
3622
3623 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3624 if( endoffile )
3625 {
3626 *nextdialog = NULL;
3627 return SCIP_OKAY;
3628 }
3629 if( filename[0] != '\0' )
3630 {
3631 FILE* file;
3632
3633 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3634
3635 file = fopen(filename, "w");
3636 if( file == NULL )
3637 {
3638 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
3639 SCIPdialoghdlrClearBuffer(dialoghdlr);
3640 }
3641 else
3642 {
3643 SCIP_Bool printzeros;
3644
3645 SCIPinfoMessage(scip, file, "solution status: ");
3646 SCIP_CALL_FINALLY( SCIPprintStatus(scip, file), fclose(file) );
3647
3648 SCIP_CALL_FINALLY( SCIPgetBoolParam(scip, "write/printzeros", &printzeros), fclose(file) );
3649
3650 SCIPinfoMessage(scip, file, "\n");
3651 SCIP_CALL_FINALLY( SCIPprintBestSol(scip, file, printzeros), fclose(file) );
3652
3653 SCIPdialogMessage(scip, NULL, "written solution information to file <%s>\n", filename);
3654 fclose(file);
3655 }
3656 } /*lint !e593*/
3657
3658 SCIPdialogMessage(scip, NULL, "\n");
3659
3660 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3661
3662 return SCIP_OKAY;
3663}
3664
3665/** dialog execution method for the write mipstart command */
3666static
3667SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteMIPStart)
3668{ /*lint --e{715}*/
3669 char* filename;
3670 SCIP_Bool endoffile;
3671
3672 SCIPdialogMessage(scip, NULL, "\n");
3673
3674 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3675 if( endoffile )
3676 {
3677 *nextdialog = NULL;
3678 return SCIP_OKAY;
3679 }
3680 if( filename[0] != '\0' )
3681 {
3682 FILE* file;
3683
3684 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3685
3686 file = fopen(filename, "w");
3687 if( file == NULL )
3688 {
3689 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
3690 SCIPdialoghdlrClearBuffer(dialoghdlr);
3691 }
3692 else
3693 {
3694 SCIP_SOL* sol;
3695
3696 SCIPinfoMessage(scip, file, "\n");
3697
3698 sol = SCIPgetBestSol(scip);
3699
3700 if( sol == NULL )
3701 {
3702 SCIPdialogMessage(scip, NULL, "no mip start available\n");
3703 }
3704 else
3705 {
3706 SCIP_CALL_FINALLY( SCIPprintMIPStart(scip, sol, file), fclose(file) );
3707
3708 SCIPdialogMessage(scip, NULL, "written mip start information to file <%s>\n", filename);
3709 }
3710 fclose(file);
3711 }
3712 } /*lint !e593*/
3713
3714 SCIPdialogMessage(scip, NULL, "\n");
3715
3716 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3717
3718 return SCIP_OKAY;
3719}
3720
3721/** dialog execution method for writing command line history */
3722static
3723SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteCommandHistory)
3724{ /*lint --e{715}*/
3725 char* filename;
3726 SCIP_Bool endoffile;
3727
3728 SCIPdialogMessage(scip, NULL, "\n");
3729
3730 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3731 if( endoffile )
3732 {
3733 *nextdialog = NULL;
3734 return SCIP_OKAY;
3735 }
3736 if( filename[0] != '\0' )
3737 {
3738 SCIP_RETCODE retcode;
3739
3740 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3741
3742 retcode = SCIPdialogWriteHistory(filename);
3743
3744 if( retcode != SCIP_OKAY )
3745 {
3746 SCIPdialogMessage(scip, NULL, "error writing to file <%s>\n"
3747 "check that the directory exists and that you have correct permissions\n", filename);
3748 SCIPdialoghdlrClearBuffer(dialoghdlr);
3749 }
3750 else
3751 {
3752 SCIPdialogMessage(scip, NULL, "wrote available command line history to <%s>\n", filename);
3753 }
3754 }
3755
3756 SCIPdialogMessage(scip, NULL, "\n");
3757
3758 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3759
3760 return SCIP_OKAY;
3761}
3762
3763/** dialog execution method for the write finitesolution command */
3764static
3765SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteFiniteSolution)
3766{ /*lint --e{715}*/
3767 char* filename;
3768 SCIP_Bool endoffile;
3769
3770 SCIPdialogMessage(scip, NULL, "\n");
3771
3772 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3773 if( endoffile )
3774 {
3775 *nextdialog = NULL;
3776 return SCIP_OKAY;
3777 }
3778 if( filename[0] != '\0' )
3779 {
3780 FILE* file;
3781
3782 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3783
3784 file = fopen(filename, "w");
3785 if( file == NULL )
3786 {
3787 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
3788 SCIPdialoghdlrClearBuffer(dialoghdlr);
3789 }
3790 else
3791 {
3792 SCIP_SOL* bestsol = SCIPgetBestSol(scip);
3793 SCIP_Bool printzeros;
3794
3795 SCIPinfoMessage(scip, file, "solution status: ");
3796
3797 SCIP_CALL_FINALLY( SCIPprintStatus(scip, file), fclose(file) );
3798
3799 SCIPinfoMessage(scip, file, "\n");
3800
3801 if( bestsol != NULL )
3802 {
3803 SCIP_SOL* sol;
3804 SCIP_Bool success;
3805
3806 SCIP_CALL_FINALLY( SCIPcreateFiniteSolCopy(scip, &sol, bestsol, &success), fclose(file) );
3807
3808 SCIP_CALL_FINALLY( SCIPgetBoolParam(scip, "write/printzeros", &printzeros), fclose(file) );
3809
3810 if( sol != NULL )
3811 {
3812 SCIP_CALL_FINALLY( SCIPprintSol(scip, sol, file, printzeros), fclose(file) );
3813
3814 SCIPdialogMessage(scip, NULL, "written solution information to file <%s>\n", filename);
3815
3816 SCIP_CALL_FINALLY( SCIPfreeSol(scip, &sol), fclose(file) );
3817 }
3818 else
3819 {
3820 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "finite solution could not be created\n");
3821 SCIPdialogMessage(scip, NULL, "finite solution could not be created\n");
3822 }
3823 }
3824 else
3825 {
3826 SCIPmessageFPrintInfo(SCIPgetMessagehdlr(scip), file, "no solution available\n");
3827 SCIPdialogMessage(scip, NULL, "no solution available\n");
3828 }
3829
3830 fclose(file);
3831 }
3832 } /*lint !e593*/
3833
3834 SCIPdialogMessage(scip, NULL, "\n");
3835
3836 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3837
3838 return SCIP_OKAY;
3839}
3840
3841/** dialog execution method for the write statistics command */
3842static
3843SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteStatistics)
3844{ /*lint --e{715}*/
3845 char* filename;
3846 SCIP_Bool endoffile;
3847
3848 SCIPdialogMessage(scip, NULL, "\n");
3849
3850 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, "enter filename: ", &filename, &endoffile) );
3851 if( endoffile )
3852 {
3853 *nextdialog = NULL;
3854 return SCIP_OKAY;
3855 }
3856 if( filename[0] != '\0' )
3857 {
3858 FILE* file;
3859
3860 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, filename, TRUE) );
3861
3862 file = fopen(filename, "w");
3863 if( file == NULL )
3864 {
3865 SCIPdialogMessage(scip, NULL, "error creating file <%s>\n", filename);
3866 SCIPprintSysError(filename);
3867 SCIPdialoghdlrClearBuffer(dialoghdlr);
3868 }
3869 else
3870 {
3871 SCIP_CALL_FINALLY( SCIPprintStatistics(scip, file), fclose(file) );
3872
3873 SCIPdialogMessage(scip, NULL, "written statistics to file <%s>\n", filename);
3874 fclose(file);
3875 }
3876 } /*lint !e593*/
3877
3878 SCIPdialogMessage(scip, NULL, "\n");
3879
3880 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3881
3882 return SCIP_OKAY;
3883}
3884
3885/** dialog execution method for the write transproblem command */
3886static
3887SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteTransproblem)
3888{ /*lint --e{715}*/
3889 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3890
3891 if( SCIPgetStage(scip) >= SCIP_STAGE_TRANSFORMED )
3892 {
3893 SCIP_CALL( writeProblem(scip, dialog, dialoghdlr, nextdialog, TRUE, FALSE) );
3894 }
3895 else
3896 SCIPdialogMessage(scip, NULL, "no transformed problem available\n");
3897
3898 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3899
3900 return SCIP_OKAY;
3901}
3902
3903/** dialog execution method for the write generic transproblem command */
3904static
3905SCIP_DECL_DIALOGEXEC(SCIPdialogExecWriteGenTransproblem)
3906{ /*lint --e{715}*/
3907 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3908
3909 if( SCIPgetStage(scip) >= SCIP_STAGE_TRANSFORMED )
3910 {
3911 SCIP_CALL( writeProblem(scip, dialog, dialoghdlr, nextdialog, TRUE, TRUE) );
3912 }
3913 else
3914 SCIPdialogMessage(scip, NULL, "no transformed problem available\n");
3915
3916 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3917
3918 return SCIP_OKAY;
3919}
3920
3921/** dialog execution method for solution validation */
3922static
3923SCIP_DECL_DIALOGEXEC(SCIPdialogExecValidateSolve)
3924{ /*lint --e{715}*/
3925 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3926
3927 if( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
3928 {
3929 SCIPdialogMessage(scip, NULL, "\nNo problem available for validation\n");
3930 }
3931 else
3932 {
3933 char *refstrs[2];
3934 SCIP_Real refvals[2] = {SCIP_INVALID, SCIP_INVALID};
3935 const char* primaldual[] = {"primal", "dual"};
3936 char prompt[SCIP_MAXSTRLEN];
3937 int i;
3938
3939 /* read in primal and dual reference values */
3940 for( i = 0; i < 2; ++i )
3941 {
3942 char * endptr;
3943 SCIP_Bool endoffile;
3944
3945 (void)SCIPsnprintf(prompt, SCIP_MAXSTRLEN, "Please enter %s validation reference bound (or use +/-infinity) :", primaldual[i]);
3946 SCIP_CALL( SCIPdialoghdlrGetWord(dialoghdlr, dialog, prompt, &(refstrs[i]), &endoffile) );
3947
3948 /* treat no input as SCIP_UNKNOWN */
3949 if( endoffile || strncmp(refstrs[i], "\0", 1) == 0 ) /*lint !e840*/
3950 {
3951 refvals[i] = SCIP_UNKNOWN;
3952 }
3953 else if( strncmp(refstrs[i], "q", 1) == 0 )
3954 break;
3955 else if( ! SCIPparseReal(scip, refstrs[i], &refvals[i], &endptr) )
3956 {
3957 SCIPdialogMessage(scip, NULL, "Could not parse value '%s', please try again or type 'q' to quit\n", refstrs[i]);
3958 --i; /*lint !e850*/
3959 }
3960 }
3961
3962 /* check if the loop finished by checking the value of 'i'. Do not validate if user input is missing */
3963 if( i == 2 ) /*lint !e850*/
3964 {
3965 assert(refvals[0] != SCIP_INVALID); /*lint !e777*/
3966 assert(refvals[1] != SCIP_INVALID); /*lint !e777*/
3967 SCIP_CALL( SCIPvalidateSolve(scip, refvals[0], refvals[1], SCIPfeastol(scip), FALSE, NULL, NULL, NULL) );
3968 }
3969 }
3970
3971 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3972
3973 return SCIP_OKAY;
3974}
3975
3976/** dialog execution method for linear constraint type classification */
3977SCIP_DECL_DIALOGEXEC(SCIPdialogExecDisplayLinearConsClassification)
3978{ /*lint --e{715}*/
3979 SCIP_CALL( SCIPdialoghdlrAddHistory(dialoghdlr, dialog, NULL, FALSE) );
3980
3981 if( SCIPgetStage(scip) < SCIP_STAGE_PROBLEM )
3982 SCIPdialogMessage(scip, NULL, "\nNo problem available for classification\n");
3983 else
3984 {
3985 SCIP_LINCONSSTATS* linconsstats;
3986
3987 SCIP_CALL( SCIPlinConsStatsCreate(scip, &linconsstats) );
3988
3989 /* call linear constraint classification and print the statistics to standard out */
3990 SCIP_CALL( SCIPclassifyConstraintTypesLinear(scip, linconsstats) );
3991
3992 SCIPprintLinConsStats(scip, NULL, linconsstats);
3993
3994 SCIPlinConsStatsFree(scip, &linconsstats);
3995 }
3996
3997 *nextdialog = SCIPdialoghdlrGetRoot(dialoghdlr);
3998
3999 return SCIP_OKAY;
4000}
4001
4002/** creates a root dialog */
4003SCIP_RETCODE SCIPcreateRootDialog(
4004 SCIP* scip, /**< SCIP data structure */
4005 SCIP_DIALOG** root /**< pointer to store the root dialog */
4006 )
4007{
4008 SCIP_CALL( SCIPincludeDialog(scip, root,
4009 dialogCopyDefault,
4010 SCIPdialogExecMenuLazy, NULL, NULL,
4011 "SCIP", "SCIP's main menu", TRUE, NULL) );
4012
4013 SCIP_CALL( SCIPsetRootDialog(scip, *root) );
4014 SCIP_CALL( SCIPreleaseDialog(scip, root) );
4015 *root = SCIPgetRootDialog(scip);
4016
4017 return SCIP_OKAY;
4018}
4019
4020
4021/** includes or updates the default dialog menus in SCIP except for menus "fix" and "set" */
4022SCIP_RETCODE SCIPincludeDialogDefaultBasic(
4023 SCIP* scip /**< SCIP data structure */
4024 )
4025{
4026 SCIP_DIALOG* root;
4027 SCIP_DIALOG* submenu;
4028 SCIP_DIALOG* dialog;
4029
4030 /* root menu */
4031 root = SCIPgetRootDialog(scip);
4032 if( root == NULL )
4033 {
4034 SCIP_CALL( SCIPcreateRootDialog(scip, &root) );
4035 }
4036
4037 /* change */
4038 if( !SCIPdialogHasEntry(root, "change") )
4039 {
4040 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
4041 NULL,
4042 SCIPdialogExecMenu, NULL, NULL,
4043 "change", "change the problem", TRUE, NULL) );
4044 SCIP_CALL( SCIPaddDialogEntry(scip, root, submenu) );
4045 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
4046 }
4047 if( SCIPdialogFindEntry(root, "change", &submenu) != 1 )
4048 {
4049 SCIPerrorMessage("change sub menu not found\n");
4050 return SCIP_PLUGINNOTFOUND;
4051 }
4052
4053 /* change add */
4054 if( !SCIPdialogHasEntry(submenu, "add") )
4055 {
4056 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4057 NULL,
4058 SCIPdialogExecChangeAddCons, NULL, NULL,
4059 "add", "add constraint", FALSE, NULL) );
4060 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4061 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4062 }
4063
4064 /* change bounds */
4065 if( !SCIPdialogHasEntry(submenu, "bounds") )
4066 {
4067 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4068 NULL,
4069 SCIPdialogExecChangeBounds, NULL, NULL,
4070 "bounds", "change bounds of a variable", FALSE, NULL) );
4071 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4072 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4073 }
4074
4075 /* free transformed problem */
4076 if( !SCIPdialogHasEntry(submenu, "freetransproblem") )
4077 {
4078 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4079 NULL,
4080 SCIPdialogExecChangeFreetransproblem, NULL, NULL,
4081 "freetransproblem", "free transformed problem", FALSE, NULL) );
4082 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4083 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4084 }
4085
4086 /* change objective sense */
4087 if( !SCIPdialogHasEntry(submenu, "objsense") )
4088 {
4089 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4090 NULL,
4091 SCIPdialogExecChangeObjSense, NULL, NULL,
4092 "objsense", "change objective sense", FALSE, NULL) );
4093 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4094 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4095 }
4096
4097 /* checksol */
4098 if( !SCIPdialogHasEntry(root, "checksol") )
4099 {
4100 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4101 NULL,
4102 SCIPdialogExecChecksol, NULL, NULL,
4103 "checksol", "double checks best solution w.r.t. original problem", FALSE, NULL) );
4104 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4105 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4106 }
4107
4108 /* display */
4109 if( !SCIPdialogHasEntry(root, "display") )
4110 {
4111 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
4112 NULL,
4113 SCIPdialogExecMenu, NULL, NULL,
4114 "display", "display information", TRUE, NULL) );
4115 SCIP_CALL( SCIPaddDialogEntry(scip, root, submenu) );
4116 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
4117 }
4118 if( SCIPdialogFindEntry(root, "display", &submenu) != 1 )
4119 {
4120 SCIPerrorMessage("display sub menu not found\n");
4121 return SCIP_PLUGINNOTFOUND;
4122 }
4123
4124 /* display benders */
4125 if( !SCIPdialogHasEntry(submenu, "benders") )
4126 {
4127 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4128 NULL,
4129 SCIPdialogExecDisplayBenders, NULL, NULL,
4130 "benders", "display Benders' decomposition", FALSE, NULL) );
4131 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4132 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4133 }
4134
4135 /* display branching */
4136 if( !SCIPdialogHasEntry(submenu, "branching") )
4137 {
4138 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4139 NULL,
4140 SCIPdialogExecDisplayBranching, NULL, NULL,
4141 "branching", "display branching rules", FALSE, NULL) );
4142 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4143 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4144 }
4145
4146 /* display compressions */
4147 if( !SCIPdialogHasEntry(submenu, "compression") )
4148 {
4149 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4150 NULL,
4151 SCIPdialogExecDisplayCompression, NULL, NULL,
4152 "compression", "display compression techniques", FALSE, NULL) );
4153 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4154 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4155 }
4156
4157 /* display conflict */
4158 if( !SCIPdialogHasEntry(submenu, "conflict") )
4159 {
4160 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4161 NULL,
4162 SCIPdialogExecDisplayConflict, NULL, NULL,
4163 "conflict", "display conflict handlers", FALSE, NULL) );
4164 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4165 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4166 }
4167
4168 /* display conshdlrs */
4169 if( !SCIPdialogHasEntry(submenu, "conshdlrs") )
4170 {
4171 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4172 NULL,
4173 SCIPdialogExecDisplayConshdlrs, NULL, NULL,
4174 "conshdlrs", "display constraint handlers", FALSE, NULL) );
4175 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4176 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4177 }
4178
4179 /* display displaycols */
4180 if( !SCIPdialogHasEntry(submenu, "displaycols") )
4181 {
4182 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4183 NULL,
4184 SCIPdialogExecDisplayDisplaycols, NULL, NULL,
4185 "displaycols", "display display columns", FALSE, NULL) );
4186 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4187 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4188 }
4189
4190 /* display exprhdlrs */
4191 if( !SCIPdialogHasEntry(submenu, "exprhdlrs") )
4192 {
4193 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4194 NULL,
4195 SCIPdialogExecDisplayExprhdlrs, NULL, NULL,
4196 "exprhdlrs", "display expression handlers", FALSE, NULL) );
4197 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4198 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4199 }
4200
4201 /* display cut selectors */
4202 if( !SCIPdialogHasEntry(submenu, "cutselectors") ) {
4203 SCIP_CALL(SCIPincludeDialog(scip, &dialog,
4204 NULL,
4205 SCIPdialogExecDisplayCutselectors, NULL, NULL,
4206 "cutselectors", "display cut selectors", FALSE, NULL));
4207 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4208 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4209 }
4210
4211 /* display heuristics */
4212 if( !SCIPdialogHasEntry(submenu, "heuristics") )
4213 {
4214 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4215 NULL,
4216 SCIPdialogExecDisplayHeuristics, NULL, NULL,
4217 "heuristics", "display primal heuristics", FALSE, NULL) );
4218 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4219 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4220 }
4221
4222 /* display memory */
4223 if( !SCIPdialogHasEntry(submenu, "memory") )
4224 {
4225 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4226 NULL,
4227 SCIPdialogExecDisplayMemory, NULL, NULL,
4228 "memory", "display memory diagnostics", FALSE, NULL) );
4229 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4230 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4231 }
4232
4233 /* display nlpi */
4234 if( !SCIPdialogHasEntry(submenu, "nlpis") )
4235 {
4236 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4237 NULL,
4238 SCIPdialogExecDisplayNlpi, NULL, NULL,
4239 "nlpis", "display NLP solver interfaces", FALSE, NULL) );
4240 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4241 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4242 }
4243
4244 /* display nodeselectors */
4245 if( !SCIPdialogHasEntry(submenu, "nodeselectors") )
4246 {
4247 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4248 NULL,
4249 SCIPdialogExecDisplayNodeselectors, NULL, NULL,
4250 "nodeselectors", "display node selectors", FALSE, NULL) );
4251 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4252 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4253 }
4254
4255 /* display parameters */
4256 if( !SCIPdialogHasEntry(submenu, "parameters") )
4257 {
4258 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4259 NULL,
4260 SCIPdialogExecDisplayParameters, NULL, NULL,
4261 "parameters", "display non-default parameter settings", FALSE, NULL) );
4262 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4263 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4264 }
4265
4266 /* display presolvers */
4267 if( !SCIPdialogHasEntry(submenu, "presolvers") )
4268 {
4269 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4270 NULL,
4271 SCIPdialogExecDisplayPresolvers, NULL, NULL,
4272 "presolvers", "display presolvers", FALSE, NULL) );
4273 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4274 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4275 }
4276
4277 /* display pricers */
4278 if( !SCIPdialogHasEntry(submenu, "pricers") )
4279 {
4280 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4281 NULL,
4282 SCIPdialogExecDisplayPricers, NULL, NULL,
4283 "pricers", "display pricers", FALSE, NULL) );
4284 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4285 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4286 }
4287
4288 /* display problem */
4289 if( !SCIPdialogHasEntry(submenu, "problem") )
4290 {
4291 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4292 NULL,
4293 SCIPdialogExecDisplayProblem, NULL, NULL,
4294 "problem", "display original problem", FALSE, NULL) );
4295 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4296 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4297 }
4298
4299 /* display propagators */
4300 if( !SCIPdialogHasEntry(submenu, "propagators") )
4301 {
4302 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4303 NULL,
4304 SCIPdialogExecDisplayPropagators, NULL, NULL,
4305 "propagators", "display propagators", FALSE, NULL) );
4306 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4307 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4308 }
4309
4310 /* display readers */
4311 if( !SCIPdialogHasEntry(submenu, "readers") )
4312 {
4313 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4314 NULL,
4315 SCIPdialogExecDisplayReaders, NULL, NULL,
4316 "readers", "display file readers", FALSE, NULL) );
4317 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4318 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4319 }
4320
4321 /* display relaxing */
4322 if( !SCIPdialogHasEntry(submenu, "relaxators") )
4323 {
4324 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4325 NULL,
4326 SCIPdialogExecDisplayRelaxators, NULL, NULL,
4327 "relaxators", "display relaxators", FALSE, NULL) );
4328 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4329 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4330 }
4331
4332 /* display separators */
4333 if( !SCIPdialogHasEntry(submenu, "separators") )
4334 {
4335 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4336 NULL,
4337 SCIPdialogExecDisplaySeparators, NULL, NULL,
4338 "separators", "display cut separators", FALSE, NULL) );
4339 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4340 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4341 }
4342
4343 /* display solution */
4344 if( !SCIPdialogHasEntry(submenu, "solution") )
4345 {
4346 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4347 NULL,
4348 SCIPdialogExecDisplaySolution, NULL, NULL,
4349 "solution", "display best primal solution", FALSE, NULL) );
4350 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4351 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4352 }
4353
4354 /* display finite solution */
4355 if( !SCIPdialogHasEntry(submenu, "finitesolution") )
4356 {
4357 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4358 NULL,
4359 SCIPdialogExecDisplayFiniteSolution, NULL, NULL,
4360 "finitesolution", "display best primal solution (try to make solution values finite, first)", FALSE, NULL) );
4361 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4362 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4363 }
4364
4365 /* display solution */
4366 if( !SCIPdialogHasEntry(submenu, "dualsolution") )
4367 {
4368 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4369 NULL,
4370 SCIPdialogExecDisplayDualSolution, NULL, NULL,
4371 "dualsolution", "display dual solution vector (LP only, without presolving)", FALSE, NULL) );
4372 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4373 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4374 }
4375
4376 /* display solution */
4377 if( !SCIPdialogHasEntry(submenu, "sols") )
4378 {
4379 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4380 NULL,
4381 SCIPdialogExecDisplaySolutionPool, NULL, NULL,
4382 "sols", "display solutions from pool", FALSE, NULL) );
4383 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4384 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4385 }
4386
4387 /* display benders decomposition subproblem */
4388 if( !SCIPdialogHasEntry(submenu, "subproblem") )
4389 {
4390 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4391 NULL,
4392 SCIPdialogExecDisplaySubproblem, NULL, NULL,
4393 "subproblem", "display subproblem of a Benders' decomposition", FALSE, NULL) );
4394 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4395 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4396 }
4397
4398 /* display the best solution to the benders decomposition subproblem */
4399 if( !SCIPdialogHasEntry(submenu, "subsolution") )
4400 {
4401 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4402 NULL,
4403 SCIPdialogExecDisplaySubSolution, NULL, NULL,
4404 "subsolution", "display solution to the Benders' decomposition subproblems given the best master problem solution", FALSE, NULL) );
4405 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4406 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4407 }
4408
4409 /* display statistics */
4410 if( !SCIPdialogHasEntry(submenu, "statistics") )
4411 {
4412 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4413 NULL,
4414 SCIPdialogExecDisplayStatistics, NULL, NULL,
4415 "statistics", "display problem and optimization statistics", FALSE, NULL) );
4416 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4417 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4418 }
4419
4420 /* display reoptimization statistics */
4421 if( !SCIPdialogHasEntry(submenu, "reoptstatistics") )
4422 {
4423 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4424 NULL,
4425 SCIPdialogExecDisplayReoptStatistics, NULL, NULL,
4426 "reoptstatistics", "display reoptimization statistics", FALSE, NULL) );
4427 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4428 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4429 }
4430
4431 /* display transproblem */
4432 if( !SCIPdialogHasEntry(submenu, "transproblem") )
4433 {
4434 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4435 NULL,
4436 SCIPdialogExecDisplayTransproblem, NULL, NULL,
4437 "transproblem", "display current node transformed problem", FALSE, NULL) );
4438 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4439 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4440 }
4441
4442 /* display value */
4443 if( !SCIPdialogHasEntry(submenu, "value") )
4444 {
4445 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4446 NULL,
4447 SCIPdialogExecDisplayValue, NULL, NULL,
4448 "value", "display value of single variable in best primal solution", FALSE, NULL) );
4449 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4450 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4451 }
4452
4453 /* display varbranchstatistics */
4454 if( !SCIPdialogHasEntry(submenu, "varbranchstatistics") )
4455 {
4456 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4457 NULL,
4458 SCIPdialogExecDisplayVarbranchstatistics, NULL, NULL,
4459 "varbranchstatistics", "display statistics for branching on variables", FALSE, NULL) );
4460 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4461 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4462 }
4463
4464 /* display lpsolquality */
4465 if( !SCIPdialogHasEntry(submenu, "lpsolquality") )
4466 {
4467 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4468 NULL,
4469 SCIPdialogExecDisplayLPSolutionQuality, NULL, NULL,
4470 "lpsolquality", "display quality of the current LP solution, if available", FALSE, NULL) );
4471 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4472 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4473 }
4474
4475 /* display transsolution */
4476 if( !SCIPdialogHasEntry(submenu, "transsolution") )
4477 {
4478 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4479 NULL,
4480 SCIPdialogExecDisplayTranssolution, NULL, NULL,
4481 "transsolution", "display best primal solution in transformed variables", FALSE, NULL) );
4482 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4483 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4484 }
4485
4486 /* display linear constraint type classification */
4487 if( !SCIPdialogHasEntry(submenu, "linclass") )
4488 {
4489 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4490 NULL,
4491 SCIPdialogExecDisplayLinearConsClassification, NULL, NULL,
4492 "linclass", "linear constraint classification as used for MIPLIB", FALSE, NULL) );
4493 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4494 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4495 }
4496
4497 /* free */
4498 if( !SCIPdialogHasEntry(root, "free") )
4499 {
4500 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4501 NULL,
4502 SCIPdialogExecFree, NULL, NULL,
4503 "free", "free current problem from memory", FALSE, NULL) );
4504 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4505 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4506 }
4507
4508 /* help */
4509 if( !SCIPdialogHasEntry(root, "help") )
4510 {
4511 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4512 NULL,
4513 SCIPdialogExecHelp, NULL, NULL,
4514 "help", "display this help", FALSE, NULL) );
4515 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4516 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4517 }
4518
4519 /* newstart */
4520 if( !SCIPdialogHasEntry(root, "newstart") )
4521 {
4522 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4523 NULL,
4524 SCIPdialogExecNewstart, NULL, NULL,
4525 "newstart", "reset branch and bound tree to start again from root", FALSE, NULL) );
4526 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4527 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4528 }
4529
4530#ifndef NDEBUG
4531 /* transform problem (for debugging) */
4532 if( !SCIPdialogHasEntry(root, "transform") )
4533 {
4534 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4535 NULL,
4536 SCIPdialogExecTransform, NULL, NULL,
4537 "transform", "transforms problem from original state", FALSE, NULL) );
4538 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4539 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4540 }
4541#endif
4542
4543 /* optimize */
4544 if( !SCIPdialogHasEntry(root, "optimize") )
4545 {
4546 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4547 NULL,
4548 SCIPdialogExecOptimize, NULL, NULL,
4549 "optimize", "solve the problem", FALSE, NULL) );
4550 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4551 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4552 }
4553
4554 /* optimize */
4555 if( !SCIPdialogHasEntry(root, "concurrentopt") )
4556 {
4557 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4558 NULL,
4559 SCIPdialogExecConcurrentOpt, NULL, NULL,
4560 "concurrentopt", "solve the problem using concurrent solvers", FALSE, NULL) );
4561 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4562 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4563 }
4564
4565 /* presolve */
4566 if( !SCIPdialogHasEntry(root, "presolve") )
4567 {
4568 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4569 NULL,
4570 SCIPdialogExecPresolve, NULL, NULL,
4571 "presolve", "solve the problem, but stop after presolving stage", FALSE, NULL) );
4572 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4573 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4574 }
4575
4576 /* quit */
4577 if( !SCIPdialogHasEntry(root, "quit") )
4578 {
4579 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4580 NULL,
4581 SCIPdialogExecQuit, NULL, NULL,
4582 "quit", "leave SCIP", FALSE, NULL) );
4583 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4584 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4585 }
4586
4587 /* read */
4588 if( !SCIPdialogHasEntry(root, "read") )
4589 {
4590 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4591 NULL,
4592 SCIPdialogExecRead, NULL, NULL,
4593 "read", "read a problem", FALSE, NULL) );
4594 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4595 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4596 }
4597
4598 /* write */
4599 if( !SCIPdialogHasEntry(root, "write") )
4600 {
4601 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
4602 NULL,
4603 SCIPdialogExecMenu, NULL, NULL,
4604 "write", "write information to file", TRUE, NULL) );
4605 SCIP_CALL( SCIPaddDialogEntry(scip, root, submenu) );
4606 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
4607 }
4608 if( SCIPdialogFindEntry(root, "write", &submenu) != 1 )
4609 {
4610 SCIPerrorMessage("write sub menu not found\n");
4611 return SCIP_PLUGINNOTFOUND;
4612 }
4613
4614 /* write LP */
4615 if( !SCIPdialogHasEntry(submenu, "lp") )
4616 {
4617 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4618 NULL,
4619 SCIPdialogExecWriteLp, NULL, NULL,
4620 "lp", "write current node LP relaxation in LP format to file", FALSE, NULL) );
4621 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4622 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4623 }
4624
4625 /* write MIP */
4626 if( !SCIPdialogHasEntry(submenu, "mip") )
4627 {
4628 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4629 NULL,
4630 SCIPdialogExecWriteMip, NULL, NULL,
4631 "mip", "write current node MIP relaxation in LP format to file", FALSE, NULL) );
4632 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4633 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4634 }
4635
4636 /* write NLP */
4637 if( !SCIPdialogHasEntry(submenu, "nlp") )
4638 {
4639 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4640 NULL,
4641 SCIPdialogExecWriteNlp, NULL, NULL,
4642 "nlp", "write current node NLP relaxation to file", FALSE, NULL) );
4643 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4644 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4645 }
4646
4647 /* write problem */
4648 if( !SCIPdialogHasEntry(submenu, "problem") )
4649 {
4650 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4651 NULL,
4652 SCIPdialogExecWriteProblem, NULL, NULL,
4653 "problem",
4654 "write original problem to file (format is given by file extension, e.g., orig.{lp,rlp,cip,mps})",
4655 FALSE, NULL) );
4656 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4657 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4658 }
4659
4660 /* write generic problem */
4661 if( !SCIPdialogHasEntry(submenu, "genproblem") )
4662 {
4663 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4664 NULL,
4665 SCIPdialogExecWriteGenProblem, NULL, NULL,
4666 "genproblem",
4667 "write original problem with generic names to file (format is given by file extension, e.g., orig.{lp,rlp,cip,mps})",
4668 FALSE, NULL) );
4669 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4670 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4671 }
4672
4673 /* write solution */
4674 if( !SCIPdialogHasEntry(submenu, "solution") )
4675 {
4676 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4677 NULL,
4678 SCIPdialogExecWriteSolution, NULL, NULL,
4679 "solution", "write best primal solution to file", FALSE, NULL) );
4680 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4681 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4682 }
4683
4684 /* write finite solution */
4685 if( !SCIPdialogHasEntry(submenu, "finitesolution") )
4686 {
4687 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4688 NULL,
4689 SCIPdialogExecWriteFiniteSolution, NULL, NULL,
4690 "finitesolution", "write best primal solution to file (try to make solution values finite, first)", FALSE, NULL) );
4691 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4692 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4693 }
4694
4695 /* write mip start */
4696 if( !SCIPdialogHasEntry(submenu, "mipstart") )
4697 {
4698 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4699 NULL,
4700 SCIPdialogExecWriteMIPStart, NULL, NULL,
4701 "mipstart", "write mip start to file", FALSE, NULL) );
4702 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4703 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4704 }
4705
4706 /* write statistics */
4707 if( !SCIPdialogHasEntry(submenu, "statistics") )
4708 {
4709 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4710 NULL,
4711 SCIPdialogExecWriteStatistics, NULL, NULL,
4712 "statistics", "write statistics to file", FALSE, NULL) );
4713 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4714 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4715 }
4716
4717 /* write transproblem */
4718 if( !SCIPdialogHasEntry(submenu, "transproblem") )
4719 {
4720 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4721 NULL,
4722 SCIPdialogExecWriteTransproblem, NULL, NULL,
4723 "transproblem",
4724 "write current node transformed problem to file (format is given by file extension, e.g., trans.{lp,rlp,cip,mps})",
4725 FALSE, NULL) );
4726 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4727 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4728 }
4729
4730 /* write transproblem with generic names */
4731 if( !SCIPdialogHasEntry(submenu, "gentransproblem") )
4732 {
4733 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4734 NULL,
4735 SCIPdialogExecWriteGenTransproblem, NULL, NULL,
4736 "gentransproblem",
4737 "write current node transformed problem with generic names to file (format is given by file extension, e.g., trans.{lp,rlp,cip,mps})",
4738 FALSE, NULL) );
4739 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4740 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4741 }
4742
4743 /* write cliquegraph */
4744 if( !SCIPdialogHasEntry(submenu, "cliquegraph") )
4745 {
4746 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4747 NULL,
4748 SCIPdialogExecCliquegraph, NULL, NULL,
4749 "cliquegraph",
4750 "write graph of cliques and implications of binary variables to GML file (better call after presolving)",
4751 FALSE, NULL) );
4752 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4753 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4754 }
4755
4756 /* write command line history */
4757 if( !SCIPdialogHasEntry(submenu, "history") )
4758 {
4759 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
4760 NULL,
4761 SCIPdialogExecWriteCommandHistory, NULL, NULL,
4762 "history",
4763 "write command line history to a file (only works if SCIP was compiled with 'readline')",
4764 FALSE, NULL) );
4765 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
4766 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4767 }
4768
4769 /* validate solve */
4770 if( !SCIPdialogHasEntry(root, "validatesolve") )
4771 {
4772 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecValidateSolve, NULL, NULL,
4773 "validatesolve",
4774 "validate the solution against external objective reference interval",
4775 FALSE, NULL) );
4776 SCIP_CALL( SCIPaddDialogEntry(scip, root, dialog) );
4777 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
4778 }
4779
4780 return SCIP_OKAY;
4781}
4782
4783/** if a '/' occurs in the parameter's name, adds a sub menu dialog to the given menu and inserts the parameter dialog
4784 * recursively in the sub menu; if no '/' occurs in the name, adds a parameter change dialog into the given dialog menu
4785 */
4786static
4787SCIP_RETCODE addSetParamDialog(
4788 SCIP* scip, /**< SCIP data structure */
4789 SCIP_DIALOG* menu, /**< dialog menu to insert the parameter into */
4790 SCIP_PARAM* param, /**< parameter to add a dialog for */
4791 char* paramname /**< parameter name to parse */
4792 )
4793{
4794 char* slash;
4795 char* dirname;
4796
4797 assert(paramname != NULL);
4798
4799 /* check for a '/' */
4800 slash = strchr(paramname, '/');
4801
4802 if( slash == NULL )
4803 {
4804 /* check, if the corresponding dialog already exists */
4805 if( !SCIPdialogHasEntry(menu, paramname) )
4806 {
4807 SCIP_DIALOG* paramdialog;
4808
4809 if( SCIPparamIsAdvanced(param) )
4810 {
4811 SCIP_DIALOG* advmenu;
4812
4813 if( !SCIPdialogHasEntry(menu, "advanced") )
4814 {
4815 /* if not yet existing, create an advanced sub menu */
4816 char desc[SCIP_MAXSTRLEN];
4817
4818 (void) SCIPsnprintf(desc, SCIP_MAXSTRLEN, "advanced parameters");
4819 SCIP_CALL( SCIPincludeDialog(scip, &advmenu,
4820 NULL,
4821 SCIPdialogExecMenu, NULL, NULL, "advanced", desc, TRUE, NULL) );
4822 SCIP_CALL( SCIPaddDialogEntry(scip, menu, advmenu) );
4823 SCIP_CALL( SCIPreleaseDialog(scip, &advmenu) );
4824 }
4825
4826 /* find the corresponding sub menu */
4827 (void)SCIPdialogFindEntry(menu, "advanced", &advmenu);
4828 if( advmenu == NULL )
4829 {
4830 SCIPerrorMessage("dialog sub menu not found\n");
4831 return SCIP_PLUGINNOTFOUND;
4832 }
4833
4834 if( !SCIPdialogHasEntry(advmenu, paramname) )
4835 {
4836 /* create a parameter change dialog */
4837 SCIP_CALL( SCIPincludeDialog(scip, &paramdialog,
4838 NULL,
4839 SCIPdialogExecSetParam, SCIPdialogDescSetParam, NULL,
4840 paramname, SCIPparamGetDesc(param), FALSE, (SCIP_DIALOGDATA*)param) );
4841 SCIP_CALL( SCIPaddDialogEntry(scip, advmenu, paramdialog) );
4842 SCIP_CALL( SCIPreleaseDialog(scip, &paramdialog) );
4843 }
4844 }
4845 else
4846 {
4847 /* create a parameter change dialog */
4848 SCIP_CALL( SCIPincludeDialog(scip, &paramdialog,
4849 NULL,
4850 SCIPdialogExecSetParam, SCIPdialogDescSetParam, NULL,
4851 paramname, SCIPparamGetDesc(param), FALSE, (SCIP_DIALOGDATA*)param) );
4852 SCIP_CALL( SCIPaddDialogEntry(scip, menu, paramdialog) );
4853 SCIP_CALL( SCIPreleaseDialog(scip, &paramdialog) );
4854 }
4855 }
4856 }
4857 else
4858 {
4859 SCIP_DIALOG* submenu;
4860
4861 /* split the parameter name into dirname and parameter name */
4862 dirname = paramname;
4863 paramname = slash+1;
4864 *slash = '\0';
4865
4866 /* if not yet existing, create a corresponding sub menu */
4867 if( !SCIPdialogHasEntry(menu, dirname) )
4868 {
4869 char desc[SCIP_MAXSTRLEN];
4870
4871 (void) SCIPsnprintf(desc, SCIP_MAXSTRLEN, "parameters for <%s>", dirname);
4872 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
4873 NULL,
4874 SCIPdialogExecMenu, NULL, NULL, dirname, desc, TRUE, NULL) );
4875 SCIP_CALL( SCIPaddDialogEntry(scip, menu, submenu) );
4876 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
4877 }
4878
4879 /* find the corresponding sub menu */
4880 (void)SCIPdialogFindEntry(menu, dirname, &submenu);
4881 if( submenu == NULL )
4882 {
4883 SCIPerrorMessage("dialog sub menu not found\n");
4884 return SCIP_PLUGINNOTFOUND;
4885 }
4886
4887 /* recursively call add parameter method */
4888 SCIP_CALL( addSetParamDialog(scip, submenu, param, paramname) );
4889 }
4890
4891 return SCIP_OKAY;
4892}
4893
4894/** if a '/' occurs in the parameter's name, adds a sub menu dialog to the given menu and inserts the parameter dialog
4895 * recursively in the sub menu; if no '/' occurs in the name, adds a fix parameter dialog into the given dialog menu
4896 */
4897static
4898SCIP_RETCODE addFixParamDialog(
4899 SCIP* scip, /**< SCIP data structure */
4900 SCIP_DIALOG* menu, /**< dialog menu to insert the parameter into */
4901 SCIP_PARAM* param, /**< parameter to add a dialog for */
4902 char* paramname /**< parameter name to parse */
4903 )
4904{
4905 char* slash;
4906 char* dirname;
4907
4908 assert(paramname != NULL);
4909
4910 /* check for a '/' */
4911 slash = strchr(paramname, '/');
4912
4913 if( slash == NULL )
4914 {
4915 /* check, if the corresponding dialog already exists */
4916 if( !SCIPdialogHasEntry(menu, paramname) )
4917 {
4918 SCIP_DIALOG* paramdialog;
4919
4920 if( SCIPparamIsAdvanced(param) )
4921 {
4922 SCIP_DIALOG* advmenu;
4923
4924 if( !SCIPdialogHasEntry(menu, "advanced") )
4925 {
4926 /* if not yet existing, create an advanced sub menu */
4927 char desc[SCIP_MAXSTRLEN];
4928
4929 (void) SCIPsnprintf(desc, SCIP_MAXSTRLEN, "advanced parameters");
4930 SCIP_CALL( SCIPincludeDialog(scip, &advmenu,
4931 NULL,
4932 SCIPdialogExecMenu, NULL, NULL, "advanced", desc, TRUE, NULL) );
4933 SCIP_CALL( SCIPaddDialogEntry(scip, menu, advmenu) );
4934 SCIP_CALL( SCIPreleaseDialog(scip, &advmenu) );
4935 }
4936
4937 /* find the corresponding sub menu */
4938 (void)SCIPdialogFindEntry(menu, "advanced", &advmenu);
4939 if( advmenu == NULL )
4940 {
4941 SCIPerrorMessage("dialog sub menu not found\n");
4942 return SCIP_PLUGINNOTFOUND;
4943 }
4944
4945 if( !SCIPdialogHasEntry(advmenu, paramname) )
4946 {
4947 /* create a fix parameter dialog */
4948 SCIP_CALL( SCIPincludeDialog(scip, &paramdialog,
4949 NULL,
4950 SCIPdialogExecFixParam, SCIPdialogDescFixParam, NULL,
4951 paramname, SCIPparamGetDesc(param), FALSE, (SCIP_DIALOGDATA*)param) );
4952 SCIP_CALL( SCIPaddDialogEntry(scip, advmenu, paramdialog) );
4953 SCIP_CALL( SCIPreleaseDialog(scip, &paramdialog) );
4954 }
4955 }
4956 else
4957 {
4958 /* create a fix parameter dialog */
4959 SCIP_CALL( SCIPincludeDialog(scip, &paramdialog,
4960 NULL,
4961 SCIPdialogExecFixParam, SCIPdialogDescFixParam, NULL,
4962 paramname, SCIPparamGetDesc(param), FALSE, (SCIP_DIALOGDATA*)param) );
4963 SCIP_CALL( SCIPaddDialogEntry(scip, menu, paramdialog) );
4964 SCIP_CALL( SCIPreleaseDialog(scip, &paramdialog) );
4965 }
4966 }
4967 }
4968 else
4969 {
4970 SCIP_DIALOG* submenu;
4971
4972 /* split the parameter name into dirname and parameter name */
4973 dirname = paramname;
4974 paramname = slash+1;
4975 *slash = '\0';
4976
4977 /* if not yet existing, create a corresponding sub menu */
4978 if( !SCIPdialogHasEntry(menu, dirname) )
4979 {
4980 char desc[SCIP_MAXSTRLEN];
4981
4982 (void) SCIPsnprintf(desc, SCIP_MAXSTRLEN, "parameters for <%s>", dirname);
4983 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
4984 NULL,
4985 SCIPdialogExecMenu, NULL, NULL, dirname, desc, TRUE, NULL) );
4986 SCIP_CALL( SCIPaddDialogEntry(scip, menu, submenu) );
4987 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
4988 }
4989
4990 /* find the corresponding sub menu */
4991 (void)SCIPdialogFindEntry(menu, dirname, &submenu);
4992 if( submenu == NULL )
4993 {
4994 SCIPerrorMessage("dialog sub menu not found\n");
4995 return SCIP_PLUGINNOTFOUND;
4996 }
4997
4998 /* recursively call add parameter method */
4999 SCIP_CALL( addFixParamDialog(scip, submenu, param, paramname) );
5000 }
5001
5002 return SCIP_OKAY;
5003}
5004
5005/** create a "emphasis" sub menu */
5006static
5007SCIP_RETCODE createEmphasisSubmenu(
5008 SCIP* scip, /**< SCIP data structure */
5009 SCIP_DIALOG* root, /**< the menu to add the empty sub menu */
5010 SCIP_DIALOG** submenu /**< pointer to store the created emphasis sub menu */
5011 )
5012{
5013 if( !SCIPdialogHasEntry(root, "emphasis") )
5014 {
5015 SCIP_CALL( SCIPincludeDialog(scip, submenu,
5016 NULL, SCIPdialogExecMenu, NULL, NULL,
5017 "emphasis", "predefined parameter settings", TRUE, NULL) );
5018 SCIP_CALL( SCIPaddDialogEntry(scip, root, *submenu) );
5019 SCIP_CALL( SCIPreleaseDialog(scip, submenu) );
5020 }
5021 else if( SCIPdialogFindEntry(root, "emphasis", submenu) != 1 )
5022 {
5023 SCIPerrorMessage("emphasis sub menu not found\n");
5024 return SCIP_PLUGINNOTFOUND;
5025 }
5026
5027 assert(*submenu != NULL);
5028
5029 return SCIP_OKAY;
5030}
5031
5032
5033/** includes or updates the "set" menu for each available parameter setting */
5034SCIP_RETCODE SCIPincludeDialogDefaultSet(
5035 SCIP* scip /**< SCIP data structure */
5036 )
5037{
5038 SCIP_DIALOG* root;
5039 SCIP_DIALOG* setmenu;
5040 SCIP_DIALOG* emphasismenu;
5041 SCIP_DIALOG* submenu;
5042 SCIP_DIALOG* dialog;
5043 SCIP_PARAM** params;
5044 char* paramname;
5045 int nparams;
5046 int i;
5047
5048 SCIP_BRANCHRULE** branchrules;
5049 SCIP_CONFLICTHDLR** conflicthdlrs;
5050 SCIP_CONSHDLR** conshdlrs;
5051 SCIP_CUTSEL** cutsels;
5052 SCIP_DISP** disps;
5053 SCIP_HEUR** heurs;
5054 SCIP_NLPI** nlpis;
5055 SCIP_NODESEL** nodesels;
5056 SCIP_PRESOL** presols;
5057 SCIP_PRICER** pricers;
5058 SCIP_READER** readers;
5059 SCIP_SEPA** sepas;
5060 int nbranchrules;
5061 int nconflicthdlrs;
5062 int nconshdlrs;
5063 int ncutsels;
5064 int ndisps;
5065 int nheurs;
5066 int nnlpis;
5067 int nnodesels;
5068 int npresols;
5069 int npricers;
5070 int nreaders;
5071 int nsepas;
5072
5073 /* get root dialog */
5074 root = SCIPgetRootDialog(scip);
5075 if( root == NULL )
5076 {
5077 SCIPerrorMessage("root dialog not found\n");
5078 return SCIP_PLUGINNOTFOUND;
5079 }
5080
5081 /* find (or create) the "set" menu of the root dialog */
5082 if( !SCIPdialogHasEntry(root, "set") )
5083 {
5084 SCIP_CALL( SCIPincludeDialog(scip, &setmenu,
5085 NULL, SCIPdialogExecMenu, NULL, NULL,
5086 "set", "load/save/change parameters", TRUE, NULL) );
5087 SCIP_CALL( SCIPaddDialogEntry(scip, root, setmenu) );
5088 SCIP_CALL( SCIPreleaseDialog(scip, &setmenu) );
5089 }
5090 if( SCIPdialogFindEntry(root, "set", &setmenu) != 1 )
5091 {
5092 SCIPerrorMessage("set sub menu not found\n");
5093 return SCIP_PLUGINNOTFOUND;
5094 }
5095
5096 /* set default */
5097 if( !SCIPdialogHasEntry(setmenu, "default") )
5098 {
5099 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5100 NULL,
5101 SCIPdialogExecSetDefault, NULL, NULL,
5102 "default", "reset parameter settings to their default values", FALSE, NULL) );
5103 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, dialog) );
5104 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5105 }
5106
5107 /* set load */
5108 if( !SCIPdialogHasEntry(setmenu, "load") )
5109 {
5110 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5111 NULL,
5112 SCIPdialogExecSetLoad, NULL, NULL,
5113 "load", "load parameter settings from a file", FALSE, NULL) );
5114 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, dialog) );
5115 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5116 }
5117
5118 /* set save */
5119 if( !SCIPdialogHasEntry(setmenu, "save") )
5120 {
5121 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5122 NULL,
5123 SCIPdialogExecSetSave, NULL, NULL,
5124 "save", "save parameter settings to a file", FALSE, NULL) );
5125 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, dialog) );
5126 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5127 }
5128
5129 /* set diffsave */
5130 if( !SCIPdialogHasEntry(setmenu, "diffsave") )
5131 {
5132 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5133 NULL,
5134 SCIPdialogExecSetDiffsave, NULL, NULL,
5135 "diffsave", "save non-default parameter settings to a file", FALSE, NULL) );
5136 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, dialog) );
5137 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5138 }
5139
5140 /* set branching */
5141 if( !SCIPdialogHasEntry(setmenu, "branching") )
5142 {
5143 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5144 NULL,
5145 SCIPdialogExecMenu, NULL, NULL,
5146 "branching", "change parameters for branching rules", TRUE, NULL) );
5147 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5148 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5149 }
5150 if( SCIPdialogFindEntry(setmenu, "branching", &submenu) != 1 )
5151 {
5152 SCIPerrorMessage("branching sub menu not found\n");
5153 return SCIP_PLUGINNOTFOUND;
5154 }
5155
5156 nbranchrules = SCIPgetNBranchrules(scip);
5157 branchrules = SCIPgetBranchrules(scip);
5158
5159 for( i = 0; i < nbranchrules; ++i )
5160 {
5161 if( !SCIPdialogHasEntry(submenu, SCIPbranchruleGetName(branchrules[i])) )
5162 {
5163 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5164 NULL,
5165 SCIPdialogExecMenu, NULL, NULL,
5166 SCIPbranchruleGetName(branchrules[i]), SCIPbranchruleGetDesc(branchrules[i]), TRUE, NULL) );
5167 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5168 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5169 }
5170 }
5171
5172 /* set branching priority */
5173 if( !SCIPdialogHasEntry(submenu, "priority") )
5174 {
5175 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5176 NULL,
5177 SCIPdialogExecSetBranchingPriority, NULL, NULL,
5178 "priority", "change branching priority of a single variable", FALSE, NULL) );
5179 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5180 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5181 }
5182
5183 /* set branching direction */
5184 if( !SCIPdialogHasEntry(submenu, "direction") )
5185 {
5186 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5187 NULL,
5188 SCIPdialogExecSetBranchingDirection, NULL, NULL,
5189 "direction", "change preferred branching direction of a single variable (-1:down, 0:auto, +1:up)",
5190 FALSE, NULL) );
5191 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5192 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5193 }
5194
5195 /* set conflict */
5196 if( !SCIPdialogHasEntry(setmenu, "conflict") )
5197 {
5198 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5199 NULL,
5200 SCIPdialogExecMenu, NULL, NULL,
5201 "conflict", "change parameters for conflict handlers", TRUE, NULL) );
5202 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5203 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5204 }
5205 if( SCIPdialogFindEntry(setmenu, "conflict", &submenu) != 1 )
5206 {
5207 SCIPerrorMessage("conflict sub menu not found\n");
5208 return SCIP_PLUGINNOTFOUND;
5209 }
5210
5211 nconflicthdlrs = SCIPgetNConflicthdlrs(scip);
5212 conflicthdlrs = SCIPgetConflicthdlrs(scip);
5213
5214 for( i = 0; i < nconflicthdlrs; ++i )
5215 {
5216 if( !SCIPdialogHasEntry(submenu, SCIPconflicthdlrGetName(conflicthdlrs[i])) )
5217 {
5218 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5219 NULL,
5220 SCIPdialogExecMenu, NULL, NULL,
5221 SCIPconflicthdlrGetName(conflicthdlrs[i]), SCIPconflicthdlrGetDesc(conflicthdlrs[i]), TRUE, NULL) );
5222 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5223 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5224 }
5225 }
5226
5227 /* set constraints */
5228 if( !SCIPdialogHasEntry(setmenu, "constraints") )
5229 {
5230 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5231 NULL,
5232 SCIPdialogExecMenu, NULL, NULL,
5233 "constraints", "change parameters for constraint handlers", TRUE, NULL) );
5234 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5235 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5236 }
5237 if( SCIPdialogFindEntry(setmenu, "constraints", &submenu) != 1 )
5238 {
5239 SCIPerrorMessage("constraints sub menu not found\n");
5240 return SCIP_PLUGINNOTFOUND;
5241 }
5242
5243 nconshdlrs = SCIPgetNConshdlrs(scip);
5244 conshdlrs = SCIPgetConshdlrs(scip);
5245
5246 for( i = 0; i < nconshdlrs; ++i )
5247 {
5248 if( !SCIPdialogHasEntry(submenu, SCIPconshdlrGetName(conshdlrs[i])) )
5249 {
5250 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5251 NULL,
5252 SCIPdialogExecMenu, NULL, NULL,
5253 SCIPconshdlrGetName(conshdlrs[i]), SCIPconshdlrGetDesc(conshdlrs[i]), TRUE, NULL) );
5254 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5255 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5256 }
5257 }
5258
5259 /* set cutselection */
5260 if( !SCIPdialogHasEntry(setmenu, "cutselection") )
5261 {
5262 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5263 NULL,
5264 SCIPdialogExecMenu, NULL, NULL,
5265 "cutselection", "change parameters for cut selectors", TRUE, NULL) );
5266 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5267 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5268 }
5269 if( SCIPdialogFindEntry(setmenu, "cutselection", &submenu) != 1 )
5270 {
5271 SCIPerrorMessage("cutselection sub menu not found\n");
5272 return SCIP_PLUGINNOTFOUND;
5273 }
5274
5275 ncutsels = SCIPgetNCutsels(scip);
5276 cutsels = SCIPgetCutsels(scip);
5277
5278 for( i = 0; i < ncutsels; ++i )
5279 {
5280 if( !SCIPdialogHasEntry(submenu, SCIPcutselGetName(cutsels[i])) )
5281 {
5282 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5283 NULL,
5284 SCIPdialogExecMenu, NULL, NULL,
5285 SCIPcutselGetName(cutsels[i]), SCIPcutselGetDesc(cutsels[i]), TRUE, NULL) );
5286 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5287 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5288 }
5289 }
5290
5291 /* set display */
5292 if( !SCIPdialogHasEntry(setmenu, "display") )
5293 {
5294 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5295 NULL,
5296 SCIPdialogExecMenu, NULL, NULL,
5297 "display", "change parameters for display columns", TRUE, NULL) );
5298 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5299 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5300 }
5301 if( SCIPdialogFindEntry(setmenu, "display", &submenu) != 1 )
5302 {
5303 SCIPerrorMessage("display sub menu not found\n");
5304 return SCIP_PLUGINNOTFOUND;
5305 }
5306
5307 ndisps = SCIPgetNDisps(scip);
5308 disps = SCIPgetDisps(scip);
5309
5310 for( i = 0; i < ndisps; ++i )
5311 {
5312 if( !SCIPdialogHasEntry(submenu, SCIPdispGetName(disps[i])) )
5313 {
5314 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5315 NULL,
5316 SCIPdialogExecMenu, NULL, NULL,
5317 SCIPdispGetName(disps[i]), SCIPdispGetDesc(disps[i]), TRUE, NULL) );
5318 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5319 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5320 }
5321 }
5322
5323 /* set estimate */
5324 if( !SCIPdialogHasEntry(setmenu, "estimation") )
5325 {
5326 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5327 NULL, SCIPdialogExecMenu, NULL, NULL,
5328 "estimation", "change parameters for restarts and tree size estimation", TRUE, NULL) );
5329 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5330 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5331 }
5332
5333 /* set expr */
5334 if( !SCIPdialogHasEntry(setmenu, "expr") )
5335 {
5336 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5337 NULL, SCIPdialogExecMenu, NULL, NULL,
5338 "expr", "change parameters for expression handlers", TRUE, NULL) );
5339 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5340 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5341 }
5342
5343 /* set heuristics */
5344 if( !SCIPdialogHasEntry(setmenu, "heuristics") )
5345 {
5346 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5347 NULL,
5348 SCIPdialogExecMenu, NULL, NULL,
5349 "heuristics", "change parameters for primal heuristics", TRUE, NULL) );
5350 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5351 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5352 }
5353 if( SCIPdialogFindEntry(setmenu, "heuristics", &submenu) != 1 )
5354 {
5355 SCIPerrorMessage("heuristics sub menu not found\n");
5356 return SCIP_PLUGINNOTFOUND;
5357 }
5358
5359 nheurs = SCIPgetNHeurs(scip);
5360 heurs = SCIPgetHeurs(scip);
5361
5362 for( i = 0; i < nheurs; ++i )
5363 {
5364 if( !SCIPdialogHasEntry(submenu, SCIPheurGetName(heurs[i])) )
5365 {
5366 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5367 NULL,
5368 SCIPdialogExecMenu, NULL, NULL,
5369 SCIPheurGetName(heurs[i]), SCIPheurGetDesc(heurs[i]), TRUE, NULL) );
5370 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5371 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5372 }
5373 }
5374
5375 /* create set heuristics emphasis */
5376 SCIP_CALL( createEmphasisSubmenu(scip, submenu, &emphasismenu) );
5377 assert(emphasismenu != NULL);
5378
5379 /* set heuristics emphasis aggressive */
5380 if( !SCIPdialogHasEntry(emphasismenu, "aggressive") )
5381 {
5382 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5383 NULL, SCIPdialogExecSetHeuristicsAggressive, NULL, NULL,
5384 "aggressive", "sets heuristics <aggressive>", FALSE, NULL) );
5385 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5386 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5387 }
5388
5389 /* set heuristics emphasis default */
5390 if( !SCIPdialogHasEntry(emphasismenu, "default") )
5391 {
5392 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5393 NULL, SCIPdialogExecSetHeuristicsDefault, NULL, NULL,
5394 "default", "sets heuristics settings to <default> ", FALSE, NULL) );
5395 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5396 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5397 }
5398
5399 /* set heuristics emphasis fast */
5400 if( !SCIPdialogHasEntry(emphasismenu, "fast") )
5401 {
5402 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5403 NULL, SCIPdialogExecSetHeuristicsFast, NULL, NULL,
5404 "fast", "sets heuristics <fast>", FALSE, NULL) );
5405 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5406 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5407 }
5408
5409 /* set heuristics emphasis off */
5410 if( !SCIPdialogHasEntry(emphasismenu, "off") )
5411 {
5412 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5413 NULL, SCIPdialogExecSetHeuristicsOff, NULL, NULL,
5414 "off", "turns <off> all heuristics", FALSE, NULL) );
5415 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5416 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5417 }
5418
5419 /* set limits */
5420 if( !SCIPdialogHasEntry(setmenu, "limits") )
5421 {
5422 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5423 NULL,
5424 SCIPdialogExecMenu, NULL, NULL,
5425 "limits", "change parameters for time, memory, objective value, and other limits", TRUE, NULL) );
5426 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5427
5428 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5429 NULL,
5430 SCIPdialogExecSetLimitsObjective, NULL, NULL,
5431 "objective", "set limit on objective function, such that only solutions better than this limit are accepted", FALSE, NULL) );
5432 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5433 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5434
5435 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5436 }
5437
5438 /* set LP */
5439 if( !SCIPdialogHasEntry(setmenu, "lp") )
5440 {
5441 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5442 NULL,
5443 SCIPdialogExecMenu, NULL, NULL,
5444 "lp", "change parameters for linear programming relaxations", TRUE, NULL) );
5445 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5446 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5447 }
5448
5449 /* set NLP */
5450 if( !SCIPdialogHasEntry(setmenu, "nlp") )
5451 {
5452 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5453 NULL,
5454 SCIPdialogExecMenu, NULL, NULL,
5455 "nlp", "change parameters for nonlinear programming relaxation", TRUE, NULL) );
5456 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5457 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5458 }
5459
5460 /* set memory */
5461 if( !SCIPdialogHasEntry(setmenu, "memory") )
5462 {
5463 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5464 NULL,
5465 SCIPdialogExecMenu, NULL, NULL,
5466 "memory", "change parameters for memory management", TRUE, NULL) );
5467 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5468 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5469 }
5470
5471 /* set misc */
5472 if( !SCIPdialogHasEntry(setmenu, "misc") )
5473 {
5474 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5475 NULL,
5476 SCIPdialogExecMenu, NULL, NULL,
5477 "misc", "change parameters for miscellaneous stuff", TRUE, NULL) );
5478 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5479 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5480 }
5481
5482 /* set nlhdlr */
5483 if( !SCIPdialogHasEntry(setmenu, "nlhdlr") )
5484 {
5485 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5486 NULL, SCIPdialogExecMenu, NULL, NULL,
5487 "nlhdlr", "change parameters for nonlinear handlers", TRUE, NULL) );
5488 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5489 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5490 }
5491
5492 /* set nlpi */
5493 if( !SCIPdialogHasEntry(setmenu, "nlpi") )
5494 {
5495 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5496 NULL,
5497 SCIPdialogExecMenu, NULL, NULL,
5498 "nlpi", "change parameters for NLP solver interfaces", TRUE, NULL) );
5499 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5500 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5501 }
5502 if( SCIPdialogFindEntry(setmenu, "nlpi", &submenu) != 1 )
5503 {
5504 SCIPerrorMessage("nlpi sub menu not found\n");
5505 return SCIP_PLUGINNOTFOUND;
5506 }
5507
5508 nnlpis = SCIPgetNNlpis(scip);
5509 nlpis = SCIPgetNlpis(scip);
5510
5511 for( i = 0; i < nnlpis; ++i )
5512 {
5513 if( !SCIPdialogHasEntry(submenu, SCIPnlpiGetName(nlpis[i])) )
5514 {
5515 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5516 NULL,
5517 SCIPdialogExecMenu, NULL, NULL,
5518 SCIPnlpiGetName(nlpis[i]), SCIPnlpiGetDesc(nlpis[i]), TRUE, NULL) );
5519 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5520 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5521 }
5522 }
5523
5524 /* set nodeselection */
5525 if( !SCIPdialogHasEntry(setmenu, "nodeselection") )
5526 {
5527 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5528 NULL,
5529 SCIPdialogExecMenu, NULL, NULL,
5530 "nodeselection", "change parameters for node selectors", TRUE, NULL) );
5531 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5532 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5533 }
5534 if( SCIPdialogFindEntry(setmenu, "nodeselection", &submenu) != 1 )
5535 {
5536 SCIPerrorMessage("nodeselection sub menu not found\n");
5537 return SCIP_PLUGINNOTFOUND;
5538 }
5539
5540 nnodesels = SCIPgetNNodesels(scip);
5541 nodesels = SCIPgetNodesels(scip);
5542
5543 for( i = 0; i < nnodesels; ++i )
5544 {
5545 if( !SCIPdialogHasEntry(submenu, SCIPnodeselGetName(nodesels[i])) )
5546 {
5547 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5548 NULL,
5549 SCIPdialogExecMenu, NULL, NULL,
5550 SCIPnodeselGetName(nodesels[i]), SCIPnodeselGetDesc(nodesels[i]), TRUE, NULL) );
5551 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5552 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5553 }
5554 }
5555
5556 /* set numerics */
5557 if( !SCIPdialogHasEntry(setmenu, "numerics") )
5558 {
5559 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5560 NULL,
5561 SCIPdialogExecMenu, NULL, NULL,
5562 "numerics", "change parameters for numerical values", TRUE, NULL) );
5563 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5564 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5565 }
5566
5567 /* set parallel */
5568 if( !SCIPdialogHasEntry(setmenu, "parallel") )
5569 {
5570 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5571 NULL,
5572 SCIPdialogExecMenu, NULL, NULL,
5573 "parallel", "change parameters for parallel implementation", TRUE, NULL) );
5574 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5575 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5576 }
5577
5578 /* set presolving */
5579 if( !SCIPdialogHasEntry(setmenu, "presolving") )
5580 {
5581 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5582 NULL,
5583 SCIPdialogExecMenu, NULL, NULL,
5584 "presolving", "change parameters for presolving", TRUE, NULL) );
5585 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5586 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5587 }
5588 if( SCIPdialogFindEntry(setmenu, "presolving", &submenu) != 1 )
5589 {
5590 SCIPerrorMessage("presolving sub menu not found\n");
5591 return SCIP_PLUGINNOTFOUND;
5592 }
5593
5594 npresols = SCIPgetNPresols(scip);
5595 presols = SCIPgetPresols(scip);
5596
5597 for( i = 0; i < npresols; ++i )
5598 {
5599 if( !SCIPdialogHasEntry(submenu, SCIPpresolGetName(presols[i])) )
5600 {
5601 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5602 NULL, SCIPdialogExecMenu, NULL, NULL,
5603 SCIPpresolGetName(presols[i]), SCIPpresolGetDesc(presols[i]), TRUE, NULL) );
5604 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5605 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5606 }
5607 }
5608
5609 /* create set presolving emphasis */
5610 SCIP_CALL( createEmphasisSubmenu(scip, submenu, &emphasismenu) );
5611 assert(emphasismenu != NULL);
5612
5613 /* set presolving emphasis aggressive */
5614 if( !SCIPdialogHasEntry(emphasismenu, "aggressive") )
5615 {
5616 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5617 NULL, SCIPdialogExecSetPresolvingAggressive, NULL, NULL,
5618 "aggressive", "sets presolving <aggressive>", FALSE, NULL) );
5619 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5620 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5621 }
5622
5623 /* set presolving emphasis default */
5624 if( !SCIPdialogHasEntry(emphasismenu, "default") )
5625 {
5626 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5627 NULL, SCIPdialogExecSetPresolvingDefault, NULL, NULL,
5628 "default", "sets presolving settings to <default>", FALSE, NULL) );
5629 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5630 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5631 }
5632
5633 /* set presolving emphasis fast */
5634 if( !SCIPdialogHasEntry(emphasismenu, "fast") )
5635 {
5636 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5637 NULL, SCIPdialogExecSetPresolvingFast, NULL, NULL,
5638 "fast", "sets presolving <fast>", FALSE, NULL) );
5639 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5640 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5641 }
5642
5643 /* set presolving emphasis off */
5644 if( !SCIPdialogHasEntry(emphasismenu, "off") )
5645 {
5646 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5647 NULL, SCIPdialogExecSetPresolvingOff, NULL, NULL,
5648 "off", "turns <off> all presolving", FALSE, NULL) );
5649 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5650 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5651 }
5652
5653 /* set pricing */
5654 if( !SCIPdialogHasEntry(setmenu, "pricing") )
5655 {
5656 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5657 NULL,
5658 SCIPdialogExecMenu, NULL, NULL,
5659 "pricing", "change parameters for pricing variables", TRUE, NULL) );
5660 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5661 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5662 }
5663 if( SCIPdialogFindEntry(setmenu, "pricing", &submenu) != 1 )
5664 {
5665 SCIPerrorMessage("pricing sub menu not found\n");
5666 return SCIP_PLUGINNOTFOUND;
5667 }
5668
5669 npricers = SCIPgetNPricers(scip);
5670 pricers = SCIPgetPricers(scip);
5671
5672 for( i = 0; i < npricers; ++i )
5673 {
5674 if( !SCIPdialogHasEntry(submenu, SCIPpricerGetName(pricers[i])) )
5675 {
5676 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5677 NULL,
5678 SCIPdialogExecMenu, NULL, NULL,
5679 SCIPpricerGetName(pricers[i]), SCIPpricerGetDesc(pricers[i]), TRUE, NULL) );
5680 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5681 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5682 }
5683 }
5684
5685 /* set propagation */
5686 if( !SCIPdialogHasEntry(setmenu, "propagating") )
5687 {
5688 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5689 NULL,
5690 SCIPdialogExecMenu, NULL, NULL,
5691 "propagating", "change parameters for constraint propagation", TRUE, NULL) );
5692 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5693 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5694 }
5695
5696 /* set reading */
5697 if( !SCIPdialogHasEntry(setmenu, "reading") )
5698 {
5699 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5700 NULL,
5701 SCIPdialogExecMenu, NULL, NULL,
5702 "reading", "change parameters for problem file readers", TRUE, NULL) );
5703 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5704 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5705 }
5706 if( SCIPdialogFindEntry(setmenu, "reading", &submenu) != 1 )
5707 {
5708 SCIPerrorMessage("reading sub menu not found\n");
5709 return SCIP_PLUGINNOTFOUND;
5710 }
5711
5712 nreaders = SCIPgetNReaders(scip);
5713 readers = SCIPgetReaders(scip);
5714
5715 for( i = 0; i < nreaders; ++i )
5716 {
5717 if( !SCIPdialogHasEntry(submenu, SCIPreaderGetName(readers[i])) )
5718 {
5719 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5720 NULL,
5721 SCIPdialogExecMenu, NULL, NULL,
5722 SCIPreaderGetName(readers[i]), SCIPreaderGetDesc(readers[i]), TRUE, NULL) );
5723 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5724 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5725 }
5726 }
5727
5728 /* set separating */
5729 if( !SCIPdialogHasEntry(setmenu, "separating") )
5730 {
5731 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5732 NULL, SCIPdialogExecMenu, NULL, NULL,
5733 "separating", "change parameters for cut separators", TRUE, NULL) );
5734 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5735 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5736 }
5737 if( SCIPdialogFindEntry(setmenu, "separating", &submenu) != 1 )
5738 {
5739 SCIPerrorMessage("separating sub menu not found\n");
5740 return SCIP_PLUGINNOTFOUND;
5741 }
5742
5743 nsepas = SCIPgetNSepas(scip);
5744 sepas = SCIPgetSepas(scip);
5745
5746 for( i = 0; i < nsepas; ++i )
5747 {
5748 if( !SCIPdialogHasEntry(submenu, SCIPsepaGetName(sepas[i])) )
5749 {
5750 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5751 NULL, SCIPdialogExecMenu, NULL, NULL,
5752 SCIPsepaGetName(sepas[i]), SCIPsepaGetDesc(sepas[i]), TRUE, NULL) );
5753 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5754 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5755 }
5756 }
5757
5758 /* create set separating emphasis */
5759 SCIP_CALL( createEmphasisSubmenu(scip, submenu, &emphasismenu) );
5760 assert(emphasismenu != NULL);
5761
5762 /* set separating emphasis aggressive */
5763 if( !SCIPdialogHasEntry(emphasismenu, "aggressive") )
5764 {
5765 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5766 NULL, SCIPdialogExecSetSeparatingAggressive, NULL, NULL,
5767 "aggressive", "sets separating <aggressive>", FALSE, NULL) );
5768 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5769 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5770 }
5771
5772 /* set separating emphasis default */
5773 if( !SCIPdialogHasEntry(emphasismenu, "default") )
5774 {
5775 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5776 NULL, SCIPdialogExecSetSeparatingDefault, NULL, NULL,
5777 "default", "sets separating settings to <default>", FALSE, NULL) );
5778 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5779 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5780 }
5781
5782 /* set separating emphasis fast */
5783 if( !SCIPdialogHasEntry(emphasismenu, "fast") )
5784 {
5785 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5786 NULL, SCIPdialogExecSetSeparatingFast, NULL, NULL,
5787 "fast", "sets separating <fast>", FALSE, NULL) );
5788 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5789 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5790 }
5791
5792 /* set separating emphasis off */
5793 if( !SCIPdialogHasEntry(emphasismenu, "off") )
5794 {
5795 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
5796 NULL, SCIPdialogExecSetSeparatingOff, NULL, NULL,
5797 "off", "turns <off> all separation", FALSE, NULL) );
5798 SCIP_CALL( SCIPaddDialogEntry(scip, emphasismenu, dialog) );
5799 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5800 }
5801
5802 /* set timing */
5803 if( !SCIPdialogHasEntry(setmenu, "timing") )
5804 {
5805 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5806 NULL, SCIPdialogExecMenu, NULL, NULL,
5807 "timing", "change parameters for timing issues", TRUE, NULL) );
5808 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5809 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5810 }
5811
5812 /* set visualization */
5813 if( !SCIPdialogHasEntry(setmenu, "visual") )
5814 {
5815 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5816 NULL, SCIPdialogExecMenu, NULL, NULL,
5817 "visual", "change parameters for visualization output", TRUE, NULL) );
5818 SCIP_CALL( SCIPaddDialogEntry(scip, setmenu, submenu) );
5819 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5820 }
5821
5822 /* set emphasis */
5823 SCIP_CALL( createEmphasisSubmenu(scip, setmenu, &submenu) );
5824
5825 /* get SCIP's parameters */
5826 params = SCIPgetParams(scip);
5827 nparams = SCIPgetNParams(scip);
5828
5829 /* insert each parameter into the set menu */
5830 for( i = 0; i < nparams; ++i )
5831 {
5832 const char* pname;
5833
5834 pname = SCIPparamGetName(params[i]);
5835 SCIP_ALLOC( BMSduplicateMemoryArray(&paramname, pname, strlen(pname)+1) );
5836 SCIP_CALL( addSetParamDialog(scip, setmenu, params[i], paramname) );
5837 BMSfreeMemoryArray(&paramname);
5838 }
5839
5840 /* set emphasis feasibility */
5841 /* add "counter" dialog to "set/emphasis" sub menu */
5842 if( !SCIPdialogHasEntry(submenu, "counter") )
5843 {
5844 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisCounter, NULL, NULL,
5845 "counter", "predefined parameter settings for a \"feasible\" and \"fast\" counting process", FALSE, NULL) );
5846 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5847 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5848 }
5849
5850 /* add "cpsolver" dialog to "set/emphasis" sub menu */
5851 if( !SCIPdialogHasEntry(submenu, "cpsolver") )
5852 {
5853 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisCpsolver, NULL, NULL,
5854 "cpsolver", "predefined parameter settings for CP like search", FALSE, NULL) );
5855 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5856 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5857 }
5858
5859 /* add "easycip" dialog to "set/emphasis" sub menu */
5860 if( !SCIPdialogHasEntry(submenu, "easycip") )
5861 {
5862 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisEasycip, NULL, NULL,
5863 "easycip", "predefined parameter settings for easy problems", FALSE, NULL) );
5864 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5865 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5866 }
5867
5868 /* add "feasibility" dialog to "set/emphasis" sub menu */
5869 if( !SCIPdialogHasEntry(submenu, "feasibility") )
5870 {
5871 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisFeasibility, NULL, NULL,
5872 "feasibility", "predefined parameter settings for feasibility problems", FALSE, NULL) );
5873 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5874 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5875 }
5876
5877 /* add "hardlp" dialog to "set/emphasis" sub menu */
5878 if( !SCIPdialogHasEntry(submenu, "hardlp") )
5879 {
5880 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisHardlp, NULL, NULL,
5881 "hardlp", "predefined parameter settings for problems with a hard LP", FALSE, NULL) );
5882 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5883 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5884 }
5885
5886 /* add "optimality" dialog to "set/emphasis" sub menu */
5887 if( !SCIPdialogHasEntry(submenu, "optimality") )
5888 {
5889 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisOptimality, NULL, NULL,
5890 "optimality", "predefined parameter settings for proving optimality fast", FALSE, NULL) );
5891 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5892 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5893 }
5894
5895 /* add "numerics" dialog to "set/emphasis" sub menu */
5896 if( !SCIPdialogHasEntry(submenu, "numerics") )
5897 {
5898 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisNumerics, NULL, NULL,
5899 "numerics", "predefined parameter settings for increased numerical stability", FALSE, NULL) );
5900 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5901 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5902 }
5903
5904 /* add "benchmark" dialog to "set/emphasis" sub menu */
5905 if( !SCIPdialogHasEntry(submenu, "benchmark") )
5906 {
5907 SCIP_CALL( SCIPincludeDialog(scip, &dialog, NULL, SCIPdialogExecSetEmphasisBenchmark, NULL, NULL,
5908 "benchmark", "predefined parameter settings for running in benchmark mode", FALSE, NULL) );
5909 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
5910 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
5911 }
5912
5913 return SCIP_OKAY;
5914}
5915
5916/** includes or updates the "fix" menu for each available parameter setting */
5917SCIP_RETCODE SCIPincludeDialogDefaultFix(
5918 SCIP* scip /**< SCIP data structure */
5919 )
5920{
5921 SCIP_DIALOG* root;
5922 SCIP_DIALOG* fixmenu;
5923 SCIP_DIALOG* submenu;
5924 SCIP_DIALOG* dialog;
5925 SCIP_PARAM** params;
5926 char* paramname;
5927 int nparams;
5928 int i;
5929
5930 SCIP_BRANCHRULE** branchrules;
5931 SCIP_CONFLICTHDLR** conflicthdlrs;
5932 SCIP_CONSHDLR** conshdlrs;
5933 SCIP_CUTSEL** cutsels;
5934 SCIP_DISP** disps;
5935 SCIP_HEUR** heurs;
5936 SCIP_NLPI** nlpis;
5937 SCIP_NODESEL** nodesels;
5938 SCIP_PRESOL** presols;
5939 SCIP_PRICER** pricers;
5940 SCIP_READER** readers;
5941 SCIP_SEPA** sepas;
5942 int nbranchrules;
5943 int nconflicthdlrs;
5944 int nconshdlrs;
5945 int ncutsels;
5946 int ndisps;
5947 int nheurs;
5948 int nnlpis;
5949 int nnodesels;
5950 int npresols;
5951 int npricers;
5952 int nreaders;
5953 int nsepas;
5954
5955 /* get root dialog */
5956 root = SCIPgetRootDialog(scip);
5957 if( root == NULL )
5958 {
5959 SCIPerrorMessage("root dialog not found\n");
5960 return SCIP_PLUGINNOTFOUND;
5961 }
5962
5963 /* find (or create) the "fix" menu of the root dialog */
5964 if( !SCIPdialogHasEntry(root, "fix") )
5965 {
5966 SCIP_CALL( SCIPincludeDialog(scip, &fixmenu,
5967 NULL, SCIPdialogExecMenu, NULL, NULL,
5968 "fix", "fix/unfix parameters", TRUE, NULL) );
5969 SCIP_CALL( SCIPaddDialogEntry(scip, root, fixmenu) );
5970 SCIP_CALL( SCIPreleaseDialog(scip, &fixmenu) );
5971 }
5972 if( SCIPdialogFindEntry(root, "fix", &fixmenu) != 1 )
5973 {
5974 SCIPerrorMessage("fix sub menu not found\n");
5975 return SCIP_PLUGINNOTFOUND;
5976 }
5977
5978 /* fix branching */
5979 if( !SCIPdialogHasEntry(fixmenu, "branching") )
5980 {
5981 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
5982 NULL,
5983 SCIPdialogExecMenu, NULL, NULL,
5984 "branching", "fix parameters for branching rules", TRUE, NULL) );
5985 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
5986 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
5987 }
5988 if( SCIPdialogFindEntry(fixmenu, "branching", &submenu) != 1 )
5989 {
5990 SCIPerrorMessage("branching sub menu not found\n");
5991 return SCIP_PLUGINNOTFOUND;
5992 }
5993
5994 nbranchrules = SCIPgetNBranchrules(scip);
5995 branchrules = SCIPgetBranchrules(scip);
5996
5997 for( i = 0; i < nbranchrules; ++i )
5998 {
5999 if( !SCIPdialogHasEntry(submenu, SCIPbranchruleGetName(branchrules[i])) )
6000 {
6001 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6002 NULL,
6003 SCIPdialogExecMenu, NULL, NULL,
6004 SCIPbranchruleGetName(branchrules[i]), SCIPbranchruleGetDesc(branchrules[i]), TRUE, NULL) );
6005 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6006 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6007 }
6008 }
6009
6010 /* fix conflict */
6011 if( !SCIPdialogHasEntry(fixmenu, "conflict") )
6012 {
6013 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6014 NULL,
6015 SCIPdialogExecMenu, NULL, NULL,
6016 "conflict", "fix parameters for conflict handlers", TRUE, NULL) );
6017 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6018 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6019 }
6020 if( SCIPdialogFindEntry(fixmenu, "conflict", &submenu) != 1 )
6021 {
6022 SCIPerrorMessage("conflict sub menu not found\n");
6023 return SCIP_PLUGINNOTFOUND;
6024 }
6025
6026 nconflicthdlrs = SCIPgetNConflicthdlrs(scip);
6027 conflicthdlrs = SCIPgetConflicthdlrs(scip);
6028
6029 for( i = 0; i < nconflicthdlrs; ++i )
6030 {
6031 if( !SCIPdialogHasEntry(submenu, SCIPconflicthdlrGetName(conflicthdlrs[i])) )
6032 {
6033 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6034 NULL,
6035 SCIPdialogExecMenu, NULL, NULL,
6036 SCIPconflicthdlrGetName(conflicthdlrs[i]), SCIPconflicthdlrGetDesc(conflicthdlrs[i]), TRUE, NULL) );
6037 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6038 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6039 }
6040 }
6041
6042 /* fix constraints */
6043 if( !SCIPdialogHasEntry(fixmenu, "constraints") )
6044 {
6045 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6046 NULL,
6047 SCIPdialogExecMenu, NULL, NULL,
6048 "constraints", "fix parameters for constraint handlers", TRUE, NULL) );
6049 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6050 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6051 }
6052 if( SCIPdialogFindEntry(fixmenu, "constraints", &submenu) != 1 )
6053 {
6054 SCIPerrorMessage("constraints sub menu not found\n");
6055 return SCIP_PLUGINNOTFOUND;
6056 }
6057
6058 nconshdlrs = SCIPgetNConshdlrs(scip);
6059 conshdlrs = SCIPgetConshdlrs(scip);
6060
6061 for( i = 0; i < nconshdlrs; ++i )
6062 {
6063 if( !SCIPdialogHasEntry(submenu, SCIPconshdlrGetName(conshdlrs[i])) )
6064 {
6065 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6066 NULL,
6067 SCIPdialogExecMenu, NULL, NULL,
6068 SCIPconshdlrGetName(conshdlrs[i]), SCIPconshdlrGetDesc(conshdlrs[i]), TRUE, NULL) );
6069 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6070 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6071 }
6072 }
6073
6074 /* fix cutselection */
6075 if( !SCIPdialogHasEntry(fixmenu, "cutselection") )
6076 {
6077 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6078 NULL,
6079 SCIPdialogExecMenu, NULL, NULL,
6080 "cutselection", "fix parameters for cut selectors", TRUE, NULL) );
6081 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6082 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6083 }
6084 if( SCIPdialogFindEntry(fixmenu, "cutselection", &submenu) != 1 )
6085 {
6086 SCIPerrorMessage("cutselection sub menu not found\n");
6087 return SCIP_PLUGINNOTFOUND;
6088 }
6089
6090 ncutsels = SCIPgetNCutsels(scip);
6091 cutsels = SCIPgetCutsels(scip);
6092
6093 for( i = 0; i < ncutsels; ++i )
6094 {
6095 if( !SCIPdialogHasEntry(submenu, SCIPcutselGetName(cutsels[i])) )
6096 {
6097 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6098 NULL,
6099 SCIPdialogExecMenu, NULL, NULL,
6100 SCIPcutselGetName(cutsels[i]), SCIPcutselGetDesc(cutsels[i]), TRUE, NULL) );
6101 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6102 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6103 }
6104 }
6105
6106 /* fix display */
6107 if( !SCIPdialogHasEntry(fixmenu, "display") )
6108 {
6109 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6110 NULL,
6111 SCIPdialogExecMenu, NULL, NULL,
6112 "display", "fix parameters for display columns", TRUE, NULL) );
6113 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6114 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6115 }
6116 if( SCIPdialogFindEntry(fixmenu, "display", &submenu) != 1 )
6117 {
6118 SCIPerrorMessage("display sub menu not found\n");
6119 return SCIP_PLUGINNOTFOUND;
6120 }
6121
6122 ndisps = SCIPgetNDisps(scip);
6123 disps = SCIPgetDisps(scip);
6124
6125 for( i = 0; i < ndisps; ++i )
6126 {
6127 if( !SCIPdialogHasEntry(submenu, SCIPdispGetName(disps[i])) )
6128 {
6129 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6130 NULL,
6131 SCIPdialogExecMenu, NULL, NULL,
6132 SCIPdispGetName(disps[i]), SCIPdispGetDesc(disps[i]), TRUE, NULL) );
6133 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6134 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6135 }
6136 }
6137
6138 /* fix heuristics */
6139 if( !SCIPdialogHasEntry(fixmenu, "heuristics") )
6140 {
6141 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6142 NULL,
6143 SCIPdialogExecMenu, NULL, NULL,
6144 "heuristics", "fix parameters for primal heuristics", TRUE, NULL) );
6145 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6146 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6147 }
6148 if( SCIPdialogFindEntry(fixmenu, "heuristics", &submenu) != 1 )
6149 {
6150 SCIPerrorMessage("heuristics sub menu not found\n");
6151 return SCIP_PLUGINNOTFOUND;
6152 }
6153
6154 nheurs = SCIPgetNHeurs(scip);
6155 heurs = SCIPgetHeurs(scip);
6156
6157 for( i = 0; i < nheurs; ++i )
6158 {
6159 if( !SCIPdialogHasEntry(submenu, SCIPheurGetName(heurs[i])) )
6160 {
6161 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6162 NULL,
6163 SCIPdialogExecMenu, NULL, NULL,
6164 SCIPheurGetName(heurs[i]), SCIPheurGetDesc(heurs[i]), TRUE, NULL) );
6165 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6166 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6167 }
6168 }
6169
6170 /* fix limits */
6171 if( !SCIPdialogHasEntry(fixmenu, "limits") )
6172 {
6173 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6174 NULL,
6175 SCIPdialogExecMenu, NULL, NULL,
6176 "limits", "fix parameters for time, memory, objective value, and other limits", TRUE, NULL) );
6177 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6178
6179 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6180 }
6181
6182 /* fix LP */
6183 if( !SCIPdialogHasEntry(fixmenu, "lp") )
6184 {
6185 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6186 NULL,
6187 SCIPdialogExecMenu, NULL, NULL,
6188 "lp", "fix parameters for linear programming relaxations", TRUE, NULL) );
6189 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6190 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6191 }
6192
6193 /* fix NLP */
6194 if( !SCIPdialogHasEntry(fixmenu, "nlp") )
6195 {
6196 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6197 NULL,
6198 SCIPdialogExecMenu, NULL, NULL,
6199 "nlp", "fix parameters for nonlinear programming relaxations", TRUE, NULL) );
6200 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6201 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6202 }
6203
6204 /* fix memory */
6205 if( !SCIPdialogHasEntry(fixmenu, "memory") )
6206 {
6207 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6208 NULL,
6209 SCIPdialogExecMenu, NULL, NULL,
6210 "memory", "fix parameters for memory management", TRUE, NULL) );
6211 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6212 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6213 }
6214
6215 /* fix misc */
6216 if( !SCIPdialogHasEntry(fixmenu, "misc") )
6217 {
6218 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6219 NULL,
6220 SCIPdialogExecMenu, NULL, NULL,
6221 "misc", "fix parameters for miscellaneous stuff", TRUE, NULL) );
6222 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6223 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6224 }
6225
6226 /* fix nlpi */
6227 if( !SCIPdialogHasEntry(fixmenu, "nlpi") )
6228 {
6229 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6230 NULL,
6231 SCIPdialogExecMenu, NULL, NULL,
6232 "nlpi", "fix parameters for NLP solver interfaces", TRUE, NULL) );
6233 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6234 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6235 }
6236 if( SCIPdialogFindEntry(fixmenu, "nlpi", &submenu) != 1 )
6237 {
6238 SCIPerrorMessage("nlpi sub menu not found\n");
6239 return SCIP_PLUGINNOTFOUND;
6240 }
6241
6242 nnlpis = SCIPgetNNlpis(scip);
6243 nlpis = SCIPgetNlpis(scip);
6244
6245 for( i = 0; i < nnlpis; ++i )
6246 {
6247 if( !SCIPdialogHasEntry(submenu, SCIPnlpiGetName(nlpis[i])) )
6248 {
6249 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6250 NULL,
6251 SCIPdialogExecMenu, NULL, NULL,
6252 SCIPnlpiGetName(nlpis[i]), SCIPnlpiGetDesc(nlpis[i]), TRUE, NULL) );
6253 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6254 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6255 }
6256 }
6257
6258 /* fix nodeselection */
6259 if( !SCIPdialogHasEntry(fixmenu, "nodeselection") )
6260 {
6261 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6262 NULL,
6263 SCIPdialogExecMenu, NULL, NULL,
6264 "nodeselection", "fix parameters for node selectors", TRUE, NULL) );
6265 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6266 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6267 }
6268 if( SCIPdialogFindEntry(fixmenu, "nodeselection", &submenu) != 1 )
6269 {
6270 SCIPerrorMessage("nodeselection sub menu not found\n");
6271 return SCIP_PLUGINNOTFOUND;
6272 }
6273
6274 nnodesels = SCIPgetNNodesels(scip);
6275 nodesels = SCIPgetNodesels(scip);
6276
6277 for( i = 0; i < nnodesels; ++i )
6278 {
6279 if( !SCIPdialogHasEntry(submenu, SCIPnodeselGetName(nodesels[i])) )
6280 {
6281 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6282 NULL,
6283 SCIPdialogExecMenu, NULL, NULL,
6284 SCIPnodeselGetName(nodesels[i]), SCIPnodeselGetDesc(nodesels[i]), TRUE, NULL) );
6285 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6286 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6287 }
6288 }
6289
6290 /* fix numerics */
6291 if( !SCIPdialogHasEntry(fixmenu, "numerics") )
6292 {
6293 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6294 NULL,
6295 SCIPdialogExecMenu, NULL, NULL,
6296 "numerics", "fix parameters for numerical values", TRUE, NULL) );
6297 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6298 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6299 }
6300
6301 /* fix presolving */
6302 if( !SCIPdialogHasEntry(fixmenu, "presolving") )
6303 {
6304 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6305 NULL,
6306 SCIPdialogExecMenu, NULL, NULL,
6307 "presolving", "fix parameters for presolving", TRUE, NULL) );
6308 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6309 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6310 }
6311 if( SCIPdialogFindEntry(fixmenu, "presolving", &submenu) != 1 )
6312 {
6313 SCIPerrorMessage("presolving sub menu not found\n");
6314 return SCIP_PLUGINNOTFOUND;
6315 }
6316
6317 npresols = SCIPgetNPresols(scip);
6318 presols = SCIPgetPresols(scip);
6319
6320 for( i = 0; i < npresols; ++i )
6321 {
6322 if( !SCIPdialogHasEntry(submenu, SCIPpresolGetName(presols[i])) )
6323 {
6324 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6325 NULL, SCIPdialogExecMenu, NULL, NULL,
6326 SCIPpresolGetName(presols[i]), SCIPpresolGetDesc(presols[i]), TRUE, NULL) );
6327 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6328 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6329 }
6330 }
6331
6332 /* fix pricing */
6333 if( !SCIPdialogHasEntry(fixmenu, "pricing") )
6334 {
6335 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6336 NULL,
6337 SCIPdialogExecMenu, NULL, NULL,
6338 "pricing", "fix parameters for pricing variables", TRUE, NULL) );
6339 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6340 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6341 }
6342 if( SCIPdialogFindEntry(fixmenu, "pricing", &submenu) != 1 )
6343 {
6344 SCIPerrorMessage("pricing sub menu not found\n");
6345 return SCIP_PLUGINNOTFOUND;
6346 }
6347
6348 npricers = SCIPgetNPricers(scip);
6349 pricers = SCIPgetPricers(scip);
6350
6351 for( i = 0; i < npricers; ++i )
6352 {
6353 if( !SCIPdialogHasEntry(submenu, SCIPpricerGetName(pricers[i])) )
6354 {
6355 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6356 NULL,
6357 SCIPdialogExecMenu, NULL, NULL,
6358 SCIPpricerGetName(pricers[i]), SCIPpricerGetDesc(pricers[i]), TRUE, NULL) );
6359 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6360 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6361 }
6362 }
6363
6364 /* fix propagation */
6365 if( !SCIPdialogHasEntry(fixmenu, "propagating") )
6366 {
6367 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6368 NULL,
6369 SCIPdialogExecMenu, NULL, NULL,
6370 "propagating", "fix parameters for constraint propagation", TRUE, NULL) );
6371 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6372 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6373 }
6374
6375 /* fix reading */
6376 if( !SCIPdialogHasEntry(fixmenu, "reading") )
6377 {
6378 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6379 NULL,
6380 SCIPdialogExecMenu, NULL, NULL,
6381 "reading", "fix parameters for problem file readers", TRUE, NULL) );
6382 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6383 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6384 }
6385 if( SCIPdialogFindEntry(fixmenu, "reading", &submenu) != 1 )
6386 {
6387 SCIPerrorMessage("reading sub menu not found\n");
6388 return SCIP_PLUGINNOTFOUND;
6389 }
6390
6391 nreaders = SCIPgetNReaders(scip);
6392 readers = SCIPgetReaders(scip);
6393
6394 for( i = 0; i < nreaders; ++i )
6395 {
6396 if( !SCIPdialogHasEntry(submenu, SCIPreaderGetName(readers[i])) )
6397 {
6398 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6399 NULL,
6400 SCIPdialogExecMenu, NULL, NULL,
6401 SCIPreaderGetName(readers[i]), SCIPreaderGetDesc(readers[i]), TRUE, NULL) );
6402 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6403 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6404 }
6405 }
6406
6407 /* fix separating */
6408 if( !SCIPdialogHasEntry(fixmenu, "separating") )
6409 {
6410 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6411 NULL, SCIPdialogExecMenu, NULL, NULL,
6412 "separating", "fix parameters for cut separators", TRUE, NULL) );
6413 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6414 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6415 }
6416 if( SCIPdialogFindEntry(fixmenu, "separating", &submenu) != 1 )
6417 {
6418 SCIPerrorMessage("separating sub menu not found\n");
6419 return SCIP_PLUGINNOTFOUND;
6420 }
6421
6422 nsepas = SCIPgetNSepas(scip);
6423 sepas = SCIPgetSepas(scip);
6424
6425 for( i = 0; i < nsepas; ++i )
6426 {
6427 if( !SCIPdialogHasEntry(submenu, SCIPsepaGetName(sepas[i])) )
6428 {
6429 SCIP_CALL( SCIPincludeDialog(scip, &dialog,
6430 NULL, SCIPdialogExecMenu, NULL, NULL,
6431 SCIPsepaGetName(sepas[i]), SCIPsepaGetDesc(sepas[i]), TRUE, NULL) );
6432 SCIP_CALL( SCIPaddDialogEntry(scip, submenu, dialog) );
6433 SCIP_CALL( SCIPreleaseDialog(scip, &dialog) );
6434 }
6435 }
6436
6437 /* fix timing */
6438 if( !SCIPdialogHasEntry(fixmenu, "timing") )
6439 {
6440 SCIP_CALL( SCIPincludeDialog(scip, &submenu,
6441 NULL, SCIPdialogExecMenu, NULL, NULL,
6442 "timing", "fix parameters for timing issues", TRUE, NULL) );
6443 SCIP_CALL( SCIPaddDialogEntry(scip, fixmenu, submenu) );
6444 SCIP_CALL( SCIPreleaseDialog(scip, &submenu) );
6445 }
6446
6447 /* get SCIP's parameters */
6448 params = SCIPgetParams(scip);
6449 nparams = SCIPgetNParams(scip);
6450
6451 /* insert each parameter into the fix menu */
6452 for( i = 0; i < nparams; ++i )
6453 {
6454 const char* pname;
6455
6456 pname = SCIPparamGetName(params[i]);
6457 SCIP_ALLOC( BMSduplicateMemoryArray(&paramname, pname, strlen(pname)+1) );
6458 SCIP_CALL( addFixParamDialog(scip, fixmenu, params[i], paramname) );
6459 BMSfreeMemoryArray(&paramname);
6460 }
6461
6462 return SCIP_OKAY;
6463}
bound
static long bound
Definition: GomoryHuTree.cpp:47
r
SCIP_Real * r
Definition: circlepacking.c:59
cons_linear.h
Constraint handler for linear constraints in their most general form, .
NULL
#define NULL
Definition: def.h:267
SCIP_MAXSTRLEN
#define SCIP_MAXSTRLEN
Definition: def.h:288
SCIP_Longint
#define SCIP_Longint
Definition: def.h:158
SCIP_INVALID
#define SCIP_INVALID
Definition: def.h:193
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIP_ALLOC
#define SCIP_ALLOC(x)
Definition: def.h:385
SCIP_Real
#define SCIP_Real
Definition: def.h:173
SCIP_UNKNOWN
#define SCIP_UNKNOWN
Definition: def.h:194
TRUE
#define TRUE
Definition: def.h:93
FALSE
#define FALSE
Definition: def.h:94
SCIP_LONGINT_FORMAT
#define SCIP_LONGINT_FORMAT
Definition: def.h:165
SCIP_REAL_FORMAT
#define SCIP_REAL_FORMAT
Definition: def.h:176
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:374
SCIP_CALL_FINALLY
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:416
writeProblem
static SCIP_RETCODE writeProblem(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG **nextdialog, SCIP_Bool transformed, SCIP_Bool genericnames)
Definition: dialog_default.c:237
dialogExecMenu
static SCIP_RETCODE dialogExecMenu(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG **nextdialog)
Definition: dialog_default.c:98
addFixParamDialog
static SCIP_RETCODE addFixParamDialog(SCIP *scip, SCIP_DIALOG *menu, SCIP_PARAM *param, char *paramname)
Definition: dialog_default.c:4898
createEmphasisSubmenu
static SCIP_RETCODE createEmphasisSubmenu(SCIP *scip, SCIP_DIALOG *root, SCIP_DIALOG **submenu)
Definition: dialog_default.c:5007
addSetParamDialog
static SCIP_RETCODE addSetParamDialog(SCIP *scip, SCIP_DIALOG *menu, SCIP_PARAM *param, char *paramname)
Definition: dialog_default.c:4787
displayReaders
static void displayReaders(SCIP *scip, SCIP_Bool reader, SCIP_Bool writer)
Definition: dialog_default.c:200
parseBoolValue
static SCIP_Bool parseBoolValue(SCIP *scip, const char *valuestr, SCIP_Bool *error)
Definition: dialog_default.c:163
SCIP_DECL_DIALOGCOPY
static SCIP_DECL_DIALOGCOPY(dialogCopyDefault)
Definition: dialog_default.c:332
dialog_default.h
default user interface dialog
SCIPclassifyConstraintTypesLinear
SCIP_RETCODE SCIPclassifyConstraintTypesLinear(SCIP *scip, SCIP_LINCONSSTATS *linconsstats)
Definition: cons_linear.c:15348
SCIP_DECL_DIALOGEXEC
SCIP_DECL_DIALOGEXEC(SCIPdialogExecMenu)
Definition: dialog_default.c:346
SCIP_DECL_DIALOGDESC
SCIP_DECL_DIALOGDESC(SCIPdialogDescSetParam)
Definition: dialog_default.c:2739
SCIPcreateRootDialog
SCIP_RETCODE SCIPcreateRootDialog(SCIP *scip, SCIP_DIALOG **root)
Definition: dialog_default.c:4003
SCIPincludeDialogDefaultBasic
SCIP_RETCODE SCIPincludeDialogDefaultBasic(SCIP *scip)
Definition: dialog_default.c:4022
SCIPincludeDialogDefaultSet
SCIP_RETCODE SCIPincludeDialogDefaultSet(SCIP *scip)
Definition: dialog_default.c:5034
SCIPincludeDialogDefaultFix
SCIP_RETCODE SCIPincludeDialogDefaultFix(SCIP *scip)
Definition: dialog_default.c:5917
SCIPfileExists
SCIP_Bool SCIPfileExists(const char *filename)
Definition: misc.c:11079
SCIPisTransformed
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip_general.c:596
SCIPprintStatus
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
Definition: scip_general.c:521
SCIPgetStage
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:380
SCIPwriteOrigProblem
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:601
SCIPsetObjlimit
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip_prob.c:1422
SCIPgetObjlimit
SCIP_Real SCIPgetObjlimit(SCIP *scip)
Definition: scip_prob.c:1492
SCIPaddCons
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:2770
SCIPfreeProb
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition: scip_prob.c:694
SCIPsetObjsense
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip_prob.c:1242
SCIPwriteTransProblem
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:648
SCIPgetNFixedVars
int SCIPgetNFixedVars(SCIP *scip)
Definition: scip_prob.c:2309
SCIPgetFixedVars
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
Definition: scip_prob.c:2266
SCIPfindVar
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip_prob.c:2685
SCIPreadProb
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
Definition: scip_prob.c:339
SCIPinfoMessage
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
SCIPgetMessagehdlr
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
Definition: scip_message.c:88
SCIPdialogMessage
void SCIPdialogMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:191
SCIPgetBoolParam
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip_param.c:250
SCIPisStringParamValid
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:734
SCIPresetParams
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip_param.c:853
SCIPchgCharParam
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip_param.c:635
SCIPchgStringParam
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:693
SCIPgetNParams
int SCIPgetNParams(SCIP *scip)
Definition: scip_param.c:1013
SCIPsetHeuristics
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:927
SCIPisCharParamValid
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip_param.c:676
SCIPgetRealParam
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:307
SCIPisIntParamValid
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:502
SCIPreadParams
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
Definition: scip_param.c:772
SCIPwriteParams
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip_param.c:813
SCIPchgBoolParam
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:403
SCIPsetPresolving
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:953
SCIPchgRealParam
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:577
SCIPsetEmphasis
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: scip_param.c:882
SCIPchgLongintParam
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:519
SCIPgetParams
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip_param.c:999
SCIPisLongintParamValid
SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:560
SCIPisRealParamValid
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:618
SCIPchgIntParam
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:461
SCIPsetSeparating
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:979
SCIPisBoolParamValid
SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:444
SCIPgetNActiveBenders
int SCIPgetNActiveBenders(SCIP *scip)
Definition: scip_benders.c:532
SCIPgetBenders
SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)
Definition: scip_benders.c:508
SCIPgetNBenders
int SCIPgetNBenders(SCIP *scip)
Definition: scip_benders.c:521
SCIPbendersGetPriority
int SCIPbendersGetPriority(SCIP_BENDERS *benders)
Definition: benders.c:5944
SCIPbendersGetDesc
const char * SCIPbendersGetDesc(SCIP_BENDERS *benders)
Definition: benders.c:5934
SCIPbendersGetSubproblemType
SCIP_BENDERSSUBTYPE SCIPbendersGetSubproblemType(SCIP_BENDERS *benders, int probnumber)
Definition: benders.c:6321
SCIPfreeBendersSubproblem
SCIP_RETCODE SCIPfreeBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, int probnumber)
Definition: scip_benders.c:861
SCIPsetupBendersSubproblem
SCIP_RETCODE SCIPsetupBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, int probnumber, SCIP_BENDERSENFOTYPE type)
Definition: scip_benders.c:780
SCIPsolveBendersSubproblem
SCIP_RETCODE SCIPsolveBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, int probnumber, SCIP_Bool *infeasible, SCIP_Bool solvecip, SCIP_Real *objective)
Definition: scip_benders.c:818
SCIPbendersIsActive
SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)
Definition: benders.c:2675
SCIPbendersGetName
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
Definition: benders.c:5924
SCIPbendersGetNSubproblems
int SCIPbendersGetNSubproblems(SCIP_BENDERS *benders)
Definition: benders.c:5968
SCIPbendersSubproblem
SCIP * SCIPbendersSubproblem(SCIP_BENDERS *benders, int probnumber)
Definition: benders.c:5978
SCIPbranchruleGetMaxdepth
int SCIPbranchruleGetMaxdepth(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2015
SCIPgetBranchrules
SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)
Definition: scip_branch.c:312
SCIPbranchruleGetName
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1971
SCIPbranchruleGetPriority
int SCIPbranchruleGetPriority(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1991
SCIPbranchruleGetMaxbounddist
SCIP_Real SCIPbranchruleGetMaxbounddist(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2037
SCIPbranchruleGetDesc
const char * SCIPbranchruleGetDesc(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1981
SCIPgetNBranchrules
int SCIPgetNBranchrules(SCIP *scip)
Definition: scip_branch.c:323
SCIPcomprGetPriority
int SCIPcomprGetPriority(SCIP_COMPR *compr)
Definition: compr.c:476
SCIPgetNCompr
int SCIPgetNCompr(SCIP *scip)
Definition: scip_compr.c:263
SCIPgetComprs
SCIP_COMPR ** SCIPgetComprs(SCIP *scip)
Definition: scip_compr.c:250
SCIPcomprGetDesc
const char * SCIPcomprGetDesc(SCIP_COMPR *compr)
Definition: compr.c:466
SCIPcomprGetName
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition: compr.c:456
SCIPcomprGetMinNodes
int SCIPcomprGetMinNodes(SCIP_COMPR *compr)
Definition: compr.c:500
SCIPconflicthdlrGetPriority
int SCIPconflicthdlrGetPriority(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict_graphanalysis.c:1513
SCIPconflicthdlrGetName
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict_graphanalysis.c:1493
SCIPconflicthdlrGetDesc
const char * SCIPconflicthdlrGetDesc(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict_graphanalysis.c:1503
SCIPgetConflicthdlrs
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
Definition: scip_conflict.c:249
SCIPgetNConflicthdlrs
int SCIPgetNConflicthdlrs(SCIP *scip)
Definition: scip_conflict.c:262
SCIPconshdlrGetEagerFreq
int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5150
SCIPconshdlrGetPresolTiming
SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5272
SCIPgetNConshdlrs
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip_cons.c:965
SCIPconshdlrGetSepaPriority
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5100
SCIPconshdlrGetPropFreq
int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5140
SCIPconshdlrGetName
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4197
SCIPconshdlrGetDesc
const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4207
SCIPconshdlrGetCheckPriority
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5120
SCIPconshdlrGetSepaFreq
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5130
SCIPgetConshdlrs
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip_cons.c:954
SCIPconshdlrGetEnfoPriority
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5110
SCIPparseCons
SCIP_RETCODE SCIPparseCons(SCIP *scip, SCIP_CONS **cons, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
Definition: scip_cons.c:1082
SCIPreleaseCons
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1174
SCIPcutselGetDesc
const char * SCIPcutselGetDesc(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:245
SCIPcutselGetPriority
int SCIPcutselGetPriority(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:440
SCIPcutselGetName
const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:159
SCIPgetCutsels
SCIP_CUTSEL ** SCIPgetCutsels(SCIP *scip)
Definition: scip_cutsel.c:234
SCIPgetNCutsels
int SCIPgetNCutsels(SCIP *scip)
Definition: scip_cutsel.c:247
SCIPdialoghdlrClearBuffer
void SCIPdialoghdlrClearBuffer(SCIP_DIALOGHDLR *dialoghdlr)
Definition: dialog.c:446
SCIPreleaseDialog
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
Definition: scip_dialog.c:124
SCIPdialoghdlrGetRoot
SCIP_DIALOG * SCIPdialoghdlrGetRoot(SCIP_DIALOGHDLR *dialoghdlr)
Definition: dialog.c:436
SCIPdialogHasEntry
SCIP_Bool SCIPdialogHasEntry(SCIP_DIALOG *dialog, const char *entryname)
Definition: dialog.c:995
SCIPdialoghdlrAddHistory
SCIP_RETCODE SCIPdialoghdlrAddHistory(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *command, SCIP_Bool escapecommand)
Definition: dialog.c:726
SCIPincludeDialog
SCIP_RETCODE SCIPincludeDialog(SCIP *scip, SCIP_DIALOG **dialog, SCIP_DECL_DIALOGCOPY((*dialogcopy)), SCIP_DECL_DIALOGEXEC((*dialogexec)), SCIP_DECL_DIALOGDESC((*dialogdesc)), SCIP_DECL_DIALOGFREE((*dialogfree)), const char *name, const char *desc, SCIP_Bool issubmenu, SCIP_DIALOGDATA *dialogdata)
Definition: scip_dialog.c:59
SCIPdialoghdlrIsBufferEmpty
SCIP_Bool SCIPdialoghdlrIsBufferEmpty(SCIP_DIALOGHDLR *dialoghdlr)
Definition: dialog.c:457
SCIPaddDialogEntry
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
Definition: scip_dialog.c:171
SCIPdialoghdlrGetWord
SCIP_RETCODE SCIPdialoghdlrGetWord(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *prompt, char **inputword, SCIP_Bool *endoffile)
Definition: dialog.c:546
SCIPdialogGetData
SCIP_DIALOGDATA * SCIPdialogGetData(SCIP_DIALOG *dialog)
Definition: dialog.c:1253
SCIPdialogDisplayCompletions
SCIP_RETCODE SCIPdialogDisplayCompletions(SCIP_DIALOG *dialog, SCIP *scip, const char *entryname)
Definition: dialog.c:1140
SCIPsetRootDialog
SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip_dialog.c:141
SCIPgetRootDialog
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
Definition: scip_dialog.c:157
SCIPdialogWriteHistory
SCIP_RETCODE SCIPdialogWriteHistory(const char *filename)
Definition: dialog.c:1274
SCIPdialogFindEntry
int SCIPdialogFindEntry(SCIP_DIALOG *dialog, const char *entryname, SCIP_DIALOG **subdialog)
Definition: dialog.c:1028
SCIPdialoghdlrGetLine
SCIP_RETCODE SCIPdialoghdlrGetLine(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *prompt, char **inputline, SCIP_Bool *endoffile)
Definition: dialog.c:470
SCIPdialogGetParent
SCIP_DIALOG * SCIPdialogGetParent(SCIP_DIALOG *dialog)
Definition: dialog.c:1223
SCIPdialogDisplayMenu
SCIP_RETCODE SCIPdialogDisplayMenu(SCIP_DIALOG *dialog, SCIP *scip)
Definition: dialog.c:1072
SCIPgetDisps
SCIP_DISP ** SCIPgetDisps(SCIP *scip)
Definition: scip_disp.c:110
SCIPgetNDisps
int SCIPgetNDisps(SCIP *scip)
Definition: scip_disp.c:121
SCIPdispGetStatus
SCIP_DISPSTATUS SCIPdispGetStatus(SCIP_DISP *disp)
Definition: disp.c:395
SCIPdispGetName
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:335
SCIPdispGetHeader
const char * SCIPdispGetHeader(SCIP_DISP *disp)
Definition: disp.c:355
SCIPdispGetPosition
int SCIPdispGetPosition(SCIP_DISP *disp)
Definition: disp.c:385
SCIPdispGetPriority
int SCIPdispGetPriority(SCIP_DISP *disp)
Definition: disp.c:375
SCIPdispGetWidth
int SCIPdispGetWidth(SCIP_DISP *disp)
Definition: disp.c:365
SCIPdispGetDesc
const char * SCIPdispGetDesc(SCIP_DISP *disp)
Definition: disp.c:345
SCIPexprhdlrGetName
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:545
SCIPgetNExprhdlrs
int SCIPgetNExprhdlrs(SCIP *scip)
Definition: scip_expr.c:857
SCIPexprhdlrGetPrecedence
unsigned int SCIPexprhdlrGetPrecedence(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:565
SCIPexprhdlrGetDescription
const char * SCIPexprhdlrGetDescription(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:555
SCIPgetExprhdlrs
SCIP_EXPRHDLR ** SCIPgetExprhdlrs(SCIP *scip)
Definition: scip_expr.c:846
SCIPheurGetDispchar
char SCIPheurGetDispchar(SCIP_HEUR *heur)
Definition: heur.c:1473
SCIPgetHeurs
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip_heur.c:271
SCIPheurGetDesc
const char * SCIPheurGetDesc(SCIP_HEUR *heur)
Definition: heur.c:1463
SCIPheurGetPriority
int SCIPheurGetPriority(SCIP_HEUR *heur)
Definition: heur.c:1514
SCIPgetNHeurs
int SCIPgetNHeurs(SCIP *scip)
Definition: scip_heur.c:282
SCIPheurGetFreqofs
int SCIPheurGetFreqofs(SCIP_HEUR *heur)
Definition: heur.c:1559
SCIPheurGetFreq
int SCIPheurGetFreq(SCIP_HEUR *heur)
Definition: heur.c:1538
SCIPheurGetName
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1453
SCIPprintLPSolutionQuality
SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip_lp.c:1021
SCIPwriteMIP
SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip_lp.c:935
SCIPwriteLP
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip_lp.c:901
SCIPprintMemoryDiagnostic
void SCIPprintMemoryDiagnostic(SCIP *scip)
Definition: scip_mem.c:181
SCIPfreeBufferArray
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:136
SCIPduplicateBufferArray
#define SCIPduplicateBufferArray(scip, ptr, source, num)
Definition: scip_mem.h:132
SCIPfreeBufferArrayNull
#define SCIPfreeBufferArrayNull(scip, ptr)
Definition: scip_mem.h:137
SCIPnlpiGetDesc
const char * SCIPnlpiGetDesc(SCIP_NLPI *nlpi)
Definition: nlpi.c:732
SCIPnlpiGetPriority
int SCIPnlpiGetPriority(SCIP_NLPI *nlpi)
Definition: nlpi.c:742
SCIPnlpiGetName
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition: nlpi.c:722
SCIPgetNNlpis
int SCIPgetNNlpis(SCIP *scip)
Definition: scip_nlpi.c:200
SCIPgetNlpis
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
Definition: scip_nlpi.c:187
SCIPwriteNLP
SCIP_RETCODE SCIPwriteNLP(SCIP *scip, const char *filename)
Definition: scip_nlp.c:727
SCIPisNLPConstructed
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
Definition: scip_nlp.c:110
SCIPgetNodesels
SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)
Definition: scip_nodesel.c:247
SCIPnodeselGetDesc
const char * SCIPnodeselGetDesc(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1062
SCIPnodeselGetMemsavePriority
int SCIPnodeselGetMemsavePriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1096
SCIPnodeselGetStdPriority
int SCIPnodeselGetStdPriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1072
SCIPgetNNodesels
int SCIPgetNNodesels(SCIP *scip)
Definition: scip_nodesel.c:258
SCIPnodeselGetName
const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1052
SCIPpresolGetPriority
int SCIPpresolGetPriority(SCIP_PRESOL *presol)
Definition: presol.c:619
SCIPgetPresols
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip_presol.c:249
SCIPpresolGetDesc
const char * SCIPpresolGetDesc(SCIP_PRESOL *presol)
Definition: presol.c:609
SCIPgetNPresols
int SCIPgetNPresols(SCIP *scip)
Definition: scip_presol.c:262
SCIPpresolGetMaxrounds
int SCIPpresolGetMaxrounds(SCIP_PRESOL *presol)
Definition: presol.c:629
SCIPpresolGetTiming
SCIP_PRESOLTIMING SCIPpresolGetTiming(SCIP_PRESOL *presol)
Definition: presol.c:653
SCIPpresolGetName
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:599
SCIPpricerGetDesc
const char * SCIPpricerGetDesc(SCIP_PRICER *pricer)
Definition: pricer.c:610
SCIPpricerIsDelayed
SCIP_Bool SCIPpricerIsDelayed(SCIP_PRICER *pricer)
Definition: pricer.c:706
SCIPpricerGetPriority
int SCIPpricerGetPriority(SCIP_PRICER *pricer)
Definition: pricer.c:620
SCIPgetNPricers
int SCIPgetNPricers(SCIP *scip)
Definition: scip_pricer.c:337
SCIPgetPricers
SCIP_PRICER ** SCIPgetPricers(SCIP *scip)
Definition: scip_pricer.c:324
SCIPpricerGetName
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition: pricer.c:600
SCIPlinConsStatsFree
void SCIPlinConsStatsFree(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
Definition: cons.c:8064
SCIPprintLinConsStats
void SCIPprintLinConsStats(SCIP *scip, FILE *file, SCIP_LINCONSSTATS *linconsstats)
Definition: cons.c:8124
SCIPlinConsStatsCreate
SCIP_RETCODE SCIPlinConsStatsCreate(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
Definition: cons.c:8051
SCIPpropIsDelayed
SCIP_Bool SCIPpropIsDelayed(SCIP_PROP *prop)
Definition: prop.c:1136
SCIPpropGetFreq
int SCIPpropGetFreq(SCIP_PROP *prop)
Definition: prop.c:1009
SCIPgetNProps
int SCIPgetNProps(SCIP *scip)
Definition: scip_prop.c:355
SCIPpropGetDesc
const char * SCIPpropGetDesc(SCIP_PROP *prop)
Definition: prop.c:951
SCIPpropGetPresolPriority
int SCIPpropGetPresolPriority(SCIP_PROP *prop)
Definition: prop.c:971
SCIPpropGetName
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:941
SCIPpropGetPriority
int SCIPpropGetPriority(SCIP_PROP *prop)
Definition: prop.c:961
SCIPgetProps
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip_prop.c:342
SCIPpropGetPresolTiming
SCIP_PRESOLTIMING SCIPpropGetPresolTiming(SCIP_PROP *prop)
Definition: prop.c:1296
SCIPreaderGetExtension
const char * SCIPreaderGetExtension(SCIP_READER *reader)
Definition: reader.c:577
SCIPgetNReaders
int SCIPgetNReaders(SCIP *scip)
Definition: scip_reader.c:259
SCIPreaderGetName
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:557
SCIPreaderCanRead
SCIP_Bool SCIPreaderCanRead(SCIP_READER *reader)
Definition: reader.c:587
SCIPgetReaders
SCIP_READER ** SCIPgetReaders(SCIP *scip)
Definition: scip_reader.c:248
SCIPreaderCanWrite
SCIP_Bool SCIPreaderCanWrite(SCIP_READER *reader)
Definition: reader.c:597
SCIPreaderGetDesc
const char * SCIPreaderGetDesc(SCIP_READER *reader)
Definition: reader.c:567
SCIPgetRelaxs
SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)
Definition: scip_relax.c:247
SCIPgetNRelaxs
int SCIPgetNRelaxs(SCIP *scip)
Definition: scip_relax.c:260
SCIPrelaxGetFreq
int SCIPrelaxGetFreq(SCIP_RELAX *relax)
Definition: relax.c:586
SCIPrelaxGetName
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:542
SCIPrelaxGetDesc
const char * SCIPrelaxGetDesc(SCIP_RELAX *relax)
Definition: relax.c:552
SCIPrelaxGetPriority
int SCIPrelaxGetPriority(SCIP_RELAX *relax)
Definition: relax.c:562
SCIPgetNSepas
int SCIPgetNSepas(SCIP *scip)
Definition: scip_sepa.c:273
SCIPsepaGetPriority
int SCIPsepaGetPriority(SCIP_SEPA *sepa)
Definition: sepa.c:763
SCIPsepaGetMaxbounddist
SCIP_Real SCIPsepaGetMaxbounddist(SCIP_SEPA *sepa)
Definition: sepa.c:808
SCIPsepaGetFreq
int SCIPsepaGetFreq(SCIP_SEPA *sepa)
Definition: sepa.c:787
SCIPsepaGetName
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:743
SCIPsepaGetDesc
const char * SCIPsepaGetDesc(SCIP_SEPA *sepa)
Definition: sepa.c:753
SCIPsepaIsDelayed
SCIP_Bool SCIPsepaIsDelayed(SCIP_SEPA *sepa)
Definition: sepa.c:1089
SCIPgetSepas
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip_sepa.c:260
SCIPcheckSolOrig
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
Definition: scip_sol.c:3309
SCIPgetBestSol
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip_sol.c:2169
SCIPprintBestSol
SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:2235
SCIPfreeSol
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip_sol.c:841
SCIPsolGetRelBoundViolation
SCIP_Real SCIPsolGetRelBoundViolation(SCIP_SOL *sol)
Definition: sol.c:2623
SCIPprintSol
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:1631
SCIPsolGetAbsConsViolation
SCIP_Real SCIPsolGetAbsConsViolation(SCIP_SOL *sol)
Definition: sol.c:2663
SCIPsolGetAbsBoundViolation
SCIP_Real SCIPsolGetAbsBoundViolation(SCIP_SOL *sol)
Definition: sol.c:2613
SCIPcreateNLPSol
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip_sol.c:254
SCIPsolGetAbsIntegralityViolation
SCIP_Real SCIPsolGetAbsIntegralityViolation(SCIP_SOL *sol)
Definition: sol.c:2633
SCIPtransformObj
SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip_sol.c:1407
SCIPgetNSols
int SCIPgetNSols(SCIP *scip)
Definition: scip_sol.c:2070
SCIPsolGetAbsLPRowViolation
SCIP_Real SCIPsolGetAbsLPRowViolation(SCIP_SOL *sol)
Definition: sol.c:2643
SCIPcreateFiniteSolCopy
SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
Definition: scip_sol.c:705
SCIPprintBestTransSol
SCIP_RETCODE SCIPprintBestTransSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:2275
SCIPsolIsOriginal
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
Definition: sol.c:2721
SCIPprintMIPStart
SCIP_RETCODE SCIPprintMIPStart(SCIP *scip, SCIP_SOL *sol, FILE *file)
Definition: scip_sol.c:1770
SCIPsolGetRelLPRowViolation
SCIP_Real SCIPsolGetRelLPRowViolation(SCIP_SOL *sol)
Definition: sol.c:2653
SCIPgetSols
SCIP_SOL ** SCIPgetSols(SCIP *scip)
Definition: scip_sol.c:2119
SCIPgetSolVal
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip_sol.c:1217
SCIPsolGetRelConsViolation
SCIP_Real SCIPsolGetRelConsViolation(SCIP_SOL *sol)
Definition: sol.c:2673
SCIPprintDualSol
SCIP_RETCODE SCIPprintDualSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:2001
SCIPtransformProb
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
Definition: scip_solve.c:222
SCIPpresolve
SCIP_RETCODE SCIPpresolve(SCIP *scip)
Definition: scip_solve.c:2328
SCIPsolveConcurrent
SCIP_RETCODE SCIPsolveConcurrent(SCIP *scip)
Definition: scip_solve.c:2860
SCIPfreeTransform
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
Definition: scip_solve.c:3344
SCIPfreeSolve
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
Definition: scip_solve.c:3214
SCIPsolve
SCIP_RETCODE SCIPsolve(SCIP *scip)
Definition: scip_solve.c:2498
SCIPprintStatistics
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4186
SCIPprintBranchingStatistics
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4320
SCIPprintTransProblem
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2415
SCIPprintReoptStatistics
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4239
SCIPprintOrigProblem
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2371
SCIPisInfinity
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:521
SCIPchgFeastol
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
Definition: scip_numerics.c:253
SCIPfeastol
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip_numerics.c:165
SCIPisGT
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:484
SCIPisEQ
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:445
SCIPisLT
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:458
SCIPparseReal
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
Definition: scip_numerics.c:404
SCIPvalidateSolve
SCIP_RETCODE SCIPvalidateSolve(SCIP *scip, SCIP_Real primalreference, SCIP_Real dualreference, SCIP_Real reftol, SCIP_Bool quiet, SCIP_Bool *feasible, SCIP_Bool *primalboundcheck, SCIP_Bool *dualboundcheck)
Definition: scip_validation.c:69
SCIPvarGetStatus
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:17538
SCIPwriteCliqueGraph
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7710
SCIPvarGetObj
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17926
SCIPvarGetUbGlobal
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:18088
SCIPchgVarBranchDirection
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:8085
SCIPchgVarBranchPriority
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7980
SCIPvarGetName
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17419
SCIPchgVarLbGlobal
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4943
SCIPvarGetBranchDirection
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
Definition: var.c:18260
SCIPchgVarUbGlobal
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:5032
SCIPvarGetBranchPriority
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:18250
SCIPvarGetLbGlobal
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:18078
SCIPsortPtr
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIPstrToIntValue
SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)
Definition: misc.c:10946
SCIPsnprintf
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10877
SCIPescapeString
void SCIPescapeString(char *t, int bufsize, const char *s)
Definition: misc.c:10832
SCIPprintSysError
void SCIPprintSysError(const char *message)
Definition: misc.c:10769
SCIPstrncpy
int SCIPstrncpy(char *t, const char *s, int size)
Definition: misc.c:10919
paramname
static const char * paramname[]
Definition: lpi_msk.c:5096
memory.h
memory allocation routines
BMSduplicateMemoryArray
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:143
BMSfreeMemoryArray
#define BMSfreeMemoryArray(ptr)
Definition: memory.h:147
SCIPmessageFPrintInfo
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition: message.c:618
SCIPparamGetName
const char * SCIPparamGetName(SCIP_PARAM *param)
Definition: paramset.c:659
SCIPparamGetRealMin
SCIP_Real SCIPparamGetRealMin(SCIP_PARAM *param)
Definition: paramset.c:842
SCIPparamGetCharAllowedValues
char * SCIPparamGetCharAllowedValues(SCIP_PARAM *param)
Definition: paramset.c:889
SCIPparamIsAdvanced
SCIP_Bool SCIPparamIsAdvanced(SCIP_PARAM *param)
Definition: paramset.c:689
SCIPparamGetType
SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM *param)
Definition: paramset.c:649
SCIPparamGetString
char * SCIPparamGetString(SCIP_PARAM *param)
Definition: paramset.c:911
SCIPparamGetIntMin
int SCIPparamGetIntMin(SCIP_PARAM *param)
Definition: paramset.c:748
SCIPparamSetFixed
void SCIPparamSetFixed(SCIP_PARAM *param, SCIP_Bool fixed)
Definition: paramset.c:4440
SCIPparamGetLongintMin
SCIP_Longint SCIPparamGetLongintMin(SCIP_PARAM *param)
Definition: paramset.c:795
SCIPparamGetBool
SCIP_Bool SCIPparamGetBool(SCIP_PARAM *param)
Definition: paramset.c:709
SCIPparamGetDesc
const char * SCIPparamGetDesc(SCIP_PARAM *param)
Definition: paramset.c:669
SCIPparamGetInt
int SCIPparamGetInt(SCIP_PARAM *param)
Definition: paramset.c:734
SCIPparamGetIntMax
int SCIPparamGetIntMax(SCIP_PARAM *param)
Definition: paramset.c:759
SCIPparamGetReal
SCIP_Real SCIPparamGetReal(SCIP_PARAM *param)
Definition: paramset.c:828
SCIPparamGetChar
char SCIPparamGetChar(SCIP_PARAM *param)
Definition: paramset.c:875
SCIPparamGetLongint
SCIP_Longint SCIPparamGetLongint(SCIP_PARAM *param)
Definition: paramset.c:781
SCIPparamGetLongintMax
SCIP_Longint SCIPparamGetLongintMax(SCIP_PARAM *param)
Definition: paramset.c:806
SCIPparamGetRealMax
SCIP_Real SCIPparamGetRealMax(SCIP_PARAM *param)
Definition: paramset.c:853
SCIPparamIsFixed
SCIP_Bool SCIPparamIsFixed(SCIP_PARAM *param)
Definition: paramset.c:699
pub_benders.h
public methods for Benders' decomposition
pub_branch.h
public methods for branching rules
pub_compr.h
public methods for tree compressions
pub_conflict.h
public methods for conflict analysis handlers
pub_cons.h
public methods for managing constraints
pub_cutsel.h
public methods for cut selectors
pub_dialog.h
public methods for user interface dialog
pub_disp.h
public methods for displaying runtime statistics
pub_expr.h
public functions to work with algebraic expressions
pub_heur.h
public methods for primal heuristics
pub_message.h
public methods for message output
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:64
pub_misc.h
public data structures and miscellaneous methods
pub_misc_sort.h
methods for sorting joint arrays of various types
pub_nodesel.h
public methods for node selectors
pub_paramset.h
public methods for handling parameter settings
pub_presol.h
public methods for presolvers
pub_pricer.h
public methods for variable pricers
pub_prop.h
public methods for propagators
pub_reader.h
public methods for input file readers
pub_relax.h
public methods for relaxation handlers
pub_sepa.h
public methods for separators
pub_sol.h
public methods for primal CIP solutions
pub_var.h
public methods for problem variables
scip_benders.h
public methods for Benders decomposition
scip_branch.h
public methods for branching rule plugins and branching
scip_compr.h
public methods for compression plugins
scip_conflict.h
public methods for conflict handler plugins and conflict analysis
scip_cons.h
public methods for constraint handler plugins and constraints
scip_cutsel.h
public methods for cut selector plugins
scip_dialog.h
public methods for dialog handler plugins
scip_disp.h
public methods for display handler plugins
scip_expr.h
public functions to work with algebraic expressions
scip_general.h
general public methods
scip_heur.h
public methods for primal heuristic plugins and divesets
scip_lp.h
public methods for the LP relaxation, rows and columns
scip_mem.h
public methods for memory management
scip_message.h
public methods for message handling
scip_nlp.h
public methods for nonlinear relaxation
scip_nlpi.h
public methods for NLPI solver interfaces
scip_nodesel.h
public methods for node selector plugins
scip_numerics.h
public methods for numerical tolerances
scip_param.h
public methods for SCIP parameter handling
scip_presol.h
public methods for presolving plugins
scip_pricer.h
public methods for variable pricer plugins
scip_prob.h
public methods for global and local (sub)problems
scip_prop.h
public methods for propagator plugins
scip_reader.h
public methods for reader plugins
scip_relax.h
public methods for relaxator plugins
scip_sepa.h
public methods for separator plugins
scip_sol.h
public methods for solutions
scip_solve.h
public solving methods
scip_solvingstats.h
public methods for querying solving statistics
scip_validation.h
public methods for validation
scip_var.h
public methods for SCIP variables
SCIP_Benders
Definition: struct_benders.h:58
SCIP_Branchrule
Definition: struct_branch.h:79
SCIP_Compr
Definition: struct_compr.h:47
SCIP_Conflicthdlr
Definition: struct_conflict.h:50
SCIP_Cons
Definition: struct_cons.h:47
SCIP_Conshdlr
Definition: struct_cons.h:127
SCIP_Cutsel
Definition: struct_cutsel.h:47
SCIP_Dialog
Definition: struct_dialog.h:46
SCIP_Dialoghdlr
Definition: struct_dialog.h:71
SCIP_Disp
Definition: struct_disp.h:46
SCIP_Exprhdlr
Definition: struct_expr.h:44
SCIP_Heur
Definition: struct_heur.h:98
SCIP_LinConsStats
Definition: struct_cons.h:292
SCIP_Nlpi
Definition: struct_nlpi.h:47
SCIP_Nodesel
Definition: struct_nodesel.h:62
SCIP_Param
Definition: struct_paramset.h:109
SCIP_Presol
Definition: struct_presol.h:47
SCIP_Pricer
Definition: struct_pricer.h:47
SCIP_Prop
Definition: struct_prop.h:47
SCIP_Reader
Definition: struct_reader.h:46
SCIP_Relax
Definition: struct_relax.h:47
SCIP_Sepa
Definition: struct_sepa.h:47
SCIP_Sol
Definition: struct_sol.h:74
SCIP_Var
Definition: struct_var.h:208
SCIP_BENDERSENFOTYPE_CHECK
@ SCIP_BENDERSENFOTYPE_CHECK
Definition: type_benders.h:49
SCIP_BENDERSSUBTYPE_CONVEXCONT
@ SCIP_BENDERSSUBTYPE_CONVEXCONT
Definition: type_benders.h:73
SCIP_DIALOGDATA
struct SCIP_DialogData SCIP_DIALOGDATA
Definition: type_dialog.h:51
SCIP_DISPSTATUS_ON
@ SCIP_DISPSTATUS_ON
Definition: type_disp.h:62
SCIP_DISPSTATUS_OFF
@ SCIP_DISPSTATUS_OFF
Definition: type_disp.h:60
SCIP_DISPSTATUS_AUTO
@ SCIP_DISPSTATUS_AUTO
Definition: type_disp.h:61
SCIP_BRANCHDIR_DOWNWARDS
@ SCIP_BRANCHDIR_DOWNWARDS
Definition: type_history.h:43
SCIP_BRANCHDIR_FIXED
@ SCIP_BRANCHDIR_FIXED
Definition: type_history.h:45
SCIP_BRANCHDIR_AUTO
@ SCIP_BRANCHDIR_AUTO
Definition: type_history.h:46
SCIP_BRANCHDIR_UPWARDS
@ SCIP_BRANCHDIR_UPWARDS
Definition: type_history.h:44
SCIP_PARAMSETTING_OFF
@ SCIP_PARAMSETTING_OFF
Definition: type_paramset.h:63
SCIP_PARAMSETTING_AGGRESSIVE
@ SCIP_PARAMSETTING_AGGRESSIVE
Definition: type_paramset.h:61
SCIP_PARAMSETTING_DEFAULT
@ SCIP_PARAMSETTING_DEFAULT
Definition: type_paramset.h:59
SCIP_PARAMSETTING_FAST
@ SCIP_PARAMSETTING_FAST
Definition: type_paramset.h:62
SCIP_PARAMEMPHASIS_NUMERICS
@ SCIP_PARAMEMPHASIS_NUMERICS
Definition: type_paramset.h:81
SCIP_PARAMEMPHASIS_CPSOLVER
@ SCIP_PARAMEMPHASIS_CPSOLVER
Definition: type_paramset.h:72
SCIP_PARAMEMPHASIS_HARDLP
@ SCIP_PARAMEMPHASIS_HARDLP
Definition: type_paramset.h:75
SCIP_PARAMEMPHASIS_FEASIBILITY
@ SCIP_PARAMEMPHASIS_FEASIBILITY
Definition: type_paramset.h:74
SCIP_PARAMEMPHASIS_BENCHMARK
@ SCIP_PARAMEMPHASIS_BENCHMARK
Definition: type_paramset.h:82
SCIP_PARAMEMPHASIS_EASYCIP
@ SCIP_PARAMEMPHASIS_EASYCIP
Definition: type_paramset.h:73
SCIP_PARAMEMPHASIS_COUNTER
@ SCIP_PARAMEMPHASIS_COUNTER
Definition: type_paramset.h:77
SCIP_PARAMEMPHASIS_OPTIMALITY
@ SCIP_PARAMEMPHASIS_OPTIMALITY
Definition: type_paramset.h:76
SCIP_PARAMTYPE_CHAR
@ SCIP_PARAMTYPE_CHAR
Definition: type_paramset.h:51
SCIP_PARAMTYPE_STRING
@ SCIP_PARAMTYPE_STRING
Definition: type_paramset.h:52
SCIP_PARAMTYPE_BOOL
@ SCIP_PARAMTYPE_BOOL
Definition: type_paramset.h:47
SCIP_PARAMTYPE_INT
@ SCIP_PARAMTYPE_INT
Definition: type_paramset.h:48
SCIP_PARAMTYPE_LONGINT
@ SCIP_PARAMTYPE_LONGINT
Definition: type_paramset.h:49
SCIP_PARAMTYPE_REAL
@ SCIP_PARAMTYPE_REAL
Definition: type_paramset.h:50
SCIP_OBJSENSE_MAXIMIZE
@ SCIP_OBJSENSE_MAXIMIZE
Definition: type_prob.h:47
SCIP_OBJSENSE_MINIMIZE
@ SCIP_OBJSENSE_MINIMIZE
Definition: type_prob.h:48
SCIP_FILECREATEERROR
@ SCIP_FILECREATEERROR
Definition: type_retcode.h:48
SCIP_NOFILE
@ SCIP_NOFILE
Definition: type_retcode.h:47
SCIP_READERROR
@ SCIP_READERROR
Definition: type_retcode.h:45
SCIP_INVALIDDATA
@ SCIP_INVALIDDATA
Definition: type_retcode.h:52
SCIP_PLUGINNOTFOUND
@ SCIP_PLUGINNOTFOUND
Definition: type_retcode.h:54
SCIP_WRITEERROR
@ SCIP_WRITEERROR
Definition: type_retcode.h:46
SCIP_PARAMETERWRONGVAL
@ SCIP_PARAMETERWRONGVAL
Definition: type_retcode.h:57
SCIP_OKAY
@ SCIP_OKAY
Definition: type_retcode.h:42
SCIP_INVALIDCALL
@ SCIP_INVALIDCALL
Definition: type_retcode.h:51
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_STAGE_PROBLEM
@ SCIP_STAGE_PROBLEM
Definition: type_set.h:45
SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_INITPRESOLVE
Definition: type_set.h:48
SCIP_STAGE_SOLVED
@ SCIP_STAGE_SOLVED
Definition: type_set.h:54
SCIP_STAGE_PRESOLVING
@ SCIP_STAGE_PRESOLVING
Definition: type_set.h:49
SCIP_STAGE_TRANSFORMED
@ SCIP_STAGE_TRANSFORMED
Definition: type_set.h:47
SCIP_STAGE_INITSOLVE
@ SCIP_STAGE_INITSOLVE
Definition: type_set.h:52
SCIP_STAGE_EXITPRESOLVE
@ SCIP_STAGE_EXITPRESOLVE
Definition: type_set.h:50
SCIP_STAGE_EXITSOLVE
@ SCIP_STAGE_EXITSOLVE
Definition: type_set.h:55
SCIP_STAGE_INIT
@ SCIP_STAGE_INIT
Definition: type_set.h:44
SCIP_STAGE_FREE
@ SCIP_STAGE_FREE
Definition: type_set.h:57
SCIP_STAGE_FREETRANS
@ SCIP_STAGE_FREETRANS
Definition: type_set.h:56
SCIP_STAGE_SOLVING
@ SCIP_STAGE_SOLVING
Definition: type_set.h:53
SCIP_STAGE_TRANSFORMING
@ SCIP_STAGE_TRANSFORMING
Definition: type_set.h:46
SCIP_STAGE_PRESOLVED
@ SCIP_STAGE_PRESOLVED
Definition: type_set.h:51
SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_MEDIUM
Definition: type_timing.h:53
SCIP_PRESOLTIMING_FAST
#define SCIP_PRESOLTIMING_FAST
Definition: type_timing.h:52
SCIP_PRESOLTIMING_EXHAUSTIVE
#define SCIP_PRESOLTIMING_EXHAUSTIVE
Definition: type_timing.h:54
SCIP_VARSTATUS_FIXED
@ SCIP_VARSTATUS_FIXED
Definition: type_var.h:52