/** creates a new solution for the original problem by copying the solution of the subproblem */
static
SCIP_RETCODE createNewSol(
SCIP* scip, /**< original SCIP data structure */
SCIP_HEUR* heur, /**< the current heuristic */
SCIP_SOL* sol, /**< solution of the subproblem */
SCIP_Bool* success /**< used to store whether new solution was found or not */
)
{
SCIP_VAR** vars; /* the original problem's variables */
int nvars; /* the original problem's number of variables */
SCIP_Real* solvals; /* solution values of the subproblem */
SCIP_SOL* newsol; /* solution to be created for the original problem */
assert(scip != NULL);
/* get variables' data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPallocBufferArray(scip, &solvals, nvars) );
/* copy the solution */
SCIP_CALL( SCIPgetSolVals(scip, sol, nvars, vars, solvals) );
/* create new solution for the original problem */
SCIP_CALL( SCIPcreateSol(scip, &newsol, heur) );
SCIP_CALL( SCIPsetSolVals(scip, newsol, nvars, vars, solvals) );
/* try to add new solution to scip and free it immediately */
SCIP_CALL( SCIPtrySolFree(scip, &newsol, FALSE, TRUE, TRUE, TRUE, success) );
SCIPfreeBufferArray(scip, &solvals);
return SCIP_OKAY;
}
/** initialization method of primal heuristic (called after problem was transformed) */
static
SCIP_DECL_HEURINIT(heurInitZirounding)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* create working solution */
SCIP_CALL( SCIPcreateSol(scip, &heurdata->sol, heur) );
return SCIP_OKAY;
}
/** initialization method of primal heuristic (called after problem was transformed) */
static
SCIP_DECL_HEURINIT(heurInitRandrounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* create heuristic data */
SCIP_CALL( SCIPcreateSol(scip, &heurdata->sol, heur) );
heurdata->lastlp = -1;
heurdata->randseed = DEFAULT_RANDSEED;
return SCIP_OKAY;
}
/** initialization method of primal heuristic (called after problem was transformed) */
static
SCIP_DECL_HEURINIT(heurInitSimplerounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(SCIPheurGetData(heur) == NULL);
/* create heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
SCIP_CALL( SCIPcreateSol(scip, &heurdata->sol, heur) );
heurdata->lastlp = -1;
heurdata->nroundablevars = -1;
SCIPheurSetData(heur, heurdata);
return SCIP_OKAY;
}
/** generate point for close cut separation
*
* The constructed point is the convex combination of the point stored in set->closesol and the
* current LP solution. The convexity parameter is set->sepa_closecombvalue. If this parameter is
* 0, the point coincides with the LP solution.
*/
static
SCIP_RETCODE generateCloseCutPoint(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPADATA* sepadata, /**< separator data */
SCIP_SOL** point /**< point to be generated (or NULL if unsuccessful) */
)
{
SCIP_VAR** vars;
SCIP_VAR* var;
SCIP_Real val;
SCIP_Real alpha;
SCIP_Real onealpha;
int nvars;
int i;
assert( scip != NULL );
assert( point != NULL );
*point = NULL;
if ( sepadata->sepasol == NULL )
return SCIP_OKAY;
alpha = sepadata->sepacombvalue;
if ( alpha < 0.001 )
return SCIP_OKAY;
onealpha = 1.0 - alpha;
/* create solution */
SCIP_CALL( SCIPcreateSol(scip, point, NULL) );
/* generate convex combination */
vars = SCIPgetVars(scip);
nvars = SCIPgetNVars(scip);
for (i = 0; i < nvars; ++i)
{
var = vars[i];
val = alpha * SCIPgetSolVal(scip, sepadata->sepasol, var) + onealpha * SCIPvarGetLPSol(var);
if ( ! SCIPisZero(scip, val) )
{
SCIP_CALL( SCIPsetSolVal(scip, *point, var, val) );
}
}
return SCIP_OKAY;
}
/** creates a new solution for the original problem by copying the solution of the subproblem */
static
SCIP_RETCODE createNewSol(
SCIP* scip, /**< original SCIP data structure */
SCIP* subscip, /**< SCIP structure of the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
SCIP_HEUR* heur, /**< crossover heuristic structure */
SCIP_SOL* subsol, /**< solution of the subproblem */
int* solindex, /**< index of the solution */
SCIP_Bool* success /**< used to store whether new solution was found or not */
)
{
SCIP_VAR** vars; /* the original problem's variables */
int nvars;
SCIP_SOL* newsol; /* solution to be created for the original problem */
SCIP_Real* subsolvals; /* solution values of the subproblem */
assert(scip != NULL);
assert(subscip != NULL);
assert(subvars != NULL);
assert(subsol != NULL);
/* get variables' data */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* sub-SCIP may have more variables than the number of active (transformed) variables in the main SCIP
* since constraint copying may have required the copy of variables that are fixed in the main SCIP
*/
assert(nvars <= SCIPgetNOrigVars(subscip));
SCIP_CALL( SCIPallocBufferArray(scip, &subsolvals, nvars) );
/* copy the solution */
SCIP_CALL( SCIPgetSolVals(subscip, subsol, nvars, subvars, subsolvals) );
/* create new solution for the original problem */
SCIP_CALL( SCIPcreateSol(scip, &newsol, heur) );
SCIP_CALL( SCIPsetSolVals(scip, newsol, nvars, vars, subsolvals) );
*solindex = SCIPsolGetIndex(newsol);
/* try to add new solution to scip and free it immediately */
SCIP_CALL( SCIPtrySolFree(scip, &newsol, FALSE, TRUE, TRUE, TRUE, success) );
SCIPfreeBufferArray(scip, &subsolvals);
return SCIP_OKAY;
}
/** creates a new solution for the original problem by copying the solution of the subproblem */
static
SCIP_RETCODE createNewSol(
SCIP* scip, /**< SCIP data structure of the original problem */
SCIP* subscip, /**< SCIP data structure of the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
SCIP_HEUR* heur, /**< the Localbranching heuristic */
SCIP_SOL* subsol, /**< solution of the subproblem */
SCIP_Bool* success /**< pointer to store, whether new solution was found */
)
{
SCIP_VAR** vars;
int nvars;
SCIP_SOL* newsol;
SCIP_Real* subsolvals;
assert( scip != NULL );
assert( subscip != NULL );
assert( subvars != NULL );
assert( subsol != NULL );
/* copy the solution */
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
/* sub-SCIP may have more variables than the number of active (transformed) variables in the main SCIP
* since constraint copying may have required the copy of variables that are fixed in the main SCIP
*/
assert(nvars <= SCIPgetNOrigVars(subscip));
SCIP_CALL( SCIPallocBufferArray(scip, &subsolvals, nvars) );
/* copy the solution */
SCIP_CALL( SCIPgetSolVals(subscip, subsol, nvars, subvars, subsolvals) );
/* create new solution for the original problem */
SCIP_CALL( SCIPcreateSol(scip, &newsol, heur) );
SCIP_CALL( SCIPsetSolVals(scip, newsol, nvars, vars, subsolvals) );
SCIP_CALL( SCIPtrySolFree(scip, &newsol, FALSE, TRUE, TRUE, TRUE, success) );
SCIPfreeBufferArray(scip, &subsolvals);
return SCIP_OKAY;
}
/** initialization method of primal heuristic (called after problem was transformed) */
static
SCIP_DECL_HEURINIT(heurInitLinesearchdiving)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(heur != NULL);
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* create working solution */
SCIP_CALL( SCIPcreateSol(scip, &heurdata->sol, heur) );
/* initialize data */
heurdata->nlpiterations = 0;
heurdata->nsuccess = 0;
return SCIP_OKAY;
}
/** initialization method of primal heuristic (called after problem was transformed) */
static
SCIP_DECL_HEURINIT(heurInitObjpscostdiving) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* create working solution */
SCIP_CALL( SCIPcreateSol(scip, &heurdata->sol, heur) );
/* initialize data */
heurdata->nlpiterations = 0;
heurdata->nsuccess = 0;
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecOctane)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
SCIP_SOL* sol;
SCIP_SOL** first_sols; /* stores the first ffirst sols in order to check for common violation of a row */
SCIP_VAR** vars; /* the variables of the problem */
SCIP_VAR** fracvars; /* variables, that are fractional in current LP solution */
SCIP_VAR** subspacevars; /* the variables on which the search is performed. Either coinciding with vars or with the
* space of all fractional variables of the current LP solution */
SCIP_Real p; /* n/2 - <delta,x> ( for some facet delta ) */
SCIP_Real q; /* <delta,a> */
SCIP_Real* rayorigin; /* origin of the ray, vector x in paper */
SCIP_Real* raydirection; /* direction of the ray, vector a in paper */
SCIP_Real* negquotient; /* negated quotient of rayorigin and raydirection, vector v in paper */
SCIP_Real* lambda; /* stores the distance of the facets (s.b.) to the origin of the ray */
SCIP_Bool usefracspace; /* determines whether the search concentrates on fractional variables and fixes integer ones */
SCIP_Bool cons_viol; /* used for checking whether a linear constraint is violated by one of the possible solutions */
SCIP_Bool success;
SCIP_Bool* sign; /* signature of the direction of the ray */
SCIP_Bool** facets; /* list of extended facets */
int nvars; /* number of variables */
int nbinvars; /* number of 0-1-variables */
int nfracvars; /* number of fractional variables in current LP solution */
int nsubspacevars; /* dimension of the subspace on which the search is performed */
int nfacets; /* number of facets hidden by the ray that where already found */
int i; /* counter */
int j; /* counter */
int f_max; /* {0,1}-points to be checked */
int f_first; /* {0,1}-points to be generated at first in order to check whether a restart is necessary */
int r; /* counter */
int firstrule;
int* perm; /* stores the way in which the coordinates were permuted */
int* fracspace; /* maps the variables of the subspace to the original variables */
assert(heur != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(scip != NULL);
assert(result != NULL);
assert(SCIPhasCurrentNodeLP(scip));
*result = SCIP_DELAYED;
/* only call heuristic, if an optimal LP solution is at hand */
if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
return SCIP_OKAY;
*result = SCIP_DIDNOTRUN;
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, NULL, NULL, NULL) );
/* OCTANE is for use in 0-1 programs only */
if( nvars != nbinvars )
return SCIP_OKAY;
/* get heuristic's data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
/* don't call heuristic, if it was not successful enough in the past */
/*lint --e{647}*/
if( SCIPgetNNodes(scip) % (SCIPheurGetNCalls(heur) / (100 * SCIPheurGetNBestSolsFound(heur) + 10*heurdata->nsuccess + 1) + 1) != 0 )
return SCIP_OKAY;
SCIP_CALL( SCIPgetLPBranchCands(scip, &fracvars, NULL, NULL, &nfracvars, NULL) );
/* don't use integral starting points */
if( nfracvars == 0 )
return SCIP_OKAY;
/* get working pointers from heurdata */
sol = heurdata->sol;
assert( sol != NULL );
f_max = heurdata->f_max;
f_first = heurdata->f_first;
usefracspace = heurdata->usefracspace;
SCIP_CALL( SCIPallocBufferArray(scip, &fracspace, nvars) );
/* determine the space one which OCTANE should work either as the whole space or as the space of fractional variables */
if( usefracspace )
{
nsubspacevars = nfracvars;
SCIP_CALL( SCIPallocBufferArray(scip, &subspacevars, nsubspacevars) );
BMScopyMemoryArray(subspacevars, fracvars, nsubspacevars);
for( i = nvars - 1; i >= 0; --i )
fracspace[i] = -1;
for( i = nsubspacevars - 1; i >= 0; --i )
fracspace[SCIPvarGetProbindex(subspacevars[i])] = i;
}
else
{
int currentindex;
nsubspacevars = nvars;
SCIP_CALL( SCIPallocBufferArray(scip, &subspacevars, nsubspacevars) );
/* only copy the variables which are in the current LP */
currentindex = 0;
for( i = 0; i < nvars; ++i )
{
if( SCIPcolGetLPPos(SCIPvarGetCol(vars[i])) >= 0 )
{
subspacevars[currentindex] = vars[i];
fracspace[i] = currentindex;
++currentindex;
}
else
{
fracspace[i] = -1;
--nsubspacevars;
}
}
}
/* nothing to do for empty search space */
if( nsubspacevars == 0 )
return SCIP_OKAY;
assert(0 < nsubspacevars && nsubspacevars <= nvars);
for( i = 0; i < nsubspacevars; i++)
assert(fracspace[SCIPvarGetProbindex(subspacevars[i])] == i);
/* at most 2^(n-1) facets can be hit */
if( nsubspacevars < 30 )
{
/*lint --e{701}*/
assert(f_max > 0);
f_max = MIN(f_max, 1 << (nsubspacevars - 1) );
}
f_first = MIN(f_first, f_max);
/* memory allocation */
SCIP_CALL( SCIPallocBufferArray(scip, &rayorigin, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &raydirection, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &negquotient, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &sign, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &perm, nsubspacevars) );
SCIP_CALL( SCIPallocBufferArray(scip, &lambda, f_max + 1) );
SCIP_CALL( SCIPallocBufferArray(scip, &facets, f_max + 1) );
for( i = f_max; i >= 0; --i )
{
/*lint --e{866}*/
SCIP_CALL( SCIPallocBufferArray(scip, &facets[i], nsubspacevars) );
}
SCIP_CALL( SCIPallocBufferArray(scip, &first_sols, f_first) );
*result = SCIP_DIDNOTFIND;
/* starting OCTANE */
SCIPdebugMessage("run Octane heuristic on %s variables, which are %d vars, generate at most %d facets, using rule number %d\n",
usefracspace ? "fractional" : "all", nsubspacevars, f_max, (heurdata->lastrule+1)%5);
/* generate starting point in original coordinates */
SCIP_CALL( generateStartingPoint(scip, rayorigin, subspacevars, nsubspacevars) );
for( i = nsubspacevars - 1; i >= 0; --i )
rayorigin[i] -= 0.5;
firstrule = heurdata->lastrule;
++firstrule;
for( r = firstrule; r <= firstrule + 10 && !SCIPisStopped(scip); r++ )
{
SCIP_ROW** rows;
int nrows;
/* generate shooting ray in original coordinates by certain rules */
switch(r % 5)
{
case 1:
if( heurdata->useavgnbray )
{
SCIP_CALL( generateAverageNBRay(scip, raydirection, fracspace, subspacevars, nsubspacevars) );
}
break;
case 2:
if( heurdata->useobjray )
{
SCIP_CALL( generateObjectiveRay(scip, raydirection, subspacevars, nsubspacevars) );
}
break;
case 3:
if( heurdata->usediffray )
{
SCIP_CALL( generateDifferenceRay(scip, raydirection, subspacevars, nsubspacevars) );
}
break;
case 4:
if( heurdata->useavgwgtray && SCIPisLPSolBasic(scip) )
{
SCIP_CALL( generateAverageRay(scip, raydirection, subspacevars, nsubspacevars, TRUE) );
}
break;
case 0:
if( heurdata->useavgray && SCIPisLPSolBasic(scip) )
{
SCIP_CALL( generateAverageRay(scip, raydirection, subspacevars, nsubspacevars, FALSE) );
}
break;
default:
SCIPerrorMessage("invalid ray rule identifier\n");
SCIPABORT();
}
/* there must be a feasible direction for the shooting ray */
if( isZero(scip, raydirection, nsubspacevars) )
continue;
/* transform coordinates such that raydirection >= 0 */
flipCoords(rayorigin, raydirection, sign, nsubspacevars);
for( i = f_max - 1; i >= 0; --i)
lambda[i] = SCIPinfinity(scip);
/* calculate negquotient, initialize perm, facets[0], p, and q */
p = 0.5 * nsubspacevars;
q = 0.0;
for( i = nsubspacevars - 1; i >= 0; --i )
{
/* calculate negquotient, the ratio of rayorigin and raydirection, paying special attention to the case raydirection[i] == 0 */
if( SCIPisFeasZero(scip, raydirection[i]) )
{
if( rayorigin[i] < 0 )
negquotient[i] = SCIPinfinity(scip);
else
negquotient[i] = -SCIPinfinity(scip);
}
else
negquotient[i] = - (rayorigin[i] / raydirection[i]);
perm[i] = i;
/* initialization of facets[0] to the all-one facet with p and q its characteristic values */
facets[0][i] = TRUE;
p -= rayorigin[i];
q += raydirection[i];
}
assert(SCIPisPositive(scip, q));
/* resort the coordinates in nonincreasing order of negquotient */
SCIPsortDownRealRealRealBoolPtr( negquotient, raydirection, rayorigin, sign, (void**) subspacevars, nsubspacevars);
#ifndef NDEBUG
for( i = 0; i < nsubspacevars; i++ )
assert( raydirection[i] >= 0 );
for( i = 1; i < nsubspacevars; i++ )
assert( negquotient[i - 1] >= negquotient[i] );
#endif
/* finished initialization */
/* find the first facet of the octahedron hit by a ray shot from rayorigin into direction raydirection */
for( i = 0; i < nsubspacevars && negquotient[i] * q > p; ++i )
{
facets[0][i] = FALSE;
p += 2 * rayorigin[i];
q -= 2 * raydirection[i];
assert(SCIPisPositive(scip, p));
assert(SCIPisPositive(scip, q));
}
/* avoid dividing by values close to 0.0 */
if( !SCIPisFeasPositive(scip, q) )
continue;
/* assert necessary for flexelint */
assert(q > 0);
lambda[0] = p / q;
nfacets = 1;
/* find the first facets hit by the ray */
for( i = 0; i < nfacets && i < f_first; ++i)
generateNeighborFacets(scip, facets, lambda, rayorigin, raydirection, negquotient, nsubspacevars, f_max, i, &nfacets);
/* construct the first ffirst possible solutions */
for( i = 0; i < nfacets && i < f_first; ++i )
{
SCIP_CALL( SCIPcreateSol(scip, &first_sols[i], heur) );
SCIP_CALL( getSolFromFacet(scip, facets[i], first_sols[i], sign, subspacevars, nsubspacevars) );
assert( first_sols[i] != NULL );
}
/* try, whether there is a row violated by all of the first ffirst solutions */
cons_viol = FALSE;
SCIP_CALL( SCIPgetLPRowsData(scip, &rows, &nrows) );
for( i = nrows - 1; i >= 0; --i )
{
if( !SCIProwIsLocal(rows[i]) )
{
SCIP_COL** cols;
SCIP_Real constant;
SCIP_Real lhs;
SCIP_Real rhs;
SCIP_Real rowval;
SCIP_Real* coeffs;
int nnonzerovars;
int k;
/* get the row's data */
constant = SCIProwGetConstant(rows[i]);
lhs = SCIProwGetLhs(rows[i]);
rhs = SCIProwGetRhs(rows[i]);
coeffs = SCIProwGetVals(rows[i]);
nnonzerovars = SCIProwGetNNonz(rows[i]);
cols = SCIProwGetCols(rows[i]);
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[0], SCIPcolGetVar(cols[j]));
/* if the row's lhs is violated by the first sol, test, whether it is violated by the next ones, too */
if( lhs > rowval )
{
cons_viol = TRUE;
for( k = MIN(f_first, nfacets) - 1; k > 0; --k )
{
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[k], SCIPcolGetVar(cols[j]));
if( lhs <= rowval )
{
cons_viol = FALSE;
break;
}
}
}
/* dito for the right hand side */
else if( rhs < rowval )
{
cons_viol = TRUE;
for( k = MIN(f_first, nfacets) - 1; k > 0; --k )
{
rowval = constant;
for( j = nnonzerovars - 1; j >= 0; --j )
rowval += coeffs[j] * SCIPgetSolVal(scip, first_sols[k], SCIPcolGetVar(cols[j]));
if( rhs >= rowval )
{
cons_viol = FALSE;
break;
}
}
}
/* break as soon as one row is violated by all of the ffirst solutions */
if( cons_viol )
break;
}
}
if( !cons_viol )
{
/* if there was no row violated by all solutions, try whether one or more of them are feasible */
for( i = MIN(f_first, nfacets) - 1; i >= 0; --i )
{
assert(first_sols[i] != NULL);
SCIP_CALL( SCIPtrySol(scip, first_sols[i], FALSE, TRUE, FALSE, TRUE, &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
/* search for further facets and construct and try solutions out of facets fixed as closest ones */
for( i = f_first; i < f_max; ++i)
{
if( i >= nfacets )
break;
generateNeighborFacets(scip, facets, lambda, rayorigin, raydirection, negquotient, nsubspacevars, f_max, i, &nfacets);
SCIP_CALL( getSolFromFacet(scip, facets[i], sol, sign, subspacevars, nsubspacevars) );
SCIP_CALL( SCIPtrySol(scip, sol, FALSE, TRUE, FALSE, TRUE, &success) );
if( success )
*result = SCIP_FOUNDSOL;
}
}
/* finished OCTANE */
for( i = MIN(f_first, nfacets) - 1; i >= 0; --i )
{
SCIP_CALL( SCIPfreeSol(scip, &first_sols[i]) );
}
}
heurdata->lastrule = r;
if( *result == SCIP_FOUNDSOL )
++(heurdata->nsuccess);
/* free temporary memory */
SCIPfreeBufferArray(scip, &first_sols);
for( i = f_max; i >= 0; --i )
SCIPfreeBufferArray(scip, &facets[i]);
SCIPfreeBufferArray(scip, &facets);
SCIPfreeBufferArray(scip, &lambda);
SCIPfreeBufferArray(scip, &perm);
SCIPfreeBufferArray(scip, &sign);
SCIPfreeBufferArray(scip, &negquotient);
SCIPfreeBufferArray(scip, &raydirection);
SCIPfreeBufferArray(scip, &rayorigin);
SCIPfreeBufferArray(scip, &subspacevars);
SCIPfreeBufferArray(scip, &fracspace);
return SCIP_OKAY;
}
/** transforms given solution of the master problem into solution of the original problem
* @todo think about types of epsilons used in this method
*/
SCIP_RETCODE GCGrelaxTransformMastersolToOrigsol(
SCIP* scip, /**< SCIP data structure */
SCIP_SOL* mastersol, /**< solution of the master problem, or NULL for current LP solution */
SCIP_SOL** origsol /**< pointer to store the new created original problem's solution */
)
{
SCIP* masterprob;
int npricingprobs;
int* blocknrs;
SCIP_Real* blockvalue;
SCIP_Real increaseval;
SCIP_VAR** mastervars;
SCIP_Real* mastervals;
int nmastervars;
SCIP_VAR** vars;
int nvars;
SCIP_Real feastol;
int i;
int j;
assert(scip != NULL);
assert(origsol != NULL);
masterprob = GCGrelaxGetMasterprob(scip);
npricingprobs = GCGrelaxGetNPricingprobs(scip);
assert( !SCIPisInfinity(scip, SCIPgetSolOrigObj(masterprob, mastersol)) );
SCIP_CALL( SCIPcreateSol(scip, origsol, GCGrelaxGetProbingheur(scip)) );
SCIP_CALL( SCIPallocBufferArray(scip, &blockvalue, npricingprobs) );
SCIP_CALL( SCIPallocBufferArray(scip, &blocknrs, npricingprobs) );
/* get variables of the master problem and their solution values */
SCIP_CALL( SCIPgetVarsData(masterprob, &mastervars, &nmastervars, NULL, NULL, NULL, NULL) );
assert(mastervars != NULL);
assert(nmastervars >= 0);
SCIP_CALL( SCIPallocBufferArray(scip, &mastervals, nmastervars) );
SCIP_CALL( SCIPgetSolVals(masterprob, mastersol, nmastervars, mastervars, mastervals) );
/* initialize the block values for the pricing problems */
for( i = 0; i < npricingprobs; i++ )
{
blockvalue[i] = 0.0;
blocknrs[i] = 0;
}
/* loop over all given master variables */
for( i = 0; i < nmastervars; i++ )
{
SCIP_VAR** origvars;
int norigvars;
SCIP_Real* origvals;
SCIP_Bool isray;
int blocknr;
origvars = GCGmasterVarGetOrigvars(mastervars[i]);
norigvars = GCGmasterVarGetNOrigvars(mastervars[i]);
origvals = GCGmasterVarGetOrigvals(mastervars[i]);
blocknr = GCGvarGetBlock(mastervars[i]);
isray = GCGmasterVarIsRay(mastervars[i]);
assert(GCGvarIsMaster(mastervars[i]));
assert(!SCIPisFeasNegative(scip, mastervals[i]));
/** @todo handle infinite master solution values */
assert(!SCIPisInfinity(scip, mastervals[i]));
/* first of all, handle variables representing rays */
if( isray )
{
assert(blocknr >= 0);
/* we also want to take into account variables representing rays, that have a small value (between normal and feas eps),
* so we do no feas comparison here */
if( SCIPisPositive(scip, mastervals[i]) )
{
/* loop over all original variables contained in the current master variable */
for( j = 0; j < norigvars; j++ )
{
if( SCIPisZero(scip, origvals[j]) )
break;
assert(!SCIPisZero(scip, origvals[j]));
/* the original variable is a linking variable: just transfer the solution value of the direct copy (this is done later) */
if( GCGvarIsLinking(origvars[j]) )
continue;
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origvars[j]), origvals[j] * mastervals[i], SCIPvarGetName(mastervars[i]));
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origvars[j], origvals[j] * mastervals[i]) );
}
}
mastervals[i] = 0.0;
continue;
}
/* handle the variables with value >= 1 to get integral values in original solution */
while( SCIPisFeasGE(scip, mastervals[i], 1.0) )
{
/* variable was directly transferred to the master problem (only in linking conss or linking variable) */
/** @todo this may be the wrong place for this case, handle it before the while loop
* and remove the similar case in the next while loop */
if( blocknr == -1 )
{
assert(norigvars == 1);
assert(origvals[0] == 1.0);
/* increase the corresponding value */
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origvars[0]), origvals[0] * mastervals[i], SCIPvarGetName(mastervars[i]));
SCIP_CALL( SCIPincSolVal(scip, *origsol, origvars[0], origvals[0] * mastervals[i]) );
mastervals[i] = 0.0;
}
else
{
assert(blocknr >= 0);
/* loop over all original variables contained in the current master variable */
for( j = 0; j < norigvars; j++ )
{
SCIP_VAR* pricingvar;
int norigpricingvars;
SCIP_VAR** origpricingvars;
if( SCIPisZero(scip, origvals[j]) )
break;
assert(!SCIPisZero(scip, origvals[j]));
/* the original variable is a linking variable: just transfer the solution value of the direct copy (this is done above) */
if( GCGvarIsLinking(origvars[j]) )
continue;
pricingvar = GCGoriginalVarGetPricingVar(origvars[j]);
assert(GCGvarIsPricing(pricingvar));
norigpricingvars = GCGpricingVarGetNOrigvars(pricingvar);
origpricingvars = GCGpricingVarGetOrigvars(pricingvar);
/* just in case a variable has a value higher than the number of blocks, it represents */
if( norigpricingvars <= blocknrs[blocknr] )
{
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[norigpricingvars-1]), mastervals[i] * origvals[j], SCIPvarGetName(mastervars[i]));
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[norigpricingvars-1], mastervals[i] * origvals[j]) );
mastervals[i] = 1.0;
}
/* this should be default */
else
{
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[blocknrs[blocknr]]), origvals[j], SCIPvarGetName(mastervars[i]) );
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[blocknrs[blocknr]], origvals[j]) );
}
}
mastervals[i] = mastervals[i] - 1.0;
blocknrs[blocknr]++;
}
}
}
/* loop over all given master variables */
for( i = 0; i < nmastervars; i++ )
{
SCIP_VAR** origvars;
int norigvars;
SCIP_Real* origvals;
int blocknr;
origvars = GCGmasterVarGetOrigvars(mastervars[i]);
norigvars = GCGmasterVarGetNOrigvars(mastervars[i]);
origvals = GCGmasterVarGetOrigvals(mastervars[i]);
blocknr = GCGvarGetBlock(mastervars[i]);
if( SCIPisFeasZero(scip, mastervals[i]) )
{
continue;
}
assert(SCIPisFeasGE(scip, mastervals[i], 0.0) && SCIPisFeasLT(scip, mastervals[i], 1.0));
while( SCIPisFeasPositive(scip, mastervals[i]) )
{
assert(GCGvarIsMaster(mastervars[i]));
assert(!GCGmasterVarIsRay(mastervars[i]));
if( blocknr == -1 )
{
assert(norigvars == 1);
assert(origvals[0] == 1.0);
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origvars[0]), origvals[0] * mastervals[i], SCIPvarGetName(mastervars[i]) );
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origvars[0], origvals[0] * mastervals[i]) );
mastervals[i] = 0.0;
}
else
{
increaseval = MIN(mastervals[i], 1.0 - blockvalue[blocknr]);
/* loop over all original variables contained in the current master variable */
for( j = 0; j < norigvars; j++ )
{
SCIP_VAR* pricingvar;
int norigpricingvars;
SCIP_VAR** origpricingvars;
if( SCIPisZero(scip, origvals[j]) )
continue;
/* the original variable is a linking variable: just transfer the solution value of the direct copy (this is done above) */
if( GCGvarIsLinking(origvars[j]) )
continue;
pricingvar = GCGoriginalVarGetPricingVar(origvars[j]);
assert(GCGvarIsPricing(pricingvar));
norigpricingvars = GCGpricingVarGetNOrigvars(pricingvar);
origpricingvars = GCGpricingVarGetOrigvars(pricingvar);
if( norigpricingvars <= blocknrs[blocknr] )
{
increaseval = mastervals[i];
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[norigpricingvars-1]), origvals[j] * increaseval, SCIPvarGetName(mastervars[i]) );
/* increase the corresponding value */
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[norigpricingvars-1], origvals[j] * increaseval) );
}
else
{
/* increase the corresponding value */
SCIPdebugMessage("Increasing value of %s by %f because of %s\n", SCIPvarGetName(origpricingvars[blocknrs[blocknr]]), origvals[j] * increaseval, SCIPvarGetName(mastervars[i]) );
SCIP_CALL( SCIPincSolVal(scip, *origsol, origpricingvars[blocknrs[blocknr]], origvals[j] * increaseval) );
}
}
mastervals[i] = mastervals[i] - increaseval;
if( SCIPisFeasZero(scip, mastervals[i]) )
{
mastervals[i] = 0.0;
}
blockvalue[blocknr] += increaseval;
/* if the value assigned to the block is equal to 1, this block is full and we take the next block */
if( SCIPisFeasGE(scip, blockvalue[blocknr], 1.0) )
{
blockvalue[blocknr] = 0.0;
blocknrs[blocknr]++;
}
}
}
}
SCIPfreeBufferArray(scip, &mastervals);
SCIPfreeBufferArray(scip, &blocknrs);
SCIPfreeBufferArray(scip, &blockvalue);
/* if the solution violates one of its bounds by more than feastol
* and less than 10*feastol, round it and print a warning
*/
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
SCIP_CALL( SCIPgetRealParam(scip, "numerics/feastol", &feastol) );
for( i = 0; i < nvars; ++i )
{
SCIP_Real solval;
SCIP_Real lb;
SCIP_Real ub;
solval = SCIPgetSolVal(scip, *origsol, vars[i]);
lb = SCIPvarGetLbLocal(vars[i]);
ub = SCIPvarGetUbLocal(vars[i]);
if( SCIPisFeasGT(scip, solval, ub) && EPSEQ(solval, ub, 10 * feastol) )
{
SCIP_CALL( SCIPsetSolVal(scip, *origsol, vars[i], ub) );
SCIPwarningMessage(scip, "Variable %s rounded from %g to %g in relaxation solution\n",
SCIPvarGetName(vars[i]), solval, ub);
}
else if( SCIPisFeasLT(scip, solval, lb) && EPSEQ(solval, lb, 10 * feastol) )
{
SCIP_CALL( SCIPsetSolVal(scip, *origsol, vars[i], lb) );
SCIPwarningMessage(scip, "Variable %s rounded from %g to %g in relaxation solution\n",
SCIPvarGetName(vars[i]), solval, lb);
}
}
return SCIP_OKAY;
}
/** reads a given xml solution file */
static
SCIP_RETCODE readXMLSol(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< name of the input file */
)
{
SCIP_Bool unknownvariablemessage;
SCIP_SOL* sol;
SCIP_Bool error;
XML_NODE* start;
const XML_NODE* varsnode;
const XML_NODE* varnode;
const char* tag;
assert( scip != NULL );
assert( filename != NULL );
/* read xml file */
start = xmlProcess(filename);
if( start == NULL )
{
SCIPerrorMessage("Some error occured during parsing the XML solution file.\n");
return SCIP_READERROR;
}
/* create zero solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, NULL) );
error = FALSE;
/* find variable sections */
tag = "variables";
varsnode = xmlFindNodeMaxdepth(start, tag, 0, 3);
if( varsnode == NULL )
{
/* free xml data */
xmlFreeNode(start);
SCIPerrorMessage("Variable section not found.\n");
return SCIP_READERROR;
}
/* loop through all variables */
unknownvariablemessage = FALSE;
for( varnode = xmlFirstChild(varsnode); varnode != NULL; varnode = xmlNextSibl(varnode) )
{
SCIP_VAR* var;
const char* varname;
const char* varvalue;
SCIP_Real value;
int nread;
/* find variable name */
varname = xmlGetAttrval(varnode, "name");
if( varname == NULL )
{
SCIPerrorMessage("Attribute \"name\" of variable not found.\n");
error = TRUE;
break;
}
/* find the variable */
var = SCIPfindVar(scip, varname);
if( var == NULL )
{
if( !unknownvariablemessage )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "unknown variable <%s> of solution file <%s>\n",
varname, filename);
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, " (further unknown variables are ignored)\n");
unknownvariablemessage = TRUE;
}
continue;
}
/* find value of variable */
varvalue = xmlGetAttrval(varnode, "value");
if( varvalue == NULL )
{
SCIPerrorMessage("Attribute \"value\" of variable not found.\n");
error = TRUE;
break;
}
/* cast the value */
if( strncasecmp(varvalue, "inv", 3) == 0 )
continue;
else if( strncasecmp(varvalue, "+inf", 4) == 0 || strncasecmp(varvalue, "inf", 3) == 0 )
value = SCIPinfinity(scip);
else if( strncasecmp(varvalue, "-inf", 4) == 0 )
value = -SCIPinfinity(scip);
else
{
nread = sscanf(varvalue, "%lf", &value);
if( nread != 1 )
{
SCIPwarningMessage(scip, "invalid solution value <%s> for variable <%s> in XML solution file <%s>\n", varvalue, varname, filename);
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 );
}
}
}
if( !error )
{
SCIP_Bool stored;
/* 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",
filename, stored ? "accepted" : "rejected - solution is infeasible or objective too poor");
}
else
{
SCIP_CALL( SCIPaddSolFree(scip, &sol, &stored) );
/* display result */
SCIPverbMessage(scip, SCIP_VERBLEVEL_NORMAL, NULL, "primal solution from solution file <%s> was %s\n",
filename, stored ? "accepted as candidate, will be checked when solving starts" : "rejected - solution objective too poor");
}
}
else
{
/* free solution */
SCIP_CALL( SCIPfreeSol(scip, &sol) );
/* free xml data */
xmlFreeNode(start);
return SCIP_READERROR;
}
/* free xml data */
xmlFreeNode(start);
return SCIP_OKAY;
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecTrivial)
{ /*lint --e{715}*/
SCIP_VAR** vars;
SCIP_SOL* lbsol; /* solution where all variables are set to their lower bounds */
SCIP_SOL* ubsol; /* solution where all variables are set to their upper bounds */
SCIP_SOL* zerosol; /* solution where all variables are set to zero */
SCIP_SOL* locksol; /* solution where all variables are set to the bound with the fewer locks */
SCIP_Real large;
int nvars;
int nbinvars;
int i;
SCIP_Bool success;
SCIP_Bool zerovalid;
*result = SCIP_DIDNOTRUN;
if( SCIPgetNRuns(scip) > 1 )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
success = FALSE;
/* initialize data structure */
SCIP_CALL( SCIPcreateSol(scip, &lbsol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &ubsol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &zerosol, heur) );
SCIP_CALL( SCIPcreateSol(scip, &locksol, heur) );
/* determine large value to set variables to */
large = SCIPinfinity(scip);
if( !SCIPisInfinity(scip, 0.1 / SCIPfeastol(scip)) )
large = 0.1 / SCIPfeastol(scip);
SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, &nbinvars, NULL, NULL, NULL) );
/* if the problem is binary, we do not have to check the zero solution, since it is equal to the lower bound
* solution */
zerovalid = (nvars != nbinvars);
assert(vars != NULL || nvars == 0);
for( i = 0; i < nvars; i++ )
{
SCIP_Real lb;
SCIP_Real ub;
assert(vars != NULL); /* this assert is needed for flexelint */
lb = SCIPvarGetLbLocal(vars[i]);
ub = SCIPvarGetUbLocal(vars[i]);
/* if problem is obviously infeasible due to empty domain, stop */
if( SCIPisGT(scip, lb, ub) )
goto TERMINATE;
/* set bounds to sufficient large value */
if( SCIPisInfinity(scip, -lb) )
lb = MIN(-large, ub);
if( SCIPisInfinity(scip, ub) )
{
SCIP_Real tmp;
tmp = SCIPvarGetLbLocal(vars[i]);
ub = MAX(tmp, large);
}
SCIP_CALL( SCIPsetSolVal(scip, lbsol, vars[i], lb) );
SCIP_CALL( SCIPsetSolVal(scip, ubsol, vars[i], ub) );
/* try the zero vector, if it is in the bounds region */
if( zerovalid )
{
if( SCIPisLE(scip, lb, 0.0) && SCIPisLE(scip, 0.0, ub) )
{
SCIP_CALL( SCIPsetSolVal(scip, zerosol, vars[i], 0.0) );
}
else
zerovalid = FALSE;
}
/* set variables to the bound with fewer locks, if tie choose an average value */
if( SCIPvarGetNLocksDown(vars[i]) > SCIPvarGetNLocksUp(vars[i]) )
{
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], ub) );
}
else if( SCIPvarGetNLocksDown(vars[i]) < SCIPvarGetNLocksUp(vars[i]) )
{
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], lb) );
}
else
{
SCIP_Real solval;
solval = (lb+ub)/2.0;
/* if a tie occurs, roughly every third integer variable will be rounded up */
if( SCIPvarGetType(vars[i]) != SCIP_VARTYPE_CONTINUOUS )
solval = i % 3 == 0 ? SCIPceil(scip,solval) : SCIPfloor(scip,solval);
assert(SCIPisFeasLE(scip,SCIPvarGetLbLocal(vars[i]),solval) && SCIPisFeasLE(scip,solval,SCIPvarGetUbLocal(vars[i])));
SCIP_CALL( SCIPsetSolVal(scip, locksol, vars[i], solval) );
}
}
/* try lower bound solution */
SCIPdebugMessage("try lower bound solution\n");
SCIP_CALL( SCIPtrySol(scip, lbsol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible lower bound solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, lbsol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
/* try upper bound solution */
SCIPdebugMessage("try upper bound solution\n");
SCIP_CALL( SCIPtrySol(scip, ubsol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible upper bound solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, ubsol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
/* try zero solution */
if( zerovalid )
{
SCIPdebugMessage("try zero solution\n");
SCIP_CALL( SCIPtrySol(scip, zerosol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible zero solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, zerosol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
}
/* try lock solution */
SCIPdebugMessage("try lock solution\n");
SCIP_CALL( SCIPtrySol(scip, locksol, FALSE, FALSE, TRUE, TRUE, &success) );
if( success )
{
SCIPdebugMessage("found feasible lock solution:\n");
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, locksol, NULL, FALSE) ) );
*result = SCIP_FOUNDSOL;
}
TERMINATE:
/* free solutions */
SCIP_CALL( SCIPfreeSol(scip, &lbsol) );
SCIP_CALL( SCIPfreeSol(scip, &ubsol) );
SCIP_CALL( SCIPfreeSol(scip, &zerosol) );
SCIP_CALL( SCIPfreeSol(scip, &locksol) );
return SCIP_OKAY;
}
/** try one-opt on given solution */
static
SCIP_RETCODE tryOneOpt(
SCIP* scip, /**< SCIP data structure */
SCIP_HEUR* heur, /**< indicator heuristic */
SCIP_HEURDATA* heurdata, /**< heuristic data */
int nindconss, /**< number of indicator constraints */
SCIP_CONS** indconss, /**< indicator constraints */
SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
int* nfoundsols /**< number of solutions found */
)
{
SCIP_Bool cutoff;
SCIP_Bool lperror;
SCIP_Bool stored;
SCIP_SOL* sol;
int cnt = 0;
int i;
int c;
assert( scip != NULL );
assert( heur != NULL );
assert( heurdata != NULL );
assert( nindconss == 0 || indconss != NULL );
assert( solcand != NULL );
assert( nfoundsols != NULL );
SCIPdebugMessage("Performing one-opt ...\n");
*nfoundsols = 0;
SCIP_CALL( SCIPstartProbing(scip) );
for (i = 0; i < nindconss; ++i)
{
SCIP_VAR* binvar;
/* skip nonactive constraints */
if ( ! SCIPconsIsActive(indconss[i]) )
continue;
binvar = SCIPgetBinaryVarIndicator(indconss[i]);
assert( binvar != NULL );
/* skip constraints with fixed variables */
if ( SCIPvarGetUbLocal(binvar) < 0.5 || SCIPvarGetLbLocal(binvar) > 0.5 )
continue;
/* return if the we would exceed the depth limit of the tree */
if( SCIPgetDepthLimit(scip) <= SCIPgetDepth(scip) )
break;
/* get rid of all bound changes */
SCIP_CALL( SCIPnewProbingNode(scip) );
++cnt;
/* fix variables */
for (c = 0; c < nindconss; ++c)
{
SCIP_Bool s;
/* skip nonactive constraints */
if ( ! SCIPconsIsActive(indconss[c]) )
continue;
binvar = SCIPgetBinaryVarIndicator(indconss[c]);
assert( binvar != NULL );
/* fix variables according to solution candidate, except constraint i */
if ( c == i )
s = ! solcand[c];
else
s = solcand[c];
if ( ! s )
{
if ( SCIPvarGetLbLocal(binvar) < 0.5 && SCIPvarGetUbLocal(binvar) > 0.5 )
{
SCIP_CALL( SCIPchgVarLbProbing(scip, binvar, 1.0) );
}
}
else
{
if ( SCIPvarGetUbLocal(binvar) > 0.5 && SCIPvarGetLbLocal(binvar) < 0.5 )
{
SCIP_CALL( SCIPchgVarUbProbing(scip, binvar, 0.0) );
}
}
}
/* propagate variables */
SCIP_CALL( SCIPpropagateProbing(scip, -1, &cutoff, NULL) );
if ( cutoff )
{
SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
continue;
}
/* solve LP to move continuous variables */
SCIP_CALL( SCIPsolveProbingLP(scip, -1, &lperror, &cutoff) );
/* the LP often reaches the objective limit - we currently do not use such solutions */
if ( lperror || cutoff || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
{
#ifdef SCIP_DEBUG
if ( lperror )
SCIPdebugMessage("An LP error occured.\n");
#endif
SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
continue;
}
/* create solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, heur) );
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* check solution for feasibility */
SCIPdebugMessage("One-opt found solution candidate with value %g.\n", SCIPgetSolTransObj(scip, sol));
/* only check integrality, because we solved an LP */
SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, TRUE, FALSE, &stored) );
if ( stored )
++(*nfoundsols);
SCIP_CALL( SCIPbacktrackProbing(scip, 0) );
}
SCIP_CALL( SCIPendProbing(scip) );
SCIPdebugMessage("Finished one-opt (tried variables: %d, found sols: %d).\n", cnt, *nfoundsols);
return SCIP_OKAY;
}
/** try given solution */
static
SCIP_RETCODE trySolCandidate(
SCIP* scip, /**< SCIP data structure */
SCIP_HEUR* heur, /**< indicator heuristic */
SCIP_HEURDATA* heurdata, /**< heuristic data */
int nindconss, /**< number of indicator constraints */
SCIP_CONS** indconss, /**< indicator constraints */
SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
int* nfoundsols /**< number of solutions found */
)
{
SCIP_Bool cutoff;
SCIP_Bool lperror;
SCIP_Bool stored;
SCIP_SOL* sol;
int c;
assert( scip != NULL );
assert( heur != NULL );
assert( heurdata != NULL );
assert( nindconss == 0 || indconss != NULL );
assert( solcand != NULL );
assert( nfoundsols != NULL );
SCIPdebugMessage("Trying to generate feasible solution with indicators from solution candidate ...\n");
*nfoundsols = 0;
SCIP_CALL( SCIPstartProbing(scip) );
/* we can stop here if we have already reached the maximal depth */
if( SCIPgetDepthLimit(scip) <= SCIPgetDepth(scip) )
{
SCIP_CALL( SCIPendProbing(scip) );
return SCIP_OKAY;
}
SCIP_CALL( SCIPnewProbingNode(scip) );
/* fix variables */
for (c = 0; c < nindconss; ++c)
{
SCIP_VAR* binvar;
/* skip nonactive constraints */
if ( ! SCIPconsIsActive(indconss[c]) )
continue;
binvar = SCIPgetBinaryVarIndicator(indconss[c]);
assert( binvar != NULL );
/* Fix binary variables not in cover to 1 and corresponding slack variables to 0. The other binary variables are fixed to 0. */
if ( ! solcand[c] )
{
/* to be sure, check for non-fixed variables */
if ( SCIPvarGetLbLocal(binvar) < 0.5 && SCIPvarGetUbLocal(binvar) > 0.5 )
{
SCIP_CALL( SCIPchgVarLbProbing(scip, binvar, 1.0) );
}
}
else
{
if ( SCIPvarGetUbLocal(binvar) > 0.5 && SCIPvarGetLbLocal(binvar) < 0.5 )
{
SCIP_CALL( SCIPchgVarUbProbing(scip, binvar, 0.0) );
}
}
}
/* propagate variables */
SCIP_CALL( SCIPpropagateProbing(scip, -1, &cutoff, NULL) );
if ( cutoff )
{
SCIPdebugMessage("Solution candidate reaches cutoff (in propagation).\n");
SCIP_CALL( SCIPendProbing(scip) );
return SCIP_OKAY;
}
/* solve LP to move continuous variables */
SCIP_CALL( SCIPsolveProbingLP(scip, -1, &lperror, &cutoff) );
/* the LP often reaches the objective limit - we currently do not use such solutions */
if ( lperror || cutoff || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
{
#ifdef SCIP_DEBUG
if ( lperror )
SCIPdebugMessage("An LP error occured.\n");
else
SCIPdebugMessage("Solution candidate reaches cutoff (in LP solving).\n");
#endif
SCIP_CALL( SCIPendProbing(scip) );
return SCIP_OKAY;
}
/* create solution */
SCIP_CALL( SCIPcreateSol(scip, &sol, heur) );
/* copy the current LP solution to the working solution */
SCIP_CALL( SCIPlinkLPSol(scip, sol) );
/* check solution for feasibility */
#ifdef SCIP_DEBUG
SCIPdebugMessage("Found solution candidate with value %g.\n", SCIPgetSolTransObj(scip, sol));
#ifdef SCIP_MORE_DEBUG
SCIP_CALL( SCIPprintSol(scip, sol, NULL, FALSE) );
#endif
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, TRUE, TRUE, TRUE, &stored) );
if ( stored )
{
++(*nfoundsols);
SCIPdebugMessage("Solution is feasible and stored.\n");
}
else
SCIPdebugMessage("Solution was not stored.\n");
#else
/* only check integrality, because we solved an LP */
SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, TRUE, FALSE, &stored) );
if ( stored )
++(*nfoundsols);
#endif
SCIP_CALL( SCIPendProbing(scip) );
/* possibly perform one-opt */
if ( stored && heurdata->oneopt )
{
int nfound = 0;
assert( *nfoundsols > 0 );
SCIP_CALL( tryOneOpt(scip, heur, heurdata, nindconss, indconss, solcand, &nfound) );
}
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;
}
}
/** execution method of primal heuristic */
static
SCIP_DECL_HEUREXEC(heurExecForward)
{ /*lint --e{715}*/
SCIP_PROBDATA* probdata;
int n;
int p;
int ndep;
/* "_" means the matrix for blas */
SCIP_Real* y; /* [n] */
SCIP_Real* orig_X_; /* [n*p] */
SCIP_Real* orig_Q_; /* [p*p] <- (X^t) X */
SCIP_Real* orig_q; /* [p] <- (X^t) y */
SCIP_Real r;
int* Mdep; /* [ndep] */
int* groupX; /* [ndep*p] */
/* for forward selection */
int dim;
int* list; /* [p] */
SCIP_Real* a; /* [dim] */
SCIP_Real* a_old; /* [dim-1] */
SCIP_Real* a_new; /* [dim] */
SCIP_Real RSS; /* residual sum of square */
SCIP_Real RSS_new;
SCIP_Real AIC;
SCIP_Real AIC_new;
int ublb;
int *Branchz; /* [3*p] */
/*
* X: sub matrix of orig_X_
* Y: (X^t X)^-1
* X_new = (X, x_i);
* Z: (X_new ^t X_new)^-1
* = ( V v
v^t u )
*/
SCIP_Real* Xy; /* sub vector of orig_q */
SCIP_Real* X_;
SCIP_Real* Y_; /* [(dim-1)*(dim-1)] */
SCIP_Real* Z_; /* [dim*dim] */
SCIP_Real* W_; /* [dim*dim] */
SCIP_Real* V_; /* [(dim-1)*(dim-1)] */
SCIP_Real* v; /* [dim-1] */
SCIP_Real u;
SCIP_Real* b; /* [dim-1] */
SCIP_Real* c; /* [dim-1] */
SCIP_Real* d; /* [n] */
/* variables */
SCIP_VAR** var_a; /* [p] continuous variables */
SCIP_VAR** var_z; /* [p] 01 variables */
SCIP_VAR** var_ep; /* [n] continuous variables */
SCIP_VAR* var_rss; /* continuous variable, residual sum of squares */
SCIP_VAR* var_log; /* continuous variable, log(rss) */
/* set solution */
SCIP_Real *ep;
int nsols;
int store;
SCIP_SOL** sols;
SCIP_Real objval;
SCIP_SOL* sol;
SCIP_Real* solvals;
SCIP_Bool success;
int nvars = SCIPgetNVars(scip);
SCIP_VAR** vars;
int i,j,t,ct;
int memo;
assert(heur != NULL);
assert(scip != NULL);
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
assert(result != NULL);
#if MYPARA_LOG
printf("forward selection!\n");
#endif
/* get heuristic data */
/*
SCIP_HEURDATA* heurdata;
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
assert(lastsolindices != NULL);
*/
/* get values from probdata */
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
n = SCIPprobdataGetNdatas(probdata);
p = SCIPprobdataGetNexvars(probdata);
ndep = SCIPprobdataGetNdep(probdata);
y = SCIPprobdataGety(probdata);
orig_X_ = SCIPprobdataGetX(probdata);
orig_Q_ = SCIPprobdataGetQ(probdata);
orig_q = SCIPprobdataGetq(probdata);
r = SCIPprobdataGetr(probdata);
if( ndep ){
Mdep = SCIPprobdataGetMdep(probdata);
groupX = SCIPprobdataGetgroupX(probdata);
}else{
Mdep = NULL;
groupX = NULL;
}
/* variables */
var_a = SCIPprobdataGetVars_a(probdata);
var_z = SCIPprobdataGetVars_z(probdata);
var_ep = SCIPprobdataGetVars_ep(probdata);
var_rss = SCIPprobdataGetVar_rss(probdata);
var_log = SCIPprobdataGetVar_log(probdata);
/* get branching info */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &Branchz, 3*p));
GenerateZeroVecInt( 3*p, Branchz);
for(i=0; i<p; ++i){
ublb = SCIPround(scip, SCIPcomputeVarUbLocal(scip, var_z[i])
+ SCIPcomputeVarLbLocal(scip, var_z[i]));
*(Branchz+(ublb*p)+i) = 1;
}
#if MYPARA_LOG
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
#endif
if( ndep ){
for(i=0; i<ndep; i++){
memo = -1;
for(j=0; j<p; j++){
if( *(groupX+(i*p)+j)==1 ){
if( *(Branchz+j)==1 ) break;
if( *(Branchz+p+j)==1 ) memo=j;
if( j==Mdep[i] ){
if( memo==-1 ){
printf("error in heur_backward.c\n");
stop();
}
*(Branchz+p+memo) = 0;
*(Branchz+memo) = 1;
break;
}
}
}
}
}
#if MYPARA_LOG
printf("linear dependent\n");
if( ndep ){
for(i=0; i<3; i++){
for(j=0; j<p; j++){
printf("%d, ", *(Branchz+(i*p)+j));
}
newline();
}
}
#endif
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &X_, n*p));
SCIP_CALL( SCIPallocBufferArray(scip, &Xy, p));
SCIP_CALL( SCIPallocBufferArray(scip, &d, n));
SCIP_CALL( SCIPallocBufferArray(scip, &list, p));
/* initialize from Branchz */
#if MYPARA_LOG
printf("initialization\n");
#endif
GenerateZeroVecInt( p, list);
dim = 0;
memo = -1;
AIC = 1e+06;
SCIP_CALL( SCIPallocBufferArray(scip, &a_old, dim+1));
for(i=0; i<p; i++){
if( Branchz[i]==1 ){ /* if z_i is fixed to 0 */
list[i] = -1;
}else if( Branchz[p+i]==1 ){ /* if z_i is unfixed */
list[i] = 0;
}else if( Branchz[2*p+i]==1 ){ /* if z_i is fixed 1 */
dim++;
list[i] = dim;
if( dim == 1 ){
a_old[0] = orig_q[i] / mat_( orig_Q_, p, i, i);
RSS = RSSvalue( 1, a_old, &orig_q[i], r);
AIC = AICvalue( n, dim, RSS);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * i], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[i];
/* generate Y ( dim = 1 ) */
SCIP_CALL( SCIPallocBufferArray( scip, &Y_, dim*dim));
Y_[0] = 1 / mat_( orig_Q_, p, i, i);
}else{
/* alloc */
SCIPfreeBufferArray(scip, &a_old);
SCIP_CALL( SCIPallocBufferArray( scip, &a_old, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &b, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &c, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &v, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &V_, (dim-1)*(dim-1)));
SCIP_CALL( SCIPallocBufferArray( scip, &Z_, (dim)*(dim)));
/* 1. b <- X^t x_i */
dgemv_t( X_, n, dim-1, &orig_X_[n * i], b);
//printv( dim-1, b);
/* 2. c <- Y b */
dgemv_2( Y_, dim-1, dim-1, b, c);
//printv( dim-1, c);
/* 3. d <- - X c + x_i */
dgemv_1( X_, n, dim-1, c, &orig_X_[n * i], -1.0, 1.0, d);
//printv( n, d);
/* 4. u <- 1/<x_i, d> */
u = 1.0 / myddot_( &orig_X_[n * i], d, n);
//prints(u);
/* 5. v <- - u c */
mydscal_( c, dim-1, -u, v);
//printv( dim-1, v);
/* 6. V <- Y + u c c^t */
dger_1( Y_, c, c, dim-1, dim-1, u, V_);
//printM_( V_, dim-1, dim-1);
/* 7. Z */
/* V */
for(j=0; j<(dim-1); j++){
for(t=0; t<(dim-1); t++){
*(Z_ + j + (t*dim) ) = mat_( V_, dim-1, j, t);
}
}
/* v */
for(j=0; j<(dim-1); j++){
*(Z_ + dim-1 + (j*dim) ) = v[j];
*(Z_ + j + ((dim-1)*dim)) = v[j];
}
/* u */
*(Z_ + dim-1 + ((dim-1)*dim)) = u;
//printM_( Z_, dim, dim);
/* 8. a_old <- Z (Xy) */
Xy[dim-1] = orig_q[i];
dgemv_2( Z_, dim, dim, Xy, a_old);
//printv( dim, a_old);
RSS = RSSvalue( dim, a_old, Xy, r);
AIC = AICvalue( n, dim, RSS);
/* copy */
SCIPfreeBufferArray(scip, &Y_);
SCIP_CALL( SCIPallocBufferArray(scip, &Y_, dim*dim));
mydcopy_( Z_, Y_, dim*dim);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * i], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[i];
/* free */
SCIPfreeBufferArray(scip, &b);
SCIPfreeBufferArray(scip, &c);
SCIPfreeBufferArray(scip, &v);
SCIPfreeBufferArray(scip, &V_);
SCIPfreeBufferArray(scip, &Z_);
}
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", i, AIC);
#endif
}else{
printf("error:heur_forward.c\n");
stop();
}
}
if( dim == 0 ){
#if MYPARA_LOG
printf("[dim:0]\n");
#endif
dim++;
RSS = 1e+06;
for(i=0; i<p; i++){
if( list[i] == 0 ){
a_old[0] = orig_q[i] / mat_( orig_Q_, p, i, i);
RSS_new = RSSvalue( 1, a_old, &orig_q[i], r);
if( RSS_new < RSS ){
RSS = RSS_new;
memo = i;
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
}
if( memo < 0 || memo >= p ){
printf("error in heur_forward.c\n");
stop();
}
AIC = AICvalue( n, dim, RSS);
list[memo] = dim;
/* update X_ and Xy */
mydcopy_( &orig_X_[n * memo], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[memo];
/* generate Y ( dim = 1 ) */
SCIP_CALL( SCIPallocBufferArray( scip, &Y_, dim*dim));
Y_[0] = 1 / mat_( orig_Q_, p, memo, memo);
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", memo, AIC);
#endif
} /* if ( dim==0 ) */
while(1){
dim++;
memo = -1;
RSS = 1e+06;
#if MYPARA_LOG
printf("(dim=%d) ", dim);
Longline();
#endif
/* alloc */
SCIP_CALL( SCIPallocBufferArray( scip, &a_new, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &a, dim));
SCIP_CALL( SCIPallocBufferArray( scip, &b, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &c, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &v, dim-1));
SCIP_CALL( SCIPallocBufferArray( scip, &V_, (dim-1)*(dim-1)));
SCIP_CALL( SCIPallocBufferArray( scip, &Z_, (dim)*(dim)));
SCIP_CALL( SCIPallocBufferArray( scip, &W_, (dim)*(dim)));
for(i=0; i<p; i++){
/*
* 1. b <- X^t x_i
* 2. c <- Y b
* 3. d <- - X c + x_i
* 4. u <- 1 / <x_i, d>
* 5. v <- - u c
* 6. V <- Y + u c c^t
* 7. Z <- ( V v
v^t u )
* 8. a_new <- Z (Xy)
*/
if( list[i]==0 ){
/* 1. b <- X^t x_i */
dgemv_t( X_, n, dim-1, &orig_X_[n * i], b);
//printv( dim-1, b);
/* 2. c <- Y b */
dgemv_2( Y_, dim-1, dim-1, b, c);
//printv( dim-1, c);
/* 3. d <- - X c + x_i */
dgemv_1( X_, n, dim-1, c, &orig_X_[n * i], -1.0, 1.0, d);
//printv( n, d);
/* 4. u <- 1/<x_i, d> */
u = 1.0 / myddot_( &orig_X_[n * i], d, n);
//prints(u);
/* 5. v <- - u c */
mydscal_( c, dim-1, -u, v);
//printv( dim-1, v);
/* 6. V <- Y + u c c^t */
dger_1( Y_, c, c, dim-1, dim-1, u, V_);
//printM_( V_, dim-1, dim-1);
/* 7. Z */
/* V */
for(j=0; j<(dim-1); j++){
for(t=0; t<(dim-1); t++){
*(Z_ + j + (t*dim) ) = mat_( V_, dim-1, j, t);
}
}
/* v */
for(j=0; j<(dim-1); j++){
*(Z_ + dim-1 + (j*dim) ) = v[j];
*(Z_ + j + ((dim-1)*dim)) = v[j];
}
/* u */
*(Z_ + dim-1 + ((dim-1)*dim)) = u;
//printM_( Z_, dim, dim);
/* 8. a_new <- Z (Xy) */
Xy[dim-1] = orig_q[i];
dgemv_2( Z_, dim, dim, Xy, a_new);
//printv( dim, a_new);
/* test */
RSS_new = RSSvalue( dim, a_new, Xy, r);
if( RSS_new < RSS ){
RSS = RSS_new;
memo = i;
mydcopy_( Z_, W_, dim*dim);
mydcopy_( a_new, a, dim);
}
#if MYPARA_LOG
printf("%d: RSS = %f\n", i, RSS_new);
#endif
}
}
if( memo < 0 || memo >= p ){
if( memo == -1 ){
for(i=0; i<p; i++){
if( list[i] == 0 ){
memo = i;
break;
}
}
if( memo != -1 ){
printf("error in heur_forward.c\n");
stop();
}
}else{
printf("error in heur_forward.c\n");
stop();
}
}
AIC_new = AICvalue( n, dim, RSS);
if( AIC_new < AIC ){
AIC = AIC_new;
list[memo] = dim;
#if MYPARA_LOG
printf("---> %dth variable, AIC:%f\n", memo, AIC);
#endif
/* copy and free */
SCIPfreeBufferArray(scip, &Y_);
SCIP_CALL( SCIPallocBufferArray(scip, &Y_, dim*dim));
mydcopy_( W_, Y_, dim*dim);
SCIPfreeBufferArray(scip, &a_old);
SCIP_CALL( SCIPallocBufferArray(scip, &a_old, dim));
mydcopy_( a, a_old, dim);
/* update X_ and Xy */
mydcopy_( &orig_X_[n * memo], &X_[n * (dim-1)], n);
Xy[dim-1] = orig_q[memo];
}else{
memo = -1;
SCIPfreeBufferArray(scip, Y_);
#if MYPARA_LOG
printf("--> no selection, (AIC:%f)\n", AIC_new);
#endif
}
/* free */
SCIPfreeBufferArray(scip, &a_new);
SCIPfreeBufferArray(scip, &a);
SCIPfreeBufferArray(scip, &b);
SCIPfreeBufferArray(scip, &c);
SCIPfreeBufferArray(scip, &v);
SCIPfreeBufferArray(scip, &V_);
SCIPfreeBufferArray(scip, &Z_);
SCIPfreeBufferArray(scip, &W_);
if( memo == -1 ){
dim--;
break;
}
}
nsols = SCIPgetNSols(scip);
if( nsols < MP_NUM_SOL ){
store = 1;
}else{
sols = SCIPgetSols(scip);
objval = AIC;
nsols = MP_NUM_SOL;
if( objval < SCIPgetSolOrigObj(scip,sols[nsols-1]) ){
store = 1;
}else{
store = 0;
}
}
if( store ){
/* generate solution */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &ep, n));
dgemv_1( X_, n, dim, a_old, y, -1.0, 1.0, ep);
/* set solution */
/* alloc */
SCIP_CALL( SCIPallocBufferArray(scip, &solvals, nvars));
SCIP_CALL( SCIPallocBufferArray(scip, &vars, nvars));
ct=0;
/* a */
for(i=0; i<p; ++i){
vars[ct] = var_a[i];
if( list[i] > 0 ){
solvals[ct] = a_old[list[i]-1];
}else{
solvals[ct] = 0.0;
}
ct++;
}
/* z */
for(i=0; i<p; i++){
vars[ct] = var_z[i];
if( list[i] > 0 ){
solvals[ct] = 1.0;
}else{
solvals[ct] = 0.0;
}
ct++;
}
/* ep */
for(i=0; i<n; ++i){
vars[ct] = var_ep[i];
solvals[ct] = ep[i];
ct++;
}
vars[ct] = var_rss;
solvals[ct] = myddot_( ep, ep, n);
ct++;
vars[ct] = var_log;
solvals[ct] = log(myddot_( ep, ep, n));
ct++;
if( ct!=nvars ){
SCIPerrorMessage("It is unexpected error in set sol,");
printf("( ct, nvars) = ( %d, %d)", ct, nvars);
stop();
}
SCIP_CALL( SCIPcreateSol(scip, &sol, heur));
SCIP_CALL( SCIPsetSolVals(scip, sol, nvars, vars, solvals));
SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, FALSE, TRUE, TRUE, &success));
/* free */
SCIPfreeBufferArray(scip, &ep);
SCIPfreeBufferArray(scip, &solvals);
SCIPfreeBufferArray(scip, &vars);
}
/* free */
SCIPfreeBufferArray(scip, &d);
SCIPfreeBufferArray(scip, &X_);
SCIPfreeBufferArray(scip, &Xy);
SCIPfreeBufferArray(scip, &a_old);
SCIPfreeBufferArray(scip, &list);
SCIPfreeBufferArray(scip, &Branchz);
*result = SCIP_FOUNDSOL;
return SCIP_OKAY;
}
