48 #include "blockmemshell/memory.h" 50 #include "scip/pub_misc.h" 51 #include "scip/pub_message.h" 58 #define BMS_CALL(x) do \ 62 SCIPerrorMessage("No memory in function call\n"); \ 63 return SCIP_NOMEMORY; \ 69 #define CHECK_IF_SOLVED(sdpi) do \ 71 if ( ! (sdpi->solved) ) \ 73 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \ 74 return SCIP_LPERROR; \ 80 #define CHECK_IF_SOLVED_BOOL(sdpi) do \ 82 if ( ! (sdpi->solved) ) \ 84 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \ 91 #define DUPLICATE_ARRAY_NULL(blkmem, target, source, size) do \ 94 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, target, source, size) ); \ 101 #define SCIP_CALL_PARAM(x) do \ 103 SCIP_RETCODE _restat_; \ 104 if ( (_restat_ = (x)) != SCIP_OKAY ) \ 106 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \ 108 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \ 117 #define SCIP_CALL_PARAM_IGNORE_UNKNOWN(x) do \ 119 SCIP_RETCODE _restat_; \ 120 if ( (_restat_ = (x)) != SCIP_OKAY ) \ 122 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \ 124 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \ 132 #define MIN_GAPTOL 1e-10 134 #define DEFAULT_SDPSOLVERGAPTOL 1e-4 135 #define DEFAULT_FEASTOL 1e-6 136 #define DEFAULT_EPSILON 1e-9 137 #define DEFAULT_PENALTYPARAM 1e+5 138 #define DEFAULT_MAXPENALTYPARAM 1e+10 139 #define DEFAULT_NPENALTYINCR 8 145 SCIP_MESSAGEHDLR* messagehdlr;
158 int* sdpconstnblocknonz;
162 SCIP_Real** sdpconstval;
166 int** sdpnblockvarnonz;
191 SCIP_Bool infeasible;
196 SCIP_Real penaltyparam;
197 SCIP_Real maxpenaltyparam;
199 SCIP_Real peninfeasadjust;
240 assert ( sdpi != NULL );
241 assert ( v < sdpi->nvars );
242 assert ( sdpi->lb != NULL );
243 assert ( sdpi->ub != NULL );
248 assert( lb < ub + sdpi->feastol || sdpi->infeasible );
250 return ( ub-lb <= sdpi->epsilon );
253 #define isFixed(sdpi, v) (sdpi->ub[v] - sdpi->lb[v] <= sdpi->epsilon) 267 int* sdpconstnblocknonz,
271 SCIP_Real** sdpconstval
280 SCIP_Real** fixedvals;
282 assert ( sdpi != NULL );
283 assert ( sdpconstnnonz != NULL );
284 assert ( sdpconstnblocknonz != NULL );
285 assert ( sdpconstrow != NULL );
286 assert ( sdpconstcol != NULL );
287 assert ( sdpconstval != NULL );
289 for (block = 0; block < sdpi->nsdpblocks; block++)
291 assert ( sdpconstrow[block] != NULL );
292 assert ( sdpconstcol[block] != NULL );
293 assert ( sdpconstval[block] != NULL );
302 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks) );
303 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks) );
304 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks) );
305 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks) );
307 for (block = 0; block < sdpi->nsdpblocks; block++)
310 nfixednonz[block] = 0;
311 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
313 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
314 nfixednonz[block] += sdpi->sdpnblockvarnonz[block][v];
317 fixedrows[block] = NULL;
318 fixedcols[block] = NULL;
319 fixedvals[block] = NULL;
321 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]) );
322 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]) );
323 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]) );
326 nfixednonz[block] = 0;
330 for (block = 0; block < sdpi->nsdpblocks; block++)
332 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
334 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
336 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
338 fixedrows[block][nfixednonz[block]] = sdpi->sdprow[block][v][i];
339 fixedcols[block][nfixednonz[block]] = sdpi->sdpcol[block][v][i];
342 fixedvals[block][nfixednonz[block]] = - sdpi->sdpval[block][v][i] * sdpi->lb[sdpi->sdpvar[block][v]];
351 for (block = 0; block < sdpi->nsdpblocks; block++)
354 sdpi->sdpconstnblocknonz[block], fixedrows[block], fixedcols[block], fixedvals[block], nfixednonz[block],
355 sdpconstrow[block], sdpconstcol[block], sdpconstval[block], &sdpconstnblocknonz[block]) );
356 *sdpconstnnonz += sdpconstnblocknonz[block];
360 for (block = 0; block < sdpi->nsdpblocks; block++)
362 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]);
363 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]);
364 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]);
366 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks);
367 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks);
368 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks);
369 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks);
380 int* sdpconstnblocknonz,
384 SCIP_Real** sdpconstval,
390 int* blockindchanges,
399 assert( sdpi != NULL );
400 assert( sdpconstnblocknonz != NULL );
401 assert( sdpconstrow != NULL );
402 assert( sdpconstcol != NULL );
403 assert( sdpconstval != NULL );
404 assert( indchanges != NULL );
405 assert( nremovedinds != NULL );
406 assert( blockindchanges != NULL );
407 assert( nremovedblocks != NULL );
410 for (block = 0; block < sdpi->nsdpblocks; block++)
412 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
413 indchanges[block][i] = -1;
419 for (block = 0; block < sdpi->nsdpblocks; block++)
423 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
425 if ( ! (
isFixed(sdpi, sdpi->sdpvar[block][v])) )
427 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
429 assert ( REALABS(sdpi->sdpval[block][v][i]) > sdpi->epsilon);
430 if ( indchanges[block][sdpi->sdprow[block][v][i]] == -1 )
432 indchanges[block][sdpi->sdprow[block][v][i]] = 1;
435 if ( indchanges[block][sdpi->sdpcol[block][v][i]] == -1 )
437 indchanges[block][sdpi->sdpcol[block][v][i]] = 1;
440 if ( nfoundinds == sdpi->sdpblocksizes[block] )
444 if (nfoundinds == sdpi->sdpblocksizes[block])
448 if ( nfoundinds < sdpi->sdpblocksizes[block] )
451 for (i = 0; i < sdpconstnblocknonz[block]; i++)
453 assert ( REALABS(sdpconstval[block][i]) > sdpi->epsilon);
454 if ( indchanges[block][sdpconstrow[block][i]] == -1 )
456 indchanges[block][sdpconstrow[block][i]] = 1;
459 if ( indchanges[block][sdpconstcol[block][i]] == -1 )
461 indchanges[block][sdpconstcol[block][i]] = 1;
464 if ( nfoundinds == sdpi->sdpblocksizes[block] )
470 nremovedinds[block] = 0;
471 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
473 if ( indchanges[block][i] == -1 )
475 SCIPdebugMessage(
"empty row and col %d were removed from block %d of SDP %d\n", i, block, sdpi->sdpid);
477 nremovedinds[block]++;
482 indchanges[block][i] = nremovedinds[block];
487 if ( nremovedinds[block] == sdpi->sdpblocksizes[block] )
489 SCIPdebugMessage(
"empty block %d detected in SDP %d, this will be removed", block, sdpi->sdpid);
490 blockindchanges[block] = -1;
494 blockindchanges[block] = *nremovedblocks;
508 SCIP_Real* lplhsafterfix,
512 SCIP_Real* lprhsafterfix,
517 SCIP_Bool* fixingsfound
527 assert( sdpi != NULL );
528 assert( nactivelpcons != NULL );
529 assert( sdpi->nlpcons == 0 || lplhsafterfix != NULL );
530 assert( sdpi->nlpcons == 0 || lprhsafterfix != NULL );
531 assert( sdpi->nlpcons == 0 || rownactivevars != NULL );
532 assert( sdpi->nlpcons == 0 || fixingsfound != NULL );
535 if ( sdpi->nlpcons == 0 || sdpi->lpnnonz == 0 )
542 for (c = 0; c < sdpi->nlpcons; c++)
543 rownactivevars[c] = 0;
546 for (i = 0; i < sdpi->lpnnonz; i++)
548 assert( i == 0 || sdpi->lprow[i-1] <= sdpi->lprow[i] );
551 if ( sdpi->lprow[i] > lastrow )
554 if ( lastrow >= 0 && rownactivevars[lastrow] > 1 )
556 else if ( lastrow >= 0 && rownactivevars[lastrow] == 1 )
558 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
560 nonzcol = sdpi->lpcol[nonzind];
561 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
563 nonzval = sdpi->lpval[nonzind];
564 assert( REALABS(nonzval) > sdpi->epsilon );
571 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
574 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f " 575 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
576 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
579 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
581 *fixingsfound = TRUE;
582 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
583 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
586 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
588 sdpi->infeasible = TRUE;
589 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
590 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
596 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
599 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f " 600 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
601 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
604 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
606 *fixingsfound = TRUE;
607 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
608 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
612 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
614 sdpi->infeasible = TRUE;
615 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
616 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
625 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
628 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f " 629 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
630 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
633 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
635 *fixingsfound = TRUE;
636 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
637 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
641 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
643 sdpi->infeasible = TRUE;
644 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
645 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
651 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
654 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f " 655 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
656 sdpi->ub[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
659 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
661 *fixingsfound = TRUE;
662 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
663 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
667 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
669 sdpi->infeasible = TRUE;
670 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
671 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
677 else if ( lastrow >= 0 )
679 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
681 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
683 sdpi->infeasible = TRUE;
684 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
685 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
691 lastrow = sdpi->lprow[i];
694 lplhsafterfix[*nactivelpcons] = sdpi->lplhs[lastrow];
695 lprhsafterfix[*nactivelpcons] = sdpi->lprhs[lastrow];
699 if ( !
isFixed(sdpi, sdpi->lpcol[i]) )
701 rownactivevars[lastrow]++;
707 lplhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
708 lprhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
713 if ( rownactivevars[lastrow] > 1 )
715 else if ( rownactivevars[lastrow] == 1 )
717 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
719 nonzcol = sdpi->lpcol[nonzind];
720 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
722 nonzval = sdpi->lpval[nonzind];
723 assert( REALABS(nonzval) > sdpi->epsilon );
730 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
733 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f " 734 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
735 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
738 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
740 *fixingsfound = TRUE;
741 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
742 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
746 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
748 sdpi->infeasible = TRUE;
749 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
755 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] - sdpi->epsilon) )
758 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f " 759 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
760 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
763 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
765 *fixingsfound = TRUE;
766 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
767 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
771 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
773 sdpi->infeasible = TRUE;
774 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
783 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
786 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f " 787 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
788 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
791 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
793 *fixingsfound = TRUE;
794 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
795 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
799 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
801 sdpi->infeasible = TRUE;
802 SCIPdebugMessage(
"We found a lower bound that is bigger than the upper bound, so the problem is infeasible !\n");
808 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
811 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f " 812 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
813 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
816 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
818 *fixingsfound = TRUE;
819 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
820 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
824 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
826 sdpi->infeasible = TRUE;
827 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
835 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
837 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
839 sdpi->infeasible = TRUE;
840 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
841 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
858 for (v = 0; v < sdpi->nvars; v++)
862 sdpi->allfixed = FALSE;
869 SCIPdebugMessage(
"Detected that all variables in SDP %d are fixed.\n", sdpi->sdpid);
870 sdpi->allfixed = TRUE;
881 int* sdpconstnblocknonz,
885 SCIP_Real** sdpconstval,
894 SCIP_Real* fullmatrix;
897 SCIP_Real eigenvalue;
903 assert( sdpi->allfixed );
908 for (b = 0; b < sdpi->nsdpblocks; b++)
910 if ( sdpi->sdpblocksizes[b] - nremovedinds[b] > maxsize )
911 maxsize = sdpi->sdpblocksizes[b] - nremovedinds[b];
915 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize) );
918 for (b = 0; b < sdpi->nsdpblocks; b++)
921 if ( blockindchanges[b] == -1 )
924 size = sdpi->sdpblocksizes[b] - nremovedinds[b];
927 for (i = 0; i < size * size; i++)
931 for (i = 0; i < sdpconstnblocknonz[b]; i++)
933 assert( 0 <= sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] && sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] < size );
934 assert( 0 <= sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] && sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] < size );
935 fullmatrix[(sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]]) * size
936 + sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]]] = -1 * sdpconstval[b][i];
940 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
942 fixedval = sdpi->lb[sdpi->sdpvar[b][v]];
945 if ( REALABS(fixedval) < sdpi->epsilon )
949 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
951 assert( 0 <= sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] &&
952 sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] < size );
953 assert( 0 <= sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] &&
954 sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] < size );
955 fullmatrix[(sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]]) * size
956 + sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]]] += fixedval * sdpi->sdpval[b][v][i];
964 if ( eigenvalue < -1 * sdpi->feastol )
966 sdpi->infeasible = TRUE;
967 SCIPdebugMessage(
"Detected infeasibility for SDP %d with all fixed variables!\n", sdpi->sdpid);
973 BMSfreeBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize);
976 sdpi->infeasible = FALSE;
977 SCIPdebugMessage(
"Unique solution for SDP %d with all fixed variables is feasible!\n", sdpi->sdpid);
990 int* sdpconstnblocknonz,
994 SCIP_Real** sdpconstval,
998 SCIP_Real* lplhsafterfix,
999 SCIP_Real* lprhsafterfix,
1000 int* rowsnactivevars,
1001 int* blockindchanges,
1006 SCIP_Bool rootnodefailed
1011 SCIP_Bool origfeas = FALSE;
1012 SCIP_Bool penaltybound = FALSE;
1015 SCIP_Real* slaterlpval;
1016 SCIP_Real* slaterlplhs;
1017 SCIP_Real* slaterlprhs;
1018 int* slaterrowsnactivevars;
1019 int nremovedslaterlpinds;
1023 int slaternactivelpcons;
1024 SCIP_Real* slaterlb;
1025 SCIP_Real* slaterub;
1026 int slaternremovedvarbounds;
1027 SCIP_Real solvertimelimit;
1028 clock_t currenttime;
1030 assert( sdpi != NULL );
1031 assert( sdpconstnnonz == 0 || sdpconstnblocknonz != NULL );
1032 assert( sdpconstnnonz == 0 || sdpconstrow != NULL );
1033 assert( sdpconstnnonz == 0 || sdpconstcol != NULL );
1034 assert( sdpconstnnonz == 0 || sdpconstval != NULL );
1035 assert( sdpi->nsdpblocks == 0 || indchanges != NULL );
1036 assert( sdpi->nsdpblocks == 0 || nremovedinds != NULL );
1037 assert( nactivelpcons == 0 || lplhsafterfix != NULL );
1038 assert( nactivelpcons == 0 || lprhsafterfix != NULL );
1039 assert( sdpi->nlpcons == 0 || rowsnactivevars != NULL );
1040 assert( sdpi->nsdpblocks == 0 || blockindchanges != NULL );
1045 solvertimelimit = timelimit;
1048 currenttime = clock();
1049 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
1055 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1056 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1057 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1058 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1059 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1064 if ( rootnodefailed )
1066 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem could " 1067 "not be checked, ");
1069 else if ( sdpi->slatercheck == 2 )
1070 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for dual problem.\n");
1077 if ( rootnodefailed )
1078 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds " 1079 "as smallest eigenvalue maximization problem is unbounded, ");
1082 SCIPdebugMessage(
"Slater condition for dual problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded.\n", sdpi->sdpid);
1088 if ( rootnodefailed )
1090 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem " 1091 "not fullfilled as problem is infeasible, ");
1093 else if ( sdpi->slatercheck == 2 )
1094 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for dual problem for SDP %d not fullfilled, problem infeasible.\n", sdpi->sdpid);
1101 if ( objval < - sdpi->feastol )
1103 if ( rootnodefailed )
1105 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds" 1106 "with smallest eigenvalue %f, ", -1.0 * objval);
1109 SCIPdebugMessage(
"Slater condition for SDP %d is fullfilled for dual problem with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1112 else if ( objval < sdpi->feastol )
1114 if ( rootnodefailed )
1116 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem " 1117 "not fullfilled with smallest eigenvalue %f, ", -1.0 * objval);
1119 else if ( sdpi->slatercheck == 2 )
1121 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, expect numerical trouble.\n",
1122 sdpi->sdpid, -1.0 * objval);
1128 if ( sdpi->slatercheck == 2 )
1130 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, problem is infeasible.\n",
1131 sdpi->sdpid, -1.0 * objval);
1156 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars) );
1157 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars) );
1158 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars) );
1161 for (i = 0; i < sdpi->lpnnonz; i++)
1163 slaterlprow[i] = sdpi->lprow[i];
1164 slaterlpcol[i] = sdpi->lpcol[i];
1165 slaterlpval[i] = sdpi->lpval[i];
1169 for (v = 0; v < sdpi->nvars; v++)
1171 slaterlprow[sdpi->lpnnonz + v] = sdpi->nlpcons;
1172 slaterlpcol[sdpi->lpnnonz + v] = v;
1173 slaterlpval[sdpi->lpnnonz + v] = 0.0;
1175 for (b = 0; b < sdpi->nsdpblocks; b++)
1177 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
1179 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
1181 if ( sdpi->sdprow[b][v][i] == sdpi->sdpcol[b][v][i] )
1182 slaterlpval[sdpi->lpnnonz + sdpi->sdpvar[b][v]] += sdpi->sdpval[b][v][i];
1188 nremovedslaterlpinds = 0;
1189 for (v = 0; v < sdpi->nvars; v++)
1191 if ( REALABS(slaterlpval[sdpi->lpnnonz + v]) <= sdpi->epsilon )
1192 nremovedslaterlpinds++;
1196 slaterlprow[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlprow[sdpi->lpnnonz + v];
1197 slaterlpcol[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpcol[sdpi->lpnnonz + v];
1198 slaterlpval[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpval[sdpi->lpnnonz + v];
1203 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1) );
1204 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1) );
1207 for (i = 0; i < nactivelpcons; i++)
1210 slaterlplhs[i] = lplhsafterfix[i];
1212 slaterlplhs[i] = 0.0;
1215 slaterlprhs[i] = lprhsafterfix[i];
1217 slaterlprhs[i] = 0.0;
1221 slaterlplhs[nactivelpcons] = 1.0;
1225 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1) );
1228 for (i = 0; i < sdpi->nlpcons; i++)
1229 slaterrowsnactivevars[i] = rowsnactivevars[i];
1232 slaterrowsnactivevars[sdpi->nlpcons] = 0;
1233 for (v = 0; v < sdpi->nvars; v++)
1236 slaterrowsnactivevars[sdpi->nlpcons]++;
1239 slaternactivelpcons = (slaterrowsnactivevars[sdpi->nlpcons] > 1) ? nactivelpcons + 1 : nactivelpcons;
1246 slaternremovedvarbounds = 0;
1247 for (v = 0; v < sdpi->nvars; v++)
1252 slaternremovedvarbounds++;
1257 slaternremovedvarbounds++;
1264 if ( slaternremovedvarbounds == 2 * sdpi->nvars )
1266 if ( rootnodefailed )
1268 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem holds since all variables have finite upper and lower bounds \n");
1271 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled as all variables have finite upper and lower bounds \n", sdpi->sdpid);
1277 currenttime = clock();
1278 solvertimelimit = timelimit - ((SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC);
1282 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, 0, NULL, NULL, NULL, NULL,
1283 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1284 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, slaternactivelpcons, sdpi->nlpcons + 1, slaterlplhs, slaterlprhs,
1285 slaterrowsnactivevars, sdpi->lpnnonz + sdpi->nvars - nremovedslaterlpinds, slaterlprow, slaterlpcol, slaterlpval, NULL, NULL, NULL, NULL,
1290 if ( rootnodefailed )
1292 SCIPmessagePrintInfo(sdpi->messagehdlr,
"unable to check Slater condition for primal problem \n");
1294 else if ( sdpi->slatercheck == 2 )
1295 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for primal problem, could not solve auxilliary problem.\n");
1300 if ( rootnodefailed )
1302 SCIPmessagePrintInfo(sdpi->messagehdlr,
" primal Slater condition shows infeasibility \n");
1304 else if ( sdpi->slatercheck == 2 )
1306 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled " 1307 "smallest eigenvalue has to be negative, so primal problem is infeasible (if the dual slater condition holds," 1308 "this means, that the original (dual) problem is unbounded.\n",sdpi->sdpid);
1314 if ( rootnodefailed )
1316 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problems holds sunce smallest eigenvalue maximization problem" 1320 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded \n", sdpi->sdpid);
1327 if ( objval > - sdpi->feastol)
1329 if ( rootnodefailed )
1331 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem not fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1333 else if ( sdpi->slatercheck == 2 )
1335 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled " 1336 "as smallest eigenvalue was %f, expect numerical trouble or infeasible problem.\n",sdpi->sdpid, -1.0 * objval);
1342 if ( rootnodefailed )
1344 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1347 SCIPdebugMessage(
"Slater condition for primal problem of SDP %d is fullfilled with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1354 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterub, sdpi->nvars);
1355 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlb, sdpi->nvars);
1356 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1);
1357 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1);
1358 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1);
1359 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars);
1360 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars);
1361 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars);
1448 SCIP_MESSAGEHDLR* messagehdlr,
1453 assert ( sdpi != NULL );
1454 assert ( blkmem != NULL );
1456 SCIPdebugMessage(
"Calling SCIPsdpiCreate\n");
1458 BMS_CALL( BMSallocBlockMemory(blkmem, sdpi) );
1462 (*sdpi)->messagehdlr = messagehdlr;
1463 (*sdpi)->blkmem = blkmem;
1464 (*sdpi)->bufmem = bufmem;
1466 (*sdpi)->niterations = 0;
1467 (*sdpi)->nsdpcalls = 0;
1469 (*sdpi)->nsdpblocks = 0;
1470 (*sdpi)->sdpconstnnonz = 0;
1471 (*sdpi)->sdpnnonz = 0;
1472 (*sdpi)->nlpcons = 0;
1473 (*sdpi)->lpnnonz = 0;
1474 (*sdpi)->slatercheck = 0;
1475 (*sdpi)->solved = FALSE;
1476 (*sdpi)->penalty = FALSE;
1477 (*sdpi)->infeasible = FALSE;
1478 (*sdpi)->allfixed = FALSE;
1480 (*sdpi)->obj = NULL;
1483 (*sdpi)->sdpblocksizes = NULL;
1484 (*sdpi)->sdpnblockvars = NULL;
1485 (*sdpi)->sdpconstnblocknonz = NULL;
1486 (*sdpi)->sdpconstrow = NULL;
1487 (*sdpi)->sdpconstcol = NULL;
1488 (*sdpi)->sdpconstval = NULL;
1489 (*sdpi)->sdpnblockvarnonz = NULL;
1490 (*sdpi)->sdpvar = NULL;
1491 (*sdpi)->sdprow = NULL;
1492 (*sdpi)->sdpcol = NULL;
1493 (*sdpi)->sdpval = NULL;
1494 (*sdpi)->lplhs = NULL;
1495 (*sdpi)->lprhs = NULL;
1496 (*sdpi)->lprow = NULL;
1497 (*sdpi)->lpcol = NULL;
1498 (*sdpi)->lpval = NULL;
1521 SCIPdebugMessage(
"Calling SCIPsdpiFree \n");
1522 assert ( sdpi != NULL );
1523 assert ( *sdpi != NULL );
1526 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpval), (*sdpi)->lpnnonz);
1527 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpcol), (*sdpi)->lpnnonz);
1528 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprow), (*sdpi)->lpnnonz);
1529 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprhs), (*sdpi)->nlpcons);
1530 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lplhs), (*sdpi)->nlpcons);
1533 for (i = 0; i < (*sdpi)->nsdpblocks; i++)
1535 for (j = 0; j < (*sdpi)->sdpnblockvars[i]; j++)
1537 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1538 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1539 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1541 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i]), (*sdpi)->sdpnblockvars[i]);
1542 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i]), (*sdpi)->sdpnblockvars[i]);
1543 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i]), (*sdpi)->sdpnblockvars[i]);
1544 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar[i]), (*sdpi)->sdpnblockvars[i]);
1545 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz[i]), (*sdpi)->sdpnblockvars[i]);
1546 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval[i]), (*sdpi)->sdpconstnblocknonz[i]);
1547 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow[i]), (*sdpi)->sdpconstnblocknonz[i]);
1548 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol[i]), (*sdpi)->sdpconstnblocknonz[i]);
1552 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz), (*sdpi)->nsdpblocks);
1553 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstnblocknonz), (*sdpi)->nsdpblocks);
1554 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval), (*sdpi)->nsdpblocks);
1555 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol), (*sdpi)->nsdpblocks);
1556 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow), (*sdpi)->nsdpblocks);
1557 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar), (*sdpi)->nsdpblocks);
1558 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval), (*sdpi)->nsdpblocks);
1559 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol), (*sdpi)->nsdpblocks);
1560 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow), (*sdpi)->nsdpblocks);
1561 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvars), (*sdpi)->nsdpblocks);
1562 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpblocksizes), (*sdpi)->nsdpblocks);
1563 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->ub), (*sdpi)->nvars);
1564 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lb), (*sdpi)->nvars);
1565 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->obj), (*sdpi)->nvars);
1570 BMSfreeBlockMemory((*sdpi)->blkmem, sdpi);
1591 assert( oldsdpi != NULL );
1593 SCIPdebugMessage(
"Cloning SDPI %d\n", oldsdpi->sdpid);
1596 blkmem = oldsdpi->blkmem;
1597 nvars = oldsdpi->nvars;
1598 nsdpblocks = oldsdpi->nsdpblocks;
1599 lpnnonz = oldsdpi->lpnnonz;
1601 BMS_CALL( BMSallocBlockMemory(blkmem, &newsdpi) );
1603 SCIP_CALL(
SCIPsdpiSolverCreate(&(newsdpi->sdpisolver), oldsdpi->messagehdlr, oldsdpi->blkmem, oldsdpi->bufmem) );
1605 newsdpi->messagehdlr = oldsdpi->messagehdlr;
1606 newsdpi->blkmem = blkmem;
1607 newsdpi->nvars = nvars;
1609 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->obj), oldsdpi->obj, nvars) );
1610 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lb), oldsdpi->lb, nvars) );
1611 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->ub), oldsdpi->ub, nvars) );
1613 newsdpi->nsdpblocks = nsdpblocks;
1615 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpblocksizes), oldsdpi->sdpblocksizes, nsdpblocks) );
1616 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvars), oldsdpi->sdpnblockvars, nsdpblocks) );
1619 newsdpi->sdpconstnnonz = oldsdpi->sdpconstnnonz;
1621 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstnblocknonz), oldsdpi->sdpconstnblocknonz, nsdpblocks) );
1622 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow), nsdpblocks) );
1623 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol), nsdpblocks) );
1624 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstval), nsdpblocks) );
1626 for (b = 0; b < nsdpblocks; b++)
1628 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow[b]), oldsdpi->sdpconstrow[b], oldsdpi->sdpconstnblocknonz[b]) );
1629 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol[b]), oldsdpi->sdpconstcol[b], oldsdpi->sdpconstnblocknonz[b]) );
1630 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstval[b]), oldsdpi->sdpconstval[b], oldsdpi->sdpconstnblocknonz[b]) );
1634 newsdpi->sdpnnonz = oldsdpi->sdpnnonz;
1636 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz), nsdpblocks) );
1637 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpvar), nsdpblocks) );
1638 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow), nsdpblocks) );
1639 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol), nsdpblocks) );
1640 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval), nsdpblocks) );
1642 for (b = 0; b < nsdpblocks; b++)
1644 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz[b]), oldsdpi->sdpnblockvarnonz[b], oldsdpi->sdpnblockvars[b]) );
1645 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpvar[b]), oldsdpi->sdpvar[b], oldsdpi->sdpnblockvars[b]) );
1647 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow[b]), oldsdpi->sdpnblockvars[b]) );
1648 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b]), oldsdpi->sdpnblockvars[b]) );
1649 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval[b]), oldsdpi->sdpnblockvars[b]) );
1651 for (v = 0; v < oldsdpi->sdpnblockvars[b]; v++)
1653 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdprow[b][v]), oldsdpi->sdprow[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1654 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b][v]), oldsdpi->sdpcol[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1655 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpval[b][v]), oldsdpi->sdpval[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1660 newsdpi->nlpcons = oldsdpi->nlpcons;
1662 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lplhs), oldsdpi->lplhs, oldsdpi->nlpcons) );
1663 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprhs), oldsdpi->lprhs, oldsdpi->nlpcons) );
1665 newsdpi->lpnnonz = lpnnonz;
1667 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprow), oldsdpi->lprow, lpnnonz) );
1668 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpcol), oldsdpi->lpcol, lpnnonz) );
1669 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpval), oldsdpi->lpval, lpnnonz) );
1672 newsdpi->solved = FALSE;
1673 newsdpi->penalty = FALSE;
1674 newsdpi->infeasible = FALSE;
1675 newsdpi->allfixed = FALSE;
1676 newsdpi->sdpid = 1000000 + oldsdpi->sdpid;
1677 newsdpi->epsilon = oldsdpi->epsilon;
1678 newsdpi->gaptol = oldsdpi->gaptol;
1679 newsdpi->feastol = oldsdpi->feastol;
1709 int* sdpconstnblocknonz,
1713 SCIP_Real** sdpconstval,
1715 int** sdpnblockvarnonz,
1723 SCIP_Real*** sdpval,
1738 SCIPdebugMessage(
"Calling SCIPsdpiLoadSDP (%d)\n",sdpi->sdpid);
1740 assert ( sdpi != NULL );
1741 assert ( nvars > 0 );
1742 assert ( obj != NULL );
1743 assert ( lb != NULL );
1744 assert ( ub != NULL );
1747 if (sdpconstnnonz > 0 || sdpnnonz > 0 || nsdpblocks > 0)
1749 assert ( sdpblocksizes != NULL );
1750 assert ( sdpnblockvars != NULL );
1751 assert ( nsdpblocks > 0 );
1752 assert ( sdpconstnblocknonz != NULL );
1753 assert ( sdpnblockvarnonz != NULL );
1755 if (sdpconstnnonz > 0)
1757 assert ( sdpconstrow != NULL );
1758 assert ( sdpconstcol != NULL );
1759 assert ( sdpconstval != NULL );
1761 for (i = 0; i < nsdpblocks; i++)
1763 if (sdpconstnblocknonz[i] > 0)
1765 assert ( sdpconstrow[i] != NULL );
1766 assert ( sdpconstcol[i] != NULL );
1767 assert ( sdpconstval[i] != NULL );
1774 assert ( sdprow != NULL );
1775 assert ( sdpcol != NULL );
1776 assert ( sdpval != NULL );
1778 for ( i = 0; i < nsdpblocks; i++ )
1780 assert ( sdpcol[i] != NULL );
1781 assert ( sdprow[i] != NULL );
1782 assert ( sdpval[i] != NULL );
1784 for ( v = 0; v < sdpnblockvars[i]; v++)
1786 if (sdpnblockvarnonz[i][v] > 0)
1788 assert ( sdpcol[i][v] != NULL );
1789 assert ( sdprow[i][v] != NULL );
1790 assert ( sdpval[i][v] != NULL );
1798 assert ( nlpcons == 0 || lplhs != NULL );
1799 assert ( nlpcons == 0 || lprhs != NULL );
1800 assert ( lpnnonz == 0 || lprow != NULL );
1801 assert ( lpnnonz == 0 || lpcol != NULL );
1802 assert ( lpnnonz == 0 || lpval != NULL );
1807 for (block = sdpi->nsdpblocks - 1; block >= 0; block--)
1809 for (v = sdpi->sdpnblockvars[block] - 1; v >= 0; v--)
1811 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1812 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1813 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1816 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block]), sdpi->sdpnblockvars[block]);
1817 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block]), sdpi->sdpnblockvars[block]);
1818 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpi->sdpnblockvars[block]);
1819 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpi->sdpconstnblocknonz[block]);
1820 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpi->sdpconstnblocknonz[block]);
1821 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpi->sdpconstnblocknonz[block]);
1822 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpi->sdpnblockvars[block]);
1823 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpi->sdpnblockvars[block]);
1826 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->ub), sdpi->nvars);
1827 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lb), sdpi->nvars);
1828 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->obj), sdpi->nvars);
1830 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpblocksizes), sdpi->nsdpblocks);
1831 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvars), sdpi->nsdpblocks);
1832 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpi->nsdpblocks);
1835 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->obj), obj, nvars) );
1836 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->lb), lb, nvars) );
1837 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->ub), ub, nvars) );
1840 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpconstnblocknonz, nsdpblocks);
1843 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpnblockvarnonz), sdpi->nsdpblocks, nsdpblocks) );
1844 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstcol), sdpi->nsdpblocks, nsdpblocks) );
1845 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstrow), sdpi->nsdpblocks, nsdpblocks) );
1846 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstval), sdpi->nsdpblocks, nsdpblocks) );
1847 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpvar), sdpi->nsdpblocks, nsdpblocks) );
1848 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol), sdpi->nsdpblocks, nsdpblocks) );
1849 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow), sdpi->nsdpblocks, nsdpblocks) );
1850 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval), sdpi->nsdpblocks, nsdpblocks) );
1852 for (block = 0; block < nsdpblocks; block++)
1854 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpnblockvarnonz[block], sdpnblockvars[block]);
1856 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpconstcol[block], sdpconstnblocknonz[block]);
1857 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpconstrow[block], sdpconstnblocknonz[block]);
1858 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpconstval[block], sdpconstnblocknonz[block]);
1861 for (i = 0; i < sdpi->sdpconstnblocknonz[block]; ++i)
1864 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpvar[block], sdpnblockvars[block]);
1866 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpnblockvars[block]) );
1867 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow[block]), sdpnblockvars[block]) );
1868 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval[block]), sdpnblockvars[block]) );
1870 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
1872 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpcol[block][v], sdpnblockvarnonz[block][v]);
1873 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdprow[block][v], sdpnblockvarnonz[block][v]);
1874 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpval[block][v], sdpnblockvarnonz[block][v]);
1877 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; ++i)
1883 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1884 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1885 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1886 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1887 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1896 sdpi->nvars = nvars;
1897 sdpi->nsdpblocks = nsdpblocks;
1899 sdpi->sdpconstnnonz = sdpconstnnonz;
1900 sdpi->sdpnnonz = sdpnnonz;
1903 sdpi->lpnnonz = lpnnonz;
1904 sdpi->nlpcons = nlpcons;
1906 sdpi->solved = FALSE;
1907 sdpi->infeasible = FALSE;
1908 sdpi->allfixed = FALSE;
1909 sdpi->nsdpcalls = 0;
1910 sdpi->niterations = 0;
1922 const SCIP_Real* lhs,
1923 const SCIP_Real* rhs,
1928 const SCIP_Real* val
1933 SCIPdebugMessage(
"Adding %d LP-Constraints to SDP %d.\n", nrows, sdpi->sdpid);
1935 assert ( sdpi != NULL );
1940 assert ( lhs != NULL );
1941 assert ( rhs != NULL );
1942 assert ( nnonz >= 0 );
1943 assert ( row != NULL );
1944 assert ( col != NULL );
1945 assert ( val != NULL );
1947 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1948 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1950 for (i = 0; i < nrows; i++)
1952 sdpi->lplhs[sdpi->nlpcons + i] = lhs[i];
1953 sdpi->lprhs[sdpi->nlpcons + i] = rhs[i];
1956 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1957 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1958 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1960 for (i = 0; i < nnonz; i++)
1962 assert ( 0 <= row[i] && row[i] < nrows );
1964 sdpi->lprow[sdpi->lpnnonz + i] = row[i] + sdpi->nlpcons;
1966 assert ( 0 <= col[i] && col[i] < sdpi->nvars );
1967 sdpi->lpcol[sdpi->lpnnonz + i] = col[i];
1969 sdpi->lpval[sdpi->lpnnonz + i] = val[i];
1972 sdpi->nlpcons = sdpi->nlpcons + nrows;
1973 sdpi->lpnnonz = sdpi->lpnnonz + nnonz;
1975 sdpi->solved = FALSE;
1976 sdpi->infeasible = FALSE;
1977 sdpi->nsdpcalls = 0;
1978 sdpi->niterations = 0;
1996 SCIPdebugMessage(
"Deleting rows %d to %d from SDP %d.\n", firstrow, lastrow, sdpi->sdpid);
1998 assert ( sdpi != NULL );
1999 assert ( firstrow >= 0 );
2000 assert ( firstrow <= lastrow );
2001 assert ( lastrow < sdpi->nlpcons );
2004 if (firstrow == 0 && lastrow == sdpi->nlpcons - 1)
2006 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
2007 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
2008 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
2009 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
2010 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
2021 sdpi->solved = FALSE;
2022 sdpi->infeasible = FALSE;
2023 sdpi->allfixed = FALSE;
2024 sdpi->nsdpcalls = 0;
2025 sdpi->niterations = 0;
2030 deletedrows = lastrow - firstrow + 1;
2034 for (i = lastrow + 1; i < sdpi->nlpcons; i++)
2036 sdpi->lplhs[i - deletedrows] = sdpi->lplhs[i];
2037 sdpi->lprhs[i - deletedrows] = sdpi->lprhs[i];
2039 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2040 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2043 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
2047 for (i = 0; i < sdpi->lpnnonz; i++)
2049 if (sdpi->lprow[i] >= firstrow && sdpi->lprow[i] <= lastrow)
2058 if (firstrowind > -1)
2061 while (i < sdpi->lpnnonz && sdpi->lprow[i] <= lastrow)
2066 deletednonz = lastrowind - firstrowind + 1;
2069 for (i = lastrowind + 1; i < sdpi->lpnnonz; i++)
2071 sdpi->lpcol[i - deletednonz] = sdpi->lpcol[i];
2073 sdpi->lprow[i - deletednonz] = sdpi->lprow[i] - deletedrows;
2074 sdpi->lpval[i - deletednonz] = sdpi->lpval[i];
2078 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2079 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2080 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2081 sdpi->nlpcons = sdpi->nlpcons - deletedrows;
2082 sdpi->lpnnonz = sdpi->lpnnonz - deletednonz;
2084 sdpi->solved = FALSE;
2085 sdpi->infeasible = FALSE;
2086 sdpi->allfixed = FALSE;
2087 sdpi->nsdpcalls = 0;
2088 sdpi->niterations = 0;
2105 SCIPdebugMessage(
"Calling SCIPsdpiDelLPRowset for SDP %d.\n", sdpi->sdpid);
2107 assert ( sdpi != NULL );
2108 assert ( dstat != NULL );
2110 oldnlpcons = sdpi->nlpcons;
2113 for (i = 0; i < oldnlpcons; i++)
2123 dstat[i] = i - deletedrows;
2126 sdpi->solved = FALSE;
2127 sdpi->infeasible = FALSE;
2128 sdpi->allfixed = FALSE;
2129 sdpi->nsdpcalls = 0;
2130 sdpi->niterations = 0;
2140 assert( sdpi != NULL );
2142 SCIPdebugMessage(
"Called SCIPsdpiClear in SDP %d.\n", sdpi->sdpid);
2156 const SCIP_Real* obj
2161 SCIPdebugMessage(
"Changing %d objective coefficients in SDP %d\n", nvars, sdpi->sdpid);
2163 assert( sdpi != NULL );
2164 assert( ind != NULL );
2165 assert( obj != NULL );
2167 for (i = 0; i < nvars; i++)
2169 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2170 sdpi->obj[ind[i]] = obj[i];
2173 sdpi->solved = FALSE;
2174 sdpi->nsdpcalls = 0;
2175 sdpi->niterations = 0;
2185 const SCIP_Real* lb,
2191 SCIPdebugMessage(
"Changing %d variable bounds in SDP %d\n", nvars, sdpi->sdpid);
2193 assert( sdpi != NULL );
2194 assert( ind != NULL );
2195 assert( lb != NULL );
2196 assert( ub != NULL );
2198 for (i = 0; i < nvars; i++)
2200 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2201 sdpi->lb[ind[i]] = lb[i];
2202 sdpi->ub[ind[i]] = ub[i];
2205 sdpi->solved = FALSE;
2206 sdpi->infeasible = FALSE;
2207 sdpi->allfixed = FALSE;
2208 sdpi->nsdpcalls = 0;
2209 sdpi->niterations = 0;
2219 const SCIP_Real* lhs,
2220 const SCIP_Real* rhs
2225 SCIPdebugMessage(
"Changing %d left and right hand sides of SDP %d\n", nrows, sdpi->sdpid);
2227 assert( sdpi != NULL );
2228 assert( 0 <= nrows && nrows <= sdpi->nlpcons );
2229 assert( ind != NULL );
2230 assert( lhs != NULL );
2231 assert( rhs != NULL );
2233 for (i = 0; i < nrows; i++)
2235 assert ( ind[i] >= 0 );
2236 assert ( ind[i] < sdpi->nlpcons );
2237 sdpi->lplhs[ind[i]] = lhs[i];
2238 sdpi->lprhs[ind[i]] = rhs[i];
2241 sdpi->solved = FALSE;
2242 sdpi->infeasible = FALSE;
2243 sdpi->allfixed = FALSE;
2244 sdpi->nsdpcalls = 0;
2245 sdpi->niterations = 0;
2264 assert( sdpi != NULL );
2265 assert( nlprows != NULL );
2267 *nlprows = sdpi->nlpcons;
2278 assert( sdpi != NULL );
2279 assert( nsdpblocks != NULL );
2281 *nsdpblocks = sdpi->nsdpblocks;
2292 assert( sdpi != NULL );
2293 assert( nvars != NULL );
2295 *nvars = sdpi->nvars;
2306 assert( sdpi != NULL );
2307 assert( nnonz != NULL );
2309 *nnonz = sdpi->sdpnnonz;
2320 assert( sdpi != NULL );
2321 assert( nnonz != NULL );
2323 *nnonz = sdpi->sdpconstnnonz;
2334 assert( sdpi != NULL );
2335 assert( nnonz != NULL );
2337 *nnonz = sdpi->lpnnonz;
2352 assert( sdpi != NULL );
2353 assert( firstvar >= 0 );
2354 assert( firstvar <= lastvar );
2355 assert( lastvar < sdpi->nvars);
2356 assert( vals != NULL );
2358 for (i = 0; i < lastvar - firstvar + 1; i++)
2359 vals[i] = sdpi->obj[firstvar + i];
2375 assert( sdpi != NULL );
2376 assert( firstvar >= 0 );
2377 assert( firstvar <= lastvar );
2378 assert( lastvar < sdpi->nvars);
2379 assert( lbs != NULL );
2380 assert( ubs != NULL );
2382 for (i = 0; i < lastvar - firstvar + 1; i++)
2385 lbs[i] = sdpi->lb[firstvar + i];
2387 ubs[i] = sdpi->ub[firstvar + i];
2402 assert( sdpi != NULL );
2403 assert( firstrow >= 0 );
2404 assert( firstrow <= lastrow );
2405 assert( lastrow < sdpi->nlpcons);
2406 assert( lhss != NULL );
2408 for (i = 0; i < lastrow - firstrow + 1; i++)
2409 lhss[firstrow + i] = sdpi->lplhs[i];
2424 assert( sdpi != NULL );
2425 assert( firstrow >= 0 );
2426 assert( firstrow <= lastrow );
2427 assert( lastrow < sdpi->nlpcons);
2428 assert( rhss != NULL );
2430 for (i = 0; i < lastrow - firstrow + 1; i++)
2431 rhss[firstrow + i] = sdpi->lprhs[i];
2457 int* startZnblocknonz,
2463 SCIP_Real** startZval,
2465 int* startXnblocknonz,
2471 SCIP_Real** startXval,
2475 SCIP_Bool enforceslatercheck,
2480 int* sdpconstnblocknonz = NULL;
2481 int** sdpconstrow = NULL;
2482 int** sdpconstcol = NULL;
2483 SCIP_Real** sdpconstval = NULL;
2484 int** indchanges = NULL;
2485 int* nremovedinds = NULL;
2486 SCIP_Real* lplhsafterfix;
2487 SCIP_Real* lprhsafterfix;
2488 SCIP_Real solvertimelimit;
2489 SCIP_Bool fixingfound;
2491 clock_t currenttime;
2492 int* rowsnactivevars;
2493 int* blockindchanges;
2496 int nremovedblocks = 0;
2498 int naddediterations;
2501 assert( sdpi != NULL );
2503 starttime = clock();
2505 SCIPdebugMessage(
"Forwarding SDP %d to solver!\n", sdpi->sdpid);
2507 sdpi->penalty = FALSE;
2509 sdpi->solved = FALSE;
2510 sdpi->nsdpcalls = 0;
2511 sdpi->niterations = 0;
2515 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks) );
2516 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks) );
2517 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks) );
2518 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks) );
2519 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks) );
2520 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks) );
2521 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks) );
2522 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons) );
2523 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons) );
2524 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons) );
2526 for (block = 0; block < sdpi->nsdpblocks; block++)
2528 sdpconstrow[block] = NULL;
2529 sdpconstcol[block] = NULL;
2530 sdpconstval[block] = NULL;
2531 indchanges[block] = NULL;
2532 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]) );
2533 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2534 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2535 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2542 fixingfound = FALSE;
2545 while ( fixingfound );
2548 for (block = 0; block < sdpi->nsdpblocks; block++)
2549 sdpconstnblocknonz[block] = sdpi->sdpnnonz + sdpi->sdpconstnnonz;
2551 SCIP_CALL(
compConstMatAfterFixings(sdpi, &sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval) );
2554 for (block = 0; block < sdpi->nsdpblocks; block++)
2556 assert ( sdpconstnblocknonz[block] <= sdpi->sdpnnonz + sdpi->sdpconstnnonz );
2558 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2559 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2560 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2563 SCIP_CALL(
findEmptyRowColsSDP(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges, &nremovedblocks) );
2568 if ( sdpi->allfixed && ! sdpi->infeasible )
2570 SCIP_CALL(
checkFixedFeasibilitySdp(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges) );
2573 if ( sdpi->infeasible )
2575 SCIPdebugMessage(
"SDP %d not given to solver, as infeasibility was detected during presolving!\n", sdpi->sdpid++);
2578 sdpi->solved = TRUE;
2582 else if ( sdpi->allfixed )
2584 SCIPdebugMessage(
"SDP %d not given to solver, as all variables were fixed during presolving (the solution was feasible)!\n", sdpi->sdpid++);
2587 sdpi->solved = TRUE;
2593 if ( sdpi->slatercheck )
2595 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2596 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, FALSE) );
2600 solvertimelimit = timelimit;
2603 currenttime = clock();
2604 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2609 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2610 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2611 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2612 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2613 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2614 startXnblocknonz, startXrow, startXcol, startXval, startsettings, solvertimelimit) );
2616 sdpi->solved = TRUE;
2619 naddediterations = 0;
2621 sdpi->niterations += naddediterations;
2624 sdpi->nsdpcalls += naddedsdpcalls;
2629 SCIP_Real penaltyparam;
2630 SCIP_Real penaltyparamfact;
2632 SCIP_Real gaptolfact;
2634 SCIP_Bool penaltybound;
2639 penaltybound = TRUE;
2644 solvertimelimit = timelimit;
2647 currenttime = clock();
2648 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2651 SCIPdebugMessage(
"SDP %d returned inacceptable result, trying penalty formulation.\n", sdpi->sdpid);
2656 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2657 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2658 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2659 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2660 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2664 naddediterations = 0;
2666 sdpi->niterations += naddediterations;
2669 sdpi->nsdpcalls += naddedsdpcalls;
2685 sdpi->peninfeasadjust * sdpi->feastol : sdpi->peninfeasadjust * sdpi->gaptol))) ||
2688 SCIPdebugMessage(
"SDP %d found infeasible using penalty formulation, maximum of smallest eigenvalue is %f.\n", sdpi->sdpid, -1.0 * objval);
2689 sdpi->penalty = TRUE;
2690 sdpi->infeasible = TRUE;
2695 penaltybound = TRUE;
2697 penaltyparam = sdpi->penaltyparam;
2699 SCIPdebugMessage(
"SDP %d not found infeasible using penalty formulation, maximum of smallest eigenvalue is %f.\n", sdpi->sdpid, -1.0 * objval);
2704 penaltyparamfact = sdpi->npenaltyincr > 0 ? pow((sdpi->maxpenaltyparam / sdpi->penaltyparam), 1.0/sdpi->npenaltyincr) :
2705 2*sdpi->maxpenaltyparam / sdpi->penaltyparam;
2706 gaptol = sdpi->gaptol;
2707 gaptolfact = sdpi->npenaltyincr > 0 ? pow((
MIN_GAPTOL / sdpi->gaptol), 1.0/sdpi->npenaltyincr) : 0.5 *
MIN_GAPTOL / sdpi->gaptol;
2713 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penaltyparameter %f\n", sdpi->sdpid, penaltyparam);
2716 solvertimelimit = timelimit;
2719 currenttime = clock();
2720 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2722 if ( solvertimelimit <= 0 )
2727 sdpi->lb, sdpi->ub, sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2728 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2729 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2730 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2731 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2732 startXnblocknonz, startXrow, startXcol, startXval, startsettings, solvertimelimit, &feasorig, &penaltybound) );
2735 naddediterations = 0;
2737 sdpi->niterations += naddediterations;
2740 sdpi->nsdpcalls += naddedsdpcalls;
2745 penaltyparam *= penaltyparamfact;
2746 SCIPdebugMessage(
"Solver did not converge even with penalty formulation, increasing penaltyparameter.\n");
2752 if ( objbound > sdpi->bestbound + sdpi->gaptol )
2753 sdpi->bestbound = objbound;
2761 penaltyparam *= penaltyparamfact;
2762 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, increasing penaltyparameter\n");
2766 gaptol *= gaptolfact;
2768 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, even though primal penalty " 2769 "bound was not reached, decreasing tolerance for duality gap in SDP-solver\n");
2775 if ( gaptol > sdpi->gaptol )
2783 sdpi->penalty = TRUE;
2784 sdpi->solved = TRUE;
2789 SCIPdebugMessage(
"Problem was found to be infeasible using a penalty formulation \n");
2790 sdpi->infeasible = TRUE;
2791 sdpi->penalty = TRUE;
2792 sdpi->solved = TRUE;
2797 SCIPdebugMessage(
"SDP-Solver could not solve the problem even after using a penalty formulation \n");
2798 sdpi->solved = FALSE;
2799 sdpi->penalty = TRUE;
2803 if ( sdpi->solved == FALSE && enforceslatercheck)
2805 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2806 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, TRUE) );
2808 else if ( sdpi->solved == FALSE )
2811 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Numerical trouble\n");
2813 SCIPdebugMessage(
"SDP-Interface was unable to solve SDP %d\n", sdpi->sdpid);
2821 for (block = 0; block < sdpi->nsdpblocks; block++)
2823 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpconstnblocknonz[block]);
2824 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpconstnblocknonz[block]);
2825 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpconstnblocknonz[block]);
2826 BMSfreeBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]);
2828 BMSfreeBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons);
2829 BMSfreeBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons);
2830 BMSfreeBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons);
2831 BMSfreeBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks);
2832 BMSfreeBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks);
2833 BMSfreeBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks);
2834 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks);
2835 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks);
2836 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks);
2837 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks);
2859 assert( sdpi != NULL );
2869 assert( sdpi != NULL );
2882 assert( sdpi != NULL );
2885 if ( sdpi->infeasible || sdpi->allfixed )
2894 SCIP_Bool* primalfeasible,
2895 SCIP_Bool* dualfeasible
2898 assert( sdpi != NULL );
2901 if ( sdpi->infeasible )
2903 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2904 *dualfeasible = FALSE;
2907 else if ( sdpi->allfixed )
2909 SCIPdebugMessage(
"All variables were fixed during preprocessing, dual problem is feasible, primal feasibility not available\n");
2910 *dualfeasible = TRUE;
2926 assert( sdpi != NULL );
2929 if ( sdpi->infeasible )
2931 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal unboundedness not available\n");
2934 else if ( sdpi->allfixed )
2936 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal unboundedness not available\n");
2950 assert( sdpi != NULL );
2953 if ( sdpi->infeasible )
2955 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2958 else if ( sdpi->allfixed )
2960 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal feasibility not available\n");
2974 assert(sdpi != NULL );
2977 if ( sdpi->infeasible )
2979 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2982 else if ( sdpi->allfixed )
2984 SCIPdebugMessage(
"All variables fixed during preprocessing, primal feasibility not available\n");
2998 assert( sdpi != NULL );
3001 if ( sdpi->infeasible )
3003 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore is not unbounded\n");
3006 else if ( sdpi->allfixed )
3008 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore the problem is not unbounded\n");
3022 assert( sdpi != NULL );
3025 if ( sdpi->infeasible )
3027 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3030 else if ( sdpi->allfixed )
3032 SCIPdebugMessage(
"All variables were fixed during preprocessing, solution is feasible\n");
3046 assert( sdpi != NULL );
3049 if ( sdpi->infeasible )
3051 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3054 else if ( sdpi->allfixed )
3056 SCIPdebugMessage(
"All variables fixed during preprocessing, solution is feasible\n");
3068 assert( sdpi != NULL );
3071 if ( sdpi->infeasible )
3073 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this counts as converged.\n");
3076 else if ( sdpi->allfixed )
3078 SCIPdebugMessage(
"All variables were fixed during preprocessing, this counts as converged.\n");
3090 assert( sdpi != NULL );
3093 if ( sdpi->infeasible )
3095 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective limit available.\n");
3098 else if ( sdpi->allfixed )
3100 SCIPdebugMessage(
"All variables were fixed during preprocessing, no objective limit available.\n");
3112 assert( sdpi != NULL );
3115 if ( sdpi->infeasible )
3117 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iteration limit available.\n");
3120 else if ( sdpi->allfixed )
3122 SCIPdebugMessage(
"All variables were fixed during preprocessing, no iteration limit available.\n");
3134 assert( sdpi != NULL );
3136 if ( sdpi->infeasible )
3138 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no time limit available.\n");
3141 else if ( sdpi->allfixed )
3143 SCIPdebugMessage(
"All variables were fixed during preprocessing, no time limit available.\n");
3146 else if ( ! sdpi->solved )
3148 SCIPdebugMessage(
"Problem was not solved, time limit not exceeded.\n");
3170 assert( sdpi != NULL );
3172 if ( ! sdpi->solved )
3174 SCIPdebugMessage(
"Problem wasn't solved yet.\n");
3177 else if ( sdpi->infeasible )
3179 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no internal status available.\n");
3182 else if ( sdpi->allfixed )
3184 SCIPdebugMessage(
"All variables were fixed during preprocessing, no internal status available.\n");
3196 assert( sdpi != NULL );
3199 if ( sdpi->infeasible )
3201 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore there is no optimal solution.\n");
3204 else if ( sdpi->allfixed )
3206 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore there is no optimal solution.\n");
3220 assert( sdpi != NULL );
3222 if ( sdpi->infeasible )
3224 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this is acceptable in a B&B context.\n");
3227 else if ( sdpi->allfixed )
3229 SCIPdebugMessage(
"All variables fixed during preprocessing, this is acceptable in a B&B context.\n");
3232 else if ( ! sdpi->solved )
3234 SCIPdebugMessage(
"Problem not solved succesfully, this is not acceptable in a B&B context.\n");
3247 assert( sdpi != NULL );
3248 assert( objval != NULL );
3251 if ( sdpi->infeasible )
3253 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3257 if ( sdpi->allfixed )
3264 for (v = 0; v < sdpi->nvars; v++)
3265 *objval += sdpi->lb[v] * sdpi->obj[v];
3283 assert( sdpi != NULL );
3284 assert( objlb != NULL );
3289 if ( sdpi->infeasible )
3291 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3295 if ( sdpi->allfixed )
3302 for (v = 0; v < sdpi->nvars; v++)
3303 *objlb += sdpi->lb[v] * sdpi->obj[v];
3313 if ( sdpi->penalty )
3315 *objlb = sdpi->bestbound;
3336 assert( sdpi != NULL );
3337 assert( dualsollength != NULL );
3338 assert( *dualsollength == 0 || dualsol != NULL );
3341 if ( sdpi->infeasible )
3343 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no solution available.\n");
3346 else if ( sdpi->allfixed )
3348 if ( objval != NULL )
3352 if ( *dualsollength > 0 )
3356 assert( dualsol != NULL );
3357 if ( *dualsollength < sdpi->nvars )
3359 SCIPdebugMessage(
"The given array in SCIPsdpiGetSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3360 *dualsollength = sdpi->nvars;
3366 for (v = 0; v < sdpi->nvars; v++)
3367 dualsol[v] = sdpi->lb[v];
3382 int* startXnblocknonz
3386 assert( sdpi != NULL );
3387 assert( nblocks >= 0 );
3388 assert( startXnblocknonz != NULL );
3390 if ( sdpi->infeasible )
3392 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no preoptimal solution available.\n");
3393 startXnblocknonz[0] = -1;
3397 else if ( sdpi->allfixed )
3399 SCIPdebugMessage(
"No primal solution available, as problem was solved during preprocessing\n");
3400 startXnblocknonz[0] = -1;
3424 int* startXnblocknonz,
3428 SCIP_Real** startXval
3431 assert( sdpi != NULL );
3432 assert( success != NULL );
3433 assert( dualsol != NULL );
3434 assert( dualsollength != NULL );
3435 assert( *dualsollength >= 0 );
3436 assert( startXnblocknonz != NULL || nblocks == -1 );
3437 assert( startXrow != NULL || nblocks == -1 );
3438 assert( startXcol != NULL || nblocks == -1 );
3439 assert( startXval != NULL || nblocks == -1 );
3441 if ( sdpi->infeasible )
3444 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no preoptimal solution available.\n");
3445 assert( startXnblocknonz != NULL );
3446 startXnblocknonz[0] = -1;
3450 else if ( sdpi->allfixed )
3454 assert( dualsol != NULL );
3458 if ( *dualsollength < sdpi->nvars )
3460 SCIPdebugMessage(
"The given array in SCIPsdpiGetPreoptimalSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3461 *dualsollength = sdpi->nvars;
3467 for (v = 0; v < sdpi->nvars; v++)
3468 dualsol[v] = sdpi->lb[v];
3472 SCIPdebugMessage(
"No primal solution available, as problem was solved during preprocessing\n");
3473 assert( startXnblocknonz != NULL );
3474 startXnblocknonz[0] = -1;
3481 startXrow, startXcol, startXval) );
3499 assert( sdpi != NULL );
3500 assert( lbvars != NULL );
3501 assert( ubvars != NULL );
3502 assert( arraylength != NULL );
3503 assert( *arraylength >= 0 );
3506 if ( sdpi->infeasible )
3508 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal variables available.\n");
3511 else if ( sdpi->allfixed )
3513 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal variables available.\n");
3526 int* startXnblocknonz
3529 assert( sdpi != NULL );
3531 if ( sdpi->infeasible )
3533 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal solution available.\n");
3536 else if ( sdpi->allfixed )
3538 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal solution available.\n");
3556 int* startXnblocknonz,
3560 SCIP_Real** startXval
3563 assert( sdpi != NULL );
3565 if ( sdpi->infeasible )
3567 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal solution available.\n");
3570 else if ( sdpi->allfixed )
3572 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal solution available.\n");
3586 assert( sdpi != NULL );
3597 assert( sdpi != NULL );
3598 assert( iterations != NULL );
3600 *iterations = sdpi->niterations;
3611 assert( sdpi != NULL );
3612 assert( calls != NULL );
3614 *calls = sdpi->nsdpcalls;
3625 assert( sdpi != NULL );
3626 assert( usedsetting != NULL );
3628 if ( ! sdpi->solved )
3630 SCIPdebugMessage(
"Problem was not solved successfully.\n");
3634 else if ( sdpi->infeasible && ! sdpi->penalty )
3636 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3640 else if ( sdpi->allfixed )
3642 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3646 else if ( sdpi->penalty )
3664 assert( sdpi != NULL );
3665 assert( slatersetting != NULL );
3667 if ( ! sdpi->solved )
3669 SCIPdebugMessage(
"Problem was not solved successfully");
3672 SCIPdebugMessage(
", but we could at least compute a lower bound. \n");
3677 switch( sdpi->primalslater )
3689 switch( sdpi->dualslater )
3713 SCIPdebugMessage(
".\n");
3718 switch( sdpi->primalslater )
3730 switch( sdpi->dualslater )
3754 else if ( sdpi->infeasible && ( ! sdpi->penalty ) )
3756 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3760 else if ( sdpi->allfixed )
3762 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3766 else if ( sdpi->penalty )
3768 switch( sdpi->primalslater )
3785 switch( sdpi->dualslater )
3811 switch( sdpi->primalslater )
3818 switch( usedsetting )
3836 switch( usedsetting )
3858 switch( usedsetting )
3876 switch( usedsetting )
3892 switch( sdpi->dualslater )
3900 switch( usedsetting )
3917 switch( usedsetting )
3934 switch( usedsetting )
3968 assert( sdpi != NULL );
3969 assert( primalslater != NULL );
3970 assert( dualslater != NULL );
3972 if ( sdpi->infeasible )
3975 *dualslater = sdpi->dualslater;
3979 if (sdpi->allfixed )
3986 *primalslater = sdpi->primalslater;
3987 *dualslater = sdpi->dualslater;
4009 assert( sdpi != NULL );
4020 assert( sdpi != NULL );
4032 assert( sdpi != NULL );
4033 assert( sdpi->sdpisolver != NULL );
4034 assert( dval != NULL );
4039 *dval = sdpi->epsilon;
4042 *dval = sdpi->gaptol;
4045 *dval = sdpi->feastol;
4054 *dval = sdpi->penaltyparam;
4057 *dval = sdpi->maxpenaltyparam;
4066 *dval = sdpi->peninfeasadjust;
4069 return SCIP_PARAMETERUNKNOWN;
4082 assert( sdpi != NULL );
4087 sdpi->epsilon = dval;
4091 sdpi->gaptol = dval;
4095 sdpi->feastol = dval;
4105 sdpi->penaltyparam = dval;
4109 sdpi->maxpenaltyparam = dval;
4118 sdpi->peninfeasadjust = dval;
4121 return SCIP_PARAMETERUNKNOWN;
4134 assert( sdpi != NULL );
4135 assert( sdpi->sdpisolver != NULL );
4136 assert( ival != NULL );
4145 *ival = sdpi->slatercheck;
4148 *ival = sdpi->npenaltyincr;
4151 return SCIP_PARAMETERUNKNOWN;
4164 assert( sdpi != NULL );
4165 assert( sdpi->sdpisolver != NULL );
4170 assert( ival == 0 || ival == 1 );
4177 sdpi->slatercheck = ival;
4180 sdpi->npenaltyincr = ival;
4183 return SCIP_PARAMETERUNKNOWN;
4202 SCIP_Real* penaltyparam
4207 sdpi->penaltyparam = *penaltyparam;
4215 SCIP_Real penaltyparam,
4216 SCIP_Real* maxpenaltyparam
4221 sdpi->maxpenaltyparam = *maxpenaltyparam;
4225 if ( sdpi->penaltyparam > *maxpenaltyparam )
4227 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpi->penaltyparam, *maxpenaltyparam);
4228 sdpi->penaltyparam = *maxpenaltyparam;
4252 assert( sdpi != NULL );
4253 assert( fname != NULL );
4255 SCIPdebugMessage(
"Not implemented yet\n");
4256 return SCIP_LPERROR;
4265 assert( sdpi != NULL );
4266 assert( fname != NULL );
4268 SCIPdebugMessage(
"Not implemented yet\n");
4269 return SCIP_LPERROR;
SCIP_RETCODE SCIPsdpiFree(SCIP_SDPI **sdpi)
SCIP_Bool SCIPsdpiIsDualUnbounded(SCIP_SDPI *sdpi)
#define DEFAULT_SDPSOLVERGAPTOL
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetPrimalBoundVars(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
SCIP_RETCODE SCIPsdpiDelLPRows(SCIP_SDPI *sdpi, int firstrow, int lastrow)
SCIP_EXPORT SCIP_Real SCIPsdpiSolverInfinity(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT int SCIPsdpiSolverGetInternalStatus(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiChgLPLhRhSides(SCIP_SDPI *sdpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int *ival)
SCIP_RETCODE SCIPsdpiGetSdpCalls(SCIP_SDPI *sdpi, int *calls)
SCIP_Bool SCIPsdpiDoesWarmstartNeedPrimal(void)
SCIP_EXPORT SCIP_Real SCIPsdpiSolverGetMaxPrimalEntry(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetSolFeasibility(SCIP_SDPI *sdpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPsdpiWriteSDP(SCIP_SDPI *sdpi, const char *fname)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real *dval)
static SCIP_RETCODE checkAllFixed(SCIP_SDPI *sdpi)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverResetCounter(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverSettingsUsed(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPSOLVERSETTING *usedsetting)
SCIP_RETCODE SCIPsdpiGetLPNNonz(SCIP_SDPI *sdpi, int *nnonz)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetPreoptimalSol(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *success, SCIP_Real *dualsol, int *dualsollength, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
SCIP_RETCODE SCIPsdpiGetPrimalMatrix(SCIP_SDPI *sdpi, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
enum SCIP_SDPSolverSetting SCIP_SDPSOLVERSETTING
SCIP_Bool SCIPsdpiIsOptimal(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiGetIntpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, int *ival)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsObjlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetSDPNNonz(SCIP_SDPI *sdpi, int *nnonz)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsConverged(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiIsInfinity(SCIP_SDPI *sdpi, SCIP_Real val)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverSetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real dval)
const char * SCIPsdpiGetSolverName(void)
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_EXPORT SCIP_Bool SCIPsdpiSolverIsTimelimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_Real SCIPsdpiSolverGetDefaultSdpiSolverGaptol(void)
SCIP_Bool SCIPsdpiIsPrimalInfeasible(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiSolve(SCIP_SDPI *sdpi, SCIP_Real *starty, int *startZnblocknonz, int **startZrow, int **startZcol, SCIP_Real **startZval, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval, SCIP_SDPSOLVERSETTING startsettings, SCIP_Bool enforceslatercheck, SCIP_Real timelimit)
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)
SCIP_RETCODE SCIPsdpiGetPrimalNonzeros(SCIP_SDPI *sdpi, int nblocks, int *startXnblocknonz)
SCIP_RETCODE SCIPsdpiGetIterations(SCIP_SDPI *sdpi, int *iterations)
SCIP_RETCODE SCIPsdpiSettingsUsed(SCIP_SDPI *sdpi, SCIP_SDPSOLVERSETTING *usedsetting)
SCIP_RETCODE SCIPsdpiSlaterSettings(SCIP_SDPI *sdpi, SCIP_SDPSLATERSETTING *slatersetting)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetSolFeasibility(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsPrimalInfeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetSol(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval, SCIP_Real *dualsol, int *dualsollength)
SCIP_EXPORT SCIP_Real SCIPsdpiSolverGetDefaultSdpiSolverFeastol(void)
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)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsDualFeasible(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)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetSdpCalls(SCIP_SDPISOLVER *sdpisolver, int *calls)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverCreate(SCIP_SDPISOLVER **sdpisolver, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, BMS_BUFMEM *bufmem)
enum SCIP_SDPSlaterSetting SCIP_SDPSLATERSETTING
SCIP_RETCODE SCIPsdpiClone(SCIP_SDPI *oldsdpi, SCIP_SDPI *newsdpi)
SCIP_RETCODE SCIPsdpiChgBounds(SCIP_SDPI *sdpi, int nvars, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_RETCODE SCIPsdpiDelLPRowset(SCIP_SDPI *sdpi, int *dstat)
SCIP_RETCODE SCIPsdpiGetLowerObjbound(SCIP_SDPI *sdpi, SCIP_Real *objlb)
SCIP_Bool SCIPsdpiIsObjlimExc(SCIP_SDPI *sdpi)
#define SCIP_CALL_PARAM_IGNORE_UNKNOWN(x)
SCIP_RETCODE SCIPsdpiGetObj(SCIP_SDPI *sdpi, int firstvar, int lastvar, SCIP_Real *vals)
SCIP_EXPORT int SCIPsdpiSolverGetDefaultSdpiSolverNpenaltyIncreases(void)
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_Real SCIPsdpiGetDefaultSdpiSolverFeastol(void)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverSetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int ival)
SCIP_EXPORT SCIP_RETCODE SCIPlapackComputeIthEigenvalue(BMS_BUFMEM *bufmem, SCIP_Bool geteigenvectors, int n, SCIP_Real *A, int i, SCIP_Real *eigenvalue, SCIP_Real *eigenvector)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverFeasibilityKnown(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_EXPORT const char * SCIPsdpiSolverGetSolverName(void)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetPrimalMatrix(SCIP_SDPISOLVER *sdpisolver, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
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)
SCIP_Bool SCIPsdpiIsPrimalUnbounded(SCIP_SDPI *sdpi)
SCIP_Real SCIPsdpiInfinity(SCIP_SDPI *sdpi)
#define CHECK_IF_SOLVED_BOOL(sdpi)
SCIP_EXPORT 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 *starty, int *startZnblocknonz, int **startZrow, int **startZcol, SCIP_Real **startZval, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval, SCIP_SDPSOLVERSETTING startsettings, SCIP_Real timelimit)
SCIP_RETCODE SCIPsdpiGetRhSides(SCIP_SDPI *sdpi, int firstrow, int lastrow, SCIP_Real *rhss)
SCIP_RETCODE SCIPsdpiCreate(SCIP_SDPI **sdpi, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, BMS_BUFMEM *bufmem)
#define DUPLICATE_ARRAY_NULL(blkmem, target, source, size)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsDualInfeasible(SCIP_SDPISOLVER *sdpisolver)
adds the main functionality to fix/unfix/(multi-)aggregate variables by merging two three-tuple-array...
SCIP_EXPORT const char * SCIPsdpiSolverGetSolverDesc(void)
static void ensureLowerTriangular(int *i, int *j)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverComputeMaxPenaltyparam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real penaltyparam, SCIP_Real *maxpenaltyparam)
SCIP_RETCODE SCIPsdpiGetObjval(SCIP_SDPI *sdpi, SCIP_Real *objval)
SCIP_EXPORT void * SCIPsdpiSolverGetSolverPointer(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsAcceptable(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverIncreaseCounter(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsOptimal(SCIP_SDPISOLVER *sdpisolver)
int SCIPsdpiGetDefaultSdpiSolverNpenaltyIncreases(void)
SCIP_Bool SCIPsdpiIsConverged(SCIP_SDPI *sdpi)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverWasSolved(SCIP_SDPISOLVER *sdpisolver)
static SCIP_Bool isFixed(SCIP_SDPI *sdpi, int v)
#define DEFAULT_MAXPENALTYPARAM
SCIP_Bool SCIPsdpiWasSolved(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiReadSDP(SCIP_SDPI *sdpi, const char *fname)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverDoesWarmstartNeedPrimal(void)
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)
SCIP_RETCODE SCIPsdpiChgObj(SCIP_SDPI *sdpi, int nvars, const int *ind, const SCIP_Real *obj)
SCIP_RETCODE SCIPsdpiGetPreoptimalSol(SCIP_SDPI *sdpi, SCIP_Bool *success, SCIP_Real *dualsol, int *dualsollength, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
#define DEFAULT_NPENALTYINCR
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetObjval(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval)
#define DEFAULT_PENALTYPARAM
SCIP_Bool SCIPsdpiIsDualFeasible(SCIP_SDPI *sdpi)
struct SCIP_SDPi SCIP_SDPI
SCIP_Bool SCIPsdpiIsPrimalFeasible(SCIP_SDPI *sdpi)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverComputePenaltyparam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real maxcoeff, SCIP_Real *penaltyparam)
SCIP_RETCODE SCIPsdpiSetRealpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, SCIP_Real dval)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetPrimalNonzeros(SCIP_SDPISOLVER *sdpisolver, int nblocks, int *startXnblocknonz)
SCIP_EXPORT 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 *starty, int *startZnblocknonz, int **startZrow, int **startZcol, SCIP_Real **startZval, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval, SCIP_SDPSOLVERSETTING startsettings, SCIP_Real timelimit, SCIP_Bool *feasorig, SCIP_Bool *penaltybound)
enum SCIP_SDPSlater SCIP_SDPSLATER
SCIP_Real SCIPsdpiGetMaxPrimalEntry(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpVarfixerMergeArraysIntoNew(BMS_BLKMEM *blkmem, SCIP_Real epsilon, 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)
interface methods for eigenvector computation and matrix multiplication using openblas ...
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)
static SCIP_RETCODE compConstMatAfterFixings(SCIP_SDPI *sdpi, int *sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval)
SCIP_Real SCIPsdpiGetDefaultSdpiSolverGaptol(void)
SCIP_RETCODE SCIPsdpiGetPreoptimalPrimalNonzeros(SCIP_SDPI *sdpi, int nblocks, int *startXnblocknonz)
#define CHECK_IF_SOLVED(sdpi)
enum SCIP_SDPParam SCIP_SDPPARAM
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverFree(SCIP_SDPISOLVER **sdpisolver)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetPreoptimalPrimalNonzeros(SCIP_SDPISOLVER *sdpisolver, int nblocks, int *startXnblocknonz)
SCIP_RETCODE SCIPsdpiGetNLPRows(SCIP_SDPI *sdpi, int *nlprows)
SCIP_RETCODE SCIPsdpiGetLhSides(SCIP_SDPI *sdpi, int firstrow, int lastrow, SCIP_Real *lhss)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverGetIterations(SCIP_SDPISOLVER *sdpisolver, int *iterations)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsInfinity(SCIP_SDPISOLVER *sdpisolver, SCIP_Real val)
SCIP_RETCODE SCIPsdpiGetPrimalBoundVars(SCIP_SDPI *sdpi, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsPrimalFeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_EXPORT SCIP_RETCODE SCIPsdpiSolverComputeLambdastar(SCIP_SDPISOLVER *sdpisolver, SCIP_Real maxguess)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsDualUnbounded(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolvedOrig(SCIP_SDPI *sdpi)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsPrimalUnbounded(SCIP_SDPISOLVER *sdpisolver)
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)
SCIP_EXPORT SCIP_Bool SCIPsdpiSolverIsIterlimExc(SCIP_SDPISOLVER *sdpisolver)