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,
1057 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
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, NULL, NULL, 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);
1446 SCIP_MESSAGEHDLR* messagehdlr,
1451 assert ( sdpi != NULL );
1452 assert ( blkmem != NULL );
1454 SCIPdebugMessage(
"Calling SCIPsdpiCreate\n");
1456 BMS_CALL( BMSallocBlockMemory(blkmem, sdpi) );
1460 (*sdpi)->messagehdlr = messagehdlr;
1461 (*sdpi)->blkmem = blkmem;
1462 (*sdpi)->bufmem = bufmem;
1464 (*sdpi)->niterations = 0;
1465 (*sdpi)->nsdpcalls = 0;
1467 (*sdpi)->nsdpblocks = 0;
1468 (*sdpi)->sdpconstnnonz = 0;
1469 (*sdpi)->sdpnnonz = 0;
1470 (*sdpi)->nlpcons = 0;
1471 (*sdpi)->lpnnonz = 0;
1472 (*sdpi)->slatercheck = 0;
1473 (*sdpi)->solved = FALSE;
1474 (*sdpi)->penalty = FALSE;
1475 (*sdpi)->infeasible = FALSE;
1476 (*sdpi)->allfixed = FALSE;
1478 (*sdpi)->obj = NULL;
1481 (*sdpi)->sdpblocksizes = NULL;
1482 (*sdpi)->sdpnblockvars = NULL;
1483 (*sdpi)->sdpconstnblocknonz = NULL;
1484 (*sdpi)->sdpconstrow = NULL;
1485 (*sdpi)->sdpconstcol = NULL;
1486 (*sdpi)->sdpconstval = NULL;
1487 (*sdpi)->sdpnblockvarnonz = NULL;
1488 (*sdpi)->sdpvar = NULL;
1489 (*sdpi)->sdprow = NULL;
1490 (*sdpi)->sdpcol = NULL;
1491 (*sdpi)->sdpval = NULL;
1492 (*sdpi)->lplhs = NULL;
1493 (*sdpi)->lprhs = NULL;
1494 (*sdpi)->lprow = NULL;
1495 (*sdpi)->lpcol = NULL;
1496 (*sdpi)->lpval = NULL;
1519 SCIPdebugMessage(
"Calling SCIPsdpiFree \n");
1520 assert ( sdpi != NULL );
1521 assert ( *sdpi != NULL );
1524 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpval), (*sdpi)->lpnnonz);
1525 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpcol), (*sdpi)->lpnnonz);
1526 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprow), (*sdpi)->lpnnonz);
1527 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprhs), (*sdpi)->nlpcons);
1528 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lplhs), (*sdpi)->nlpcons);
1531 for (i = 0; i < (*sdpi)->nsdpblocks; i++)
1533 for (j = 0; j < (*sdpi)->sdpnblockvars[i]; j++)
1535 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1536 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1537 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1539 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i]), (*sdpi)->sdpnblockvars[i]);
1540 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i]), (*sdpi)->sdpnblockvars[i]);
1541 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i]), (*sdpi)->sdpnblockvars[i]);
1542 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar[i]), (*sdpi)->sdpnblockvars[i]);
1543 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz[i]), (*sdpi)->sdpnblockvars[i]);
1544 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval[i]), (*sdpi)->sdpconstnblocknonz[i]);
1545 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow[i]), (*sdpi)->sdpconstnblocknonz[i]);
1546 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol[i]), (*sdpi)->sdpconstnblocknonz[i]);
1550 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz), (*sdpi)->nsdpblocks);
1551 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstnblocknonz), (*sdpi)->nsdpblocks);
1552 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval), (*sdpi)->nsdpblocks);
1553 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol), (*sdpi)->nsdpblocks);
1554 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow), (*sdpi)->nsdpblocks);
1555 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar), (*sdpi)->nsdpblocks);
1556 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval), (*sdpi)->nsdpblocks);
1557 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol), (*sdpi)->nsdpblocks);
1558 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow), (*sdpi)->nsdpblocks);
1559 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvars), (*sdpi)->nsdpblocks);
1560 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpblocksizes), (*sdpi)->nsdpblocks);
1561 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->ub), (*sdpi)->nvars);
1562 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lb), (*sdpi)->nvars);
1563 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->obj), (*sdpi)->nvars);
1568 BMSfreeBlockMemory((*sdpi)->blkmem, sdpi);
1589 assert( oldsdpi != NULL );
1591 SCIPdebugMessage(
"Cloning SDPI %d\n", oldsdpi->sdpid);
1594 blkmem = oldsdpi->blkmem;
1595 nvars = oldsdpi->nvars;
1596 nsdpblocks = oldsdpi->nsdpblocks;
1597 lpnnonz = oldsdpi->lpnnonz;
1599 BMS_CALL( BMSallocBlockMemory(blkmem, &newsdpi) );
1601 SCIP_CALL(
SCIPsdpiSolverCreate(&(newsdpi->sdpisolver), oldsdpi->messagehdlr, oldsdpi->blkmem, oldsdpi->bufmem) );
1603 newsdpi->messagehdlr = oldsdpi->messagehdlr;
1604 newsdpi->blkmem = blkmem;
1605 newsdpi->nvars = nvars;
1607 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->obj), oldsdpi->obj, nvars) );
1608 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lb), oldsdpi->lb, nvars) );
1609 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->ub), oldsdpi->ub, nvars) );
1611 newsdpi->nsdpblocks = nsdpblocks;
1613 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpblocksizes), oldsdpi->sdpblocksizes, nsdpblocks) );
1614 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvars), oldsdpi->sdpnblockvars, nsdpblocks) );
1617 newsdpi->sdpconstnnonz = oldsdpi->sdpconstnnonz;
1619 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstnblocknonz), oldsdpi->sdpconstnblocknonz, nsdpblocks) );
1620 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow), nsdpblocks) );
1621 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol), nsdpblocks) );
1622 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstval), nsdpblocks) );
1624 for (b = 0; b < nsdpblocks; b++)
1626 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow[b]), oldsdpi->sdpconstrow[b], oldsdpi->sdpconstnblocknonz[b]) );
1627 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol[b]), oldsdpi->sdpconstcol[b], oldsdpi->sdpconstnblocknonz[b]) );
1628 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstval[b]), oldsdpi->sdpconstval[b], oldsdpi->sdpconstnblocknonz[b]) );
1632 newsdpi->sdpnnonz = oldsdpi->sdpnnonz;
1634 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz), nsdpblocks) );
1635 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpvar), nsdpblocks) );
1636 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow), nsdpblocks) );
1637 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol), nsdpblocks) );
1638 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval), nsdpblocks) );
1640 for (b = 0; b < nsdpblocks; b++)
1642 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz[b]), oldsdpi->sdpnblockvarnonz[b], oldsdpi->sdpnblockvars[b]) );
1643 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpvar[b]), oldsdpi->sdpvar[b], oldsdpi->sdpnblockvars[b]) );
1645 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow[b]), oldsdpi->sdpnblockvars[b]) );
1646 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b]), oldsdpi->sdpnblockvars[b]) );
1647 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval[b]), oldsdpi->sdpnblockvars[b]) );
1649 for (v = 0; v < oldsdpi->sdpnblockvars[b]; v++)
1651 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdprow[b][v]), oldsdpi->sdprow[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1652 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b][v]), oldsdpi->sdpcol[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1653 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpval[b][v]), oldsdpi->sdpval[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1658 newsdpi->nlpcons = oldsdpi->nlpcons;
1660 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lplhs), oldsdpi->lplhs, oldsdpi->nlpcons) );
1661 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprhs), oldsdpi->lprhs, oldsdpi->nlpcons) );
1663 newsdpi->lpnnonz = lpnnonz;
1665 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprow), oldsdpi->lprow, lpnnonz) );
1666 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpcol), oldsdpi->lpcol, lpnnonz) );
1667 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpval), oldsdpi->lpval, lpnnonz) );
1670 newsdpi->solved = FALSE;
1671 newsdpi->penalty = FALSE;
1672 newsdpi->infeasible = FALSE;
1673 newsdpi->allfixed = FALSE;
1674 newsdpi->sdpid = 1000000 + oldsdpi->sdpid;
1675 newsdpi->epsilon = oldsdpi->epsilon;
1676 newsdpi->gaptol = oldsdpi->gaptol;
1677 newsdpi->feastol = oldsdpi->feastol;
1707 int* sdpconstnblocknonz,
1711 SCIP_Real** sdpconstval,
1713 int** sdpnblockvarnonz,
1721 SCIP_Real*** sdpval,
1736 SCIPdebugMessage(
"Calling SCIPsdpiLoadSDP (%d)\n",sdpi->sdpid);
1738 assert ( sdpi != NULL );
1739 assert ( nvars > 0 );
1740 assert ( obj != NULL );
1741 assert ( lb != NULL );
1742 assert ( ub != NULL );
1745 if (sdpconstnnonz > 0 || sdpnnonz > 0 || nsdpblocks > 0)
1747 assert ( sdpblocksizes != NULL );
1748 assert ( sdpnblockvars != NULL );
1749 assert ( nsdpblocks > 0 );
1750 assert ( sdpconstnblocknonz != NULL );
1751 assert ( sdpnblockvarnonz != NULL );
1753 if (sdpconstnnonz > 0)
1755 assert ( sdpconstrow != NULL );
1756 assert ( sdpconstcol != NULL );
1757 assert ( sdpconstval != NULL );
1759 for (i = 0; i < nsdpblocks; i++)
1761 if (sdpconstnblocknonz[i] > 0)
1763 assert ( sdpconstrow[i] != NULL );
1764 assert ( sdpconstcol[i] != NULL );
1765 assert ( sdpconstval[i] != NULL );
1772 assert ( sdprow != NULL );
1773 assert ( sdpcol != NULL );
1774 assert ( sdpval != NULL );
1776 for ( i = 0; i < nsdpblocks; i++ )
1778 assert ( sdpcol[i] != NULL );
1779 assert ( sdprow[i] != NULL );
1780 assert ( sdpval[i] != NULL );
1782 for ( v = 0; v < sdpnblockvars[i]; v++)
1784 if (sdpnblockvarnonz[i][v] > 0)
1786 assert ( sdpcol[i][v] != NULL );
1787 assert ( sdprow[i][v] != NULL );
1788 assert ( sdpval[i][v] != NULL );
1796 assert ( nlpcons == 0 || lplhs != NULL );
1797 assert ( nlpcons == 0 || lprhs != NULL );
1798 assert ( lpnnonz == 0 || lprow != NULL );
1799 assert ( lpnnonz == 0 || lpcol != NULL );
1800 assert ( lpnnonz == 0 || lpval != NULL );
1805 for (block = sdpi->nsdpblocks - 1; block >= 0; block--)
1807 for (v = sdpi->sdpnblockvars[block] - 1; v >= 0; v--)
1809 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1810 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1811 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1814 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block]), sdpi->sdpnblockvars[block]);
1815 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block]), sdpi->sdpnblockvars[block]);
1816 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpi->sdpnblockvars[block]);
1817 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpi->sdpconstnblocknonz[block]);
1818 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpi->sdpconstnblocknonz[block]);
1819 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpi->sdpconstnblocknonz[block]);
1820 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpi->sdpnblockvars[block]);
1821 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpi->sdpnblockvars[block]);
1824 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->ub), sdpi->nvars);
1825 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lb), sdpi->nvars);
1826 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->obj), sdpi->nvars);
1828 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpblocksizes), sdpi->nsdpblocks);
1829 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvars), sdpi->nsdpblocks);
1830 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpi->nsdpblocks);
1833 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->obj), obj, nvars) );
1834 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->lb), lb, nvars) );
1835 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->ub), ub, nvars) );
1838 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpconstnblocknonz, nsdpblocks);
1841 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpnblockvarnonz), sdpi->nsdpblocks, nsdpblocks) );
1842 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstcol), sdpi->nsdpblocks, nsdpblocks) );
1843 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstrow), sdpi->nsdpblocks, nsdpblocks) );
1844 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstval), sdpi->nsdpblocks, nsdpblocks) );
1845 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpvar), sdpi->nsdpblocks, nsdpblocks) );
1846 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol), sdpi->nsdpblocks, nsdpblocks) );
1847 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow), sdpi->nsdpblocks, nsdpblocks) );
1848 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval), sdpi->nsdpblocks, nsdpblocks) );
1850 for (block = 0; block < nsdpblocks; block++)
1852 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpnblockvarnonz[block], sdpnblockvars[block]);
1854 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpconstcol[block], sdpconstnblocknonz[block]);
1855 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpconstrow[block], sdpconstnblocknonz[block]);
1856 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpconstval[block], sdpconstnblocknonz[block]);
1859 for (i = 0; i < sdpi->sdpconstnblocknonz[block]; ++i)
1862 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpvar[block], sdpnblockvars[block]);
1864 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpnblockvars[block]) );
1865 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow[block]), sdpnblockvars[block]) );
1866 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval[block]), sdpnblockvars[block]) );
1868 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
1870 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpcol[block][v], sdpnblockvarnonz[block][v]);
1871 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdprow[block][v], sdpnblockvarnonz[block][v]);
1872 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpval[block][v], sdpnblockvarnonz[block][v]);
1875 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; ++i)
1881 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1882 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1883 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1884 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1885 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1894 sdpi->nvars = nvars;
1895 sdpi->nsdpblocks = nsdpblocks;
1897 sdpi->sdpconstnnonz = sdpconstnnonz;
1898 sdpi->sdpnnonz = sdpnnonz;
1901 sdpi->lpnnonz = lpnnonz;
1902 sdpi->nlpcons = nlpcons;
1904 sdpi->solved = FALSE;
1905 sdpi->infeasible = FALSE;
1906 sdpi->allfixed = FALSE;
1907 sdpi->nsdpcalls = 0;
1908 sdpi->niterations = 0;
1920 const SCIP_Real* lhs,
1921 const SCIP_Real* rhs,
1926 const SCIP_Real* val
1931 SCIPdebugMessage(
"Adding %d LP-Constraints to SDP %d.\n", nrows, sdpi->sdpid);
1933 assert ( sdpi != NULL );
1938 assert ( lhs != NULL );
1939 assert ( rhs != NULL );
1940 assert ( nnonz >= 0 );
1941 assert ( row != NULL );
1942 assert ( col != NULL );
1943 assert ( val != NULL );
1945 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1946 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1948 for (i = 0; i < nrows; i++)
1950 sdpi->lplhs[sdpi->nlpcons + i] = lhs[i];
1951 sdpi->lprhs[sdpi->nlpcons + i] = rhs[i];
1954 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1955 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1956 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1958 for (i = 0; i < nnonz; i++)
1960 assert ( 0 <= row[i] && row[i] < nrows );
1962 sdpi->lprow[sdpi->lpnnonz + i] = row[i] + sdpi->nlpcons;
1964 assert ( 0 <= col[i] && col[i] < sdpi->nvars );
1965 sdpi->lpcol[sdpi->lpnnonz + i] = col[i];
1967 sdpi->lpval[sdpi->lpnnonz + i] = val[i];
1970 sdpi->nlpcons = sdpi->nlpcons + nrows;
1971 sdpi->lpnnonz = sdpi->lpnnonz + nnonz;
1973 sdpi->solved = FALSE;
1974 sdpi->infeasible = FALSE;
1975 sdpi->nsdpcalls = 0;
1976 sdpi->niterations = 0;
1994 SCIPdebugMessage(
"Deleting rows %d to %d from SDP %d.\n", firstrow, lastrow, sdpi->sdpid);
1996 assert ( sdpi != NULL );
1997 assert ( firstrow >= 0 );
1998 assert ( firstrow <= lastrow );
1999 assert ( lastrow < sdpi->nlpcons );
2002 if (firstrow == 0 && lastrow == sdpi->nlpcons - 1)
2004 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
2005 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
2006 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
2007 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
2008 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
2019 sdpi->solved = FALSE;
2020 sdpi->infeasible = FALSE;
2021 sdpi->allfixed = FALSE;
2022 sdpi->nsdpcalls = 0;
2023 sdpi->niterations = 0;
2028 deletedrows = lastrow - firstrow + 1;
2032 for (i = lastrow + 1; i < sdpi->nlpcons; i++)
2034 sdpi->lplhs[i - deletedrows] = sdpi->lplhs[i];
2035 sdpi->lprhs[i - deletedrows] = sdpi->lprhs[i];
2037 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2038 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2041 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
2045 for (i = 0; i < sdpi->lpnnonz; i++)
2047 if (sdpi->lprow[i] >= firstrow && sdpi->lprow[i] <= lastrow)
2056 if (firstrowind > -1)
2059 while (i < sdpi->lpnnonz && sdpi->lprow[i] <= lastrow)
2064 deletednonz = lastrowind - firstrowind + 1;
2067 for (i = lastrowind + 1; i < sdpi->lpnnonz; i++)
2069 sdpi->lpcol[i - deletednonz] = sdpi->lpcol[i];
2071 sdpi->lprow[i - deletednonz] = sdpi->lprow[i] - deletedrows;
2072 sdpi->lpval[i - deletednonz] = sdpi->lpval[i];
2076 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2077 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2078 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2079 sdpi->nlpcons = sdpi->nlpcons - deletedrows;
2080 sdpi->lpnnonz = sdpi->lpnnonz - deletednonz;
2082 sdpi->solved = FALSE;
2083 sdpi->infeasible = FALSE;
2084 sdpi->allfixed = FALSE;
2085 sdpi->nsdpcalls = 0;
2086 sdpi->niterations = 0;
2103 SCIPdebugMessage(
"Calling SCIPsdpiDelLPRowset for SDP %d.\n", sdpi->sdpid);
2105 assert ( sdpi != NULL );
2106 assert ( dstat != NULL );
2108 oldnlpcons = sdpi->nlpcons;
2111 for (i = 0; i < oldnlpcons; i++)
2121 dstat[i] = i - deletedrows;
2124 sdpi->solved = FALSE;
2125 sdpi->infeasible = FALSE;
2126 sdpi->allfixed = FALSE;
2127 sdpi->nsdpcalls = 0;
2128 sdpi->niterations = 0;
2138 assert( sdpi != NULL );
2140 SCIPdebugMessage(
"Called SCIPsdpiClear in SDP %d.\n", sdpi->sdpid);
2154 const SCIP_Real* obj
2159 SCIPdebugMessage(
"Changing %d objective coefficients in SDP %d\n", nvars, sdpi->sdpid);
2161 assert( sdpi != NULL );
2162 assert( ind != NULL );
2163 assert( obj != NULL );
2165 for (i = 0; i < nvars; i++)
2167 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2168 sdpi->obj[ind[i]] = obj[i];
2171 sdpi->solved = FALSE;
2172 sdpi->nsdpcalls = 0;
2173 sdpi->niterations = 0;
2183 const SCIP_Real* lb,
2189 SCIPdebugMessage(
"Changing %d variable bounds in SDP %d\n", nvars, sdpi->sdpid);
2191 assert( sdpi != NULL );
2192 assert( ind != NULL );
2193 assert( lb != NULL );
2194 assert( ub != NULL );
2196 for (i = 0; i < nvars; i++)
2198 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2199 sdpi->lb[ind[i]] = lb[i];
2200 sdpi->ub[ind[i]] = ub[i];
2203 sdpi->solved = FALSE;
2204 sdpi->infeasible = FALSE;
2205 sdpi->allfixed = FALSE;
2206 sdpi->nsdpcalls = 0;
2207 sdpi->niterations = 0;
2217 const SCIP_Real* lhs,
2218 const SCIP_Real* rhs
2223 SCIPdebugMessage(
"Changing %d left and right hand sides of SDP %d\n", nrows, sdpi->sdpid);
2225 assert( sdpi != NULL );
2226 assert( 0 <= nrows && nrows <= sdpi->nlpcons );
2227 assert( ind != NULL );
2228 assert( lhs != NULL );
2229 assert( rhs != NULL );
2231 for (i = 0; i < nrows; i++)
2233 assert ( ind[i] >= 0 );
2234 assert ( ind[i] < sdpi->nlpcons );
2235 sdpi->lplhs[ind[i]] = lhs[i];
2236 sdpi->lprhs[ind[i]] = rhs[i];
2239 sdpi->solved = FALSE;
2240 sdpi->infeasible = FALSE;
2241 sdpi->allfixed = FALSE;
2242 sdpi->nsdpcalls = 0;
2243 sdpi->niterations = 0;
2262 assert( sdpi != NULL );
2263 assert( nlprows != NULL );
2265 *nlprows = sdpi->nlpcons;
2276 assert( sdpi != NULL );
2277 assert( nsdpblocks != NULL );
2279 *nsdpblocks = sdpi->nsdpblocks;
2290 assert( sdpi != NULL );
2291 assert( nvars != NULL );
2293 *nvars = sdpi->nvars;
2304 assert( sdpi != NULL );
2305 assert( nnonz != NULL );
2307 *nnonz = sdpi->sdpnnonz;
2318 assert( sdpi != NULL );
2319 assert( nnonz != NULL );
2321 *nnonz = sdpi->sdpconstnnonz;
2332 assert( sdpi != NULL );
2333 assert( nnonz != NULL );
2335 *nnonz = sdpi->lpnnonz;
2350 assert( sdpi != NULL );
2351 assert( firstvar >= 0 );
2352 assert( firstvar <= lastvar );
2353 assert( lastvar < sdpi->nvars);
2354 assert( vals != NULL );
2356 for (i = 0; i < lastvar - firstvar + 1; i++)
2357 vals[i] = sdpi->obj[firstvar + i];
2373 assert( sdpi != NULL );
2374 assert( firstvar >= 0 );
2375 assert( firstvar <= lastvar );
2376 assert( lastvar < sdpi->nvars);
2377 assert( lbs != NULL );
2378 assert( ubs != NULL );
2380 for (i = 0; i < lastvar - firstvar + 1; i++)
2383 lbs[i] = sdpi->lb[firstvar + i];
2385 ubs[i] = sdpi->ub[firstvar + i];
2400 assert( sdpi != NULL );
2401 assert( firstrow >= 0 );
2402 assert( firstrow <= lastrow );
2403 assert( lastrow < sdpi->nlpcons);
2404 assert( lhss != NULL );
2406 for (i = 0; i < lastrow - firstrow + 1; i++)
2407 lhss[firstrow + i] = sdpi->lplhs[i];
2422 assert( sdpi != NULL );
2423 assert( firstrow >= 0 );
2424 assert( firstrow <= lastrow );
2425 assert( lastrow < sdpi->nlpcons);
2426 assert( rhss != NULL );
2428 for (i = 0; i < lastrow - firstrow + 1; i++)
2429 rhss[firstrow + i] = sdpi->lprhs[i];
2454 int* startZnblocknonz,
2460 SCIP_Real** startZval,
2462 int* startXnblocknonz,
2468 SCIP_Real** startXval,
2472 SCIP_Bool enforceslatercheck,
2477 int* sdpconstnblocknonz = NULL;
2478 int** sdpconstrow = NULL;
2479 int** sdpconstcol = NULL;
2480 SCIP_Real** sdpconstval = NULL;
2481 int** indchanges = NULL;
2482 int* nremovedinds = NULL;
2483 SCIP_Real* lplhsafterfix;
2484 SCIP_Real* lprhsafterfix;
2485 SCIP_Real solvertimelimit;
2486 SCIP_Bool fixingfound;
2488 clock_t currenttime;
2489 int* rowsnactivevars;
2490 int* blockindchanges;
2493 int nremovedblocks = 0;
2495 int naddediterations;
2498 assert( sdpi != NULL );
2500 starttime = clock();
2502 SCIPdebugMessage(
"Forwarding SDP %d to solver!\n", sdpi->sdpid);
2504 sdpi->penalty = FALSE;
2506 sdpi->solved = FALSE;
2507 sdpi->nsdpcalls = 0;
2508 sdpi->niterations = 0;
2512 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks) );
2513 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks) );
2514 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks) );
2515 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks) );
2516 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks) );
2517 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks) );
2518 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks) );
2519 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons) );
2520 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons) );
2521 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons) );
2523 for (block = 0; block < sdpi->nsdpblocks; block++)
2525 sdpconstrow[block] = NULL;
2526 sdpconstcol[block] = NULL;
2527 sdpconstval[block] = NULL;
2528 indchanges[block] = NULL;
2529 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]) );
2530 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2531 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2532 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2539 fixingfound = FALSE;
2542 while ( fixingfound );
2545 for (block = 0; block < sdpi->nsdpblocks; block++)
2546 sdpconstnblocknonz[block] = sdpi->sdpnnonz + sdpi->sdpconstnnonz;
2548 SCIP_CALL(
compConstMatAfterFixings(sdpi, &sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval) );
2551 for (block = 0; block < sdpi->nsdpblocks; block++)
2553 assert ( sdpconstnblocknonz[block] <= sdpi->sdpnnonz + sdpi->sdpconstnnonz );
2555 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2556 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2557 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2560 SCIP_CALL(
findEmptyRowColsSDP(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges, &nremovedblocks) );
2565 if ( sdpi->allfixed && ! sdpi->infeasible )
2567 SCIP_CALL(
checkFixedFeasibilitySdp(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges) );
2570 if ( sdpi->infeasible )
2572 SCIPdebugMessage(
"SDP %d not given to solver, as infeasibility was detected during presolving!\n", sdpi->sdpid++);
2575 sdpi->solved = TRUE;
2579 else if ( sdpi->allfixed )
2581 SCIPdebugMessage(
"SDP %d not given to solver, as all variables were fixed during presolving (the solution was feasible)!\n", sdpi->sdpid++);
2584 sdpi->solved = TRUE;
2590 if ( sdpi->slatercheck )
2592 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2593 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, FALSE) );
2597 solvertimelimit = timelimit;
2600 currenttime = clock();
2601 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2606 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2607 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2608 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2609 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2610 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2611 startXnblocknonz, startXrow, startXcol, startXval, startsettings, solvertimelimit) );
2613 sdpi->solved = TRUE;
2616 naddediterations = 0;
2618 sdpi->niterations += naddediterations;
2621 sdpi->nsdpcalls += naddedsdpcalls;
2626 SCIP_Real penaltyparam;
2627 SCIP_Real penaltyparamfact;
2629 SCIP_Real gaptolfact;
2631 SCIP_Bool penaltybound;
2636 penaltybound = TRUE;
2641 solvertimelimit = timelimit;
2644 currenttime = clock();
2645 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2651 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2652 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2653 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2654 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2655 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2659 naddediterations = 0;
2661 sdpi->niterations += naddediterations;
2664 sdpi->nsdpcalls += naddedsdpcalls;
2679 if ( (
SCIPsdpiSolverIsOptimal(sdpi->sdpisolver) && (objval > (sdpi->feastol > sdpi->gaptol ? sdpi->feastol : sdpi->gaptol))) ||
2682 SCIPdebugMessage(
"SDP %d found infeasible using penalty formulation, maximum of smallest eigenvalue is %f.\n", sdpi->sdpid, -1.0 * objval);
2683 sdpi->penalty = TRUE;
2684 sdpi->infeasible = TRUE;
2689 penaltybound = TRUE;
2691 penaltyparam = sdpi->penaltyparam;
2696 penaltyparamfact = sdpi->npenaltyincr > 0 ? pow((sdpi->maxpenaltyparam / sdpi->penaltyparam), 1.0/sdpi->npenaltyincr) :
2697 2*sdpi->maxpenaltyparam / sdpi->penaltyparam;
2698 gaptol = sdpi->gaptol;
2699 gaptolfact = sdpi->npenaltyincr > 0 ? pow((
MIN_GAPTOL / sdpi->gaptol), 1.0/sdpi->npenaltyincr) : 0.5 *
MIN_GAPTOL / sdpi->gaptol;
2705 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penaltyparameter %f\n", sdpi->sdpid, penaltyparam);
2708 solvertimelimit = timelimit;
2711 currenttime = clock();
2712 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2714 if ( solvertimelimit <= 0 )
2719 sdpi->lb, sdpi->ub, sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2720 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2721 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2722 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2723 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2724 startXnblocknonz, startXrow, startXcol, startXval, startsettings, solvertimelimit, &feasorig, &penaltybound) );
2727 naddediterations = 0;
2729 sdpi->niterations += naddediterations;
2732 sdpi->nsdpcalls += naddedsdpcalls;
2737 penaltyparam *= penaltyparamfact;
2738 SCIPdebugMessage(
"Solver did not converge even with penalty formulation, increasing penaltyparameter.\n");
2744 if ( objbound > sdpi->bestbound + sdpi->gaptol )
2745 sdpi->bestbound = objbound;
2753 penaltyparam *= penaltyparamfact;
2754 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, increasing penaltyparameter\n");
2758 gaptol *= gaptolfact;
2760 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, even though primal penalty "
2761 "bound was not reached, decreasing tolerance for duality gap in SDP-solver\n");
2767 if ( gaptol > sdpi->gaptol )
2775 sdpi->penalty = TRUE;
2776 sdpi->solved = TRUE;
2781 SCIPdebugMessage(
"Problem was found to be infeasible using a penalty formulation \n");
2782 sdpi->infeasible = TRUE;
2783 sdpi->penalty = TRUE;
2784 sdpi->solved = TRUE;
2789 SCIPdebugMessage(
"SDP-Solver could not solve the problem even after using a penalty formulation \n");
2790 sdpi->solved = FALSE;
2791 sdpi->penalty = TRUE;
2795 if ( sdpi->solved == FALSE && enforceslatercheck)
2797 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2798 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, TRUE) );
2800 else if ( sdpi->solved == FALSE )
2803 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Numerical trouble\n");
2805 SCIPdebugMessage(
"SDP-Interface was unable to solve SDP %d\n", sdpi->sdpid);
2813 for (block = 0; block < sdpi->nsdpblocks; block++)
2815 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpconstnblocknonz[block]);
2816 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpconstnblocknonz[block]);
2817 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpconstnblocknonz[block]);
2818 BMSfreeBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]);
2820 BMSfreeBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons);
2821 BMSfreeBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons);
2822 BMSfreeBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons);
2823 BMSfreeBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks);
2824 BMSfreeBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks);
2825 BMSfreeBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks);
2826 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks);
2827 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks);
2828 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks);
2829 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks);
2851 assert( sdpi != NULL );
2861 assert( sdpi != NULL );
2873 assert( sdpi != NULL );
2876 if ( sdpi->infeasible || sdpi->allfixed )
2885 SCIP_Bool* primalfeasible,
2886 SCIP_Bool* dualfeasible
2889 assert( sdpi != NULL );
2892 if ( sdpi->infeasible )
2894 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2895 *dualfeasible = FALSE;
2898 else if ( sdpi->allfixed )
2900 SCIPdebugMessage(
"All variables were fixed during preprocessing, dual problem is feasible, primal feasibility not available\n");
2901 *dualfeasible = TRUE;
2916 assert( sdpi != NULL );
2919 if ( sdpi->infeasible )
2921 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal unboundedness not available\n");
2924 else if ( sdpi->allfixed )
2926 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal unboundedness not available\n");
2939 assert( sdpi != NULL );
2942 if ( sdpi->infeasible )
2944 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2947 else if ( sdpi->allfixed )
2949 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal feasibility not available\n");
2962 assert(sdpi != NULL );
2965 if ( sdpi->infeasible )
2967 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2970 else if ( sdpi->allfixed )
2972 SCIPdebugMessage(
"All variables fixed during preprocessing, primal feasibility not available\n");
2985 assert( sdpi != NULL );
2988 if ( sdpi->infeasible )
2990 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore is not unbounded\n");
2993 else if ( sdpi->allfixed )
2995 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore the problem is not unbounded\n");
3008 assert( sdpi != NULL );
3011 if ( sdpi->infeasible )
3013 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3016 else if ( sdpi->allfixed )
3018 SCIPdebugMessage(
"All variables were fixed during preprocessing, solution is feasible\n");
3031 assert( sdpi != NULL );
3034 if ( sdpi->infeasible )
3036 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3039 else if ( sdpi->allfixed )
3041 SCIPdebugMessage(
"All variables fixed during preprocessing, solution is feasible\n");
3053 assert( sdpi != NULL );
3056 if ( sdpi->infeasible )
3058 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this counts as converged.\n");
3061 else if ( sdpi->allfixed )
3063 SCIPdebugMessage(
"All variables were fixed during preprocessing, this counts as converged.\n");
3075 assert( sdpi != NULL );
3078 if ( sdpi->infeasible )
3080 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective limit available.\n");
3083 else if ( sdpi->allfixed )
3085 SCIPdebugMessage(
"All variables were fixed during preprocessing, no objective limit available.\n");
3097 assert( sdpi != NULL );
3100 if ( sdpi->infeasible )
3102 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iteration limit available.\n");
3105 else if ( sdpi->allfixed )
3107 SCIPdebugMessage(
"All variables were fixed during preprocessing, no iteration limit available.\n");
3119 assert( sdpi != NULL );
3121 if ( sdpi->infeasible )
3123 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no time limit available.\n");
3126 else if ( sdpi->allfixed )
3128 SCIPdebugMessage(
"All variables were fixed during preprocessing, no time limit available.\n");
3131 else if ( ! sdpi->solved )
3133 SCIPdebugMessage(
"Problem was not solved, time limit not exceeded.\n");
3154 assert( sdpi != NULL );
3156 if ( ! sdpi->solved )
3158 SCIPdebugMessage(
"Problem wasn't solved yet.\n");
3161 else if ( sdpi->infeasible )
3163 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no internal status available.\n");
3166 else if ( sdpi->allfixed )
3168 SCIPdebugMessage(
"All variables were fixed during preprocessing, no internal status available.\n");
3180 assert( sdpi != NULL );
3183 if ( sdpi->infeasible )
3185 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore there is no optimal solution.\n");
3188 else if ( sdpi->allfixed )
3190 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore there is no optimal solution.\n");
3203 assert( sdpi != NULL );
3205 if ( sdpi->infeasible )
3207 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this is acceptable in a B&B context.\n");
3210 else if ( sdpi->allfixed )
3212 SCIPdebugMessage(
"All variables fixed during preprocessing, this is acceptable in a B&B context.\n");
3215 else if ( ! sdpi->solved )
3217 SCIPdebugMessage(
"Problem not solved succesfully, this is not acceptable in a B&B context.\n");
3230 assert( sdpi != NULL );
3231 assert( objval != NULL );
3234 if ( sdpi->infeasible )
3236 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3240 if ( sdpi->allfixed )
3247 for (v = 0; v < sdpi->nvars; v++)
3248 *objval += sdpi->lb[v] * sdpi->obj[v];
3265 assert( sdpi != NULL );
3266 assert( objlb != NULL );
3271 if ( sdpi->infeasible )
3273 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3277 if ( sdpi->allfixed )
3284 for (v = 0; v < sdpi->nvars; v++)
3285 *objlb += sdpi->lb[v] * sdpi->obj[v];
3295 if ( sdpi->penalty )
3297 *objlb = sdpi->bestbound;
3317 assert( sdpi != NULL );
3318 assert( dualsollength != NULL );
3319 assert( *dualsollength == 0 || dualsol != NULL );
3322 if ( sdpi->infeasible )
3324 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no solution available.\n");
3327 else if ( sdpi->allfixed )
3329 if ( objval != NULL )
3333 if ( *dualsollength > 0 )
3337 assert( dualsol != NULL );
3338 if ( *dualsollength < sdpi->nvars )
3340 SCIPdebugMessage(
"The given array in SCIPsdpiGetSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3341 *dualsollength = sdpi->nvars;
3347 for (v = 0; v < sdpi->nvars; v++)
3348 dualsol[v] = sdpi->lb[v];
3363 int* startXnblocknonz
3367 assert( sdpi != NULL );
3368 assert( nblocks >= 0 );
3369 assert( startXnblocknonz != NULL );
3371 if ( sdpi->infeasible )
3373 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no preoptimal solution available.\n");
3374 startXnblocknonz[0] = -1;
3378 else if ( sdpi->allfixed )
3380 SCIPdebugMessage(
"No primal solution available, as problem was solved during preprocessing\n");
3381 startXnblocknonz[0] = -1;
3405 int* startXnblocknonz,
3409 SCIP_Real** startXval
3412 assert( sdpi != NULL );
3413 assert( success != NULL );
3414 assert( dualsol != NULL );
3415 assert( dualsollength != NULL );
3416 assert( *dualsollength >= 0 );
3417 assert( startXnblocknonz != NULL || nblocks == -1 );
3418 assert( startXrow != NULL || nblocks == -1 );
3419 assert( startXcol != NULL || nblocks == -1 );
3420 assert( startXval != NULL || nblocks == -1 );
3422 if ( sdpi->infeasible )
3425 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no preoptimal solution available.\n");
3426 startXnblocknonz[0] = -1;
3430 else if ( sdpi->allfixed )
3434 assert( dualsol != NULL );
3438 if ( *dualsollength < sdpi->nvars )
3440 SCIPdebugMessage(
"The given array in SCIPsdpiGetPreoptimalSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3441 *dualsollength = sdpi->nvars;
3447 for (v = 0; v < sdpi->nvars; v++)
3448 dualsol[v] = sdpi->lb[v];
3452 SCIPdebugMessage(
"No primal solution available, as problem was solved during preprocessing\n");
3453 startXnblocknonz[0] = -1;
3460 startXrow, startXcol, startXval) );
3477 assert( sdpi != NULL );
3478 assert( lbvars != NULL );
3479 assert( ubvars != NULL );
3480 assert( arraylength != NULL );
3481 assert( *arraylength >= 0 );
3484 if ( sdpi->infeasible )
3486 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal variables available.\n");
3489 else if ( sdpi->allfixed )
3491 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal variables available.\n");
3504 int* startXnblocknonz
3507 assert( sdpi != NULL );
3509 if ( sdpi->infeasible )
3511 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal solution available.\n");
3514 else if ( sdpi->allfixed )
3516 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal solution available.\n");
3532 int* startXnblocknonz,
3536 SCIP_Real** startXval
3539 assert( sdpi != NULL );
3541 if ( sdpi->infeasible )
3543 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal solution available.\n");
3546 else if ( sdpi->allfixed )
3548 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal solution available.\n");
3562 assert( sdpi != NULL );
3573 assert( sdpi != NULL );
3574 assert( iterations != NULL );
3576 *iterations = sdpi->niterations;
3587 assert( sdpi != NULL );
3588 assert( calls != NULL );
3590 *calls = sdpi->nsdpcalls;
3601 assert( sdpi != NULL );
3602 assert( usedsetting != NULL );
3604 if ( ! sdpi->solved )
3606 SCIPdebugMessage(
"Problem was not solved successfully.\n");
3610 else if ( sdpi->infeasible && ! sdpi->penalty )
3612 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3616 else if ( sdpi->allfixed )
3618 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3622 else if ( sdpi->penalty )
3640 assert( sdpi != NULL );
3641 assert( slatersetting != NULL );
3643 if ( ! sdpi->solved )
3645 SCIPdebugMessage(
"Problem was not solved successfully");
3648 SCIPdebugMessage(
", but we could at least compute a lower bound. \n");
3653 switch( sdpi->primalslater )
3665 switch( sdpi->dualslater )
3689 SCIPdebugMessage(
".\n");
3694 switch( sdpi->primalslater )
3706 switch( sdpi->dualslater )
3730 else if ( sdpi->infeasible && ( ! sdpi->penalty ) )
3732 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3736 else if ( sdpi->allfixed )
3738 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3742 else if ( sdpi->penalty )
3744 switch( sdpi->primalslater )
3761 switch( sdpi->dualslater )
3787 switch( sdpi->primalslater )
3794 switch( usedsetting )
3812 switch( usedsetting )
3834 switch( usedsetting )
3852 switch( usedsetting )
3868 switch( sdpi->dualslater )
3876 switch( usedsetting )
3893 switch( usedsetting )
3910 switch( usedsetting )
3944 assert( sdpi != NULL );
3945 assert( primalslater != NULL );
3946 assert( dualslater != NULL );
3949 if ( sdpi->infeasible )
3952 *dualslater = sdpi->dualslater;
3956 if (sdpi->allfixed )
3963 *primalslater = sdpi->primalslater;
3964 *dualslater = sdpi->dualslater;
3986 assert( sdpi != NULL );
3997 assert( sdpi != NULL );
4009 assert( sdpi != NULL );
4010 assert( sdpi->sdpisolver != NULL );
4011 assert( dval != NULL );
4016 *dval = sdpi->epsilon;
4019 *dval = sdpi->gaptol;
4022 *dval = sdpi->feastol;
4031 *dval = sdpi->penaltyparam;
4034 *dval = sdpi->maxpenaltyparam;
4043 return SCIP_PARAMETERUNKNOWN;
4056 assert( sdpi != NULL );
4061 sdpi->epsilon = dval;
4065 sdpi->gaptol = dval;
4069 sdpi->feastol = dval;
4079 sdpi->penaltyparam = dval;
4083 sdpi->maxpenaltyparam = dval;
4092 return SCIP_PARAMETERUNKNOWN;
4105 assert( sdpi != NULL );
4106 assert( sdpi->sdpisolver != NULL );
4107 assert( ival != NULL );
4116 *ival = sdpi->slatercheck;
4119 *ival = sdpi->npenaltyincr;
4122 return SCIP_PARAMETERUNKNOWN;
4135 assert( sdpi != NULL );
4136 assert( sdpi->sdpisolver != NULL );
4141 assert( ival == 0 || ival == 1 );
4148 sdpi->slatercheck = ival;
4151 sdpi->npenaltyincr = ival;
4154 return SCIP_PARAMETERUNKNOWN;
4173 SCIP_Real* penaltyparam
4178 sdpi->penaltyparam = *penaltyparam;
4186 SCIP_Real penaltyparam,
4187 SCIP_Real* maxpenaltyparam
4192 sdpi->maxpenaltyparam = *maxpenaltyparam;
4196 if ( sdpi->penaltyparam > *maxpenaltyparam )
4198 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpi->penaltyparam, *maxpenaltyparam);
4199 sdpi->penaltyparam = *maxpenaltyparam;
4223 SCIPdebugMessage(
"Not implemented yet\n");
4224 return SCIP_LPERROR;
4233 SCIPdebugMessage(
"Not implemented yet\n");
4234 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_Bool SCIPsdpiDoesWarmstartNeedPrimal(void)
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 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)
EXTERN SCIP_RETCODE SCIPsdpiSolverResetCounter(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverFeasibilityKnown(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverIsConverged(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetPrimalMatrix(SCIP_SDPI *sdpi, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
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)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetPreoptimalPrimalNonzeros(SCIP_SDPISOLVER *sdpisolver, int nblocks, int *startXnblocknonz)
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_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)
EXTERN int SCIPsdpiSolverGetDefaultSdpiSolverNpenaltyIncreases(void)
SCIP_RETCODE SCIPsdpiGetPrimalNonzeros(SCIP_SDPI *sdpi, int nblocks, int *startXnblocknonz)
EXTERN SCIP_Bool SCIPsdpiSolverWasSolved(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverDoesWarmstartNeedPrimal(void)
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_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)
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_RETCODE SCIPsdpiSolverGetPrimalMatrix(SCIP_SDPISOLVER *sdpisolver, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
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)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetPrimalNonzeros(SCIP_SDPISOLVER *sdpisolver, int nblocks, int *startXnblocknonz)
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)
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)
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)
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
EXTERN SCIP_Real SCIPsdpiSolverGetMaxPrimalEntry(SCIP_SDPISOLVER *sdpisolver)
#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_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)
static SCIP_RETCODE checkSlaterCondition(SCIP_SDPI *sdpi, SCIP_Real timelimit, clock_t starttime, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int **indchanges, int *nremovedinds, SCIP_Real *lplhsafterfix, SCIP_Real *lprhsafterfix, int *rowsnactivevars, int *blockindchanges, int sdpconstnnonz, int nactivelpcons, int nremovedblocks, SCIP_Bool rootnodefailed)
struct SCIP_SDPiSolver SCIP_SDPISOLVER
SCIP_RETCODE SCIPsdpiGetRealpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, SCIP_Real *dval)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetPreoptimalSol(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *success, SCIP_Real *dualsol, int *dualsollength, int nblocks, int *startXnblocknonz, int **startXrow, int **startXcol, SCIP_Real **startXval)
EXTERN SCIP_Real SCIPsdpiSolverGetDefaultSdpiSolverGaptol(void)
static SCIP_RETCODE compConstMatAfterFixings(SCIP_SDPI *sdpi, int *sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval)
EXTERN SCIP_Real SCIPsdpiSolverGetDefaultSdpiSolverFeastol(void)
SCIP_Real SCIPsdpiGetDefaultSdpiSolverGaptol(void)
SCIP_RETCODE SCIPsdpiGetPreoptimalPrimalNonzeros(SCIP_SDPI *sdpi, int nblocks, int *startXnblocknonz)
#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)
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)