46 #pragma GCC diagnostic ignored "-Wstrict-prototypes"
48 #pragma GCC diagnostic warning "-Wstrict-prototypes"
51 #include "blockmemshell/memory.h"
53 #include "scip/pub_misc.h"
56 #define DSDP_CALL(x) do \
58 int _dsdperrorcode_; \
59 if ( (_dsdperrorcode_ = (x)) != 0 ) \
61 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
62 return SCIP_LPERROR; \
68 #define DSDP_CALL_BOOL(x) do \
70 int _dsdperrorcode_; \
71 if ( (_dsdperrorcode_ = (x)) != 0 ) \
73 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
80 #define DSDP_CALLM(x) do \
82 int _dsdperrorcode_; \
83 if ( (_dsdperrorcode_ = (x)) != 0 ) \
85 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
86 return SCIP_NOMEMORY; \
92 #define BMS_CALL(x) do \
96 SCIPerrorMessage("No memory in function call.\n"); \
97 return SCIP_NOMEMORY; \
103 #define CHECK_IF_SOLVED(sdpisolver) do \
105 if (!(sdpisolver->solved)) \
107 SCIPerrorMessage("Tried to access solution information for SDP %d ahead of solving!\n", sdpisolver->sdpcounter); \
108 return SCIP_LPERROR; \
114 #define CHECK_IF_SOLVED_BOOL(sdpisolver) do \
116 if (!(sdpisolver->solved)) \
118 SCIPerrorMessage("Tried to access solution information for SDP %d ahead of solving!\n", sdpisolver->sdpcounter); \
126 struct SCIP_SDPiSolver
128 SCIP_MESSAGEHDLR* messagehdlr;
136 int* inputtodsdpmapper;
139 int* dsdptoinputmapper;
140 SCIP_Real* fixedvarsval;
141 SCIP_Real fixedvarsobjcontr;
148 SCIP_Bool penaltyworbound;
168 return i*(i+1)/2 + j;
180 assert( lb < ub + sdpisolver->feastol );
182 return (REALABS(ub-lb) <= sdpisolver->feastol);
185 #define isFixed(sdpisolver,lb,ub) (REALABS(ub-lb) <= sdpisolver->feastol)
201 SCIPsortIntIntReal(col, row, val, length);
204 while (nextentry < length)
206 firstentry = nextentry;
208 while (nextentry < length && col[nextentry] == col[firstentry])
212 SCIPsortIntReal(row + firstentry, val + firstentry, nextentry - firstentry);
238 return "Dual-Scaling Interior Point Solver for Semidefinite Programming developed by Steve Benson, Yinyu Ye, and Xiong Zhang "
239 "(http://www.mcs.anl.gov/hs/software/DSDP/)";
252 assert( sdpisolver != NULL );
253 return (
void*) sdpisolver->dsdp;
269 SCIP_MESSAGEHDLR* messagehdlr,
273 assert( sdpisolver != NULL );
274 assert( blkmem != NULL );
276 SCIPdebugMessage(
"Calling SCIPsdpiCreate \n");
278 BMS_CALL( BMSallocBlockMemory(blkmem, sdpisolver) );
280 (*sdpisolver)->messagehdlr = messagehdlr;
281 (*sdpisolver)->blkmem = blkmem;
285 (*sdpisolver)->dsdp = NULL;
286 (*sdpisolver)->sdpcone = NULL;
287 (*sdpisolver)->lpcone = NULL;
288 (*sdpisolver)->bcone = NULL;
290 (*sdpisolver)->nvars = 0;
291 (*sdpisolver)->nactivevars = 0;
292 (*sdpisolver)->inputtodsdpmapper = NULL;
293 (*sdpisolver)->dsdptoinputmapper = NULL;
294 (*sdpisolver)->fixedvarsval = NULL;
295 (*sdpisolver)->fixedvarsobjcontr = 0.0;
296 (*sdpisolver)->solved = FALSE;
297 (*sdpisolver)->sdpcounter = 0;
299 (*sdpisolver)->epsilon = 1e-5;
300 (*sdpisolver)->feastol = 1e-4;
302 (*sdpisolver)->sdpinfo = FALSE;
312 assert( sdpisolver != NULL );
313 assert( *sdpisolver != NULL );
315 SCIPdebugMessage(
"Freeing SDPISolver\n");
317 if ( (*sdpisolver)->dsdp != NULL )
319 DSDP_CALL( DSDPDestroy((*sdpisolver)->dsdp) );
322 if ( (*sdpisolver)->nvars > 0 )
323 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->inputtodsdpmapper, (*sdpisolver)->nvars);
325 if ( (*sdpisolver)->nactivevars > 0 )
326 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->dsdptoinputmapper, (*sdpisolver)->nactivevars);
328 if ( (*sdpisolver)->nvars >= (*sdpisolver)->nactivevars )
329 BMSfreeBlockMemoryArrayNull((*sdpisolver)->blkmem, &(*sdpisolver)->fixedvarsval, (*sdpisolver)->nvars - (*sdpisolver)->nactivevars);
331 BMSfreeBlockMemory((*sdpisolver)->blkmem, sdpisolver);
341 assert( sdpisolver != NULL );
343 sdpisolver->sdpcounter++;
353 assert( sdpisolver != NULL );
355 SCIPdebugMessage(
"Resetting counter of SDP-Interface from %d to 0.\n", sdpisolver->sdpcounter);
356 sdpisolver->sdpcounter = 0;
393 int* sdpconstnblocknonz,
397 SCIP_Real** sdpconstval,
399 int** sdpnblockvarnonz,
409 int* blockindchanges,
423 return SCIPsdpiSolverLoadAndSolveWithPenalty(sdpisolver, 0.0, TRUE, TRUE, nvars, obj, lb, ub, nsdpblocks, sdpblocksizes, sdpnblockvars,
424 sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, sdpnnonz, sdpnblockvarnonz, sdpvar, sdprow, sdpcol, sdpval,
425 indchanges, nremovedinds, blockindchanges, nremovedblocks, nlpcons, noldlpcons, lplhs, lprhs, rownactivevars, lpnnonz, lprow, lpcol,
450 SCIP_Real penaltyparam,
461 int* sdpconstnblocknonz,
465 SCIP_Real** sdpconstval,
467 int** sdpnblockvarnonz,
477 int* blockindchanges,
493 int* dsdpconstind = NULL;
494 double* dsdpconstval = NULL;
496 double* dsdpval = NULL;
497 int* dsdplpbegcol = NULL;
498 int* dsdplprow = NULL;
499 double* dsdplpval = NULL;
510 DSDPTerminationReason reason;
513 assert( sdpisolver != NULL );
514 assert( penaltyparam > -1 * sdpisolver->epsilon );
515 assert( penaltyparam < sdpisolver->epsilon || feasorig != NULL );
517 assert( obj != NULL );
518 assert( lb != NULL );
519 assert( ub != NULL );
520 assert( nsdpblocks >= 0 );
521 assert( nsdpblocks == 0 || sdpblocksizes != NULL );
522 assert( nsdpblocks == 0 || sdpnblockvars != NULL );
523 assert( sdpconstnnonz >= 0 );
524 assert( nsdpblocks == 0 || sdpconstnblocknonz != NULL );
525 assert( nsdpblocks == 0 || sdpconstrow != NULL );
526 assert( nsdpblocks == 0 || sdpconstcol != NULL );
527 assert( nsdpblocks == 0 || sdpconstval != NULL );
528 assert( sdpnnonz >= 0 );
529 assert( nsdpblocks == 0 || sdpnblockvarnonz != NULL );
530 assert( nsdpblocks == 0 || sdpvar != NULL );
531 assert( nsdpblocks == 0 || sdprow != NULL );
532 assert( nsdpblocks == 0 || sdpcol != NULL );
533 assert( nsdpblocks == 0 || sdpval != NULL );
534 assert( nsdpblocks == 0 || indchanges != NULL );
535 assert( nsdpblocks == 0 || nremovedinds != NULL );
536 assert( nsdpblocks == 0 || blockindchanges != NULL );
537 assert( 0 <= nremovedblocks && nremovedblocks <= nsdpblocks );
538 assert( nlpcons >= 0 );
539 assert( noldlpcons >= nlpcons );
540 assert( nlpcons == 0 || lplhs != NULL );
541 assert( nlpcons == 0 || lprhs != NULL );
542 assert( nlpcons == 0 || rownactivevars != NULL );
543 assert( lpnnonz >= 0 );
544 assert( nlpcons == 0 || lprow != NULL );
545 assert( nlpcons == 0 || lpcol != NULL );
546 assert( nlpcons == 0 || lpval != NULL );
550 if ( penaltyparam < sdpisolver->epsilon )
551 SCIPdebugMessage(
"Inserting Data into DSDP for SDP (%d) \n", ++sdpisolver->sdpcounter);
553 SCIPdebugMessage(
"Inserting Data again into DSDP for SDP (%d) \n", sdpisolver->sdpcounter);
557 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->inputtodsdpmapper), sdpisolver->nvars, nvars) );
558 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->dsdptoinputmapper), sdpisolver->nactivevars, nvars) );
559 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->fixedvarsval), sdpisolver->nvars - sdpisolver->nactivevars, nvars) );
561 sdpisolver->nvars = nvars;
562 sdpisolver->nactivevars = 0;
566 sdpisolver->fixedvarsobjcontr = 0.0;
567 for (i = 0; i < nvars; i++)
569 if (
isFixed(sdpisolver, lb[i], ub[i]) )
572 sdpisolver->inputtodsdpmapper[i] = -nfixedvars;
573 sdpisolver->fixedvarsobjcontr += obj[i] * lb[i];
574 sdpisolver->fixedvarsval[nfixedvars - 1] = lb[i];
575 SCIPdebugMessage(
"Fixing variable %d locally to %f for SDP %d in DSDP\n", i, lb[i], sdpisolver->sdpcounter);
579 sdpisolver->dsdptoinputmapper[sdpisolver->nactivevars] = i;
580 sdpisolver->nactivevars++;
581 sdpisolver->inputtodsdpmapper[i] = sdpisolver->nactivevars;
582 SCIPdebugMessage(
"Variable %d becomes variable %d for SDP %d in DSDP\n", i, sdpisolver->inputtodsdpmapper[i], sdpisolver->sdpcounter);
585 assert( sdpisolver->nactivevars + nfixedvars == sdpisolver->nvars );
586 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
588 SCIPdebugMessage(
"Variable %d is the slack variable for the explicit penalty formulation\n", sdpisolver->nactivevars + 1);
593 sdpisolver->fixedvarsobjcontr = 0.0;
596 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->fixedvarsval), nvars, nfixedvars) );
597 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->dsdptoinputmapper), nvars, sdpisolver->nactivevars) );
601 if ( sdpisolver->dsdp != NULL )
603 DSDP_CALL( DSDPDestroy(sdpisolver->dsdp) );
607 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
609 DSDP_CALLM( DSDPCreate(sdpisolver->nactivevars + 1, &(sdpisolver->dsdp)) );
610 sdpisolver->penaltyworbound = TRUE;
614 DSDP_CALLM( DSDPCreate(sdpisolver->nactivevars, &(sdpisolver->dsdp)) );
615 sdpisolver->penaltyworbound = FALSE;
617 DSDP_CALLM( DSDPCreateSDPCone(sdpisolver->dsdp, nsdpblocks - nremovedblocks, &(sdpisolver->sdpcone)) );
618 DSDP_CALLM( DSDPCreateLPCone(sdpisolver->dsdp, &(sdpisolver->lpcone)) );
619 DSDP_CALLM( DSDPCreateBCone(sdpisolver->dsdp, &(sdpisolver->bcone)) );
621 #ifdef SCIP_MORE_DEBUG
622 printf(
"setting objective values for SDP %d:\n", sdpisolver->sdpcounter);
624 for (i = 0; i < sdpisolver->nactivevars; i++)
629 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, i+1, -1.0 * obj[sdpisolver->dsdptoinputmapper[i]]) );
630 #ifdef SCIP_MORE_DEBUG
631 printf(
"var %d (was var %d): %f, ", i+1, sdpisolver->dsdptoinputmapper[i], obj[sdpisolver->dsdptoinputmapper[i]]);
636 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, i+1, 0.0) );
641 DSDP_CALL( BConeSetLowerBound(sdpisolver->bcone, i+1, lb[sdpisolver->dsdptoinputmapper[i]]) );
646 DSDP_CALL(BConeSetUpperBound(sdpisolver->bcone, i+1, ub[sdpisolver->dsdptoinputmapper[i]]));
651 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
653 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, sdpisolver->nactivevars + 1, -1.0 * penaltyparam) );
654 #ifdef SCIP_MORE_DEBUG
655 printf(
"slack variable r: %f, ", penaltyparam);
659 #ifdef SCIP_MORE_DEBUG
661 SCIPdebugMessage(
"ATTENTION: BConeView shows the WRONG sign for the lower bound!\n");
662 BConeView(sdpisolver->bcone);
666 for (block = 0; block < nsdpblocks; ++block)
669 if ( blockindchanges[block] > -1 )
672 DSDP_CALL( SDPConeSetBlockSize(sdpisolver->sdpcone, block- blockindchanges[block], sdpblocksizes[block] - nremovedinds[block]) );
690 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
693 for (block = 0; block < nsdpblocks; block++)
695 nrnonz += sdpblocksizes[block] - nremovedinds[block];
697 assert( nrnonz >= 0 );
700 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz + nrnonz) );
702 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz + nrnonz) );
707 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz) );
709 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz) );
714 for (block = 0; block < nsdpblocks; block++)
716 for (i = 0; i < sdpisolver->nactivevars; i++)
719 v = sdpisolver->dsdptoinputmapper[i];
723 for (k = 0; k < sdpnblockvars[block]; k++)
725 if ( v == sdpvar[block][k] )
736 for (k = 0; k < sdpnblockvarnonz[block][blockvar]; k++)
739 assert( indchanges[block][sdprow[block][blockvar][k]] > -1 && indchanges[block][sdpcol[block][blockvar][k]] > -1 );
742 dsdpind[ind] =
compLowerTriangPos(sdprow[block][blockvar][k] - indchanges[block][sdprow[block][blockvar][k]],
743 sdpcol[block][blockvar][k] - indchanges[block][sdpcol[block][blockvar][k]]);
744 dsdpval[ind] = -1.0 * sdpval[block][blockvar][k];
749 SCIPsortIntReal(dsdpind + startind, dsdpval + startind, sdpnblockvarnonz[block][blockvar]);
751 assert( blockindchanges[block] > -1 );
755 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], i + 1, sdpblocksizes[block] - nremovedinds[block],
756 1.0, 0, dsdpind + startind,dsdpval + startind, sdpnblockvarnonz[block][blockvar]));
760 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
764 for (block = 0; block < nsdpblocks; block++)
766 if ( blockindchanges[block] > -1 )
768 for (i = 0; i < sdpblocksizes[block] - nremovedinds[block]; i++)
774 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], sdpisolver->nactivevars + 1,
775 sdpblocksizes[block] - nremovedinds[block], 1.0, 0, dsdpind + ind - (sdpblocksizes[block] - nremovedinds[block]) ,
776 dsdpval + ind - (sdpblocksizes[block] - nremovedinds[block]), sdpblocksizes[block] - nremovedinds[block]) );
779 assert( ind - startind == nrnonz );
784 if ( sdpconstnnonz > 0 )
786 assert( nsdpblocks > 0 );
787 assert( sdpconstnblocknonz!= NULL );
788 assert( sdpconstcol != NULL );
789 assert( sdpconstrow != NULL );
790 assert( sdpconstval != NULL );
797 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpconstind, sdpconstnnonz) );
799 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpconstval, sdpconstnnonz) );
803 for (block = 0; block < nsdpblocks; block++)
807 if ( sdpconstnblocknonz[block] > 0 )
810 for (i = 0; i < sdpconstnblocknonz[block]; i++)
813 assert( indchanges[block][sdpconstrow[block][i]] > -1 && indchanges[block][sdpconstcol[block][i]] > -1 );
816 dsdpconstind[ind] =
compLowerTriangPos(sdpconstrow[block][i] - indchanges[block][sdpconstrow[block][i]],
817 sdpconstcol[block][i] - indchanges[block][sdpconstcol[block][i]]);
818 dsdpconstval[ind] = -1 * sdpconstval[block][i];
823 SCIPsortIntReal(dsdpconstind + startind, dsdpconstval + startind, sdpconstnblocknonz[block]);
825 assert( blockindchanges[block] > -1 );
829 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], 0, sdpblocksizes[block] - nremovedinds[block],
830 1.0, 0, dsdpconstind + startind, dsdpconstval + startind, ind - startind));
835 #ifdef SCIP_MORE_DEBUG
836 SDPConeView2(sdpisolver->sdpcone);
848 assert( noldlpcons > 0 );
849 assert( lprhs != NULL );
850 assert( lpcol != NULL );
851 assert( lprow != NULL );
852 assert( lpval != NULL );
855 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &rowmapper, 2*noldlpcons) );
860 for (i = 0; i < noldlpcons; i++)
862 if ( rownactivevars[i] >= 2 )
866 rowmapper[2*i] = pos;
873 rowmapper[2*i + 1] = pos;
877 rowmapper[2*i + 1] = -1;
884 rowmapper[2*i + 1] = -1;
888 assert( nlpineqs <= 2*nlpcons );
895 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
897 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 3) );
901 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 2) );
910 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
912 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, 2 * nlpineqs + 2*lpnnonz) );
916 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, nlpineqs + 2*lpnnonz) );
921 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
923 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs) );
927 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars) );
939 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
941 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, 2 * nlpineqs + 2*lpnnonz) );
945 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, nlpineqs + 2*lpnnonz) );
950 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
952 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs) );
956 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars) );
964 for (i = 0; i < nlpcons; i++)
968 if ( REALABS(lplhs[i]) > sdpisolver->epsilon )
970 dsdplprow[dsdpnlpnonz] = pos;
971 dsdplpval[dsdpnlpnonz] = -lplhs[i];
978 if ( REALABS(lprhs[i]) > sdpisolver->epsilon )
980 dsdplprow[dsdpnlpnonz] = pos;
981 dsdplpval[dsdpnlpnonz] = lprhs[i];
987 assert( pos == nlpineqs );
992 if ( REALABS(sdpisolver->objlimit) > sdpisolver->epsilon )
994 dsdplprow[dsdpnlpnonz] = nlpcons;
995 dsdplpval[dsdpnlpnonz] = sdpisolver->objlimit;
1007 dsdplpbegcol[0] = 0;
1008 for (i = 0; i < lpnnonz; i++)
1011 if ( lpcol[i] >= nextcol )
1016 for (j = nextcol; j <= lpcol[i]; j++)
1018 if ( sdpisolver->inputtodsdpmapper[j] >= 0 )
1020 assert( ! (
isFixed(sdpisolver, lb[j], ub[j])) );
1021 dsdplpbegcol[sdpisolver->inputtodsdpmapper[j]] = dsdpnlpnonz;
1026 dsdplprow[dsdpnlpnonz] = nlpcons;
1027 dsdplpval[dsdpnlpnonz] = obj[j];
1035 if ( !
isFixed(sdpisolver, lb[lpcol[i]], ub[lpcol[i]]) )
1038 if ( rowmapper[2*lprow[i]] > -1 )
1042 dsdplprow[dsdpnlpnonz] = rowmapper[2*lprow[i]];
1043 dsdplpval[dsdpnlpnonz] = -lpval[i];
1047 if ( rowmapper[2*lprow[i] + 1] > -1 )
1051 dsdplprow[dsdpnlpnonz] = rowmapper[2*lprow[i] + 1];
1052 dsdplpval[dsdpnlpnonz] = lpval[i];
1059 assert(
isFixed(sdpisolver, lb[lpcol[i]], ub[lpcol[i]]) || rownactivevars[lprow[i]] == 1 );
1064 for (j = nextcol; j < nvars; j++)
1066 if ( sdpisolver->inputtodsdpmapper[j] >= 0 )
1068 assert( ! (
isFixed(sdpisolver, lb[j], ub[j])) );
1069 dsdplpbegcol[sdpisolver->inputtodsdpmapper[j]] = dsdpnlpnonz;
1073 dsdplprow[dsdpnlpnonz] = nlpcons;
1074 dsdplpval[dsdpnlpnonz] = obj[j];
1080 dsdplpbegcol[sdpisolver->nactivevars + 1] = dsdpnlpnonz;
1083 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1085 for (i = 0; i < nlpineqs; i++)
1087 dsdplprow[dsdpnlpnonz] = i;
1088 dsdplpval[dsdpnlpnonz] = -1.0;
1091 dsdplpbegcol[sdpisolver->nactivevars + 2] = dsdpnlpnonz;
1095 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &rowmapper, 2*noldlpcons);
1100 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1102 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, 2*nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1103 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, 2*nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1107 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1108 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1113 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1115 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs, dsdpnlpnonz) );
1116 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs, dsdpnlpnonz) );
1120 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars, dsdpnlpnonz) );
1121 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars, dsdpnlpnonz) );
1128 DSDP_CALL( LPConeSetData(sdpisolver->lpcone, nlpineqs, dsdplpbegcol, dsdplprow, dsdplpval) );
1132 DSDP_CALL( LPConeSetData(sdpisolver->lpcone, nlpineqs + 1, dsdplpbegcol, dsdplprow, dsdplpval) );
1134 #ifdef SCIP_MORE_DEBUG
1135 LPConeView(sdpisolver->lpcone);
1139 SCIPdebugMessage(
"Calling DSDP-Solve for SDP (%d) \n", sdpisolver->sdpcounter);
1141 DSDP_CALL( DSDPSetGapTolerance(sdpisolver->dsdp, sdpisolver->epsilon) );
1142 DSDP_CALL( DSDPSetRTolerance(sdpisolver->dsdp, sdpisolver->feastol) );
1143 if ( sdpisolver-> sdpinfo )
1145 DSDP_CALL( DSDPSetStandardMonitor(sdpisolver->dsdp, 1) );
1149 if ( penaltyparam >= sdpisolver->epsilon && rbound )
1151 DSDP_CALL( DSDPSetPenaltyParameter(sdpisolver->dsdp, penaltyparam) );
1152 DSDP_CALL( DSDPUsePenalty(sdpisolver->dsdp, 1) );
1156 if ( start != NULL )
1158 for (i = 1; i <= sdpisolver->nactivevars; i++)
1160 DSDP_CALL( DSDPSetY0(sdpisolver->dsdp, i, start[sdpisolver->dsdptoinputmapper[i]]) );
1166 DSDP_CALL( DSDPSolve(sdpisolver->dsdp) );
1168 DSDP_CALL( DSDPComputeX(sdpisolver->dsdp) );
1169 sdpisolver->solved = TRUE;
1172 if ( sdpconstnnonz > 0 )
1174 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpconstval, sdpconstnnonz);
1175 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpconstind, sdpconstnnonz);
1180 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1182 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz + nrnonz);
1183 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz + nrnonz);
1187 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz);
1188 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz);
1192 if ( nlpcons > 0 || lpnnonz > 0 )
1194 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, dsdpnlpnonz);
1195 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, dsdpnlpnonz);
1196 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1198 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 3);
1202 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 2);
1207 DSDP_CALL(DSDPStopReason(sdpisolver->dsdp, &reason));
1211 case DSDP_CONVERGED:
1212 SCIPdebugMessage(
"DSDP converged!\n");
1215 case DSDP_INFEASIBLE_START:
1216 SCIPdebugMessage(
"DSDP started with an infeasible point!\n");
1219 case DSDP_SMALL_STEPS:
1220 SCIPdebugMessage(
"Short step lengths created by numerical difficulties prevented progress in DSDP!\n");
1223 case DSDP_INDEFINITE_SCHUR_MATRIX:
1224 SCIPdebugMessage(
"Schur Matrix in DSDP was indefinite but should have been positive semidefinite!\n");
1228 SCIPdebugMessage(
"DSDP reached maximum number of iterations!\n");
1231 case DSDP_NUMERICAL_ERROR:
1232 SCIPdebugMessage(
"A numerical error occured in DSDP!\n");
1235 case DSDP_UPPERBOUND:
1236 SCIPdebugMessage(
"Dual objective value in DSDP reached upper bound.\n");
1239 case DSDP_USER_TERMINATION:
1240 SCIPdebugMessage(
"DSDP didn't stop solving, did you?\n");
1243 case CONTINUE_ITERATING:
1244 SCIPdebugMessage(
"DSDP wants to continue iterating but somehow was stopped!\n");
1248 SCIPdebugMessage(
"Unknown stopping reason in DSDP!\n");
1253 if ( penaltyparam >= sdpisolver->epsilon )
1260 DSDP_CALL( DSDPGetR(sdpisolver->dsdp, &rval) );
1262 *feasorig = (rval < sdpisolver->feastol );
1265 SCIPdebugMessage(
"Solution not feasible in original problem, r = %f\n", rval);
1272 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, sdpisolver->nactivevars + 1) );
1274 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, sdpisolver->nactivevars + 1) );
1276 *feasorig = (dsdpsol[sdpisolver->nactivevars] < sdpisolver->feastol);
1279 SCIPdebugMessage(
"Solution not feasible in original problem, r = %f\n", dsdpsol[sdpisolver->nactivevars]);
1282 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, sdpisolver->nactivevars + 1);
1305 assert( sdpisolver != NULL );
1306 return sdpisolver->solved;
1319 DSDPSolutionType pdfeasible;
1321 assert( sdpisolver != NULL );
1324 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1326 if ( pdfeasible == DSDP_PDUNKNOWN )
1335 SCIP_Bool* primalfeasible,
1336 SCIP_Bool* dualfeasible
1339 DSDPSolutionType pdfeasible;
1341 assert( sdpisolver != NULL );
1342 assert( primalfeasible != NULL );
1343 assert( dualfeasible != NULL );
1346 DSDP_CALL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1348 switch ( pdfeasible )
1350 case DSDP_PDFEASIBLE:
1351 *primalfeasible = TRUE;
1352 *dualfeasible = TRUE;
1355 case DSDP_UNBOUNDED:
1356 *primalfeasible = FALSE;
1357 *dualfeasible = TRUE;
1360 case DSDP_INFEASIBLE:
1361 *primalfeasible = TRUE;
1362 *dualfeasible = FALSE;
1366 SCIPerrorMessage(
"DSDP doesn't know if primal and dual solutions are feasible\n");
1367 return SCIP_LPERROR;
1379 DSDPSolutionType pdfeasible;
1381 assert( sdpisolver != NULL );
1384 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1385 if ( pdfeasible == DSDP_PDUNKNOWN )
1390 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible.");
1393 else if ( pdfeasible == DSDP_INFEASIBLE )
1405 DSDPSolutionType pdfeasible;
1407 assert( sdpisolver != NULL );
1410 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1411 if ( pdfeasible == DSDP_PDUNKNOWN )
1416 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1419 else if ( pdfeasible == DSDP_UNBOUNDED )
1431 DSDPSolutionType pdfeasible;
1433 assert( sdpisolver != NULL );
1436 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1437 if ( pdfeasible == DSDP_PDUNKNOWN )
1439 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1442 else if ( pdfeasible == DSDP_UNBOUNDED )
1454 DSDPSolutionType pdfeasible;
1456 assert( sdpisolver != NULL );
1459 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1460 if ( pdfeasible == DSDP_PDUNKNOWN )
1462 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1465 else if ( pdfeasible == DSDP_UNBOUNDED )
1477 DSDPSolutionType pdfeasible;
1479 assert( sdpisolver != NULL );
1482 DSDP_CALL_BOOL(DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible));
1484 if ( pdfeasible == DSDP_PDUNKNOWN )
1486 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1489 else if ( pdfeasible == DSDP_INFEASIBLE )
1501 DSDPSolutionType pdfeasible;
1503 assert( sdpisolver != NULL );
1506 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1508 if ( pdfeasible == DSDP_PDUNKNOWN )
1510 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1513 else if ( pdfeasible == DSDP_INFEASIBLE )
1524 DSDPTerminationReason reason;
1526 assert( sdpisolver != NULL );
1531 if ( reason == DSDP_CONVERGED )
1542 SCIPdebugMessage(
"Method not implemented for DSDP, as objective limit is given as an ordinary LP-constraint, so in case the objective limit was "
1543 "exceeded, the problem will be reported as infeasible ! \n");
1553 DSDPTerminationReason reason;
1555 assert( sdpisolver != NULL );
1560 if ( reason == DSDP_MAX_IT )
1571 SCIPdebugMessage(
"Not implemented in DSDP!\n");
1572 return SCIP_LPERROR;
1589 DSDPTerminationReason reason;
1592 assert( sdpisolver != NULL );
1594 if ( sdpisolver->dsdp == NULL || (! sdpisolver->solved) )
1597 dsdpreturn = DSDPStopReason(sdpisolver->dsdp, &reason);
1599 if (dsdpreturn != 0)
1601 SCIPerrorMessage(
"DSDP-Error <%d> in function call.\n", dsdpreturn);
1607 case DSDP_CONVERGED:
1610 case DSDP_INFEASIBLE_START:
1613 case DSDP_SMALL_STEPS:
1616 case DSDP_INDEFINITE_SCHUR_MATRIX:
1622 case DSDP_NUMERICAL_ERROR:
1625 case DSDP_UPPERBOUND:
1628 case DSDP_USER_TERMINATION:
1641 assert( sdpisolver != NULL );
1651 assert( sdpisolver != NULL );
1665 SCIPdebugMessage(
"Not implemented yet\n");
1666 return SCIP_LPERROR;
1675 assert( sdpisolver != NULL );
1676 assert( objval != NULL );
1679 DSDP_CALL( DSDPGetDObjective(sdpisolver->dsdp, objval) );
1680 *objval = -1*(*objval);
1683 *objval += sdpisolver->fixedvarsobjcontr;
1704 assert( sdpisolver != NULL );
1705 assert( dualsollength != NULL );
1708 dsdpnvars = sdpisolver->penaltyworbound ? sdpisolver->nactivevars + 1 : sdpisolver->nactivevars;
1710 if ( objval != NULL )
1712 DSDP_CALL( DSDPGetDObjective(sdpisolver->dsdp, objval) );
1716 *objval += sdpisolver->fixedvarsobjcontr;
1719 if ( *dualsollength > 0 )
1721 assert( dualsol != NULL );
1722 if ( *dualsollength < sdpisolver->nvars )
1724 SCIPdebugMessage(
"The given array in SCIPsdpiSolverGetSol only had length %d, but %d was needed", *dualsollength, sdpisolver->nvars);
1725 *dualsollength = sdpisolver->nvars;
1730 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars) );
1731 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, dsdpnvars) );
1734 for (v = 0; v < sdpisolver->nvars; v++)
1736 if (sdpisolver->inputtodsdpmapper[v] > -1)
1739 dualsol[v] = dsdpsol[sdpisolver->inputtodsdpmapper[v] - 1];
1744 dualsol[v] = sdpisolver->fixedvarsval[(-1 * sdpisolver->inputtodsdpmapper[v]) - 1];
1747 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars);
1771 assert( sdpisolver != NULL );
1772 assert( lbvars != NULL );
1773 assert( ubvars != NULL );
1774 assert( arraylength != NULL );
1775 assert( *arraylength >= 0 );
1779 if ( *arraylength < sdpisolver->nvars )
1781 *arraylength = sdpisolver->nvars;
1782 SCIPdebugMessage(
"Insufficient length of array in SCIPsdpiSolverGetPrimalBoundVars (gave %d, needed %d)\n", *arraylength, sdpisolver->nvars);
1787 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &lbvarsdsdp, sdpisolver->nactivevars) );
1788 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &ubvarsdsdp, sdpisolver->nactivevars) );
1791 DSDP_CALL( BConeCopyX(sdpisolver->bcone, lbvarsdsdp, ubvarsdsdp, sdpisolver->nactivevars) );
1794 for (i = 0; i < sdpisolver->nvars; i++)
1796 if ( sdpisolver->inputtodsdpmapper[i] < 0 )
1805 lbvars[i] = lbvarsdsdp[sdpisolver->inputtodsdpmapper[i] - 1];
1806 ubvars[i] = ubvarsdsdp[sdpisolver->inputtodsdpmapper[i] - 1];
1811 BMSfreeBlockMemoryArrayNull(sdpisolver->blkmem, &ubvarsdsdp, sdpisolver->nactivevars);
1812 BMSfreeBlockMemoryArrayNull(sdpisolver->blkmem, &lbvarsdsdp, sdpisolver->nactivevars);
1823 assert( sdpisolver != NULL );
1824 assert( iterations != NULL );
1827 DSDP_CALL( DSDPGetIts(sdpisolver->dsdp, iterations) );
1884 assert( sdpisolver != NULL );
1885 assert( dval != NULL );
1890 *dval = sdpisolver->epsilon;
1893 *dval = sdpisolver->feastol;
1896 *dval = sdpisolver->objlimit;
1899 return SCIP_PARAMETERUNKNOWN;
1912 assert( sdpisolver != NULL );
1917 sdpisolver->epsilon = dval;
1918 SCIPdebugMessage(
"Setting sdpisolver epsilon to %f.\n", dval);
1921 sdpisolver->feastol = dval;
1922 SCIPdebugMessage(
"Setting sdpisolver feastol to %f.\n", dval);
1927 SCIPdebugMessage(
"Setting sdpisolver objlimit to %f.\n", dval);
1928 sdpisolver->objlimit = dval;
1931 return SCIP_PARAMETERUNKNOWN;
1944 assert( sdpisolver != NULL );
1949 *ival = sdpisolver->sdpinfo;
1950 SCIPdebugMessage(
"Getting sdpisolver information output (%d).\n", *ival);
1953 return SCIP_PARAMETERUNKNOWN;
1966 assert( sdpisolver != NULL );
1971 sdpisolver->sdpinfo = (SCIP_Bool) ival;
1972 SCIPdebugMessage(
"Setting sdpisolver information output (%d).\n", ival);
1975 return SCIP_PARAMETERUNKNOWN;
1999 SCIPdebugMessage(
"Not implemented yet\n");
2000 return SCIP_LPERROR;
2009 SCIPdebugMessage(
"Not implemented yet\n");
2010 return SCIP_LPERROR;
SCIP_Bool SCIPsdpiSolverIsConverged(SCIP_SDPISOLVER *sdpisolver)
int SCIPsdpiSolverGetInternalStatus(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsPrimalFeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsPrimalUnbounded(SCIP_SDPISOLVER *sdpisolver)
SCIP_Real SCIPsdpiSolverMaxPenParam(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsObjlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsDualFeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSolverGetSol(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval, SCIP_Real *dualsol, int *dualsollength)
SCIP_Real SCIPsdpiSolverInfinity(SCIP_SDPISOLVER *sdpisolver)
static SCIP_Bool isFixed(SCIP_SDPISOLVER *sdpisolver, SCIP_Real lb, SCIP_Real ub)
const char * SCIPsdpiSolverGetSolverDesc(void)
#define CHECK_IF_SOLVED_BOOL(sdpisolver)
SCIP_RETCODE SCIPsdpiSolverGetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int *ival)
#define DSDP_CALL_BOOL(x)
interface methods for specific SDP solvers
SCIP_RETCODE SCIPsdpiSolverResetCounter(SCIP_SDPISOLVER *sdpisolver)
void * SCIPsdpiSolverGetSolverPointer(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSolverGetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real *dval)
SCIP_Bool SCIPsdpiSolverIsInfinity(SCIP_SDPISOLVER *sdpisolver, SCIP_Real val)
SCIP_RETCODE SCIPsdpiSolverSetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real dval)
SCIP_Bool SCIPsdpiSolverIsPrimalInfeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSolverGetSolFeasibility(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPsdpiSolverFree(SCIP_SDPISOLVER **sdpisolver)
#define CHECK_IF_SOLVED(sdpisolver)
static void sortColRow(int *row, int *col, SCIP_Real *val, int length)
SCIP_Bool SCIPsdpiSolverIsDualUnbounded(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverFeasibilityKnown(SCIP_SDPISOLVER *sdpisolver)
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 SCIPsdpiSolverGetObjval(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval)
const char * SCIPsdpiSolverGetSolverName(void)
SCIP_Bool SCIPsdpiSolverIsGEMaxPenParam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real val)
SCIP_RETCODE SCIPsdpiSolverSetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int ival)
SCIP_Bool SCIPsdpiSolverIsIterlimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSolverGetPrimalBoundVars(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
SCIP_RETCODE SCIPsdpiSolverIncreaseCounter(SCIP_SDPISOLVER *sdpisolver)
static int compLowerTriangPos(int i, int j)
SCIP_Bool SCIPsdpiSolverIsTimelimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverWasSolved(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSolverCreate(SCIP_SDPISOLVER **sdpisolver, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPsdpiSolverIgnoreInstability(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *success)
struct SCIP_SDPiSolver SCIP_SDPISOLVER
SCIP_Bool SCIPsdpiSolverIsOptimal(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsAcceptable(SCIP_SDPISOLVER *sdpisolver)
enum SCIP_SDPParam SCIP_SDPPARAM
SCIP_Bool SCIPsdpiSolverIsDualInfeasible(SCIP_SDPISOLVER *sdpisolver)
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)
SCIP_RETCODE SCIPsdpiSolverWriteSDP(SCIP_SDPISOLVER *sdpisolver, const char *fname)
SCIP_RETCODE SCIPsdpiSolverReadSDP(SCIP_SDPISOLVER *sdpisolver, const char *fname)
SCIP_RETCODE SCIPsdpiSolverGetIterations(SCIP_SDPISOLVER *sdpisolver, int *iterations)