47 #include "blockmemshell/memory.h"
49 #include "scip/pub_misc.h"
53 #define BMS_CALL(x) do \
57 SCIPerrorMessage("No memory in function call\n"); \
58 return SCIP_NOMEMORY; \
64 #define CHECK_IF_SOLVED(sdpi) do \
66 if ( ! (sdpi->solved) ) \
68 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \
69 return SCIP_LPERROR; \
75 #define CHECK_IF_SOLVED_BOOL(sdpi) do \
77 if ( ! (sdpi->solved) ) \
79 SCIPerrorMessage("Tried to access solution information ahead of solving! \n"); \
86 #define DUPLICATE_ARRAY_NULL(blkmem, target, source, size) do \
89 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, target, source, size) ); \
96 #define SCIP_CALL_PARAM(x) do \
98 SCIP_RETCODE _restat_; \
99 if ( (_restat_ = (x)) != SCIP_OKAY ) \
101 if ( _restat_ != SCIP_PARAMETERUNKNOWN ) \
103 SCIPerrorMessage("Error <%d> in function call\n", _restat_); \
115 SCIP_MESSAGEHDLR* messagehdlr;
127 int* sdpconstnblocknonz;
131 SCIP_Real** sdpconstval;
135 int** sdpnblockvarnonz;
154 SCIP_Bool slatercheck;
157 SCIP_Bool infeasible;
197 assert ( sdpi != NULL );
198 assert ( v < sdpi->nvars );
199 assert ( sdpi->lb != NULL );
200 assert ( sdpi->ub != NULL );
205 assert( lb < ub + sdpi->feastol || sdpi->infeasible );
207 return ( REALABS(ub-lb) <= sdpi->feastol );
210 #define isFixed(sdpi, v) (REALABS(sdpi->ub[v] - sdpi->lb[v]) <= sdpi->epsilon)
224 int* sdpconstnblocknonz,
228 SCIP_Real** sdpconstval
237 SCIP_Real** fixedvals;
239 assert ( sdpi != NULL );
240 assert ( sdpconstnnonz != NULL );
241 assert ( sdpconstnblocknonz != NULL );
242 assert ( sdpconstrow != NULL );
243 assert ( sdpconstcol != NULL );
244 assert ( sdpconstval != NULL );
246 for (block = 0; block < sdpi->nsdpblocks; block++)
248 assert ( sdpconstrow[block] != NULL );
249 assert ( sdpconstcol[block] != NULL );
250 assert ( sdpconstval[block] != NULL );
259 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks) );
260 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks) );
261 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks) );
262 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks) );
264 for (block = 0; block < sdpi->nsdpblocks; block++)
267 nfixednonz[block] = 0;
268 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
270 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
271 nfixednonz[block] += sdpi->sdpnblockvarnonz[block][v];
274 fixedrows[block] = NULL;
275 fixedcols[block] = NULL;
276 fixedvals[block] = NULL;
278 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]) );
279 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]) );
280 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]) );
283 nfixednonz[block] = 0;
287 for (block = 0; block < sdpi->nsdpblocks; block++)
289 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
291 if (
isFixed(sdpi, sdpi->sdpvar[block][v]))
293 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
295 fixedrows[block][nfixednonz[block]] = sdpi->sdprow[block][v][i];
296 fixedcols[block][nfixednonz[block]] = sdpi->sdpcol[block][v][i];
299 fixedvals[block][nfixednonz[block]] = - sdpi->sdpval[block][v][i] * sdpi->lb[sdpi->sdpvar[block][v]];
308 for (block = 0; block < sdpi->nsdpblocks; block++)
311 sdpi->sdpconstnblocknonz[block], fixedrows[block], fixedcols[block], fixedvals[block], nfixednonz[block],
312 sdpconstrow[block], sdpconstcol[block], sdpconstval[block], &sdpconstnblocknonz[block]) );
313 *sdpconstnnonz += sdpconstnblocknonz[block];
317 for (block = 0; block < sdpi->nsdpblocks; block++)
319 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedvals[block]), nfixednonz[block]);
320 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedcols[block]), nfixednonz[block]);
321 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(fixedrows[block]), nfixednonz[block]);
323 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedvals, sdpi->nsdpblocks);
324 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedcols, sdpi->nsdpblocks);
325 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &fixedrows, sdpi->nsdpblocks);
326 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &nfixednonz, sdpi->nsdpblocks);
337 int* sdpconstnblocknonz,
341 SCIP_Real** sdpconstval,
347 int* blockindchanges,
356 assert( sdpi != NULL );
357 assert( sdpconstnblocknonz != NULL );
358 assert( sdpconstrow != NULL );
359 assert( sdpconstcol != NULL );
360 assert( sdpconstval != NULL );
361 assert( indchanges != NULL );
362 assert( nremovedinds != NULL );
363 assert( blockindchanges != NULL );
364 assert( nremovedblocks != NULL );
367 for (block = 0; block < sdpi->nsdpblocks; block++)
369 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
370 indchanges[block][i] = -1;
376 for (block = 0; block < sdpi->nsdpblocks; block++)
380 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
382 if ( ! (
isFixed(sdpi, sdpi->sdpvar[block][v])) )
384 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; i++)
386 assert ( REALABS(sdpi->sdpval[block][v][i]) > sdpi->epsilon);
387 if ( indchanges[block][sdpi->sdprow[block][v][i]] == -1 )
389 indchanges[block][sdpi->sdprow[block][v][i]] = 1;
392 if ( indchanges[block][sdpi->sdpcol[block][v][i]] == -1 )
394 indchanges[block][sdpi->sdpcol[block][v][i]] = 1;
397 if ( nfoundinds == sdpi->sdpblocksizes[block] )
401 if (nfoundinds == sdpi->sdpblocksizes[block])
405 if ( nfoundinds < sdpi->sdpblocksizes[block] )
408 for (i = 0; i < sdpconstnblocknonz[block]; i++)
410 assert ( REALABS(sdpconstval[block][i]) > sdpi->epsilon);
411 if ( indchanges[block][sdpconstrow[block][i]] == -1 )
413 indchanges[block][sdpconstrow[block][i]] = 1;
416 if ( indchanges[block][sdpconstcol[block][i]] == -1 )
418 indchanges[block][sdpconstcol[block][i]] = 1;
421 if ( nfoundinds == sdpi->sdpblocksizes[block] )
427 nremovedinds[block] = 0;
428 for (i = 0; i < sdpi->sdpblocksizes[block]; i++)
430 if ( indchanges[block][i] == -1 )
432 SCIPdebugMessage(
"empty row and col %d were removed from block %d of SDP %d\n", i, block, sdpi->sdpid);
434 nremovedinds[block]++;
439 indchanges[block][i] = nremovedinds[block];
444 if ( nremovedinds[block] == sdpi->sdpblocksizes[block] )
446 SCIPdebugMessage(
"empty block %d detected in SDP %d, this will be removed", block, sdpi->sdpid);
447 blockindchanges[block] = -1;
451 blockindchanges[block] = *nremovedblocks;
465 SCIP_Real* lplhsafterfix,
469 SCIP_Real* lprhsafterfix,
474 SCIP_Bool* fixingsfound
484 assert( sdpi != NULL );
485 assert( nactivelpcons != NULL );
486 assert( sdpi->nlpcons == 0 || lplhsafterfix != NULL );
487 assert( sdpi->nlpcons == 0 || lprhsafterfix != NULL );
488 assert( sdpi->nlpcons == 0 || rownactivevars != NULL );
489 assert( sdpi->nlpcons == 0 || fixingsfound != NULL );
492 if ( sdpi->nlpcons == 0 || sdpi->lpnnonz == 0 )
499 for (c = 0; c < sdpi->nlpcons; c++)
500 rownactivevars[c] = 0;
505 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
508 for (i = 0; i < sdpi->lpnnonz; i++)
510 assert( i == 0 || sdpi->lprow[i-1] <= sdpi->lprow[i] );
513 if ( sdpi->lprow[i] > lastrow )
516 if ( lastrow >= 0 && rownactivevars[lastrow] > 1 )
518 else if ( lastrow >= 0 && rownactivevars[lastrow] == 1 )
520 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
522 nonzcol = sdpi->lpcol[nonzind];
523 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
525 nonzval = sdpi->lpval[nonzind];
526 assert( REALABS(nonzval) > sdpi->feastol );
533 ((lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
536 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
537 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
538 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
541 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
543 *fixingsfound = TRUE;
544 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
545 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
548 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
550 sdpi->infeasible = TRUE;
551 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
552 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
558 ((lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->feastol) )
561 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
562 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
563 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
566 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
568 *fixingsfound = TRUE;
569 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
570 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
573 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
575 sdpi->infeasible = TRUE;
576 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
577 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
586 ((lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->feastol) )
589 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
590 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
591 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
594 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
596 *fixingsfound = TRUE;
597 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
598 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
601 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
603 sdpi->infeasible = TRUE;
604 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
605 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
611 ((lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
614 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
615 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
616 sdpi->ub[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
619 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
621 *fixingsfound = TRUE;
622 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
623 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
626 if (sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol)
628 sdpi->infeasible = TRUE;
629 SCIPdebugMessage(
"We found an upper bound %f that is lower than the lower bound %f for variable %d, so the problem is infeasible !\n",
630 sdpi->ub[nonzcol], sdpi->lb[nonzcol], nonzcol);
636 else if ( lastrow >= 0 )
638 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
640 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
642 sdpi->infeasible = TRUE;
643 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
644 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
650 lastrow = sdpi->lprow[i];
653 lplhsafterfix[*nactivelpcons] = sdpi->lplhs[lastrow];
654 lprhsafterfix[*nactivelpcons] = sdpi->lprhs[lastrow];
658 if ( !
isFixed(sdpi, sdpi->lpcol[i]) )
660 rownactivevars[lastrow]++;
666 lplhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
667 lprhsafterfix[*nactivelpcons] -= sdpi->lpval[i] * sdpi->lb[sdpi->lpcol[i]];
671 if ( rownactivevars[lastrow] > 1 )
673 else if ( rownactivevars[lastrow] == 1 )
675 assert( 0 <= nonzind && nonzind < sdpi->lpnnonz );
677 nonzcol = sdpi->lpcol[nonzind];
678 assert( 0 <= nonzcol && nonzcol < sdpi->nvars );
680 nonzval = sdpi->lpval[nonzind];
681 assert( REALABS(nonzval) > sdpi->epsilon );
688 ((lplhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
691 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
692 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
693 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
696 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
698 *fixingsfound = TRUE;
699 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
700 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
703 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
705 sdpi->infeasible = TRUE;
706 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
712 ((lprhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] - sdpi->feastol) )
715 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
716 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
717 sdpi->lb[nonzcol] = lprhsafterfix[*nactivelpcons] / nonzval;
720 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
722 *fixingsfound = TRUE;
723 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
724 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
727 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
729 sdpi->infeasible = TRUE;
730 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
739 ((lplhsafterfix[*nactivelpcons] / nonzval) > sdpi->lb[nonzcol] + sdpi->feastol) )
742 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, lower bound of variable %d has been sharpened to %f "
743 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lplhsafterfix[*nactivelpcons] / nonzval, sdpi->lb[nonzcol]);
744 sdpi->lb[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
747 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
749 *fixingsfound = TRUE;
750 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
751 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
754 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
756 sdpi->infeasible = TRUE;
757 SCIPdebugMessage(
"We found a lower bound that is bigger than the upper bound, so the problem is infeasible !\n");
763 ((lprhsafterfix[*nactivelpcons] / nonzval) < sdpi->ub[nonzcol] - sdpi->feastol) )
766 SCIPdebugMessage(
"empty LP-row %d has been removed from SDP %d, upper bound of variable %d has been sharpened to %f "
767 "(originally %f)\n", lastrow, sdpi->sdpid, nonzcol, lprhsafterfix[*nactivelpcons] / nonzval, sdpi->ub[nonzcol]);
768 sdpi->ub[nonzcol] = lplhsafterfix[*nactivelpcons] / nonzval;
771 if ( REALABS(sdpi->lb[nonzcol] - sdpi->ub[nonzcol]) < sdpi->feastol )
773 *fixingsfound = TRUE;
774 SCIPdebugMessage(
"computeLpLhsRhsAfterFixings fixed variable %d to value %f in SDP %d\n",
775 nonzcol, sdpi->lb[nonzcol], sdpi->sdpid);
778 if ( sdpi->ub[nonzcol] < sdpi->lb[nonzcol] - sdpi->feastol )
780 sdpi->infeasible = TRUE;
781 SCIPdebugMessage(
"We found an upper bound that is lower than the lower bound, so the problem is infeasible !\n");
789 assert( lastrow == -1 || rownactivevars[lastrow] == 0 );
791 if ( lplhsafterfix[*nactivelpcons] > sdpi->feastol || lprhsafterfix[*nactivelpcons] < -sdpi->feastol )
793 sdpi->infeasible = TRUE;
794 SCIPdebugMessage(
"We found a constraint which with given fixings reads %f <= 0 <= %f, so the current problem is infeasible !\n",
795 lplhsafterfix[*nactivelpcons], lprhsafterfix[*nactivelpcons] );
854 SCIP_MESSAGEHDLR* messagehdlr,
858 assert ( sdpi != NULL );
859 assert ( blkmem != NULL );
861 SCIPdebugMessage(
"Calling SCIPsdpiCreate\n");
863 BMS_CALL(BMSallocBlockMemory(blkmem, sdpi));
867 (*sdpi)->messagehdlr = messagehdlr;
868 (*sdpi)->blkmem = blkmem;
871 (*sdpi)->nsdpblocks = 0;
872 (*sdpi)->sdpconstnnonz = 0;
873 (*sdpi)->sdpnnonz = 0;
874 (*sdpi)->nlpcons = 0;
875 (*sdpi)->lpnnonz = 0;
876 (*sdpi)->slatercheck = FALSE;
877 (*sdpi)->solved = FALSE;
878 (*sdpi)->penalty = FALSE;
879 (*sdpi)->infeasible = FALSE;
884 (*sdpi)->sdpblocksizes = NULL;
885 (*sdpi)->sdpnblockvars = NULL;
886 (*sdpi)->sdpconstnblocknonz = NULL;
887 (*sdpi)->sdpconstrow = NULL;
888 (*sdpi)->sdpconstcol = NULL;
889 (*sdpi)->sdpconstval = NULL;
890 (*sdpi)->sdpnblockvarnonz = NULL;
891 (*sdpi)->sdpvar = NULL;
892 (*sdpi)->sdprow = NULL;
893 (*sdpi)->sdpcol = NULL;
894 (*sdpi)->sdpval = NULL;
895 (*sdpi)->lplhs = NULL;
896 (*sdpi)->lprhs = NULL;
897 (*sdpi)->lprow = NULL;
898 (*sdpi)->lpcol = NULL;
899 (*sdpi)->lpval = NULL;
901 (*sdpi)->epsilon = 1e-5;
902 (*sdpi)->feastol = 1e-4;
915 SCIPdebugMessage(
"Calling SCIPsdpiFree \n");
916 assert ( sdpi != NULL );
917 assert ( *sdpi != NULL );
920 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpval), (*sdpi)->lpnnonz);
921 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lpcol), (*sdpi)->lpnnonz);
922 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprow), (*sdpi)->lpnnonz);
923 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lprhs), (*sdpi)->nlpcons);
924 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->lplhs), (*sdpi)->nlpcons);
927 for (i = 0; i < (*sdpi)->nsdpblocks; i++)
929 for (j = 0; j < (*sdpi)->sdpnblockvars[i]; j++)
931 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
932 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
933 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i][j]), (*sdpi)->sdpnblockvarnonz[i][j]);
935 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval[i]), (*sdpi)->sdpnblockvars[i]);
936 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow[i]), (*sdpi)->sdpnblockvars[i]);
937 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol[i]), (*sdpi)->sdpnblockvars[i]);
938 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar[i]), (*sdpi)->sdpnblockvars[i]);
939 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz[i]), (*sdpi)->sdpnblockvars[i]);
940 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval[i]), (*sdpi)->sdpconstnblocknonz[i]);
941 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow[i]), (*sdpi)->sdpconstnblocknonz[i]);
942 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol[i]), (*sdpi)->sdpconstnblocknonz[i]);
946 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvarnonz), (*sdpi)->nsdpblocks);
947 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstnblocknonz), (*sdpi)->nsdpblocks);
948 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpval), (*sdpi)->nsdpblocks);
949 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpcol), (*sdpi)->nsdpblocks);
950 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdprow), (*sdpi)->nsdpblocks);
951 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpvar), (*sdpi)->nsdpblocks);
952 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstval), (*sdpi)->nsdpblocks);
953 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstcol), (*sdpi)->nsdpblocks);
954 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpconstrow), (*sdpi)->nsdpblocks);
955 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpnblockvars), (*sdpi)->nsdpblocks);
956 BMSfreeBlockMemoryArrayNull((*sdpi)->blkmem, &((*sdpi)->sdpblocksizes), (*sdpi)->nsdpblocks);
957 BMSfreeBlockMemoryArray((*sdpi)->blkmem, &((*sdpi)->ub), (*sdpi)->nvars);
958 BMSfreeBlockMemoryArray((*sdpi)->blkmem, &((*sdpi)->lb), (*sdpi)->nvars);
959 BMSfreeBlockMemoryArray((*sdpi)->blkmem, &((*sdpi)->obj), (*sdpi)->nvars);
964 BMSfreeBlockMemory((*sdpi)->blkmem, sdpi);
983 assert( oldsdpi != NULL );
985 SCIPdebugMessage(
"Cloning SDPI %d\n", oldsdpi->sdpid);
988 blkmem = oldsdpi->blkmem;
989 nvars = oldsdpi->nvars;
990 nsdpblocks = oldsdpi->nsdpblocks;
991 lpnnonz = oldsdpi->lpnnonz;
993 BMS_CALL( BMSallocBlockMemory(blkmem, &newsdpi) );
995 SCIP_CALL(
SCIPsdpiSolverCreate(&(newsdpi->sdpisolver), oldsdpi->messagehdlr, oldsdpi->blkmem) );
997 newsdpi->messagehdlr = oldsdpi->messagehdlr;
998 newsdpi->blkmem = blkmem;
999 newsdpi->nvars = nvars;
1001 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->obj), oldsdpi->obj, nvars) );
1002 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lb), oldsdpi->lb, nvars) );
1003 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->ub), oldsdpi->ub, nvars) );
1005 newsdpi->nsdpblocks = nsdpblocks;
1007 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpblocksizes), oldsdpi->sdpblocksizes, nsdpblocks) );
1008 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvars), oldsdpi->sdpnblockvars, nsdpblocks) );
1011 newsdpi->sdpconstnnonz = oldsdpi->sdpconstnnonz;
1013 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstnblocknonz), oldsdpi->sdpconstnblocknonz, nsdpblocks) );
1014 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow), nsdpblocks) );
1015 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol), nsdpblocks) );
1016 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpconstval), nsdpblocks) );
1018 for (b = 0; b < nsdpblocks; b++)
1020 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstrow[b]), oldsdpi->sdpconstrow[b], oldsdpi->sdpconstnblocknonz[b]) );
1021 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstcol[b]), oldsdpi->sdpconstcol[b], oldsdpi->sdpconstnblocknonz[b]) );
1022 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpconstval[b]), oldsdpi->sdpconstval[b], oldsdpi->sdpconstnblocknonz[b]) );
1026 newsdpi->sdpnnonz = oldsdpi->sdpnnonz;
1028 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz), nsdpblocks) );
1029 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpvar), nsdpblocks) );
1030 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow), nsdpblocks) );
1031 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol), nsdpblocks) );
1032 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval), nsdpblocks) );
1034 for (b = 0; b < nsdpblocks; b++)
1036 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpnblockvarnonz[b]), oldsdpi->sdpnblockvarnonz[b], oldsdpi->sdpnblockvars[b]) );
1037 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpvar[b]), oldsdpi->sdpvar[b], oldsdpi->sdpnblockvars[b]) );
1039 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdprow[b]), oldsdpi->sdpnblockvars[b]) );
1040 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b]), oldsdpi->sdpnblockvars[b]) );
1041 BMS_CALL( BMSallocBlockMemoryArray(blkmem, &(newsdpi->sdpval[b]), oldsdpi->sdpnblockvars[b]) );
1043 for (v = 0; v < oldsdpi->sdpnblockvars[b]; v++)
1045 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdprow[b][v]), oldsdpi->sdprow[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1046 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpcol[b][v]), oldsdpi->sdpcol[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1047 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->sdpval[b][v]), oldsdpi->sdpval[b][v], oldsdpi->sdpnblockvarnonz[b][v]) );
1052 newsdpi->nlpcons = oldsdpi->nlpcons;
1054 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lplhs), oldsdpi->lplhs, oldsdpi->nlpcons) );
1055 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprhs), oldsdpi->lprhs, oldsdpi->nlpcons) );
1057 newsdpi->lpnnonz = lpnnonz;
1059 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lprow), oldsdpi->lprow, lpnnonz) );
1060 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpcol), oldsdpi->lpcol, lpnnonz) );
1061 BMS_CALL( BMSduplicateBlockMemoryArray(blkmem, &(newsdpi->lpval), oldsdpi->lpval, lpnnonz) );
1064 newsdpi->solved = FALSE;
1065 newsdpi->penalty = FALSE;
1066 newsdpi->infeasible = FALSE;
1067 newsdpi->sdpid = 1000000 + oldsdpi->sdpid;
1068 newsdpi->epsilon = oldsdpi->epsilon;
1069 newsdpi->feastol = oldsdpi->feastol;
1099 int* sdpconstnblocknonz,
1103 SCIP_Real** sdpconstval,
1105 int** sdpnblockvarnonz,
1113 SCIP_Real*** sdpval,
1128 SCIPdebugMessage(
"Calling SCIPsdpiLoadSDP (%d)\n",sdpi->sdpid);
1130 assert ( sdpi != NULL );
1131 assert ( nvars > 0 );
1132 assert ( obj != NULL );
1133 assert ( lb != NULL );
1134 assert ( ub != NULL );
1137 if (sdpconstnnonz > 0 || sdpnnonz > 0 || nsdpblocks > 0)
1139 assert ( sdpblocksizes != NULL );
1140 assert ( sdpnblockvars != NULL );
1141 assert ( nsdpblocks > 0 );
1142 assert ( sdpconstnblocknonz != NULL );
1143 assert ( sdpnblockvarnonz != NULL );
1145 if (sdpconstnnonz > 0)
1147 assert ( sdpconstrow != NULL );
1148 assert ( sdpconstcol != NULL );
1149 assert ( sdpconstval != NULL );
1151 for (i = 0; i < nsdpblocks; i++)
1153 if (sdpconstnblocknonz[i] > 0)
1155 assert ( sdpconstrow[i] != NULL );
1156 assert ( sdpconstcol[i] != NULL );
1157 assert ( sdpconstval[i] != NULL );
1164 assert ( sdprow != NULL );
1165 assert ( sdpcol != NULL );
1166 assert ( sdpval != NULL );
1168 for ( i = 0; i < nsdpblocks; i++ )
1170 assert ( sdpcol[i] != NULL );
1171 assert ( sdprow[i] != NULL );
1172 assert ( sdpval[i] != NULL );
1174 for ( v = 0; v < sdpnblockvars[i]; v++)
1176 if (sdpnblockvarnonz[i][v] > 0)
1178 assert ( sdpcol[i][v] != NULL );
1179 assert ( sdprow[i][v] != NULL );
1180 assert ( sdpval[i][v] != NULL );
1188 assert ( nlpcons == 0 || lplhs != NULL );
1189 assert ( nlpcons == 0 || lprhs != NULL );
1190 assert ( lpnnonz == 0 || lprow != NULL );
1191 assert ( lpnnonz == 0 || lpcol != NULL );
1192 assert ( lpnnonz == 0 || lpval != NULL );
1197 for (block = sdpi->nsdpblocks - 1; block >= 0; block--)
1199 for (v = sdpi->sdpnblockvars[block] - 1; v >= 0; v--)
1201 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1202 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1203 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpi->sdpnblockvarnonz[block][v]);
1206 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpval[block]), sdpi->sdpnblockvars[block]);
1207 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdprow[block]), sdpi->sdpnblockvars[block]);
1208 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpi->sdpnblockvars[block]);
1209 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpi->sdpconstnblocknonz[block]);
1210 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpi->sdpconstnblocknonz[block]);
1211 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpi->sdpconstnblocknonz[block]);
1212 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpi->sdpnblockvars[block]);
1213 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpi->sdpnblockvars[block]);
1216 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->ub), sdpi->nvars);
1217 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lb), sdpi->nvars);
1218 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->obj), sdpi->nvars);
1220 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpblocksizes), sdpi->nsdpblocks);
1221 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpnblockvars), sdpi->nsdpblocks);
1222 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpi->nsdpblocks);
1225 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->obj), obj, nvars) );
1226 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->lb), lb, nvars) );
1227 BMS_CALL( BMSduplicateBlockMemoryArray(sdpi->blkmem, &(sdpi->ub), ub, nvars) );
1230 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstnblocknonz), sdpconstnblocknonz, nsdpblocks);
1233 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpnblockvarnonz), sdpi->nsdpblocks, nsdpblocks) );
1234 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstcol), sdpi->nsdpblocks, nsdpblocks) );
1235 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstrow), sdpi->nsdpblocks, nsdpblocks) );
1236 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpconstval), sdpi->nsdpblocks, nsdpblocks) );
1237 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpvar), sdpi->nsdpblocks, nsdpblocks) );
1238 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol), sdpi->nsdpblocks, nsdpblocks) );
1239 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow), sdpi->nsdpblocks, nsdpblocks) );
1240 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval), sdpi->nsdpblocks, nsdpblocks) );
1242 for (block = 0; block < nsdpblocks; block++)
1244 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpnblockvarnonz[block]), sdpnblockvarnonz[block], sdpnblockvars[block]);
1246 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstcol[block]), sdpconstcol[block], sdpconstnblocknonz[block]);
1247 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstrow[block]), sdpconstrow[block], sdpconstnblocknonz[block]);
1248 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpconstval[block]), sdpconstval[block], sdpconstnblocknonz[block]);
1251 for (i = 0; i < sdpi->sdpconstnblocknonz[block]; ++i)
1254 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpvar[block]), sdpvar[block], sdpnblockvars[block]);
1256 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpcol[block]), sdpnblockvars[block]) );
1257 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdprow[block]), sdpnblockvars[block]) );
1258 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpi->sdpval[block]), sdpnblockvars[block]) );
1260 for (v = 0; v < sdpi->sdpnblockvars[block]; v++)
1262 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpcol[block][v]), sdpcol[block][v], sdpnblockvarnonz[block][v]);
1263 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdprow[block][v]), sdprow[block][v], sdpnblockvarnonz[block][v]);
1264 DUPLICATE_ARRAY_NULL(sdpi->blkmem, &(sdpi->sdpval[block][v]), sdpval[block][v], sdpnblockvarnonz[block][v]);
1267 for (i = 0; i < sdpi->sdpnblockvarnonz[block][v]; ++i)
1273 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1274 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1275 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1276 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1277 BMSfreeBlockMemoryArrayNull(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1286 sdpi->nvars = nvars;
1287 sdpi->nsdpblocks = nsdpblocks;
1289 sdpi->sdpconstnnonz = sdpconstnnonz;
1290 sdpi->sdpnnonz = sdpnnonz;
1293 sdpi->lpnnonz = lpnnonz;
1294 sdpi->nlpcons = nlpcons;
1296 sdpi->solved = FALSE;
1297 sdpi->infeasible = FALSE;
1309 const SCIP_Real* lhs,
1310 const SCIP_Real* rhs,
1315 const SCIP_Real* val
1320 SCIPdebugMessage(
"Adding %d LP-Constraints to SDP %d.\n", nrows, sdpi->sdpid);
1322 assert ( sdpi != NULL );
1327 assert ( lhs != NULL );
1328 assert ( rhs != NULL );
1329 assert ( nnonz >= 0 );
1330 assert ( row != NULL );
1331 assert ( col != NULL );
1332 assert ( val != NULL );
1334 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1335 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons + nrows) );
1337 for (i = 0; i < nrows; i++)
1339 sdpi->lplhs[sdpi->nlpcons + i] = lhs[i];
1340 sdpi->lprhs[sdpi->nlpcons + i] = rhs[i];
1343 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1344 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1345 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz + nnonz) );
1347 for (i = 0; i < nnonz; i++)
1349 assert ( 0 <= row[i] && row[i] < nrows );
1351 sdpi->lprow[sdpi->lpnnonz + i] = row[i] + sdpi->nlpcons;
1353 assert ( 0 <= col[i] && col[i] < sdpi->nvars );
1354 sdpi->lpcol[sdpi->lpnnonz + i] = col[i];
1356 sdpi->lpval[sdpi->lpnnonz + i] = val[i];
1359 sdpi->nlpcons = sdpi->nlpcons + nrows;
1360 sdpi->lpnnonz = sdpi->lpnnonz + nnonz;
1362 sdpi->solved = FALSE;
1363 sdpi->infeasible = FALSE;
1381 SCIPdebugMessage(
"Deleting rows %d to %d from SDP %d.\n", firstrow, lastrow, sdpi->sdpid);
1383 assert ( sdpi != NULL );
1384 assert ( firstrow >= 0 );
1385 assert ( firstrow <= lastrow );
1386 assert ( lastrow < sdpi->nlpcons );
1389 if (firstrow == 0 && lastrow == sdpi->nlpcons - 1)
1391 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz);
1392 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz);
1393 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz);
1394 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons);
1395 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons);
1406 sdpi->solved = FALSE;
1407 sdpi->infeasible = FALSE;
1412 deletedrows = lastrow - firstrow + 1;
1416 for (i = lastrow + 1; i < sdpi->nlpcons; i++)
1418 sdpi->lplhs[i - deletedrows] = sdpi->lplhs[i];
1419 sdpi->lprhs[i - deletedrows] = sdpi->lprhs[i];
1421 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lplhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
1422 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprhs), sdpi->nlpcons, sdpi->nlpcons - deletedrows) );
1425 SCIPsortIntIntReal(sdpi->lprow, sdpi->lpcol, sdpi->lpval, sdpi->lpnnonz);
1429 for (i = 0; i < sdpi->lpnnonz; i++)
1431 if (sdpi->lprow[i] >= firstrow && sdpi->lprow[i] <= lastrow)
1440 if (firstrowind > -1)
1443 while (i < sdpi->lpnnonz && sdpi->lprow[i] <= lastrow)
1448 deletednonz = lastrowind - firstrowind + 1;
1451 for (i = lastrowind + 1; i < sdpi->lpnnonz; i++)
1453 sdpi->lpcol[i - deletednonz] = sdpi->lpcol[i];
1455 sdpi->lprow[i - deletednonz] = sdpi->lprow[i] - deletedrows;
1456 sdpi->lpval[i - deletednonz] = sdpi->lpval[i];
1460 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpcol), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
1461 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lprow), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
1462 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpi->lpval), sdpi->lpnnonz, sdpi->lpnnonz - deletednonz) );
1463 sdpi->nlpcons = sdpi->nlpcons - deletedrows;
1464 sdpi->lpnnonz = sdpi->lpnnonz - deletednonz;
1466 sdpi->solved = FALSE;
1467 sdpi->infeasible = FALSE;
1484 SCIPdebugMessage(
"Calling SCIPsdpiDelLPRowset for SDP %d.\n", sdpi->sdpid);
1486 assert ( sdpi != NULL );
1487 assert ( dstat != NULL );
1489 oldnlpcons = sdpi->nlpcons;
1492 for (i = 0; i < oldnlpcons; i++)
1502 dstat[i] = i - deletedrows;
1505 sdpi->solved = FALSE;
1506 sdpi->infeasible = FALSE;
1516 assert( sdpi != NULL );
1518 SCIPdebugMessage(
"Called SCIPsdpiClear in SDP %d.\n", sdpi->sdpid);
1532 const SCIP_Real* lb,
1538 SCIPdebugMessage(
"Changing %d variable bounds in SDP %d\n", nvars, sdpi->sdpid);
1540 assert ( sdpi != NULL );
1541 assert ( ind != NULL );
1542 assert ( lb != NULL );
1543 assert ( ub != NULL );
1545 for (i = 0; i < nvars; i++)
1547 assert ( 0 <= ind[i] && ind[i] < sdpi->nvars );
1548 sdpi->lb[ind[i]] = lb[i];
1549 sdpi->ub[ind[i]] = ub[i];
1552 sdpi->solved = FALSE;
1562 const SCIP_Real* lhs,
1563 const SCIP_Real* rhs
1568 SCIPdebugMessage(
"Changing %d left and right hand sides of SDP %d\n", nrows, sdpi->sdpid);
1570 assert( sdpi != NULL );
1571 assert( 0 <= nrows && nrows <= sdpi->nlpcons );
1572 assert( ind != NULL );
1573 assert( lhs != NULL );
1574 assert( rhs != NULL );
1576 for (i = 0; i < nrows; i++)
1578 assert ( ind[i] >= 0 );
1579 assert ( ind[i] < sdpi->nlpcons );
1580 sdpi->lplhs[ind[i]] = lhs[i];
1581 sdpi->lprhs[ind[i]] = rhs[i];
1584 sdpi->solved = FALSE;
1603 assert( sdpi != NULL );
1605 *nlprows = sdpi->nlpcons;
1616 assert( sdpi != NULL );
1618 *nsdpblocks = sdpi->nsdpblocks;
1629 assert( sdpi != NULL );
1631 *nvars = sdpi->nvars;
return SCIP_OKAY;
1640 assert( sdpi != NULL );
1642 *nnonz = sdpi->sdpnnonz;
1653 assert( sdpi != NULL );
1655 *nnonz = sdpi->sdpconstnnonz;
1666 assert( sdpi != NULL );
1668 *nnonz = sdpi->lpnnonz;
1683 assert( sdpi != NULL );
1684 assert( firstvar >= 0 );
1685 assert( firstvar <= lastvar );
1686 assert( lastvar < sdpi->nvars);
1687 assert( vals != NULL );
1689 for (i = 0; i < lastvar - firstvar + 1; i++)
1690 vals[i] = sdpi->obj[firstvar + i];
1706 assert( sdpi != NULL );
1707 assert( firstvar >= 0 );
1708 assert( firstvar <= lastvar );
1709 assert( lastvar < sdpi->nvars);
1710 assert( lbs != NULL );
1711 assert( ubs != NULL );
1713 for (i = 0; i < lastvar - firstvar + 1; i++)
1716 lbs[i] = sdpi->lb[firstvar + i];
1718 ubs[i] = sdpi->ub[firstvar + i];
1733 assert( sdpi != NULL );
1734 assert( firstrow >= 0 );
1735 assert( firstrow <= lastrow );
1736 assert( lastrow < sdpi->nlpcons);
1737 assert( lhss != NULL );
1739 for (i = 0; i < lastrow - firstrow + 1; i++)
1740 lhss[firstrow + i] = sdpi->lplhs[i];
1755 assert( sdpi != NULL );
1756 assert( firstrow >= 0 );
1757 assert( firstrow <= lastrow );
1758 assert( lastrow < sdpi->nlpcons);
1759 assert( rhss != NULL );
1761 for (i = 0; i < lastrow - firstrow + 1; i++)
1762 rhss[firstrow + i] = sdpi->lprhs[i];
1783 int* totalsdpiterations,
1784 SCIP_Bool enforceslatercheck
1790 int* sdpconstnblocknonz;
1793 SCIP_Real** sdpconstval;
1797 SCIP_Real* lplhsafterfix;
1798 SCIP_Real* lprhsafterfix;
1799 int* rowsnactivevars;
1800 SCIP_Bool fixingfound;
1802 int* blockindchanges;
1805 assert ( sdpi != NULL );
1806 assert ( totalsdpiterations != NULL );
1808 SCIPdebugMessage(
"Forwarding SDP %d to solver!\n", sdpi->sdpid);
1810 sdpconstnblocknonz = NULL;
1815 nremovedinds = NULL;
1820 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks) );
1821 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks) );
1822 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks) );
1823 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks) );
1824 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks) );
1825 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks) );
1826 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks) );
1827 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons) );
1828 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons) );
1829 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons) );
1831 for (block = 0; block < sdpi->nsdpblocks; block++)
1833 sdpconstrow[block] = NULL;
1834 sdpconstcol[block] = NULL;
1835 sdpconstval[block] = NULL;
1836 indchanges[block] = NULL;
1837 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]) );
1838 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
1839 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
1840 BMS_CALL( BMSallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz) );
1847 fixingfound = FALSE;
1850 while (fixingfound);
1853 for (block = 0; block < sdpi->nsdpblocks; block++)
1854 sdpconstnblocknonz[block] = sdpi->sdpnnonz + sdpi->sdpconstnnonz;
1856 SCIP_CALL(
compConstMatAfterFixings(sdpi, &sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval) );
1859 for (block = 0; block < sdpi->nsdpblocks; block++)
1861 assert ( sdpconstnblocknonz[block] <= sdpi->sdpnnonz + sdpi->sdpconstnnonz );
1863 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
1864 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
1865 BMS_CALL( BMSreallocBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpi->sdpnnonz + sdpi->sdpconstnnonz, sdpconstnblocknonz[block]) );
1868 SCIP_CALL (
findEmptyRowColsSDP(sdpi, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, indchanges, nremovedinds, blockindchanges, &nremovedblocks) );
1870 if ( sdpi->infeasible )
1872 SCIPdebugMessage(
"SDP %d not given to solver, as infeasibility was detected during presolving!\n", sdpi->sdpid++);
1875 sdpi->solved = TRUE;
1879 if ( sdpi->slatercheck )
1887 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1888 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1889 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1890 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1891 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, &origfeas) );
1895 printf(
"Unable to check Slater condition for dual problem of SDP %d, could mean that the Slater conidition for the primal problem"
1896 " is not fullfilled.\n", sdpi->sdpid);
1901 if ( objval < - sdpi->feastol )
1902 SCIPdebugMessage(
"Slater condition for SDP %d is fullfilled for dual problem with smallest eigenvalue %f.\n", sdpi->sdpid, -1.0 * objval);
1904 printf(
"Slater condition for SDP %d not fullfilled for dual problem as smallest eigenvalue was %f, expect numerical trouble.\n",
1905 sdpi->sdpid, -1.0 * objval);
1911 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1912 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1913 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1914 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1915 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start) );
1917 sdpi->penalty = FALSE;
1918 sdpi->solved = TRUE;
1923 SCIP_Real penaltyparam;
1930 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penalty formulation\n", sdpi->sdpid);
1933 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1934 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1935 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1936 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1937 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, &feasorig) );
1948 SCIPdebugMessage(
"Solver did not produce an acceptable result, trying SDP %d again with penaltyparameter %f\n", sdpi->sdpid, penaltyparam);
1951 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1952 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1953 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1954 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1955 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, &feasorig) );
1957 penaltyparam *= 10.0;
1964 sdpi->penalty = TRUE;
1968 sdpi->solved = FALSE;
1969 sdpi->penalty = TRUE;
1974 SCIPdebugMessage(
"Problem was found to be infeasible using a penalty formulation \n");
1975 sdpi->infeasible = TRUE;
1976 sdpi->penalty = TRUE;
1980 SCIPdebugMessage(
"SDP-Solver could not solve the problem even after using a penalty formulation \n");
1981 sdpi->solved = FALSE;
1982 sdpi->penalty = TRUE;
1985 if ( sdpi->solved == FALSE && enforceslatercheck)
1993 sdpi->nsdpblocks, sdpi->sdpblocksizes, sdpi->sdpnblockvars, sdpconstnnonz,
1994 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval,
1995 sdpi->sdpnnonz, sdpi->sdpnblockvarnonz, sdpi->sdpvar, sdpi->sdprow, sdpi->sdpcol,
1996 sdpi->sdpval, indchanges, nremovedinds, blockindchanges, nremovedblocks, nactivelpcons, sdpi->nlpcons, lplhsafterfix, lprhsafterfix,
1997 rowsnactivevars, sdpi->lpnnonz, sdpi->lprow, sdpi->lpcol, sdpi->lpval, start, &origfeas) );
2001 printf(
"SDP-solver could not solve root node relaxation, unable to check Slater condition for dual problem of SDP %d, could mean that the "
2002 "Slater conidition for the primal problem is not fullfilled.\n", sdpi->sdpid);
2007 if ( objval < - sdpi->feastol )
2008 printf(
"SDP-solver could not solve root node relaxation even though the Slater condition is fullfilled for the dual problem with smallest eigenvalue %f.\n",
2011 printf(
"SDP-solver could not solve root node relaxation, Slater condition is not fullfilled for the dual problem as smallest eigenvalue was %f.\n",
2015 else if ( sdpi->solved == FALSE )
2016 printf(
"Numerical trouble\n");
2021 for (block = 0; block < sdpi->nsdpblocks; block++)
2023 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstval[block]), sdpconstnblocknonz[block]);
2024 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstcol[block]), sdpconstnblocknonz[block]);
2025 BMSfreeBlockMemoryArray(sdpi->blkmem, &(sdpconstrow[block]), sdpconstnblocknonz[block]);
2026 BMSfreeBlockMemoryArray(sdpi->blkmem, &(indchanges[block]), sdpi->sdpblocksizes[block]);
2028 BMSfreeBlockMemoryArray(sdpi->blkmem, &rowsnactivevars, sdpi->nlpcons);
2029 BMSfreeBlockMemoryArray(sdpi->blkmem, &lprhsafterfix, sdpi->nlpcons);
2030 BMSfreeBlockMemoryArray(sdpi->blkmem, &lplhsafterfix, sdpi->nlpcons);
2031 BMSfreeBlockMemoryArray(sdpi->blkmem, &blockindchanges, sdpi->nsdpblocks);
2032 BMSfreeBlockMemoryArray(sdpi->blkmem, &nremovedinds, sdpi->nsdpblocks);
2033 BMSfreeBlockMemoryArray(sdpi->blkmem, &indchanges, sdpi->nsdpblocks);
2034 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstval, sdpi->nsdpblocks);
2035 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstcol, sdpi->nsdpblocks);
2036 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstrow, sdpi->nsdpblocks);
2037 BMSfreeBlockMemoryArray(sdpi->blkmem, &sdpconstnblocknonz, sdpi->nsdpblocks);
2040 if ( ! sdpi->infeasible )
2043 *totalsdpiterations += newiterations;
2066 assert( sdpi != NULL );
2068 return sdpi->solved;
2076 assert( sdpi != NULL );
2078 return ( ! sdpi->penalty );
2088 assert( sdpi != NULL );
2091 if (sdpi->infeasible)
2100 SCIP_Bool* primalfeasible,
2101 SCIP_Bool* dualfeasible
2104 assert( sdpi != NULL );
2107 if ( sdpi->infeasible )
2109 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2110 *dualfeasible = FALSE;
2125 assert( sdpi != NULL );
2128 if ( sdpi->infeasible )
2130 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal unboundedness not available\n");
2143 assert( sdpi != NULL );
2146 if ( sdpi->infeasible )
2148 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2161 assert(sdpi != NULL );
2164 if ( sdpi->infeasible )
2166 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, primal feasibility not available\n");
2179 assert( sdpi != NULL );
2182 if ( sdpi->infeasible )
2184 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, dual unboundedness not available\n");
2197 assert( sdpi != NULL );
2200 if ( sdpi->infeasible )
2202 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
2215 assert( sdpi != NULL );
2218 if ( sdpi->infeasible )
2220 SCIPdebugMessage(
"Problem was found infeasible during preprocessing\n");
2232 assert( sdpi != NULL );
2235 if ( sdpi->infeasible )
2237 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this counts as converged.\n");
2249 assert( sdpi != NULL );
2252 if ( sdpi->infeasible )
2254 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective limit available.\n");
2266 assert( sdpi != NULL );
2269 if ( sdpi->infeasible )
2271 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iteration limit available.\n");
2283 assert( sdpi != NULL );
2286 if ( sdpi->infeasible )
2288 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no time limit available.\n");
2309 assert( sdpi != NULL );
2311 if ( ! sdpi->solved )
2313 SCIPdebugMessage(
"Problem wasn't solved yet.\n");
2316 else if ( sdpi->infeasible )
2318 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no internal status available.\n");
2330 assert( sdpi != NULL );
2333 if ( sdpi->infeasible )
2335 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, therefore there is no optimal solution.\n");
2348 assert( sdpi != NULL );
2351 if ( sdpi->infeasible )
2353 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, this is acceptable in a B&B context.\n");
2366 assert( sdpi != NULL );
2367 assert( objval != NULL );
2370 if ( sdpi->infeasible )
2372 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no objective value available.\n");
2391 assert( sdpi != NULL );
2392 assert( dualsollength != NULL );
2393 assert( *dualsollength == 0 || dualsol != NULL );
2396 if ( sdpi->infeasible )
2398 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no solution available.\n");
2418 assert( sdpi != NULL );
2419 assert( lbvars != NULL );
2420 assert( ubvars != NULL );
2421 assert( arraylength != NULL );
2422 assert( *arraylength >= 0 );
2425 if ( sdpi->infeasible )
2427 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no primal variables available.\n");
2442 assert( sdpi != NULL );
2445 if ( sdpi->infeasible )
2447 SCIPdebugMessage(
"Problem was found infeasible during preprocessing, no iterations needed.\n");
2474 assert( sdpi != NULL );
2485 assert( sdpi != NULL );
2495 assert( sdpi != NULL );
2506 assert( sdpi != NULL );
2518 assert( sdpi != NULL );
2519 assert( sdpi->sdpisolver != NULL );
2520 assert( dval != NULL );
2525 *dval = sdpi->epsilon;
2528 *dval = sdpi->feastol;
2534 return SCIP_PARAMETERUNKNOWN;
2541 assert( REALABS(*dval - val) < sdpi->epsilon );
2555 assert( sdpi != NULL );
2556 assert( sdpi->sdpisolver != NULL );
2561 sdpi->epsilon = dval;
2565 sdpi->feastol = dval;
2572 return SCIP_PARAMETERUNKNOWN;
2579 assert( REALABS(dval - val) < sdpi->epsilon );
2593 assert( sdpi != NULL );
2594 assert( sdpi->sdpisolver != NULL );
2595 assert( ival != NULL );
2600 case SCIP_SDPPAR_THREADS:
2608 *ival = (int) sdpi->slatercheck;
2611 return SCIP_PARAMETERUNKNOWN;
2620 assert( *ival == val );
2635 assert( sdpi != NULL );
2636 assert( sdpi->sdpisolver != NULL );
2641 case SCIP_SDPPAR_THREADS:
2646 assert( ival == 0 || ival == 1 );
2650 assert( ival == 0 || ival == 1 );
2651 sdpi->slatercheck = (SCIP_Bool) ival;
2654 return SCIP_PARAMETERUNKNOWN;
2663 assert( ival == val );
2689 SCIPdebugMessage(
"Not implemented yet\n");
2690 return SCIP_LPERROR;
2699 SCIPdebugMessage(
"Not implemented yet\n");
2700 return SCIP_LPERROR;
SCIP_RETCODE SCIPsdpiFree(SCIP_SDPI **sdpi)
SCIP_Bool SCIPsdpiIsDualUnbounded(SCIP_SDPI *sdpi)
EXTERN SCIP_RETCODE SCIPsdpiSolverIncreaseCounter(SCIP_SDPISOLVER *sdpisolver)
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)
EXTERN SCIP_Bool SCIPsdpiSolverIsObjlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetSolFeasibility(SCIP_SDPI *sdpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPsdpiWriteSDP(SCIP_SDPI *sdpi, const char *fname)
EXTERN SCIP_Bool SCIPsdpiSolverIsAcceptable(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetLPNNonz(SCIP_SDPI *sdpi, int *nnonz)
EXTERN SCIP_RETCODE SCIPsdpiSolverResetCounter(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverFeasibilityKnown(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverIsConverged(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetPrimalBoundVars(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
SCIP_Bool SCIPsdpiIsOptimal(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpVarfixerMergeArraysIntoNew(BMS_BLKMEM *blkmem, SCIP_Real feastol, int *firstrow, int *firstcol, SCIP_Real *firstval, int firstlength, int *secondrow, int *secondcol, SCIP_Real *secondval, int secondlength, int *targetrow, int *targetcol, SCIP_Real *targetval, int *targetlength)
SCIP_RETCODE SCIPsdpiGetIntpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, int *ival)
SCIP_RETCODE SCIPsdpiGetSDPNNonz(SCIP_SDPI *sdpi, int *nnonz)
SCIP_Bool SCIPsdpiIsInfinity(SCIP_SDPI *sdpi, SCIP_Real val)
const char * SCIPsdpiGetSolverName(void)
EXTERN SCIP_RETCODE SCIPsdpiSolverFree(SCIP_SDPISOLVER **sdpisolver)
EXTERN SCIP_RETCODE SCIPsdpiSolverLoadAndSolve(SCIP_SDPISOLVER *sdpisolver, int nvars, SCIP_Real *obj, SCIP_Real *lb, SCIP_Real *ub, int nsdpblocks, int *sdpblocksizes, int *sdpnblockvars, int sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int sdpnnonz, int **sdpnblockvarnonz, int **sdpvar, int ***sdprow, int ***sdpcol, SCIP_Real ***sdpval, int **indchanges, int *nremovedinds, int *blockindchanges, int nremovedblocks, int nlpcons, int noldlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int *rownactivevars, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval, SCIP_Real *start)
SCIP_RETCODE SCIPsdpiGetNSDPBlocks(SCIP_SDPI *sdpi, int *nsdpblocks)
SCIP_RETCODE SCIPsdpiGetSol(SCIP_SDPI *sdpi, SCIP_Real *objval, SCIP_Real *dualsol, int *dualsollength)
interface methods for specific SDP solvers
SCIP_Bool SCIPsdpiIsPrimalInfeasible(SCIP_SDPI *sdpi)
SCIP_Bool SCIPsdpiIsGEMaxPenParam(SCIP_SDPI *sdpi, SCIP_Real val)
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 SCIPsdpiGetIterations(SCIP_SDPI *sdpi, int *iterations)
EXTERN SCIP_Bool SCIPsdpiSolverIsDualFeasible(SCIP_SDPISOLVER *sdpisolver)
EXTERN SCIP_Bool SCIPsdpiSolverIsOptimal(SCIP_SDPISOLVER *sdpisolver)
static SCIP_RETCODE findEmptyRowColsSDP(SCIP_SDPI *sdpi, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int **indchanges, int *nremovedinds, int *blockindchanges, int *nremovedblocks)
SCIP_Bool SCIPsdpiIsAcceptable(SCIP_SDPI *sdpi)
EXTERN SCIP_Bool SCIPsdpiSolverIsGEMaxPenParam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real val)
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)
SCIP_RETCODE SCIPsdpiClone(SCIP_SDPI *oldsdpi, SCIP_SDPI *newsdpi)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetIterations(SCIP_SDPISOLVER *sdpisolver, int *iterations)
EXTERN SCIP_RETCODE SCIPsdpiSolverSetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int ival)
SCIP_RETCODE SCIPsdpiChgBounds(SCIP_SDPI *sdpi, int nvars, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
EXTERN const char * SCIPsdpiSolverGetSolverDesc(void)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int *ival)
SCIP_RETCODE SCIPsdpiDelLPRowset(SCIP_SDPI *sdpi, int *dstat)
EXTERN SCIP_Bool SCIPsdpiSolverIsDualInfeasible(SCIP_SDPISOLVER *sdpisolver)
EXTERN const char * SCIPsdpiSolverGetSolverName(void)
SCIP_Bool SCIPsdpiIsObjlimExc(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiGetObj(SCIP_SDPI *sdpi, int firstvar, int lastvar, SCIP_Real *vals)
void * SCIPsdpiGetSolverPointer(SCIP_SDPI *sdpi)
int SCIPsdpiGetInternalStatus(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiCreate(SCIP_SDPI **sdpi, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem)
EXTERN SCIP_RETCODE SCIPsdpiSolverLoadAndSolveWithPenalty(SCIP_SDPISOLVER *sdpisolver, SCIP_Real penaltyparam, SCIP_Bool withobj, SCIP_Bool rbound, int nvars, SCIP_Real *obj, SCIP_Real *lb, SCIP_Real *ub, int nsdpblocks, int *sdpblocksizes, int *sdpnblockvars, int sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int sdpnnonz, int **sdpnblockvarnonz, int **sdpvar, int ***sdprow, int ***sdpcol, SCIP_Real ***sdpval, int **indchanges, int *nremovedinds, int *blockindchanges, int nremovedblocks, int nlpcons, int noldlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int *rownactivevars, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval, SCIP_Real *start, SCIP_Bool *feasorig)
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 SCIPsdpiSetIntpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, int ival)
SCIP_Bool SCIPsdpiIsPrimalUnbounded(SCIP_SDPI *sdpi)
SCIP_Real SCIPsdpiInfinity(SCIP_SDPI *sdpi)
#define CHECK_IF_SOLVED_BOOL(sdpi)
EXTERN SCIP_Bool SCIPsdpiSolverIsIterlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiGetRhSides(SCIP_SDPI *sdpi, int firstrow, int lastrow, SCIP_Real *rhss)
#define DUPLICATE_ARRAY_NULL(blkmem, target, source, size)
adds the main functionality to fix/unfix/(multi-)aggregate variables by merging two three-tuple-array...
static void ensureLowerTriangular(int *i, int *j)
SCIP_RETCODE SCIPsdpiSolve(SCIP_SDPI *sdpi, SCIP_Real *start, int *totalsdpiterations, SCIP_Bool enforceslatercheck)
SCIP_RETCODE SCIPsdpiGetObjval(SCIP_SDPI *sdpi, SCIP_Real *objval)
EXTERN SCIP_RETCODE SCIPsdpiSolverGetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real *dval)
SCIP_Bool SCIPsdpiIsConverged(SCIP_SDPI *sdpi)
static SCIP_Bool isFixed(SCIP_SDPI *sdpi, int v)
EXTERN SCIP_Bool SCIPsdpiSolverIsTimelimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiWasSolved(SCIP_SDPI *sdpi)
SCIP_RETCODE SCIPsdpiReadSDP(SCIP_SDPI *sdpi, const char *fname)
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)
EXTERN SCIP_Bool SCIPsdpiSolverIsDualUnbounded(SCIP_SDPISOLVER *sdpisolver)
SCIP_Real SCIPsdpiMaxPenParam(SCIP_SDPI *sdpi)
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)
EXTERN SCIP_Real SCIPsdpiSolverMaxPenParam(SCIP_SDPISOLVER *sdpisolver)
struct SCIP_SDPiSolver SCIP_SDPISOLVER
SCIP_RETCODE SCIPsdpiGetRealpar(SCIP_SDPI *sdpi, SCIP_SDPPARAM type, SCIP_Real *dval)
EXTERN SCIP_RETCODE SCIPsdpiSolverCreate(SCIP_SDPISOLVER **sdpisolver, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem)
static SCIP_RETCODE compConstMatAfterFixings(SCIP_SDPI *sdpi, int *sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval)
#define CHECK_IF_SOLVED(sdpi)
EXTERN SCIP_Real SCIPsdpiSolverInfinity(SCIP_SDPISOLVER *sdpisolver)
enum SCIP_SDPParam SCIP_SDPPARAM
EXTERN void * SCIPsdpiSolverGetSolverPointer(SCIP_SDPISOLVER *sdpisolver)
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)
SCIP_Bool SCIPsdpiSolvedOrig(SCIP_SDPI *sdpi)
#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)