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"
60 #define PENALTYBOUNDTOL 1E-3
63 #define MIN_PENALTYPARAM 1e5
64 #define MAX_PENALTYPARAM 1e12
65 #define PENALTYPARAM_FACTOR 1e4
66 #define MAX_MAXPENALTYPARAM 1e15
67 #define MAXPENALTYPARAM_FACTOR 1e6
68 #define INFEASFEASTOLCHANGE 0.1
69 #define INFEASMINFEASTOL 1E-9
72 #define DSDP_CALL(x) do \
74 int _dsdperrorcode_; \
75 if ( (_dsdperrorcode_ = (x)) != 0 ) \
77 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
78 return SCIP_LPERROR; \
84 #define DSDP_CALL_BOOL(x) do \
86 int _dsdperrorcode_; \
87 if ( (_dsdperrorcode_ = (x)) != 0 ) \
89 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
96 #define DSDP_CALLM(x) do \
98 int _dsdperrorcode_; \
99 if ( (_dsdperrorcode_ = (x)) != 0 ) \
101 SCIPerrorMessage("DSDP-Error <%d> in function call.\n", _dsdperrorcode_); \
102 return SCIP_NOMEMORY; \
108 #define BMS_CALL(x) do \
112 SCIPerrorMessage("No memory in function call.\n"); \
113 return SCIP_NOMEMORY; \
119 #define TIMEOFDAY_CALL(x) do \
122 if ( (_errorcode_ = (x)) != 0 ) \
124 SCIPerrorMessage("Error in gettimeofday! \n"); \
131 #define CHECK_IF_SOLVED(sdpisolver) do \
133 if (!(sdpisolver->solved)) \
135 SCIPerrorMessage("Tried to access solution information for SDP %d ahead of solving!\n", sdpisolver->sdpcounter); \
136 return SCIP_LPERROR; \
142 #define CHECK_IF_SOLVED_BOOL(sdpisolver) do \
144 if (!(sdpisolver->solved)) \
146 SCIPerrorMessage("Tried to access solution information for SDP %d ahead of solving!\n", sdpisolver->sdpcounter); \
154 struct SCIP_SDPiSolver
156 SCIP_MESSAGEHDLR* messagehdlr;
165 int* inputtodsdpmapper;
168 int* dsdptoinputmapper;
169 SCIP_Real* fixedvarsval;
170 SCIP_Real fixedvarsobjcontr;
177 SCIP_Real sdpsolverfeastol;
178 SCIP_Real penaltyparam;
182 SCIP_Bool penaltyworbound;
187 SCIP_Bool timelimitinitial;
194 struct timeval starttime;
216 return i*(i+1)/2 + j;
228 assert( lb < ub + sdpisolver->feastol );
230 return (ub-lb <= sdpisolver->epsilon);
233 #define isFixed(sdpisolver,lb,ub) (ub-lb <= sdpisolver->epsilon)
249 SCIPsortIntIntReal(col, row, val, length);
252 while (nextentry < length)
254 firstentry = nextentry;
256 while (nextentry < length && col[nextentry] == col[firstentry])
260 SCIPsortIntReal(row + firstentry, val + firstentry, nextentry - firstentry);
272 struct timeval currenttime;
273 SCIP_Real startseconds;
274 SCIP_Real currentseconds;
275 SCIP_Real elapsedtime;
277 assert( dsdp != NULL );
278 assert( ctx != NULL );
282 startseconds = (SCIP_Real) (timings->starttime).tv_sec + (SCIP_Real) (timings->starttime).tv_usec / 1e6;
285 currentseconds = (SCIP_Real) currenttime.tv_sec + (SCIP_Real) currenttime.tv_usec / 1e6;
287 elapsedtime = currentseconds - startseconds;
289 if ( elapsedtime > timings->timelimit )
291 DSDP_CALL( DSDPSetConvergenceFlag(dsdp, DSDP_USER_TERMINATION) );
292 timings->stopped = TRUE;
293 SCIPdebugMessage(
"Time limit reached! Stopping DSDP.\n");
321 return "Dual-Scaling Interior Point SDP-Solver by S. Benson, Y. Ye, and X. Zhang (http://www.mcs.anl.gov/hs/software/DSDP/)";
334 assert( sdpisolver != NULL );
335 return (
void*) sdpisolver->dsdp;
367 SCIP_MESSAGEHDLR* messagehdlr,
372 assert( sdpisolver != NULL );
373 assert( blkmem != NULL );
374 assert( bufmem != NULL );
376 SCIPdebugMessage(
"Calling SCIPsdpiCreate \n");
378 BMS_CALL( BMSallocBlockMemory(blkmem, sdpisolver) );
380 (*sdpisolver)->messagehdlr = messagehdlr;
381 (*sdpisolver)->blkmem = blkmem;
382 (*sdpisolver)->bufmem = bufmem;
386 (*sdpisolver)->dsdp = NULL;
387 (*sdpisolver)->sdpcone = NULL;
388 (*sdpisolver)->lpcone = NULL;
389 (*sdpisolver)->bcone = NULL;
391 (*sdpisolver)->nvars = 0;
392 (*sdpisolver)->nactivevars = 0;
393 (*sdpisolver)->inputtodsdpmapper = NULL;
394 (*sdpisolver)->dsdptoinputmapper = NULL;
395 (*sdpisolver)->fixedvarsval = NULL;
396 (*sdpisolver)->fixedvarsobjcontr = 0.0;
397 (*sdpisolver)->objcoefs = NULL;
398 (*sdpisolver)->solved = FALSE;
399 (*sdpisolver)->timelimit = FALSE;
400 (*sdpisolver)->timelimitinitial = FALSE;
401 (*sdpisolver)->penalty = FALSE;
402 (*sdpisolver)->penaltyworbound = FALSE;
403 (*sdpisolver)->feasorig = FALSE;
404 (*sdpisolver)->sdpcounter = 0;
405 (*sdpisolver)->niterations = 0;
406 (*sdpisolver)->nsdpcalls = 0;
408 (*sdpisolver)->epsilon = 1e-9;
409 (*sdpisolver)->gaptol = 1e-4;
410 (*sdpisolver)->feastol = 1e-6;
411 (*sdpisolver)->sdpsolverfeastol = 1e-6;
412 (*sdpisolver)->penaltyparam = 1e5;
414 (*sdpisolver)->sdpinfo = FALSE;
425 assert( sdpisolver != NULL );
426 assert( *sdpisolver != NULL );
428 SCIPdebugMessage(
"Freeing SDPISolver\n");
430 if ( (*sdpisolver)->dsdp != NULL )
432 DSDP_CALL( DSDPDestroy((*sdpisolver)->dsdp) );
435 if ( (*sdpisolver)->nvars > 0 )
436 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->inputtodsdpmapper, (*sdpisolver)->nvars);
438 if ( (*sdpisolver)->nactivevars > 0 )
440 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->dsdptoinputmapper, (*sdpisolver)->nactivevars);
441 BMSfreeBlockMemoryArray((*sdpisolver)->blkmem, &(*sdpisolver)->objcoefs, (*sdpisolver)->nactivevars);
444 if ( (*sdpisolver)->nvars >= (*sdpisolver)->nactivevars )
445 BMSfreeBlockMemoryArrayNull((*sdpisolver)->blkmem, &(*sdpisolver)->fixedvarsval, (*sdpisolver)->nvars - (*sdpisolver)->nactivevars);
447 BMSfreeBlockMemory((*sdpisolver)->blkmem, sdpisolver);
457 assert( sdpisolver != NULL );
459 sdpisolver->sdpcounter++;
469 assert( sdpisolver != NULL );
471 SCIPdebugMessage(
"Resetting counter of SDP-Interface from %d to 0.\n", sdpisolver->sdpcounter);
472 sdpisolver->sdpcounter = 0;
509 int* sdpconstnblocknonz,
513 SCIP_Real** sdpconstval,
515 int** sdpnblockvarnonz,
525 int* blockindchanges,
542 return SCIPsdpiSolverLoadAndSolveWithPenalty(sdpisolver, 0.0, TRUE, TRUE, nvars, obj, lb, ub, nsdpblocks, sdpblocksizes, sdpnblockvars,
543 sdpconstnnonz, sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, sdpnnonz, sdpnblockvarnonz, sdpvar, sdprow, sdpcol, sdpval,
544 indchanges, nremovedinds, blockindchanges, nremovedblocks, nlpcons, noldlpcons, lplhs, lprhs, rownactivevars, lpnnonz, lprow, lpcol,
545 lpval, start, startsettings, timelimit, NULL, NULL);
569 SCIP_Real penaltyparam,
580 int* sdpconstnblocknonz,
584 SCIP_Real** sdpconstval,
586 int** sdpnblockvarnonz,
596 int* blockindchanges,
613 SCIP_Bool* penaltybound
617 int* dsdpconstind = NULL;
618 SCIP_Real* dsdpconstval = NULL;
620 SCIP_Real* dsdpval = NULL;
621 int* dsdplpbegcol = NULL;
622 int* dsdplprow = NULL;
623 SCIP_Real* dsdplpval = NULL;
636 DSDPTerminationReason reason;
639 assert( sdpisolver != NULL );
640 assert( penaltyparam > -1 * sdpisolver->epsilon );
641 assert( penaltyparam < sdpisolver->epsilon || ( feasorig != NULL ) );
643 assert( obj != NULL );
644 assert( lb != NULL );
645 assert( ub != NULL );
646 assert( nsdpblocks >= 0 );
647 assert( nsdpblocks == 0 || sdpblocksizes != NULL );
648 assert( nsdpblocks == 0 || sdpnblockvars != NULL );
649 assert( sdpconstnnonz >= 0 );
650 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstnblocknonz != NULL );
651 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstrow != NULL );
652 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstcol != NULL );
653 assert( nsdpblocks == 0 || sdpconstnnonz == 0 || sdpconstval != NULL );
654 assert( sdpnnonz >= 0 );
655 assert( nsdpblocks == 0 || sdpnblockvarnonz != NULL );
656 assert( nsdpblocks == 0 || sdpvar != NULL );
657 assert( nsdpblocks == 0 || sdprow != NULL );
658 assert( nsdpblocks == 0 || sdpcol != NULL );
659 assert( nsdpblocks == 0 || sdpval != NULL );
660 assert( nsdpblocks == 0 || indchanges != NULL );
661 assert( nsdpblocks == 0 || nremovedinds != NULL );
662 assert( nsdpblocks == 0 || blockindchanges != NULL );
663 assert( 0 <= nremovedblocks && nremovedblocks <= nsdpblocks );
664 assert( nlpcons >= 0 );
665 assert( noldlpcons >= nlpcons );
666 assert( nlpcons == 0 || lplhs != NULL );
667 assert( nlpcons == 0 || lprhs != NULL );
668 assert( nlpcons == 0 || rownactivevars != NULL );
669 assert( lpnnonz >= 0 );
670 assert( nlpcons == 0 || lprow != NULL );
671 assert( nlpcons == 0 || lpcol != NULL );
672 assert( nlpcons == 0 || lpval != NULL );
674 sdpisolver->penalty = penaltyparam > sdpisolver->epsilon;
676 if ( timelimit <= 0.0 )
678 sdpisolver->timelimit = TRUE;
679 sdpisolver->timelimitinitial = TRUE;
680 sdpisolver->solved = FALSE;
684 sdpisolver->timelimitinitial = FALSE;
686 sdpisolver->feasorig = FALSE;
690 timings.timelimit = timelimit;
691 timings.stopped = FALSE;
695 if ( penaltyparam < sdpisolver->epsilon )
697 SCIPdebugMessage(
"Inserting Data into DSDP for SDP (%d) \n", ++sdpisolver->sdpcounter);
702 SCIPdebugMessage(
"Inserting Data again into DSDP for SDP (%d) \n", sdpisolver->sdpcounter);
708 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->inputtodsdpmapper), sdpisolver->nvars, nvars) );
709 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->dsdptoinputmapper), sdpisolver->nactivevars, nvars) );
710 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->fixedvarsval), sdpisolver->nvars - sdpisolver->nactivevars, nvars) );
711 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->objcoefs), sdpisolver->nactivevars, nvars) );
713 sdpisolver->nvars = nvars;
714 sdpisolver->nactivevars = 0;
716 sdpisolver->niterations = 0;
717 sdpisolver->nsdpcalls = 0;
720 sdpisolver->fixedvarsobjcontr = 0.0;
721 for (i = 0; i < nvars; i++)
723 if (
isFixed(sdpisolver, lb[i], ub[i]) )
726 sdpisolver->inputtodsdpmapper[i] = -nfixedvars;
727 sdpisolver->fixedvarsobjcontr += obj[i] * lb[i];
728 sdpisolver->fixedvarsval[nfixedvars - 1] = lb[i];
729 SCIPdebugMessage(
"Fixing variable %d locally to %f for SDP %d in DSDP\n", i, lb[i], sdpisolver->sdpcounter);
733 sdpisolver->dsdptoinputmapper[sdpisolver->nactivevars] = i;
734 sdpisolver->objcoefs[sdpisolver->nactivevars] = obj[i];
735 sdpisolver->nactivevars++;
736 sdpisolver->inputtodsdpmapper[i] = sdpisolver->nactivevars;
737 SCIPdebugMessage(
"Variable %d becomes variable %d for SDP %d in DSDP\n", i, sdpisolver->inputtodsdpmapper[i], sdpisolver->sdpcounter);
740 assert( sdpisolver->nactivevars + nfixedvars == sdpisolver->nvars );
741 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
743 SCIPdebugMessage(
"Variable %d is the slack variable for the explicit penalty formulation\n", sdpisolver->nactivevars + 1);
748 sdpisolver->fixedvarsobjcontr = 0.0;
751 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->objcoefs), nvars, sdpisolver->nactivevars) );
752 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->fixedvarsval), nvars, nfixedvars) );
753 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &(sdpisolver->dsdptoinputmapper), nvars, sdpisolver->nactivevars) );
757 if ( sdpisolver->dsdp != NULL )
759 DSDP_CALL( DSDPDestroy(sdpisolver->dsdp) );
763 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
765 DSDP_CALLM( DSDPCreate(sdpisolver->nactivevars + 1, &(sdpisolver->dsdp)) );
766 sdpisolver->penaltyworbound = TRUE;
770 DSDP_CALLM( DSDPCreate(sdpisolver->nactivevars, &(sdpisolver->dsdp)) );
771 sdpisolver->penaltyworbound = FALSE;
773 DSDP_CALLM( DSDPCreateSDPCone(sdpisolver->dsdp, nsdpblocks - nremovedblocks, &(sdpisolver->sdpcone)) );
774 DSDP_CALLM( DSDPCreateLPCone(sdpisolver->dsdp, &(sdpisolver->lpcone)) );
775 DSDP_CALLM( DSDPCreateBCone(sdpisolver->dsdp, &(sdpisolver->bcone)) );
777 #ifdef SCIP_MORE_DEBUG
778 SCIPmessagePrintInfo(sdpisolver->messagehdlr,
"setting objective values for SDP %d:\n", sdpisolver->sdpcounter);
781 for (i = 0; i < sdpisolver->nactivevars; i++)
786 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, i+1, -1.0 * obj[sdpisolver->dsdptoinputmapper[i]]) );
787 #ifdef SCIP_MORE_DEBUG
788 SCIPmessagePrintInfo(sdpisolver->messagehdlr,
"var %d (was var %d): %f, ", i+1, sdpisolver->dsdptoinputmapper[i], obj[sdpisolver->dsdptoinputmapper[i]]);
793 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, i+1, 0.0) );
799 DSDP_CALL( BConeSetLowerBound(sdpisolver->bcone, i+1, lb[sdpisolver->dsdptoinputmapper[i]]) );
805 DSDP_CALL(BConeSetUpperBound(sdpisolver->bcone, i+1, ub[sdpisolver->dsdptoinputmapper[i]]));
810 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
812 DSDP_CALL( DSDPSetDualObjective(sdpisolver->dsdp, sdpisolver->nactivevars + 1, -1.0 * penaltyparam) );
813 #ifdef SCIP_MORE_DEBUG
814 SCIPmessagePrintInfo(sdpisolver->messagehdlr,
"slack variable r: %f, ", penaltyparam);
818 #ifdef SCIP_MORE_DEBUG
819 SCIPmessagePrintInfo(sdpisolver->messagehdlr,
"\n");
820 SCIPdebugMessage(
"ATTENTION: BConeView shows the WRONG sign for the lower bound!\n");
821 BConeView(sdpisolver->bcone);
825 for (block = 0; block < nsdpblocks; ++block)
828 if ( blockindchanges[block] > -1 )
831 DSDP_CALL( SDPConeSetBlockSize(sdpisolver->sdpcone, block- blockindchanges[block], sdpblocksizes[block] - nremovedinds[block]) );
849 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
852 for (block = 0; block < nsdpblocks; block++)
853 nrnonz += sdpblocksizes[block] - nremovedinds[block];
854 assert( nrnonz >= 0 );
857 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz + nrnonz) );
859 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz + nrnonz) );
864 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz) );
866 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz) );
871 for (block = 0; block < nsdpblocks; block++)
873 for (i = 0; i < sdpisolver->nactivevars; i++)
876 v = sdpisolver->dsdptoinputmapper[i];
880 for (k = 0; k < sdpnblockvars[block]; k++)
882 if ( v == sdpvar[block][k] )
893 for (k = 0; k < sdpnblockvarnonz[block][blockvar]; k++)
896 assert( indchanges[block][sdprow[block][blockvar][k]] > -1 && indchanges[block][sdpcol[block][blockvar][k]] > -1 );
899 dsdpind[ind] =
compLowerTriangPos(sdprow[block][blockvar][k] - indchanges[block][sdprow[block][blockvar][k]],
900 sdpcol[block][blockvar][k] - indchanges[block][sdpcol[block][blockvar][k]]);
901 dsdpval[ind] = -1.0 * sdpval[block][blockvar][k];
906 SCIPsortIntReal(dsdpind + startind, dsdpval + startind, sdpnblockvarnonz[block][blockvar]);
908 assert( blockindchanges[block] > -1 );
912 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], i + 1, sdpblocksizes[block] - nremovedinds[block],
913 1.0, 0, dsdpind + startind,dsdpval + startind, sdpnblockvarnonz[block][blockvar]));
918 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
922 for (block = 0; block < nsdpblocks; block++)
924 if ( blockindchanges[block] > -1 )
926 for (i = 0; i < sdpblocksizes[block] - nremovedinds[block]; i++)
932 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], sdpisolver->nactivevars + 1,
933 sdpblocksizes[block] - nremovedinds[block], 1.0, 0, dsdpind + ind - (sdpblocksizes[block] - nremovedinds[block]) ,
934 dsdpval + ind - (sdpblocksizes[block] - nremovedinds[block]), sdpblocksizes[block] - nremovedinds[block]) );
937 assert( ind - startind == nrnonz );
942 if ( sdpconstnnonz > 0 )
944 assert( nsdpblocks > 0 );
945 assert( sdpconstnblocknonz!= NULL );
946 assert( sdpconstcol != NULL );
947 assert( sdpconstrow != NULL );
948 assert( sdpconstval != NULL );
955 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpconstind, sdpconstnnonz) );
957 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpconstval, sdpconstnnonz) );
961 for (block = 0; block < nsdpblocks; block++)
965 if ( sdpconstnblocknonz[block] > 0 )
968 for (i = 0; i < sdpconstnblocknonz[block]; i++)
971 assert( indchanges[block][sdpconstrow[block][i]] > -1 && indchanges[block][sdpconstcol[block][i]] > -1 );
974 dsdpconstind[ind] =
compLowerTriangPos(sdpconstrow[block][i] - indchanges[block][sdpconstrow[block][i]],
975 sdpconstcol[block][i] - indchanges[block][sdpconstcol[block][i]]);
976 dsdpconstval[ind] = -1 * sdpconstval[block][i];
981 SCIPsortIntReal(dsdpconstind + startind, dsdpconstval + startind, sdpconstnblocknonz[block]);
983 assert( blockindchanges[block] > -1 );
987 DSDP_CALL( SDPConeSetASparseVecMat(sdpisolver->sdpcone, block - blockindchanges[block], 0, sdpblocksizes[block] - nremovedinds[block],
988 1.0, 0, dsdpconstind + startind, dsdpconstval + startind, ind - startind));
993 #ifdef SCIP_MORE_DEBUG
994 SDPConeView2(sdpisolver->sdpcone);
1006 assert( noldlpcons > 0 );
1007 assert( lprhs != NULL );
1008 assert( lpcol != NULL );
1009 assert( lprow != NULL );
1010 assert( lpval != NULL );
1013 BMS_CALL( BMSallocBufferMemoryArray(sdpisolver->bufmem, &rowmapper, 2*noldlpcons) );
1018 for (i = 0; i < noldlpcons; i++)
1020 if ( rownactivevars[i] >= 2 )
1024 rowmapper[2*i] = pos;
1028 rowmapper[2*i] = -1;
1032 rowmapper[2*i + 1] = pos;
1036 rowmapper[2*i + 1] = -1;
1042 rowmapper[2*i] = -1;
1043 rowmapper[2*i + 1] = -1;
1047 assert( nlpineqs <= 2*nlpcons );
1054 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1056 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 3) );
1060 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 2) );
1070 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1072 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, 2 * nlpineqs + 2*lpnnonz) );
1076 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, nlpineqs + 2*lpnnonz) );
1081 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1083 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs) );
1087 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars) );
1099 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1101 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, 2 * nlpineqs + 2*lpnnonz) );
1105 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, nlpineqs + 2*lpnnonz) );
1110 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1112 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs) );
1116 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars) );
1124 for (i = 0; i < nlpcons; i++)
1128 if ( REALABS(lplhs[i]) > sdpisolver->epsilon )
1130 dsdplprow[dsdpnlpnonz] = pos;
1131 dsdplpval[dsdpnlpnonz] = -lplhs[i];
1138 if ( REALABS(lprhs[i]) > sdpisolver->epsilon )
1140 dsdplprow[dsdpnlpnonz] = pos;
1141 dsdplpval[dsdpnlpnonz] = lprhs[i];
1147 assert( pos == nlpineqs );
1152 if ( REALABS(sdpisolver->objlimit) > sdpisolver->epsilon )
1154 dsdplprow[dsdpnlpnonz] = nlpcons;
1155 dsdplpval[dsdpnlpnonz] = sdpisolver->objlimit;
1167 dsdplpbegcol[0] = 0;
1168 for (i = 0; i < lpnnonz; i++)
1171 if ( lpcol[i] >= nextcol )
1176 for (j = nextcol; j <= lpcol[i]; j++)
1178 if ( sdpisolver->inputtodsdpmapper[j] >= 0 )
1180 assert( ! (
isFixed(sdpisolver, lb[j], ub[j])) );
1181 dsdplpbegcol[sdpisolver->inputtodsdpmapper[j]] = dsdpnlpnonz;
1186 dsdplprow[dsdpnlpnonz] = nlpcons;
1187 dsdplpval[dsdpnlpnonz] = obj[j];
1196 if ( !
isFixed(sdpisolver, lb[lpcol[i]], ub[lpcol[i]]) )
1199 if ( rowmapper[2*lprow[i]] > -1 )
1203 dsdplprow[dsdpnlpnonz] = rowmapper[2*lprow[i]];
1204 dsdplpval[dsdpnlpnonz] = -lpval[i];
1208 if ( rowmapper[2*lprow[i] + 1] > -1 )
1212 dsdplprow[dsdpnlpnonz] = rowmapper[2*lprow[i] + 1];
1213 dsdplpval[dsdpnlpnonz] = lpval[i];
1220 assert(
isFixed(sdpisolver, lb[lpcol[i]], ub[lpcol[i]]) || rownactivevars[lprow[i]] == 1 );
1225 for (j = nextcol; j < nvars; j++)
1227 if ( sdpisolver->inputtodsdpmapper[j] >= 0 )
1229 assert( ! (
isFixed(sdpisolver, lb[j], ub[j])) );
1230 dsdplpbegcol[sdpisolver->inputtodsdpmapper[j]] = dsdpnlpnonz;
1234 dsdplprow[dsdpnlpnonz] = nlpcons;
1235 dsdplpval[dsdpnlpnonz] = obj[j];
1241 dsdplpbegcol[sdpisolver->nactivevars + 1] = dsdpnlpnonz;
1244 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1246 for (i = 0; i < nlpineqs; i++)
1248 dsdplprow[dsdpnlpnonz] = i;
1249 dsdplpval[dsdpnlpnonz] = -1.0;
1252 dsdplpbegcol[sdpisolver->nactivevars + 2] = dsdpnlpnonz;
1256 BMSfreeBufferMemoryArray(sdpisolver->bufmem, &rowmapper);
1261 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1263 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, 2*nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1264 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, 2*nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1268 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1269 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, nlpineqs + 2*lpnnonz, dsdpnlpnonz) );
1274 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1276 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs, dsdpnlpnonz) );
1277 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars + nlpineqs, dsdpnlpnonz) );
1281 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, (nlpineqs + 1) + 2*lpnnonz + nvars, dsdpnlpnonz) );
1282 BMS_CALL( BMSreallocBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, (nlpineqs + 1) + 2*lpnnonz + nvars, dsdpnlpnonz) );
1289 DSDP_CALL( LPConeSetData(sdpisolver->lpcone, nlpineqs, dsdplpbegcol, dsdplprow, dsdplpval) );
1293 DSDP_CALL( LPConeSetData(sdpisolver->lpcone, nlpineqs + 1, dsdplpbegcol, dsdplprow, dsdplpval) );
1295 #ifdef SCIP_MORE_DEBUG
1296 LPConeView(sdpisolver->lpcone);
1300 SCIPdebugMessage(
"Calling DSDP-Solve for SDP (%d) \n", sdpisolver->sdpcounter);
1302 DSDP_CALL( DSDPSetGapTolerance(sdpisolver->dsdp, sdpisolver->gaptol) );
1303 DSDP_CALL( DSDPSetRTolerance(sdpisolver->dsdp, sdpisolver->sdpsolverfeastol) );
1304 if ( sdpisolver-> sdpinfo )
1306 DSDP_CALL( DSDPSetStandardMonitor(sdpisolver->dsdp, 1) );
1310 if ( penaltyparam >= sdpisolver->epsilon && rbound )
1312 DSDP_CALL( DSDPSetPenaltyParameter(sdpisolver->dsdp, penaltyparam) );
1313 DSDP_CALL( DSDPUsePenalty(sdpisolver->dsdp, 1) );
1318 DSDP_CALL( DSDPSetPenaltyParameter(sdpisolver->dsdp, sdpisolver->penaltyparam) );
1322 if ( start != NULL )
1324 for (i = 1; i <= sdpisolver->nactivevars; i++)
1326 DSDP_CALL( DSDPSetY0(sdpisolver->dsdp, i, start[sdpisolver->dsdptoinputmapper[i]]) );
1336 DSDP_CALL( DSDPSolve(sdpisolver->dsdp) );
1338 sdpisolver->nsdpcalls++;
1339 DSDP_CALL( DSDPGetIts(sdpisolver->dsdp, &(sdpisolver->niterations)) );
1342 if ( timings.stopped )
1344 sdpisolver->timelimit = TRUE;
1345 sdpisolver->solved = FALSE;
1349 sdpisolver->timelimit = FALSE;
1350 DSDP_CALL( DSDPComputeX(sdpisolver->dsdp) );
1351 sdpisolver->solved = TRUE;
1356 feastol = sdpisolver->sdpsolverfeastol;
1360 SCIP_Real* solvector;
1362 SCIP_Bool infeasible;
1366 BMS_CALL( BMSallocBufferMemoryArray(sdpisolver->bufmem, &solvector, nvars) );
1367 nvarspointer = nvars;
1369 assert( nvarspointer == nvars );
1372 SCIP_CALL(
SCIPsdpSolcheckerCheck(sdpisolver->bufmem, nvars, lb, ub, nsdpblocks, sdpblocksizes, sdpnblockvars, sdpconstnnonz,
1373 sdpconstnblocknonz, sdpconstrow, sdpconstcol, sdpconstval, sdpnnonz, sdpnblockvarnonz, sdpvar, sdprow, sdpcol, sdpval,
1374 indchanges, nremovedinds, blockindchanges, nlpcons, noldlpcons, lplhs, lprhs, rownactivevars, lpnnonz, lprow, lpcol, lpval,
1375 solvector, sdpisolver->feastol, sdpisolver->epsilon, &infeasible) );
1377 BMSfreeBufferMemoryArray(sdpisolver->bufmem, &solvector);
1381 SCIPdebugMessage(
"Solution feasible for DSDP but outside feasibility tolerance, changing SDPA feasibility tolerance from %f to %f\n",
1388 DSDP_CALL( DSDPSetRTolerance(sdpisolver->dsdp, feastol) );
1390 DSDP_CALL( DSDPSolve(sdpisolver->dsdp) );
1393 sdpisolver->nsdpcalls++;
1394 DSDP_CALL( DSDPGetIts(sdpisolver->dsdp, &newiterations) );
1395 sdpisolver->niterations += newiterations;
1398 if ( timings.stopped )
1400 sdpisolver->timelimit = TRUE;
1401 sdpisolver->solved = FALSE;
1405 sdpisolver->timelimit = FALSE;
1406 DSDP_CALL( DSDPComputeX(sdpisolver->dsdp) );
1407 sdpisolver->solved = TRUE;
1412 sdpisolver->solved = FALSE;
1413 SCIPmessagePrintInfo(sdpisolver->messagehdlr,
"SDPA failed to reach required feasibility tolerance! \n");
1421 if ( sdpconstnnonz > 0 )
1423 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpconstval, sdpconstnnonz);
1424 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpconstind, sdpconstnnonz);
1429 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1431 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz + nrnonz);
1432 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz + nrnonz);
1436 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpval, sdpnnonz);
1437 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpind, sdpnnonz);
1441 if ( nlpcons > 0 || lpnnonz > 0 )
1443 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpval, dsdpnlpnonz);
1444 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplprow, dsdpnlpnonz);
1445 if ( penaltyparam > sdpisolver->epsilon && (! rbound) )
1447 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 3);
1451 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdplpbegcol, sdpisolver->nactivevars + 2);
1456 DSDP_CALL( DSDPStopReason(sdpisolver->dsdp, &reason) );
1460 case DSDP_CONVERGED:
1461 SCIPdebugMessage(
"DSDP converged!\n");
1464 case DSDP_INFEASIBLE_START:
1465 SCIPdebugMessage(
"DSDP started with an infeasible point!\n");
1468 case DSDP_SMALL_STEPS:
1469 SCIPdebugMessage(
"Short step lengths created by numerical difficulties prevented progress in DSDP!\n");
1472 case DSDP_INDEFINITE_SCHUR_MATRIX:
1473 SCIPdebugMessage(
"Schur Matrix in DSDP was indefinite but should have been positive semidefinite!\n");
1477 SCIPdebugMessage(
"DSDP reached maximum number of iterations!\n");
1480 case DSDP_NUMERICAL_ERROR:
1481 SCIPdebugMessage(
"A numerical error occured in DSDP!\n");
1484 case DSDP_UPPERBOUND:
1485 SCIPdebugMessage(
"Dual objective value in DSDP reached upper bound.\n");
1488 case DSDP_USER_TERMINATION:
1489 SCIPdebugMessage(
"DSDP didn't stop solving, did you?\n");
1492 case CONTINUE_ITERATING:
1493 SCIPdebugMessage(
"DSDP wants to continue iterating but somehow was stopped!\n");
1497 SCIPdebugMessage(
"Unknown stopping reason in DSDP!\n");
1502 if ( penaltyparam >= sdpisolver->epsilon && sdpisolver->solved )
1510 DSDP_CALL( DSDPGetR(sdpisolver->dsdp, &rval) );
1512 *feasorig = (rval < sdpisolver->feastol );
1517 sdpisolver->feasorig = *feasorig;
1524 if ( penaltybound != NULL )
1526 SCIPdebugMessage(
"Solution not feasible in original problem, r = %f\n", rval);
1529 DSDP_CALL( DSDPGetTraceX(sdpisolver->dsdp, &trace) );
1532 assert( trace < penaltyparam + sdpisolver->feastol );
1538 *penaltybound = TRUE;
1539 SCIPdebugMessage(
"Tr(X) = %f == %f = Gamma, penalty formulation not exact, Gamma should be increased or problem is infeasible\n",
1540 trace, penaltyparam);
1543 *penaltybound = FALSE;
1554 BMS_CALL( BMSallocBufferMemoryArray(sdpisolver->bufmem, &dsdpsol, sdpisolver->nactivevars + 1) );
1556 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, sdpisolver->nactivevars + 1) );
1558 *feasorig = (dsdpsol[sdpisolver->nactivevars] < sdpisolver->feastol);
1563 if ( penaltybound != NULL )
1565 SCIPdebugMessage(
"Solution not feasible in original problem, r = %f\n", dsdpsol[sdpisolver->nactivevars]);
1568 DSDP_CALL( DSDPGetTraceX(sdpisolver->dsdp, &trace) );
1571 assert( trace < penaltyparam + sdpisolver->feastol );
1577 *penaltybound = TRUE;
1578 SCIPdebugMessage(
"Tr(X) = %f == %f = Gamma, penalty formulation not exact, Gamma should be increased or problem is infeasible\n",
1579 trace, penaltyparam);
1582 *penaltybound = FALSE;
1587 BMSfreeBufferMemoryArray(sdpisolver->bufmem, &dsdpsol);
1610 assert( sdpisolver != NULL );
1611 return sdpisolver->solved;
1624 DSDPSolutionType pdfeasible;
1626 assert( sdpisolver != NULL );
1629 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1631 if ( pdfeasible == DSDP_PDUNKNOWN )
1640 SCIP_Bool* primalfeasible,
1641 SCIP_Bool* dualfeasible
1644 DSDPSolutionType pdfeasible;
1646 assert( sdpisolver != NULL );
1647 assert( primalfeasible != NULL );
1648 assert( dualfeasible != NULL );
1651 DSDP_CALL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1653 switch ( pdfeasible )
1655 case DSDP_PDFEASIBLE:
1656 *primalfeasible = TRUE;
1657 *dualfeasible = TRUE;
1660 case DSDP_UNBOUNDED:
1661 *primalfeasible = FALSE;
1662 *dualfeasible = TRUE;
1665 case DSDP_INFEASIBLE:
1666 *primalfeasible = TRUE;
1667 *dualfeasible = FALSE;
1671 SCIPerrorMessage(
"DSDP doesn't know if primal and dual solutions are feasible\n");
1672 return SCIP_LPERROR;
1684 DSDPSolutionType pdfeasible;
1686 assert( sdpisolver != NULL );
1689 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1690 if ( pdfeasible == DSDP_PDUNKNOWN )
1695 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible.");
1698 else if ( pdfeasible == DSDP_INFEASIBLE )
1710 DSDPSolutionType pdfeasible;
1712 assert( sdpisolver != NULL );
1715 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1716 if ( pdfeasible == DSDP_PDUNKNOWN )
1721 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1724 else if ( pdfeasible == DSDP_UNBOUNDED )
1736 DSDPSolutionType pdfeasible;
1738 assert( sdpisolver != NULL );
1741 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1742 if ( pdfeasible == DSDP_PDUNKNOWN )
1744 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1747 else if ( pdfeasible == DSDP_UNBOUNDED )
1759 DSDPSolutionType pdfeasible;
1761 assert( sdpisolver != NULL );
1764 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1765 if ( pdfeasible == DSDP_PDUNKNOWN )
1767 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1770 else if ( pdfeasible == DSDP_UNBOUNDED )
1782 DSDPSolutionType pdfeasible;
1784 assert( sdpisolver != NULL );
1787 DSDP_CALL_BOOL(DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible));
1789 if ( pdfeasible == DSDP_PDUNKNOWN )
1791 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1794 else if ( pdfeasible == DSDP_INFEASIBLE )
1806 DSDPSolutionType pdfeasible;
1808 assert( sdpisolver != NULL );
1811 DSDP_CALL_BOOL( DSDPGetSolutionType(sdpisolver->dsdp, &pdfeasible) );
1813 if ( pdfeasible == DSDP_PDUNKNOWN )
1815 SCIPdebugMessage(
"DSDP doesn't know if primal and dual solutions are feasible");
1818 else if ( pdfeasible == DSDP_INFEASIBLE )
1829 DSDPTerminationReason reason;
1831 assert( sdpisolver != NULL );
1833 if ( sdpisolver->timelimit )
1836 if ( ! sdpisolver->solved )
1841 if ( reason == DSDP_CONVERGED )
1852 SCIPdebugMessage(
"Method not implemented for DSDP, as objective limit is given as an ordinary LP-constraint, so in case the objective limit was "
1853 "exceeded, the problem will be reported as infeasible ! \n");
1863 DSDPTerminationReason reason;
1865 assert( sdpisolver != NULL );
1870 if ( reason == DSDP_MAX_IT )
1881 assert( sdpisolver != NULL );
1883 return sdpisolver->timelimit;
1900 DSDPTerminationReason reason;
1903 assert( sdpisolver != NULL );
1905 if ( sdpisolver->dsdp == NULL || (! sdpisolver->solved) )
1908 if ( sdpisolver->timelimit )
1911 dsdpreturn = DSDPStopReason(sdpisolver->dsdp, &reason);
1913 if (dsdpreturn != 0)
1915 SCIPerrorMessage(
"DSDP-Error <%d> in function call.\n", dsdpreturn);
1921 case DSDP_CONVERGED:
1924 case DSDP_INFEASIBLE_START:
1927 case DSDP_SMALL_STEPS:
1930 case DSDP_INDEFINITE_SCHUR_MATRIX:
1936 case DSDP_NUMERICAL_ERROR:
1939 case DSDP_UPPERBOUND:
1942 case DSDP_USER_TERMINATION:
1955 assert( sdpisolver != NULL );
1965 assert( sdpisolver != NULL );
1976 SCIPdebugMessage(
"Not implemented yet\n");
1977 return SCIP_LPERROR;
1989 assert( sdpisolver != NULL );
1990 assert( objval != NULL );
1993 dsdpnvars = sdpisolver->penaltyworbound ? sdpisolver->nactivevars + 1 : sdpisolver->nactivevars;
1995 if ( sdpisolver->penalty && ( ! sdpisolver->feasorig ))
1999 DSDP_CALL( DSDPGetDObjective(sdpisolver->dsdp, objval) );
2000 *objval = -1*(*objval);
2008 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars) );
2009 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, dsdpnvars) );
2013 for (v = 0; v < sdpisolver->nactivevars; v++)
2015 if ( REALABS(dsdpsol[v]) > sdpisolver->epsilon )
2016 *objval += sdpisolver->objcoefs[v] * dsdpsol[v];
2021 *objval += sdpisolver->fixedvarsobjcontr;
2023 if ( ( ! sdpisolver->penalty ) || sdpisolver->feasorig )
2025 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars);
2047 assert( sdpisolver != NULL );
2048 assert( dualsollength != NULL );
2051 dsdpnvars = sdpisolver->penaltyworbound ? sdpisolver->nactivevars + 1 : sdpisolver->nactivevars;
2053 if ( *dualsollength > 0 )
2055 assert( dualsol != NULL );
2056 if ( *dualsollength < sdpisolver->nvars )
2058 SCIPdebugMessage(
"The given array in SCIPsdpiSolverGetSol only had length %d, but %d was needed", *dualsollength, sdpisolver->nvars);
2059 *dualsollength = sdpisolver->nvars;
2064 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars) );
2065 DSDP_CALL( DSDPGetY(sdpisolver->dsdp, dsdpsol, dsdpnvars) );
2068 for (v = 0; v < sdpisolver->nvars; v++)
2070 if (sdpisolver->inputtodsdpmapper[v] > -1)
2073 dualsol[v] = dsdpsol[sdpisolver->inputtodsdpmapper[v] - 1];
2078 dualsol[v] = sdpisolver->fixedvarsval[(-1 * sdpisolver->inputtodsdpmapper[v]) - 1];
2082 if ( objval != NULL )
2084 if ( sdpisolver->penalty && ( ! sdpisolver->feasorig ))
2088 DSDP_CALL( DSDPGetDObjective(sdpisolver->dsdp, objval) );
2089 *objval = -1*(*objval);
2095 for (v = 0; v < sdpisolver->nactivevars; v++)
2097 if ( REALABS(dsdpsol[v]) > sdpisolver->epsilon )
2098 *objval += sdpisolver->objcoefs[v] * dsdpsol[v];
2103 *objval += sdpisolver->fixedvarsobjcontr;
2106 BMSfreeBlockMemoryArray(sdpisolver->blkmem, &dsdpsol, dsdpnvars);
2108 else if ( objval != NULL )
2131 SCIP_Real* lbvarsdsdp;
2132 SCIP_Real* ubvarsdsdp;
2135 assert( sdpisolver != NULL );
2136 assert( lbvars != NULL );
2137 assert( ubvars != NULL );
2138 assert( arraylength != NULL );
2139 assert( *arraylength >= 0 );
2143 if ( *arraylength < sdpisolver->nvars )
2145 *arraylength = sdpisolver->nvars;
2146 SCIPdebugMessage(
"Insufficient length of array in SCIPsdpiSolverGetPrimalBoundVars (gave %d, needed %d)\n", *arraylength, sdpisolver->nvars);
2151 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &lbvarsdsdp, sdpisolver->nactivevars) );
2152 BMS_CALL( BMSallocBlockMemoryArray(sdpisolver->blkmem, &ubvarsdsdp, sdpisolver->nactivevars) );
2155 DSDP_CALL( BConeCopyX(sdpisolver->bcone, lbvarsdsdp, ubvarsdsdp, sdpisolver->nactivevars) );
2158 for (i = 0; i < sdpisolver->nvars; i++)
2160 if ( sdpisolver->inputtodsdpmapper[i] < 0 )
2169 lbvars[i] = lbvarsdsdp[sdpisolver->inputtodsdpmapper[i] - 1];
2170 ubvars[i] = ubvarsdsdp[sdpisolver->inputtodsdpmapper[i] - 1];
2175 BMSfreeBlockMemoryArrayNull(sdpisolver->blkmem, &ubvarsdsdp, sdpisolver->nactivevars);
2176 BMSfreeBlockMemoryArrayNull(sdpisolver->blkmem, &lbvarsdsdp, sdpisolver->nactivevars);
2187 assert( sdpisolver != NULL );
2188 assert( iterations != NULL );
2190 if ( sdpisolver->timelimitinitial )
2193 *iterations = sdpisolver->niterations;
2204 assert( sdpisolver != NULL );
2205 assert( calls != NULL );
2207 if ( sdpisolver->timelimitinitial )
2210 *calls = sdpisolver->nsdpcalls;
2221 assert( sdpisolver != NULL );
2222 assert( usedsetting != NULL );
2227 *usedsetting = sdpisolver->usedsetting;
2268 assert( sdpisolver != NULL );
2269 assert( dval != NULL );
2274 *dval = sdpisolver->epsilon;
2277 *dval = sdpisolver->gaptol;
2280 *dval = sdpisolver->feastol;
2283 *dval = sdpisolver->sdpsolverfeastol;
2286 *dval = sdpisolver->penaltyparam;
2289 *dval = sdpisolver->objlimit;
2292 return SCIP_PARAMETERUNKNOWN;
2305 assert( sdpisolver != NULL );
2310 sdpisolver->epsilon = dval;
2311 SCIPdebugMessage(
"Setting sdpisolver epsilon to %f.\n", dval);
2314 sdpisolver->gaptol = dval;
2315 SCIPdebugMessage(
"Setting sdpisolver gaptol to %f.\n", dval);
2318 sdpisolver->feastol = dval;
2319 SCIPdebugMessage(
"Setting sdpisolver feastol to %f.\n", dval);
2322 sdpisolver->sdpsolverfeastol = dval;
2323 SCIPdebugMessage(
"Setting sdpisolver sdpsolverfeastol to %f.\n", dval);
2326 sdpisolver->penaltyparam = dval;
2327 SCIPdebugMessage(
"Setting sdpisolver penaltyparameter to %f.\n", dval);
2330 SCIPdebugMessage(
"Setting sdpisolver objlimit to %f.\n", dval);
2331 sdpisolver->objlimit = dval;
2334 SCIPdebugMessage(
"Parameter SCIP_SDPPAR_LAMBDASTAR not used by DSDP");
2337 return SCIP_PARAMETERUNKNOWN;
2350 assert( sdpisolver != NULL );
2355 *ival = (int) sdpisolver->sdpinfo;
2356 SCIPdebugMessage(
"Getting sdpisolver information output (%d).\n", *ival);
2359 return SCIP_PARAMETERUNKNOWN;
2372 assert( sdpisolver != NULL );
2377 sdpisolver->sdpinfo = (SCIP_Bool) ival;
2378 SCIPdebugMessage(
"Setting sdpisolver information output (%d).\n", ival);
2381 return SCIP_PARAMETERUNKNOWN;
2393 SCIPdebugMessage(
"Lambdastar parameter not used by DSDP");
2402 SCIP_Real* penaltyparam
2407 assert( sdpisolver != NULL );
2408 assert( penaltyparam != NULL );
2426 SCIPdebugMessage(
"Setting penaltyparameter to %f.\n", compval);
2427 sdpisolver->penaltyparam = compval;
2428 *penaltyparam = compval;
2436 SCIP_Real penaltyparam,
2437 SCIP_Real* maxpenaltyparam
2442 assert( sdpisolver != NULL );
2443 assert( maxpenaltyparam != NULL );
2449 *maxpenaltyparam = compval;
2450 SCIPdebugMessage(
"Setting maximum penaltyparameter to %f.\n", compval);
2459 if ( sdpisolver->penaltyparam > *maxpenaltyparam )
2461 SCIPdebugMessage(
"Decreasing penaltyparameter of %f to maximum penalty paramater of %f.\n", sdpisolver->penaltyparam, *maxpenaltyparam);
2462 sdpisolver->penaltyparam = *maxpenaltyparam;
2485 SCIPdebugMessage(
"Not implemented yet\n");
2486 return SCIP_LPERROR;
2495 SCIPdebugMessage(
"Not implemented yet\n");
2496 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)
int SCIPsdpiSolverGetDefaultSdpiSolverNpenaltyIncreases(void)
#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_RETCODE SCIPsdpiSolverCreate(SCIP_SDPISOLVER **sdpisolver, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, BMS_BUFMEM *bufmem)
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 SCIPsdpSolcheckerCheck(BMS_BUFMEM *bufmem, int nvars, 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 nlpcons, int noldlpcons, SCIP_Real *lplhs, SCIP_Real *lprhs, int *rownactivevars, int lpnnonz, int *lprow, int *lpcol, SCIP_Real *lpval, SCIP_Real *solvector, SCIP_Real feastol, SCIP_Real epsilon, SCIP_Bool *infeasible)
checks a given SDP solution for feasibility
SCIP_RETCODE SCIPsdpiSolverSetIntpar(SCIP_SDPISOLVER *sdpisolver, SCIP_SDPPARAM type, int ival)
SCIP_Bool SCIPsdpiSolverIsIterlimExc(SCIP_SDPISOLVER *sdpisolver)
#define INFEASFEASTOLCHANGE
#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 SCIPsdpiSolverIgnoreInstability(SCIP_SDPISOLVER *sdpisolver, SCIP_Bool *success)
struct SCIP_SDPiSolver SCIP_SDPISOLVER
SCIP_Real SCIPsdpiSolverGetDefaultSdpiSolverFeastol(void)
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)