/** creates a relaxation handler */
SCIP_RETCODE SCIPrelaxCreate(
SCIP_RELAX** relax, /**< pointer to relaxation handler data structure */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of relaxation handler */
const char* desc, /**< description of relaxation handler */
int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
int freq, /**< frequency for calling relaxation handler */
SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(relax != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(freq >= -1);
assert(relaxexec != NULL);
SCIP_ALLOC( BMSallocMemory(relax) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*relax)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*relax)->desc, desc, strlen(desc)+1) );
(*relax)->priority = priority;
(*relax)->freq = freq;
(*relax)->relaxcopy = relaxcopy;
(*relax)->relaxfree = relaxfree;
(*relax)->relaxinit = relaxinit;
(*relax)->relaxexit = relaxexit;
(*relax)->relaxinitsol = relaxinitsol;
(*relax)->relaxexitsol = relaxexitsol;
(*relax)->relaxexec = relaxexec;
(*relax)->relaxdata = relaxdata;
SCIP_CALL( SCIPclockCreate(&(*relax)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*relax)->relaxclock, SCIP_CLOCKTYPE_DEFAULT) );
(*relax)->ncalls = 0;
(*relax)->lastsolvednode = -1;
(*relax)->initialized = FALSE;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "relaxing/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of relaxation handler <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*relax)->priority, FALSE, priority, INT_MIN/4, INT_MAX/4,
paramChgdRelaxPriority, (SCIP_PARAMDATA*)(*relax)) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "relaxing/%s/freq", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "frequency for calling relaxation handler <%s> (-1: never, 0: only in root node)", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*relax)->freq, FALSE, freq, -1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates pricing storage */
SCIP_RETCODE SCIPpricestoreCreate(
SCIP_PRICESTORE** pricestore /**< pointer to store pricing storage */
)
{
assert(pricestore != NULL);
SCIP_ALLOC( BMSallocMemory(pricestore) );
SCIP_CALL( SCIPclockCreate(&(*pricestore)->probpricingtime, SCIP_CLOCKTYPE_DEFAULT) );
(*pricestore)->vars = NULL;
(*pricestore)->scores = NULL;
(*pricestore)->bdviolvars = NULL;
(*pricestore)->bdviolvarslb = NULL;
(*pricestore)->bdviolvarsub = NULL;
(*pricestore)->varssize = 0;
(*pricestore)->nvars = 0;
(*pricestore)->bdviolvarssize = 0;
(*pricestore)->nbdviolvars = 0;
(*pricestore)->naddedbdviolvars = 0;
(*pricestore)->nprobpricings = 0;
(*pricestore)->nprobvarsfound = 0;
(*pricestore)->nvarsfound = 0;
(*pricestore)->nvarsapplied = 0;
(*pricestore)->initiallp = FALSE;
return SCIP_OKAY;
}
/** creates a reader */
SCIP_RETCODE SCIPreaderCreate(
SCIP_READER** reader, /**< pointer to store reader */
const char* name, /**< name of reader */
const char* desc, /**< description of reader */
const char* extension, /**< file extension that reader processes */
SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
SCIP_DECL_READERREAD ((*readerread)), /**< read method */
SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
SCIP_READERDATA* readerdata /**< reader data */
)
{
assert(reader != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(extension != NULL);
SCIP_ALLOC( BMSallocMemory(reader) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*reader)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*reader)->desc, desc, strlen(desc)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*reader)->extension, extension, strlen(extension)+1) );
(*reader)->readercopy = readercopy;
(*reader)->readerfree = readerfree;
(*reader)->readerread = readerread;
(*reader)->readerwrite = readerwrite;
(*reader)->readerdata = readerdata;
/* create reading clock */
SCIP_CALL( SCIPclockCreate(&(*reader)->readingtime, SCIP_CLOCKTYPE_DEFAULT) );
return SCIP_OKAY;
}
/** creates a variable pricer
* To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
*/
SCIP_RETCODE SCIPpricerCreate(
SCIP_PRICER** pricer, /**< pointer to variable pricer data structure */
SCIP_SET* set, /**< global SCIP settings */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of variable pricer */
const char* desc, /**< description of variable pricer */
int priority, /**< priority of the variable pricer */
SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
* problem variables with negative reduced costs are found */
SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
SCIP_PRICERDATA* pricerdata /**< variable pricer data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(pricer != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(pricerredcost != NULL);
SCIP_ALLOC( BMSallocMemory(pricer) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*pricer)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*pricer)->desc, desc, strlen(desc)+1) );
(*pricer)->priority = priority;
(*pricer)->pricercopy = pricercopy;
(*pricer)->pricerfree = pricerfree;
(*pricer)->pricerinit = pricerinit;
(*pricer)->pricerexit = pricerexit;
(*pricer)->pricerinitsol = pricerinitsol;
(*pricer)->pricerexitsol = pricerexitsol;
(*pricer)->pricerredcost = pricerredcost;
(*pricer)->pricerfarkas = pricerfarkas;
(*pricer)->pricerdata = pricerdata;
SCIP_CALL( SCIPclockCreate(&(*pricer)->pricerclock, SCIP_CLOCKTYPE_DEFAULT) );
(*pricer)->ncalls = 0;
(*pricer)->nvarsfound = 0;
(*pricer)->delay = delay;
(*pricer)->active = FALSE;
(*pricer)->initialized = FALSE;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "pricers/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of pricer <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, blkmem, paramname, paramdesc,
&(*pricer)->priority, FALSE, priority, INT_MIN/4, INT_MAX/4,
paramChgdPricerPriority, (SCIP_PARAMDATA*)(*pricer)) ); /*lint !e740*/
return SCIP_OKAY;
}
/** reads problem data from file with given reader or returns SCIP_DIDNOTRUN */
SCIP_RETCODE SCIPreaderRead(
SCIP_READER* reader, /**< reader */
SCIP_SET* set, /**< global SCIP settings */
const char* filename, /**< name of the input file */
const char* extension, /**< extension of the input file name */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
SCIP_RETCODE retcode;
assert(reader != NULL);
assert(set != NULL);
assert(filename != NULL);
assert(result != NULL);
/* check, if reader is applicable on the given file */
if( readerIsApplicable(reader, extension) && reader->readerread != NULL )
{
SCIP_CLOCK* readingtime;
/**@note we need temporary clock to measure the reading time correctly since in case of creating a new problem
* within the reader all clocks are reset (including the reader clocks); this resetting is necessary for
* example for those case we people solve several problems using the (same) interactive shell
*/
assert(!SCIPclockIsRunning(reader->readingtime));
/* create a temporary clock for measuring the reading time */
SCIP_CALL( SCIPclockCreate(&readingtime, SCIP_CLOCKTYPE_DEFAULT) );
/* start timing */
SCIPclockStart(readingtime, set);
/* call reader to read problem */
retcode = reader->readerread(set->scip, reader, filename, result);
/* stop timing */
SCIPclockStop(readingtime, set);
/* add time to reader reading clock */
SCIPclockSetTime(reader->readingtime, SCIPclockGetTime(reader->readingtime) + SCIPclockGetTime(readingtime));
/* free the temporary clock */
SCIPclockFree(&readingtime);
}
else
{
*result = SCIP_DIDNOTRUN;
retcode = SCIP_OKAY;
}
/* check for reader errors */
if( retcode == SCIP_NOFILE || retcode == SCIP_READERROR )
return retcode;
/* check if the result code is valid in case no reader error occurred */
assert( *result == SCIP_DIDNOTRUN || *result == SCIP_SUCCESS );
SCIP_CALL( retcode );
return SCIP_OKAY;
}
/** creates a presolver */
SCIP_RETCODE SCIPpresolCreate(
SCIP_PRESOL** presol, /**< pointer to store presolver */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of presolver */
const char* desc, /**< description of presolver */
int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
SCIP_Bool delay, /**< should presolver be delayed, if other presolvers found reductions? */
SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
SCIP_PRESOLDATA* presoldata /**< presolver data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(presol != NULL);
assert(name != NULL);
assert(desc != NULL);
SCIP_ALLOC( BMSallocMemory(presol) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*presol)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*presol)->desc, desc, strlen(desc)+1) );
(*presol)->presolcopy = presolcopy;
(*presol)->presolfree = presolfree;
(*presol)->presolinit = presolinit;
(*presol)->presolexit = presolexit;
(*presol)->presolinitpre = presolinitpre;
(*presol)->presolexitpre = presolexitpre;
(*presol)->presolexec = presolexec;
(*presol)->presoldata = presoldata;
SCIP_CALL( SCIPclockCreate(&(*presol)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*presol)->presolclock, SCIP_CLOCKTYPE_DEFAULT) );
(*presol)->wasdelayed = FALSE;
(*presol)->initialized = FALSE;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of presolver <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*presol)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
paramChgdPresolPriority, (SCIP_PARAMDATA*)(*presol)) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/maxrounds", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname,
"maximal number of presolving rounds the presolver participates in (-1: no limit)",
&(*presol)->maxrounds, FALSE, maxrounds, -1, INT_MAX, NULL, NULL) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/delay", name);
SCIP_CALL( SCIPsetAddBoolParam(set, messagehdlr, blkmem, paramname,
"should presolver be delayed, if other presolvers found reductions?",
&(*presol)->delay, TRUE, delay, NULL, NULL) ); /*lint !e740*/
return SCIP_OKAY;
}
/** creates problem statistics data */
SCIP_RETCODE SCIPstatCreate(
SCIP_STAT** stat, /**< pointer to problem statistics data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
)
{
assert(stat != NULL);
assert(set != NULL);
SCIP_ALLOC( BMSallocMemory(stat) );
SCIP_CALL( SCIPclockCreate(&(*stat)->solvingtime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->presolvingtime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->primallptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->duallptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->lexduallptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->barrierlptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->divinglptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->strongbranchtime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->conflictlptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->lpsoltime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->pseudosoltime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->sbsoltime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->nodeactivationtime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->nlpsoltime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->copyclock, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*stat)->strongpropclock, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPhistoryCreate(&(*stat)->glbhistory, blkmem) );
SCIP_CALL( SCIPhistoryCreate(&(*stat)->glbhistorycrun, blkmem) );
SCIP_CALL( SCIPvbcCreate(&(*stat)->vbc, messagehdlr) );
(*stat)->status = SCIP_STATUS_UNKNOWN;
(*stat)->marked_nvaridx = 0;
(*stat)->marked_ncolidx = 0;
(*stat)->marked_nrowidx = 0;
(*stat)->userinterrupt = FALSE;
(*stat)->userrestart = FALSE;
(*stat)->inrestart = FALSE;
(*stat)->collectvarhistory = TRUE;
(*stat)->subscipdepth = 0;
SCIPstatReset(*stat, set);
return SCIP_OKAY;
}
/** creates a separator */
SCIP_RETCODE SCIPsepaCreate(
SCIP_SEPA** sepa, /**< pointer to separator data structure */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of separator */
const char* desc, /**< description of separator */
int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
int freq, /**< frequency for calling separator */
SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
* to best node's dual bound for applying separation */
SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
SCIP_SEPADATA* sepadata /**< separator data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(sepa != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(freq >= -1);
assert(0.0 <= maxbounddist && maxbounddist <= 1.0);
assert(sepaexeclp != NULL || sepaexecsol != NULL);
SCIP_ALLOC( BMSallocMemory(sepa) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*sepa)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*sepa)->desc, desc, strlen(desc)+1) );
(*sepa)->priority = priority;
(*sepa)->freq = freq;
(*sepa)->maxbounddist = maxbounddist;
(*sepa)->usessubscip = usessubscip;
(*sepa)->sepacopy = sepacopy;
(*sepa)->sepafree = sepafree;
(*sepa)->sepainit = sepainit;
(*sepa)->sepaexit = sepaexit;
(*sepa)->sepainitsol = sepainitsol;
(*sepa)->sepaexitsol = sepaexitsol;
(*sepa)->sepaexeclp = sepaexeclp;
(*sepa)->sepaexecsol = sepaexecsol;
(*sepa)->sepadata = sepadata;
SCIP_CALL( SCIPclockCreate(&(*sepa)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*sepa)->sepaclock, SCIP_CLOCKTYPE_DEFAULT) );
(*sepa)->lastsepanode = -1;
(*sepa)->ncalls = 0;
(*sepa)->ncutoffs = 0;
(*sepa)->ncutsfound = 0;
(*sepa)->ncutsapplied = 0;
(*sepa)->nconssfound = 0;
(*sepa)->ndomredsfound = 0;
(*sepa)->ncallsatnode = 0;
(*sepa)->ncutsfoundatnode = 0;
(*sepa)->lpwasdelayed = FALSE;
(*sepa)->solwasdelayed = FALSE;
(*sepa)->initialized = FALSE;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of separator <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*sepa)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
paramChgdSepaPriority, (SCIP_PARAMDATA*)(*sepa)) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/freq", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "frequency for calling separator <%s> (-1: never, 0: only in root node)", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*sepa)->freq, FALSE, freq, -1, INT_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/maxbounddist", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <%s> (0.0: only on current best node, 1.0: on all nodes)",
name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*sepa)->maxbounddist, TRUE, maxbounddist, 0.0, 1.0, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/delay", name);
SCIP_CALL( SCIPsetAddBoolParam(set, messagehdlr, blkmem, paramname,
"should separator be delayed, if other separators found cuts?",
&(*sepa)->delay, TRUE, delay, NULL, NULL) ); /*lint !e740*/
return SCIP_OKAY;
}
/** creates a tree compression */
SCIP_RETCODE SCIPcomprCreate(
SCIP_COMPR** compr, /**< pointer to tree compression data structure */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of tree compression */
const char* desc, /**< description of tree compression */
int priority, /**< priority of the tree compression */
int minnnodes, /**< minimal number of nodes for calling compression */
SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
SCIP_COMPRDATA* comprdata /**< tree compression data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(compr != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(comprexec != NULL);
SCIP_ALLOC( BMSallocMemory(compr) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*compr)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*compr)->desc, desc, strlen(desc)+1) );
(*compr)->priority = priority;
(*compr)->minnnodes = minnnodes;
(*compr)->comprcopy = comprcopy;
(*compr)->comprfree = comprfree;
(*compr)->comprinit = comprinit;
(*compr)->comprexit = comprexit;
(*compr)->comprinitsol = comprinitsol;
(*compr)->comprexitsol = comprexitsol;
(*compr)->comprexec = comprexec;
(*compr)->comprdata = comprdata;
SCIP_CALL( SCIPclockCreate(&(*compr)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*compr)->comprclock, SCIP_CLOCKTYPE_DEFAULT) );
(*compr)->ncalls = 0;
(*compr)->nfound = 0;
(*compr)->rate = 0.0;
(*compr)->initialized = FALSE;
(*compr)->nnodes = 0;
(*compr)->loi = 0.0;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "compression/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of compression <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*compr)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
paramChgdComprPriority, (SCIP_PARAMDATA*)(*compr)) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "compression/%s/minnleaves", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "minimal number of leave nodes for calling tree compression <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*compr)->minnnodes, FALSE, minnnodes, 1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates a presolver */
SCIP_RETCODE SCIPpresolCreate(
SCIP_PRESOL** presol, /**< pointer to store presolver */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of presolver */
const char* desc, /**< description of presolver */
int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
SCIP_PRESOLDATA* presoldata /**< presolver data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(presol != NULL);
assert(name != NULL);
assert(desc != NULL);
/* the interface change from delay flags to timings cannot be recognized at compile time: Exit with an appropriate
* error message
*/
if( timing < SCIP_PRESOLTIMING_FAST || timing > SCIP_PRESOLTIMING_ALWAYS )
{
SCIPmessagePrintError("ERROR: 'PRESOLDELAY'-flag no longer available since SCIP 3.2, use an appropriate "
"'SCIP_PRESOLTIMING' for <%s> presolver instead.\n", name);
return SCIP_PARAMETERWRONGVAL;
}
SCIP_ALLOC( BMSallocMemory(presol) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*presol)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*presol)->desc, desc, strlen(desc)+1) );
(*presol)->presolcopy = presolcopy;
(*presol)->presolfree = presolfree;
(*presol)->presolinit = presolinit;
(*presol)->presolexit = presolexit;
(*presol)->presolinitpre = presolinitpre;
(*presol)->presolexitpre = presolexitpre;
(*presol)->presolexec = presolexec;
(*presol)->presoldata = presoldata;
SCIP_CALL( SCIPclockCreate(&(*presol)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*presol)->presolclock, SCIP_CLOCKTYPE_DEFAULT) );
(*presol)->initialized = FALSE;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of presolver <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*presol)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
paramChgdPresolPriority, (SCIP_PARAMDATA*)(*presol)) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/maxrounds", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname,
"maximal number of presolving rounds the presolver participates in (-1: no limit)",
&(*presol)->maxrounds, FALSE, maxrounds, -1, INT_MAX, NULL, NULL) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/timing", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "timing mask of presolver <%s> (%u:FAST, %u:MEDIUM, %u:EXHAUSTIVE)",
name, SCIP_PRESOLTIMING_FAST, SCIP_PRESOLTIMING_MEDIUM, SCIP_PRESOLTIMING_EXHAUSTIVE);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
(int*)&(*presol)->timing, TRUE, (int)timing, (int) SCIP_PRESOLTIMING_FAST, (int) SCIP_PRESOLTIMING_ALWAYS, NULL, NULL) ); /*lint !e740*/
return SCIP_OKAY;
}
/** creates a primal heuristic */
SCIP_RETCODE SCIPheurCreate(
SCIP_HEUR** heur, /**< pointer to primal heuristic data structure */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of primal heuristic */
const char* desc, /**< description of primal heuristic */
char dispchar, /**< display character of primal heuristic */
int priority, /**< priority of the primal heuristic */
int freq, /**< frequency for calling primal heuristic */
int freqofs, /**< frequency offset for calling primal heuristic */
int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed */
SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
SCIP_HEURDATA* heurdata /**< primal heuristic data */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(heur != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(freq >= -1);
assert(freqofs >= 0);
assert(heurexec != NULL);
SCIP_ALLOC( BMSallocMemory(heur) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*heur)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*heur)->desc, desc, strlen(desc)+1) );
(*heur)->dispchar = dispchar;
(*heur)->priority = priority;
(*heur)->freq = freq;
(*heur)->freqofs = freqofs;
(*heur)->maxdepth = maxdepth;
(*heur)->delaypos = -1;
(*heur)->timingmask = timingmask;
(*heur)->usessubscip = usessubscip;
(*heur)->heurcopy = heurcopy;
(*heur)->heurfree = heurfree;
(*heur)->heurinit = heurinit;
(*heur)->heurexit = heurexit;
(*heur)->heurinitsol = heurinitsol;
(*heur)->heurexitsol = heurexitsol;
(*heur)->heurexec = heurexec;
(*heur)->heurdata = heurdata;
SCIP_CALL( SCIPclockCreate(&(*heur)->setuptime, SCIP_CLOCKTYPE_DEFAULT) );
SCIP_CALL( SCIPclockCreate(&(*heur)->heurclock, SCIP_CLOCKTYPE_DEFAULT) );
(*heur)->ncalls = 0;
(*heur)->nsolsfound = 0;
(*heur)->nbestsolsfound = 0;
(*heur)->initialized = FALSE;
(*heur)->divesets = NULL;
(*heur)->ndivesets = 0;
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/priority", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "priority of heuristic <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*heur)->priority, TRUE, priority, INT_MIN/4, INT_MAX/4,
paramChgdHeurPriority, (SCIP_PARAMDATA*)(*heur)) ); /*lint !e740*/
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freq", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "frequency for calling primal heuristic <%s> (-1: never, 0: only at depth freqofs)", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*heur)->freq, FALSE, freq, -1, INT_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freqofs", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "frequency offset for calling primal heuristic <%s>", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*heur)->freqofs, FALSE, freqofs, 0, INT_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxdepth", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "maximal depth level to call primal heuristic <%s> (-1: no limit)", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
&(*heur)->maxdepth, TRUE, maxdepth, -1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}