51 #include "objscip/objscip.h"
52 #include "scip/cons_linear.h"
60 SCIP_Bool hybridascent_
61 ) :scip_(scip), stabcenterconsvals((SCIP_Real*) NULL), stabcenterconsvalssize(0), nstabcenterconsvals(0),
62 stabcentercutvals((SCIP_Real*) NULL), stabcentercutvalssize(0), nstabcentercutvals(0),
63 stabcenterlinkingconsvals((SCIP_Real*) NULL), nstabcenterlinkingconsvals(0), stabcenterlinkingconsvalssize(0),
64 stabcenterconv((SCIP_Real*) NULL), nstabcenterconv(0), dualdiffnorm(0.0),
65 subgradientconsvals(NULL), subgradientconsvalssize(0), nsubgradientconsvals(0),
66 subgradientcutvals(NULL), subgradientcutvalssize(0), nsubgradientcutvals(0),
67 subgradientlinkingconsvals(NULL),
68 subgradientnorm(0.0), hybridfactor(0.0),
69 pricingtype(pricingtype_), alpha(0.8), alphabar(0.8), hybridascent(hybridascent_), beta(0.0), nodenr(-1), k(0), t(0), hasstabilitycenter(FALSE),stabcenterbound(-SCIPinfinity(scip)),
70 inmispricingschedule(FALSE), subgradientproduct(0.0)
77 SCIPfreeBlockMemoryArrayNull(scip_, &stabcenterconsvals, stabcenterconsvalssize);
78 SCIPfreeBlockMemoryArrayNull(scip_, &stabcentercutvals, stabcentercutvalssize);
79 SCIPfreeBlockMemoryArrayNull(scip_, &stabcenterlinkingconsvals, stabcenterlinkingconsvalssize);
80 SCIPfreeBlockMemoryArrayNull(scip_, &subgradientconsvals, subgradientconsvalssize);
81 SCIPfreeBlockMemoryArrayNull(scip_, &subgradientcutvals, subgradientcutvalssize);
82 SCIPfreeBlockMemoryArrayNull(scip_, &subgradientlinkingconsvals, subgradientlinkingconsvalssize);
83 SCIPfreeBlockMemoryArrayNull(scip_, &stabcenterconv, nstabcenterconv);
85 stabcenterconsvals = (SCIP_Real*) NULL;
86 stabcentercutvals = (SCIP_Real*) NULL;
87 stabcenterlinkingconsvals = (SCIP_Real*) NULL;
88 stabcenterconv = (SCIP_Real*) NULL;
95 SCIP_RETCODE Stabilization::updateStabcenterconsvals()
100 if( nconss == nstabcenterconsvals )
105 if( nconss > stabcenterconsvalssize )
107 int oldsize = stabcenterconsvalssize;
108 stabcenterconsvalssize = SCIPcalcMemGrowSize(scip_, nconss);
109 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &stabcenterconsvals, oldsize, stabcenterconsvalssize) );
111 assert(stabcenterconsvals != NULL);
112 BMSclearMemoryArray(&stabcenterconsvals[nstabcenterconsvals], (
size_t)nconss-nstabcenterconsvals);
114 nstabcenterconsvals = nconss;
119 SCIP_RETCODE Stabilization::updateStabcentercutvals()
123 if( ncuts == nstabcentercutvals )
128 if( ncuts > stabcentercutvalssize )
130 int oldsize = stabcentercutvalssize;
131 stabcentercutvalssize = SCIPcalcMemGrowSize(scip_, ncuts);
132 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &stabcentercutvals, oldsize, stabcentercutvalssize) );
134 assert(stabcentercutvals != NULL);
135 BMSclearMemoryArray(&stabcentercutvals[nstabcentercutvals], (
size_t)ncuts-nstabcentercutvals);
137 nstabcentercutvals = ncuts;
142 SCIP_RETCODE Stabilization::updateSubgradientconsvals()
147 if( nconss == nsubgradientconsvals )
152 if( nconss > subgradientconsvalssize )
154 int oldsize = subgradientconsvalssize;
155 subgradientconsvalssize = SCIPcalcMemGrowSize(scip_, nconss);
156 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &subgradientconsvals, oldsize, subgradientconsvalssize) );
158 assert(subgradientconsvals != NULL);
159 BMSclearMemoryArray(&subgradientconsvals[nsubgradientconsvals], (
size_t)nconss-nsubgradientconsvals);
161 nsubgradientconsvals = nconss;
166 SCIP_RETCODE Stabilization::updateSubgradientcutvals()
170 if( ncuts == nsubgradientcutvals )
175 if( ncuts > subgradientcutvalssize )
177 int oldsize = subgradientcutvalssize;
178 subgradientcutvalssize = SCIPcalcMemGrowSize(scip_, ncuts);
179 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &subgradientcutvals, oldsize, subgradientcutvalssize) );
181 assert(subgradientcutvals != NULL);
182 BMSclearMemoryArray(&subgradientcutvals[nsubgradientcutvals], (
size_t)ncuts-nsubgradientcutvals);
184 nsubgradientcutvals = ncuts;
194 if( nlinkingconssnew > stabcenterlinkingconsvalssize)
196 int newsize = SCIPcalcMemGrowSize(scip_, nlinkingconssnew);
197 SCIP_CALL(SCIPreallocBlockMemoryArray(scip_, &stabcenterlinkingconsvals, stabcenterlinkingconsvalssize, newsize));
202 SCIP_CALL( SCIPreallocBlockMemoryArray(scip_, &subgradientlinkingconsvals, stabcenterlinkingconsvalssize,
204 BMSclearMemoryArray(subgradientlinkingconsvals, nlinkingconssnew);
206 stabcenterlinkingconsvalssize = newsize;
209 nstabcenterlinkingconsvals = nlinkingconssnew;
210 BMSclearMemoryArray(stabcenterlinkingconsvals, nstabcenterlinkingconsvals);
220 SCIPfreeBlockMemoryArrayNull(scip_, &stabcenterconv, nstabcenterconv);
221 SCIP_CALL( SCIPallocBlockMemoryArray(scip_, &stabcenterconv, nconvconssnew) );
223 nstabcenterconv = nconvconssnew;
224 BMSclearMemoryArray(stabcenterconv, nstabcenterconv);
234 SCIP_Real subgradient = 0.0;
236 assert(i < nstabcenterlinkingconsvals);
238 assert(stabcenterlinkingconsvals != NULL);
242 if( hybridascent && hasstabilitycenter )
243 subgradient = subgradientlinkingconsvals[i];
245 return computeDual(stabcenterlinkingconsvals[i], pricingtype->
consGetDual(scip_, cons), subgradient, 0.0, 0.0);
254 SCIP_Real subgradient = 0.0;
259 assert(dual != NULL);
263 if( i >= nstabcenterconsvals )
264 SCIP_CALL( updateStabcenterconsvals() );
266 assert(i < nstabcenterconsvals);
267 assert(stabcenterconsvals != NULL);
269 if( i >= nsubgradientconsvals && hybridascent )
270 SCIP_CALL( updateSubgradientconsvals() );
272 if( hybridascent && hasstabilitycenter )
273 subgradient = subgradientconsvals[i];
275 *dual = computeDual(stabcenterconsvals[i], pricingtype->
consGetDual(scip_, cons), subgradient, SCIPgetLhsLinear(scip_, cons), SCIPgetRhsLinear(scip_, cons));
289 assert(dual != NULL);
292 SCIP_Real subgradient = 0.0;
294 if( i >= nstabcentercutvals )
295 SCIP_CALL( updateStabcentercutvals() );
297 assert(i < nstabcentercutvals);
298 assert(stabcentercutvals != NULL);
300 if( i >= nsubgradientcutvals && hybridascent )
301 SCIP_CALL( updateSubgradientcutvals() );
303 if( hybridascent && hasstabilitycenter )
305 assert(subgradientcutvals != NULL);
306 subgradient = subgradientcutvals[i];
309 *dual = computeDual(stabcentercutvals[i], pricingtype->
rowGetDual(row), subgradient, SCIProwGetLhs(row), SCIProwGetRhs(row));
320 assert(i < nstabcenterconv);
322 assert(stabcenterconv != NULL);
325 SCIP_Real subgradient = 0.0;
331 SCIP_Real lowerbound,
332 SCIP_Real* dualsolconv,
336 assert(dualsolconv != NULL);
337 SCIPdebugMessage(
"Updating stability center: ");
340 if( SCIPisLE(scip_, lowerbound, stabcenterbound) && hasstabilitycenter )
342 SCIPdebugPrintf(
"no bound increase: %g <= %g\n", lowerbound, SCIPnodeGetLowerbound(SCIPgetCurrentNode(scip_)));
346 SCIPdebugPrintf(
"bound increase: %g > %g\n", lowerbound, SCIPnodeGetLowerbound(SCIPgetCurrentNode(scip_)));
349 SCIP_CALL( updateStabcenterconsvals() );
350 SCIP_CALL( updateStabcentercutvals() );
354 SCIP_CALL( updateSubgradientconsvals() );
355 SCIP_CALL( updateSubgradientcutvals() );
366 assert(nconss <= nstabcenterconsvals);
367 assert(ncuts <= nstabcentercutvals);
369 for(
int i = 0; i < nconss; ++i )
371 SCIP_CALL(
consGetDual(i, &stabcenterconsvals[i]) );
374 for(
int i = 0; i < ncuts; ++i )
376 SCIP_CALL(
rowGetDual(i, &stabcentercutvals[i]) );
379 for(
int i = 0; i < nstabcenterlinkingconsvals; ++i)
384 for(
int i = 0; i < nprobs; ++i )
388 stabcenterconv[i] = dualsolconv[i];
392 calculateSubgradient(pricingcols);
394 hasstabilitycenter = TRUE;
395 stabcenterbound = lowerbound;
400 SCIP_Real Stabilization::computeDual(
403 SCIP_Real subgradient,
408 SCIP_Real usedalpha = alpha;
409 SCIP_Real usedbeta = beta;
411 if ( inmispricingschedule )
413 usedalpha = alphabar;
417 if( hasstabilitycenter && (SCIPisZero(scip_, usedbeta) || SCIPisZero(scip_, usedalpha)) )
418 return usedalpha*center+(1.0-usedalpha)*current;
419 else if( hasstabilitycenter && SCIPisPositive(scip_, usedbeta) )
421 SCIP_Real dual = center + hybridfactor * (beta * (center + subgradient * dualdiffnorm / subgradientnorm) + (1.0 - beta) * current - center);
424 if( SCIPisInfinity(scip_, rhs) )
425 dual = MAX(dual, 0.0);
426 else if( SCIPisInfinity(scip_, -lhs) )
427 dual = MIN(dual, 0.0);
435 void Stabilization::updateIterationCount()
440 void Stabilization::updateIterationCountMispricing()
447 if( nodenr != SCIPnodeGetNumber(SCIPgetCurrentNode(scip_)) )
449 nodenr = SCIPnodeGetNumber(SCIPgetCurrentNode(scip_));
453 hasstabilitycenter = FALSE;
454 stabcenterbound = -SCIPinfinity(scip_);
455 inmispricingschedule = FALSE;
462 if( hasstabilitycenter && hybridascent && !inmispricingschedule )
465 SCIP_CALL( updateStabcenterconsvals() );
466 SCIP_CALL( updateStabcentercutvals() );
468 SCIP_CALL( updateSubgradientconsvals() );
469 SCIP_CALL( updateSubgradientcutvals() );
471 if( SCIPisPositive(scip_, alpha) )
473 calculateDualdiffnorm();
475 calculateHybridFactor();
484 SCIPdebugMessage(
"Alphabar update after mispricing\n");
485 updateIterationCountMispricing();
486 alphabar = MAX(0.0, 1-k*(1-alpha));
487 SCIPdebugMessage(
"alphabar updated to %g in mispricing iteration k=%d and node pricing iteration t=%d \n", alphabar, k, t);
492 SCIPdebugMessage(
"Alpha update after successful pricing\n");
493 updateIterationCount();
498 if( SCIPisNegative(scip_, subgradientproduct) )
509 void Stabilization::increaseAlpha()
512 alpha = MIN(0.9, alpha+(1-alpha)*0.1);
514 SCIPdebugMessage(
"alpha increased to %g\n", alpha);
517 void Stabilization::decreaseAlpha()
519 alpha = MAX(0.0, alpha-0.1);
521 SCIPdebugMessage(
"alpha decreased to %g\n", alpha);
524 SCIP_Real Stabilization::calculateSubgradientProduct(
536 assert(nconss <= nstabcenterconsvals);
540 assert(ncuts <= nstabcentercutvals);
542 SCIP_Real gradientproduct = 0.0;
545 for(
int i = 0; i < nconss; ++i )
552 SCIP_CONS* origcons = origmasterconss[i];
554 SCIP_CALL( SCIPallocBufferArray(origprob, &vars, nvars) );
555 SCIP_CALL( SCIPallocBufferArray(origprob, &vals, nvars) );
559 SCIP_Real dual = pricingtype->
consGetDual(scip_, masterconss[i]);
564 assert(!SCIPisInfinity(scip_, ABS(dual)));
566 if( SCIPisFeasPositive(scip_, stabdual) )
570 else if( SCIPisFeasNegative(scip_, stabdual) )
576 SCIPfreeBufferArray(origprob, &vals);
577 SCIPfreeBufferArray(origprob, &vars);
581 for(
int j = 0; j < nvars; ++j )
589 val = SCIPgetSolVal(scip_, (SCIP_SOL*) NULL, mastervar);
590 assert( !SCIPisInfinity(scip_, val) );
598 assert(pricingcols[block] != NULL);
603 assert(pricingprob != NULL);
605 assert(!SCIPisInfinity(scip_, ABS(val)));
607 assert(stabcenterconsvals != NULL);
608 assert(vals != NULL);
609 gradientproduct -= (dual - stabcenterconsvals[i]) * vals[j] * val;
612 assert(stabcenterconsvals != NULL);
613 assert(!SCIPisInfinity(scip_, ABS(lhs)));
615 gradientproduct += (dual - stabcenterconsvals[i]) * lhs;
616 SCIPfreeBufferArray(origprob, &vals);
617 SCIPfreeBufferArray(origprob, &vars);
621 for(
int i = 0; i < ncuts; ++i )
628 SCIP_ROW* origcut = origmastercuts[i];
629 nvars = SCIProwGetNNonz(origcut);
630 cols = SCIProwGetCols(origcut);
631 vals = SCIProwGetVals(origcut);
633 SCIP_Real dual = pricingtype->
rowGetDual(mastercuts[i]);
634 assert(!SCIPisInfinity(scip_, ABS(dual)));
640 if( SCIPisFeasGT(scip_, stabdual, 0.0) )
642 lhs = SCIProwGetLhs(origcut);
644 else if( SCIPisFeasLT(scip_, stabdual, 0.0) )
646 lhs = SCIProwGetRhs(origcut);
652 for(
int j = 0; j < nvars; ++j )
655 SCIP_VAR* var = SCIPcolGetVar(cols[j]);
663 val = SCIPgetSolVal(scip_, (SCIP_SOL*) NULL, mastervar);
664 assert(!SCIPisInfinity(scip_, ABS(val)));
673 assert(pricingcols[block] != NULL);
678 assert(pricingprob != NULL);
680 assert(!SCIPisInfinity(scip_, ABS(val)));
682 assert(stabcentercutvals != NULL);
683 assert(vals != NULL);
684 gradientproduct -= (dual - stabcentercutvals[i]) * vals[j] * val;
687 assert(!SCIPisInfinity(scip_, ABS(lhs)));
688 assert(stabcentercutvals != NULL);
690 gradientproduct += (dual - stabcentercutvals[i]) * lhs;
694 for(
int i = 0; i < nlinkingconss; ++i )
697 SCIP_VAR* pricingvar;
698 SCIP_CONS* linkingcons = linkingconss[i];
699 int block = linkingconsblocks[i];
700 mastervar = SCIPgetVarsLinear(scip_, linkingcons)[0];
706 assert(pricingprob != NULL);
708 assert(stabcenterlinkingconsvals != NULL);
709 SCIP_Real dual = pricingtype->
consGetDual(scip_, linkingcons) - stabcenterlinkingconsvals[i];
713 if( SCIPisFeasZero(origprob, stabdual) )
716 assert(pricingcols[block] != NULL);
718 SCIP_Real masterval = SCIPgetSolVal(scip_, (SCIP_SOL*) NULL, mastervar);
719 SCIP_Real pricingval =
GCGcolGetSolVal(pricingprob, pricingcols[block], pricingvar);
720 assert(!SCIPisInfinity(scip_, ABS(masterval)));
721 assert(!SCIPisInfinity(scip_, ABS(pricingval)));
722 assert(!SCIPisInfinity(scip_, ABS(dual)));
723 gradientproduct -= dual * (masterval - pricingval);
726 SCIPdebugMessage(
"Update gradient product with value %g.\n", gradientproduct);
728 return gradientproduct;
732 void Stabilization::calculateSubgradient(
744 assert(nconss <= nstabcenterconsvals);
747 assert(ncuts <= nstabcentercutvals);
749 subgradientnorm = 0.0;
752 for(
int i = 0; i < nconss; ++i )
758 SCIP_Real infeasibility;
760 SCIP_CONS* origcons = origmasterconss[i];
762 SCIPallocBufferArray(origprob, &vars, nvars);
763 SCIPallocBufferArray(origprob, &vals, nvars);
767 SCIP_Real dual = stabcenterconsvals[i];
768 assert(!SCIPisInfinity(scip_, ABS(dual)));
772 for(
int j = 0; j < nvars; ++j )
780 val = SCIPgetSolVal(scip_, (SCIP_SOL*) NULL, mastervar);
781 assert( !SCIPisInfinity(scip_, val) );
789 assert(pricingcols[block] != NULL);
794 assert(pricingprob != NULL);
796 assert(!SCIPisInfinity(scip_, ABS(val)));
798 assert(vals != NULL);
799 activity += vals[j] * val;
804 if( SCIPisFeasPositive(scip_, dual) )
806 infeasibility =
GCGconsGetLhs(origprob, origcons) - activity;
808 else if( SCIPisFeasNegative(scip_, dual) )
810 infeasibility =
GCGconsGetRhs(origprob, origcons) - activity;
813 assert(subgradientconsvals != NULL);
814 assert(!SCIPisInfinity(scip_, SQR(infeasibility)));
816 subgradientconsvals[i] = infeasibility;
818 if( SCIPisPositive(scip_, SQR(infeasibility)) )
819 subgradientnorm += SQR(infeasibility);
821 SCIPfreeBufferArray(origprob, &vals);
822 SCIPfreeBufferArray(origprob, &vars);
826 for(
int i = 0; i < ncuts; ++i )
832 SCIP_Real infeasibility;
834 SCIP_ROW* origcut = origmastercuts[i];
835 nvars = SCIProwGetNNonz(origcut);
836 cols = SCIProwGetCols(origcut);
837 vals = SCIProwGetVals(origcut);
841 SCIP_Real dual = stabcentercutvals[i];
842 assert(!SCIPisInfinity(scip_, ABS(dual)));
843 for(
int j = 0; j < nvars; ++j )
846 SCIP_VAR* var = SCIPcolGetVar(cols[j]);
854 val = SCIPgetSolVal(scip_, (SCIP_SOL*) NULL, mastervar);
855 assert(!SCIPisInfinity(scip_, ABS(val)));
864 assert(pricingcols[block] != NULL);
869 assert(pricingprob != NULL);
871 assert(!SCIPisInfinity(scip_, ABS(val)));
873 assert(stabcentercutvals != NULL);
874 assert(vals != NULL);
875 activity += vals[j] * val;
880 if( SCIPisFeasPositive(scip_, dual) )
882 infeasibility = SCIProwGetLhs(origcut) - activity;
884 else if( SCIPisFeasNegative(scip_, dual) )
886 infeasibility = SCIProwGetRhs(origcut) - activity;
889 assert(subgradientcutvals != NULL);
890 assert(!SCIPisInfinity(scip_, SQR(infeasibility)));
892 subgradientcutvals[i] = infeasibility;
894 if( SCIPisPositive(scip_, SQR(infeasibility)) )
895 subgradientnorm += SQR(infeasibility);
899 for(
int i = 0; i < nlinkingconss; ++i )
902 SCIP_VAR* pricingvar;
903 SCIP_CONS* linkingcons = linkingconss[i];
904 int block = linkingconsblocks[i];
906 SCIP_Real infeasibility;
907 mastervar = SCIPgetVarsLinear(scip_, linkingcons)[0];
913 assert(pricingprob != NULL);
915 assert(pricingcols[block] != NULL);
917 assert(stabcenterlinkingconsvals != NULL);
918 SCIP_Real masterval = SCIPgetSolVal(scip_, (SCIP_SOL*) NULL, mastervar);
919 SCIP_Real pricingval =
GCGcolGetSolVal(pricingprob, pricingcols[block], pricingvar);
920 assert(!SCIPisInfinity(scip_, ABS(masterval)));
921 assert(!SCIPisInfinity(scip_, ABS(pricingval)));
922 activity = (masterval - pricingval);
924 infeasibility = activity;
926 assert(subgradientlinkingconsvals != NULL);
927 assert(!SCIPisInfinity(scip_, SQR(infeasibility)));
929 subgradientlinkingconsvals[i] = infeasibility;
931 if( SCIPisPositive(scip_, SQR(infeasibility)) )
932 subgradientnorm += SQR(infeasibility);
936 assert(!SCIPisNegative(scip_, subgradientnorm));
938 subgradientnorm = SQRT(subgradientnorm);
940 SCIPdebugMessage(
"Update subgradient and subgradientnorm with value %g.\n", subgradientnorm);
944 void Stabilization::calculateDualdiffnorm()
952 assert(nconss <= nstabcenterconsvals);
955 assert(ncuts <= nstabcentercutvals);
960 assert(stabcenterconsvals != NULL);
962 for(
int i = 0; i < nconss; ++i )
964 SCIP_Real dualdiff = SQR(stabcenterconsvals[i] - pricingtype->
consGetDual(scip_, masterconss[i]));
966 if( SCIPisPositive(scip_, dualdiff) )
967 dualdiffnorm += dualdiff;
971 assert(stabcenterconsvals != NULL);
973 for(
int i = 0; i < ncuts; ++i )
975 SCIP_Real dualdiff = SQR(stabcentercutvals[i] - pricingtype->
rowGetDual(mastercuts[i]));
977 if( SCIPisPositive(scip_, dualdiff) )
978 dualdiffnorm += dualdiff;
982 assert(stabcenterlinkingconsvals != NULL);
984 for(
int i = 0; i < nlinkingconss; ++i )
986 SCIP_Real dualdiff = SQR(stabcenterlinkingconsvals[i] - pricingtype->
consGetDual(scip_, linkingconss[i]));
988 if( SCIPisPositive(scip_, dualdiff) )
989 dualdiffnorm += dualdiff;
992 dualdiffnorm = SQRT(dualdiffnorm);
993 SCIPdebugMessage(
"Update dualdiffnorm with value %g.\n", dualdiffnorm);
997 void Stabilization::calculateBeta()
1005 assert(nconss <= nstabcenterconsvals);
1008 assert(ncuts <= nstabcentercutvals);
1013 assert(stabcenterconsvals != NULL);
1015 for(
int i = 0; i < nconss; ++i )
1017 SCIP_Real dualdiff = ABS(pricingtype->
consGetDual(scip_, masterconss[i]) - stabcenterconsvals[i]);
1018 SCIP_Real product = dualdiff * ABS(subgradientconsvals[i]);
1020 if( SCIPisPositive(scip_, product) )
1025 assert(stabcentercutvals != NULL || ncuts == 0);
1027 for(
int i = 0; i < ncuts; ++i )
1029 SCIP_Real dualdiff = ABS(pricingtype->
rowGetDual(mastercuts[i]) - stabcentercutvals[i]);
1030 SCIP_Real product = dualdiff * ABS(subgradientcutvals[i]);
1032 if( SCIPisPositive(scip_, product) )
1037 assert(stabcenterlinkingconsvals != NULL);
1039 for(
int i = 0; i < nlinkingconss; ++i )
1041 SCIP_Real dualdiff = ABS(pricingtype->
consGetDual(scip_, linkingconss[i]) - stabcenterlinkingconsvals[i]);
1042 SCIP_Real product = dualdiff * ABS(subgradientlinkingconsvals[i]);
1044 if( SCIPisPositive(scip_, product) )
1048 if( SCIPisPositive(scip_, subgradientnorm) )
1049 beta = beta / (subgradientnorm * dualdiffnorm);
1051 SCIPdebugMessage(
"Update beta with value %g.\n", beta);
1053 assert( ( SCIPisPositive(scip_, beta) || SCIPisZero(scip_, subgradientnorm)) && SCIPisLE(scip_, beta, 1.0) );
1057 void Stabilization::calculateHybridFactor()
1066 assert(nconss <= nstabcenterconsvals);
1069 assert(ncuts <= nstabcentercutvals);
1071 SCIP_Real divisornorm = 0.0;
1074 assert(stabcenterconsvals != NULL);
1076 for(
int i = 0; i < nconss; ++i )
1078 SCIP_Real divisor = SQR((beta - 1.0) * stabcenterconsvals[i]
1079 + beta * (subgradientconsvals[i] * dualdiffnorm / subgradientnorm)
1080 + (1 - beta) * pricingtype->
consGetDual(scip_, masterconss[i]));
1082 if( SCIPisPositive(scip_, divisor) )
1083 divisornorm += divisor;
1087 assert(stabcenterconsvals != NULL);
1089 for(
int i = 0; i < ncuts; ++i )
1091 SCIP_Real divisor = SQR((beta - 1.0) * stabcentercutvals[i]
1092 + beta * (subgradientcutvals[i] * dualdiffnorm / subgradientnorm)
1093 + (1 - beta) * pricingtype->
rowGetDual(mastercuts[i]));
1095 if( SCIPisPositive(scip_, divisor) )
1096 divisornorm += divisor;
1100 assert(stabcenterlinkingconsvals != NULL);
1102 for(
int i = 0; i < nlinkingconss; ++i )
1104 SCIP_Real divisor = SQR((beta - 1.0) * stabcenterlinkingconsvals[i]
1105 + beta * (subgradientlinkingconsvals[i] * dualdiffnorm / subgradientnorm)
1106 + (1 - beta) * pricingtype->
consGetDual(scip_, linkingconss[i]));
1108 if( SCIPisPositive(scip_, divisor) )
1109 divisornorm += divisor;
1112 divisornorm = SQRT(divisornorm);
1114 hybridfactor = ((1 - alpha) * dualdiffnorm) / divisornorm;
1116 SCIPdebugMessage(
"Update hybridfactor with value %g.\n", hybridfactor);
1118 assert( SCIPisPositive(scip_, hybridfactor) );
1124 if( inmispricingschedule )
1125 return SCIPisGT(scip_, alphabar, 0.0);
1126 return SCIPisGT(scip_, alpha, 0.0);
1133 inmispricingschedule = TRUE;
1140 inmispricingschedule = FALSE;
1148 return inmispricingschedule;
1157 SCIP_CALL( updateStabcenterconsvals() );
1158 SCIP_CALL( updateStabcentercutvals() );
1160 subgradientproduct = calculateSubgradientProduct(pricingcols);