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 SCIP_CALL_PARAM_IGNORE_UNKNOWN(x) do \
118 SCIP_RETCODE _restat_; \
119 if ( (_restat_ = (x)) != SCIP_OKAY ) \
121 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \
123 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \
131 #define MIN_GAPTOL 1e-10
133 #define DEFAULT_SDPSOLVERGAPTOL 1e-4
134 #define DEFAULT_FEASTOL 1e-6
135 #define DEFAULT_EPSILON 1e-9
136 #define DEFAULT_PENALTYPARAM 1e+5
137 #define DEFAULT_MAXPENALTYPARAM 1e+10
138 #define DEFAULT_NPENALTYINCR 8
144 SCIP_MESSAGEHDLR* messagehdlr;
157 int* sdpconstnblocknonz;
161 SCIP_Real** sdpconstval;
165 int** sdpnblockvarnonz;
190 SCIP_Bool infeasible;
195 SCIP_Real penaltyparam;
196 SCIP_Real maxpenaltyparam;
237 assert ( sdpi != NULL );
238 assert ( v < sdpi->nvars );
239 assert ( sdpi->lb != NULL );
240 assert ( sdpi->ub != NULL );
245 assert( lb < ub + sdpi->feastol || sdpi->infeasible );
247 return ( ub-lb <= sdpi->epsilon );
250 #define isFixed(sdpi, v) (sdpi->ub[v] - sdpi->lb[v] <= sdpi->epsilon)
264 int* sdpconstnblocknonz,
268 SCIP_Real** sdpconstval
277 SCIP_Real** fixedvals;
279 assert ( sdpi != NULL );
280 assert ( sdpconstnnonz != NULL );
281 assert ( sdpconstnblocknonz != NULL );
282 assert ( sdpconstrow != NULL );
283 assert ( sdpconstcol != NULL );
284 assert ( sdpconstval != NULL );
286 for (block = 0; block < sdpi->nsdpblocks; block++)
288 assert ( sdpconstrow[block] != NULL );
289 assert ( sdpconstcol[block] != NULL );
290 assert ( sdpconstval[block] != NULL );
299 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks) );
300 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks) );
301 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks) );
302 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks) );
304 for (block = 0; block < sdpi->nsdpblocks; block++)
307 nfixednonz[block] = 0;
308 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
310 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
311 nfixednonz[block] += sdpi->sdpnblockvarnonz[block][v];
314 fixedrows[block] = NULL;
315 fixedcols[block] = NULL;
316 fixedvals[block] = NULL;
318 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]) );
319 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]) );
320 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]) );
323 nfixednonz[block] = 0;
327 for (block = 0; block < sdpi->nsdpblocks; block++)
329 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
331 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
333 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
335 fixedrows[block][nfixednonz[block]] = sdpi->sdprow[block][v][i];
336 fixedcols[block][nfixednonz[block]] = sdpi->sdpcol[block][v][i];
339 fixedvals[block][nfixednonz[block]] = - sdpi->sdpval[block][v][i] * sdpi->lb[sdpi->sdpvar[block][v]];
348 for (block = 0; block < sdpi->nsdpblocks; block++)
351 sdpi->sdpconstnblocknonz[block], fixedrows[block], fixedcols[block], fixedvals[block], nfixednonz[block],
352 sdpconstrow[block], sdpconstcol[block], sdpconstval[block], &sdpconstnblocknonz[block]) );
353 *sdpconstnnonz += sdpconstnblocknonz[block];
357 for (block = 0; block < sdpi->nsdpblocks; block++)
359 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]);
360 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]);
361 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]);
363 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks);
364 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks);
365 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks);
366 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks);
377 int* sdpconstnblocknonz,
381 SCIP_Real** sdpconstval,
387 int* blockindchanges,
396 assert( sdpi != NULL );
397 assert( sdpconstnblocknonz != NULL );
398 assert( sdpconstrow != NULL );
399 assert( sdpconstcol != NULL );
400 assert( sdpconstval != NULL );
401 assert( indchanges != NULL );
402 assert( nremovedinds != NULL );
403 assert( blockindchanges != NULL );
404 assert( nremovedblocks != NULL );
407 for (block = 0; block < sdpi->nsdpblocks; block++)
409 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
410 indchanges[block][i] = -1;
416 for (block = 0; block < sdpi->nsdpblocks; block++)
420 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
422 if ( ! (
isFixed(sdpi, sdpi->sdpvar[block][v])) )
424 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
426 assert ( REALABS(sdpi->sdpval[block][v][i]) > sdpi->epsilon);
427 if ( indchanges[block][sdpi->sdprow[block][v][i]] == -1 )
429 indchanges[block][sdpi->sdprow[block][v][i]] = 1;
432 if ( indchanges[block][sdpi->sdpcol[block][v][i]] == -1 )
434 indchanges[block][sdpi->sdpcol[block][v][i]] = 1;
437 if ( nfoundinds == sdpi->sdpblocksizes[block] )
441 if (nfoundinds == sdpi->sdpblocksizes[block])
445 if ( nfoundinds < sdpi->sdpblocksizes[block] )
448 for (i = 0; i < sdpconstnblocknonz[block]; i++)
450 assert ( REALABS(sdpconstval[block][i]) > sdpi->epsilon);
451 if ( indchanges[block][sdpconstrow[block][i]] == -1 )
453 indchanges[block][sdpconstrow[block][i]] = 1;
456 if ( indchanges[block][sdpconstcol[block][i]] == -1 )
458 indchanges[block][sdpconstcol[block][i]] = 1;
461 if ( nfoundinds == sdpi->sdpblocksizes[block] )
467 nremovedinds[block] = 0;
468 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
470 if ( indchanges[block][i] == -1 )
472 SCIPdebugMessage(
"empty row and col %d were removed from block %d of SDP %d\n", i, block, sdpi->sdpid);
474 nremovedinds[block]++;
479 indchanges[block][i] = nremovedinds[block];
484 if ( nremovedinds[block] == sdpi->sdpblocksizes[block] )
486 SCIPdebugMessage(
"empty block %d detected in SDP %d, this will be removed", block, sdpi->sdpid);
487 blockindchanges[block] = -1;
491 blockindchanges[block] = *nremovedblocks;
505 SCIP_Real* lplhsafterfix,
509 SCIP_Real* lprhsafterfix,
514 SCIP_Bool* fixingsfound
524 assert( sdpi != NULL );
525 assert( nactivelpcons != NULL );
526 assert( sdpi->nlpcons == 0 || lplhsafterfix != NULL );
527 assert( sdpi->nlpcons == 0 || lprhsafterfix != NULL );
528 assert( sdpi->nlpcons == 0 || rownactivevars != NULL );
529 assert( sdpi->nlpcons == 0 || fixingsfound != NULL );
532 if ( sdpi->nlpcons == 0 || sdpi->lpnnonz == 0 )
539 for (c = 0; c < sdpi->nlpcons; c++)
540 rownactivevars[c] = 0;
543 for (i = 0; i < sdpi->lpnnonz; i++)
545 assert( i == 0 || sdpi->lprow[i-1] <= sdpi->lprow[i] );
548 if ( sdpi->lprow[i] > lastrow )
551 if ( lastrow >= 0 && rownactivevars[lastrow] > 1 )
553 else if ( lastrow >= 0 && rownactivevars[lastrow] == 1 )
555 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
557 nonzcol = sdpi->lpcol[nonzind];
558 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
560 nonzval = sdpi->lpval[nonzind];
561 assert( REALABS(nonzval) > sdpi->epsilon );
568 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
571 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
572 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
573 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
576 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
578 *fixingsfound = TRUE;
579 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
580 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
583 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
585 sdpi->infeasible = TRUE;
586 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
587 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
593 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
596 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
597 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
598 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
601 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
603 *fixingsfound = TRUE;
604 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
605 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
609 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
611 sdpi->infeasible = TRUE;
612 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
613 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
622 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
625 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
626 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
627 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
630 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
632 *fixingsfound = TRUE;
633 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
634 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
638 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
640 sdpi->infeasible = TRUE;
641 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
642 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
648 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
651 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
652 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
653 sdpi->ub[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
656 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
658 *fixingsfound = TRUE;
659 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
660 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
664 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
666 sdpi->infeasible = TRUE;
667 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
668 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
674 else if ( lastrow >= 0 )
676 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
678 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
680 sdpi->infeasible = TRUE;
681 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
682 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
688 lastrow = sdpi->lprow[i];
691 lplhsafterfix[*nactivelpcons] = sdpi->lplhs[lastrow];
692 lprhsafterfix[*nactivelpcons] = sdpi->lprhs[lastrow];
696 if ( !
isFixed(sdpi, sdpi->lpcol[i]) )
698 rownactivevars[lastrow]++;
704 lplhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
705 lprhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
710 if ( rownactivevars[lastrow] > 1 )
712 else if ( rownactivevars[lastrow] == 1 )
714 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
716 nonzcol = sdpi->lpcol[nonzind];
717 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
719 nonzval = sdpi->lpval[nonzind];
720 assert( REALABS(nonzval) > sdpi->epsilon );
727 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
730 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
731 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
732 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
735 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
737 *fixingsfound = TRUE;
738 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
739 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
743 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
745 sdpi->infeasible = TRUE;
746 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
752 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] - sdpi->epsilon) )
755 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
756 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
757 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
760 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
762 *fixingsfound = TRUE;
763 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
764 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
768 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
770 sdpi->infeasible = TRUE;
771 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
780 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
783 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
784 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
785 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
788 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
790 *fixingsfound = TRUE;
791 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
792 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
796 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
798 sdpi->infeasible = TRUE;
799 SCIPdebugMessage(
"We found a lower bound that is bigger than the upper bound, so the problem is infeasible !\n");
805 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
808 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
809 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
810 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
813 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
815 *fixingsfound = TRUE;
816 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
817 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
821 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
823 sdpi->infeasible = TRUE;
824 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
832 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
834 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
836 sdpi->infeasible = TRUE;
837 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
838 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
856 for (v = 0; v < sdpi->nvars; v++)
860 sdpi->allfixed = FALSE;
867 SCIPdebugMessage(
"Detected that all variables in SDP %d are fixed.\n", sdpi->sdpid);
868 sdpi->allfixed = TRUE;
879 int* sdpconstnblocknonz,
883 SCIP_Real** sdpconstval,
892 SCIP_Real* fullmatrix;
895 SCIP_Real eigenvalue;
901 assert( sdpi->allfixed );
906 for (b = 0; b < sdpi->nsdpblocks; b++)
908 if ( sdpi->sdpblocksizes[b] - nremovedinds[b] > maxsize )
909 maxsize = sdpi->sdpblocksizes[b] - nremovedinds[b];
913 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize) );
916 for (b = 0; b < sdpi->nsdpblocks; b++)
919 if ( blockindchanges[b] == -1 )
922 size = sdpi->sdpblocksizes[b] - nremovedinds[b];
925 for (i = 0; i < size * size; i++)
929 for (i = 0; i < sdpconstnblocknonz[b]; i++)
931 assert( 0 <= sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] && sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] < size );
932 assert( 0 <= sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] && sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] < size );
933 fullmatrix[(sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]]) * size
934 + sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]]] = -1 * sdpconstval[b][i];
938 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
940 fixedval = sdpi->lb[sdpi->sdpvar[b][v]];
943 if ( REALABS(fixedval) < sdpi->epsilon )
947 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
949 assert( 0 <= sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] &&
950 sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] < size );
951 assert( 0 <= sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] &&
952 sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] < size );
953 fullmatrix[(sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]]) * size
954 + sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]]] += fixedval * sdpi->sdpval[b][v][i];
962 if ( eigenvalue < -1 * sdpi->feastol )
964 sdpi->infeasible = TRUE;
965 SCIPdebugMessage(
"Detected infeasibility for SDP %d with all fixed variables!\n", sdpi->sdpid);
971 BMSfreeBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize);
974 sdpi->infeasible = FALSE;
975 SCIPdebugMessage(
"Unique solution for SDP %d with all fixed variables is feasible!\n", sdpi->sdpid);
988 int* sdpconstnblocknonz,
992 SCIP_Real** sdpconstval,
996 SCIP_Real* lplhsafterfix,
997 SCIP_Real* lprhsafterfix,
998 int* rowsnactivevars,
999 int* blockindchanges,
1004 SCIP_Bool rootnodefailed
1009 SCIP_Bool origfeas = FALSE;
1010 SCIP_Bool penaltybound = FALSE;
1013 SCIP_Real* slaterlpval;
1014 SCIP_Real* slaterlplhs;
1015 SCIP_Real* slaterlprhs;
1016 int* slaterrowsnactivevars;
1017 int nremovedslaterlpinds;
1021 int slaternactivelpcons;
1022 SCIP_Real* slaterlb;
1023 SCIP_Real* slaterub;
1024 int slaternremovedvarbounds;
1025 SCIP_Real solvertimelimit;
1026 clock_t currenttime;
1028 assert( sdpi != NULL );
1029 assert( sdpconstnnonz == 0 || sdpconstnblocknonz != NULL );
1030 assert( sdpconstnnonz == 0 || sdpconstrow != NULL );
1031 assert( sdpconstnnonz == 0 || sdpconstcol != NULL );
1032 assert( sdpconstnnonz == 0 || sdpconstval != NULL );
1033 assert( sdpi->nsdpblocks == 0 || indchanges != NULL );
1034 assert( sdpi->nsdpblocks == 0 || nremovedinds != NULL );
1035 assert( nactivelpcons == 0 || lplhsafterfix != NULL );
1036 assert( nactivelpcons == 0 || lprhsafterfix != NULL );
1037 assert( sdpi->nlpcons == 0 || rowsnactivevars != NULL );
1038 assert( sdpi->nsdpblocks == 0 || blockindchanges != NULL );
1043 solvertimelimit = timelimit;
1046 currenttime = clock();
1047 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
1053 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1054 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1055 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1056 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1058 &origfeas, &penaltybound) );
1062 if ( rootnodefailed )
1064 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem could "
1065 "not be checked, ");
1067 else if ( sdpi->slatercheck == 2 )
1068 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for dual problem.\n");
1075 if ( rootnodefailed )
1076 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds "
1077 "as smallest eigenvalue maximization problem is unbounded, ");
1080 SCIPdebugMessage(
"Slater condition for dual problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded.\n", sdpi->sdpid);
1086 if ( rootnodefailed )
1088 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem "
1089 "not fullfilled as problem is infeasible, ");
1091 else if ( sdpi->slatercheck == 2 )
1092 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for dual problem for SDP %d not fullfilled, problem infeasible.\n", sdpi->sdpid);
1099 if ( objval < - sdpi->feastol )
1101 if ( rootnodefailed )
1103 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds"
1104 "with smallest eigenvalue %f, ", -1.0 * objval);
1107 SCIPdebugMessage(
"Slater condition for SDP %d is fullfilled for dual problem with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1110 else if ( objval < sdpi->feastol )
1112 if ( rootnodefailed )
1114 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem "
1115 "not fullfilled with smallest eigenvalue %f, ", -1.0 * objval);
1117 else if ( sdpi->slatercheck == 2 )
1119 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, expect numerical trouble.\n",
1120 sdpi->sdpid, -1.0 * objval);
1126 if ( sdpi->slatercheck == 2 )
1128 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, problem is infeasible.\n",
1129 sdpi->sdpid, -1.0 * objval);
1154 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars) );
1155 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars) );
1156 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars) );
1159 for (i = 0; i < sdpi->lpnnonz; i++)
1161 slaterlprow[i] = sdpi->lprow[i];
1162 slaterlpcol[i] = sdpi->lpcol[i];
1163 slaterlpval[i] = sdpi->lpval[i];
1167 for (v = 0; v < sdpi->nvars; v++)
1169 slaterlprow[sdpi->lpnnonz + v] = sdpi->nlpcons;
1170 slaterlpcol[sdpi->lpnnonz + v] = v;
1171 slaterlpval[sdpi->lpnnonz + v] = 0.0;
1173 for (b = 0; b < sdpi->nsdpblocks; b++)
1175 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
1177 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
1179 if ( sdpi->sdprow[b][v][i] == sdpi->sdpcol[b][v][i] )
1180 slaterlpval[sdpi->lpnnonz + sdpi->sdpvar[b][v]] += sdpi->sdpval[b][v][i];
1186 nremovedslaterlpinds = 0;
1187 for (v = 0; v < sdpi->nvars; v++)
1189 if ( REALABS(slaterlpval[sdpi->lpnnonz + v]) <= sdpi->epsilon )
1190 nremovedslaterlpinds++;
1194 slaterlprow[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlprow[sdpi->lpnnonz + v];
1195 slaterlpcol[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpcol[sdpi->lpnnonz + v];
1196 slaterlpval[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpval[sdpi->lpnnonz + v];
1201 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1) );
1202 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1) );
1205 for (i = 0; i < nactivelpcons; i++)
1208 slaterlplhs[i] = lplhsafterfix[i];
1210 slaterlplhs[i] = 0.0;
1213 slaterlprhs[i] = lprhsafterfix[i];
1215 slaterlprhs[i] = 0.0;
1219 slaterlplhs[nactivelpcons] = 1.0;
1223 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1) );
1226 for (i = 0; i < sdpi->nlpcons; i++)
1227 slaterrowsnactivevars[i] = rowsnactivevars[i];
1230 slaterrowsnactivevars[sdpi->nlpcons] = 0;
1231 for (v = 0; v < sdpi->nvars; v++)
1234 slaterrowsnactivevars[sdpi->nlpcons]++;
1237 slaternactivelpcons = (slaterrowsnactivevars[sdpi->nlpcons] > 1) ? nactivelpcons + 1 : nactivelpcons;
1244 slaternremovedvarbounds = 0;
1245 for (v = 0; v < sdpi->nvars; v++)
1250 slaternremovedvarbounds++;
1255 slaternremovedvarbounds++;
1262 if ( slaternremovedvarbounds == 2 * sdpi->nvars )
1264 if ( rootnodefailed )
1266 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem holds since all variables have finite upper and lower bounds \n");
1269 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled as all variables have finite upper and lower bounds \n", sdpi->sdpid);
1275 currenttime = clock();
1276 solvertimelimit = timelimit - ((SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC);
1280 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, 0, NULL, NULL, NULL, NULL,
1281 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1282 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, slaternactivelpcons, sdpi->nlpcons + 1, slaterlplhs, slaterlprhs,
1283 slaterrowsnactivevars, sdpi->lpnnonz + sdpi->nvars - nremovedslaterlpinds, slaterlprow, slaterlpcol, slaterlpval, NULL,
1288 if ( rootnodefailed )
1290 SCIPmessagePrintInfo(sdpi->messagehdlr,
"unable to check Slater condition for primal problem \n");
1292 else if ( sdpi->slatercheck == 2 )
1293 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for primal problem, could not solve auxilliary problem.\n");
1298 if ( rootnodefailed )
1300 SCIPmessagePrintInfo(sdpi->messagehdlr,
" primal Slater condition shows infeasibility \n");
1302 else if ( sdpi->slatercheck == 2 )
1304 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled "
1305 "smallest eigenvalue has to be negative, so primal problem is infeasible (if the dual slater condition holds,"
1306 "this means, that the original (dual) problem is unbounded.\n",sdpi->sdpid);
1312 if ( rootnodefailed )
1314 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problems holds sunce smallest eigenvalue maximization problem"
1318 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded \n", sdpi->sdpid);
1325 if ( objval > - sdpi->feastol)
1327 if ( rootnodefailed )
1329 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem not fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1331 else if ( sdpi->slatercheck == 2 )
1333 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled "
1334 "as smallest eigenvalue was %f, expect numerical trouble or infeasible problem.\n",sdpi->sdpid, -1.0 * objval);
1340 if ( rootnodefailed )
1342 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1345 SCIPdebugMessage(
"Slater condition for primal problem of SDP %d is fullfilled with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1352 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterub, sdpi->nvars);
1353 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlb, sdpi->nvars);
1354 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1);
1355 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1);
1356 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1);
1357 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars);
1358 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars);
1359 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars);
1430 SCIP_MESSAGEHDLR* messagehdlr,
1435 assert ( sdpi != NULL );
1436 assert ( blkmem != NULL );
1438 SCIPdebugMessage(
"Calling SCIPsdpiCreate\n");
1440 BMS_CALL( BMSallocBlockMemory(blkmem, sdpi) );
1444 (*sdpi)->messagehdlr = messagehdlr;
1445 (*sdpi)->blkmem = blkmem;
1446 (*sdpi)->bufmem = bufmem;
1448 (*sdpi)->niterations = 0;
1449 (*sdpi)->nsdpcalls = 0;
1451 (*sdpi)->nsdpblocks = 0;
1452 (*sdpi)->sdpconstnnonz = 0;
1453 (*sdpi)->sdpnnonz = 0;
1454 (*sdpi)->nlpcons = 0;
1455 (*sdpi)->lpnnonz = 0;
1456 (*sdpi)->slatercheck = 0;
1457 (*sdpi)->solved = FALSE;
1458 (*sdpi)->penalty = FALSE;
1459 (*sdpi)->infeasible = FALSE;
1460 (*sdpi)->allfixed = FALSE;
1462 (*sdpi)->obj = NULL;
1465 (*sdpi)->sdpblocksizes = NULL;
1466 (*sdpi)->sdpnblockvars = NULL;
1467 (*sdpi)->sdpconstnblocknonz = NULL;
1468 (*sdpi)->sdpconstrow = NULL;
1469 (*sdpi)->sdpconstcol = NULL;
1470 (*sdpi)->sdpconstval = NULL;
1471 (*sdpi)->sdpnblockvarnonz = NULL;
1472 (*sdpi)->sdpvar = NULL;
1473 (*sdpi)->sdprow = NULL;
1474 (*sdpi)->sdpcol = NULL;
1475 (*sdpi)->sdpval = NULL;
1476 (*sdpi)->lplhs = NULL;
1477 (*sdpi)->lprhs = NULL;
1478 (*sdpi)->lprow = NULL;
1479 (*sdpi)->lpcol = NULL;
1480 (*sdpi)->lpval = NULL;
1503 SCIPdebugMessage(
"Calling SCIPsdpiFree \n");
1504 assert ( sdpi != NULL );
1505 assert ( *sdpi != NULL );
1508 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpval), (*sdpi)->lpnnonz);
1509 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpcol), (*sdpi)->lpnnonz);
1510 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprow), (*sdpi)->lpnnonz);
1511 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprhs), (*sdpi)->nlpcons);
1512 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lplhs), (*sdpi)->nlpcons);
1515 for (i = 0; i < (*sdpi)->nsdpblocks; i++)
1517 for (j = 0; j < (*sdpi)->sdpnblockvars[i]; j++)
1519 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1520 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1521 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1523 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i]), (*sdpi)->sdpnblockvars[i]);
1524 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i]), (*sdpi)->sdpnblockvars[i]);
1525 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i]), (*sdpi)->sdpnblockvars[i]);
1526 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar[i]), (*sdpi)->sdpnblockvars[i]);
1527 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz[i]), (*sdpi)->sdpnblockvars[i]);
1528 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval[i]), (*sdpi)->sdpconstnblocknonz[i]);
1529 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow[i]), (*sdpi)->sdpconstnblocknonz[i]);
1530 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol[i]), (*sdpi)->sdpconstnblocknonz[i]);
1534 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz), (*sdpi)->nsdpblocks);
1535 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstnblocknonz), (*sdpi)->nsdpblocks);
1536 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval), (*sdpi)->nsdpblocks);
1537 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol), (*sdpi)->nsdpblocks);
1538 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow), (*sdpi)->nsdpblocks);
1539 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar), (*sdpi)->nsdpblocks);
1540 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval), (*sdpi)->nsdpblocks);
1541 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol), (*sdpi)->nsdpblocks);
1542 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow), (*sdpi)->nsdpblocks);
1543 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvars), (*sdpi)->nsdpblocks);
1544 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpblocksizes), (*sdpi)->nsdpblocks);
1545 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->ub), (*sdpi)->nvars);
1546 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lb), (*sdpi)->nvars);
1547 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->obj), (*sdpi)->nvars);
1552 BMSfreeBlockMemory((*sdpi)->blkmem, sdpi);
1573 assert( oldsdpi != NULL );
1575 SCIPdebugMessage(
"Cloning SDPI %d\n", oldsdpi->sdpid);
1578 blkmem = oldsdpi->blkmem;
1579 nvars = oldsdpi->nvars;
1580 nsdpblocks = oldsdpi->nsdpblocks;
1581 lpnnonz = oldsdpi->lpnnonz;
1583 BMS_CALL( BMSallocBlockMemory(blkmem, &newsdpi) );
1585 SCIP_CALL(
SCIPsdpiSolverCreate(&(newsdpi->sdpisolver), oldsdpi->messagehdlr, oldsdpi->blkmem, oldsdpi->bufmem) );
1587 newsdpi->messagehdlr = oldsdpi->messagehdlr;
1588 newsdpi->blkmem = blkmem;
1589 newsdpi->nvars = nvars;
1591 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->obj), oldsdpi->obj, nvars) );
1592 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lb), oldsdpi->lb, nvars) );
1593 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->ub), oldsdpi->ub, nvars) );
1595 newsdpi->nsdpblocks = nsdpblocks;
1597 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpblocksizes), oldsdpi->sdpblocksizes, nsdpblocks) );
1598 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvars), oldsdpi->sdpnblockvars, nsdpblocks) );
1601 newsdpi->sdpconstnnonz = oldsdpi->sdpconstnnonz;
1603 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstnblocknonz), oldsdpi->sdpconstnblocknonz, nsdpblocks) );
1604 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow), nsdpblocks) );
1605 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol), nsdpblocks) );
1606 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstval), nsdpblocks) );
1608 for (b = 0; b < nsdpblocks; b++)
1610 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow[b]), oldsdpi->sdpconstrow[b], oldsdpi->sdpconstnblocknonz[b]) );
1611 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol[b]), oldsdpi->sdpconstcol[b], oldsdpi->sdpconstnblocknonz[b]) );
1612 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstval[b]), oldsdpi->sdpconstval[b], oldsdpi->sdpconstnblocknonz[b]) );
1616 newsdpi->sdpnnonz = oldsdpi->sdpnnonz;
1618 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz), nsdpblocks) );
1619 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpvar), nsdpblocks) );
1620 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow), nsdpblocks) );
1621 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol), nsdpblocks) );
1622 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval), nsdpblocks) );
1624 for (b = 0; b < nsdpblocks; b++)
1626 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz[b]), oldsdpi->sdpnblockvarnonz[b], oldsdpi->sdpnblockvars[b]) );
1627 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpvar[b]), oldsdpi->sdpvar[b], oldsdpi->sdpnblockvars[b]) );
1629 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow[b]), oldsdpi->sdpnblockvars[b]) );
1630 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b]), oldsdpi->sdpnblockvars[b]) );
1631 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval[b]), oldsdpi->sdpnblockvars[b]) );
1633 for (v = 0; v < oldsdpi->sdpnblockvars[b]; v++)
1635 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdprow[b][v]), oldsdpi->sdprow[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1636 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b][v]), oldsdpi->sdpcol[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1637 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpval[b][v]), oldsdpi->sdpval[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1642 newsdpi->nlpcons = oldsdpi->nlpcons;
1644 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lplhs), oldsdpi->lplhs, oldsdpi->nlpcons) );
1645 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprhs), oldsdpi->lprhs, oldsdpi->nlpcons) );
1647 newsdpi->lpnnonz = lpnnonz;
1649 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprow), oldsdpi->lprow, lpnnonz) );
1650 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpcol), oldsdpi->lpcol, lpnnonz) );
1651 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpval), oldsdpi->lpval, lpnnonz) );
1654 newsdpi->solved = FALSE;
1655 newsdpi->penalty = FALSE;
1656 newsdpi->infeasible = FALSE;
1657 newsdpi->allfixed = FALSE;
1658 newsdpi->sdpid = 1000000 + oldsdpi->sdpid;
1659 newsdpi->epsilon = oldsdpi->epsilon;
1660 newsdpi->gaptol = oldsdpi->gaptol;
1661 newsdpi->feastol = oldsdpi->feastol;
1691 int* sdpconstnblocknonz,
1695 SCIP_Real** sdpconstval,
1697 int** sdpnblockvarnonz,
1705 SCIP_Real*** sdpval,
1720 SCIPdebugMessage(
"Calling SCIPsdpiLoadSDP (%d)\n",sdpi->sdpid);
1722 assert ( sdpi != NULL );
1723 assert ( nvars > 0 );
1724 assert ( obj != NULL );
1725 assert ( lb != NULL );
1726 assert ( ub != NULL );
1729 if (sdpconstnnonz > 0 || sdpnnonz > 0 || nsdpblocks > 0)
1731 assert ( sdpblocksizes != NULL );
1732 assert ( sdpnblockvars != NULL );
1733 assert ( nsdpblocks > 0 );
1734 assert ( sdpconstnblocknonz != NULL );
1735 assert ( sdpnblockvarnonz != NULL );
1737 if (sdpconstnnonz > 0)
1739 assert ( sdpconstrow != NULL );
1740 assert ( sdpconstcol != NULL );
1741 assert ( sdpconstval != NULL );
1743 for (i = 0; i < nsdpblocks; i++)
1745 if (sdpconstnblocknonz[i] > 0)
1747 assert ( sdpconstrow[i] != NULL );
1748 assert ( sdpconstcol[i] != NULL );
1749 assert ( sdpconstval[i] != NULL );
1756 assert ( sdprow != NULL );
1757 assert ( sdpcol != NULL );
1758 assert ( sdpval != NULL );
1760 for ( i = 0; i < nsdpblocks; i++ )
1762 assert ( sdpcol[i] != NULL );
1763 assert ( sdprow[i] != NULL );
1764 assert ( sdpval[i] != NULL );
1766 for ( v = 0; v < sdpnblockvars[i]; v++)
1768 if (sdpnblockvarnonz[i][v] > 0)
1770 assert ( sdpcol[i][v] != NULL );
1771 assert ( sdprow[i][v] != NULL );
1772 assert ( sdpval[i][v] != NULL );
1780 assert ( nlpcons == 0 || lplhs != NULL );
1781 assert ( nlpcons == 0 || lprhs != NULL );
1782 assert ( lpnnonz == 0 || lprow != NULL );
1783 assert ( lpnnonz == 0 || lpcol != NULL );
1784 assert ( lpnnonz == 0 || lpval != NULL );
1789 for (block = sdpi->nsdpblocks - 1; block >= 0; block--)
1791 for (v = sdpi->sdpnblockvars[block] - 1; v >= 0; v--)
1793 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1794 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1795 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1798 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block]), sdpi->sdpnblockvars[block]);
1799 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block]), sdpi->sdpnblockvars[block]);
1800 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpi->sdpnblockvars[block]);
1801 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpi->sdpconstnblocknonz[block]);
1802 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpi->sdpconstnblocknonz[block]);
1803 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpi->sdpconstnblocknonz[block]);
1804 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpi->sdpnblockvars[block]);
1805 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpi->sdpnblockvars[block]);
1808 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->ub), sdpi->nvars);
1809 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lb), sdpi->nvars);
1810 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->obj), sdpi->nvars);
1812 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpblocksizes), sdpi->nsdpblocks);
1813 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvars), sdpi->nsdpblocks);
1814 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpi->nsdpblocks);
1817 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->obj), obj, nvars) );
1818 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->lb), lb, nvars) );
1819 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->ub), ub, nvars) );
1822 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpconstnblocknonz, nsdpblocks);
1825 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpnblockvarnonz), sdpi->nsdpblocks, nsdpblocks) );
1826 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstcol), sdpi->nsdpblocks, nsdpblocks) );
1827 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstrow), sdpi->nsdpblocks, nsdpblocks) );
1828 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstval), sdpi->nsdpblocks, nsdpblocks) );
1829 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpvar), sdpi->nsdpblocks, nsdpblocks) );
1830 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol), sdpi->nsdpblocks, nsdpblocks) );
1831 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow), sdpi->nsdpblocks, nsdpblocks) );
1832 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval), sdpi->nsdpblocks, nsdpblocks) );
1834 for (block = 0; block < nsdpblocks; block++)
1836 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpnblockvarnonz[block], sdpnblockvars[block]);
1838 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpconstcol[block], sdpconstnblocknonz[block]);
1839 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpconstrow[block], sdpconstnblocknonz[block]);
1840 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpconstval[block], sdpconstnblocknonz[block]);
1843 for (i = 0; i < sdpi->sdpconstnblocknonz[block]; ++i)
1846 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpvar[block], sdpnblockvars[block]);
1848 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpnblockvars[block]) );
1849 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow[block]), sdpnblockvars[block]) );
1850 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval[block]), sdpnblockvars[block]) );
1852 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
1854 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpcol[block][v], sdpnblockvarnonz[block][v]);
1855 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdprow[block][v], sdpnblockvarnonz[block][v]);
1856 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpval[block][v], sdpnblockvarnonz[block][v]);
1859 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; ++i)
1865 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1866 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1867 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1868 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1869 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1878 sdpi->nvars = nvars;
1879 sdpi->nsdpblocks = nsdpblocks;
1881 sdpi->sdpconstnnonz = sdpconstnnonz;
1882 sdpi->sdpnnonz = sdpnnonz;
1885 sdpi->lpnnonz = lpnnonz;
1886 sdpi->nlpcons = nlpcons;
1888 sdpi->solved = FALSE;
1889 sdpi->infeasible = FALSE;
1890 sdpi->allfixed = FALSE;
1891 sdpi->nsdpcalls = 0;
1892 sdpi->niterations = 0;
1904 const SCIP_Real* lhs,
1905 const SCIP_Real* rhs,
1910 const SCIP_Real* val
1915 SCIPdebugMessage(
"Adding %d LP-Constraints to SDP %d.\n", nrows, sdpi->sdpid);
1917 assert ( sdpi != NULL );
1922 assert ( lhs != NULL );
1923 assert ( rhs != NULL );
1924 assert ( nnonz >= 0 );
1925 assert ( row != NULL );
1926 assert ( col != NULL );
1927 assert ( val != NULL );
1929 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1930 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1932 for (i = 0; i < nrows; i++)
1934 sdpi->lplhs[sdpi->nlpcons + i] = lhs[i];
1935 sdpi->lprhs[sdpi->nlpcons + i] = rhs[i];
1938 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1939 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1940 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1942 for (i = 0; i < nnonz; i++)
1944 assert ( 0 <= row[i] && row[i] < nrows );
1946 sdpi->lprow[sdpi->lpnnonz + i] = row[i] + sdpi->nlpcons;
1948 assert ( 0 <= col[i] && col[i] < sdpi->nvars );
1949 sdpi->lpcol[sdpi->lpnnonz + i] = col[i];
1951 sdpi->lpval[sdpi->lpnnonz + i] = val[i];
1954 sdpi->nlpcons = sdpi->nlpcons + nrows;
1955 sdpi->lpnnonz = sdpi->lpnnonz + nnonz;
1957 sdpi->solved = FALSE;
1958 sdpi->infeasible = FALSE;
1959 sdpi->nsdpcalls = 0;
1960 sdpi->niterations = 0;
1978 SCIPdebugMessage(
"Deleting rows %d to %d from SDP %d.\n", firstrow, lastrow, sdpi->sdpid);
1980 assert ( sdpi != NULL );
1981 assert ( firstrow >= 0 );
1982 assert ( firstrow <= lastrow );
1983 assert ( lastrow < sdpi->nlpcons );
1986 if (firstrow == 0 && lastrow == sdpi->nlpcons - 1)
1988 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1989 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1990 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1991 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1992 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
2003 sdpi->solved = FALSE;
2004 sdpi->infeasible = FALSE;
2005 sdpi->allfixed = FALSE;
2006 sdpi->nsdpcalls = 0;
2007 sdpi->niterations = 0;
2012 deletedrows = lastrow - firstrow + 1;
2016 for (i = lastrow + 1; i < sdpi->nlpcons; i++)
2018 sdpi->lplhs[i - deletedrows] = sdpi->lplhs[i];
2019 sdpi->lprhs[i - deletedrows] = sdpi->lprhs[i];
2021 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2022 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2025 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
2029 for (i = 0; i < sdpi->lpnnonz; i++)
2031 if (sdpi->lprow[i] >= firstrow && sdpi->lprow[i] <= lastrow)
2040 if (firstrowind > -1)
2043 while (i < sdpi->lpnnonz && sdpi->lprow[i] <= lastrow)
2048 deletednonz = lastrowind - firstrowind + 1;
2051 for (i = lastrowind + 1; i < sdpi->lpnnonz; i++)
2053 sdpi->lpcol[i - deletednonz] = sdpi->lpcol[i];
2055 sdpi->lprow[i - deletednonz] = sdpi->lprow[i] - deletedrows;
2056 sdpi->lpval[i - deletednonz] = sdpi->lpval[i];
2060 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2061 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2062 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2063 sdpi->nlpcons = sdpi->nlpcons - deletedrows;
2064 sdpi->lpnnonz = sdpi->lpnnonz - deletednonz;
2066 sdpi->solved = FALSE;
2067 sdpi->infeasible = FALSE;
2068 sdpi->allfixed = FALSE;
2069 sdpi->nsdpcalls = 0;
2070 sdpi->niterations = 0;
2087 SCIPdebugMessage(
"Calling SCIPsdpiDelLPRowset for SDP %d.\n", sdpi->sdpid);
2089 assert ( sdpi != NULL );
2090 assert ( dstat != NULL );
2092 oldnlpcons = sdpi->nlpcons;
2095 for (i = 0; i < oldnlpcons; i++)
2105 dstat[i] = i - deletedrows;
2108 sdpi->solved = FALSE;
2109 sdpi->infeasible = FALSE;
2110 sdpi->allfixed = FALSE;
2111 sdpi->nsdpcalls = 0;
2112 sdpi->niterations = 0;
2122 assert( sdpi != NULL );
2124 SCIPdebugMessage(
"Called SCIPsdpiClear in SDP %d.\n", sdpi->sdpid);
2138 const SCIP_Real* obj
2143 SCIPdebugMessage(
"Changing %d objective coefficients in SDP %d\n", nvars, sdpi->sdpid);
2145 assert( sdpi != NULL );
2146 assert( ind != NULL );
2147 assert( obj != NULL );
2149 for (i = 0; i < nvars; i++)
2151 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2152 sdpi->obj[ind[i]] = obj[i];
2155 sdpi->solved = FALSE;
2156 sdpi->nsdpcalls = 0;
2157 sdpi->niterations = 0;
2167 const SCIP_Real* lb,
2173 SCIPdebugMessage(
"Changing %d variable bounds in SDP %d\n", nvars, sdpi->sdpid);
2175 assert( sdpi != NULL );
2176 assert( ind != NULL );
2177 assert( lb != NULL );
2178 assert( ub != NULL );
2180 for (i = 0; i < nvars; i++)
2182 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2183 sdpi->lb[ind[i]] = lb[i];
2184 sdpi->ub[ind[i]] = ub[i];
2187 sdpi->solved = FALSE;
2188 sdpi->infeasible = FALSE;
2189 sdpi->allfixed = FALSE;
2190 sdpi->nsdpcalls = 0;
2191 sdpi->niterations = 0;
2201 const SCIP_Real* lhs,
2202 const SCIP_Real* rhs
2207 SCIPdebugMessage(
"Changing %d left and right hand sides of SDP %d\n", nrows, sdpi->sdpid);
2209 assert( sdpi != NULL );
2210 assert( 0 <= nrows && nrows <= sdpi->nlpcons );
2211 assert( ind != NULL );
2212 assert( lhs != NULL );
2213 assert( rhs != NULL );
2215 for (i = 0; i < nrows; i++)
2217 assert ( ind[i] >= 0 );
2218 assert ( ind[i] < sdpi->nlpcons );
2219 sdpi->lplhs[ind[i]] = lhs[i];
2220 sdpi->lprhs[ind[i]] = rhs[i];
2223 sdpi->solved = FALSE;
2224 sdpi->infeasible = FALSE;
2225 sdpi->allfixed = FALSE;
2226 sdpi->nsdpcalls = 0;
2227 sdpi->niterations = 0;
2246 assert( sdpi != NULL );
2247 assert( nlprows != NULL );
2249 *nlprows = sdpi->nlpcons;
2260 assert( sdpi != NULL );
2261 assert( nsdpblocks != NULL );
2263 *nsdpblocks = sdpi->nsdpblocks;
2274 assert( sdpi != NULL );
2275 assert( nvars != NULL );
2277 *nvars = sdpi->nvars;
2288 assert( sdpi != NULL );
2289 assert( nnonz != NULL );
2291 *nnonz = sdpi->sdpnnonz;
2302 assert( sdpi != NULL );
2303 assert( nnonz != NULL );
2305 *nnonz = sdpi->sdpconstnnonz;
2316 assert( sdpi != NULL );
2317 assert( nnonz != NULL );
2319 *nnonz = sdpi->lpnnonz;
2334 assert( sdpi != NULL );
2335 assert( firstvar >= 0 );
2336 assert( firstvar <= lastvar );
2337 assert( lastvar < sdpi->nvars);
2338 assert( vals != NULL );
2340 for (i = 0; i < lastvar - firstvar + 1; i++)
2341 vals[i] = sdpi->obj[firstvar + i];
2357 assert( sdpi != NULL );
2358 assert( firstvar >= 0 );
2359 assert( firstvar <= lastvar );
2360 assert( lastvar < sdpi->nvars);
2361 assert( lbs != NULL );
2362 assert( ubs != NULL );
2364 for (i = 0; i < lastvar - firstvar + 1; i++)
2367 lbs[i] = sdpi->lb[firstvar + i];
2369 ubs[i] = sdpi->ub[firstvar + i];
2384 assert( sdpi != NULL );
2385 assert( firstrow >= 0 );
2386 assert( firstrow <= lastrow );
2387 assert( lastrow < sdpi->nlpcons);
2388 assert( lhss != NULL );
2390 for (i = 0; i < lastrow - firstrow + 1; i++)
2391 lhss[firstrow + i] = sdpi->lplhs[i];
2406 assert( sdpi != NULL );
2407 assert( firstrow >= 0 );
2408 assert( firstrow <= lastrow );
2409 assert( lastrow < sdpi->nlpcons);
2410 assert( rhss != NULL );
2412 for (i = 0; i < lastrow - firstrow + 1; i++)
2413 rhss[firstrow + i] = sdpi->lprhs[i];
2436 SCIP_Bool enforceslatercheck,
2441 int* sdpconstnblocknonz = NULL;
2442 int** sdpconstrow = NULL;
2443 int** sdpconstcol = NULL;
2444 SCIP_Real** sdpconstval = NULL;
2445 int** indchanges = NULL;
2446 int* nremovedinds = NULL;
2447 SCIP_Real* lplhsafterfix;
2448 SCIP_Real* lprhsafterfix;
2449 SCIP_Real solvertimelimit;
2450 SCIP_Bool fixingfound;
2452 clock_t currenttime;
2453 int* rowsnactivevars;
2454 int* blockindchanges;
2457 int nremovedblocks = 0;
2459 int naddediterations;
2462 assert( sdpi != NULL );
2464 starttime = clock();
2466 SCIPdebugMessage(
"Forwarding SDP %d to solver!\n", sdpi->sdpid);
2468 sdpi->penalty = FALSE;
2470 sdpi->solved = FALSE;
2471 sdpi->nsdpcalls = 0;
2472 sdpi->niterations = 0;
2476 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks) );
2477 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks) );
2478 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks) );
2479 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks) );
2480 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks) );
2481 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks) );
2482 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks) );
2483 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons) );
2484 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons) );
2485 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons) );
2487 for (block = 0; block < sdpi->nsdpblocks; block++)
2489 sdpconstrow[block] = NULL;
2490 sdpconstcol[block] = NULL;
2491 sdpconstval[block] = NULL;
2492 indchanges[block] = NULL;
2493 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]) );
2494 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2495 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2496 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2503 fixingfound = FALSE;
2506 while ( fixingfound );
2509 for (block = 0; block < sdpi->nsdpblocks; block++)
2510 sdpconstnblocknonz[block] = sdpi->sdpnnonz + sdpi->sdpconstnnonz;
2512 SCIP_CALL(
compConstMatAfterFixings(sdpi, &sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval) );
2515 for (block = 0; block < sdpi->nsdpblocks; block++)
2517 assert ( sdpconstnblocknonz[block] <= sdpi->sdpnnonz + sdpi->sdpconstnnonz );
2519 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2520 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2521 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2524 SCIP_CALL(
findEmptyRowColsSDP(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges, &nremovedblocks) );
2529 if ( sdpi->allfixed && ! sdpi->infeasible )
2531 SCIP_CALL(
checkFixedFeasibilitySdp(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges) );
2534 if ( sdpi->infeasible )
2536 SCIPdebugMessage(
"SDP %d not given to solver, as infeasibility was detected during presolving!\n", sdpi->sdpid++);
2539 sdpi->solved = TRUE;
2543 else if ( sdpi->allfixed )
2545 SCIPdebugMessage(
"SDP %d not given to solver, as all variables were fixed during presolving (the solution was feasible)!\n", sdpi->sdpid++);
2548 sdpi->solved = TRUE;
2554 if ( sdpi->slatercheck )
2556 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2557 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, FALSE) );
2561 solvertimelimit = timelimit;
2564 currenttime = clock();
2565 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2570 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2571 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2572 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2573 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2574 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, startsettings, solvertimelimit) );
2576 sdpi->solved = TRUE;
2579 naddediterations = 0;
2581 sdpi->niterations += naddediterations;
2584 sdpi->nsdpcalls += naddedsdpcalls;
2589 SCIP_Real penaltyparam;
2590 SCIP_Real penaltyparamfact;
2592 SCIP_Real gaptolfact;
2594 SCIP_Bool penaltybound;
2599 penaltybound = TRUE;
2604 solvertimelimit = timelimit;
2607 currenttime = clock();
2608 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2614 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2615 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2616 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2617 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2619 &feasorig, &penaltybound) );
2622 naddediterations = 0;
2624 sdpi->niterations += naddediterations;
2627 sdpi->nsdpcalls += naddedsdpcalls;
2642 if ( (
SCIPsdpiSolverIsOptimal(sdpi->sdpisolver) && (objval > (sdpi->feastol > sdpi->gaptol ? sdpi->feastol : sdpi->gaptol))) ||
2645 SCIPdebugMessage(
"SDP %d found infeasible using penalty formulation, maximum of smallest eigenvalue is %f.\n", sdpi->sdpid, -1.0 * objval);
2646 sdpi->penalty = TRUE;
2647 sdpi->infeasible = TRUE;
2652 penaltybound = TRUE;
2654 penaltyparam = sdpi->penaltyparam;
2659 penaltyparamfact = sdpi->npenaltyincr > 0 ? pow((sdpi->maxpenaltyparam / sdpi->penaltyparam), 1.0/sdpi->npenaltyincr) :
2660 2*sdpi->maxpenaltyparam / sdpi->penaltyparam;
2661 gaptol = sdpi->gaptol;
2662 gaptolfact = sdpi->npenaltyincr > 0 ? pow((
MIN_GAPTOL / sdpi->gaptol), 1.0/sdpi->npenaltyincr) : 0.5 *
MIN_GAPTOL / sdpi->gaptol;
2668 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penaltyparameter %f\n", sdpi->sdpid, penaltyparam);
2671 solvertimelimit = timelimit;
2674 currenttime = clock();
2675 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2677 if ( solvertimelimit <= 0 )
2682 sdpi->lb, sdpi->ub, sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2683 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2684 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2685 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2686 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, startsettings, solvertimelimit, &feasorig, &penaltybound) );
2689 naddediterations = 0;
2691 sdpi->niterations += naddediterations;
2694 sdpi->nsdpcalls += naddedsdpcalls;
2699 penaltyparam *= penaltyparamfact;
2700 SCIPdebugMessage(
"Solver did not converge even with penalty formulation, increasing penaltyparameter.\n");
2706 if ( objbound > sdpi->bestbound + sdpi->gaptol )
2707 sdpi->bestbound = objbound;
2715 penaltyparam *= penaltyparamfact;
2716 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, increasing penaltyparameter\n");
2720 gaptol *= gaptolfact;
2722 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, even though primal penalty "
2723 "bound was not reached, decreasing tolerance for duality gap in SDP-solver\n");
2729 if ( gaptol > sdpi->gaptol )
2737 sdpi->penalty = TRUE;
2738 sdpi->solved = TRUE;
2743 SCIPdebugMessage(
"Problem was found to be infeasible using a penalty formulation \n");
2744 sdpi->infeasible = TRUE;
2745 sdpi->penalty = TRUE;
2746 sdpi->solved = TRUE;
2751 SCIPdebugMessage(
"SDP-Solver could not solve the problem even after using a penalty formulation \n");
2752 sdpi->solved = FALSE;
2753 sdpi->penalty = TRUE;
2757 if ( sdpi->solved == FALSE && enforceslatercheck)
2759 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2760 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, TRUE) );
2762 else if ( sdpi->solved == FALSE )
2765 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Numerical trouble\n");
2767 SCIPdebugMessage(
"SDP-Interface was unable to solve SDP %d\n", sdpi->sdpid);
2775 for (block = 0; block < sdpi->nsdpblocks; block++)
2777 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpconstnblocknonz[block]);
2778 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpconstnblocknonz[block]);
2779 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpconstnblocknonz[block]);
2780 BMSfreeBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]);
2782 BMSfreeBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons);
2783 BMSfreeBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons);
2784 BMSfreeBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons);
2785 BMSfreeBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks);
2786 BMSfreeBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks);
2787 BMSfreeBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks);
2788 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks);
2789 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks);
2790 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks);
2791 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks);
2813 assert( sdpi != NULL );
2823 assert( sdpi != NULL );
2835 assert( sdpi != NULL );
2838 if ( sdpi->infeasible || sdpi->allfixed )
2847 SCIP_Bool* primalfeasible,
2848 SCIP_Bool* dualfeasible
2851 assert( sdpi != NULL );
2854 if ( sdpi->infeasible )
2856 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2857 *dualfeasible = FALSE;
2860 else if ( sdpi->allfixed )
2862 SCIPdebugMessage(
"All variables were fixed during preprocessing, dual problem is feasible, primal feasibility not available\n");
2863 *dualfeasible = TRUE;
2878 assert( sdpi != NULL );
2881 if ( sdpi->infeasible )
2883 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal unboundedness not available\n");
2886 else if ( sdpi->allfixed )
2888 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal unboundedness not available\n");
2901 assert( sdpi != NULL );
2904 if ( sdpi->infeasible )
2906 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2909 else if ( sdpi->allfixed )
2911 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal feasibility not available\n");
2924 assert(sdpi != NULL );
2927 if ( sdpi->infeasible )
2929 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2932 else if ( sdpi->allfixed )
2934 SCIPdebugMessage(
"All variables fixed during preprocessing, primal feasibility not available\n");
2947 assert( sdpi != NULL );
2950 if ( sdpi->infeasible )
2952 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore is not unbounded\n");
2955 else if ( sdpi->allfixed )
2957 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore the problem is not unbounded\n");
2970 assert( sdpi != NULL );
2973 if ( sdpi->infeasible )
2975 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
2978 else if ( sdpi->allfixed )
2980 SCIPdebugMessage(
"All variables were fixed during preprocessing, solution is feasible\n");
2993 assert( sdpi != NULL );
2996 if ( sdpi->infeasible )
2998 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3001 else if ( sdpi->allfixed )
3003 SCIPdebugMessage(
"All variables fixed during preprocessing, solution is feasible\n");
3015 assert( sdpi != NULL );
3018 if ( sdpi->infeasible )
3020 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this counts as converged.\n");
3023 else if ( sdpi->allfixed )
3025 SCIPdebugMessage(
"All variables were fixed during preprocessing, this counts as converged.\n");
3037 assert( sdpi != NULL );
3040 if ( sdpi->infeasible )
3042 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective limit available.\n");
3045 else if ( sdpi->allfixed )
3047 SCIPdebugMessage(
"All variables were fixed during preprocessing, no objective limit available.\n");
3059 assert( sdpi != NULL );
3062 if ( sdpi->infeasible )
3064 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iteration limit available.\n");
3067 else if ( sdpi->allfixed )
3069 SCIPdebugMessage(
"All variables were fixed during preprocessing, no iteration limit available.\n");
3081 assert( sdpi != NULL );
3083 if ( sdpi->infeasible )
3085 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no time limit available.\n");
3088 else if ( sdpi->allfixed )
3090 SCIPdebugMessage(
"All variables were fixed during preprocessing, no time limit available.\n");
3093 else if ( ! sdpi->solved )
3095 SCIPdebugMessage(
"Problem was not solved, time limit not exceeded.\n");
3116 assert( sdpi != NULL );
3118 if ( ! sdpi->solved )
3120 SCIPdebugMessage(
"Problem wasn't solved yet.\n");
3123 else if ( sdpi->infeasible )
3125 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no internal status available.\n");
3128 else if ( sdpi->allfixed )
3130 SCIPdebugMessage(
"All variables were fixed during preprocessing, no internal status available.\n");
3142 assert( sdpi != NULL );
3145 if ( sdpi->infeasible )
3147 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore there is no optimal solution.\n");
3150 else if ( sdpi->allfixed )
3152 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore there is no optimal solution.\n");
3165 assert( sdpi != NULL );
3167 if ( sdpi->infeasible )
3169 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this is acceptable in a B&B context.\n");
3172 else if ( sdpi->allfixed )
3174 SCIPdebugMessage(
"All variables fixed during preprocessing, this is acceptable in a B&B context.\n");
3177 else if ( ! sdpi->solved )
3179 SCIPdebugMessage(
"Problem not solved succesfully, this is not acceptable in a B&B context.\n");
3192 assert( sdpi != NULL );
3193 assert( objval != NULL );
3196 if ( sdpi->infeasible )
3198 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3202 if ( sdpi->allfixed )
3209 for (v = 0; v < sdpi->nvars; v++)
3210 *objval += sdpi->lb[v] * sdpi->obj[v];
3227 assert( sdpi != NULL );
3228 assert( objlb != NULL );
3233 if ( sdpi->infeasible )
3235 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3239 if ( sdpi->allfixed )
3246 for (v = 0; v < sdpi->nvars; v++)
3247 *objlb += sdpi->lb[v] * sdpi->obj[v];
3257 if ( sdpi->penalty )
3259 *objlb = sdpi->bestbound;
3279 assert( sdpi != NULL );
3280 assert( dualsollength != NULL );
3281 assert( *dualsollength == 0 || dualsol != NULL );
3284 if ( sdpi->infeasible )
3286 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no solution available.\n");
3289 else if ( sdpi->allfixed )
3291 if ( objval != NULL )
3295 if ( *dualsollength > 0 )
3299 assert( dualsol != NULL );
3300 if ( *dualsollength < sdpi->nvars )
3302 SCIPdebugMessage(
"The given array in SCIPsdpiGetSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3303 *dualsollength = sdpi->nvars;
3309 for (v = 0; v < sdpi->nvars; v++)
3310 dualsol[v] = sdpi->lb[v];
3333 assert( sdpi != NULL );
3334 assert( lbvars != NULL );
3335 assert( ubvars != NULL );
3336 assert( arraylength != NULL );
3337 assert( *arraylength >= 0 );
3340 if ( sdpi->infeasible )
3342 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal variables available.\n");
3345 else if ( sdpi->allfixed )
3347 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal variables available.\n");
3362 assert( sdpi != NULL );
3363 assert( iterations != NULL );
3365 *iterations = sdpi->niterations;
3376 assert( sdpi != NULL );
3377 assert( calls != NULL );
3379 *calls = sdpi->nsdpcalls;
3390 assert( sdpi != NULL );
3391 assert( usedsetting != NULL );
3393 if ( ! sdpi->solved )
3395 SCIPdebugMessage(
"Problem was not solved successfully.\n");
3399 else if ( sdpi->infeasible && ! sdpi->penalty )
3401 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3405 else if ( sdpi->allfixed )
3407 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3411 else if ( sdpi->penalty )
3429 assert( sdpi != NULL );
3430 assert( slatersetting != NULL );
3432 if ( ! sdpi->solved )
3434 SCIPdebugMessage(
"Problem was not solved successfully");
3437 SCIPdebugMessage(
", but we could at least compute a lower bound. \n");
3442 switch( sdpi->primalslater )
3454 switch( sdpi->dualslater )
3478 SCIPdebugMessage(
".\n");
3483 switch( sdpi->primalslater )
3495 switch( sdpi->dualslater )
3519 else if ( sdpi->infeasible && ( ! sdpi->penalty ) )
3521 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3525 else if ( sdpi->allfixed )
3527 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3531 else if ( sdpi->penalty )
3533 switch( sdpi->primalslater )
3550 switch( sdpi->dualslater )
3576 switch( sdpi->primalslater )
3583 switch( usedsetting )
3601 switch( usedsetting )
3623 switch( usedsetting )
3641 switch( usedsetting )
3657 switch( sdpi->dualslater )
3665 switch( usedsetting )
3682 switch( usedsetting )
3699 switch( usedsetting )
3733 assert( sdpi != NULL );
3734 assert( primalslater != NULL );
3735 assert( dualslater != NULL );
3738 if ( sdpi->infeasible )
3741 *dualslater = sdpi->dualslater;
3745 if (sdpi->allfixed )
3752 *primalslater = sdpi->primalslater;
3753 *dualslater = sdpi->dualslater;
3775 assert( sdpi != NULL );
3786 assert( sdpi != NULL );
3798 assert( sdpi != NULL );
3799 assert( sdpi->sdpisolver != NULL );
3800 assert( dval != NULL );
3805 *dval = sdpi->epsilon;
3808 *dval = sdpi->gaptol;
3811 *dval = sdpi->feastol;
3820 *dval = sdpi->penaltyparam;
3823 *dval = sdpi->maxpenaltyparam;
3829 return SCIP_PARAMETERUNKNOWN;
3842 assert( sdpi != NULL );
3847 sdpi->epsilon = dval;
3851 sdpi->gaptol = dval;
3855 sdpi->feastol = dval;
3865 sdpi->penaltyparam = dval;
3869 sdpi->maxpenaltyparam = dval;
3875 return SCIP_PARAMETERUNKNOWN;
3888 assert( sdpi != NULL );
3889 assert( sdpi->sdpisolver != NULL );
3890 assert( ival != NULL );
3899 *ival = sdpi->slatercheck;
3902 *ival = sdpi->npenaltyincr;
3905 return SCIP_PARAMETERUNKNOWN;
3918 assert( sdpi != NULL );
3919 assert( sdpi->sdpisolver != NULL );
3924 assert( ival == 0 || ival == 1 );
3931 sdpi->slatercheck = ival;
3934 sdpi->npenaltyincr = ival;
3937 return SCIP_PARAMETERUNKNOWN;
3956 SCIP_Real* penaltyparam
3961 sdpi->penaltyparam = *penaltyparam;
3969 SCIP_Real penaltyparam,
3970 SCIP_Real* maxpenaltyparam
3975 sdpi->maxpenaltyparam = *maxpenaltyparam;
3979 if ( sdpi->penaltyparam > *maxpenaltyparam )
3981 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpi->penaltyparam, *maxpenaltyparam);
3982 sdpi->penaltyparam = *maxpenaltyparam;
4006 SCIPdebugMessage(
"Not implemented yet\n");
4007 return SCIP_LPERROR;
4016 SCIPdebugMessage(
"Not implemented yet\n");
4017 return SCIP_LPERROR;
SCIP_RETCODE SCIPsdpiFree(SCIP_SDPI **sdpi)
SCIP_Bool SCIPsdpiIsDualUnbounded(SCIP_SDPI *sdpi)
#define DEFAULT_SDPSOLVERGAPTOL
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)
SCIP_RETCODE SCIPsdpiGetSdpCalls(SCIP_SDPI *sdpi, int *calls)
EXTERN SCIP_RETCODE SCIPlapackComputeIthEigenvalue(BMS_BUFMEM *bufmem, SCIP_Bool geteigenvectors, int n, SCIP_Real *A, int i, SCIP_Real *eigenvalue, SCIP_Real *eigenvector)
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)
EXTERN SCIP_RETCODE SCIPsdpiSolverCreate(SCIP_SDPISOLVER **sdpisolver, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, BMS_BUFMEM *bufmem)
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 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 int SCIPsdpiSolverGetDefaultSdpiSolverNpenaltyIncreases(void)
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)
#define SCIP_CALL_PARAM_IGNORE_UNKNOWN(x)
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_Real SCIPsdpiGetDefaultSdpiSolverFeastol(void)
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)
SCIP_RETCODE SCIPsdpiCreate(SCIP_SDPI **sdpi, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, BMS_BUFMEM *bufmem)
#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)
int SCIPsdpiGetDefaultSdpiSolverNpenaltyIncreases(void)
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_NPENALTYINCR
#define DEFAULT_PENALTYPARAM
SCIP_Bool SCIPsdpiIsDualFeasible(SCIP_SDPI *sdpi)
struct SCIP_SDPi SCIP_SDPI
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
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)
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)
EXTERN SCIP_Real SCIPsdpiSolverGetDefaultSdpiSolverFeastol(void)
#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)