47 #pragma GCC diagnostic ignored "-Wstrict-prototypes"
49 #pragma GCC diagnostic warning "-Wstrict-prototypes"
52 #include "blockmemshell/memory.h"
54 #include "scip/pub_misc.h"
59 #define PENALTYBOUNDTOL 1E-3
62 #define MIN_PENALTYPARAM 1e5
63 #define MAX_PENALTYPARAM 1e12
64 #define PENALTYPARAM_FACTOR 1e4
65 #define MAX_MAXPENALTYPARAM 1e15
66 #define MAXPENALTYPARAM_FACTOR 1e6
69 #define DSDP_CALL(x) do \
71 int _dsdperrorcode_; \
72 if ( (_dsdperrorcode_ = (x)) != 0 ) \
74 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
75 return SCIP_LPERROR; \
81 #define DSDP_CALL_BOOL(x) do \
83 int _dsdperrorcode_; \
84 if ( (_dsdperrorcode_ = (x)) != 0 ) \
86 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
93 #define DSDP_CALLM(x) do \
95 int _dsdperrorcode_; \
96 if ( (_dsdperrorcode_ = (x)) != 0 ) \
98 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
99 return SCIP_NOMEMORY; \
105 #define BMS_CALL(x) do \
109 SCIPerrorMessage("No memory in function call.\n"); \
110 return SCIP_NOMEMORY; \
116 #define TIMEOFDAY_CALL(x) do \
119 if ( (_errorcode_ = (x)) != 0 ) \
121 SCIPerrorMessage("Error in gettimeofday! \n"); \
128 #define CHECK_IF_SOLVED(sdpisolver) do \
130 if (!(sdpisolver->solved)) \
132 SCIPerrorMessage("Tried to access solution information for SDP %d ahead of solving!\n", sdpisolver->sdpcounter); \
133 return SCIP_LPERROR; \
139 #define CHECK_IF_SOLVED_BOOL(sdpisolver) do \
141 if (!(sdpisolver->solved)) \
143 SCIPerrorMessage("Tried to access solution information for SDP %d ahead of solving!\n", sdpisolver->sdpcounter); \
151 struct SCIP_SDPiSolver
153 SCIP_MESSAGEHDLR* messagehdlr;
161 int* inputtodsdpmapper;
164 int* dsdptoinputmapper;
165 SCIP_Real* fixedvarsval;
166 SCIP_Real fixedvarsobjcontr;
171 SCIP_Real penaltyparam;
174 SCIP_Bool penaltyworbound;
177 SCIP_Bool timelimitinitial;
182 struct timeval starttime;
204 return i*(i+1)/2 + j;
216 assert( lb < ub + sdpisolver->feastol );
218 return (REALABS(ub-lb) <= sdpisolver->feastol);
221 #define isFixed(sdpisolver,lb,ub) (REALABS(ub-lb) <= sdpisolver->feastol)
237 SCIPsortIntIntReal(col, row, val, length);
240 while (nextentry < length)
242 firstentry = nextentry;
244 while (nextentry < length && col[nextentry] == col[firstentry])
248 SCIPsortIntReal(row + firstentry, val + firstentry, nextentry - firstentry);
260 struct timeval currenttime;
261 SCIP_Real startseconds;
262 SCIP_Real currentseconds;
263 SCIP_Real elapsedtime;
265 assert( dsdp != NULL );
266 assert( ctx != NULL );
270 startseconds = (SCIP_Real) (timings->starttime).tv_sec + (SCIP_Real) (timings->starttime).tv_usec / 1e6;
273 currentseconds = (SCIP_Real) currenttime.tv_sec + (SCIP_Real) currenttime.tv_usec / 1e6;
275 elapsedtime = currentseconds - startseconds;
277 if ( elapsedtime > timings->timelimit )
279 DSDP_CALL( DSDPSetConvergenceFlag(dsdp, DSDP_USER_TERMINATION) );
280 timings->stopped = TRUE;
281 SCIPdebugMessage(
"Time limit reached! Stopping DSDP.\n");
309 return "Dual-Scaling Interior Point SDP-Solver by S. Benson, Y. Ye, and X. Zhang (http://www.mcs.anl.gov/hs/software/DSDP/)";
322 assert( sdpisolver != NULL );
323 return (
void*) sdpisolver->dsdp;
339 SCIP_MESSAGEHDLR* messagehdlr,
343 assert( sdpisolver != NULL );
344 assert( blkmem != NULL );
346 SCIPdebugMessage(
"Calling SCIPsdpiCreate \n");
348 BMS_CALL( BMSallocBlockMemory(blkmem, sdpisolver) );
350 (*sdpisolver)->messagehdlr = messagehdlr;
351 (*sdpisolver)->blkmem = blkmem;
355 (*sdpisolver)->dsdp = NULL;
356 (*sdpisolver)->sdpcone = NULL;
357 (*sdpisolver)->lpcone = NULL;
358 (*sdpisolver)->bcone = NULL;
360 (*sdpisolver)->nvars = 0;
361 (*sdpisolver)->nactivevars = 0;
362 (*sdpisolver)->inputtodsdpmapper = NULL;
363 (*sdpisolver)->dsdptoinputmapper = NULL;
364 (*sdpisolver)->fixedvarsval = NULL;
365 (*sdpisolver)->fixedvarsobjcontr = 0.0;
366 (*sdpisolver)->solved = FALSE;
367 (*sdpisolver)->timelimit = FALSE;
368 (*sdpisolver)->timelimitinitial = FALSE;
369 (*sdpisolver)->sdpcounter = 0;
371 (*sdpisolver)->epsilon = 1e-4;
372 (*sdpisolver)->feastol = 1e-6;
373 (*sdpisolver)->penaltyparam = 1e5;
375 (*sdpisolver)->sdpinfo = FALSE;
386 assert( sdpisolver != NULL );
387 assert( *sdpisolver != NULL );
389 SCIPdebugMessage(
"Freeing SDPISolver\n");
391 if ( (*sdpisolver)->dsdp != NULL )
393 DSDP_CALL( DSDPDestroy((*sdpisolver)->dsdp) );
396 if ( (*sdpisolver)->nvars > 0 )
397 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->inputtodsdpmapper, (*sdpisolver)->nvars);
399 if ( (*sdpisolver)->nactivevars > 0 )
400 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->dsdptoinputmapper, (*sdpisolver)->nactivevars);
402 if ( (*sdpisolver)->nvars >= (*sdpisolver)->nactivevars )
403 BMSfreeBlockMemoryArrayNull((*sdpisolver)->blkmem, &(*sdpisolver)->fixedvarsval, (*sdpisolver)->nvars - (*sdpisolver)->nactivevars);
405 BMSfreeBlockMemory((*sdpisolver)->blkmem, sdpisolver);
415 assert( sdpisolver != NULL );
417 sdpisolver->sdpcounter++;
427 assert( sdpisolver != NULL );
429 SCIPdebugMessage(
"Resetting counter of SDP-Interface from %d to 0.\n", sdpisolver->sdpcounter);
430 sdpisolver->sdpcounter = 0;
467 int* sdpconstnblocknonz,
471 SCIP_Real** sdpconstval,
473 int** sdpnblockvarnonz,
483 int* blockindchanges,
500 return SCIPsdpiSolverLoadAndSolveWithPenalty(sdpisolver, 0.0, TRUE, TRUE, nvars, obj, lb, ub, nsdpblocks, sdpblocksizes, sdpnblockvars,
501 sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, sdpnnonz, sdpnblockvarnonz, sdpvar, sdprow, sdpcol, sdpval,
502 indchanges, nremovedinds, blockindchanges, nremovedblocks, nlpcons, noldlpcons, lplhs, lprhs, rownactivevars, lpnnonz, lprow, lpcol,
503 lpval, start, startsettings, timelimit, NULL, NULL);
527 SCIP_Real penaltyparam,
538 int* sdpconstnblocknonz,
542 SCIP_Real** sdpconstval,
544 int** sdpnblockvarnonz,
554 int* blockindchanges,
571 SCIP_Bool* penaltybound
575 int* dsdpconstind = NULL;
576 SCIP_Real* dsdpconstval = NULL;
578 SCIP_Real* dsdpval = NULL;
579 int* dsdplpbegcol = NULL;
580 int* dsdplprow = NULL;
581 SCIP_Real* dsdplpval = NULL;
593 DSDPTerminationReason reason;
596 assert( sdpisolver != NULL );
597 assert( penaltyparam > -1 * sdpisolver->epsilon );
598 assert( penaltyparam < sdpisolver->epsilon || ( feasorig != NULL ) );
600 assert( obj != NULL );
601 assert( lb != NULL );
602 assert( ub != NULL );
603 assert( nsdpblocks >= 0 );
604 assert( nsdpblocks == 0 || sdpblocksizes != NULL );
605 assert( nsdpblocks == 0 || sdpnblockvars != NULL );
606 assert( sdpconstnnonz >= 0 );
607 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstnblocknonz != NULL );
608 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstrow != NULL );
609 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstcol != NULL );
610 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstval != NULL );
611 assert( sdpnnonz >= 0 );
612 assert( nsdpblocks == 0 || sdpnblockvarnonz != NULL );
613 assert( nsdpblocks == 0 || sdpvar != NULL );
614 assert( nsdpblocks == 0 || sdprow != NULL );
615 assert( nsdpblocks == 0 || sdpcol != NULL );
616 assert( nsdpblocks == 0 || sdpval != NULL );
617 assert( nsdpblocks == 0 || indchanges != NULL );
618 assert( nsdpblocks == 0 || nremovedinds != NULL );
619 assert( nsdpblocks == 0 || blockindchanges != NULL );
620 assert( 0 <= nremovedblocks && nremovedblocks <= nsdpblocks );
621 assert( nlpcons >= 0 );
622 assert( noldlpcons >= nlpcons );
623 assert( nlpcons == 0 || lplhs != NULL );
624 assert( nlpcons == 0 || lprhs != NULL );
625 assert( nlpcons == 0 || rownactivevars != NULL );
626 assert( lpnnonz >= 0 );
627 assert( nlpcons == 0 || lprow != NULL );
628 assert( nlpcons == 0 || lpcol != NULL );
629 assert( nlpcons == 0 || lpval != NULL );
631 if ( timelimit <= 0.0 )
633 sdpisolver->timelimit = TRUE;
634 sdpisolver->timelimitinitial = TRUE;
635 sdpisolver->solved = FALSE;
639 sdpisolver->timelimitinitial = FALSE;
643 timings.timelimit = timelimit;
644 timings.stopped = FALSE;
648 if ( penaltyparam < sdpisolver->epsilon )
650 SCIPdebugMessage(
"Inserting Data into DSDP for SDP (%d) \n", ++sdpisolver->sdpcounter);
655 SCIPdebugMessage(
"Inserting Data again into DSDP for SDP (%d) \n", sdpisolver->sdpcounter);
661 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->inputtodsdpmapper), sdpisolver->nvars, nvars) );
662 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->dsdptoinputmapper), sdpisolver->nactivevars, nvars) );
663 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->fixedvarsval), sdpisolver->nvars - sdpisolver->nactivevars, nvars) );
665 sdpisolver->nvars = nvars;
666 sdpisolver->nactivevars = 0;
670 sdpisolver->fixedvarsobjcontr = 0.0;
671 for (i = 0; i < nvars; i++)
673 if (
isFixed(sdpisolver, lb[i], ub[i]) )
676 sdpisolver->inputtodsdpmapper[i] = -nfixedvars;
677 sdpisolver->fixedvarsobjcontr += obj[i] * lb[i];
678 sdpisolver->fixedvarsval[nfixedvars - 1] = lb[i];
679 SCIPdebugMessage(
"Fixing variable %d locally to %f for SDP %d in DSDP\n", i, lb[i], sdpisolver->sdpcounter);
683 sdpisolver->dsdptoinputmapper[sdpisolver->nactivevars] = i;
684 sdpisolver->nactivevars++;
685 sdpisolver->inputtodsdpmapper[i] = sdpisolver->nactivevars;
686 SCIPdebugMessage(
"Variable %d becomes variable %d for SDP %d in DSDP\n", i, sdpisolver->inputtodsdpmapper[i], sdpisolver->sdpcounter);
689 assert( sdpisolver->nactivevars + nfixedvars == sdpisolver->nvars );
690 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
692 SCIPdebugMessage(
"Variable %d is the slack variable for the explicit penalty formulation\n", sdpisolver->nactivevars + 1);
697 sdpisolver->fixedvarsobjcontr = 0.0;
700 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->fixedvarsval), nvars, nfixedvars) );
701 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->dsdptoinputmapper), nvars, sdpisolver->nactivevars) );
705 if ( sdpisolver->dsdp != NULL )
707 DSDP_CALL( DSDPDestroy(sdpisolver->dsdp) );
711 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
713 DSDP_CALLM( DSDPCreate(sdpisolver->nactivevars + 1, &(sdpisolver->dsdp)) );
714 sdpisolver->penaltyworbound = TRUE;
718 DSDP_CALLM( DSDPCreate(sdpisolver->nactivevars, &(sdpisolver->dsdp)) );
719 sdpisolver->penaltyworbound = FALSE;
721 DSDP_CALLM( DSDPCreateSDPCone(sdpisolver->dsdp, nsdpblocks - nremovedblocks, &(sdpisolver->sdpcone)) );
722 DSDP_CALLM( DSDPCreateLPCone(sdpisolver->dsdp, &(sdpisolver->lpcone)) );
723 DSDP_CALLM( DSDPCreateBCone(sdpisolver->dsdp, &(sdpisolver->bcone)) );
725 #ifdef SCIP_MORE_DEBUG
726 SCIPmessagePrintInfo(sdpi->messagehdlr,
"setting objective values for SDP %d:\n", sdpisolver->sdpcounter);
729 for (i = 0; i < sdpisolver->nactivevars; i++)
734 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, i+1, -1.0 * obj[sdpisolver->dsdptoinputmapper[i]]) );
735 #ifdef SCIP_MORE_DEBUG
736 SCIPmessagePrintInfo(sdpi->messagehdlr,
"var %d (was var %d): %f, ", i+1, sdpisolver->dsdptoinputmapper[i], obj[sdpisolver->dsdptoinputmapper[i]]);
741 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, i+1, 0.0) );
747 DSDP_CALL( BConeSetLowerBound(sdpisolver->bcone, i+1, lb[sdpisolver->dsdptoinputmapper[i]]) );
753 DSDP_CALL(BConeSetUpperBound(sdpisolver->bcone, i+1, ub[sdpisolver->dsdptoinputmapper[i]]));
758 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
760 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, sdpisolver->nactivevars + 1, -1.0 * penaltyparam) );
761 #ifdef SCIP_MORE_DEBUG
762 SCIPmessagePrintInfo(sdpi->messagehdlr,
"slack variable r: %f, ", penaltyparam);
766 #ifdef SCIP_MORE_DEBUG
767 SCIPmessagePrintInfo(sdpi->messagehdlr,
"\n");
768 SCIPdebugMessage(
"ATTENTION: BConeView shows the WRONG sign for the lower bound!\n");
769 BConeView(sdpisolver->bcone);
773 for (block = 0; block < nsdpblocks; ++block)
776 if ( blockindchanges[block] > -1 )
779 DSDP_CALL( SDPConeSetBlockSize(sdpisolver->sdpcone, block- blockindchanges[block], sdpblocksizes[block] - nremovedinds[block]) );
797 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
800 for (block = 0; block < nsdpblocks; block++)
801 nrnonz += sdpblocksizes[block] - nremovedinds[block];
802 assert( nrnonz >= 0 );
805 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz + nrnonz) );
807 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz + nrnonz) );
812 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz) );
814 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz) );
819 for (block = 0; block < nsdpblocks; block++)
821 for (i = 0; i < sdpisolver->nactivevars; i++)
824 v = sdpisolver->dsdptoinputmapper[i];
828 for (k = 0; k < sdpnblockvars[block]; k++)
830 if ( v == sdpvar[block][k] )
841 for (k = 0; k < sdpnblockvarnonz[block][blockvar]; k++)
844 assert( indchanges[block][sdprow[block][blockvar][k]] > -1 && indchanges[block][sdpcol[block][blockvar][k]] > -1 );
847 dsdpind[ind] =
compLowerTriangPos(sdprow[block][blockvar][k] - indchanges[block][sdprow[block][blockvar][k]],
848 sdpcol[block][blockvar][k] - indchanges[block][sdpcol[block][blockvar][k]]);
849 dsdpval[ind] = -1.0 * sdpval[block][blockvar][k];
854 SCIPsortIntReal(dsdpind + startind, dsdpval + startind, sdpnblockvarnonz[block][blockvar]);
856 assert( blockindchanges[block] > -1 );
860 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], i + 1, sdpblocksizes[block] - nremovedinds[block],
861 1.0, 0, dsdpind + startind,dsdpval + startind, sdpnblockvarnonz[block][blockvar]));
866 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
870 for (block = 0; block < nsdpblocks; block++)
872 if ( blockindchanges[block] > -1 )
874 for (i = 0; i < sdpblocksizes[block] - nremovedinds[block]; i++)
880 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], sdpisolver->nactivevars + 1,
881 sdpblocksizes[block] - nremovedinds[block], 1.0, 0, dsdpind + ind - (sdpblocksizes[block] - nremovedinds[block]) ,
882 dsdpval + ind - (sdpblocksizes[block] - nremovedinds[block]), sdpblocksizes[block] - nremovedinds[block]) );
885 assert( ind - startind == nrnonz );
890 if ( sdpconstnnonz > 0 )
892 assert( nsdpblocks > 0 );
893 assert( sdpconstnblocknonz!= NULL );
894 assert( sdpconstcol != NULL );
895 assert( sdpconstrow != NULL );
896 assert( sdpconstval != NULL );
903 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpconstind, sdpconstnnonz) );
905 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpconstval, sdpconstnnonz) );
909 for (block = 0; block < nsdpblocks; block++)
913 if ( sdpconstnblocknonz[block] > 0 )
916 for (i = 0; i < sdpconstnblocknonz[block]; i++)
919 assert( indchanges[block][sdpconstrow[block][i]] > -1 && indchanges[block][sdpconstcol[block][i]] > -1 );
922 dsdpconstind[ind] =
compLowerTriangPos(sdpconstrow[block][i] - indchanges[block][sdpconstrow[block][i]],
923 sdpconstcol[block][i] - indchanges[block][sdpconstcol[block][i]]);
924 dsdpconstval[ind] = -1 * sdpconstval[block][i];
929 SCIPsortIntReal(dsdpconstind + startind, dsdpconstval + startind, sdpconstnblocknonz[block]);
931 assert( blockindchanges[block] > -1 );
935 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], 0, sdpblocksizes[block] - nremovedinds[block],
936 1.0, 0, dsdpconstind + startind, dsdpconstval + startind, ind - startind));
941 #ifdef SCIP_MORE_DEBUG
942 SDPConeView2(sdpisolver->sdpcone);
954 assert( noldlpcons > 0 );
955 assert( lprhs != NULL );
956 assert( lpcol != NULL );
957 assert( lprow != NULL );
958 assert( lpval != NULL );
961 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &rowmapper, 2*noldlpcons) );
966 for (i = 0; i < noldlpcons; i++)
968 if ( rownactivevars[i] >= 2 )
972 rowmapper[2*i] = pos;
980 rowmapper[2*i + 1] = pos;
984 rowmapper[2*i + 1] = -1;
991 rowmapper[2*i + 1] = -1;
995 assert( nlpineqs <= 2*nlpcons );
1002 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1004 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 3) );
1008 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 2) );
1018 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1020 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, 2 * nlpineqs + 2*lpnnonz) );
1024 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, nlpineqs + 2*lpnnonz) );
1029 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1031 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs) );
1035 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars) );
1047 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1049 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, 2 * nlpineqs + 2*lpnnonz) );
1053 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, nlpineqs + 2*lpnnonz) );
1058 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1060 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs) );
1064 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars) );
1072 for (i = 0; i < nlpcons; i++)
1076 if ( REALABS(lplhs[i]) > sdpisolver->epsilon )
1078 dsdplprow[dsdpnlpnonz] = pos;
1079 dsdplpval[dsdpnlpnonz] = -lplhs[i];
1086 if ( REALABS(lprhs[i]) > sdpisolver->epsilon )
1088 dsdplprow[dsdpnlpnonz] = pos;
1089 dsdplpval[dsdpnlpnonz] = lprhs[i];
1095 assert( pos == nlpineqs );
1100 if ( REALABS(sdpisolver->objlimit) > sdpisolver->epsilon )
1102 dsdplprow[dsdpnlpnonz] = nlpcons;
1103 dsdplpval[dsdpnlpnonz] = sdpisolver->objlimit;
1115 dsdplpbegcol[0] = 0;
1116 for (i = 0; i < lpnnonz; i++)
1119 if ( lpcol[i] >= nextcol )
1124 for (j = nextcol; j <= lpcol[i]; j++)
1126 if ( sdpisolver->inputtodsdpmapper[j] >= 0 )
1128 assert( ! (
isFixed(sdpisolver, lb[j], ub[j])) );
1129 dsdplpbegcol[sdpisolver->inputtodsdpmapper[j]] = dsdpnlpnonz;
1134 dsdplprow[dsdpnlpnonz] = nlpcons;
1135 dsdplpval[dsdpnlpnonz] = obj[j];
1144 if ( !
isFixed(sdpisolver, lb[lpcol[i]], ub[lpcol[i]]) )
1147 if ( rowmapper[2*lprow[i]] > -1 )
1151 dsdplprow[dsdpnlpnonz] = rowmapper[2*lprow[i]];
1152 dsdplpval[dsdpnlpnonz] = -lpval[i];
1156 if ( rowmapper[2*lprow[i] + 1] > -1 )
1160 dsdplprow[dsdpnlpnonz] = rowmapper[2*lprow[i] + 1];
1161 dsdplpval[dsdpnlpnonz] = lpval[i];
1168 assert(
isFixed(sdpisolver, lb[lpcol[i]], ub[lpcol[i]]) || rownactivevars[lprow[i]] == 1 );
1173 for (j = nextcol; j < nvars; j++)
1175 if ( sdpisolver->inputtodsdpmapper[j] >= 0 )
1177 assert( ! (
isFixed(sdpisolver, lb[j], ub[j])) );
1178 dsdplpbegcol[sdpisolver->inputtodsdpmapper[j]] = dsdpnlpnonz;
1182 dsdplprow[dsdpnlpnonz] = nlpcons;
1183 dsdplpval[dsdpnlpnonz] = obj[j];
1189 dsdplpbegcol[sdpisolver->nactivevars + 1] = dsdpnlpnonz;
1192 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1194 for (i = 0; i < nlpineqs; i++)
1196 dsdplprow[dsdpnlpnonz] = i;
1197 dsdplpval[dsdpnlpnonz] = -1.0;
1200 dsdplpbegcol[sdpisolver->nactivevars + 2] = dsdpnlpnonz;
1204 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &rowmapper, 2*noldlpcons);
1209 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1211 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, 2*nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1212 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, 2*nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1216 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1217 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1222 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1224 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs, dsdpnlpnonz) );
1225 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs, dsdpnlpnonz) );
1229 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars, dsdpnlpnonz) );
1230 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars, dsdpnlpnonz) );
1237 DSDP_CALL( LPConeSetData(sdpisolver->lpcone, nlpineqs, dsdplpbegcol, dsdplprow, dsdplpval) );
1241 DSDP_CALL( LPConeSetData(sdpisolver->lpcone, nlpineqs + 1, dsdplpbegcol, dsdplprow, dsdplpval) );
1243 #ifdef SCIP_MORE_DEBUG
1244 LPConeView(sdpisolver->lpcone);
1248 SCIPdebugMessage(
"Calling DSDP-Solve for SDP (%d) \n", sdpisolver->sdpcounter);
1250 DSDP_CALL( DSDPSetGapTolerance(sdpisolver->dsdp, sdpisolver->epsilon) );
1251 DSDP_CALL( DSDPSetRTolerance(sdpisolver->dsdp, sdpisolver->feastol) );
1252 if ( sdpisolver-> sdpinfo )
1254 DSDP_CALL( DSDPSetStandardMonitor(sdpisolver->dsdp, 1) );
1258 if ( penaltyparam >= sdpisolver->epsilon && rbound )
1260 DSDP_CALL( DSDPSetPenaltyParameter(sdpisolver->dsdp, penaltyparam) );
1261 DSDP_CALL( DSDPUsePenalty(sdpisolver->dsdp, 1) );
1266 DSDP_CALL( DSDPSetPenaltyParameter(sdpisolver->dsdp, sdpisolver->penaltyparam) );
1270 if ( start != NULL )
1272 for (i = 1; i <= sdpisolver->nactivevars; i++)
1274 DSDP_CALL( DSDPSetY0(sdpisolver->dsdp, i, start[sdpisolver->dsdptoinputmapper[i]]) );
1284 DSDP_CALL( DSDPSolve(sdpisolver->dsdp) );
1287 if ( timings.stopped )
1289 sdpisolver->timelimit = TRUE;
1290 sdpisolver->solved = FALSE;
1294 sdpisolver->timelimit = FALSE;
1295 DSDP_CALL( DSDPComputeX(sdpisolver->dsdp) );
1296 sdpisolver->solved = TRUE;
1300 if ( sdpconstnnonz > 0 )
1302 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpconstval, sdpconstnnonz);
1303 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpconstind, sdpconstnnonz);
1308 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1310 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz + nrnonz);
1311 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz + nrnonz);
1315 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz);
1316 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz);
1320 if ( nlpcons > 0 || lpnnonz > 0 )
1322 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, dsdpnlpnonz);
1323 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, dsdpnlpnonz);
1324 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1326 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 3);
1330 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 2);
1335 DSDP_CALL( DSDPStopReason(sdpisolver->dsdp, &reason) );
1339 case DSDP_CONVERGED:
1340 SCIPdebugMessage(
"DSDP converged!\n");
1343 case DSDP_INFEASIBLE_START:
1344 SCIPdebugMessage(
"DSDP started with an infeasible point!\n");
1347 case DSDP_SMALL_STEPS:
1348 SCIPdebugMessage(
"Short step lengths created by numerical difficulties prevented progress in DSDP!\n");
1351 case DSDP_INDEFINITE_SCHUR_MATRIX:
1352 SCIPdebugMessage(
"Schur Matrix in DSDP was indefinite but should have been positive semidefinite!\n");
1356 SCIPdebugMessage(
"DSDP reached maximum number of iterations!\n");
1359 case DSDP_NUMERICAL_ERROR:
1360 SCIPdebugMessage(
"A numerical error occured in DSDP!\n");
1363 case DSDP_UPPERBOUND:
1364 SCIPdebugMessage(
"Dual objective value in DSDP reached upper bound.\n");
1367 case DSDP_USER_TERMINATION:
1368 SCIPdebugMessage(
"DSDP didn't stop solving, did you?\n");
1371 case CONTINUE_ITERATING:
1372 SCIPdebugMessage(
"DSDP wants to continue iterating but somehow was stopped!\n");
1376 SCIPdebugMessage(
"Unknown stopping reason in DSDP!\n");
1381 if ( penaltyparam >= sdpisolver->epsilon && sdpisolver->solved )
1389 DSDP_CALL( DSDPGetR(sdpisolver->dsdp, &rval) );
1391 *feasorig = (rval < sdpisolver->feastol );
1398 if ( penaltybound != NULL )
1400 SCIPdebugMessage(
"Solution not feasible in original problem, r = %f\n", rval);
1403 DSDP_CALL( DSDPGetTraceX(sdpisolver->dsdp, &trace) );
1406 assert( trace < penaltyparam + sdpisolver->feastol );
1412 *penaltybound = TRUE;
1413 SCIPdebugMessage(
"Tr(X) = %f == %f = Gamma, penalty formulation not exact, Gamma should be increased or problem is infeasible\n",
1414 trace, penaltyparam);
1417 *penaltybound = FALSE;
1428 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, sdpisolver->nactivevars + 1) );
1430 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, sdpisolver->nactivevars + 1) );
1432 *feasorig = (dsdpsol[sdpisolver->nactivevars] < sdpisolver->feastol);
1437 if ( penaltybound != NULL )
1439 SCIPdebugMessage(
"Solution not feasible in original problem, r = %f\n", dsdpsol[sdpisolver->nactivevars]);
1442 DSDP_CALL( DSDPGetTraceX(sdpisolver->dsdp, &trace) );
1445 assert( trace < penaltyparam + sdpisolver->feastol );
1451 *penaltybound = TRUE;
1452 SCIPdebugMessage(
"Tr(X) = %f == %f = Gamma, penalty formulation not exact, Gamma should be increased or problem is infeasible\n",
1453 trace, penaltyparam);
1456 *penaltybound = FALSE;
1483 assert( sdpisolver != NULL );
1484 return sdpisolver->solved;
1497 DSDPSolutionType pdfeasible;
1499 assert( sdpisolver != NULL );
1502 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1504 if ( pdfeasible == DSDP_PDUNKNOWN )
1513 SCIP_Bool* primalfeasible,
1514 SCIP_Bool* dualfeasible
1517 DSDPSolutionType pdfeasible;
1519 assert( sdpisolver != NULL );
1520 assert( primalfeasible != NULL );
1521 assert( dualfeasible != NULL );
1524 DSDP_CALL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1526 switch ( pdfeasible )
1528 case DSDP_PDFEASIBLE:
1529 *primalfeasible = TRUE;
1530 *dualfeasible = TRUE;
1533 case DSDP_UNBOUNDED:
1534 *primalfeasible = FALSE;
1535 *dualfeasible = TRUE;
1538 case DSDP_INFEASIBLE:
1539 *primalfeasible = TRUE;
1540 *dualfeasible = FALSE;
1544 SCIPerrorMessage(
"DSDP doesn't know if primal and dual solutions are feasible\n");
1545 return SCIP_LPERROR;
1557 DSDPSolutionType pdfeasible;
1559 assert( sdpisolver != NULL );
1562 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1563 if ( pdfeasible == DSDP_PDUNKNOWN )
1568 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible.");
1571 else if ( pdfeasible == DSDP_INFEASIBLE )
1583 DSDPSolutionType pdfeasible;
1585 assert( sdpisolver != NULL );
1588 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1589 if ( pdfeasible == DSDP_PDUNKNOWN )
1594 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1597 else if ( pdfeasible == DSDP_UNBOUNDED )
1609 DSDPSolutionType pdfeasible;
1611 assert( sdpisolver != NULL );
1614 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1615 if ( pdfeasible == DSDP_PDUNKNOWN )
1617 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1620 else if ( pdfeasible == DSDP_UNBOUNDED )
1632 DSDPSolutionType pdfeasible;
1634 assert( sdpisolver != NULL );
1637 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1638 if ( pdfeasible == DSDP_PDUNKNOWN )
1640 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1643 else if ( pdfeasible == DSDP_UNBOUNDED )
1655 DSDPSolutionType pdfeasible;
1657 assert( sdpisolver != NULL );
1660 DSDP_CALL_BOOL(DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible));
1662 if ( pdfeasible == DSDP_PDUNKNOWN )
1664 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1667 else if ( pdfeasible == DSDP_INFEASIBLE )
1679 DSDPSolutionType pdfeasible;
1681 assert( sdpisolver != NULL );
1684 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1686 if ( pdfeasible == DSDP_PDUNKNOWN )
1688 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1691 else if ( pdfeasible == DSDP_INFEASIBLE )
1702 DSDPTerminationReason reason;
1704 assert( sdpisolver != NULL );
1706 if ( sdpisolver->timelimit )
1713 if ( reason == DSDP_CONVERGED )
1724 SCIPdebugMessage(
"Method not implemented for DSDP, as objective limit is given as an ordinary LP-constraint, so in case the objective limit was "
1725 "exceeded, the problem will be reported as infeasible ! \n");
1735 DSDPTerminationReason reason;
1737 assert( sdpisolver != NULL );
1742 if ( reason == DSDP_MAX_IT )
1753 assert( sdpisolver != NULL );
1755 return sdpisolver->timelimit;
1772 DSDPTerminationReason reason;
1775 assert( sdpisolver != NULL );
1777 if ( sdpisolver->dsdp == NULL || (! sdpisolver->solved) )
1780 if ( sdpisolver->timelimit )
1783 dsdpreturn = DSDPStopReason(sdpisolver->dsdp, &reason);
1785 if (dsdpreturn != 0)
1787 SCIPerrorMessage(
"DSDP-Error <%d> in function call.\n", dsdpreturn);
1793 case DSDP_CONVERGED:
1796 case DSDP_INFEASIBLE_START:
1799 case DSDP_SMALL_STEPS:
1802 case DSDP_INDEFINITE_SCHUR_MATRIX:
1808 case DSDP_NUMERICAL_ERROR:
1811 case DSDP_UPPERBOUND:
1814 case DSDP_USER_TERMINATION:
1827 assert( sdpisolver != NULL );
1837 assert( sdpisolver != NULL );
1848 SCIPdebugMessage(
"Not implemented yet\n");
1849 return SCIP_LPERROR;
1858 assert( sdpisolver != NULL );
1859 assert( objval != NULL );
1862 DSDP_CALL( DSDPGetDObjective(sdpisolver->dsdp, objval) );
1863 *objval = -1*(*objval);
1866 *objval += sdpisolver->fixedvarsobjcontr;
1887 assert( sdpisolver != NULL );
1888 assert( dualsollength != NULL );
1891 dsdpnvars = sdpisolver->penaltyworbound ? sdpisolver->nactivevars + 1 : sdpisolver->nactivevars;
1893 if ( objval != NULL )
1895 DSDP_CALL( DSDPGetDObjective(sdpisolver->dsdp, objval) );
1899 *objval += sdpisolver->fixedvarsobjcontr;
1902 if ( *dualsollength > 0 )
1904 assert( dualsol != NULL );
1905 if ( *dualsollength < sdpisolver->nvars )
1907 SCIPdebugMessage(
"The given array in SCIPsdpiSolverGetSol only had length %d, but %d was needed", *dualsollength, sdpisolver->nvars);
1908 *dualsollength = sdpisolver->nvars;
1913 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars) );
1914 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, dsdpnvars) );
1917 for (v = 0; v < sdpisolver->nvars; v++)
1919 if (sdpisolver->inputtodsdpmapper[v] > -1)
1922 dualsol[v] = dsdpsol[sdpisolver->inputtodsdpmapper[v] - 1];
1927 dualsol[v] = sdpisolver->fixedvarsval[(-1 * sdpisolver->inputtodsdpmapper[v]) - 1];
1930 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars);
1950 SCIP_Real* lbvarsdsdp;
1951 SCIP_Real* ubvarsdsdp;
1954 assert( sdpisolver != NULL );
1955 assert( lbvars != NULL );
1956 assert( ubvars != NULL );
1957 assert( arraylength != NULL );
1958 assert( *arraylength >= 0 );
1962 if ( *arraylength < sdpisolver->nvars )
1964 *arraylength = sdpisolver->nvars;
1965 SCIPdebugMessage(
"Insufficient length of array in SCIPsdpiSolverGetPrimalBoundVars (gave %d, needed %d)\n", *arraylength, sdpisolver->nvars);
1970 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &lbvarsdsdp, sdpisolver->nactivevars) );
1971 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &ubvarsdsdp, sdpisolver->nactivevars) );
1974 DSDP_CALL( BConeCopyX(sdpisolver->bcone, lbvarsdsdp, ubvarsdsdp, sdpisolver->nactivevars) );
1977 for (i = 0; i < sdpisolver->nvars; i++)
1979 if ( sdpisolver->inputtodsdpmapper[i] < 0 )
1988 lbvars[i] = lbvarsdsdp[sdpisolver->inputtodsdpmapper[i] - 1];
1989 ubvars[i] = ubvarsdsdp[sdpisolver->inputtodsdpmapper[i] - 1];
1994 BMSfreeBlockMemoryArrayNull(sdpisolver->blkmem, &ubvarsdsdp, sdpisolver->nactivevars);
1995 BMSfreeBlockMemoryArrayNull(sdpisolver->blkmem, &lbvarsdsdp, sdpisolver->nactivevars);
2006 assert( sdpisolver != NULL );
2007 assert( iterations != NULL );
2009 if ( sdpisolver->timelimitinitial )
2012 DSDP_CALL( DSDPGetIts(sdpisolver->dsdp, iterations) );
2023 assert( sdpisolver != NULL );
2024 assert( calls != NULL );
2026 if ( sdpisolver->timelimitinitial )
2040 assert( sdpisolver != NULL );
2041 assert( usedsetting != NULL );
2046 *usedsetting = sdpisolver->usedsetting;
2087 assert( sdpisolver != NULL );
2088 assert( dval != NULL );
2093 *dval = sdpisolver->epsilon;
2096 *dval = sdpisolver->feastol;
2099 *dval = sdpisolver->penaltyparam;
2102 *dval = sdpisolver->objlimit;
2105 return SCIP_PARAMETERUNKNOWN;
2118 assert( sdpisolver != NULL );
2123 sdpisolver->epsilon = dval;
2124 SCIPdebugMessage(
"Setting sdpisolver epsilon to %f.\n", dval);
2127 sdpisolver->feastol = dval;
2128 SCIPdebugMessage(
"Setting sdpisolver feastol to %f.\n", dval);
2131 sdpisolver->penaltyparam = dval;
2132 SCIPdebugMessage(
"Setting sdpisolver penaltyparameter to %f.\n", dval);
2135 SCIPdebugMessage(
"Setting sdpisolver objlimit to %f.\n", dval);
2136 sdpisolver->objlimit = dval;
2139 SCIPdebugMessage(
"Parameter SCIP_SDPPAR_LAMBDASTAR not used by DSDP");
2142 return SCIP_PARAMETERUNKNOWN;
2155 assert( sdpisolver != NULL );
2160 *ival = (int) sdpisolver->sdpinfo;
2161 SCIPdebugMessage(
"Getting sdpisolver information output (%d).\n", *ival);
2164 return SCIP_PARAMETERUNKNOWN;
2177 assert( sdpisolver != NULL );
2182 sdpisolver->sdpinfo = (SCIP_Bool) ival;
2183 SCIPdebugMessage(
"Setting sdpisolver information output (%d).\n", ival);
2186 return SCIP_PARAMETERUNKNOWN;
2198 SCIPdebugMessage(
"Lambdastar parameter not used by DSDP");
2207 SCIP_Real* penaltyparam
2212 assert( sdpisolver != NULL );
2213 assert( penaltyparam != NULL );
2231 SCIPdebugMessage(
"Setting penaltyparameter to %f.\n", compval);
2232 sdpisolver->penaltyparam = compval;
2233 *penaltyparam = compval;
2241 SCIP_Real penaltyparam,
2242 SCIP_Real* maxpenaltyparam
2247 assert( sdpisolver != NULL );
2248 assert( maxpenaltyparam != NULL );
2254 *maxpenaltyparam = compval;
2255 SCIPdebugMessage(
"Setting maximum penaltyparameter to %f.\n", compval);
2264 if ( sdpisolver->penaltyparam > *maxpenaltyparam )
2266 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpisolver->penaltyparam, *maxpenaltyparam);
2267 sdpisolver->penaltyparam = *maxpenaltyparam;
2290 SCIPdebugMessage(
"Not implemented yet\n");
2291 return SCIP_LPERROR;
2300 SCIPdebugMessage(
"Not implemented yet\n");
2301 return SCIP_LPERROR;
SCIP_Bool SCIPsdpiSolverIsConverged(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_SDPSOLVERSETTING startsettings, SCIP_Real timelimit, SCIP_Bool *feasorig, SCIP_Bool *penaltybound)
int SCIPsdpiSolverGetInternalStatus(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsPrimalFeasible(SCIP_SDPISOLVER *sdpisolver)
SCIP_Bool SCIPsdpiSolverIsPrimalUnbounded(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)
enum SCIP_SDPSolverSetting SCIP_SDPSOLVERSETTING
SCIP_RETCODE SCIPsdpiSolverGetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int *ival)
#define DSDP_CALL_BOOL(x)
SCIP_RETCODE SCIPsdpiSolverSettingsUsed(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPSOLVERSETTING *usedsetting)
interface methods for specific SDP-solvers
SCIP_RETCODE SCIPsdpiSolverResetCounter(SCIP_SDPISOLVER *sdpisolver)
void * SCIPsdpiSolverGetSolverPointer(SCIP_SDPISOLVER *sdpisolver)
#define TIMEOFDAY_CALL(x)
SCIP_RETCODE SCIPsdpiSolverGetRealpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, SCIP_Real *dval)
SCIP_Bool SCIPsdpiSolverIsInfinity(SCIP_SDPISOLVER *sdpisolver, SCIP_Real val)
#define PENALTYPARAM_FACTOR
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 SCIPsdpiSolverGetObjval(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *objval)
const char * SCIPsdpiSolverGetSolverName(void)
SCIP_RETCODE SCIPsdpiSolverComputeMaxPenaltyparam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real penaltyparam, SCIP_Real *maxpenaltyparam)
SCIP_RETCODE SCIPsdpiSolverSetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int ival)
SCIP_Bool SCIPsdpiSolverIsIterlimExc(SCIP_SDPISOLVER *sdpisolver)
#define MAXPENALTYPARAM_FACTOR
SCIP_RETCODE SCIPsdpiSolverGetPrimalBoundVars(SCIP_SDPISOLVER *sdpisolver, SCIP_Real *lbvars, SCIP_Real *ubvars, int *arraylength)
SCIP_RETCODE SCIPsdpiSolverLoadAndSolve(SCIP_SDPISOLVER *sdpisolver, int nvars, SCIP_Real *obj, SCIP_Real *lb, SCIP_Real *ub, int nsdpblocks, int *sdpblocksizes, int *sdpnblockvars, int sdpconstnnonz, int *sdpconstnblocknonz, int **sdpconstrow, int **sdpconstcol, SCIP_Real **sdpconstval, int sdpnnonz, int **sdpnblockvarnonz, int **sdpvar, int ***sdprow, int ***sdpcol, SCIP_Real ***sdpval, int **indchanges, int *nremovedinds, int *blockindchanges, int nremovedblocks, int nlpcons, int noldlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int *rownactivevars, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval, SCIP_Real *start, SCIP_SDPSOLVERSETTING startsettings, SCIP_Real timelimit)
static int checkTimeLimitDSDP(DSDP dsdp, void *ctx)
SCIP_RETCODE SCIPsdpiSolverIncreaseCounter(SCIP_SDPISOLVER *sdpisolver)
static int compLowerTriangPos(int i, int j)
SCIP_Bool SCIPsdpiSolverIsTimelimExc(SCIP_SDPISOLVER *sdpisolver)
SCIP_RETCODE SCIPsdpiSolverComputeLambdastar(SCIP_SDPISOLVER *sdpisolver, SCIP_Real maxguess)
SCIP_Bool SCIPsdpiSolverWasSolved(SCIP_SDPISOLVER *sdpisolver)
#define MAX_MAXPENALTYPARAM
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_RETCODE SCIPsdpiSolverGetSdpCalls(SCIP_SDPISOLVER *sdpisolver, int *calls)
SCIP_Bool SCIPsdpiSolverIsAcceptable(SCIP_SDPISOLVER *sdpisolver)
enum SCIP_SDPParam SCIP_SDPPARAM
SCIP_RETCODE SCIPsdpiSolverComputePenaltyparam(SCIP_SDPISOLVER *sdpisolver, SCIP_Real maxcoeff, SCIP_Real *penaltyparam)
SCIP_Bool SCIPsdpiSolverIsDualInfeasible(SCIP_SDPISOLVER *sdpisolver)
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)