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