/** branching execution method for fractional LP solutions */
static
SCIP_DECL_BRANCHEXECLP(branchExeclpnodereopt)
{/*lint --e{715}*/
assert(branchrule != NULL );
assert(*result != SCIP_BRANCHED);
*result = SCIP_DIDNOTRUN;
if( SCIPisReoptEnabled(scip) && SCIPreoptimizeNode(scip, SCIPgetCurrentNode(scip)) )
{
SCIP_VAR** branchcands;
SCIP_Real* branchcandssol;
SCIP_Real* branchcandsfrac;
int nbranchcands;
SCIP_Bool sbinit;
SCIP_Real objsimrootlp;
SCIP_CALL( SCIPgetBoolParam(scip, "reoptimization/strongbranchinginit", &sbinit) );
SCIP_CALL( SCIPgetRealParam(scip, "reoptimization/objsimrootLP", &objsimrootlp) );
if( sbinit && SCIPgetCurrentNode(scip) == SCIPgetRootNode(scip)
&& SCIPgetReoptSimilarity(scip, SCIPgetNReoptRuns(scip), SCIPgetNReoptRuns(scip)) <= objsimrootlp ) /* check objsimrootlp */
{
/* get branching candidates */
SCIP_CALL( SCIPgetLPBranchCands(scip, &branchcands, &branchcandssol, &branchcandsfrac, NULL, &nbranchcands, NULL) );
/* run strong branching initialization */
if( nbranchcands > 0 )
{
SCIP_CALL( SCIPexecRelpscostBranching(scip, TRUE, branchcands, branchcandssol, branchcandsfrac, nbranchcands, FALSE, result) );
assert(*result == SCIP_DIDNOTRUN || *result == SCIP_CUTOFF || *result == SCIP_REDUCEDDOM);
}
}
if( *result != SCIP_CUTOFF && *result != SCIP_REDUCEDDOM)
{
assert((SCIPnodeGetReoptID(SCIPgetCurrentNode(scip)) == 0 && SCIPnodeGetDepth(SCIPgetCurrentNode(scip)) == 0 )
|| 1 <= SCIPnodeGetReoptID(SCIPgetCurrentNode(scip)));
SCIP_CALL( Exec(scip, result) );
}
}
return SCIP_OKAY;
}
/* Read SAT formula in "CNF File Format".
*
* The specification is taken from the
*
* Satisfiability Suggested Format
*
* Online available at http://www.intellektik.informatik.tu-darmstadt.de/SATLIB/Benchmarks/SAT/satformat.ps
*
* The method reads all files of CNF format. Other formats (SAT, SATX, SATE) are not supported.
*/
static
SCIP_RETCODE readCnf(
SCIP* scip, /**< SCIP data structure */
SCIP_FILE* file /**< input file */
)
{
SCIP_RETCODE retcode;
SCIP_VAR** vars;
SCIP_VAR** clausevars;
SCIP_CONS* cons;
int* varsign;
char* tok;
char* nexttok;
char line[MAXLINELEN];
char format[SCIP_MAXSTRLEN];
char varname[SCIP_MAXSTRLEN];
char s[SCIP_MAXSTRLEN];
SCIP_Bool dynamicconss;
SCIP_Bool dynamiccols;
SCIP_Bool dynamicrows;
SCIP_Bool useobj;
int linecount;
int clauselen;
int clausenum;
int nvars;
int nclauses;
int varnum;
int v;
assert(scip != NULL);
assert(file != NULL);
retcode = SCIP_OKAY;
linecount = 0;
/* read header */
SCIP_CALL( readCnfLine(scip, file, line, (int) sizeof(line), &linecount) );
if( *line != 'p' )
{
readError(scip, linecount, "problem declaration line expected");
return SCIP_READERROR;
}
if( sscanf(line, "p %8s %d %d", format, &nvars, &nclauses) != 3 )
{
readError(scip, linecount, "invalid problem declaration (must be 'p cnf <nvars> <nclauses>')");
return SCIP_READERROR;
}
if( strcmp(format, "cnf") != 0 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid format tag <%s> (must be 'cnf')", format);
readError(scip, linecount, s);
return SCIP_READERROR;
}
if( nvars <= 0 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid number of variables <%d> (must be positive)", nvars);
readError(scip, linecount, s);
return SCIP_READERROR;
}
if( nclauses <= 0 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid number of clauses <%d> (must be positive)", nclauses);
readError(scip, linecount, s);
return SCIP_READERROR;
}
/* get parameter values */
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/dynamicconss", &dynamicconss) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/dynamiccols", &dynamiccols) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/dynamicrows", &dynamicrows) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/cnfreader/useobj", &useobj) );
/* get temporary memory */
SCIP_CALL( SCIPallocBufferArray(scip, &vars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &clausevars, nvars) );
SCIP_CALL( SCIPallocBufferArray(scip, &varsign, nvars) );
/* create the variables */
for( v = 0; v < nvars; ++v )
{
(void) SCIPsnprintf(varname, SCIP_MAXSTRLEN, "x%d", v+1);
SCIP_CALL( SCIPcreateVar(scip, &vars[v], varname, 0.0, 1.0, 0.0, SCIP_VARTYPE_BINARY, !dynamiccols, dynamiccols,
NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, vars[v]) );
varsign[v] = 0;
}
/* read clauses */
clausenum = 0;
clauselen = 0;
do
{
retcode = readCnfLine(scip, file, line, (int) sizeof(line), &linecount);
if( retcode != SCIP_OKAY )
goto TERMINATE;
if( *line != '\0' && *line != '%' )
{
tok = SCIPstrtok(line, " \f\n\r\t", &nexttok);
while( tok != NULL )
{
/* parse literal and check for errors */
if( sscanf(tok, "%d", &v) != 1 )
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid literal <%s>", tok);
readError(scip, linecount, s);
retcode = SCIP_READERROR;
goto TERMINATE;
}
/* interpret literal number: v == 0: end of clause, v < 0: negated literal, v > 0: positive literal */
if( v == 0 )
{
/* end of clause: construct clause and add it to SCIP */
if( clauselen == 0 )
readWarning(scip, linecount, "empty clause detected in line -- problem infeasible");
clausenum++;
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "c%d", clausenum);
if( SCIPfindConshdlr(scip, "logicor") != NULL )
{
/* if the constraint handler logicor exit create a logicor constraint */
SCIP_CALL( SCIPcreateConsLogicor(scip, &cons, s, clauselen, clausevars,
!dynamicrows, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, dynamicconss, dynamicrows, FALSE) );
}
else if( SCIPfindConshdlr(scip, "setppc") != NULL )
{
/* if the constraint handler logicor does not exit but constraint
* handler setppc create a setppc constraint */
SCIP_CALL( SCIPcreateConsSetcover(scip, &cons, s, clauselen, clausevars,
!dynamicrows, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, dynamicconss, dynamicrows, FALSE) );
}
else
{
/* if none of the previous constraint handler exits create a linear
* constraint */
SCIP_Real* vals;
int i;
SCIP_CALL( SCIPallocBufferArray(scip, &vals, clauselen) );
for( i = 0; i < clauselen; ++i )
vals[i] = 1.0;
SCIP_CALL( SCIPcreateConsLinear(scip, &cons, s, clauselen, clausevars, vals, 1.0, SCIPinfinity(scip),
!dynamicrows, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, dynamicconss, dynamicrows, FALSE) );
SCIPfreeBufferArray(scip, &vals);
}
SCIP_CALL( SCIPaddCons(scip, cons) );
SCIP_CALL( SCIPreleaseCons(scip, &cons) );
clauselen = 0;
}
else if( v >= -nvars && v <= nvars )
{
if( clauselen >= nvars )
{
readError(scip, linecount, "too many literals in clause");
retcode = SCIP_READERROR;
goto TERMINATE;
}
/* add literal to clause */
varnum = ABS(v)-1;
if( v < 0 )
{
SCIP_CALL( SCIPgetNegatedVar(scip, vars[varnum], &clausevars[clauselen]) );
varsign[varnum]--;
}
else
{
clausevars[clauselen] = vars[varnum];
varsign[varnum]++;
}
clauselen++;
}
else
{
(void) SCIPsnprintf(s, SCIP_MAXSTRLEN, "invalid variable number <%d>", ABS(v));
readError(scip, linecount, s);
retcode = SCIP_READERROR;
goto TERMINATE;
}
/* get next token */
tok = SCIPstrtok(NULL, " \f\n\r\t", &nexttok);
}
}
}
while( *line != '\0' && *line != '%' );
/* check for additional literals */
if( clauselen > 0 )
{
SCIPwarningMessage(scip, "found %d additional literals after last clause\n", clauselen);
}
/* check number of clauses */
if( clausenum != nclauses )
{
SCIPwarningMessage(scip, "expected %d clauses, but found %d\n", nclauses, clausenum);
}
TERMINATE:
/* change objective values and release variables */
SCIP_CALL( SCIPsetObjsense(scip, SCIP_OBJSENSE_MAXIMIZE) );
if( useobj )
{
for( v = 0; v < nvars; ++v )
{
SCIP_CALL( SCIPchgVarObj(scip, vars[v], (SCIP_Real)varsign[v]) );
SCIP_CALL( SCIPreleaseVar(scip, &vars[v]) );
}
}
/* free temporary memory */
SCIPfreeBufferArray(scip, &varsign);
SCIPfreeBufferArray(scip, &clausevars);
SCIPfreeBufferArray(scip, &vars);
return retcode;
}
int GamsScip::callSolver()
{
assert(gmo != NULL);
assert(gev != NULL);
assert(scip != NULL);
/* set interface type so we see =B= and =X= equations */
gmoInterfaceSet(gmo, gmoIFace_Raw);
if( gmoGetEquTypeCnt(gmo, gmoequ_C) || gmoGetEquTypeCnt(gmo, gmoequ_B) || gmoGetEquTypeCnt(gmo, gmoequ_X) )
{
gevLogStat(gev, "ERROR: Conic and logic constraints and external functions not supported by SCIP interface.\n");
gmoSolveStatSet(gmo, gmoSolveStat_Capability);
gmoModelStatSet(gmo, gmoModelStat_NoSolutionReturned);
return 1;
}
// set number of threads for linear algebra routines used in Ipopt
setNumThreads(gev, gevThreads(gev));
// update error printing callback in SCIP to use current gev
SCIPmessageSetErrorPrinting(printErrorGev, (void*)gev);
SCIP_RETCODE scipret;
// let GMO reader setup SCIP parameters and read options file
// do this here already so we know how to assemble dialog
scipret = SCIPreadParamsReaderGmo(scip);
if( scipret != SCIP_OKAY )
{
char buffer[256];
sprintf(buffer, "Error %d in call of SCIP function\n", scipret);
gevLogStatPChar(gev, buffer);
gmoSolveStatSet(gmo, gmoSolveStat_SystemErr);
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
return 1;
}
SCIPinfoMessage(scip, NULL, "non-default parameter settings:\n");
SCIPwriteParams(scip, NULL, FALSE, TRUE);
char* interactive = NULL;
SCIP_CALL_ABORT( SCIPgetStringParam(scip, "gams/interactive", &interactive) );
assert(interactive != NULL);
#ifdef GAMS_BUILD
if( interactive[0] != '\0' && !palLicenseIsAcademic(pal) )
{
gevLogStat(gev, "SCIP interactive shell not available in demo mode.\n");
interactive[0] = '\0';
}
#endif
SCIP_Bool printstat;
SCIP_CALL_ABORT( SCIPgetBoolParam(scip, "display/statistics", &printstat) );
char* attrfile = NULL;
#if 0
SCIP_CALL( SCIPgetStringParam(scip, "constraints/attrfile", &attrfile) );
#endif
// setup commands to be executed by SCIP
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "readgams") ); // setup model
if( attrfile != NULL && *attrfile != '\0' )
{
char buffer[SCIP_MAXSTRLEN + 10];
size_t len;
len = strlen(attrfile);
if( len >= 3 && strcmp(&attrfile[len-3], ".ca") == 0 )
(void) SCIPsnprintf(buffer, sizeof(buffer), "read %g", attrfile);
else
(void) SCIPsnprintf(buffer, sizeof(buffer), "read %g ca", attrfile);
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, buffer) ); // process constraints attribute file
}
if( interactive[0] == '\0' )
{
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "optimize") ); // solve model
if( printstat )
{
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "disp statistics") ); // display solution statistics
}
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "write gamssol") ); // pass solution to GMO
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, "quit") ); // quit shell
}
else
{
// pass user commands to shell
SCIP_CALL_ABORT( SCIPaddDialogInputLine(scip, interactive) );
}
// run SCIP
scipret = SCIPstartInteraction(scip);
// evaluate SCIP return code
switch( scipret )
{
case SCIP_OKAY:
break;
case SCIP_READERROR:
/* if it's readerror, then we guess that it comes from encountering an unsupported gams instruction in the gmo readers makeExprtree method
* we still return with zero then
*/
gmoModelStatSet(gmo, gmoModelStat_NoSolutionReturned);
gmoSolveStatSet(gmo, gmoSolveStat_Capability);
break;
case SCIP_LPERROR:
case SCIP_MAXDEPTHLEVEL:
/* if SCIP failed due to internal error (forced LP solve failed, max depth level reached), also return zero */
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
gmoSolveStatSet(gmo, gmoSolveStat_SolverErr);
break;
case SCIP_NOMEMORY:
/* there is no extra solver status for running out of memory, but memory is a resource, so return this */
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
gmoSolveStatSet(gmo, gmoSolveStat_Resource);
break;
default:
{
char buffer[256];
sprintf(buffer, "Error %d in call of SCIP function\n", scipret);
gevLogStatPChar(gev, buffer);
gmoModelStatSet(gmo, gmoModelStat_ErrorNoSolution);
gmoSolveStatSet(gmo, gmoSolveStat_SystemErr);
return 1;
}
}
return 0;
}
/** problem reading method of reader */
static
SCIP_DECL_READERREAD(readerReadCip)
{ /*lint --e{715}*/
CIPINPUT cipinput;
SCIP_Real objscale;
SCIP_Real objoffset;
SCIP_Bool initialconss;
SCIP_Bool dynamicconss;
SCIP_Bool dynamiccols;
SCIP_Bool dynamicrows;
SCIP_Bool initialvar;
SCIP_Bool removablevar;
SCIP_RETCODE retcode;
if( NULL == (cipinput.file = SCIPfopen(filename, "r")) )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
SCIPprintSysError(filename);
return SCIP_NOFILE;
}
cipinput.len = 131071;
SCIP_CALL( SCIPallocBufferArray(scip, &(cipinput.strbuf), cipinput.len) );
cipinput.linenumber = 0;
cipinput.section = CIP_START;
cipinput.haserror = FALSE;
cipinput.endfile = FALSE;
cipinput.readingsize = 65535;
SCIP_CALL( SCIPcreateProb(scip, filename, NULL, NULL, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/initialconss", &initialconss) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamiccols", &dynamiccols) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamicconss", &dynamicconss) );
SCIP_CALL( SCIPgetBoolParam(scip, "reading/dynamicrows", &dynamicrows) );
initialvar = !dynamiccols;
removablevar = dynamiccols;
objscale = 1.0;
objoffset = 0.0;
while( cipinput.section != CIP_END && !cipinput.haserror )
{
/* get next input string */
SCIP_CALL( getInputString(scip, &cipinput) );
if( cipinput.endfile )
break;
switch( cipinput.section )
{
case CIP_START:
getStart(scip, &cipinput);
break;
case CIP_STATISTIC:
SCIP_CALL( getStatistics(scip, &cipinput) );
break;
case CIP_OBJECTIVE:
SCIP_CALL( getObjective(scip, &cipinput, &objscale, &objoffset) );
break;
case CIP_VARS:
retcode = getVariable(scip, &cipinput, initialvar, removablevar, objscale);
if( retcode == SCIP_READERROR )
{
cipinput.haserror = TRUE;
goto TERMINATE;
}
SCIP_CALL(retcode);
break;
case CIP_FIXEDVARS:
retcode = getFixedVariable(scip, &cipinput);
if( retcode == SCIP_READERROR )
{
cipinput.haserror = TRUE;
goto TERMINATE;
}
SCIP_CALL(retcode);
break;
case CIP_CONSTRAINTS:
retcode = getConstraint(scip, &cipinput, initialconss, dynamicconss, dynamicrows);
if( retcode == SCIP_READERROR )
{
cipinput.haserror = TRUE;
goto TERMINATE;
}
SCIP_CALL(retcode);
break;
default:
SCIPerrorMessage("invalid CIP state\n");
SCIPABORT();
return SCIP_INVALIDDATA; /*lint !e527*/
} /*lint !e788*/
}
if( !SCIPisZero(scip, objoffset) && !cipinput.haserror )
{
SCIP_VAR* objoffsetvar;
objoffset *= objscale;
SCIP_CALL( SCIPcreateVar(scip, &objoffsetvar, "objoffset", objoffset, objoffset, 1.0, SCIP_VARTYPE_CONTINUOUS,
TRUE, TRUE, NULL, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPaddVar(scip, objoffsetvar) );
SCIP_CALL( SCIPreleaseVar(scip, &objoffsetvar) );
SCIPdebugMessage("added variables <objoffset> for objective offset of <%g>\n", objoffset);
}
if( cipinput.section != CIP_END && !cipinput.haserror )
{
SCIPerrorMessage("unexpected EOF\n");
}
TERMINATE:
/* close file stream */
SCIPfclose(cipinput.file);
SCIPfreeBufferArray(scip, &cipinput.strbuf);
if( cipinput.haserror )
return SCIP_READERROR;
/* successfully parsed cip format */
*result = SCIP_SUCCESS;
return SCIP_OKAY;
}
/** reads a given SCIP solution file, problem has to be transformed in advance */
static
SCIP_RETCODE readSol(
SCIP* scip, /**< SCIP data structure */
const char* fname /**< name of the input file */
)
{
SCIP_SOL* sol;
SCIP_FILE* file;
SCIP_Bool error;
SCIP_Bool unknownvariablemessage;
SCIP_Bool stored;
SCIP_Bool usevartable;
int lineno;
assert(scip != NULL);
assert(fname != NULL);
SCIP_CALL( SCIPgetBoolParam(scip, "misc/usevartable", &usevartable) );
if( !usevartable )
{
SCIPerrorMessage("Cannot read solution file if vartable is disabled. Make sure parameter 'misc/usevartable' is set to TRUE.\n");
return SCIP_READERROR;
}
/* open input file */
file = SCIPfopen(fname, "r");
if( file == NULL )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", fname);
SCIPprintSysError(fname);
return SCIP_NOFILE;
}
/* create zero solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, NULL) );
/* read the file */
error = FALSE;
unknownvariablemessage = FALSE;
lineno = 0;
while( !SCIPfeof(file) && !error )
{
char buffer[SCIP_MAXSTRLEN];
char varname[SCIP_MAXSTRLEN];
char valuestring[SCIP_MAXSTRLEN];
char objstring[SCIP_MAXSTRLEN];
SCIP_VAR* var;
SCIP_Real value;
int nread;
/* get next line */
if( SCIPfgets(buffer, (int) sizeof(buffer), file) == NULL )
break;
lineno++;
/* there are some lines which may preceed the solution information */
if( strncasecmp(buffer, "solution status:", 16) == 0 || strncasecmp(buffer, "objective value:", 16) == 0 ||
strncasecmp(buffer, "Log started", 11) == 0 || strncasecmp(buffer, "Variable Name", 13) == 0 ||
strncasecmp(buffer, "All other variables", 19) == 0 || strncasecmp(buffer, "\n", 1) == 0 ||
strncasecmp(buffer, "NAME", 4) == 0 || strncasecmp(buffer, "ENDATA", 6) == 0 ) /* allow parsing of SOL-format on the MIPLIB 2003 pages */
continue;
/* parse the line */
nread = sscanf(buffer, "%s %s %s\n", varname, valuestring, objstring);
if( nread < 2 )
{
SCIPerrorMessage("Invalid input line %d in solution file <%s>: <%s>.\n", lineno, fname, buffer);
error = TRUE;
break;
}
/* find the variable */
var = SCIPfindVar(scip, varname);
if( var == NULL )
{
if( !unknownvariablemessage )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "unknown variable <%s> in line %d of solution file <%s>\n",
varname, lineno, fname);
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, " (further unknown variables are ignored)\n");
unknownvariablemessage = TRUE;
}
continue;
}
/* cast the value */
if( strncasecmp(valuestring, "inv", 3) == 0 )
continue;
else if( strncasecmp(valuestring, "+inf", 4) == 0 || strncasecmp(valuestring, "inf", 3) == 0 )
value = SCIPinfinity(scip);
else if( strncasecmp(valuestring, "-inf", 4) == 0 )
value = -SCIPinfinity(scip);
else
{
nread = sscanf(valuestring, "%lf", &value);
if( nread != 1 )
{
SCIPerrorMessage("Invalid solution value <%s> for variable <%s> in line %d of solution file <%s>.\n",
valuestring, varname, lineno, fname);
error = TRUE;
break;
}
}
/* set the solution value of the variable, if not multiaggregated */
if( SCIPisTransformed(scip) && SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_MULTAGGR )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored solution value for multiaggregated variable <%s>\n", SCIPvarGetName(var));
}
else
{
SCIP_RETCODE retcode;
retcode = SCIPsetSolVal(scip, sol, var, value);
if( retcode == SCIP_INVALIDDATA )
{
if( SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_FIXED )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored conflicting solution value for fixed variable <%s>\n",
SCIPvarGetName(var));
}
else
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "ignored solution value for multiaggregated variable <%s>\n",
SCIPvarGetName(var));
}
}
else
{
SCIP_CALL( retcode );
}
}
}
/* close input file */
SCIPfclose(file);
if( !error )
{
/* add and free the solution */
if( SCIPisTransformed(scip) )
{
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, TRUE, TRUE, TRUE, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
fname, stored ? "accepted" : "rejected - solution is infeasible or objective too poor");
}
else
{
/* add primal solution to solution candidate storage, frees the solution afterwards */
SCIP_CALL( SCIPaddSolFree(scip, &sol, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
fname, stored ? "accepted as candidate, will be checked when solving starts" : "rejected - solution objective too poor");
}
return SCIP_OKAY;
}
else
{
/* free solution */
SCIP_CALL( SCIPfreeSol(scip, &sol) );
return SCIP_READERROR;
}
}
static
SCIP_RETCODE run(
const char* nlfile, /**< name of AMPL .nl file */
const char* setfile, /**< SCIP settings file, or NULL to try default scip.set */
SCIP_Bool interactive /**< whether to start SCIP interactive shell instead of solving command */
)
{
SCIP* scip;
char buffer[SCIP_MAXSTRLEN];
SCIP_Bool printstat;
assert(nlfile != NULL);
/* setup SCIP and print version information */
SCIP_CALL( SCIPcreate(&scip) );
SCIPprintVersion(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
SCIP_CALL( SCIPincludeDefaultPlugins(scip) );
SCIP_CALL( SCIPincludeReaderNl(scip) );
SCIP_CALL( SCIPaddBoolParam(scip, "display/statistics",
"whether to print statistics on a solve",
NULL, FALSE, FALSE, NULL, NULL) );
SCIPprintExternalCodes(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
/* read setting file */
if( setfile != NULL )
{
SCIP_CALL( SCIPreadParams(scip, setfile) );
}
SCIP_CALL( SCIPgetBoolParam(scip, "display/statistics", &printstat) );
/* setup commands to be executed by SCIP */
SCIP_CALL( SCIPaddDialogInputLine(scip, "display param") );
/* add .nl extension, if not given */
(void) SCIPsnprintf(buffer, SCIP_MAXSTRLEN, "read %s%s", nlfile, (strlen(nlfile) < 3 || strcmp(nlfile+(strlen(nlfile)-3), ".nl") != 0) ? ".nl" : "");
SCIP_CALL( SCIPaddDialogInputLine(scip, buffer) );
if( !interactive )
{
/* SCIP_CALL( SCIPaddDialogInputLine(scip, "display problem") ); */
SCIP_CALL( SCIPaddDialogInputLine(scip, "optimize") );
SCIP_CALL( SCIPaddDialogInputLine(scip, "write amplsol") );
if( printstat )
{
SCIP_CALL( SCIPaddDialogInputLine(scip, "display statistics") );
}
SCIP_CALL( SCIPaddDialogInputLine(scip, "quit") );
}
/* run SCIP */
SCIP_CALL( SCIPstartInteraction(scip) );
SCIP_CALL( SCIPfree(&scip) );
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecReoptsols)
{/*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL** sols;
SCIP_Real objsimsol;
SCIP_Bool sepabestsol;
int allocmem;
int nchecksols;
int nsolsadded;
#ifdef SCIP_MORE_DEBUG
int nsolsaddedrun;
#endif
int run;
int max_run;
assert(heur != NULL);
assert(scip != NULL);
*result = SCIP_DIDNOTRUN;
if( !SCIPisReoptEnabled(scip) )
return SCIP_OKAY;
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
max_run = heurdata->maxruns == -1 ? 0 : MAX(0, SCIPgetNReoptRuns(scip)-1-heurdata->maxruns); /*lint !e666*/
nchecksols = heurdata->maxsols == -1 ? INT_MAX : heurdata->maxsols;
SCIP_CALL( SCIPgetRealParam(scip, "reoptimization/objsimsol", &objsimsol) );
SCIP_CALL( SCIPgetBoolParam(scip, "reoptimization/sepabestsol", &sepabestsol) );
/* allocate a buffer array to store the solutions */
allocmem = 20;
SCIP_CALL( SCIPallocBufferArray(scip, &sols, allocmem) );
nsolsadded = 0;
for( run = SCIPgetNReoptRuns(scip); run > max_run && nchecksols > 0; run-- )
{
SCIP_Real sim;
int nsols;
#ifdef SCIP_MORE_DEBUG
nsolsaddedrun = 0;
#endif
nsols = 0;
if( objsimsol == -1 )
sim = 1;
else
sim = SCIPgetReoptSimilarity(scip, run, SCIPgetNReoptRuns(scip)-1);
if( sim >= objsimsol )
{
int s;
/* get solutions of a specific run */
SCIP_CALL( SCIPgetReopSolsRun(scip, run, sols, allocmem, &nsols) );
/* check memory and reallocate */
if( nsols > allocmem )
{
allocmem = nsols;
SCIP_CALL( SCIPreallocBufferArray(scip, &sols, allocmem) );
SCIP_CALL( SCIPgetReopSolsRun(scip, run, sols, allocmem, &nsols) );
}
assert(nsols <= allocmem);
/* update the solutions
* stop, if the maximal number of solutions to be checked is reached
*/
for( s = 0; s < nsols && nchecksols > 0; s++ )
{
SCIP_SOL* sol;
SCIP_Real objsol;
sol = sols[s];
SCIP_CALL( SCIPrecomputeSolObj(scip, sol) );
objsol = SCIPgetSolTransObj(scip, sol);
/* we do not want to add solutions with objective value +infinity.
* moreover, the solution should improve the current primal bound
*/
if( !SCIPisInfinity(scip, objsol) && !SCIPisInfinity(scip, -objsol)
&& SCIPisFeasLT(scip, objsol, SCIPgetCutoffbound(scip)) )
{
SCIP_Bool stored;
SCIP_Bool feasible;
if( sepabestsol )
{
SCIP_CALL( SCIPcheckSolOrig(scip, sol, &feasible, FALSE, TRUE) );
}
else
feasible = TRUE;
if( feasible)
{
/* create a new solution */
SCIP_CALL( createNewSol(scip, heur, sol, &stored) );
if( stored )
{
nsolsadded++;
#ifdef SCIP_MORE_DEBUG
nsolsaddedrun++;
#endif
heurdata->nimprovingsols++;
}
}
}
nchecksols--;
heurdata->ncheckedsols++;
}
}
#ifdef SCIP_MORE_DEBUG
printf(">> heuristic <%s> found %d of %d improving solutions from run %d.\n", HEUR_NAME, nsolsaddedrun, nsols, run);
#endif
}
SCIPdebugMessage(">> heuristic <%s> found %d improving solutions.\n", HEUR_NAME, nsolsadded);
if( nsolsadded > 0 )
*result = SCIP_FOUNDSOL;
else
*result = SCIP_DIDNOTFIND;
/* reset the marks of the checked solutions */
SCIPresetReoptSolMarks(scip);
/* free the buffer array */
SCIPfreeBufferArray(scip, &sols);
return SCIP_OKAY;
}
