48 #include "blockmemshell/memory.h"
50 #include "scip/pub_misc.h"
57 #define BMS_CALL(x) do \
61 SCIPerrorMessage("No memory in function call\n"); \
62 return SCIP_NOMEMORY; \
68 #define CHECK_IF_SOLVED(sdpi) do \
70 if ( ! (sdpi->solved) ) \
72 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \
73 return SCIP_LPERROR; \
79 #define CHECK_IF_SOLVED_BOOL(sdpi) do \
81 if ( ! (sdpi->solved) ) \
83 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \
90 #define DUPLICATE_ARRAY_NULL(blkmem, target, source, size) do \
93 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, target, source, size) ); \
100 #define SCIP_CALL_PARAM(x) do \
102 SCIP_RETCODE _restat_; \
103 if ( (_restat_ = (x)) != SCIP_OKAY ) \
105 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \
107 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \
116 #define NINCREASESGAMMA 2
117 #define MIN_EPSILON 1e-10
119 #define DEFAULT_SDPSOLVEREPSILON 1e-4
120 #define DEFAULT_SDPSOLVERFEASTOL 1e-6
121 #define DEFAULT_PENALTYPARAM 1e+5
122 #define DEFAULT_MAXPENALTYPARAM 1e+10
128 SCIP_MESSAGEHDLR* messagehdlr;
140 int* sdpconstnblocknonz;
144 SCIP_Real** sdpconstval;
148 int** sdpnblockvarnonz;
173 SCIP_Bool infeasible;
177 SCIP_Real penaltyparam;
178 SCIP_Real maxpenaltyparam;
218 assert ( sdpi != NULL );
219 assert ( v < sdpi->nvars );
220 assert ( sdpi->lb != NULL );
221 assert ( sdpi->ub != NULL );
226 assert( lb < ub + sdpi->feastol || sdpi->infeasible );
228 return ( REALABS(ub-lb) <= sdpi->feastol );
231 #define isFixed(sdpi, v) (REALABS(sdpi->ub[v] - sdpi->lb[v]) <= sdpi->feastol)
245 int* sdpconstnblocknonz,
249 SCIP_Real** sdpconstval
258 SCIP_Real** fixedvals;
260 assert ( sdpi != NULL );
261 assert ( sdpconstnnonz != NULL );
262 assert ( sdpconstnblocknonz != NULL );
263 assert ( sdpconstrow != NULL );
264 assert ( sdpconstcol != NULL );
265 assert ( sdpconstval != NULL );
267 for (block = 0; block < sdpi->nsdpblocks; block++)
269 assert ( sdpconstrow[block] != NULL );
270 assert ( sdpconstcol[block] != NULL );
271 assert ( sdpconstval[block] != NULL );
280 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks) );
281 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks) );
282 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks) );
283 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks) );
285 for (block = 0; block < sdpi->nsdpblocks; block++)
288 nfixednonz[block] = 0;
289 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
291 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
292 nfixednonz[block] += sdpi->sdpnblockvarnonz[block][v];
295 fixedrows[block] = NULL;
296 fixedcols[block] = NULL;
297 fixedvals[block] = NULL;
299 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]) );
300 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]) );
301 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]) );
304 nfixednonz[block] = 0;
308 for (block = 0; block < sdpi->nsdpblocks; block++)
310 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
312 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
314 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
316 fixedrows[block][nfixednonz[block]] = sdpi->sdprow[block][v][i];
317 fixedcols[block][nfixednonz[block]] = sdpi->sdpcol[block][v][i];
320 fixedvals[block][nfixednonz[block]] = - sdpi->sdpval[block][v][i] * sdpi->lb[sdpi->sdpvar[block][v]];
329 for (block = 0; block < sdpi->nsdpblocks; block++)
332 sdpi->sdpconstnblocknonz[block], fixedrows[block], fixedcols[block], fixedvals[block], nfixednonz[block],
333 sdpconstrow[block], sdpconstcol[block], sdpconstval[block], &sdpconstnblocknonz[block]) );
334 *sdpconstnnonz += sdpconstnblocknonz[block];
338 for (block = 0; block < sdpi->nsdpblocks; block++)
340 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]);
341 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]);
342 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]);
344 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks);
345 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks);
346 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks);
347 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks);
358 int* sdpconstnblocknonz,
362 SCIP_Real** sdpconstval,
368 int* blockindchanges,
377 assert( sdpi != NULL );
378 assert( sdpconstnblocknonz != NULL );
379 assert( sdpconstrow != NULL );
380 assert( sdpconstcol != NULL );
381 assert( sdpconstval != NULL );
382 assert( indchanges != NULL );
383 assert( nremovedinds != NULL );
384 assert( blockindchanges != NULL );
385 assert( nremovedblocks != NULL );
388 for (block = 0; block < sdpi->nsdpblocks; block++)
390 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
391 indchanges[block][i] = -1;
397 for (block = 0; block < sdpi->nsdpblocks; block++)
401 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
403 if ( ! (
isFixed(sdpi, sdpi->sdpvar[block][v])) )
405 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
407 assert ( REALABS(sdpi->sdpval[block][v][i]) > sdpi->feastol);
408 if ( indchanges[block][sdpi->sdprow[block][v][i]] == -1 )
410 indchanges[block][sdpi->sdprow[block][v][i]] = 1;
413 if ( indchanges[block][sdpi->sdpcol[block][v][i]] == -1 )
415 indchanges[block][sdpi->sdpcol[block][v][i]] = 1;
418 if ( nfoundinds == sdpi->sdpblocksizes[block] )
422 if (nfoundinds == sdpi->sdpblocksizes[block])
426 if ( nfoundinds < sdpi->sdpblocksizes[block] )
429 for (i = 0; i < sdpconstnblocknonz[block]; i++)
431 assert ( REALABS(sdpconstval[block][i]) > sdpi->feastol);
432 if ( indchanges[block][sdpconstrow[block][i]] == -1 )
434 indchanges[block][sdpconstrow[block][i]] = 1;
437 if ( indchanges[block][sdpconstcol[block][i]] == -1 )
439 indchanges[block][sdpconstcol[block][i]] = 1;
442 if ( nfoundinds == sdpi->sdpblocksizes[block] )
448 nremovedinds[block] = 0;
449 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
451 if ( indchanges[block][i] == -1 )
453 SCIPdebugMessage(
"empty row and col %d were removed from block %d of SDP %d\n", i, block, sdpi->sdpid);
455 nremovedinds[block]++;
460 indchanges[block][i] = nremovedinds[block];
465 if ( nremovedinds[block] == sdpi->sdpblocksizes[block] )
467 SCIPdebugMessage(
"empty block %d detected in SDP %d, this will be removed", block, sdpi->sdpid);
468 blockindchanges[block] = -1;
472 blockindchanges[block] = *nremovedblocks;
486 SCIP_Real* lplhsafterfix,
490 SCIP_Real* lprhsafterfix,
495 SCIP_Bool* fixingsfound
505 assert( sdpi != NULL );
506 assert( nactivelpcons != NULL );
507 assert( sdpi->nlpcons == 0 || lplhsafterfix != NULL );
508 assert( sdpi->nlpcons == 0 || lprhsafterfix != NULL );
509 assert( sdpi->nlpcons == 0 || rownactivevars != NULL );
510 assert( sdpi->nlpcons == 0 || fixingsfound != NULL );
513 if ( sdpi->nlpcons == 0 || sdpi->lpnnonz == 0 )
520 for (c = 0; c < sdpi->nlpcons; c++)
521 rownactivevars[c] = 0;
524 for (i = 0; i < sdpi->lpnnonz; i++)
526 assert( i == 0 || sdpi->lprow[i-1] <= sdpi->lprow[i] );
529 if ( sdpi->lprow[i] > lastrow )
532 if ( lastrow >= 0 && rownactivevars[lastrow] > 1 )
534 else if ( lastrow >= 0 && rownactivevars[lastrow] == 1 )
536 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
538 nonzcol = sdpi->lpcol[nonzind];
539 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
541 nonzval = sdpi->lpval[nonzind];
542 assert( REALABS(nonzval) > sdpi->feastol );
549 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
552 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
553 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
554 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
557 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
559 *fixingsfound = TRUE;
560 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
561 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
564 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
566 sdpi->infeasible = TRUE;
567 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
568 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
574 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->feastol) )
577 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
578 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
579 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
582 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
584 *fixingsfound = TRUE;
585 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
586 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
590 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
592 sdpi->infeasible = TRUE;
593 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
594 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
603 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->feastol) )
606 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
607 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
608 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
611 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
613 *fixingsfound = TRUE;
614 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
615 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
619 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
621 sdpi->infeasible = TRUE;
622 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
623 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
629 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
632 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
633 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
634 sdpi->ub[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
637 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
639 *fixingsfound = TRUE;
640 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
641 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
645 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
647 sdpi->infeasible = TRUE;
648 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
649 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
655 else if ( lastrow >= 0 )
657 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
659 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
661 sdpi->infeasible = TRUE;
662 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
663 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
669 lastrow = sdpi->lprow[i];
672 lplhsafterfix[*nactivelpcons] = sdpi->lplhs[lastrow];
673 lprhsafterfix[*nactivelpcons] = sdpi->lprhs[lastrow];
677 if ( !
isFixed(sdpi, sdpi->lpcol[i]) )
679 rownactivevars[lastrow]++;
685 lplhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
686 lprhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
691 if ( rownactivevars[lastrow] > 1 )
693 else if ( rownactivevars[lastrow] == 1 )
695 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
697 nonzcol = sdpi->lpcol[nonzind];
698 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
700 nonzval = sdpi->lpval[nonzind];
701 assert( REALABS(nonzval) > sdpi->feastol );
708 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
711 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
712 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
713 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
716 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
718 *fixingsfound = TRUE;
719 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
720 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
724 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
726 sdpi->infeasible = TRUE;
727 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
733 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] - sdpi->feastol) )
736 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
737 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
738 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
741 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
743 *fixingsfound = TRUE;
744 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
745 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
749 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
751 sdpi->infeasible = TRUE;
752 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
761 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->feastol) )
764 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
765 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
766 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
769 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
771 *fixingsfound = TRUE;
772 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
773 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
777 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
779 sdpi->infeasible = TRUE;
780 SCIPdebugMessage(
"We found a lower bound that is bigger than the upper bound, so the problem is infeasible !\n");
786 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
789 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
790 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
791 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
794 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
796 *fixingsfound = TRUE;
797 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
798 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
802 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
804 sdpi->infeasible = TRUE;
805 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
813 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
815 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
817 sdpi->infeasible = TRUE;
818 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
819 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
837 for (v = 0; v < sdpi->nvars; v++)
841 sdpi->allfixed = FALSE;
848 SCIPdebugMessage(
"Detected that all variables in SDP %d are fixed.\n", sdpi->sdpid);
849 sdpi->allfixed = TRUE;
860 int* sdpconstnblocknonz,
864 SCIP_Real** sdpconstval,
873 SCIP_Real* fullmatrix;
876 SCIP_Real eigenvalue;
882 assert( sdpi->allfixed );
887 for (b = 0; b < sdpi->nsdpblocks; b++)
889 if ( sdpi->sdpblocksizes[b] - nremovedinds[b] > maxsize )
890 maxsize = sdpi->sdpblocksizes[b] - nremovedinds[b];
894 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize) );
897 for (b = 0; b < sdpi->nsdpblocks; b++)
900 if ( blockindchanges[b] == -1 )
903 size = sdpi->sdpblocksizes[b] - nremovedinds[b];
906 for (i = 0; i < size * size; i++)
910 for (i = 0; i < sdpconstnblocknonz[b]; i++)
912 assert( 0 <= sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] && sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] < size );
913 assert( 0 <= sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] && sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] < size );
914 fullmatrix[(sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]]) * size
915 + sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]]] = -1 * sdpconstval[b][i];
919 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
921 fixedval = sdpi->lb[sdpi->sdpvar[b][v]];
924 if ( REALABS(fixedval) < sdpi->feastol )
928 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
930 assert( 0 <= sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] &&
931 sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] < size );
932 assert( 0 <= sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] &&
933 sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] < size );
934 fullmatrix[(sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]]) * size
935 + sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]]] += fixedval * sdpi->sdpval[b][v][i];
943 if ( eigenvalue < -1 * sdpi->feastol )
945 sdpi->infeasible = TRUE;
946 SCIPdebugMessage(
"Detected infeasibility for SDP %d with all fixed variables!\n", sdpi->sdpid);
952 BMSfreeBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize);
955 sdpi->infeasible = FALSE;
956 SCIPdebugMessage(
"Unique solution for SDP %d with all fixed variables is feasible!\n", sdpi->sdpid);
968 int* sdpconstnblocknonz,
972 SCIP_Real** sdpconstval,
976 SCIP_Real* lplhsafterfix,
977 SCIP_Real* lprhsafterfix,
978 int* rowsnactivevars,
979 int* blockindchanges,
984 SCIP_Bool rootnodefailed
989 SCIP_Bool origfeas = FALSE;
990 SCIP_Bool penaltybound = FALSE;
993 SCIP_Real* slaterlpval;
994 SCIP_Real* slaterlplhs;
995 SCIP_Real* slaterlprhs;
996 int* slaterrowsnactivevars;
997 int nremovedslaterlpinds;
1001 int slaternactivelpcons;
1002 SCIP_Real* slaterlb;
1003 SCIP_Real* slaterub;
1004 int slaternremovedvarbounds;
1005 SCIP_Real solvertimelimit;
1006 clock_t currenttime;
1008 assert( sdpi != NULL );
1009 assert( sdpconstnnonz == 0 || sdpconstnblocknonz != NULL );
1010 assert( sdpconstnnonz == 0 || sdpconstrow != NULL );
1011 assert( sdpconstnnonz == 0 || sdpconstcol != NULL );
1012 assert( sdpconstnnonz == 0 || sdpconstval != NULL );
1013 assert( sdpi->nsdpblocks == 0 || indchanges != NULL );
1014 assert( sdpi->nsdpblocks == 0 || nremovedinds != NULL );
1015 assert( nactivelpcons == 0 || lplhsafterfix != NULL );
1016 assert( nactivelpcons == 0 || lprhsafterfix != NULL );
1017 assert( sdpi->nlpcons == 0 || rowsnactivevars != NULL );
1018 assert( sdpi->nsdpblocks == 0 || blockindchanges != NULL );
1023 solvertimelimit = timelimit;
1026 currenttime = clock();
1027 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
1033 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1034 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1035 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1036 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1038 &origfeas, &penaltybound) );
1042 if ( rootnodefailed )
1044 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem could "
1045 "not be checked, ");
1047 else if ( sdpi->slatercheck == 2 )
1048 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for dual problem.\n");
1055 if ( rootnodefailed )
1056 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds "
1057 "as smallest eigenvalue maximization problem is unbounded, ");
1059 SCIPdebugMessage(
"Slater condition for dual problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded.\n", sdpi->sdpid);
1064 if ( rootnodefailed )
1066 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem "
1067 "not fullfilled as problem is infeasible, ");
1069 else if ( sdpi->slatercheck == 2 )
1070 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for dual problem for SDP %d not fullfilled, problem infeasible.\n", sdpi->sdpid);
1077 if ( objval < - sdpi->feastol )
1079 if ( rootnodefailed )
1081 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds"
1082 "with smallest eigenvalue %f, ", -1.0 * objval);
1085 SCIPdebugMessage(
"Slater condition for SDP %d is fullfilled for dual problem with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1088 else if ( objval < sdpi->epsilon )
1090 if ( rootnodefailed )
1092 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem "
1093 "not fullfilled with smallest eigenvalue %f, ", -1.0 * objval);
1095 else if ( sdpi->slatercheck == 2 )
1097 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, expect numerical trouble.\n",
1098 sdpi->sdpid, -1.0 * objval);
1104 if ( sdpi->slatercheck == 2 )
1106 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, problem is infeasible.\n",
1107 sdpi->sdpid, -1.0 * objval);
1132 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars) );
1133 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars) );
1134 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars) );
1137 for (i = 0; i < sdpi->lpnnonz; i++)
1139 slaterlprow[i] = sdpi->lprow[i];
1140 slaterlpcol[i] = sdpi->lpcol[i];
1141 slaterlpval[i] = sdpi->lpval[i];
1145 for (v = 0; v < sdpi->nvars; v++)
1147 slaterlprow[sdpi->lpnnonz + v] = sdpi->nlpcons;
1148 slaterlpcol[sdpi->lpnnonz + v] = v;
1149 slaterlpval[sdpi->lpnnonz + v] = 0.0;
1151 for (b = 0; b < sdpi->nsdpblocks; b++)
1153 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
1155 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
1157 if ( sdpi->sdprow[b][v][i] == sdpi->sdpcol[b][v][i] )
1158 slaterlpval[sdpi->lpnnonz + sdpi->sdpvar[b][v]] += sdpi->sdpval[b][v][i];
1164 nremovedslaterlpinds = 0;
1165 for (v = 0; v < sdpi->nvars; v++)
1167 if ( REALABS(slaterlpval[sdpi->lpnnonz + v]) <= sdpi->feastol )
1168 nremovedslaterlpinds++;
1172 slaterlprow[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlprow[sdpi->lpnnonz + v];
1173 slaterlpcol[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpcol[sdpi->lpnnonz + v];
1174 slaterlpval[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpval[sdpi->lpnnonz + v];
1179 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1) );
1180 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1) );
1183 for (i = 0; i < nactivelpcons; i++)
1186 slaterlplhs[i] = lplhsafterfix[i];
1188 slaterlplhs[i] = 0.0;
1191 slaterlprhs[i] = lprhsafterfix[i];
1193 slaterlprhs[i] = 0.0;
1197 slaterlplhs[nactivelpcons] = 1.0;
1201 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1) );
1204 for (i = 0; i < sdpi->nlpcons; i++)
1205 slaterrowsnactivevars[i] = rowsnactivevars[i];
1208 slaterrowsnactivevars[sdpi->nlpcons] = 0;
1209 for (v = 0; v < sdpi->nvars; v++)
1212 slaterrowsnactivevars[sdpi->nlpcons]++;
1215 slaternactivelpcons = (slaterrowsnactivevars[sdpi->nlpcons] > 1) ? nactivelpcons + 1 : nactivelpcons;
1222 slaternremovedvarbounds = 0;
1223 for (v = 0; v < sdpi->nvars; v++)
1228 slaternremovedvarbounds++;
1233 slaternremovedvarbounds++;
1240 if ( slaternremovedvarbounds == 2 * sdpi->nvars )
1242 if ( rootnodefailed )
1244 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem holds since all variables have finite upper and lower bounds \n");
1247 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled as all variables have finite upper and lower bounds \n",sdpi->sdpid);
1253 currenttime = clock();
1254 solvertimelimit = timelimit - ((SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC);
1258 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, 0, NULL, NULL, NULL, NULL,
1259 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1260 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, slaternactivelpcons, sdpi->nlpcons + 1, slaterlplhs, slaterlprhs,
1261 slaterrowsnactivevars, sdpi->lpnnonz + sdpi->nvars - nremovedslaterlpinds, slaterlprow, slaterlpcol, slaterlpval, NULL,
1266 if ( rootnodefailed )
1268 SCIPmessagePrintInfo(sdpi->messagehdlr,
"unable to check Slater condition for primal problem \n");
1270 else if ( sdpi->slatercheck == 2 )
1271 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for primal problem, could not solve auxilliary problem.\n");
1276 if ( rootnodefailed )
1278 SCIPmessagePrintInfo(sdpi->messagehdlr,
" primal Slater condition shows infeasibility \n");
1280 else if ( sdpi->slatercheck == 2 )
1282 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled "
1283 "smallest eigenvalue has to be negative, so primal problem is infeasible (if the dual slater condition holds,"
1284 "this means, that the original (dual) problem is unbounded.\n",sdpi->sdpid);
1290 if ( rootnodefailed )
1292 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problems holds sunce smallest eigenvalue maximization problem"
1296 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded \n",sdpi->sdpid);
1303 if ( objval > - sdpi->feastol)
1305 if ( rootnodefailed )
1307 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem not fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1309 else if ( sdpi->slatercheck == 2 )
1311 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled "
1312 "as smallest eigenvalue was %f, expect numerical trouble or infeasible problem.\n",sdpi->sdpid, -1.0 * objval);
1318 if ( rootnodefailed )
1320 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1323 SCIPdebugMessage(
"Slater condition for primal problem of SDP %d is fullfilled with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1330 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterub, sdpi->nvars);
1331 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlb, sdpi->nvars);
1332 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1);
1333 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1);
1334 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1);
1335 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars);
1336 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars);
1337 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars);
1392 SCIP_MESSAGEHDLR* messagehdlr,
1396 assert ( sdpi != NULL );
1397 assert ( blkmem != NULL );
1399 SCIPdebugMessage(
"Calling SCIPsdpiCreate\n");
1401 BMS_CALL( BMSallocBlockMemory(blkmem, sdpi) );
1405 (*sdpi)->messagehdlr = messagehdlr;
1406 (*sdpi)->blkmem = blkmem;
1408 (*sdpi)->niterations = 0;
1409 (*sdpi)->nsdpcalls = 0;
1411 (*sdpi)->nsdpblocks = 0;
1412 (*sdpi)->sdpconstnnonz = 0;
1413 (*sdpi)->sdpnnonz = 0;
1414 (*sdpi)->nlpcons = 0;
1415 (*sdpi)->lpnnonz = 0;
1416 (*sdpi)->slatercheck = 0;
1417 (*sdpi)->solved = FALSE;
1418 (*sdpi)->penalty = FALSE;
1419 (*sdpi)->infeasible = FALSE;
1420 (*sdpi)->allfixed = FALSE;
1422 (*sdpi)->obj = NULL;
1425 (*sdpi)->sdpblocksizes = NULL;
1426 (*sdpi)->sdpnblockvars = NULL;
1427 (*sdpi)->sdpconstnblocknonz = NULL;
1428 (*sdpi)->sdpconstrow = NULL;
1429 (*sdpi)->sdpconstcol = NULL;
1430 (*sdpi)->sdpconstval = NULL;
1431 (*sdpi)->sdpnblockvarnonz = NULL;
1432 (*sdpi)->sdpvar = NULL;
1433 (*sdpi)->sdprow = NULL;
1434 (*sdpi)->sdpcol = NULL;
1435 (*sdpi)->sdpval = NULL;
1436 (*sdpi)->lplhs = NULL;
1437 (*sdpi)->lprhs = NULL;
1438 (*sdpi)->lprow = NULL;
1439 (*sdpi)->lpcol = NULL;
1440 (*sdpi)->lpval = NULL;
1461 SCIPdebugMessage(
"Calling SCIPsdpiFree \n");
1462 assert ( sdpi != NULL );
1463 assert ( *sdpi != NULL );
1466 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpval), (*sdpi)->lpnnonz);
1467 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpcol), (*sdpi)->lpnnonz);
1468 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprow), (*sdpi)->lpnnonz);
1469 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprhs), (*sdpi)->nlpcons);
1470 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lplhs), (*sdpi)->nlpcons);
1473 for (i = 0; i < (*sdpi)->nsdpblocks; i++)
1475 for (j = 0; j < (*sdpi)->sdpnblockvars[i]; j++)
1477 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1478 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1479 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1481 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i]), (*sdpi)->sdpnblockvars[i]);
1482 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i]), (*sdpi)->sdpnblockvars[i]);
1483 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i]), (*sdpi)->sdpnblockvars[i]);
1484 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar[i]), (*sdpi)->sdpnblockvars[i]);
1485 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz[i]), (*sdpi)->sdpnblockvars[i]);
1486 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval[i]), (*sdpi)->sdpconstnblocknonz[i]);
1487 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow[i]), (*sdpi)->sdpconstnblocknonz[i]);
1488 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol[i]), (*sdpi)->sdpconstnblocknonz[i]);
1492 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz), (*sdpi)->nsdpblocks);
1493 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstnblocknonz), (*sdpi)->nsdpblocks);
1494 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval), (*sdpi)->nsdpblocks);
1495 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol), (*sdpi)->nsdpblocks);
1496 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow), (*sdpi)->nsdpblocks);
1497 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar), (*sdpi)->nsdpblocks);
1498 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval), (*sdpi)->nsdpblocks);
1499 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol), (*sdpi)->nsdpblocks);
1500 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow), (*sdpi)->nsdpblocks);
1501 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvars), (*sdpi)->nsdpblocks);
1502 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpblocksizes), (*sdpi)->nsdpblocks);
1503 BMSfreeBlockMemoryArray((*sdpi)->blkmem, &((*sdpi)->ub), (*sdpi)->nvars);
1504 BMSfreeBlockMemoryArray((*sdpi)->blkmem, &((*sdpi)->lb), (*sdpi)->nvars);
1505 BMSfreeBlockMemoryArray((*sdpi)->blkmem, &((*sdpi)->obj), (*sdpi)->nvars);
1510 BMSfreeBlockMemory((*sdpi)->blkmem, sdpi);
1531 assert( oldsdpi != NULL );
1533 SCIPdebugMessage(
"Cloning SDPI %d\n", oldsdpi->sdpid);
1536 blkmem = oldsdpi->blkmem;
1537 nvars = oldsdpi->nvars;
1538 nsdpblocks = oldsdpi->nsdpblocks;
1539 lpnnonz = oldsdpi->lpnnonz;
1541 BMS_CALL( BMSallocBlockMemory(blkmem, &newsdpi) );
1543 SCIP_CALL(
SCIPsdpiSolverCreate(&(newsdpi->sdpisolver), oldsdpi->messagehdlr, oldsdpi->blkmem) );
1545 newsdpi->messagehdlr = oldsdpi->messagehdlr;
1546 newsdpi->blkmem = blkmem;
1547 newsdpi->nvars = nvars;
1549 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->obj), oldsdpi->obj, nvars) );
1550 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lb), oldsdpi->lb, nvars) );
1551 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->ub), oldsdpi->ub, nvars) );
1553 newsdpi->nsdpblocks = nsdpblocks;
1555 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpblocksizes), oldsdpi->sdpblocksizes, nsdpblocks) );
1556 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvars), oldsdpi->sdpnblockvars, nsdpblocks) );
1559 newsdpi->sdpconstnnonz = oldsdpi->sdpconstnnonz;
1561 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstnblocknonz), oldsdpi->sdpconstnblocknonz, nsdpblocks) );
1562 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow), nsdpblocks) );
1563 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol), nsdpblocks) );
1564 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstval), nsdpblocks) );
1566 for (b = 0; b < nsdpblocks; b++)
1568 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow[b]), oldsdpi->sdpconstrow[b], oldsdpi->sdpconstnblocknonz[b]) );
1569 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol[b]), oldsdpi->sdpconstcol[b], oldsdpi->sdpconstnblocknonz[b]) );
1570 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstval[b]), oldsdpi->sdpconstval[b], oldsdpi->sdpconstnblocknonz[b]) );
1574 newsdpi->sdpnnonz = oldsdpi->sdpnnonz;
1576 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz), nsdpblocks) );
1577 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpvar), nsdpblocks) );
1578 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow), nsdpblocks) );
1579 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol), nsdpblocks) );
1580 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval), nsdpblocks) );
1582 for (b = 0; b < nsdpblocks; b++)
1584 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz[b]), oldsdpi->sdpnblockvarnonz[b], oldsdpi->sdpnblockvars[b]) );
1585 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpvar[b]), oldsdpi->sdpvar[b], oldsdpi->sdpnblockvars[b]) );
1587 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow[b]), oldsdpi->sdpnblockvars[b]) );
1588 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b]), oldsdpi->sdpnblockvars[b]) );
1589 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval[b]), oldsdpi->sdpnblockvars[b]) );
1591 for (v = 0; v < oldsdpi->sdpnblockvars[b]; v++)
1593 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdprow[b][v]), oldsdpi->sdprow[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1594 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b][v]), oldsdpi->sdpcol[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1595 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpval[b][v]), oldsdpi->sdpval[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1600 newsdpi->nlpcons = oldsdpi->nlpcons;
1602 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lplhs), oldsdpi->lplhs, oldsdpi->nlpcons) );
1603 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprhs), oldsdpi->lprhs, oldsdpi->nlpcons) );
1605 newsdpi->lpnnonz = lpnnonz;
1607 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprow), oldsdpi->lprow, lpnnonz) );
1608 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpcol), oldsdpi->lpcol, lpnnonz) );
1609 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpval), oldsdpi->lpval, lpnnonz) );
1612 newsdpi->solved = FALSE;
1613 newsdpi->penalty = FALSE;
1614 newsdpi->infeasible = FALSE;
1615 newsdpi->allfixed = FALSE;
1616 newsdpi->sdpid = 1000000 + oldsdpi->sdpid;
1617 newsdpi->epsilon = oldsdpi->epsilon;
1618 newsdpi->feastol = oldsdpi->feastol;
1648 int* sdpconstnblocknonz,
1652 SCIP_Real** sdpconstval,
1654 int** sdpnblockvarnonz,
1662 SCIP_Real*** sdpval,
1677 SCIPdebugMessage(
"Calling SCIPsdpiLoadSDP (%d)\n",sdpi->sdpid);
1679 assert ( sdpi != NULL );
1680 assert ( nvars > 0 );
1681 assert ( obj != NULL );
1682 assert ( lb != NULL );
1683 assert ( ub != NULL );
1686 if (sdpconstnnonz > 0 || sdpnnonz > 0 || nsdpblocks > 0)
1688 assert ( sdpblocksizes != NULL );
1689 assert ( sdpnblockvars != NULL );
1690 assert ( nsdpblocks > 0 );
1691 assert ( sdpconstnblocknonz != NULL );
1692 assert ( sdpnblockvarnonz != NULL );
1694 if (sdpconstnnonz > 0)
1696 assert ( sdpconstrow != NULL );
1697 assert ( sdpconstcol != NULL );
1698 assert ( sdpconstval != NULL );
1700 for (i = 0; i < nsdpblocks; i++)
1702 if (sdpconstnblocknonz[i] > 0)
1704 assert ( sdpconstrow[i] != NULL );
1705 assert ( sdpconstcol[i] != NULL );
1706 assert ( sdpconstval[i] != NULL );
1713 assert ( sdprow != NULL );
1714 assert ( sdpcol != NULL );
1715 assert ( sdpval != NULL );
1717 for ( i = 0; i < nsdpblocks; i++ )
1719 assert ( sdpcol[i] != NULL );
1720 assert ( sdprow[i] != NULL );
1721 assert ( sdpval[i] != NULL );
1723 for ( v = 0; v < sdpnblockvars[i]; v++)
1725 if (sdpnblockvarnonz[i][v] > 0)
1727 assert ( sdpcol[i][v] != NULL );
1728 assert ( sdprow[i][v] != NULL );
1729 assert ( sdpval[i][v] != NULL );
1737 assert ( nlpcons == 0 || lplhs != NULL );
1738 assert ( nlpcons == 0 || lprhs != NULL );
1739 assert ( lpnnonz == 0 || lprow != NULL );
1740 assert ( lpnnonz == 0 || lpcol != NULL );
1741 assert ( lpnnonz == 0 || lpval != NULL );
1746 for (block = sdpi->nsdpblocks - 1; block >= 0; block--)
1748 for (v = sdpi->sdpnblockvars[block] - 1; v >= 0; v--)
1750 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1751 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1752 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1755 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block]), sdpi->sdpnblockvars[block]);
1756 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block]), sdpi->sdpnblockvars[block]);
1757 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpi->sdpnblockvars[block]);
1758 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpi->sdpconstnblocknonz[block]);
1759 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpi->sdpconstnblocknonz[block]);
1760 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpi->sdpconstnblocknonz[block]);
1761 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpi->sdpnblockvars[block]);
1762 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpi->sdpnblockvars[block]);
1765 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->ub), sdpi->nvars);
1766 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lb), sdpi->nvars);
1767 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->obj), sdpi->nvars);
1769 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpblocksizes), sdpi->nsdpblocks);
1770 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvars), sdpi->nsdpblocks);
1771 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpi->nsdpblocks);
1774 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->obj), obj, nvars) );
1775 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->lb), lb, nvars) );
1776 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->ub), ub, nvars) );
1779 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpconstnblocknonz, nsdpblocks);
1782 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpnblockvarnonz), sdpi->nsdpblocks, nsdpblocks) );
1783 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstcol), sdpi->nsdpblocks, nsdpblocks) );
1784 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstrow), sdpi->nsdpblocks, nsdpblocks) );
1785 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstval), sdpi->nsdpblocks, nsdpblocks) );
1786 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpvar), sdpi->nsdpblocks, nsdpblocks) );
1787 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol), sdpi->nsdpblocks, nsdpblocks) );
1788 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow), sdpi->nsdpblocks, nsdpblocks) );
1789 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval), sdpi->nsdpblocks, nsdpblocks) );
1791 for (block = 0; block < nsdpblocks; block++)
1793 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpnblockvarnonz[block], sdpnblockvars[block]);
1795 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpconstcol[block], sdpconstnblocknonz[block]);
1796 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpconstrow[block], sdpconstnblocknonz[block]);
1797 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpconstval[block], sdpconstnblocknonz[block]);
1800 for (i = 0; i < sdpi->sdpconstnblocknonz[block]; ++i)
1803 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpvar[block], sdpnblockvars[block]);
1805 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpnblockvars[block]) );
1806 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow[block]), sdpnblockvars[block]) );
1807 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval[block]), sdpnblockvars[block]) );
1809 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
1811 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpcol[block][v], sdpnblockvarnonz[block][v]);
1812 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdprow[block][v], sdpnblockvarnonz[block][v]);
1813 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpval[block][v], sdpnblockvarnonz[block][v]);
1816 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; ++i)
1822 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1823 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1824 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1825 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1826 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1835 sdpi->nvars = nvars;
1836 sdpi->nsdpblocks = nsdpblocks;
1838 sdpi->sdpconstnnonz = sdpconstnnonz;
1839 sdpi->sdpnnonz = sdpnnonz;
1842 sdpi->lpnnonz = lpnnonz;
1843 sdpi->nlpcons = nlpcons;
1845 sdpi->solved = FALSE;
1846 sdpi->infeasible = FALSE;
1847 sdpi->allfixed = FALSE;
1848 sdpi->nsdpcalls = 0;
1849 sdpi->niterations = 0;
1861 const SCIP_Real* lhs,
1862 const SCIP_Real* rhs,
1867 const SCIP_Real* val
1872 SCIPdebugMessage(
"Adding %d LP-Constraints to SDP %d.\n", nrows, sdpi->sdpid);
1874 assert ( sdpi != NULL );
1879 assert ( lhs != NULL );
1880 assert ( rhs != NULL );
1881 assert ( nnonz >= 0 );
1882 assert ( row != NULL );
1883 assert ( col != NULL );
1884 assert ( val != NULL );
1886 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1887 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1889 for (i = 0; i < nrows; i++)
1891 sdpi->lplhs[sdpi->nlpcons + i] = lhs[i];
1892 sdpi->lprhs[sdpi->nlpcons + i] = rhs[i];
1895 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1896 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1897 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1899 for (i = 0; i < nnonz; i++)
1901 assert ( 0 <= row[i] && row[i] < nrows );
1903 sdpi->lprow[sdpi->lpnnonz + i] = row[i] + sdpi->nlpcons;
1905 assert ( 0 <= col[i] && col[i] < sdpi->nvars );
1906 sdpi->lpcol[sdpi->lpnnonz + i] = col[i];
1908 sdpi->lpval[sdpi->lpnnonz + i] = val[i];
1911 sdpi->nlpcons = sdpi->nlpcons + nrows;
1912 sdpi->lpnnonz = sdpi->lpnnonz + nnonz;
1914 sdpi->solved = FALSE;
1915 sdpi->infeasible = FALSE;
1916 sdpi->nsdpcalls = 0;
1917 sdpi->niterations = 0;
1935 SCIPdebugMessage(
"Deleting rows %d to %d from SDP %d.\n", firstrow, lastrow, sdpi->sdpid);
1937 assert ( sdpi != NULL );
1938 assert ( firstrow >= 0 );
1939 assert ( firstrow <= lastrow );
1940 assert ( lastrow < sdpi->nlpcons );
1943 if (firstrow == 0 && lastrow == sdpi->nlpcons - 1)
1945 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1946 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1947 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1948 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1949 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1960 sdpi->solved = FALSE;
1961 sdpi->infeasible = FALSE;
1962 sdpi->allfixed = FALSE;
1963 sdpi->nsdpcalls = 0;
1964 sdpi->niterations = 0;
1969 deletedrows = lastrow - firstrow + 1;
1973 for (i = lastrow + 1; i < sdpi->nlpcons; i++)
1975 sdpi->lplhs[i - deletedrows] = sdpi->lplhs[i];
1976 sdpi->lprhs[i - deletedrows] = sdpi->lprhs[i];
1978 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
1979 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
1982 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
1986 for (i = 0; i < sdpi->lpnnonz; i++)
1988 if (sdpi->lprow[i] >= firstrow && sdpi->lprow[i] <= lastrow)
1997 if (firstrowind > -1)
2000 while (i < sdpi->lpnnonz && sdpi->lprow[i] <= lastrow)
2005 deletednonz = lastrowind - firstrowind + 1;
2008 for (i = lastrowind + 1; i < sdpi->lpnnonz; i++)
2010 sdpi->lpcol[i - deletednonz] = sdpi->lpcol[i];
2012 sdpi->lprow[i - deletednonz] = sdpi->lprow[i] - deletedrows;
2013 sdpi->lpval[i - deletednonz] = sdpi->lpval[i];
2017 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2018 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2019 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2020 sdpi->nlpcons = sdpi->nlpcons - deletedrows;
2021 sdpi->lpnnonz = sdpi->lpnnonz - deletednonz;
2023 sdpi->solved = FALSE;
2024 sdpi->infeasible = FALSE;
2025 sdpi->allfixed = FALSE;
2026 sdpi->nsdpcalls = 0;
2027 sdpi->niterations = 0;
2044 SCIPdebugMessage(
"Calling SCIPsdpiDelLPRowset for SDP %d.\n", sdpi->sdpid);
2046 assert ( sdpi != NULL );
2047 assert ( dstat != NULL );
2049 oldnlpcons = sdpi->nlpcons;
2052 for (i = 0; i < oldnlpcons; i++)
2062 dstat[i] = i - deletedrows;
2065 sdpi->solved = FALSE;
2066 sdpi->infeasible = FALSE;
2067 sdpi->allfixed = FALSE;
2068 sdpi->nsdpcalls = 0;
2069 sdpi->niterations = 0;
2079 assert( sdpi != NULL );
2081 SCIPdebugMessage(
"Called SCIPsdpiClear in SDP %d.\n", sdpi->sdpid);
2095 const SCIP_Real* obj
2100 SCIPdebugMessage(
"Changing %d objective coefficients in SDP %d\n", nvars, sdpi->sdpid);
2102 assert( sdpi != NULL );
2103 assert( ind != NULL );
2104 assert( obj != NULL );
2106 for (i = 0; i < nvars; i++)
2108 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2109 sdpi->obj[ind[i]] = obj[i];
2112 sdpi->solved = FALSE;
2113 sdpi->nsdpcalls = 0;
2114 sdpi->niterations = 0;
2124 const SCIP_Real* lb,
2130 SCIPdebugMessage(
"Changing %d variable bounds in SDP %d\n", nvars, sdpi->sdpid);
2132 assert( sdpi != NULL );
2133 assert( ind != NULL );
2134 assert( lb != NULL );
2135 assert( ub != NULL );
2137 for (i = 0; i < nvars; i++)
2139 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2140 sdpi->lb[ind[i]] = lb[i];
2141 sdpi->ub[ind[i]] = ub[i];
2144 sdpi->solved = FALSE;
2145 sdpi->infeasible = FALSE;
2146 sdpi->allfixed = FALSE;
2147 sdpi->nsdpcalls = 0;
2148 sdpi->niterations = 0;
2158 const SCIP_Real* lhs,
2159 const SCIP_Real* rhs
2164 SCIPdebugMessage(
"Changing %d left and right hand sides of SDP %d\n", nrows, sdpi->sdpid);
2166 assert( sdpi != NULL );
2167 assert( 0 <= nrows && nrows <= sdpi->nlpcons );
2168 assert( ind != NULL );
2169 assert( lhs != NULL );
2170 assert( rhs != NULL );
2172 for (i = 0; i < nrows; i++)
2174 assert ( ind[i] >= 0 );
2175 assert ( ind[i] < sdpi->nlpcons );
2176 sdpi->lplhs[ind[i]] = lhs[i];
2177 sdpi->lprhs[ind[i]] = rhs[i];
2180 sdpi->solved = FALSE;
2181 sdpi->infeasible = FALSE;
2182 sdpi->allfixed = FALSE;
2183 sdpi->nsdpcalls = 0;
2184 sdpi->niterations = 0;
2203 assert( sdpi != NULL );
2204 assert( nlprows != NULL );
2206 *nlprows = sdpi->nlpcons;
2217 assert( sdpi != NULL );
2218 assert( nsdpblocks != NULL );
2220 *nsdpblocks = sdpi->nsdpblocks;
2231 assert( sdpi != NULL );
2232 assert( nvars != NULL );
2234 *nvars = sdpi->nvars;
2245 assert( sdpi != NULL );
2246 assert( nnonz != NULL );
2248 *nnonz = sdpi->sdpnnonz;
2259 assert( sdpi != NULL );
2260 assert( nnonz != NULL );
2262 *nnonz = sdpi->sdpconstnnonz;
2273 assert( sdpi != NULL );
2274 assert( nnonz != NULL );
2276 *nnonz = sdpi->lpnnonz;
2291 assert( sdpi != NULL );
2292 assert( firstvar >= 0 );
2293 assert( firstvar <= lastvar );
2294 assert( lastvar < sdpi->nvars);
2295 assert( vals != NULL );
2297 for (i = 0; i < lastvar - firstvar + 1; i++)
2298 vals[i] = sdpi->obj[firstvar + i];
2314 assert( sdpi != NULL );
2315 assert( firstvar >= 0 );
2316 assert( firstvar <= lastvar );
2317 assert( lastvar < sdpi->nvars);
2318 assert( lbs != NULL );
2319 assert( ubs != NULL );
2321 for (i = 0; i < lastvar - firstvar + 1; i++)
2324 lbs[i] = sdpi->lb[firstvar + i];
2326 ubs[i] = sdpi->ub[firstvar + i];
2341 assert( sdpi != NULL );
2342 assert( firstrow >= 0 );
2343 assert( firstrow <= lastrow );
2344 assert( lastrow < sdpi->nlpcons);
2345 assert( lhss != NULL );
2347 for (i = 0; i < lastrow - firstrow + 1; i++)
2348 lhss[firstrow + i] = sdpi->lplhs[i];
2363 assert( sdpi != NULL );
2364 assert( firstrow >= 0 );
2365 assert( firstrow <= lastrow );
2366 assert( lastrow < sdpi->nlpcons);
2367 assert( rhss != NULL );
2369 for (i = 0; i < lastrow - firstrow + 1; i++)
2370 rhss[firstrow + i] = sdpi->lprhs[i];
2393 SCIP_Bool enforceslatercheck,
2398 int* sdpconstnblocknonz = NULL;
2399 int** sdpconstrow = NULL;
2400 int** sdpconstcol = NULL;
2401 SCIP_Real** sdpconstval = NULL;
2402 int** indchanges = NULL;
2403 int* nremovedinds = NULL;
2404 SCIP_Real* lplhsafterfix;
2405 SCIP_Real* lprhsafterfix;
2406 SCIP_Real solvertimelimit;
2407 SCIP_Bool fixingfound;
2409 clock_t currenttime;
2410 int* rowsnactivevars;
2411 int* blockindchanges;
2414 int nremovedblocks = 0;
2416 int naddediterations;
2419 assert( sdpi != NULL );
2421 starttime = clock();
2423 SCIPdebugMessage(
"Forwarding SDP %d to solver!\n", sdpi->sdpid);
2425 sdpi->penalty = FALSE;
2427 sdpi->solved = FALSE;
2428 sdpi->nsdpcalls = 0;
2429 sdpi->niterations = 0;
2433 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks) );
2434 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks) );
2435 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks) );
2436 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks) );
2437 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks) );
2438 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks) );
2439 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks) );
2440 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons) );
2441 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons) );
2442 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons) );
2444 for (block = 0; block < sdpi->nsdpblocks; block++)
2446 sdpconstrow[block] = NULL;
2447 sdpconstcol[block] = NULL;
2448 sdpconstval[block] = NULL;
2449 indchanges[block] = NULL;
2450 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]) );
2451 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2452 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2453 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2460 fixingfound = FALSE;
2463 while ( fixingfound );
2466 for (block = 0; block < sdpi->nsdpblocks; block++)
2467 sdpconstnblocknonz[block] = sdpi->sdpnnonz + sdpi->sdpconstnnonz;
2469 SCIP_CALL(
compConstMatAfterFixings(sdpi, &sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval) );
2472 for (block = 0; block < sdpi->nsdpblocks; block++)
2474 assert ( sdpconstnblocknonz[block] <= sdpi->sdpnnonz + sdpi->sdpconstnnonz );
2476 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2477 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2478 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2481 SCIP_CALL(
findEmptyRowColsSDP(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges, &nremovedblocks) );
2486 if ( sdpi->allfixed && ! sdpi->infeasible )
2488 SCIP_CALL(
checkFixedFeasibilitySdp(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges) );
2491 if ( sdpi->infeasible )
2493 SCIPdebugMessage(
"SDP %d not given to solver, as infeasibility was detected during presolving!\n", sdpi->sdpid++);
2496 sdpi->solved = TRUE;
2500 else if ( sdpi->allfixed )
2502 SCIPdebugMessage(
"SDP %d not given to solver, as all variables were fixed during presolving (the solution was feasible)!\n", sdpi->sdpid++);
2505 sdpi->solved = TRUE;
2511 if ( sdpi->slatercheck )
2513 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2514 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, FALSE) );
2518 solvertimelimit = timelimit;
2521 currenttime = clock();
2522 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2527 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2528 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2529 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2530 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2531 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, startsettings, solvertimelimit) );
2533 sdpi->solved = TRUE;
2536 naddediterations = 0;
2538 sdpi->niterations += naddediterations;
2541 sdpi->nsdpcalls += naddedsdpcalls;
2546 SCIP_Real penaltyparam;
2547 SCIP_Real penaltyparamfact;
2549 SCIP_Real epsilonfact;
2551 SCIP_Bool penaltybound;
2556 penaltybound = TRUE;
2561 solvertimelimit = timelimit;
2564 currenttime = clock();
2565 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2571 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2572 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2573 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2574 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2576 &feasorig, &penaltybound) );
2579 naddediterations = 0;
2581 sdpi->niterations += naddediterations;
2584 sdpi->nsdpcalls += naddedsdpcalls;
2596 SCIPdebugMessage(
"SDP %d found infeasible using penalty formulation, maximum of smallest eigenvalue is %f.\n", sdpi->sdpid, -1.0 * objval);
2597 sdpi->penalty = TRUE;
2598 sdpi->infeasible = TRUE;
2603 penaltybound = TRUE;
2605 penaltyparam = sdpi->penaltyparam;
2608 penaltyparamfact = pow((sdpi->maxpenaltyparam / sdpi->penaltyparam), 1.0/
NINCREASESGAMMA);
2609 epsilon = sdpi->epsilon;
2616 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penaltyparameter %f\n", sdpi->sdpid, penaltyparam);
2619 solvertimelimit = timelimit;
2622 currenttime = clock();
2623 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2627 sdpi->lb, sdpi->ub, sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2628 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2629 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2630 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2631 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, startsettings, solvertimelimit, &feasorig, &penaltybound) );
2634 naddediterations = 0;
2636 sdpi->niterations += naddediterations;
2639 sdpi->nsdpcalls += naddedsdpcalls;
2644 penaltyparam *= penaltyparamfact;
2645 SCIPdebugMessage(
"Solver did not converge even with penalty formulation, increasing penaltyparameter.\n");
2651 if ( objbound > sdpi->bestbound + sdpi->epsilon )
2652 sdpi->bestbound = objbound;
2660 penaltyparam *= penaltyparamfact;
2661 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, increasing penaltyparameter\n");
2665 epsilon *= epsilonfact;
2667 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, even though primal penalty "
2668 "bound was not reached, decreasing epsilon value for duality gap in SDP-solver\n");
2674 if ( epsilon > sdpi->epsilon )
2682 sdpi->penalty = TRUE;
2683 sdpi->solved = TRUE;
2688 SCIPdebugMessage(
"Problem was found to be infeasible using a penalty formulation \n");
2689 sdpi->infeasible = TRUE;
2690 sdpi->penalty = TRUE;
2691 sdpi->solved = TRUE;
2696 SCIPdebugMessage(
"SDP-Solver could not solve the problem even after using a penalty formulation \n");
2697 sdpi->solved = FALSE;
2698 sdpi->penalty = TRUE;
2702 if ( sdpi->solved == FALSE && enforceslatercheck)
2704 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2705 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, TRUE) );
2707 else if ( sdpi->solved == FALSE )
2709 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Numerical trouble\n");
2711 SCIPdebugMessage(
"SDP-Interface was unable to solve SDP %d\n", sdpi->sdpid);
2718 for (block = 0; block < sdpi->nsdpblocks; block++)
2720 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpconstnblocknonz[block]);
2721 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpconstnblocknonz[block]);
2722 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpconstnblocknonz[block]);
2723 BMSfreeBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]);
2725 BMSfreeBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons);
2726 BMSfreeBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons);
2727 BMSfreeBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons);
2728 BMSfreeBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks);
2729 BMSfreeBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks);
2730 BMSfreeBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks);
2731 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks);
2732 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks);
2733 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks);
2734 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks);
2756 assert( sdpi != NULL );
2758 return sdpi->solved;
2766 assert( sdpi != NULL );
2768 return ( ! sdpi->penalty );
2778 assert( sdpi != NULL );
2781 if ( sdpi->infeasible || sdpi->allfixed )
2790 SCIP_Bool* primalfeasible,
2791 SCIP_Bool* dualfeasible
2794 assert( sdpi != NULL );
2797 if ( sdpi->infeasible )
2799 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2800 *dualfeasible = FALSE;
2803 else if ( sdpi->allfixed )
2805 SCIPdebugMessage(
"All variables were fixed during preprocessing, dual problem is feasible, primal feasibility not available\n");
2806 *dualfeasible = TRUE;
2821 assert( sdpi != NULL );
2824 if ( sdpi->infeasible )
2826 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal unboundedness not available\n");
2829 else if ( sdpi->allfixed )
2831 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal unboundedness not available\n");
2844 assert( sdpi != NULL );
2847 if ( sdpi->infeasible )
2849 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2852 else if ( sdpi->allfixed )
2854 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal feasibility not available\n");
2867 assert(sdpi != NULL );
2870 if ( sdpi->infeasible )
2872 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2875 else if ( sdpi->allfixed )
2877 SCIPdebugMessage(
"All variables fixed during preprocessing, primal feasibility not available\n");
2890 assert( sdpi != NULL );
2893 if ( sdpi->infeasible )
2895 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore is not unbounded\n");
2898 else if ( sdpi->allfixed )
2900 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore the problem is not unbounded\n");
2913 assert( sdpi != NULL );
2916 if ( sdpi->infeasible )
2918 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
2921 else if ( sdpi->allfixed )
2923 SCIPdebugMessage(
"All variables were fixed during preprocessing, solution is feasible\n");
2936 assert( sdpi != NULL );
2939 if ( sdpi->infeasible )
2941 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
2944 else if ( sdpi->allfixed )
2946 SCIPdebugMessage(
"All variables fixed during preprocessing, solution is feasible\n");
2958 assert( sdpi != NULL );
2961 if ( sdpi->infeasible )
2963 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this counts as converged.\n");
2966 else if ( sdpi->allfixed )
2968 SCIPdebugMessage(
"All variables were fixed during preprocessing, this counts as converged.\n");
2980 assert( sdpi != NULL );
2983 if ( sdpi->infeasible )
2985 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective limit available.\n");
2988 else if ( sdpi->allfixed )
2990 SCIPdebugMessage(
"All variables were fixed during preprocessing, no objective limit available.\n");
3002 assert( sdpi != NULL );
3005 if ( sdpi->infeasible )
3007 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iteration limit available.\n");
3010 else if ( sdpi->allfixed )
3012 SCIPdebugMessage(
"All variables were fixed during preprocessing, no iteration limit available.\n");
3024 assert( sdpi != NULL );
3026 if ( sdpi->infeasible )
3028 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no time limit available.\n");
3031 else if ( sdpi->allfixed )
3033 SCIPdebugMessage(
"All variables were fixed during preprocessing, no time limit available.\n");
3036 else if ( ! sdpi->solved )
3038 SCIPdebugMessage(
"Problem was not solved, time limit not exceeded.\n");
3059 assert( sdpi != NULL );
3061 if ( ! sdpi->solved )
3063 SCIPdebugMessage(
"Problem wasn't solved yet.\n");
3066 else if ( sdpi->infeasible )
3068 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no internal status available.\n");
3071 else if ( sdpi->allfixed )
3073 SCIPdebugMessage(
"All variables were fixed during preprocessing, no internal status available.\n");
3085 assert( sdpi != NULL );
3088 if ( sdpi->infeasible )
3090 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore there is no optimal solution.\n");
3093 else if ( sdpi->allfixed )
3095 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore there is no optimal solution.\n");
3108 assert( sdpi != NULL );
3110 if ( sdpi->infeasible )
3112 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this is acceptable in a B&B context.\n");
3115 else if ( sdpi->allfixed )
3117 SCIPdebugMessage(
"All variables fixed during preprocessing, this is acceptable in a B&B context.\n");
3120 else if ( ! sdpi->solved )
3122 SCIPdebugMessage(
"Problem not solved succesfully, this is not acceptable in a B&B context.\n");
3135 assert( sdpi != NULL );
3136 assert( objval != NULL );
3139 if ( sdpi->infeasible )
3141 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3145 if ( sdpi->allfixed )
3152 for (v = 0; v < sdpi->nvars; v++)
3153 *objval += sdpi->lb[v] * sdpi->obj[v];
3170 assert( sdpi != NULL );
3171 assert( objlb != NULL );
3176 if ( sdpi->infeasible )
3178 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3182 if ( sdpi->allfixed )
3189 for (v = 0; v < sdpi->nvars; v++)
3190 *objlb += sdpi->lb[v] * sdpi->obj[v];
3200 if ( sdpi->penalty )
3202 *objlb = sdpi->bestbound;
3222 assert( sdpi != NULL );
3223 assert( dualsollength != NULL );
3224 assert( *dualsollength == 0 || dualsol != NULL );
3227 if ( sdpi->infeasible )
3229 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no solution available.\n");
3232 else if ( sdpi->allfixed )
3234 if ( objval != NULL )
3238 if ( *dualsollength > 0 )
3242 assert( dualsol != NULL );
3243 if ( *dualsollength < sdpi->nvars )
3245 SCIPdebugMessage(
"The given array in SCIPsdpiGetSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3246 *dualsollength = sdpi->nvars;
3252 for (v = 0; v < sdpi->nvars; v++)
3253 dualsol[v] = sdpi->lb[v];
3276 assert( sdpi != NULL );
3277 assert( lbvars != NULL );
3278 assert( ubvars != NULL );
3279 assert( arraylength != NULL );
3280 assert( *arraylength >= 0 );
3283 if ( sdpi->infeasible )
3285 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal variables available.\n");
3288 else if ( sdpi->allfixed )
3290 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal variables available.\n");
3305 assert( sdpi != NULL );
3306 assert( iterations != NULL );
3308 *iterations = sdpi->niterations;
3319 assert( sdpi != NULL );
3320 assert( calls != NULL );
3322 *calls = sdpi->nsdpcalls;
3333 assert( sdpi != NULL );
3334 assert( usedsetting != NULL );
3336 if ( ! sdpi->solved )
3338 SCIPdebugMessage(
"Problem was not solved successfully.\n");
3342 else if ( sdpi->infeasible && ! sdpi->penalty )
3344 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3348 else if ( sdpi->allfixed )
3350 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3354 else if ( sdpi->penalty )
3372 assert( sdpi != NULL );
3373 assert( slatersetting != NULL );
3375 if ( ! sdpi->solved )
3377 SCIPdebugMessage(
"Problem was not solved successfully");
3380 SCIPdebugMessage(
", but we could at least compute a lower bound. \n");
3385 switch( sdpi->primalslater )
3397 switch( sdpi->dualslater )
3421 SCIPdebugMessage(
".\n");
3426 switch( sdpi->primalslater )
3438 switch( sdpi->dualslater )
3462 else if ( sdpi->infeasible && ( ! sdpi->penalty ) )
3464 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3468 else if ( sdpi->allfixed )
3470 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3474 else if ( sdpi->penalty )
3476 switch( sdpi->primalslater )
3493 switch( sdpi->dualslater )
3519 switch( sdpi->primalslater )
3526 switch( usedsetting )
3544 switch( usedsetting )
3566 switch( usedsetting )
3584 switch( usedsetting )
3600 switch( sdpi->dualslater )
3608 switch( usedsetting )
3625 switch( usedsetting )
3642 switch( usedsetting )
3676 assert( sdpi != NULL );
3677 assert( primalslater != NULL );
3678 assert( dualslater != NULL );
3681 if ( sdpi->infeasible )
3684 *dualslater = sdpi->dualslater;
3688 if (sdpi->allfixed )
3695 *primalslater = sdpi->primalslater;
3696 *dualslater = sdpi->dualslater;
3718 assert( sdpi != NULL );
3729 assert( sdpi != NULL );
3741 assert( sdpi != NULL );
3742 assert( sdpi->sdpisolver != NULL );
3743 assert( dval != NULL );
3748 *dval = sdpi->epsilon;
3751 *dval = sdpi->feastol;
3757 *dval = sdpi->penaltyparam;
3760 *dval = sdpi->maxpenaltyparam;
3766 return SCIP_PARAMETERUNKNOWN;
3773 assert( REALABS(*dval - val) < sdpi->epsilon );
3787 assert( sdpi != NULL );
3792 sdpi->epsilon = dval;
3796 sdpi->feastol = dval;
3803 sdpi->penaltyparam = dval;
3807 sdpi->maxpenaltyparam = dval;
3813 return SCIP_PARAMETERUNKNOWN;
3826 assert( sdpi != NULL );
3827 assert( sdpi->sdpisolver != NULL );
3828 assert( ival != NULL );
3836 *ival = sdpi->slatercheck;
3839 return SCIP_PARAMETERUNKNOWN;
3848 assert( *ival == val );
3863 assert( sdpi != NULL );
3864 assert( sdpi->sdpisolver != NULL );
3869 assert( ival == 0 || ival == 1 );
3873 sdpi->slatercheck = ival;
3876 return SCIP_PARAMETERUNKNOWN;
3885 assert( ival == val );
3906 SCIP_Real* penaltyparam
3911 sdpi->penaltyparam = *penaltyparam;
3919 SCIP_Real penaltyparam,
3920 SCIP_Real* maxpenaltyparam
3925 sdpi->maxpenaltyparam = *maxpenaltyparam;
3929 if ( sdpi->penaltyparam > *maxpenaltyparam )
3931 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpi->penaltyparam, *maxpenaltyparam);
3932 sdpi->penaltyparam = *maxpenaltyparam;
3956 SCIPdebugMessage(
"Not implemented yet\n");
3957 return SCIP_LPERROR;
3966 SCIPdebugMessage(
"Not implemented yet\n");
3967 return SCIP_LPERROR;
SCIP_RETCODE SCIPsdpiFree(SCIP_SDPI **sdpi)
SCIP_Bool SCIPsdpiIsDualUnbounded(SCIP_SDPI *sdpi)
EXTERN SCIP_RETCODE SCIPsdpiSolverIncreaseCounter(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetSdpCalls(SCIP_SDPISOLVER *sdpisolver, int *calls)
SCIP_RETCODE SCIPsdpiDelLPRows(SCIP_SDPI *sdpi, int firstrow, int lastrow)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetSolFeasibility(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPsdpiChgLPLhRhSides(SCIP_SDPI *sdpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
EXTERN SCIP_RETCODE SCIPsdpiSolverSetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real dval)
#define DEFAULT_SDPSOLVEREPSILON
SCIP_RETCODE SCIPsdpiGetSdpCalls(SCIP_SDPI *sdpi, int *calls)
EXTERN SCIP_Bool SCIPsdpiSolverIsObjlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetSolFeasibility(SCIP_SDPI *sdpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPsdpiWriteSDP(SCIP_SDPI *sdpi, const char *fname)
EXTERN SCIP_Bool SCIPsdpiSolverIsAcceptable(SCIP_SDPISOLVER *sdpisolver)
static SCIP_RETCODE checkAllFixed(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiGetLPNNonz(SCIP_SDPI *sdpi, int *nnonz)
EXTERN SCIP_RETCODE SCIPsdpiSolverResetCounter(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverFeasibilityKnown(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverIsConverged(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetPrimalBoundVars(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
enum SCIP_SDPSolverSetting SCIP_SDPSOLVERSETTING
SCIP_Bool SCIPsdpiIsOptimal(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpVarfixerMergeArraysIntoNew(BMS_BLKMEM *blkmem, SCIP_Real feastol, int *firstrow, int *firstcol, SCIP_Real *firstval, int firstlength, int *secondrow, int *secondcol, SCIP_Real *secondval, int secondlength, int *targetrow, int *targetcol, SCIP_Real *targetval, int *targetlength)
SCIP_RETCODE SCIPsdpiGetIntpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, int *ival)
SCIP_RETCODE SCIPsdpiGetSDPNNonz(SCIP_SDPI *sdpi, int *nnonz)
SCIP_Bool SCIPsdpiIsInfinity(SCIP_SDPI *sdpi, SCIP_Real val)
const char * SCIPsdpiGetSolverName(void)
EXTERN SCIP_RETCODE SCIPsdpiSolverFree(SCIP_SDPISOLVER **sdpisolver)
EXTERN SCIP_RETCODE SCIPsdpiSolverComputeMaxPenaltyparam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real penaltyparam, SCIP_Real *maxpenaltyparam)
SCIP_RETCODE SCIPsdpiGetNSDPBlocks(SCIP_SDPI *sdpi, int *nsdpblocks)
SCIP_RETCODE SCIPsdpiGetSol(SCIP_SDPI *sdpi, SCIP_Real *objval, SCIP_Real *dualsol, int *dualsollength)
interface methods for specific SDP-solvers
SCIP_Bool SCIPsdpiIsPrimalInfeasible(SCIP_SDPI *sdpi)
SCIP_Bool SCIPsdpiFeasibilityKnown(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiLoadSDP(SCIP_SDPI *sdpi, int nvars, SCIP_Real *obj, SCIP_Real *lb, SCIP_Real *ub, int nsdpblocks, int *sdpblocksizes, int *sdpnblockvars, int sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int sdpnnonz, int **sdpnblockvarnonz, int **sdpvar, int ***sdprow, int ***sdpcol, SCIP_Real ***sdpval, int nlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval)
SCIP_RETCODE SCIPsdpiComputeLambdastar(SCIP_SDPI *sdpi, SCIP_Real maxguess)
EXTERN SCIP_Bool SCIPsdpiSolverWasSolved(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetIterations(SCIP_SDPI *sdpi, int *iterations)
SCIP_RETCODE SCIPsdpiSettingsUsed(SCIP_SDPI *sdpi, SCIP_SDPSOLVERSETTING *usedsetting)
EXTERN SCIP_RETCODE SCIPsdpiSolverComputePenaltyparam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real maxcoeff, SCIP_Real *penaltyparam)
EXTERN SCIP_Bool SCIPsdpiSolverIsDualFeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSlaterSettings(SCIP_SDPI *sdpi, SCIP_SDPSLATERSETTING *slatersetting)
EXTERN SCIP_Bool SCIPsdpiSolverIsOptimal(SCIP_SDPISOLVER *sdpisolver)
static SCIP_RETCODE findEmptyRowColsSDP(SCIP_SDPI *sdpi, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int **indchanges, int *nremovedinds, int *blockindchanges, int *nremovedblocks)
SCIP_Bool SCIPsdpiIsAcceptable(SCIP_SDPI *sdpi)
EXTERN SCIP_Bool SCIPsdpiSolverIsPrimalUnbounded(SCIP_SDPISOLVER *sdpisolver)
EXTERN int SCIPsdpiSolverGetInternalStatus(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiIsIterlimExc(SCIP_SDPI *sdpi)
SCIP_Bool SCIPsdpiIsTimelimExc(SCIP_SDPI *sdpi)
SCIP_Bool SCIPsdpiIsDualInfeasible(SCIP_SDPI *sdpi)
General interface methods for SDP-preprocessing (mainly fixing variables and removing empty rows/cols...
SCIP_RETCODE SCIPsdpiGetConstNNonz(SCIP_SDPI *sdpi, int *nnonz)
enum SCIP_SDPSlaterSetting SCIP_SDPSLATERSETTING
SCIP_RETCODE SCIPsdpiClone(SCIP_SDPI *oldsdpi, SCIP_SDPI *newsdpi)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetIterations(SCIP_SDPISOLVER *sdpisolver, int *iterations)
EXTERN SCIP_RETCODE SCIPsdpiSolverSetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int ival)
SCIP_RETCODE SCIPsdpiChgBounds(SCIP_SDPI *sdpi, int nvars, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
EXTERN const char * SCIPsdpiSolverGetSolverDesc(void)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int *ival)
SCIP_RETCODE SCIPsdpiDelLPRowset(SCIP_SDPI *sdpi, int *dstat)
EXTERN SCIP_Bool SCIPsdpiSolverIsDualInfeasible(SCIP_SDPISOLVER *sdpisolver)
EXTERN const char * SCIPsdpiSolverGetSolverName(void)
SCIP_RETCODE SCIPsdpiGetLowerObjbound(SCIP_SDPI *sdpi, SCIP_Real *objlb)
SCIP_Bool SCIPsdpiIsObjlimExc(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiGetObj(SCIP_SDPI *sdpi, int firstvar, int lastvar, SCIP_Real *vals)
void * SCIPsdpiGetSolverPointer(SCIP_SDPI *sdpi)
int SCIPsdpiGetInternalStatus(SCIP_SDPI *sdpi)
static SCIP_RETCODE checkFixedFeasibilitySdp(SCIP_SDPI *sdpi, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int **indchanges, int *nremovedinds, int *blockindchanges)
SCIP_RETCODE SCIPsdpiCreate(SCIP_SDPI **sdpi, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem)
EXTERN SCIP_Bool SCIPsdpiSolverIsPrimalInfeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiAddLPRows(SCIP_SDPI *sdpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, int nnonz, const int *row, const int *col, const SCIP_Real *val)
SCIP_RETCODE SCIPsdpiGetNVars(SCIP_SDPI *sdpi, int *nvars)
const char * SCIPsdpiGetSolverDesc(void)
SCIP_RETCODE SCIPsdpiComputePenaltyparam(SCIP_SDPI *sdpi, SCIP_Real maxcoeff, SCIP_Real *penaltyparam)
SCIP_RETCODE SCIPsdpiSetIntpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, int ival)
EXTERN SCIP_RETCODE SCIPsdpiSolverSettingsUsed(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPSOLVERSETTING *usedsetting)
SCIP_Bool SCIPsdpiIsPrimalUnbounded(SCIP_SDPI *sdpi)
SCIP_Real SCIPsdpiInfinity(SCIP_SDPI *sdpi)
#define CHECK_IF_SOLVED_BOOL(sdpi)
SCIP_RETCODE SCIPsdpiSolve(SCIP_SDPI *sdpi, SCIP_Real *start, SCIP_SDPSOLVERSETTING startsettings, SCIP_Bool enforceslatercheck, SCIP_Real timelimit)
EXTERN SCIP_Bool SCIPsdpiSolverIsIterlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetRhSides(SCIP_SDPI *sdpi, int firstrow, int lastrow, SCIP_Real *rhss)
#define DUPLICATE_ARRAY_NULL(blkmem, target, source, size)
adds the main functionality to fix/unfix/(multi-)aggregate variables by merging two three-tuple-array...
static void ensureLowerTriangular(int *i, int *j)
EXTERN SCIP_RETCODE SCIPsdpiSolverLoadAndSolve(SCIP_SDPISOLVER *sdpisolver, int nvars, SCIP_Real *obj, SCIP_Real *lb, SCIP_Real *ub, int nsdpblocks, int *sdpblocksizes, int *sdpnblockvars, int sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int sdpnnonz, int **sdpnblockvarnonz, int **sdpvar, int ***sdprow, int ***sdpcol, SCIP_Real ***sdpval, int **indchanges, int *nremovedinds, int *blockindchanges, int nremovedblocks, int nlpcons, int noldlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int *rownactivevars, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval, SCIP_Real *start, SCIP_SDPSOLVERSETTING startsettings, SCIP_Real timelimit)
SCIP_RETCODE SCIPsdpiGetObjval(SCIP_SDPI *sdpi, SCIP_Real *objval)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real *dval)
SCIP_Bool SCIPsdpiIsConverged(SCIP_SDPI *sdpi)
static SCIP_Bool isFixed(SCIP_SDPI *sdpi, int v)
#define DEFAULT_MAXPENALTYPARAM
EXTERN SCIP_Bool SCIPsdpiSolverIsTimelimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiWasSolved(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiReadSDP(SCIP_SDPI *sdpi, const char *fname)
SCIP_RETCODE SCIPsdpiComputeMaxPenaltyparam(SCIP_SDPI *sdpi, SCIP_Real penaltyparam, SCIP_Real *maxpenaltyparam)
SCIP_RETCODE SCIPsdpiClear(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiGetBounds(SCIP_SDPI *sdpi, int firstvar, int lastvar, SCIP_Real *lbs, SCIP_Real *ubs)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetObjval(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval)
SCIP_RETCODE SCIPsdpiChgObj(SCIP_SDPI *sdpi, int nvars, const int *ind, const SCIP_Real *obj)
EXTERN SCIP_Bool SCIPsdpiSolverIsDualUnbounded(SCIP_SDPISOLVER *sdpisolver)
#define DEFAULT_PENALTYPARAM
SCIP_Bool SCIPsdpiIsDualFeasible(SCIP_SDPI *sdpi)
struct SCIP_SDPi SCIP_SDPI
#define DEFAULT_SDPSOLVERFEASTOL
EXTERN SCIP_RETCODE SCIPsdpiSolverGetSol(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval, SCIP_Real *dualsol, int *dualsollength)
SCIP_Bool SCIPsdpiIsPrimalFeasible(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiSetRealpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, SCIP_Real dval)
EXTERN SCIP_Bool SCIPsdpiSolverIsPrimalFeasible(SCIP_SDPISOLVER *sdpisolver)
enum SCIP_SDPSlater SCIP_SDPSLATER
static SCIP_RETCODE checkSlaterCondition(SCIP_SDPI *sdpi, SCIP_Real timelimit, clock_t starttime, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int **indchanges, int *nremovedinds, SCIP_Real *lplhsafterfix, SCIP_Real *lprhsafterfix, int *rowsnactivevars, int *blockindchanges, int sdpconstnnonz, int nactivelpcons, int nremovedblocks, SCIP_Bool rootnodefailed)
struct SCIP_SDPiSolver SCIP_SDPISOLVER
SCIP_RETCODE SCIPsdpiGetRealpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, SCIP_Real *dval)
EXTERN SCIP_RETCODE SCIPsdpiSolverCreate(SCIP_SDPISOLVER **sdpisolver, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem)
static SCIP_RETCODE compConstMatAfterFixings(SCIP_SDPI *sdpi, int *sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval)
#define CHECK_IF_SOLVED(sdpi)
EXTERN SCIP_Real SCIPsdpiSolverInfinity(SCIP_SDPISOLVER *sdpisolver)
enum SCIP_SDPParam SCIP_SDPPARAM
EXTERN void * SCIPsdpiSolverGetSolverPointer(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverIsInfinity(SCIP_SDPISOLVER *sdpisolver, SCIP_Real val)
EXTERN SCIP_RETCODE SCIPsdpiSolverLoadAndSolveWithPenalty(SCIP_SDPISOLVER *sdpisolver, SCIP_Real penaltyparam, SCIP_Bool withobj, SCIP_Bool rbound, int nvars, SCIP_Real *obj, SCIP_Real *lb, SCIP_Real *ub, int nsdpblocks, int *sdpblocksizes, int *sdpnblockvars, int sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int sdpnnonz, int **sdpnblockvarnonz, int **sdpvar, int ***sdprow, int ***sdpcol, SCIP_Real ***sdpval, int **indchanges, int *nremovedinds, int *blockindchanges, int nremovedblocks, int nlpcons, int noldlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int *rownactivevars, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval, SCIP_Real *start, SCIP_SDPSOLVERSETTING startsettings, SCIP_Real timelimit, SCIP_Bool *feasorig, SCIP_Bool *penaltybound)
SCIP_RETCODE SCIPsdpiGetNLPRows(SCIP_SDPI *sdpi, int *nlprows)
SCIP_RETCODE SCIPsdpiGetLhSides(SCIP_SDPI *sdpi, int firstrow, int lastrow, SCIP_Real *lhss)
SCIP_RETCODE SCIPsdpiGetPrimalBoundVars(SCIP_SDPI *sdpi, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
interface methods for eigenvector computation and matrix multiplication using different versions of L...
SCIP_Bool SCIPsdpiSolvedOrig(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiSlater(SCIP_SDPI *sdpi, SCIP_SDPSLATER *primalslater, SCIP_SDPSLATER *dualslater)
#define SCIP_CALL_PARAM(x)
static SCIP_RETCODE computeLpLhsRhsAfterFixings(SCIP_SDPI *sdpi, int *nactivelpcons, SCIP_Real *lplhsafterfix, SCIP_Real *lprhsafterfix, int *rownactivevars, SCIP_Bool *fixingsfound)
EXTERN SCIP_RETCODE SCIPsdpiSolverComputeLambdastar(SCIP_SDPISOLVER *sdpisolver, SCIP_Real maxguess)
EXTERN SCIP_RETCODE SCIPlapackComputeIthEigenvalue(BMS_BLKMEM *blkmem, SCIP_Bool geteigenvectors, int n, SCIP_Real *A, int i, SCIP_Real *eigenvalue, SCIP_Real *eigenvector)