48 #include "blockmemshell/memory.h"
50 #include "scip/pub_misc.h"
51 #include "scip/pub_message.h"
58 #define BMS_CALL(x) do \
62 SCIPerrorMessage("No memory in function call\n"); \
63 return SCIP_NOMEMORY; \
69 #define CHECK_IF_SOLVED(sdpi) do \
71 if ( ! (sdpi->solved) ) \
73 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \
74 return SCIP_LPERROR; \
80 #define CHECK_IF_SOLVED_BOOL(sdpi) do \
82 if ( ! (sdpi->solved) ) \
84 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \
91 #define DUPLICATE_ARRAY_NULL(blkmem, target, source, size) do \
94 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, target, source, size) ); \
101 #define SCIP_CALL_PARAM(x) do \
103 SCIP_RETCODE _restat_; \
104 if ( (_restat_ = (x)) != SCIP_OKAY ) \
106 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \
108 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \
117 #define SCIP_CALL_PARAM_IGNORE_UNKNOWN(x) do \
119 SCIP_RETCODE _restat_; \
120 if ( (_restat_ = (x)) != SCIP_OKAY ) \
122 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \
124 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \
132 #define MIN_GAPTOL 1e-10
134 #define DEFAULT_SDPSOLVERGAPTOL 1e-4
135 #define DEFAULT_FEASTOL 1e-6
136 #define DEFAULT_EPSILON 1e-9
137 #define DEFAULT_PENALTYPARAM 1e+5
138 #define DEFAULT_MAXPENALTYPARAM 1e+10
139 #define DEFAULT_NPENALTYINCR 8
145 SCIP_MESSAGEHDLR* messagehdlr;
158 int* sdpconstnblocknonz;
162 SCIP_Real** sdpconstval;
166 int** sdpnblockvarnonz;
191 SCIP_Bool infeasible;
196 SCIP_Real penaltyparam;
197 SCIP_Real maxpenaltyparam;
199 SCIP_Real peninfeasadjust;
239 assert ( sdpi != NULL );
240 assert ( v < sdpi->nvars );
241 assert ( sdpi->lb != NULL );
242 assert ( sdpi->ub != NULL );
247 assert( lb < ub + sdpi->feastol || sdpi->infeasible );
249 return ( ub-lb <= sdpi->epsilon );
252 #define isFixed(sdpi, v) (sdpi->ub[v] - sdpi->lb[v] <= sdpi->epsilon)
266 int* sdpconstnblocknonz,
270 SCIP_Real** sdpconstval
279 SCIP_Real** fixedvals;
281 assert ( sdpi != NULL );
282 assert ( sdpconstnnonz != NULL );
283 assert ( sdpconstnblocknonz != NULL );
284 assert ( sdpconstrow != NULL );
285 assert ( sdpconstcol != NULL );
286 assert ( sdpconstval != NULL );
288 for (block = 0; block < sdpi->nsdpblocks; block++)
290 assert ( sdpconstrow[block] != NULL );
291 assert ( sdpconstcol[block] != NULL );
292 assert ( sdpconstval[block] != NULL );
301 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks) );
302 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks) );
303 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks) );
304 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks) );
306 for (block = 0; block < sdpi->nsdpblocks; block++)
309 nfixednonz[block] = 0;
310 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
312 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
313 nfixednonz[block] += sdpi->sdpnblockvarnonz[block][v];
316 fixedrows[block] = NULL;
317 fixedcols[block] = NULL;
318 fixedvals[block] = NULL;
320 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]) );
321 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]) );
322 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]) );
325 nfixednonz[block] = 0;
329 for (block = 0; block < sdpi->nsdpblocks; block++)
331 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
333 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
335 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
337 fixedrows[block][nfixednonz[block]] = sdpi->sdprow[block][v][i];
338 fixedcols[block][nfixednonz[block]] = sdpi->sdpcol[block][v][i];
341 fixedvals[block][nfixednonz[block]] = - sdpi->sdpval[block][v][i] * sdpi->lb[sdpi->sdpvar[block][v]];
350 for (block = 0; block < sdpi->nsdpblocks; block++)
353 sdpi->sdpconstnblocknonz[block], fixedrows[block], fixedcols[block], fixedvals[block], nfixednonz[block],
354 sdpconstrow[block], sdpconstcol[block], sdpconstval[block], &sdpconstnblocknonz[block]) );
355 *sdpconstnnonz += sdpconstnblocknonz[block];
359 for (block = 0; block < sdpi->nsdpblocks; block++)
361 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]);
362 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]);
363 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]);
365 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks);
366 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks);
367 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks);
368 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks);
379 int* sdpconstnblocknonz,
383 SCIP_Real** sdpconstval,
389 int* blockindchanges,
398 assert( sdpi != NULL );
399 assert( sdpconstnblocknonz != NULL );
400 assert( sdpconstrow != NULL );
401 assert( sdpconstcol != NULL );
402 assert( sdpconstval != NULL );
403 assert( indchanges != NULL );
404 assert( nremovedinds != NULL );
405 assert( blockindchanges != NULL );
406 assert( nremovedblocks != NULL );
409 for (block = 0; block < sdpi->nsdpblocks; block++)
411 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
412 indchanges[block][i] = -1;
418 for (block = 0; block < sdpi->nsdpblocks; block++)
422 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
424 if ( ! (
isFixed(sdpi, sdpi->sdpvar[block][v])) )
426 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
428 assert ( REALABS(sdpi->sdpval[block][v][i]) > sdpi->epsilon);
429 if ( indchanges[block][sdpi->sdprow[block][v][i]] == -1 )
431 indchanges[block][sdpi->sdprow[block][v][i]] = 1;
434 if ( indchanges[block][sdpi->sdpcol[block][v][i]] == -1 )
436 indchanges[block][sdpi->sdpcol[block][v][i]] = 1;
439 if ( nfoundinds == sdpi->sdpblocksizes[block] )
443 if (nfoundinds == sdpi->sdpblocksizes[block])
447 if ( nfoundinds < sdpi->sdpblocksizes[block] )
450 for (i = 0; i < sdpconstnblocknonz[block]; i++)
452 assert ( REALABS(sdpconstval[block][i]) > sdpi->epsilon);
453 if ( indchanges[block][sdpconstrow[block][i]] == -1 )
455 indchanges[block][sdpconstrow[block][i]] = 1;
458 if ( indchanges[block][sdpconstcol[block][i]] == -1 )
460 indchanges[block][sdpconstcol[block][i]] = 1;
463 if ( nfoundinds == sdpi->sdpblocksizes[block] )
469 nremovedinds[block] = 0;
470 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
472 if ( indchanges[block][i] == -1 )
474 SCIPdebugMessage(
"empty row and col %d were removed from block %d of SDP %d\n", i, block, sdpi->sdpid);
476 nremovedinds[block]++;
481 indchanges[block][i] = nremovedinds[block];
486 if ( nremovedinds[block] == sdpi->sdpblocksizes[block] )
488 SCIPdebugMessage(
"empty block %d detected in SDP %d, this will be removed", block, sdpi->sdpid);
489 blockindchanges[block] = -1;
493 blockindchanges[block] = *nremovedblocks;
507 SCIP_Real* lplhsafterfix,
511 SCIP_Real* lprhsafterfix,
516 SCIP_Bool* fixingsfound
526 assert( sdpi != NULL );
527 assert( nactivelpcons != NULL );
528 assert( sdpi->nlpcons == 0 || lplhsafterfix != NULL );
529 assert( sdpi->nlpcons == 0 || lprhsafterfix != NULL );
530 assert( sdpi->nlpcons == 0 || rownactivevars != NULL );
531 assert( sdpi->nlpcons == 0 || fixingsfound != NULL );
534 if ( sdpi->nlpcons == 0 || sdpi->lpnnonz == 0 )
541 for (c = 0; c < sdpi->nlpcons; c++)
542 rownactivevars[c] = 0;
545 for (i = 0; i < sdpi->lpnnonz; i++)
547 assert( i == 0 || sdpi->lprow[i-1] <= sdpi->lprow[i] );
550 if ( sdpi->lprow[i] > lastrow )
553 if ( lastrow >= 0 && rownactivevars[lastrow] > 1 )
555 else if ( lastrow >= 0 && rownactivevars[lastrow] == 1 )
557 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
559 nonzcol = sdpi->lpcol[nonzind];
560 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
562 nonzval = sdpi->lpval[nonzind];
563 assert( REALABS(nonzval) > sdpi->epsilon );
570 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
573 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
574 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
575 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
578 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
580 *fixingsfound = TRUE;
581 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
582 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
585 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
587 sdpi->infeasible = TRUE;
588 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
589 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
595 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
598 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
599 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
600 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
603 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
605 *fixingsfound = TRUE;
606 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
607 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
611 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
613 sdpi->infeasible = TRUE;
614 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
615 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
624 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
627 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
628 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
629 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
632 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
634 *fixingsfound = TRUE;
635 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
636 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
640 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
642 sdpi->infeasible = TRUE;
643 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
644 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
650 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
653 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
654 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
655 sdpi->ub[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
658 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
660 *fixingsfound = TRUE;
661 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
662 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
666 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
668 sdpi->infeasible = TRUE;
669 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
670 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
676 else if ( lastrow >= 0 )
678 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
680 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
682 sdpi->infeasible = TRUE;
683 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
684 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
690 lastrow = sdpi->lprow[i];
693 lplhsafterfix[*nactivelpcons] = sdpi->lplhs[lastrow];
694 lprhsafterfix[*nactivelpcons] = sdpi->lprhs[lastrow];
698 if ( !
isFixed(sdpi, sdpi->lpcol[i]) )
700 rownactivevars[lastrow]++;
706 lplhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
707 lprhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
712 if ( rownactivevars[lastrow] > 1 )
714 else if ( rownactivevars[lastrow] == 1 )
716 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
718 nonzcol = sdpi->lpcol[nonzind];
719 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
721 nonzval = sdpi->lpval[nonzind];
722 assert( REALABS(nonzval) > sdpi->epsilon );
729 ( (lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
732 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
733 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
734 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
737 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
739 *fixingsfound = TRUE;
740 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
741 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
745 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
747 sdpi->infeasible = TRUE;
748 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
754 ( (lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] - sdpi->epsilon) )
757 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
758 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
759 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
762 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
764 *fixingsfound = TRUE;
765 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
766 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
770 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
772 sdpi->infeasible = TRUE;
773 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
782 ( (lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->epsilon) )
785 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
786 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
787 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
790 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
792 *fixingsfound = TRUE;
793 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
794 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
798 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
800 sdpi->infeasible = TRUE;
801 SCIPdebugMessage(
"We found a lower bound that is bigger than the upper bound, so the problem is infeasible !\n");
807 ( (lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->epsilon) )
810 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
811 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
812 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
815 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->epsilon )
817 *fixingsfound = TRUE;
818 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
819 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
823 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
825 sdpi->infeasible = TRUE;
826 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
834 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
836 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
838 sdpi->infeasible = TRUE;
839 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
840 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
858 for (v = 0; v < sdpi->nvars; v++)
862 sdpi->allfixed = FALSE;
869 SCIPdebugMessage(
"Detected that all variables in SDP %d are fixed.\n", sdpi->sdpid);
870 sdpi->allfixed = TRUE;
881 int* sdpconstnblocknonz,
885 SCIP_Real** sdpconstval,
894 SCIP_Real* fullmatrix;
897 SCIP_Real eigenvalue;
903 assert( sdpi->allfixed );
908 for (b = 0; b < sdpi->nsdpblocks; b++)
910 if ( sdpi->sdpblocksizes[b] - nremovedinds[b] > maxsize )
911 maxsize = sdpi->sdpblocksizes[b] - nremovedinds[b];
915 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize) );
918 for (b = 0; b < sdpi->nsdpblocks; b++)
921 if ( blockindchanges[b] == -1 )
924 size = sdpi->sdpblocksizes[b] - nremovedinds[b];
927 for (i = 0; i < size * size; i++)
931 for (i = 0; i < sdpconstnblocknonz[b]; i++)
933 assert( 0 <= sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] && sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]] < size );
934 assert( 0 <= sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] && sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]] < size );
935 fullmatrix[(sdpconstrow[b][i] - indchanges[b][sdpconstrow[b][i]]) * size
936 + sdpconstcol[b][i] - indchanges[b][sdpconstcol[b][i]]] = -1 * sdpconstval[b][i];
940 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
942 fixedval = sdpi->lb[sdpi->sdpvar[b][v]];
945 if ( REALABS(fixedval) < sdpi->epsilon )
949 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
951 assert( 0 <= sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] &&
952 sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]] < size );
953 assert( 0 <= sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] &&
954 sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]] < size );
955 fullmatrix[(sdpi->sdprow[b][v][i] - indchanges[b][sdpi->sdprow[b][v][i]]) * size
956 + sdpi->sdpcol[b][v][i] - indchanges[b][sdpi->sdpcol[b][v][i]]] += fixedval * sdpi->sdpval[b][v][i];
964 if ( eigenvalue < -1 * sdpi->feastol )
966 sdpi->infeasible = TRUE;
967 SCIPdebugMessage(
"Detected infeasibility for SDP %d with all fixed variables!\n", sdpi->sdpid);
973 BMSfreeBlockMemoryArray(sdpi->blkmem, &fullmatrix, maxsize * maxsize);
976 sdpi->infeasible = FALSE;
977 SCIPdebugMessage(
"Unique solution for SDP %d with all fixed variables is feasible!\n", sdpi->sdpid);
990 int* sdpconstnblocknonz,
994 SCIP_Real** sdpconstval,
998 SCIP_Real* lplhsafterfix,
999 SCIP_Real* lprhsafterfix,
1000 int* rowsnactivevars,
1001 int* blockindchanges,
1006 SCIP_Bool rootnodefailed
1011 SCIP_Bool origfeas = FALSE;
1012 SCIP_Bool penaltybound = FALSE;
1015 SCIP_Real* slaterlpval;
1016 SCIP_Real* slaterlplhs;
1017 SCIP_Real* slaterlprhs;
1018 int* slaterrowsnactivevars;
1019 int nremovedslaterlpinds;
1023 int slaternactivelpcons;
1024 SCIP_Real* slaterlb;
1025 SCIP_Real* slaterub;
1026 int slaternremovedvarbounds;
1027 SCIP_Real solvertimelimit;
1028 clock_t currenttime;
1030 assert( sdpi != NULL );
1031 assert( sdpconstnnonz == 0 || sdpconstnblocknonz != NULL );
1032 assert( sdpconstnnonz == 0 || sdpconstrow != NULL );
1033 assert( sdpconstnnonz == 0 || sdpconstcol != NULL );
1034 assert( sdpconstnnonz == 0 || sdpconstval != NULL );
1035 assert( sdpi->nsdpblocks == 0 || indchanges != NULL );
1036 assert( sdpi->nsdpblocks == 0 || nremovedinds != NULL );
1037 assert( nactivelpcons == 0 || lplhsafterfix != NULL );
1038 assert( nactivelpcons == 0 || lprhsafterfix != NULL );
1039 assert( sdpi->nlpcons == 0 || rowsnactivevars != NULL );
1040 assert( sdpi->nsdpblocks == 0 || blockindchanges != NULL );
1045 solvertimelimit = timelimit;
1048 currenttime = clock();
1049 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
1055 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1056 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1057 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1058 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1059 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1064 if ( rootnodefailed )
1066 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem could "
1067 "not be checked, ");
1069 else if ( sdpi->slatercheck == 2 )
1070 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for dual problem.\n");
1077 if ( rootnodefailed )
1078 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds "
1079 "as smallest eigenvalue maximization problem is unbounded, ");
1082 SCIPdebugMessage(
"Slater condition for dual problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded.\n", sdpi->sdpid);
1088 if ( rootnodefailed )
1090 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem "
1091 "not fullfilled as problem is infeasible, ");
1093 else if ( sdpi->slatercheck == 2 )
1094 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for dual problem for SDP %d not fullfilled, problem infeasible.\n", sdpi->sdpid);
1101 if ( objval < - sdpi->feastol )
1103 if ( rootnodefailed )
1105 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem holds"
1106 "with smallest eigenvalue %f, ", -1.0 * objval);
1109 SCIPdebugMessage(
"Slater condition for SDP %d is fullfilled for dual problem with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1112 else if ( objval < sdpi->feastol )
1114 if ( rootnodefailed )
1116 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Aborting due to failing to solve the root node relaxation, Slater condition for the dual problem "
1117 "not fullfilled with smallest eigenvalue %f, ", -1.0 * objval);
1119 else if ( sdpi->slatercheck == 2 )
1121 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, expect numerical trouble.\n",
1122 sdpi->sdpid, -1.0 * objval);
1128 if ( sdpi->slatercheck == 2 )
1130 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, problem is infeasible.\n",
1131 sdpi->sdpid, -1.0 * objval);
1156 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars) );
1157 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars) );
1158 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars) );
1161 for (i = 0; i < sdpi->lpnnonz; i++)
1163 slaterlprow[i] = sdpi->lprow[i];
1164 slaterlpcol[i] = sdpi->lpcol[i];
1165 slaterlpval[i] = sdpi->lpval[i];
1169 for (v = 0; v < sdpi->nvars; v++)
1171 slaterlprow[sdpi->lpnnonz + v] = sdpi->nlpcons;
1172 slaterlpcol[sdpi->lpnnonz + v] = v;
1173 slaterlpval[sdpi->lpnnonz + v] = 0.0;
1175 for (b = 0; b < sdpi->nsdpblocks; b++)
1177 for (v = 0; v < sdpi->sdpnblockvars[b]; v++)
1179 for (i = 0; i < sdpi->sdpnblockvarnonz[b][v]; i++)
1181 if ( sdpi->sdprow[b][v][i] == sdpi->sdpcol[b][v][i] )
1182 slaterlpval[sdpi->lpnnonz + sdpi->sdpvar[b][v]] += sdpi->sdpval[b][v][i];
1188 nremovedslaterlpinds = 0;
1189 for (v = 0; v < sdpi->nvars; v++)
1191 if ( REALABS(slaterlpval[sdpi->lpnnonz + v]) <= sdpi->epsilon )
1192 nremovedslaterlpinds++;
1196 slaterlprow[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlprow[sdpi->lpnnonz + v];
1197 slaterlpcol[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpcol[sdpi->lpnnonz + v];
1198 slaterlpval[sdpi->lpnnonz + v - nremovedslaterlpinds] = slaterlpval[sdpi->lpnnonz + v];
1203 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1) );
1204 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1) );
1207 for (i = 0; i < nactivelpcons; i++)
1210 slaterlplhs[i] = lplhsafterfix[i];
1212 slaterlplhs[i] = 0.0;
1215 slaterlprhs[i] = lprhsafterfix[i];
1217 slaterlprhs[i] = 0.0;
1221 slaterlplhs[nactivelpcons] = 1.0;
1225 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1) );
1228 for (i = 0; i < sdpi->nlpcons; i++)
1229 slaterrowsnactivevars[i] = rowsnactivevars[i];
1232 slaterrowsnactivevars[sdpi->nlpcons] = 0;
1233 for (v = 0; v < sdpi->nvars; v++)
1236 slaterrowsnactivevars[sdpi->nlpcons]++;
1239 slaternactivelpcons = (slaterrowsnactivevars[sdpi->nlpcons] > 1) ? nactivelpcons + 1 : nactivelpcons;
1246 slaternremovedvarbounds = 0;
1247 for (v = 0; v < sdpi->nvars; v++)
1252 slaternremovedvarbounds++;
1257 slaternremovedvarbounds++;
1264 if ( slaternremovedvarbounds == 2 * sdpi->nvars )
1266 if ( rootnodefailed )
1268 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem holds since all variables have finite upper and lower bounds \n");
1271 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled as all variables have finite upper and lower bounds \n", sdpi->sdpid);
1277 currenttime = clock();
1278 solvertimelimit = timelimit - ((SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC);
1282 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, 0, NULL, NULL, NULL, NULL,
1283 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1284 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, slaternactivelpcons, sdpi->nlpcons + 1, slaterlplhs, slaterlprhs,
1285 slaterrowsnactivevars, sdpi->lpnnonz + sdpi->nvars - nremovedslaterlpinds, slaterlprow, slaterlpcol, slaterlpval, NULL, NULL, NULL, NULL,
1290 if ( rootnodefailed )
1292 SCIPmessagePrintInfo(sdpi->messagehdlr,
"unable to check Slater condition for primal problem \n");
1294 else if ( sdpi->slatercheck == 2 )
1295 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Unable to check Slater condition for primal problem, could not solve auxilliary problem.\n");
1300 if ( rootnodefailed )
1302 SCIPmessagePrintInfo(sdpi->messagehdlr,
" primal Slater condition shows infeasibility \n");
1304 else if ( sdpi->slatercheck == 2 )
1306 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled "
1307 "smallest eigenvalue has to be negative, so primal problem is infeasible (if the dual slater condition holds,"
1308 "this means, that the original (dual) problem is unbounded.\n",sdpi->sdpid);
1314 if ( rootnodefailed )
1316 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problems holds sunce smallest eigenvalue maximization problem"
1320 SCIPdebugMessage(
"Slater condition for primal problem for SDP %d fullfilled, smallest eigenvalue maximization problem unbounded \n", sdpi->sdpid);
1327 if ( objval > - sdpi->feastol)
1329 if ( rootnodefailed )
1331 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem not fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1333 else if ( sdpi->slatercheck == 2 )
1335 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem for SDP %d not fullfilled "
1336 "as smallest eigenvalue was %f, expect numerical trouble or infeasible problem.\n",sdpi->sdpid, -1.0 * objval);
1342 if ( rootnodefailed )
1344 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Slater condition for primal problem fullfilled with smallest eigenvalue %f \n", -1.0 * objval);
1347 SCIPdebugMessage(
"Slater condition for primal problem of SDP %d is fullfilled with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1354 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterub, sdpi->nvars);
1355 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlb, sdpi->nvars);
1356 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterrowsnactivevars, sdpi->nlpcons + 1);
1357 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprhs, nactivelpcons + 1);
1358 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlplhs, nactivelpcons + 1);
1359 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpval, sdpi->lpnnonz + sdpi->nvars);
1360 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlpcol, sdpi->lpnnonz + sdpi->nvars);
1361 BMSfreeBlockMemoryArray(sdpi->blkmem, &slaterlprow, sdpi->lpnnonz + sdpi->nvars);
1448 SCIP_MESSAGEHDLR* messagehdlr,
1453 assert ( sdpi != NULL );
1454 assert ( blkmem != NULL );
1456 SCIPdebugMessage(
"Calling SCIPsdpiCreate\n");
1458 BMS_CALL( BMSallocBlockMemory(blkmem, sdpi) );
1462 (*sdpi)->messagehdlr = messagehdlr;
1463 (*sdpi)->blkmem = blkmem;
1464 (*sdpi)->bufmem = bufmem;
1466 (*sdpi)->niterations = 0;
1467 (*sdpi)->nsdpcalls = 0;
1469 (*sdpi)->nsdpblocks = 0;
1470 (*sdpi)->sdpconstnnonz = 0;
1471 (*sdpi)->sdpnnonz = 0;
1472 (*sdpi)->nlpcons = 0;
1473 (*sdpi)->lpnnonz = 0;
1474 (*sdpi)->slatercheck = 0;
1475 (*sdpi)->solved = FALSE;
1476 (*sdpi)->penalty = FALSE;
1477 (*sdpi)->infeasible = FALSE;
1478 (*sdpi)->allfixed = FALSE;
1480 (*sdpi)->obj = NULL;
1483 (*sdpi)->sdpblocksizes = NULL;
1484 (*sdpi)->sdpnblockvars = NULL;
1485 (*sdpi)->sdpconstnblocknonz = NULL;
1486 (*sdpi)->sdpconstrow = NULL;
1487 (*sdpi)->sdpconstcol = NULL;
1488 (*sdpi)->sdpconstval = NULL;
1489 (*sdpi)->sdpnblockvarnonz = NULL;
1490 (*sdpi)->sdpvar = NULL;
1491 (*sdpi)->sdprow = NULL;
1492 (*sdpi)->sdpcol = NULL;
1493 (*sdpi)->sdpval = NULL;
1494 (*sdpi)->lplhs = NULL;
1495 (*sdpi)->lprhs = NULL;
1496 (*sdpi)->lprow = NULL;
1497 (*sdpi)->lpcol = NULL;
1498 (*sdpi)->lpval = NULL;
1521 SCIPdebugMessage(
"Calling SCIPsdpiFree \n");
1522 assert ( sdpi != NULL );
1523 assert ( *sdpi != NULL );
1526 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpval), (*sdpi)->lpnnonz);
1527 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpcol), (*sdpi)->lpnnonz);
1528 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprow), (*sdpi)->lpnnonz);
1529 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprhs), (*sdpi)->nlpcons);
1530 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lplhs), (*sdpi)->nlpcons);
1533 for (i = 0; i < (*sdpi)->nsdpblocks; i++)
1535 for (j = 0; j < (*sdpi)->sdpnblockvars[i]; j++)
1537 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1538 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1539 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
1541 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i]), (*sdpi)->sdpnblockvars[i]);
1542 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i]), (*sdpi)->sdpnblockvars[i]);
1543 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i]), (*sdpi)->sdpnblockvars[i]);
1544 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar[i]), (*sdpi)->sdpnblockvars[i]);
1545 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz[i]), (*sdpi)->sdpnblockvars[i]);
1546 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval[i]), (*sdpi)->sdpconstnblocknonz[i]);
1547 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow[i]), (*sdpi)->sdpconstnblocknonz[i]);
1548 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol[i]), (*sdpi)->sdpconstnblocknonz[i]);
1552 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz), (*sdpi)->nsdpblocks);
1553 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstnblocknonz), (*sdpi)->nsdpblocks);
1554 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval), (*sdpi)->nsdpblocks);
1555 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol), (*sdpi)->nsdpblocks);
1556 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow), (*sdpi)->nsdpblocks);
1557 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar), (*sdpi)->nsdpblocks);
1558 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval), (*sdpi)->nsdpblocks);
1559 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol), (*sdpi)->nsdpblocks);
1560 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow), (*sdpi)->nsdpblocks);
1561 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvars), (*sdpi)->nsdpblocks);
1562 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpblocksizes), (*sdpi)->nsdpblocks);
1563 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->ub), (*sdpi)->nvars);
1564 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lb), (*sdpi)->nvars);
1565 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->obj), (*sdpi)->nvars);
1570 BMSfreeBlockMemory((*sdpi)->blkmem, sdpi);
1591 assert( oldsdpi != NULL );
1593 SCIPdebugMessage(
"Cloning SDPI %d\n", oldsdpi->sdpid);
1596 blkmem = oldsdpi->blkmem;
1597 nvars = oldsdpi->nvars;
1598 nsdpblocks = oldsdpi->nsdpblocks;
1599 lpnnonz = oldsdpi->lpnnonz;
1601 BMS_CALL( BMSallocBlockMemory(blkmem, &newsdpi) );
1603 SCIP_CALL(
SCIPsdpiSolverCreate(&(newsdpi->sdpisolver), oldsdpi->messagehdlr, oldsdpi->blkmem, oldsdpi->bufmem) );
1605 newsdpi->messagehdlr = oldsdpi->messagehdlr;
1606 newsdpi->blkmem = blkmem;
1607 newsdpi->nvars = nvars;
1609 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->obj), oldsdpi->obj, nvars) );
1610 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lb), oldsdpi->lb, nvars) );
1611 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->ub), oldsdpi->ub, nvars) );
1613 newsdpi->nsdpblocks = nsdpblocks;
1615 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpblocksizes), oldsdpi->sdpblocksizes, nsdpblocks) );
1616 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvars), oldsdpi->sdpnblockvars, nsdpblocks) );
1619 newsdpi->sdpconstnnonz = oldsdpi->sdpconstnnonz;
1621 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstnblocknonz), oldsdpi->sdpconstnblocknonz, nsdpblocks) );
1622 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow), nsdpblocks) );
1623 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol), nsdpblocks) );
1624 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstval), nsdpblocks) );
1626 for (b = 0; b < nsdpblocks; b++)
1628 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow[b]), oldsdpi->sdpconstrow[b], oldsdpi->sdpconstnblocknonz[b]) );
1629 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol[b]), oldsdpi->sdpconstcol[b], oldsdpi->sdpconstnblocknonz[b]) );
1630 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstval[b]), oldsdpi->sdpconstval[b], oldsdpi->sdpconstnblocknonz[b]) );
1634 newsdpi->sdpnnonz = oldsdpi->sdpnnonz;
1636 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz), nsdpblocks) );
1637 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpvar), nsdpblocks) );
1638 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow), nsdpblocks) );
1639 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol), nsdpblocks) );
1640 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval), nsdpblocks) );
1642 for (b = 0; b < nsdpblocks; b++)
1644 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz[b]), oldsdpi->sdpnblockvarnonz[b], oldsdpi->sdpnblockvars[b]) );
1645 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpvar[b]), oldsdpi->sdpvar[b], oldsdpi->sdpnblockvars[b]) );
1647 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow[b]), oldsdpi->sdpnblockvars[b]) );
1648 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b]), oldsdpi->sdpnblockvars[b]) );
1649 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval[b]), oldsdpi->sdpnblockvars[b]) );
1651 for (v = 0; v < oldsdpi->sdpnblockvars[b]; v++)
1653 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdprow[b][v]), oldsdpi->sdprow[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1654 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b][v]), oldsdpi->sdpcol[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1655 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpval[b][v]), oldsdpi->sdpval[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1660 newsdpi->nlpcons = oldsdpi->nlpcons;
1662 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lplhs), oldsdpi->lplhs, oldsdpi->nlpcons) );
1663 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprhs), oldsdpi->lprhs, oldsdpi->nlpcons) );
1665 newsdpi->lpnnonz = lpnnonz;
1667 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprow), oldsdpi->lprow, lpnnonz) );
1668 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpcol), oldsdpi->lpcol, lpnnonz) );
1669 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpval), oldsdpi->lpval, lpnnonz) );
1672 newsdpi->solved = FALSE;
1673 newsdpi->penalty = FALSE;
1674 newsdpi->infeasible = FALSE;
1675 newsdpi->allfixed = FALSE;
1676 newsdpi->sdpid = 1000000 + oldsdpi->sdpid;
1677 newsdpi->epsilon = oldsdpi->epsilon;
1678 newsdpi->gaptol = oldsdpi->gaptol;
1679 newsdpi->feastol = oldsdpi->feastol;
1709 int* sdpconstnblocknonz,
1713 SCIP_Real** sdpconstval,
1715 int** sdpnblockvarnonz,
1723 SCIP_Real*** sdpval,
1738 SCIPdebugMessage(
"Calling SCIPsdpiLoadSDP (%d)\n",sdpi->sdpid);
1740 assert ( sdpi != NULL );
1741 assert ( nvars > 0 );
1742 assert ( obj != NULL );
1743 assert ( lb != NULL );
1744 assert ( ub != NULL );
1747 if (sdpconstnnonz > 0 || sdpnnonz > 0 || nsdpblocks > 0)
1749 assert ( sdpblocksizes != NULL );
1750 assert ( sdpnblockvars != NULL );
1751 assert ( nsdpblocks > 0 );
1752 assert ( sdpconstnblocknonz != NULL );
1753 assert ( sdpnblockvarnonz != NULL );
1755 if (sdpconstnnonz > 0)
1757 assert ( sdpconstrow != NULL );
1758 assert ( sdpconstcol != NULL );
1759 assert ( sdpconstval != NULL );
1761 for (i = 0; i < nsdpblocks; i++)
1763 if (sdpconstnblocknonz[i] > 0)
1765 assert ( sdpconstrow[i] != NULL );
1766 assert ( sdpconstcol[i] != NULL );
1767 assert ( sdpconstval[i] != NULL );
1774 assert ( sdprow != NULL );
1775 assert ( sdpcol != NULL );
1776 assert ( sdpval != NULL );
1778 for ( i = 0; i < nsdpblocks; i++ )
1780 assert ( sdpcol[i] != NULL );
1781 assert ( sdprow[i] != NULL );
1782 assert ( sdpval[i] != NULL );
1784 for ( v = 0; v < sdpnblockvars[i]; v++)
1786 if (sdpnblockvarnonz[i][v] > 0)
1788 assert ( sdpcol[i][v] != NULL );
1789 assert ( sdprow[i][v] != NULL );
1790 assert ( sdpval[i][v] != NULL );
1798 assert ( nlpcons == 0 || lplhs != NULL );
1799 assert ( nlpcons == 0 || lprhs != NULL );
1800 assert ( lpnnonz == 0 || lprow != NULL );
1801 assert ( lpnnonz == 0 || lpcol != NULL );
1802 assert ( lpnnonz == 0 || lpval != NULL );
1807 for (block = sdpi->nsdpblocks - 1; block >= 0; block--)
1809 for (v = sdpi->sdpnblockvars[block] - 1; v >= 0; v--)
1811 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1812 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1813 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1816 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block]), sdpi->sdpnblockvars[block]);
1817 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block]), sdpi->sdpnblockvars[block]);
1818 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpi->sdpnblockvars[block]);
1819 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpi->sdpconstnblocknonz[block]);
1820 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpi->sdpconstnblocknonz[block]);
1821 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpi->sdpconstnblocknonz[block]);
1822 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpi->sdpnblockvars[block]);
1823 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpi->sdpnblockvars[block]);
1826 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->ub), sdpi->nvars);
1827 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lb), sdpi->nvars);
1828 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->obj), sdpi->nvars);
1830 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpblocksizes), sdpi->nsdpblocks);
1831 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvars), sdpi->nsdpblocks);
1832 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpi->nsdpblocks);
1835 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->obj), obj, nvars) );
1836 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->lb), lb, nvars) );
1837 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->ub), ub, nvars) );
1840 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpconstnblocknonz, nsdpblocks);
1843 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpnblockvarnonz), sdpi->nsdpblocks, nsdpblocks) );
1844 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstcol), sdpi->nsdpblocks, nsdpblocks) );
1845 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstrow), sdpi->nsdpblocks, nsdpblocks) );
1846 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstval), sdpi->nsdpblocks, nsdpblocks) );
1847 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpvar), sdpi->nsdpblocks, nsdpblocks) );
1848 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol), sdpi->nsdpblocks, nsdpblocks) );
1849 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow), sdpi->nsdpblocks, nsdpblocks) );
1850 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval), sdpi->nsdpblocks, nsdpblocks) );
1852 for (block = 0; block < nsdpblocks; block++)
1854 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpnblockvarnonz[block], sdpnblockvars[block]);
1856 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpconstcol[block], sdpconstnblocknonz[block]);
1857 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpconstrow[block], sdpconstnblocknonz[block]);
1858 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpconstval[block], sdpconstnblocknonz[block]);
1861 for (i = 0; i < sdpi->sdpconstnblocknonz[block]; ++i)
1864 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpvar[block], sdpnblockvars[block]);
1866 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpnblockvars[block]) );
1867 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow[block]), sdpnblockvars[block]) );
1868 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval[block]), sdpnblockvars[block]) );
1870 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
1872 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpcol[block][v], sdpnblockvarnonz[block][v]);
1873 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdprow[block][v], sdpnblockvarnonz[block][v]);
1874 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpval[block][v], sdpnblockvarnonz[block][v]);
1877 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; ++i)
1883 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1884 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1885 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1886 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1887 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1896 sdpi->nvars = nvars;
1897 sdpi->nsdpblocks = nsdpblocks;
1899 sdpi->sdpconstnnonz = sdpconstnnonz;
1900 sdpi->sdpnnonz = sdpnnonz;
1903 sdpi->lpnnonz = lpnnonz;
1904 sdpi->nlpcons = nlpcons;
1906 sdpi->solved = FALSE;
1907 sdpi->infeasible = FALSE;
1908 sdpi->allfixed = FALSE;
1909 sdpi->nsdpcalls = 0;
1910 sdpi->niterations = 0;
1922 const SCIP_Real* lhs,
1923 const SCIP_Real* rhs,
1928 const SCIP_Real* val
1933 SCIPdebugMessage(
"Adding %d LP-Constraints to SDP %d.\n", nrows, sdpi->sdpid);
1935 assert ( sdpi != NULL );
1940 assert ( lhs != NULL );
1941 assert ( rhs != NULL );
1942 assert ( nnonz >= 0 );
1943 assert ( row != NULL );
1944 assert ( col != NULL );
1945 assert ( val != NULL );
1947 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1948 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1950 for (i = 0; i < nrows; i++)
1952 sdpi->lplhs[sdpi->nlpcons + i] = lhs[i];
1953 sdpi->lprhs[sdpi->nlpcons + i] = rhs[i];
1956 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1957 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1958 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1960 for (i = 0; i < nnonz; i++)
1962 assert ( 0 <= row[i] && row[i] < nrows );
1964 sdpi->lprow[sdpi->lpnnonz + i] = row[i] + sdpi->nlpcons;
1966 assert ( 0 <= col[i] && col[i] < sdpi->nvars );
1967 sdpi->lpcol[sdpi->lpnnonz + i] = col[i];
1969 sdpi->lpval[sdpi->lpnnonz + i] = val[i];
1972 sdpi->nlpcons = sdpi->nlpcons + nrows;
1973 sdpi->lpnnonz = sdpi->lpnnonz + nnonz;
1975 sdpi->solved = FALSE;
1976 sdpi->infeasible = FALSE;
1977 sdpi->nsdpcalls = 0;
1978 sdpi->niterations = 0;
1996 SCIPdebugMessage(
"Deleting rows %d to %d from SDP %d.\n", firstrow, lastrow, sdpi->sdpid);
1998 assert ( sdpi != NULL );
1999 assert ( firstrow >= 0 );
2000 assert ( firstrow <= lastrow );
2001 assert ( lastrow < sdpi->nlpcons );
2004 if (firstrow == 0 && lastrow == sdpi->nlpcons - 1)
2006 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
2007 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
2008 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
2009 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
2010 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
2021 sdpi->solved = FALSE;
2022 sdpi->infeasible = FALSE;
2023 sdpi->allfixed = FALSE;
2024 sdpi->nsdpcalls = 0;
2025 sdpi->niterations = 0;
2030 deletedrows = lastrow - firstrow + 1;
2034 for (i = lastrow + 1; i < sdpi->nlpcons; i++)
2036 sdpi->lplhs[i - deletedrows] = sdpi->lplhs[i];
2037 sdpi->lprhs[i - deletedrows] = sdpi->lprhs[i];
2039 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2040 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
2043 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
2047 for (i = 0; i < sdpi->lpnnonz; i++)
2049 if (sdpi->lprow[i] >= firstrow && sdpi->lprow[i] <= lastrow)
2058 if (firstrowind > -1)
2061 while (i < sdpi->lpnnonz && sdpi->lprow[i] <= lastrow)
2066 deletednonz = lastrowind - firstrowind + 1;
2069 for (i = lastrowind + 1; i < sdpi->lpnnonz; i++)
2071 sdpi->lpcol[i - deletednonz] = sdpi->lpcol[i];
2073 sdpi->lprow[i - deletednonz] = sdpi->lprow[i] - deletedrows;
2074 sdpi->lpval[i - deletednonz] = sdpi->lpval[i];
2078 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2079 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2080 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
2081 sdpi->nlpcons = sdpi->nlpcons - deletedrows;
2082 sdpi->lpnnonz = sdpi->lpnnonz - deletednonz;
2084 sdpi->solved = FALSE;
2085 sdpi->infeasible = FALSE;
2086 sdpi->allfixed = FALSE;
2087 sdpi->nsdpcalls = 0;
2088 sdpi->niterations = 0;
2105 SCIPdebugMessage(
"Calling SCIPsdpiDelLPRowset for SDP %d.\n", sdpi->sdpid);
2107 assert ( sdpi != NULL );
2108 assert ( dstat != NULL );
2110 oldnlpcons = sdpi->nlpcons;
2113 for (i = 0; i < oldnlpcons; i++)
2123 dstat[i] = i - deletedrows;
2126 sdpi->solved = FALSE;
2127 sdpi->infeasible = FALSE;
2128 sdpi->allfixed = FALSE;
2129 sdpi->nsdpcalls = 0;
2130 sdpi->niterations = 0;
2140 assert( sdpi != NULL );
2142 SCIPdebugMessage(
"Called SCIPsdpiClear in SDP %d.\n", sdpi->sdpid);
2156 const SCIP_Real* obj
2161 SCIPdebugMessage(
"Changing %d objective coefficients in SDP %d\n", nvars, sdpi->sdpid);
2163 assert( sdpi != NULL );
2164 assert( ind != NULL );
2165 assert( obj != NULL );
2167 for (i = 0; i < nvars; i++)
2169 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2170 sdpi->obj[ind[i]] = obj[i];
2173 sdpi->solved = FALSE;
2174 sdpi->nsdpcalls = 0;
2175 sdpi->niterations = 0;
2185 const SCIP_Real* lb,
2191 SCIPdebugMessage(
"Changing %d variable bounds in SDP %d\n", nvars, sdpi->sdpid);
2193 assert( sdpi != NULL );
2194 assert( ind != NULL );
2195 assert( lb != NULL );
2196 assert( ub != NULL );
2198 for (i = 0; i < nvars; i++)
2200 assert( 0 <= ind[i] && ind[i] < sdpi->nvars );
2201 sdpi->lb[ind[i]] = lb[i];
2202 sdpi->ub[ind[i]] = ub[i];
2205 sdpi->solved = FALSE;
2206 sdpi->infeasible = FALSE;
2207 sdpi->allfixed = FALSE;
2208 sdpi->nsdpcalls = 0;
2209 sdpi->niterations = 0;
2219 const SCIP_Real* lhs,
2220 const SCIP_Real* rhs
2225 SCIPdebugMessage(
"Changing %d left and right hand sides of SDP %d\n", nrows, sdpi->sdpid);
2227 assert( sdpi != NULL );
2228 assert( 0 <= nrows && nrows <= sdpi->nlpcons );
2229 assert( ind != NULL );
2230 assert( lhs != NULL );
2231 assert( rhs != NULL );
2233 for (i = 0; i < nrows; i++)
2235 assert ( ind[i] >= 0 );
2236 assert ( ind[i] < sdpi->nlpcons );
2237 sdpi->lplhs[ind[i]] = lhs[i];
2238 sdpi->lprhs[ind[i]] = rhs[i];
2241 sdpi->solved = FALSE;
2242 sdpi->infeasible = FALSE;
2243 sdpi->allfixed = FALSE;
2244 sdpi->nsdpcalls = 0;
2245 sdpi->niterations = 0;
2264 assert( sdpi != NULL );
2265 assert( nlprows != NULL );
2267 *nlprows = sdpi->nlpcons;
2278 assert( sdpi != NULL );
2279 assert( nsdpblocks != NULL );
2281 *nsdpblocks = sdpi->nsdpblocks;
2292 assert( sdpi != NULL );
2293 assert( nvars != NULL );
2295 *nvars = sdpi->nvars;
2306 assert( sdpi != NULL );
2307 assert( nnonz != NULL );
2309 *nnonz = sdpi->sdpnnonz;
2320 assert( sdpi != NULL );
2321 assert( nnonz != NULL );
2323 *nnonz = sdpi->sdpconstnnonz;
2334 assert( sdpi != NULL );
2335 assert( nnonz != NULL );
2337 *nnonz = sdpi->lpnnonz;
2352 assert( sdpi != NULL );
2353 assert( firstvar >= 0 );
2354 assert( firstvar <= lastvar );
2355 assert( lastvar < sdpi->nvars);
2356 assert( vals != NULL );
2358 for (i = 0; i < lastvar - firstvar + 1; i++)
2359 vals[i] = sdpi->obj[firstvar + i];
2375 assert( sdpi != NULL );
2376 assert( firstvar >= 0 );
2377 assert( firstvar <= lastvar );
2378 assert( lastvar < sdpi->nvars);
2379 assert( lbs != NULL );
2380 assert( ubs != NULL );
2382 for (i = 0; i < lastvar - firstvar + 1; i++)
2385 lbs[i] = sdpi->lb[firstvar + i];
2387 ubs[i] = sdpi->ub[firstvar + i];
2402 assert( sdpi != NULL );
2403 assert( firstrow >= 0 );
2404 assert( firstrow <= lastrow );
2405 assert( lastrow < sdpi->nlpcons);
2406 assert( lhss != NULL );
2408 for (i = 0; i < lastrow - firstrow + 1; i++)
2409 lhss[firstrow + i] = sdpi->lplhs[i];
2424 assert( sdpi != NULL );
2425 assert( firstrow >= 0 );
2426 assert( firstrow <= lastrow );
2427 assert( lastrow < sdpi->nlpcons);
2428 assert( rhss != NULL );
2430 for (i = 0; i < lastrow - firstrow + 1; i++)
2431 rhss[firstrow + i] = sdpi->lprhs[i];
2456 int* startZnblocknonz,
2462 SCIP_Real** startZval,
2464 int* startXnblocknonz,
2470 SCIP_Real** startXval,
2474 SCIP_Bool enforceslatercheck,
2479 int* sdpconstnblocknonz = NULL;
2480 int** sdpconstrow = NULL;
2481 int** sdpconstcol = NULL;
2482 SCIP_Real** sdpconstval = NULL;
2483 int** indchanges = NULL;
2484 int* nremovedinds = NULL;
2485 SCIP_Real* lplhsafterfix;
2486 SCIP_Real* lprhsafterfix;
2487 SCIP_Real solvertimelimit;
2488 SCIP_Bool fixingfound;
2490 clock_t currenttime;
2491 int* rowsnactivevars;
2492 int* blockindchanges;
2495 int nremovedblocks = 0;
2497 int naddediterations;
2500 assert( sdpi != NULL );
2502 starttime = clock();
2504 SCIPdebugMessage(
"Forwarding SDP %d to solver!\n", sdpi->sdpid);
2506 sdpi->penalty = FALSE;
2508 sdpi->solved = FALSE;
2509 sdpi->nsdpcalls = 0;
2510 sdpi->niterations = 0;
2514 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks) );
2515 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks) );
2516 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks) );
2517 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks) );
2518 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks) );
2519 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks) );
2520 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks) );
2521 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons) );
2522 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons) );
2523 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons) );
2525 for (block = 0; block < sdpi->nsdpblocks; block++)
2527 sdpconstrow[block] = NULL;
2528 sdpconstcol[block] = NULL;
2529 sdpconstval[block] = NULL;
2530 indchanges[block] = NULL;
2531 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]) );
2532 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2533 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2534 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
2541 fixingfound = FALSE;
2544 while ( fixingfound );
2547 for (block = 0; block < sdpi->nsdpblocks; block++)
2548 sdpconstnblocknonz[block] = sdpi->sdpnnonz + sdpi->sdpconstnnonz;
2550 SCIP_CALL(
compConstMatAfterFixings(sdpi, &sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval) );
2553 for (block = 0; block < sdpi->nsdpblocks; block++)
2555 assert ( sdpconstnblocknonz[block] <= sdpi->sdpnnonz + sdpi->sdpconstnnonz );
2557 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2558 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2559 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
2562 SCIP_CALL(
findEmptyRowColsSDP(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges, &nremovedblocks) );
2567 if ( sdpi->allfixed && ! sdpi->infeasible )
2569 SCIP_CALL(
checkFixedFeasibilitySdp(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges) );
2572 if ( sdpi->infeasible )
2574 SCIPdebugMessage(
"SDP %d not given to solver, as infeasibility was detected during presolving!\n", sdpi->sdpid++);
2577 sdpi->solved = TRUE;
2581 else if ( sdpi->allfixed )
2583 SCIPdebugMessage(
"SDP %d not given to solver, as all variables were fixed during presolving (the solution was feasible)!\n", sdpi->sdpid++);
2586 sdpi->solved = TRUE;
2592 if ( sdpi->slatercheck )
2594 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2595 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, FALSE) );
2599 solvertimelimit = timelimit;
2602 currenttime = clock();
2603 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2608 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2609 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2610 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2611 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2612 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2613 startXnblocknonz, startXrow, startXcol, startXval, startsettings, solvertimelimit) );
2615 sdpi->solved = TRUE;
2618 naddediterations = 0;
2620 sdpi->niterations += naddediterations;
2623 sdpi->nsdpcalls += naddedsdpcalls;
2628 SCIP_Real penaltyparam;
2629 SCIP_Real penaltyparamfact;
2631 SCIP_Real gaptolfact;
2633 SCIP_Bool penaltybound;
2638 penaltybound = TRUE;
2643 solvertimelimit = timelimit;
2646 currenttime = clock();
2647 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2653 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2654 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2655 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2656 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2657 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2661 naddediterations = 0;
2663 sdpi->niterations += naddediterations;
2666 sdpi->nsdpcalls += naddedsdpcalls;
2682 sdpi->peninfeasadjust * sdpi->feastol : sdpi->peninfeasadjust * sdpi->gaptol))) ||
2685 SCIPdebugMessage(
"SDP %d found infeasible using penalty formulation, maximum of smallest eigenvalue is %f.\n", sdpi->sdpid, -1.0 * objval);
2686 sdpi->penalty = TRUE;
2687 sdpi->infeasible = TRUE;
2692 penaltybound = TRUE;
2694 penaltyparam = sdpi->penaltyparam;
2699 penaltyparamfact = sdpi->npenaltyincr > 0 ? pow((sdpi->maxpenaltyparam / sdpi->penaltyparam), 1.0/sdpi->npenaltyincr) :
2700 2*sdpi->maxpenaltyparam / sdpi->penaltyparam;
2701 gaptol = sdpi->gaptol;
2702 gaptolfact = sdpi->npenaltyincr > 0 ? pow((
MIN_GAPTOL / sdpi->gaptol), 1.0/sdpi->npenaltyincr) : 0.5 *
MIN_GAPTOL / sdpi->gaptol;
2708 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penaltyparameter %f\n", sdpi->sdpid, penaltyparam);
2711 solvertimelimit = timelimit;
2714 currenttime = clock();
2715 solvertimelimit -= (SCIP_Real)(currenttime - starttime) / (SCIP_Real) CLOCKS_PER_SEC;
2717 if ( solvertimelimit <= 0 )
2722 sdpi->lb, sdpi->ub, sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
2723 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
2724 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
2725 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
2726 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, starty, startZnblocknonz, startZrow, startZcol, startZval,
2727 startXnblocknonz, startXrow, startXcol, startXval, startsettings, solvertimelimit, &feasorig, &penaltybound) );
2730 naddediterations = 0;
2732 sdpi->niterations += naddediterations;
2735 sdpi->nsdpcalls += naddedsdpcalls;
2740 penaltyparam *= penaltyparamfact;
2741 SCIPdebugMessage(
"Solver did not converge even with penalty formulation, increasing penaltyparameter.\n");
2747 if ( objbound > sdpi->bestbound + sdpi->gaptol )
2748 sdpi->bestbound = objbound;
2756 penaltyparam *= penaltyparamfact;
2757 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, increasing penaltyparameter\n");
2761 gaptol *= gaptolfact;
2763 SCIPdebugMessage(
"Penalty formulation produced a result which is infeasible for the original problem, even though primal penalty "
2764 "bound was not reached, decreasing tolerance for duality gap in SDP-solver\n");
2770 if ( gaptol > sdpi->gaptol )
2778 sdpi->penalty = TRUE;
2779 sdpi->solved = TRUE;
2784 SCIPdebugMessage(
"Problem was found to be infeasible using a penalty formulation \n");
2785 sdpi->infeasible = TRUE;
2786 sdpi->penalty = TRUE;
2787 sdpi->solved = TRUE;
2792 SCIPdebugMessage(
"SDP-Solver could not solve the problem even after using a penalty formulation \n");
2793 sdpi->solved = FALSE;
2794 sdpi->penalty = TRUE;
2798 if ( sdpi->solved == FALSE && enforceslatercheck)
2800 SCIP_CALL(
checkSlaterCondition(sdpi, timelimit, starttime, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges,
2801 nremovedinds, lplhsafterfix, lprhsafterfix, rowsnactivevars, blockindchanges, sdpconstnnonz, nactivelpcons, nremovedblocks, TRUE) );
2803 else if ( sdpi->solved == FALSE )
2806 SCIPmessagePrintInfo(sdpi->messagehdlr,
"Numerical trouble\n");
2808 SCIPdebugMessage(
"SDP-Interface was unable to solve SDP %d\n", sdpi->sdpid);
2816 for (block = 0; block < sdpi->nsdpblocks; block++)
2818 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpconstnblocknonz[block]);
2819 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpconstnblocknonz[block]);
2820 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpconstnblocknonz[block]);
2821 BMSfreeBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]);
2823 BMSfreeBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons);
2824 BMSfreeBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons);
2825 BMSfreeBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons);
2826 BMSfreeBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks);
2827 BMSfreeBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks);
2828 BMSfreeBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks);
2829 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks);
2830 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks);
2831 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks);
2832 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks);
2854 assert( sdpi != NULL );
2864 assert( sdpi != NULL );
2876 assert( sdpi != NULL );
2879 if ( sdpi->infeasible || sdpi->allfixed )
2888 SCIP_Bool* primalfeasible,
2889 SCIP_Bool* dualfeasible
2892 assert( sdpi != NULL );
2895 if ( sdpi->infeasible )
2897 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2898 *dualfeasible = FALSE;
2901 else if ( sdpi->allfixed )
2903 SCIPdebugMessage(
"All variables were fixed during preprocessing, dual problem is feasible, primal feasibility not available\n");
2904 *dualfeasible = TRUE;
2919 assert( sdpi != NULL );
2922 if ( sdpi->infeasible )
2924 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal unboundedness not available\n");
2927 else if ( sdpi->allfixed )
2929 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal unboundedness not available\n");
2942 assert( sdpi != NULL );
2945 if ( sdpi->infeasible )
2947 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2950 else if ( sdpi->allfixed )
2952 SCIPdebugMessage(
"All variables were fixed during preprocessing, primal feasibility not available\n");
2965 assert(sdpi != NULL );
2968 if ( sdpi->infeasible )
2970 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2973 else if ( sdpi->allfixed )
2975 SCIPdebugMessage(
"All variables fixed during preprocessing, primal feasibility not available\n");
2988 assert( sdpi != NULL );
2991 if ( sdpi->infeasible )
2993 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore is not unbounded\n");
2996 else if ( sdpi->allfixed )
2998 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore the problem is not unbounded\n");
3011 assert( sdpi != NULL );
3014 if ( sdpi->infeasible )
3016 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3019 else if ( sdpi->allfixed )
3021 SCIPdebugMessage(
"All variables were fixed during preprocessing, solution is feasible\n");
3034 assert( sdpi != NULL );
3037 if ( sdpi->infeasible )
3039 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
3042 else if ( sdpi->allfixed )
3044 SCIPdebugMessage(
"All variables fixed during preprocessing, solution is feasible\n");
3056 assert( sdpi != NULL );
3059 if ( sdpi->infeasible )
3061 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this counts as converged.\n");
3064 else if ( sdpi->allfixed )
3066 SCIPdebugMessage(
"All variables were fixed during preprocessing, this counts as converged.\n");
3078 assert( sdpi != NULL );
3081 if ( sdpi->infeasible )
3083 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective limit available.\n");
3086 else if ( sdpi->allfixed )
3088 SCIPdebugMessage(
"All variables were fixed during preprocessing, no objective limit available.\n");
3100 assert( sdpi != NULL );
3103 if ( sdpi->infeasible )
3105 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iteration limit available.\n");
3108 else if ( sdpi->allfixed )
3110 SCIPdebugMessage(
"All variables were fixed during preprocessing, no iteration limit available.\n");
3122 assert( sdpi != NULL );
3124 if ( sdpi->infeasible )
3126 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no time limit available.\n");
3129 else if ( sdpi->allfixed )
3131 SCIPdebugMessage(
"All variables were fixed during preprocessing, no time limit available.\n");
3134 else if ( ! sdpi->solved )
3136 SCIPdebugMessage(
"Problem was not solved, time limit not exceeded.\n");
3157 assert( sdpi != NULL );
3159 if ( ! sdpi->solved )
3161 SCIPdebugMessage(
"Problem wasn't solved yet.\n");
3164 else if ( sdpi->infeasible )
3166 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no internal status available.\n");
3169 else if ( sdpi->allfixed )
3171 SCIPdebugMessage(
"All variables were fixed during preprocessing, no internal status available.\n");
3183 assert( sdpi != NULL );
3186 if ( sdpi->infeasible )
3188 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore there is no optimal solution.\n");
3191 else if ( sdpi->allfixed )
3193 SCIPdebugMessage(
"All variables were fixed during preprocessing, therefore there is no optimal solution.\n");
3206 assert( sdpi != NULL );
3208 if ( sdpi->infeasible )
3210 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this is acceptable in a B&B context.\n");
3213 else if ( sdpi->allfixed )
3215 SCIPdebugMessage(
"All variables fixed during preprocessing, this is acceptable in a B&B context.\n");
3218 else if ( ! sdpi->solved )
3220 SCIPdebugMessage(
"Problem not solved succesfully, this is not acceptable in a B&B context.\n");
3233 assert( sdpi != NULL );
3234 assert( objval != NULL );
3237 if ( sdpi->infeasible )
3239 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3243 if ( sdpi->allfixed )
3250 for (v = 0; v < sdpi->nvars; v++)
3251 *objval += sdpi->lb[v] * sdpi->obj[v];
3268 assert( sdpi != NULL );
3269 assert( objlb != NULL );
3274 if ( sdpi->infeasible )
3276 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
3280 if ( sdpi->allfixed )
3287 for (v = 0; v < sdpi->nvars; v++)
3288 *objlb += sdpi->lb[v] * sdpi->obj[v];
3298 if ( sdpi->penalty )
3300 *objlb = sdpi->bestbound;
3320 assert( sdpi != NULL );
3321 assert( dualsollength != NULL );
3322 assert( *dualsollength == 0 || dualsol != NULL );
3325 if ( sdpi->infeasible )
3327 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no solution available.\n");
3330 else if ( sdpi->allfixed )
3332 if ( objval != NULL )
3336 if ( *dualsollength > 0 )
3340 assert( dualsol != NULL );
3341 if ( *dualsollength < sdpi->nvars )
3343 SCIPdebugMessage(
"The given array in SCIPsdpiGetSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3344 *dualsollength = sdpi->nvars;
3350 for (v = 0; v < sdpi->nvars; v++)
3351 dualsol[v] = sdpi->lb[v];
3366 int* startXnblocknonz
3370 assert( sdpi != NULL );
3371 assert( nblocks >= 0 );
3372 assert( startXnblocknonz != NULL );
3374 if ( sdpi->infeasible )
3376 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no preoptimal solution available.\n");
3377 startXnblocknonz[0] = -1;
3381 else if ( sdpi->allfixed )
3383 SCIPdebugMessage(
"No primal solution available, as problem was solved during preprocessing\n");
3384 startXnblocknonz[0] = -1;
3408 int* startXnblocknonz,
3412 SCIP_Real** startXval
3415 assert( sdpi != NULL );
3416 assert( success != NULL );
3417 assert( dualsol != NULL );
3418 assert( dualsollength != NULL );
3419 assert( *dualsollength >= 0 );
3420 assert( startXnblocknonz != NULL || nblocks == -1 );
3421 assert( startXrow != NULL || nblocks == -1 );
3422 assert( startXcol != NULL || nblocks == -1 );
3423 assert( startXval != NULL || nblocks == -1 );
3425 if ( sdpi->infeasible )
3428 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no preoptimal solution available.\n");
3429 startXnblocknonz[0] = -1;
3433 else if ( sdpi->allfixed )
3437 assert( dualsol != NULL );
3441 if ( *dualsollength < sdpi->nvars )
3443 SCIPdebugMessage(
"The given array in SCIPsdpiGetPreoptimalSol only had length %d, but %d was needed", *dualsollength, sdpi->nvars);
3444 *dualsollength = sdpi->nvars;
3450 for (v = 0; v < sdpi->nvars; v++)
3451 dualsol[v] = sdpi->lb[v];
3455 SCIPdebugMessage(
"No primal solution available, as problem was solved during preprocessing\n");
3456 startXnblocknonz[0] = -1;
3463 startXrow, startXcol, startXval) );
3480 assert( sdpi != NULL );
3481 assert( lbvars != NULL );
3482 assert( ubvars != NULL );
3483 assert( arraylength != NULL );
3484 assert( *arraylength >= 0 );
3487 if ( sdpi->infeasible )
3489 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal variables available.\n");
3492 else if ( sdpi->allfixed )
3494 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal variables available.\n");
3507 int* startXnblocknonz
3510 assert( sdpi != NULL );
3512 if ( sdpi->infeasible )
3514 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal solution available.\n");
3517 else if ( sdpi->allfixed )
3519 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal solution available.\n");
3535 int* startXnblocknonz,
3539 SCIP_Real** startXval
3542 assert( sdpi != NULL );
3544 if ( sdpi->infeasible )
3546 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal solution available.\n");
3549 else if ( sdpi->allfixed )
3551 SCIPdebugMessage(
"All variables fixed during preprocessing, no primal solution available.\n");
3565 assert( sdpi != NULL );
3576 assert( sdpi != NULL );
3577 assert( iterations != NULL );
3579 *iterations = sdpi->niterations;
3590 assert( sdpi != NULL );
3591 assert( calls != NULL );
3593 *calls = sdpi->nsdpcalls;
3604 assert( sdpi != NULL );
3605 assert( usedsetting != NULL );
3607 if ( ! sdpi->solved )
3609 SCIPdebugMessage(
"Problem was not solved successfully.\n");
3613 else if ( sdpi->infeasible && ! sdpi->penalty )
3615 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3619 else if ( sdpi->allfixed )
3621 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3625 else if ( sdpi->penalty )
3643 assert( sdpi != NULL );
3644 assert( slatersetting != NULL );
3646 if ( ! sdpi->solved )
3648 SCIPdebugMessage(
"Problem was not solved successfully");
3651 SCIPdebugMessage(
", but we could at least compute a lower bound. \n");
3656 switch( sdpi->primalslater )
3668 switch( sdpi->dualslater )
3692 SCIPdebugMessage(
".\n");
3697 switch( sdpi->primalslater )
3709 switch( sdpi->dualslater )
3733 else if ( sdpi->infeasible && ( ! sdpi->penalty ) )
3735 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no settings used.\n");
3739 else if ( sdpi->allfixed )
3741 SCIPdebugMessage(
"All varialbes fixed during preprocessing, no settings used.\n");
3745 else if ( sdpi->penalty )
3747 switch( sdpi->primalslater )
3764 switch( sdpi->dualslater )
3790 switch( sdpi->primalslater )
3797 switch( usedsetting )
3815 switch( usedsetting )
3837 switch( usedsetting )
3855 switch( usedsetting )
3871 switch( sdpi->dualslater )
3879 switch( usedsetting )
3896 switch( usedsetting )
3913 switch( usedsetting )
3947 assert( sdpi != NULL );
3948 assert( primalslater != NULL );
3949 assert( dualslater != NULL );
3952 if ( sdpi->infeasible )
3955 *dualslater = sdpi->dualslater;
3959 if (sdpi->allfixed )
3966 *primalslater = sdpi->primalslater;
3967 *dualslater = sdpi->dualslater;
3989 assert( sdpi != NULL );
4000 assert( sdpi != NULL );
4012 assert( sdpi != NULL );
4013 assert( sdpi->sdpisolver != NULL );
4014 assert( dval != NULL );
4019 *dval = sdpi->epsilon;
4022 *dval = sdpi->gaptol;
4025 *dval = sdpi->feastol;
4034 *dval = sdpi->penaltyparam;
4037 *dval = sdpi->maxpenaltyparam;
4046 *dval = sdpi->peninfeasadjust;
4049 return SCIP_PARAMETERUNKNOWN;
4062 assert( sdpi != NULL );
4067 sdpi->epsilon = dval;
4071 sdpi->gaptol = dval;
4075 sdpi->feastol = dval;
4085 sdpi->penaltyparam = dval;
4089 sdpi->maxpenaltyparam = dval;
4098 sdpi->peninfeasadjust = dval;
4101 return SCIP_PARAMETERUNKNOWN;
4114 assert( sdpi != NULL );
4115 assert( sdpi->sdpisolver != NULL );
4116 assert( ival != NULL );
4125 *ival = sdpi->slatercheck;
4128 *ival = sdpi->npenaltyincr;
4131 return SCIP_PARAMETERUNKNOWN;
4144 assert( sdpi != NULL );
4145 assert( sdpi->sdpisolver != NULL );
4150 assert( ival == 0 || ival == 1 );
4157 sdpi->slatercheck = ival;
4160 sdpi->npenaltyincr = ival;
4163 return SCIP_PARAMETERUNKNOWN;
4182 SCIP_Real* penaltyparam
4187 sdpi->penaltyparam = *penaltyparam;
4195 SCIP_Real penaltyparam,
4196 SCIP_Real* maxpenaltyparam
4201 sdpi->maxpenaltyparam = *maxpenaltyparam;
4205 if ( sdpi->penaltyparam > *maxpenaltyparam )
4207 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpi->penaltyparam, *maxpenaltyparam);
4208 sdpi->penaltyparam = *maxpenaltyparam;
4232 SCIPdebugMessage(
"Not implemented yet\n");
4233 return SCIP_LPERROR;
4242 SCIPdebugMessage(
"Not implemented yet\n");
4243 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)