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 */
97 static
98 SCIP_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 */
162 static
163 SCIP_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 */
199 static
200 void 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 */
236 static
237 SCIP_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) */
331 static
332 SCIP_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 */
346 SCIP_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 */
362 SCIP_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 */
370 SCIP_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 */
423 SCIP_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 */
534 SCIP_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 */
548 SCIP_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 */
588 SCIP_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 */
645 SCIP_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 */
689 SCIP_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 */
721 SCIP_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 */
764 SCIP_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 */
813 SCIP_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 */
855 SCIP_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 */
898 SCIP_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 */
950 SCIP_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 */
980 SCIP_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 */
1012 SCIP_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 */
1057 SCIP_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 */
1071 SCIP_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 */
1122 SCIP_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 */
1155 SCIP_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 */
1171 SCIP_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 */
1211 SCIP_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 */
1243 SCIP_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 */
1264 SCIP_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 */
1305 SCIP_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 */
1318 SCIP_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 */
1352 SCIP_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\
1389 If 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 */
1401 SCIP_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 */
1451 SCIP_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 */
1466 SCIP_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 */
1526 SCIP_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 */
1670 SCIP_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 */
1852 SCIP_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 */
1866 SCIP_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 */
1880 SCIP_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 */
1922 SCIP_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 */
1942 SCIP_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 */
2000 SCIP_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 */
2014 SCIP_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 */
2028 SCIP_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 */
2042 SCIP_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 */
2068 SCIP_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 */
2080 SCIP_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 */
2092 SCIP_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 */
2134 SCIP_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( SCIPsolveParallel(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 */
2176 SCIP_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 */
2218 SCIP_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 */
2263 SCIP_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 */
2273 SCIP_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 */
2365 SCIP_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 */
2378 SCIP_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 */
2412 SCIP_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 */
2449 SCIP_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 */
2486 SCIP_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 */
2739 SCIP_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 */
2795 SCIP_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 */
2839 SCIP_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 */
2859 SCIP_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 */
2952 SCIP_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 */
3017 SCIP_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 */
3029 SCIP_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 */
3041 SCIP_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 */
3053 SCIP_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 */
3065 SCIP_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 */
3077 SCIP_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 */
3089 SCIP_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 */
3101 SCIP_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 */
3113 SCIP_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 */
3125 SCIP_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 */
3137 SCIP_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 */
3149 SCIP_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 */
3161 SCIP_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 */
3176 SCIP_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 */
3191 SCIP_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 */
3206 SCIP_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 */
3221 SCIP_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 */
3236 SCIP_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 */
3251 SCIP_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 */
3266 SCIP_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 */
3281 SCIP_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 */
3334 static
3335 SCIP_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 */
3389 static
3390 SCIP_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 */
3518 static
3519 SCIP_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 */
3579 static
3580 SCIP_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 */
3597 static
3598 SCIP_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 */
3615 static
3616 SCIP_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 */
3666 static
3667 SCIP_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 */
3722 static
3723 SCIP_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 */
3764 static
3765 SCIP_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 */
3842 static
3843 SCIP_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 */
3886 static
3887 SCIP_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 */
3904 static
3905 SCIP_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 */
3922 static
3923 SCIP_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 */
3977 SCIP_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 */
4003 SCIP_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" */
4022 SCIP_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  */
4786 static
4787 SCIP_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  */
4897 static
4898 SCIP_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 */
5006 static
5007 SCIP_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 */
5034 SCIP_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 */
5917 SCIP_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 }
SCIPnlpiGetPriority
int SCIPnlpiGetPriority(SCIP_NLPI *nlpi)
Definition: nlpi.c:742
SCIPsolIsOriginal
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
Definition: sol.c:2721
SCIPgetNExprhdlrs
int SCIPgetNExprhdlrs(SCIP *scip)
Definition: scip_expr.c:857
SCIPprintReoptStatistics
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4243
SCIPprintBestSol
SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:2235
SCIP_DECL_DIALOGDESC
SCIP_DECL_DIALOGDESC(SCIPdialogDescSetParam)
Definition: dialog_default.c:2739
SCIPcomprGetDesc
const char * SCIPcomprGetDesc(SCIP_COMPR *compr)
Definition: compr.c:466
SCIPgetParams
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip_param.c:999
SCIP_PARAMEMPHASIS_CPSOLVER
Definition: type_paramset.h:72
SCIP_Presol
Definition: struct_presol.h:46
SCIP_Nodesel
Definition: struct_nodesel.h:61
SCIPgetNCutsels
int SCIPgetNCutsels(SCIP *scip)
Definition: scip_cutsel.c:247
SCIPchgVarLbGlobal
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:4945
SCIP_LinConsStats
Definition: struct_cons.h:291
SCIPcutselGetName
const char * SCIPcutselGetName(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:159
SCIPsetSeparating
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:979
NULL
#define NULL
Definition: def.h:267
SCIPfeastol
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip_numerics.c:165
SCIPconflicthdlrGetDesc
const char * SCIPconflicthdlrGetDesc(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict_graphanalysis.c:1503
SCIPheurGetPriority
int SCIPheurGetPriority(SCIP_HEUR *heur)
Definition: heur.c:1514
scip_relax.h
public methods for relaxator plugins
SCIPfreeBendersSubproblem
SCIP_RETCODE SCIPfreeBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, int probnumber)
Definition: scip_benders.c:861
SCIPisNLPConstructed
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
Definition: scip_nlp.c:110
SCIPdialoghdlrClearBuffer
void SCIPdialoghdlrClearBuffer(SCIP_DIALOGHDLR *dialoghdlr)
Definition: dialog.c:446
SCIPnodeselGetMemsavePriority
int SCIPnodeselGetMemsavePriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1096
SCIPgetExprhdlrs
SCIP_EXPRHDLR ** SCIPgetExprhdlrs(SCIP *scip)
Definition: scip_expr.c:846
scip_param.h
public methods for SCIP parameter handling
SCIP_Reader
Definition: struct_reader.h:45
SCIPpricerGetName
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
Definition: pricer.c:600
SCIPgetStage
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:380
SCIPgetNodesels
SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)
Definition: scip_nodesel.c:247
SCIPpropGetPresolTiming
SCIP_PRESOLTIMING SCIPpropGetPresolTiming(SCIP_PROP *prop)
Definition: prop.c:1296
SCIPsolGetRelBoundViolation
SCIP_Real SCIPsolGetRelBoundViolation(SCIP_SOL *sol)
Definition: sol.c:2623
SCIPgetNRelaxs
int SCIPgetNRelaxs(SCIP *scip)
Definition: scip_relax.c:260
SCIPdispGetStatus
SCIP_DISPSTATUS SCIPdispGetStatus(SCIP_DISP *disp)
Definition: disp.c:395
SCIPbranchruleGetMaxbounddist
SCIP_Real SCIPbranchruleGetMaxbounddist(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2037
SCIPdialogMessage
void SCIPdialogMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:191
scip_nodesel.h
public methods for node selector plugins
SCIP_OBJSENSE_MAXIMIZE
Definition: type_prob.h:47
SCIPcomprGetMinNodes
int SCIPcomprGetMinNodes(SCIP_COMPR *compr)
Definition: compr.c:500
scip_mem.h
public methods for memory management
SCIPaddDialogEntry
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
Definition: scip_dialog.c:171
SCIPvarGetBranchDirection
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
Definition: var.c:18261
SCIP_PARAMEMPHASIS_BENCHMARK
Definition: type_paramset.h:82
SCIPwriteLP
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip_lp.c:901
SCIPreaderCanWrite
SCIP_Bool SCIPreaderCanWrite(SCIP_READER *reader)
Definition: reader.c:597
SCIPvarGetLbGlobal
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:18079
SCIPgetRealParam
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:307
SCIP_MAXSTRLEN
#define SCIP_MAXSTRLEN
Definition: def.h:288
scip_compr.h
public methods for compression plugins
SCIPbendersGetName
const char * SCIPbendersGetName(SCIP_BENDERS *benders)
Definition: benders.c:5926
SCIPexprhdlrGetName
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:545
SCIPparseReal
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
Definition: scip_numerics.c:404
scip_conflict.h
public methods for conflict handler plugins and conflict analysis
SCIP_DECL_DIALOGCOPY
static SCIP_DECL_DIALOGCOPY(dialogCopyDefault)
Definition: dialog_default.c:332
SCIPparamGetChar
char SCIPparamGetChar(SCIP_PARAM *param)
Definition: paramset.c:875
bound
static long bound
Definition: GomoryHuTree.cpp:47
SCIPcomprGetPriority
int SCIPcomprGetPriority(SCIP_COMPR *compr)
Definition: compr.c:476
SCIPisStringParamValid
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:734
SCIPpropGetPriority
int SCIPpropGetPriority(SCIP_PROP *prop)
Definition: prop.c:961
SCIP_CALL_FINALLY
#define SCIP_CALL_FINALLY(x, y)
Definition: def.h:422
SCIPgetRelaxs
SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)
Definition: scip_relax.c:247
SCIPpropIsDelayed
SCIP_Bool SCIPpropIsDelayed(SCIP_PROP *prop)
Definition: prop.c:1136
SCIP_STAGE_TRANSFORMING
Definition: type_set.h:46
scip_solve.h
public solving methods
SCIPdispGetWidth
int SCIPdispGetWidth(SCIP_DISP *disp)
Definition: disp.c:365
SCIP_Var
Definition: struct_var.h:207
SCIPprintTransProblem
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2419
SCIP_PARAMEMPHASIS_OPTIMALITY
Definition: type_paramset.h:76
SCIPreaderGetName
const char * SCIPreaderGetName(SCIP_READER *reader)
Definition: reader.c:557
SCIP_Dialog
Definition: struct_dialog.h:45
SCIPbranchruleGetDesc
const char * SCIPbranchruleGetDesc(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1981
SCIP_BENDERSENFOTYPE_CHECK
Definition: type_benders.h:49
SCIP_DISPSTATUS_ON
Definition: type_disp.h:62
dialogExecMenu
static SCIP_RETCODE dialogExecMenu(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG **nextdialog)
Definition: dialog_default.c:98
SCIPnodeselGetDesc
const char * SCIPnodeselGetDesc(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1062
SCIPsetHeuristics
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:927
SCIPdialogDisplayCompletions
SCIP_RETCODE SCIPdialogDisplayCompletions(SCIP_DIALOG *dialog, SCIP *scip, const char *entryname)
Definition: dialog.c:1140
SCIPgetSols
SCIP_SOL ** SCIPgetSols(SCIP *scip)
Definition: scip_sol.c:2119
SCIP_PARAMTYPE_INT
Definition: type_paramset.h:48
FALSE
#define FALSE
Definition: def.h:94
scip_presol.h
public methods for presolving plugins
pub_benders.h
public methods for Benders&#39; decomposition
SCIPconshdlrGetPresolTiming
SCIP_PRESOLTIMING SCIPconshdlrGetPresolTiming(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5274
SCIP_Exprhdlr
Definition: struct_expr.h:43
SCIPisIntParamValid
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:502
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
SCIPsnprintf
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10877
TRUE
#define TRUE
Definition: def.h:93
SCIPsepaGetName
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:743
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_PRESOLTIMING_EXHAUSTIVE
#define SCIP_PRESOLTIMING_EXHAUSTIVE
Definition: type_timing.h:54
SCIPwriteOrigProblem
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:601
SCIPsetPresolving
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:953
SCIP_Param
Definition: struct_paramset.h:108
SCIPheurGetFreqofs
int SCIPheurGetFreqofs(SCIP_HEUR *heur)
Definition: heur.c:1559
SCIPgetHeurs
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip_heur.c:271
SCIPdispGetPriority
int SCIPdispGetPriority(SCIP_DISP *disp)
Definition: disp.c:375
SCIP_PARAMSETTING_DEFAULT
Definition: type_paramset.h:59
SCIP_BENDERSSUBTYPE_CONVEXCONT
Definition: type_benders.h:73
SCIPparamGetName
const char * SCIPparamGetName(SCIP_PARAM *param)
Definition: paramset.c:659
SCIPprintLinConsStats
void SCIPprintLinConsStats(SCIP *scip, FILE *file, SCIP_LINCONSSTATS *linconsstats)
Definition: cons.c:8126
SCIPdialogFindEntry
int SCIPdialogFindEntry(SCIP_DIALOG *dialog, const char *entryname, SCIP_DIALOG **subdialog)
Definition: dialog.c:1028
SCIPchgRealParam
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:577
pub_disp.h
public methods for displaying runtime statistics
pub_var.h
public methods for problem variables
SCIP_DIALOGDATA
struct SCIP_DialogData SCIP_DIALOGDATA
Definition: type_dialog.h:51
SCIPdispGetDesc
const char * SCIPdispGetDesc(SCIP_DISP *disp)
Definition: disp.c:345
SCIPstrToIntValue
SCIP_Bool SCIPstrToIntValue(const char *str, int *value, char **endptr)
Definition: misc.c:10946
SCIPnlpiGetName
const char * SCIPnlpiGetName(SCIP_NLPI *nlpi)
Definition: nlpi.c:722
scip_validation.h
public methods for validation
SCIPnlpiGetDesc
const char * SCIPnlpiGetDesc(SCIP_NLPI *nlpi)
Definition: nlpi.c:732
pub_branch.h
public methods for branching rules
SCIPgetMessagehdlr
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
Definition: scip_message.c:88
SCIPgetNlpis
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
Definition: scip_nlpi.c:187
SCIPduplicateBufferArray
#define SCIPduplicateBufferArray(scip, ptr, source, num)
Definition: scip_mem.h:132
SCIPbendersGetDesc
const char * SCIPbendersGetDesc(SCIP_BENDERS *benders)
Definition: benders.c:5936
SCIPconshdlrGetSepaFreq
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5132
SCIPpresolGetDesc
const char * SCIPpresolGetDesc(SCIP_PRESOL *presol)
Definition: presol.c:609
SCIPgetNPresols
int SCIPgetNPresols(SCIP *scip)
Definition: scip_presol.c:262
SCIPsolGetAbsConsViolation
SCIP_Real SCIPsolGetAbsConsViolation(SCIP_SOL *sol)
Definition: sol.c:2663
SCIPisEQ
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:445
SCIP_Sepa
Definition: struct_sepa.h:46
SCIP_BRANCHDIR_AUTO
Definition: type_history.h:46
SCIP_NOFILE
Definition: type_retcode.h:47
SCIPfreeBufferArray
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:136
SCIPisTransformed
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip_general.c:590
scip_var.h
public methods for SCIP variables
SCIP_Pricer
Definition: struct_pricer.h:46
SCIPchgStringParam
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:693
SCIPchgVarUbGlobal
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:5034
scip_sepa.h
public methods for separator plugins
SCIPparamGetReal
SCIP_Real SCIPparamGetReal(SCIP_PARAM *param)
Definition: paramset.c:828
SCIPconshdlrGetDesc
const char * SCIPconshdlrGetDesc(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4209
SCIPstrncpy
int SCIPstrncpy(char *t, const char *s, int size)
Definition: misc.c:10919
SCIPprintStatistics
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4190
SCIPdialogGetParent
SCIP_DIALOG * SCIPdialogGetParent(SCIP_DIALOG *dialog)
Definition: dialog.c:1223
SCIPinfoMessage
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
SCIPconshdlrGetSepaPriority
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5102
SCIP_PRESOLTIMING_FAST
#define SCIP_PRESOLTIMING_FAST
Definition: type_timing.h:52
scip_numerics.h
public methods for numerical tolerances
SCIP_Conflicthdlr
Definition: struct_conflict.h:49
SCIPgetNActiveBenders
int SCIPgetNActiveBenders(SCIP *scip)
Definition: scip_benders.c:532
SCIPgetCutsels
SCIP_CUTSEL ** SCIPgetCutsels(SCIP *scip)
Definition: scip_cutsel.c:234
SCIP_Benders
Definition: struct_benders.h:57
pub_expr.h
public functions to work with algebraic expressions
SCIP_REAL_FORMAT
#define SCIP_REAL_FORMAT
Definition: def.h:176
SCIPgetNConshdlrs
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip_cons.c:965
scip_solvingstats.h
public methods for querying solving statistics
SCIP_Sol
Definition: struct_sol.h:73
SCIPprintBranchingStatistics
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:4324
SCIPfileExists
SCIP_Bool SCIPfileExists(const char *filename)
Definition: misc.c:11079
SCIPgetNNlpis
int SCIPgetNNlpis(SCIP *scip)
Definition: scip_nlpi.c:200
SCIPsolGetRelConsViolation
SCIP_Real SCIPsolGetRelConsViolation(SCIP_SOL *sol)
Definition: sol.c:2673
SCIPgetNFixedVars
int SCIPgetNFixedVars(SCIP *scip)
Definition: scip_prob.c:2309
SCIPpricerGetPriority
int SCIPpricerGetPriority(SCIP_PRICER *pricer)
Definition: pricer.c:620
SCIPfindVar
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip_prob.c:2685
SCIPgetFixedVars
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
Definition: scip_prob.c:2266
SCIPisCharParamValid
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip_param.c:676
SCIPincludeDialogDefaultBasic
SCIP_RETCODE SCIPincludeDialogDefaultBasic(SCIP *scip)
Definition: dialog_default.c:4022
SCIPresetParams
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip_param.c:853
SCIPconshdlrGetCheckPriority
int SCIPconshdlrGetCheckPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5122
SCIPgetRootDialog
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
Definition: scip_dialog.c:157
SCIPvarGetUbGlobal
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:18089
SCIPgetReaders
SCIP_READER ** SCIPgetReaders(SCIP *scip)
Definition: scip_reader.c:248
SCIPsepaGetFreq
int SCIPsepaGetFreq(SCIP_SEPA *sepa)
Definition: sepa.c:787
scip_nlpi.h
public methods for NLPI solver interfaces
SCIPparamGetLongint
SCIP_Longint SCIPparamGetLongint(SCIP_PARAM *param)
Definition: paramset.c:781
SCIPparamGetString
char * SCIPparamGetString(SCIP_PARAM *param)
Definition: paramset.c:911
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
SCIPprintMemoryDiagnostic
void SCIPprintMemoryDiagnostic(SCIP *scip)
Definition: scip_mem.c:181
pub_paramset.h
public methods for handling parameter settings
SCIPconshdlrGetEagerFreq
int SCIPconshdlrGetEagerFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5152
pub_cons.h
public methods for managing constraints
SCIPsetObjsense
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip_prob.c:1242
SCIPisBoolParamValid
SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:444
SCIPsolGetAbsIntegralityViolation
SCIP_Real SCIPsolGetAbsIntegralityViolation(SCIP_SOL *sol)
Definition: sol.c:2633
SCIPbendersGetSubproblemType
SCIP_BENDERSSUBTYPE SCIPbendersGetSubproblemType(SCIP_BENDERS *benders, int probnumber)
Definition: benders.c:6323
SCIP_PRESOLTIMING_MEDIUM
#define SCIP_PRESOLTIMING_MEDIUM
Definition: type_timing.h:53
SCIPsolve
SCIP_RETCODE SCIPsolve(SCIP *scip)
Definition: scip_solve.c:2488
SCIPgetProps
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip_prop.c:342
SCIPheurGetName
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1453
BMSfreeMemoryArray
#define BMSfreeMemoryArray(ptr)
Definition: memory.h:147
SCIP_READERROR
Definition: type_retcode.h:45
scip_benders.h
public methods for Benders decomposition
SCIP_Cons
Definition: struct_cons.h:46
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:64
SCIPconshdlrGetName
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:4199
SCIPaddCons
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:2770
SCIPgetConshdlrs
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip_cons.c:954
SCIP_PARAMSETTING_OFF
Definition: type_paramset.h:63
SCIPincludeDialogDefaultFix
SCIP_RETCODE SCIPincludeDialogDefaultFix(SCIP *scip)
Definition: dialog_default.c:5917
SCIPisLT
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:458
SCIPwriteNLP
SCIP_RETCODE SCIPwriteNLP(SCIP *scip, const char *filename)
Definition: scip_nlp.c:727
SCIP_Conshdlr
Definition: struct_cons.h:126
SCIP_INVALIDCALL
Definition: type_retcode.h:51
SCIPfreeProb
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition: scip_prob.c:694
SCIPreadProb
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
Definition: scip_prob.c:339
SCIPdialogWriteHistory
SCIP_RETCODE SCIPdialogWriteHistory(const char *filename)
Definition: dialog.c:1274
SCIP_Compr
Definition: struct_compr.h:46
SCIPsetupBendersSubproblem
SCIP_RETCODE SCIPsetupBendersSubproblem(SCIP *scip, SCIP_BENDERS *benders, SCIP_SOL *sol, int probnumber, SCIP_BENDERSENFOTYPE type)
Definition: scip_benders.c:780
SCIP_PARAMETERWRONGVAL
Definition: type_retcode.h:57
addSetParamDialog
static SCIP_RETCODE addSetParamDialog(SCIP *scip, SCIP_DIALOG *menu, SCIP_PARAM *param, char *paramname)
Definition: dialog_default.c:4787
SCIPchgCharParam
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip_param.c:635
SCIPreaderCanRead
SCIP_Bool SCIPreaderCanRead(SCIP_READER *reader)
Definition: reader.c:587
SCIP_STAGE_EXITSOLVE
Definition: type_set.h:55
SCIPfreeBufferArrayNull
#define SCIPfreeBufferArrayNull(scip, ptr)
Definition: scip_mem.h:137
addFixParamDialog
static SCIP_RETCODE addFixParamDialog(SCIP *scip, SCIP_DIALOG *menu, SCIP_PARAM *param, char *paramname)
Definition: dialog_default.c:4898
SCIPpresolve
SCIP_RETCODE SCIPpresolve(SCIP *scip)
Definition: scip_solve.c:2318
SCIPgetNConflicthdlrs
int SCIPgetNConflicthdlrs(SCIP *scip)
Definition: scip_conflict.c:262
SCIPgetNDisps
int SCIPgetNDisps(SCIP *scip)
Definition: scip_disp.c:121
scip_expr.h
public functions to work with algebraic expressions
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
SCIPparamIsFixed
SCIP_Bool SCIPparamIsFixed(SCIP_PARAM *param)
Definition: paramset.c:699
SCIPescapeString
void SCIPescapeString(char *t, int bufsize, const char *s)
Definition: misc.c:10832
SCIPrelaxGetPriority
int SCIPrelaxGetPriority(SCIP_RELAX *relax)
Definition: relax.c:562
SCIPcheckSolOrig
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
Definition: scip_sol.c:3309
SCIPdialogDisplayMenu
SCIP_RETCODE SCIPdialogDisplayMenu(SCIP_DIALOG *dialog, SCIP *scip)
Definition: dialog.c:1072
SCIP_BRANCHDIR_FIXED
Definition: type_history.h:45
SCIPheurGetDesc
const char * SCIPheurGetDesc(SCIP_HEUR *heur)
Definition: heur.c:1463
SCIPvarGetName
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17420
SCIP_STAGE_FREETRANS
Definition: type_set.h:56
SCIPgetBoolParam
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip_param.c:250
SCIP_DISPSTATUS_OFF
Definition: type_disp.h:60
SCIPdispGetHeader
const char * SCIPdispGetHeader(SCIP_DISP *disp)
Definition: disp.c:355
SCIPprintOrigProblem
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_solvingstats.c:2375
SCIP_PARAMEMPHASIS_EASYCIP
Definition: type_paramset.h:73
SCIPpresolGetPriority
int SCIPpresolGetPriority(SCIP_PRESOL *presol)
Definition: presol.c:619
SCIPheurGetFreq
int SCIPheurGetFreq(SCIP_HEUR *heur)
Definition: heur.c:1538
SCIP_STAGE_INITSOLVE
Definition: type_set.h:52
SCIP_OKAY
Definition: type_retcode.h:42
parseBoolValue
static SCIP_Bool parseBoolValue(SCIP *scip, const char *valuestr, SCIP_Bool *error)
Definition: dialog_default.c:163
SCIP_STAGE_FREE
Definition: type_set.h:57
pub_sol.h
public methods for primal CIP solutions
SCIPrelaxGetName
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
Definition: relax.c:542
SCIPconshdlrGetPropFreq
int SCIPconshdlrGetPropFreq(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5142
SCIPsortPtr
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:380
SCIPprintStatus
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
Definition: scip_general.c:521
SCIPsetEmphasis
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: scip_param.c:882
SCIPsepaGetMaxbounddist
SCIP_Real SCIPsepaGetMaxbounddist(SCIP_SEPA *sepa)
Definition: sepa.c:808
SCIPlinConsStatsFree
void SCIPlinConsStatsFree(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
Definition: cons.c:8066
SCIP_PARAMTYPE_BOOL
Definition: type_paramset.h:47
SCIPrelaxGetFreq
int SCIPrelaxGetFreq(SCIP_RELAX *relax)
Definition: relax.c:586
SCIPisLongintParamValid
SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:560
SCIP_Heur
Definition: struct_heur.h:97
SCIP_Branchrule
Definition: struct_branch.h:78
SCIPsepaGetDesc
const char * SCIPsepaGetDesc(SCIP_SEPA *sepa)
Definition: sepa.c:753
BMSduplicateMemoryArray
#define BMSduplicateMemoryArray(ptr, source, num)
Definition: memory.h:143
SCIP_Prop
Definition: struct_prop.h:46
scip_heur.h
public methods for primal heuristic plugins and divesets
scip_cons.h
public methods for constraint handler plugins and constraints
pub_nodesel.h
public methods for node selectors
SCIPgetConflicthdlrs
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
Definition: scip_conflict.c:249
SCIP_UNKNOWN
#define SCIP_UNKNOWN
Definition: def.h:194
SCIPparamGetType
SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM *param)
Definition: paramset.c:649
SCIPbendersIsActive
SCIP_Bool SCIPbendersIsActive(SCIP_BENDERS *benders)
Definition: benders.c:2677
pub_misc.h
public data structures and miscellaneous methods
SCIPgetComprs
SCIP_COMPR ** SCIPgetComprs(SCIP *scip)
Definition: scip_compr.c:250
SCIP_PARAMTYPE_LONGINT
Definition: type_paramset.h:49
SCIPfreeTransform
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
Definition: scip_solve.c:3334
SCIPdispGetPosition
int SCIPdispGetPosition(SCIP_DISP *disp)
Definition: disp.c:385
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
scip_cutsel.h
public methods for cut selector plugins
SCIPgetObjlimit
SCIP_Real SCIPgetObjlimit(SCIP *scip)
Definition: scip_prob.c:1492
SCIPconflicthdlrGetPriority
int SCIPconflicthdlrGetPriority(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict_graphanalysis.c:1513
SCIPwriteTransProblem
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:648
SCIPprintSysError
void SCIPprintSysError(const char *message)
Definition: misc.c:10769
SCIP_Dialoghdlr
Definition: struct_dialog.h:70
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
SCIPprintBestTransSol
SCIP_RETCODE SCIPprintBestTransSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:2275
SCIPgetBenders
SCIP_BENDERS ** SCIPgetBenders(SCIP *scip)
Definition: scip_benders.c:508
paramname
static const char * paramname[]
Definition: lpi_msk.c:5096
SCIPsetObjlimit
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip_prob.c:1422
SCIPgetNPricers
int SCIPgetNPricers(SCIP *scip)
Definition: scip_pricer.c:337
SCIPsolGetAbsBoundViolation
SCIP_Real SCIPsolGetAbsBoundViolation(SCIP_SOL *sol)
Definition: sol.c:2613
SCIPvarGetBranchPriority
int SCIPvarGetBranchPriority(SCIP_VAR *var)
Definition: var.c:18251
SCIPdialogHasEntry
SCIP_Bool SCIPdialogHasEntry(SCIP_DIALOG *dialog, const char *entryname)
Definition: dialog.c:995
SCIP_PARAMEMPHASIS_FEASIBILITY
Definition: type_paramset.h:74
SCIPchgLongintParam
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:519
pub_pricer.h
public methods for variable pricers
SCIPrelaxGetDesc
const char * SCIPrelaxGetDesc(SCIP_RELAX *relax)
Definition: relax.c:552
SCIPpresolGetMaxrounds
int SCIPpresolGetMaxrounds(SCIP_PRESOL *presol)
Definition: presol.c:629
SCIPcutselGetDesc
const char * SCIPcutselGetDesc(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:245
SCIP_STAGE_PRESOLVING
Definition: type_set.h:49
SCIPpresolGetName
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
Definition: presol.c:599
SCIPnodeselGetName
const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1052
SCIPwriteCliqueGraph
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip_var.c:7712
SCIPfreeSol
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip_sol.c:841
SCIPvarGetObj
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17927
SCIP_STAGE_EXITPRESOLVE
Definition: type_set.h:50
SCIP_PARAMEMPHASIS_NUMERICS
Definition: type_paramset.h:81
SCIPprintDualSol
SCIP_RETCODE SCIPprintDualSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:2001
SCIPgetNSols
int SCIPgetNSols(SCIP *scip)
Definition: scip_sol.c:2070
SCIPbendersSubproblem
SCIP * SCIPbendersSubproblem(SCIP_BENDERS *benders, int probnumber)
Definition: benders.c:5980
SCIPcreateRootDialog
SCIP_RETCODE SCIPcreateRootDialog(SCIP *scip, SCIP_DIALOG **root)
Definition: dialog_default.c:4003
SCIPdialoghdlrGetWord
SCIP_RETCODE SCIPdialoghdlrGetWord(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *prompt, char **inputword, SCIP_Bool *endoffile)
Definition: dialog.c:546
SCIPpropGetDesc
const char * SCIPpropGetDesc(SCIP_PROP *prop)
Definition: prop.c:951
SCIPchgVarBranchPriority
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip_var.c:7982
SCIP_STAGE_SOLVED
Definition: type_set.h:54
SCIPchgFeastol
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
Definition: scip_numerics.c:253
SCIPreaderGetDesc
const char * SCIPreaderGetDesc(SCIP_READER *reader)
Definition: reader.c:567
SCIP_PARAMTYPE_STRING
Definition: type_paramset.h:52
cons_linear.h
Constraint handler for linear constraints in their most general form, .
SCIPparamGetBool
SCIP_Bool SCIPparamGetBool(SCIP_PARAM *param)
Definition: paramset.c:709
SCIPisRealParamValid
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:618
SCIPisInfinity
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:521
SCIP_STAGE_PRESOLVED
Definition: type_set.h:51
SCIPbendersGetPriority
int SCIPbendersGetPriority(SCIP_BENDERS *benders)
Definition: benders.c:5946
SCIPbendersGetNSubproblems
int SCIPbendersGetNSubproblems(SCIP_BENDERS *benders)
Definition: benders.c:5970
SCIPconshdlrGetEnfoPriority
int SCIPconshdlrGetEnfoPriority(SCIP_CONSHDLR *conshdlr)
Definition: cons.c:5112
SCIPclassifyConstraintTypesLinear
SCIP_RETCODE SCIPclassifyConstraintTypesLinear(SCIP *scip, SCIP_LINCONSSTATS *linconsstats)
Definition: cons_linear.c:15445
SCIPgetNBenders
int SCIPgetNBenders(SCIP *scip)
Definition: scip_benders.c:521
SCIPdialoghdlrAddHistory
SCIP_RETCODE SCIPdialoghdlrAddHistory(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *command, SCIP_Bool escapecommand)
Definition: dialog.c:726
SCIPparamGetIntMax
int SCIPparamGetIntMax(SCIP_PARAM *param)
Definition: paramset.c:759
SCIPpricerIsDelayed
SCIP_Bool SCIPpricerIsDelayed(SCIP_PRICER *pricer)
Definition: pricer.c:706
scip_lp.h
public methods for the LP relaxation, rows and columns
scip_pricer.h
public methods for variable pricer plugins
SCIPpropGetName
const char * SCIPpropGetName(SCIP_PROP *prop)
Definition: prop.c:941
SCIP_FILECREATEERROR
Definition: type_retcode.h:48
SCIPbranchruleGetMaxdepth
int SCIPbranchruleGetMaxdepth(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:2015
SCIPparamGetInt
int SCIPparamGetInt(SCIP_PARAM *param)
Definition: paramset.c:734
scip_nlp.h
public methods for nonlinear relaxation
SCIP_STAGE_INITPRESOLVE
Definition: type_set.h:48
r
SCIP_Real * r
Definition: circlepacking.c:59
SCIP_STAGE_PROBLEM
Definition: type_set.h:45
SCIPgetPresols
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip_presol.c:249
pub_misc_sort.h
methods for sorting joint arrays of various types
SCIP_BRANCHDIR_DOWNWARDS
Definition: type_history.h:43
SCIP_LONGINT_FORMAT
#define SCIP_LONGINT_FORMAT
Definition: def.h:165
scip_branch.h
public methods for branching rule plugins and branching
SCIPgetNHeurs
int SCIPgetNHeurs(SCIP *scip)
Definition: scip_heur.c:282
SCIPpropGetPresolPriority
int SCIPpropGetPresolPriority(SCIP_PROP *prop)
Definition: prop.c:971
SCIP_STAGE_INIT
Definition: type_set.h:44
pub_presol.h
public methods for presolvers
SCIPincludeDialogDefaultSet
SCIP_RETCODE SCIPincludeDialogDefaultSet(SCIP *scip)
Definition: dialog_default.c:5034
SCIPcomprGetName
const char * SCIPcomprGetName(SCIP_COMPR *compr)
Definition: compr.c:456
scip_general.h
general public methods
SCIPcreateNLPSol
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip_sol.c:254
SCIPdialoghdlrGetRoot
SCIP_DIALOG * SCIPdialoghdlrGetRoot(SCIP_DIALOGHDLR *dialoghdlr)
Definition: dialog.c:436
SCIP_DISPSTATUS_AUTO
Definition: type_disp.h:61
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
SCIPgetBestSol
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip_sol.c:2169
SCIPisGT
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:484
SCIPsolGetRelLPRowViolation
SCIP_Real SCIPsolGetRelLPRowViolation(SCIP_SOL *sol)
Definition: sol.c:2653
SCIP_BRANCHDIR_UPWARDS
Definition: type_history.h:44
scip_sol.h
public methods for solutions
SCIPprintMIPStart
SCIP_RETCODE SCIPprintMIPStart(SCIP *scip, SCIP_SOL *sol, FILE *file)
Definition: scip_sol.c:1770
SCIPexprhdlrGetPrecedence
unsigned int SCIPexprhdlrGetPrecedence(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:565
SCIPgetNNodesels
int SCIPgetNNodesels(SCIP *scip)
Definition: scip_nodesel.c:258
SCIPtransformObj
SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip_sol.c:1407
SCIPparamGetCharAllowedValues
char * SCIPparamGetCharAllowedValues(SCIP_PARAM *param)
Definition: paramset.c:889
SCIPgetNReaders
int SCIPgetNReaders(SCIP *scip)
Definition: scip_reader.c:259
SCIP_PARAMEMPHASIS_COUNTER
Definition: type_paramset.h:77
SCIP_PARAMTYPE_CHAR
Definition: type_paramset.h:51
SCIPgetNBranchrules
int SCIPgetNBranchrules(SCIP *scip)
Definition: scip_branch.c:323
pub_conflict.h
public methods for conflict analysis handlers
SCIPdialoghdlrIsBufferEmpty
SCIP_Bool SCIPdialoghdlrIsBufferEmpty(SCIP_DIALOGHDLR *dialoghdlr)
Definition: dialog.c:457
SCIP_Disp
Definition: struct_disp.h:45
SCIPgetBranchrules
SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)
Definition: scip_branch.c:312
pub_compr.h
public methods for tree compressions
SCIPreleaseCons
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1174
SCIPreadParams
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
Definition: scip_param.c:772
SCIPconflicthdlrGetName
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
Definition: conflict_graphanalysis.c:1493
pub_message.h
public methods for message output
SCIP_DECL_DIALOGEXEC
SCIP_DECL_DIALOGEXEC(SCIPdialogExecMenu)
Definition: dialog_default.c:346
SCIPcutselGetPriority
int SCIPcutselGetPriority(SCIP_CUTSEL *cutsel)
Definition: cutsel.c:440
SCIPmessageFPrintInfo
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
Definition: message.c:618
SCIPparamGetLongintMax
SCIP_Longint SCIPparamGetLongintMax(SCIP_PARAM *param)
Definition: paramset.c:806
SCIPparamGetDesc
const char * SCIPparamGetDesc(SCIP_PARAM *param)
Definition: paramset.c:669
SCIPvarGetStatus
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
Definition: var.c:17539
dialog_default.h
default user interface dialog
SCIPsepaIsDelayed
SCIP_Bool SCIPsepaIsDelayed(SCIP_SEPA *sepa)
Definition: sepa.c:1089
SCIP_Real
#define SCIP_Real
Definition: def.h:173
SCIPbranchruleGetName
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1971
SCIPpricerGetDesc
const char * SCIPpricerGetDesc(SCIP_PRICER *pricer)
Definition: pricer.c:610
pub_relax.h
public methods for relaxation handlers
SCIPsolveParallel
SCIP_RETCODE SCIPsolveParallel(SCIP *scip)
Definition: scip_solve.c:2820
SCIPchgVarBranchDirection
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip_var.c:8087
pub_reader.h
public methods for input file readers
SCIPheurGetDispchar
char SCIPheurGetDispchar(SCIP_HEUR *heur)
Definition: heur.c:1473
SCIPparamGetIntMin
int SCIPparamGetIntMin(SCIP_PARAM *param)
Definition: paramset.c:748
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
scip_message.h
public methods for message handling
SCIP_INVALID
#define SCIP_INVALID
Definition: def.h:193
scip_dialog.h
public methods for dialog handler plugins
SCIPgetNCompr
int SCIPgetNCompr(SCIP *scip)
Definition: scip_compr.c:263
SCIP_Longint
#define SCIP_Longint
Definition: def.h:158
SCIP_PLUGINNOTFOUND
Definition: type_retcode.h:54
scip_prop.h
public methods for propagator plugins
SCIP_STAGE_SOLVING
Definition: type_set.h:53
SCIPdialoghdlrGetLine
SCIP_RETCODE SCIPdialoghdlrGetLine(SCIP_DIALOGHDLR *dialoghdlr, SCIP_DIALOG *dialog, const char *prompt, char **inputline, SCIP_Bool *endoffile)
Definition: dialog.c:470
SCIPreleaseDialog
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
Definition: scip_dialog.c:124
SCIP_Relax
Definition: struct_relax.h:46
displayReaders
static void displayReaders(SCIP *scip, SCIP_Bool reader, SCIP_Bool writer)
Definition: dialog_default.c:200
SCIPpropGetFreq
int SCIPpropGetFreq(SCIP_PROP *prop)
Definition: prop.c:1009
SCIPtransformProb
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
Definition: scip_solve.c:222
SCIPgetSepas
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip_sepa.c:260
SCIPparamGetRealMin
SCIP_Real SCIPparamGetRealMin(SCIP_PARAM *param)
Definition: paramset.c:842
SCIPexprhdlrGetDescription
const char * SCIPexprhdlrGetDescription(SCIP_EXPRHDLR *exprhdlr)
Definition: expr.c:555
SCIP_WRITEERROR
Definition: type_retcode.h:46
SCIPwriteParams
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip_param.c:813
pub_sepa.h
public methods for separators
SCIPgetDisps
SCIP_DISP ** SCIPgetDisps(SCIP *scip)
Definition: scip_disp.c:110
pub_heur.h
public methods for primal heuristics
SCIPgetNSepas
int SCIPgetNSepas(SCIP *scip)
Definition: scip_sepa.c:273
SCIP_Cutsel
Definition: struct_cutsel.h:46
SCIPlinConsStatsCreate
SCIP_RETCODE SCIPlinConsStatsCreate(SCIP *scip, SCIP_LINCONSSTATS **linconsstats)
Definition: cons.c:8053
SCIP_OBJSENSE_MINIMIZE
Definition: type_prob.h:48
SCIP_PARAMSETTING_FAST
Definition: type_paramset.h:62
createEmphasisSubmenu
static SCIP_RETCODE createEmphasisSubmenu(SCIP *scip, SCIP_DIALOG *root, SCIP_DIALOG **submenu)
Definition: dialog_default.c:5007
SCIPdialogGetData
SCIP_DIALOGDATA * SCIPdialogGetData(SCIP_DIALOG *dialog)
Definition: dialog.c:1253
SCIP_INVALIDDATA
Definition: type_retcode.h:52
SCIPparamGetLongintMin
SCIP_Longint SCIPparamGetLongintMin(SCIP_PARAM *param)
Definition: paramset.c:795
SCIPparamIsAdvanced
SCIP_Bool SCIPparamIsAdvanced(SCIP_PARAM *param)
Definition: paramset.c:689
SCIPfreeSolve
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
Definition: scip_solve.c:3204
SCIPchgIntParam
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:461
SCIP_ALLOC
#define SCIP_ALLOC(x)
Definition: def.h:391
scip_reader.h
public methods for reader plugins
pub_cutsel.h
public methods for cut selectors
SCIPsetRootDialog
SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip_dialog.c:141
SCIPdispGetName
const char * SCIPdispGetName(SCIP_DISP *disp)
Definition: disp.c:335
scip_prob.h
public methods for global and local (sub)problems
SCIP_PARAMEMPHASIS_HARDLP
Definition: type_paramset.h:75
SCIPnodeselGetStdPriority
int SCIPnodeselGetStdPriority(SCIP_NODESEL *nodesel)
Definition: nodesel.c:1072
SCIP_VARSTATUS_FIXED
Definition: type_var.h:52
SCIPreaderGetExtension
const char * SCIPreaderGetExtension(SCIP_READER *reader)
Definition: reader.c:577
SCIPgetNParams
int SCIPgetNParams(SCIP *scip)
Definition: scip_param.c:1013
SCIPgetSolVal
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip_sol.c:1217
SCIP_STAGE_TRANSFORMED
Definition: type_set.h:47
pub_dialog.h
public methods for user interface dialog
SCIPchgBoolParam
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:403
SCIPgetNProps
int SCIPgetNProps(SCIP *scip)
Definition: scip_prop.c:355
scip_disp.h
public methods for display handler plugins
SCIPsepaGetPriority
int SCIPsepaGetPriority(SCIP_SEPA *sepa)
Definition: sepa.c:763
SCIPparamGetRealMax
SCIP_Real SCIPparamGetRealMax(SCIP_PARAM *param)
Definition: paramset.c:853
SCIP_PARAMSETTING_AGGRESSIVE
Definition: type_paramset.h:61
SCIPsolGetAbsLPRowViolation
SCIP_Real SCIPsolGetAbsLPRowViolation(SCIP_SOL *sol)
Definition: sol.c:2643
SCIPparamSetFixed
void SCIPparamSetFixed(SCIP_PARAM *param, SCIP_Bool fixed)
Definition: paramset.c:4435
SCIPpresolGetTiming
SCIP_PRESOLTIMING SCIPpresolGetTiming(SCIP_PRESOL *presol)
Definition: presol.c:653
pub_prop.h
public methods for propagators
SCIPcreateFiniteSolCopy
SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
Definition: scip_sol.c:705
SCIPbranchruleGetPriority
int SCIPbranchruleGetPriority(SCIP_BRANCHRULE *branchrule)
Definition: branch.c:1991
SCIPgetPricers
SCIP_PRICER ** SCIPgetPricers(SCIP *scip)
Definition: scip_pricer.c:324
memory.h
memory allocation routines
SCIP_PARAMTYPE_REAL
Definition: type_paramset.h:50
SCIP_Nlpi
Definition: struct_nlpi.h:46
SCIPprintSol
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip_sol.c:1631