/** 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;
}
SCIP_Bool create_graph (int n, int m, GRAPH** gr)
{
assert( gr != NULL );
BMSallocMemory(gr);
if( *gr == NULL )
return FALSE;
BMSallocMemoryArray( &(*gr)->nodes, n );
if( (*gr)->nodes == NULL )
{
BMSfreeMemory(gr);
return FALSE;
}
BMSallocMemoryArray( &(*gr)->edges, m );
if( (*gr)->edges == NULL )
{
BMSfreeMemoryArray(&(*gr)->nodes);
BMSfreeMemory(gr);
return FALSE;
}
(*gr)->nuses = 1;
(*gr)->nnodes = n;
(*gr)->nedges = m/2;
(*gr)->nedgesnonzero = m/2;
return TRUE;
}
/** 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 a clique */
static
void createClique(
CLIQUE** clique, /**< pointer to the clique */
int* nodes, /**< nodes of the clique */
int nnodes /**< number of nodes in the clique */
)
{
int i;
assert(clique != NULL);
ALLOC_ABORT( BMSallocMemory(clique) );
ALLOC_ABORT( BMSallocMemoryArray(&(*clique)->nodes, nnodes) );
/* sort the nodes into the clique's node array */
for( i = 0; i < nnodes; ++i )
{
int node;
int j;
node = nodes[i];
for( j = i; j > 0 && node < (*clique)->nodes[j-1]; --j )
(*clique)->nodes[j] = (*clique)->nodes[j-1];
(*clique)->nodes[j] = node;
}
(*clique)->nnodes = nnodes;
}
/** 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;
}
/** creates global relaxation data */
SCIP_RETCODE SCIPrelaxationCreate(
SCIP_RELAXATION** relaxation /**< global relaxation data */
)
{
assert(relaxation != NULL);
SCIP_ALLOC( BMSallocMemory(relaxation) );
(*relaxation)->relaxsolobjval = 0.0;
(*relaxation)->relaxsolvalid = FALSE;
(*relaxation)->relaxsolzero = TRUE;
return SCIP_OKAY;
}
/** creates a table for storing cliques */
static
void createCliquehash(
CLIQUEHASH** cliquehash, /**< pointer to store the clique hash table */
int tablesize /**< initial size of the clique hash table */
)
{
assert(cliquehash != NULL);
assert(tablesize > 0);
ALLOC_ABORT( BMSallocMemory(cliquehash) );
ALLOC_ABORT( BMSallocMemoryArray(&(*cliquehash)->cliques, tablesize) );
(*cliquehash)->cliquessize = tablesize;
(*cliquehash)->ncliques = 0;
}
/** creates memory buffer storage */
SCIP_RETCODE SCIPbufferCreate(
SCIP_BUFFER** buffer /**< pointer to memory buffer storage */
)
{
assert(buffer != NULL);
SCIP_ALLOC( BMSallocMemory(buffer) );
(*buffer)->data = NULL;
(*buffer)->size = NULL;
(*buffer)->used = NULL;
(*buffer)->ndata = 0;
(*buffer)->firstfree = 0;
return SCIP_OKAY;
}
/** creates block memory structures */
SCIP_RETCODE SCIPmemCreate(
SCIP_MEM** mem /**< pointer to block memory structure */
)
{
assert(mem != NULL);
SCIP_ALLOC( BMSallocMemory(mem) );
SCIP_ALLOC( (*mem)->setmem = BMScreateBlockMemory(1, 10) );
SCIP_ALLOC( (*mem)->probmem = BMScreateBlockMemory(1, 10) );
SCIPdebugMessage("created setmem block memory at <%p>\n", (void*)(*mem)->setmem);
SCIPdebugMessage("created probmem block memory at <%p>\n", (void*)(*mem)->probmem);
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 VBC Tool data structure */
SCIP_RETCODE SCIPvbcCreate(
SCIP_VBC** vbc, /**< pointer to store the VBC information */
SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
)
{
SCIP_ALLOC( BMSallocMemory(vbc) );
(*vbc)->file = NULL;
(*vbc)->messagehdlr = messagehdlr;
(*vbc)->nodenum = NULL;
(*vbc)->timestep = 0;
(*vbc)->lastnode = NULL;
(*vbc)->lastcolor = SCIP_VBCCOLOR_NONE;
(*vbc)->userealtime = FALSE;
return SCIP_OKAY;
}
/** create new node */
XML_NODE* xml_new_node(
const char* name,
int lineno
)
{
XML_NODE* n = NULL;
assert(name != NULL);
if ( BMSallocMemory(&n) != NULL )
{
BMSclearMemory(n);
BMSduplicateMemoryArray(&n->name, name, strlen(name)+1);
n->lineno = lineno;
}
return n;
}
/** creates visualization data structure */
SCIP_RETCODE SCIPvisualCreate(
SCIP_VISUAL** visual, /**< pointer to store visualization information */
SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
)
{
SCIP_ALLOC( BMSallocMemory(visual) );
(*visual)->vbcfile = NULL;
(*visual)->bakfile = NULL;
(*visual)->messagehdlr = messagehdlr;
(*visual)->nodenum = NULL;
(*visual)->timestep = 0;
(*visual)->lastnode = NULL;
(*visual)->lastcolor = SCIP_VBCCOLOR_NONE;
(*visual)->userealtime = FALSE;
return SCIP_OKAY;
}
/** create new attribute */
XML_ATTR* xml_new_attr(
const char* name,
const char* value
)
{
XML_ATTR* a = NULL;
assert(name != NULL);
assert(value != NULL);
if ( BMSallocMemory(&a) != NULL )
{
BMSclearMemory(a);
BMSduplicateMemoryArray(&a->name, name, strlen(name)+1);
BMSduplicateMemoryArray(&a->value, value, strlen(value)+1);
}
return a;
}
/** Creates and captures a message handler which deals with warning, information, and dialog (interactive shell) methods.
*
* @note The message handler does not handle error messages; see SCIPmessageSetErrorPrinting()
*/
SCIP_RETCODE SCIPmessagehdlrCreate(
SCIP_MESSAGEHDLR** messagehdlr, /**< pointer to store the message handler */
SCIP_Bool bufferedoutput, /**< should the output be buffered up to the next newline? */
const char* filename, /**< name of log file, or NULL for no log */
SCIP_Bool quiet, /**< should screen messages be suppressed? */
SCIP_DECL_MESSAGEWARNING((*messagewarning)),/**< warning message print method of message handler */
SCIP_DECL_MESSAGEDIALOG((*messagedialog)),/**< dialog message print method of message handler */
SCIP_DECL_MESSAGEINFO ((*messageinfo)), /**< info message print method of message handler */
SCIP_DECL_MESSAGEHDLRFREE((*messagehdlrfree)), /**< destructor of message handler to free message handler data */
SCIP_MESSAGEHDLRDATA* messagehdlrdata /**< message handler data */
)
{
SCIP_ALLOC( BMSallocMemory(messagehdlr) );
(*messagehdlr)->messagewarning = messagewarning;
(*messagehdlr)->messagedialog = messagedialog;
(*messagehdlr)->messageinfo = messageinfo;
(*messagehdlr)->messagehdlrfree = messagehdlrfree;
(*messagehdlr)->messagehdlrdata = messagehdlrdata;
(*messagehdlr)->warningbuffer = NULL;
(*messagehdlr)->dialogbuffer = NULL;
(*messagehdlr)->infobuffer = NULL;
(*messagehdlr)->warningbufferlen = 0;
(*messagehdlr)->dialogbufferlen = 0;
(*messagehdlr)->infobufferlen = 0;
(*messagehdlr)->nuses = 1;
(*messagehdlr)->quiet = quiet;
messagehdlrOpenLogfile(*messagehdlr, filename);
/* allocate buffer for buffered output */
if( bufferedoutput )
{
SCIP_ALLOC( BMSallocMemoryArray(&(*messagehdlr)->warningbuffer, SCIP_MAXSTRLEN) ); /*lint !e506*/
SCIP_ALLOC( BMSallocMemoryArray(&(*messagehdlr)->dialogbuffer, SCIP_MAXSTRLEN) ); /*lint !e506*/
SCIP_ALLOC( BMSallocMemoryArray(&(*messagehdlr)->infobuffer, SCIP_MAXSTRLEN) ); /*lint !e506*/
(*messagehdlr)->warningbuffer[0] = '\0';
(*messagehdlr)->dialogbuffer[0] = '\0';
(*messagehdlr)->infobuffer[0] = '\0';
}
return SCIP_OKAY;
}
/** Push new element on the parse stack.
*
* TRUE if it worked, FAILURE otherwise.
*/
static
XML_Bool push_pstack(
PPOS* ppos,
XML_NODE* node
)
{
PSTACK* p;
assert(ppos != NULL);
assert(node != NULL);
debugMessage("Pushing %s\n", node->name);
ALLOC_FALSE( BMSallocMemory(&p) );
assert(p != NULL);
p->node = node;
p->next = ppos->top;
ppos->top = p;
return TRUE;
}
/** creates block and buffer memory structures */
SCIP_RETCODE SCIPmemCreate(
SCIP_MEM** mem /**< pointer to block and buffer memory structure */
)
{
assert(mem != NULL);
SCIP_ALLOC( BMSallocMemory(mem) );
/* alloc block memory */
SCIP_ALLOC( (*mem)->setmem = BMScreateBlockMemory(1, 10) );
SCIP_ALLOC( (*mem)->probmem = BMScreateBlockMemory(1, 10) );
/* alloc memory buffers */
SCIP_ALLOC( (*mem)->buffer = BMScreateBufferMemory(SCIP_DEFAULT_MEM_ARRAYGROWFAC, SCIP_DEFAULT_MEM_ARRAYGROWINIT, FALSE) );
SCIP_ALLOC( (*mem)->cleanbuffer = BMScreateBufferMemory(SCIP_DEFAULT_MEM_ARRAYGROWFAC, SCIP_DEFAULT_MEM_ARRAYGROWINIT, TRUE) );
SCIPdebugMessage("created setmem block memory at <%p>\n", (void*)(*mem)->setmem);
SCIPdebugMessage("created probmem block memory at <%p>\n", (void*)(*mem)->probmem);
SCIPdebugMessage("created buffer memory at <%p>\n", (void*)(*mem)->buffer);
SCIPdebugMessage("created clean buffer memory at <%p>\n", (void*)(*mem)->cleanbuffer);
return SCIP_OKAY;
}
/** creates separation storage */
SCIP_RETCODE SCIPsepastoreCreate(
SCIP_SEPASTORE** sepastore /**< pointer to store separation storage */
)
{
assert(sepastore != NULL);
SCIP_ALLOC( BMSallocMemory(sepastore) );
(*sepastore)->cuts = NULL;
(*sepastore)->efficacies = NULL;
(*sepastore)->objparallelisms = NULL;
(*sepastore)->orthogonalities = NULL;
(*sepastore)->scores = NULL;
(*sepastore)->cutssize = 0;
(*sepastore)->ncuts = 0;
(*sepastore)->nforcedcuts = 0;
(*sepastore)->ncutsfound = 0;
(*sepastore)->ncutsfoundround = 0;
(*sepastore)->ncutsapplied = 0;
(*sepastore)->initiallp = FALSE;
(*sepastore)->forcecuts = FALSE;
return SCIP_OKAY;
}
/** create a set of diving heuristic settings */
SCIP_RETCODE SCIPdivesetCreate(
SCIP_DIVESET** diveset, /**< pointer to the freshly created diveset */
SCIP_HEUR* heur, /**< the heuristic to which this dive setting belongs */
const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
SCIP_Real minreldepth, /**< minimal relative depth to start diving */
SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
* where diving is performed (0.0: no limit) */
SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
* where diving is performed (0.0: no limit) */
SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
int maxlpiterofs, /**< additional number of allowed LP iterations */
SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
* more general constraint handler diving variable selection? */
SCIP_DIVETYPE divetypemask, /**< bit mask that represents the supported dive types by this dive set */
SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
)
{
char paramname[SCIP_MAXSTRLEN];
const char* divesetname;
assert(diveset != NULL);
assert(set != NULL);
assert(divesetgetscore != NULL);
assert(heur != NULL);
SCIP_ALLOC( BMSallocMemory(diveset) );
/* for convenience, the name gets inferred from the heuristic to which the diveset is added if no name is provided */
divesetname = (name == NULL ? SCIPheurGetName(heur) : name);
SCIP_ALLOC( BMSduplicateMemoryArray(&(*diveset)->name, divesetname, strlen(divesetname)+1) );
(*diveset)->heur = NULL;
/* copy callbacks */
(*diveset)->divesetgetscore = divesetgetscore;
SCIP_CALL( heurAddDiveset(heur, *diveset) );
(*diveset)->sol = NULL;
(*diveset)->divetypemask = divetypemask;
/* add collection of diving heuristic specific parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/minreldepth", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem,
paramname, "minimal relative depth to start diving",
&(*diveset)->minreldepth, TRUE, minreldepth, 0.0, 1.0, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxreldepth", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem, paramname,
"maximal relative depth to start diving",
&(*diveset)->maxreldepth, TRUE, maxreldepth, 0.0, 1.0, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxlpiterquot", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem,
paramname,
"maximal fraction of diving LP iterations compared to node LP iterations",
&(*diveset)->maxlpiterquot, FALSE, maxlpiterquot, 0.0, SCIP_REAL_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxlpiterofs", (*diveset)->name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem,
paramname,
"additional number of allowed LP iterations",
&(*diveset)->maxlpiterofs, FALSE, maxlpiterofs, 0, INT_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxdiveubquot", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem,
paramname,
"maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)",
&(*diveset)->maxdiveubquot, TRUE, maxdiveubquot, 0.0, 1.0, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxdiveavgquot", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem,
paramname,
"maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)",
&(*diveset)->maxdiveavgquot, TRUE, maxdiveavgquot, 0.0, SCIP_REAL_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxdiveubquotnosol", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem,
paramname,
"maximal UBQUOT when no solution was found yet (0.0: no limit)",
&(*diveset)->maxdiveubquotnosol, TRUE, maxdiveubquotnosol, 0.0, 1.0, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxdiveavgquotnosol", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem,
paramname,
"maximal AVGQUOT when no solution was found yet (0.0: no limit)",
&(*diveset)->maxdiveavgquotnosol, TRUE, maxdiveavgquotnosol, 0.0, SCIP_REAL_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/backtrack", (*diveset)->name);
SCIP_CALL( SCIPsetAddBoolParam(set, messagehdlr, blkmem,
paramname,
"use one level of backtracking if infeasibility is encountered?",
&(*diveset)->backtrack, FALSE, backtrack, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/lpresolvedomchgquot", (*diveset)->name);
SCIP_CALL( SCIPsetAddRealParam(set, messagehdlr, blkmem, paramname,
"percentage of immediate domain changes during probing to trigger LP resolve",
&(*diveset)->lpresolvedomchgquot, FALSE, lpresolvedomchgquot, 0.0, SCIP_REAL_MAX, NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/lpsolvefreq", (*diveset)->name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem,
paramname,
"LP solve frequency for diving heuristics (0: only after enough domain changes have been found)",
&(*diveset)->lpsolvefreq, FALSE, lpsolvefreq, 0, INT_MAX,
NULL, NULL) );
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/onlylpbranchcands", (*diveset)->name);
SCIP_CALL( SCIPsetAddBoolParam(set, messagehdlr, blkmem,
paramname,
"should only LP branching candidates be considered instead of the slower but "
"more general constraint handler diving variable selection?",
&(*diveset)->onlylpbranchcands, FALSE, onlylpbranchcands, NULL, NULL) );
SCIPdivesetReset(*diveset);
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 display column */
SCIP_RETCODE SCIPdispCreate(
SCIP_DISP** disp, /**< pointer to store display column */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
const char* name, /**< name of display column */
const char* desc, /**< description of display column */
const char* header, /**< head line of display column */
SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
SCIP_DISPDATA* dispdata, /**< display column data */
int width, /**< width of display column (no. of chars used) */
int priority, /**< priority of display column */
int position, /**< relative position of display column */
SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
)
{
char paramname[SCIP_MAXSTRLEN];
char paramdesc[SCIP_MAXSTRLEN];
assert(disp != NULL);
assert(name != NULL);
assert(desc != NULL);
assert(header != NULL);
assert(dispoutput != NULL);
assert(width >= 0);
SCIP_ALLOC( BMSallocMemory(disp) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*disp)->name, name, strlen(name)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*disp)->desc, desc, strlen(desc)+1) );
SCIP_ALLOC( BMSduplicateMemoryArray(&(*disp)->header, header, strlen(header)+1) );
(*disp)->dispstatus = dispstatus;
(*disp)->dispcopy = dispcopy;
(*disp)->dispfree = dispfree;
(*disp)->dispinit = dispinit;
(*disp)->dispexit = dispexit;
(*disp)->dispinitsol = dispinitsol;
(*disp)->dispexitsol = dispexitsol;
(*disp)->dispoutput = dispoutput;
(*disp)->dispdata = dispdata;
(*disp)->width = width;
(*disp)->priority = priority;
(*disp)->position = position;
(*disp)->stripline = stripline;
(*disp)->initialized = FALSE;
(*disp)->active = (dispstatus == SCIP_DISPSTATUS_ON);
/* add parameters */
(void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "display/%s/active", name);
(void) SCIPsnprintf(paramdesc, SCIP_MAXSTRLEN, "display activation status of display column <%s> (0: off, 1: auto, 2:on)", name);
SCIP_CALL( SCIPsetAddIntParam(set, messagehdlr, blkmem, paramname, paramdesc,
(int*)(&(*disp)->dispstatus), FALSE, (int)dispstatus, 0, 2, SCIPparamChgdDispActive, 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_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 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 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;
}