00001
00006 #include "dsdp.h"
00007 #include "dsdp5.h"
00008 #include "dsdpsys.h"
00009
00023 #undef __FUNCT__
00024 #define __FUNCT__ "DSDPSetDualObjective"
00025 int DSDPSetDualObjective(DSDP dsdp,int i, double bi){
00026 int info;
00027 DSDPFunctionBegin;
00028 DSDPValid(dsdp);
00029 if (i>dsdp->m || i<=0){
00030 DSDPSETERR2(1,"Invalid variable number: Is 1 <= %d <= %d?\n",i,dsdp->m);}
00031 info=DSDPVecSetElement(dsdp->b,i,bi);DSDPCHKERR(info);
00032 DSDPFunctionReturn(0);
00033 }
00034
00044 #undef __FUNCT__
00045 #define __FUNCT__ "DSDPCopyB"
00046 int DSDPCopyB(DSDP dsdp,double bb[], int m){
00047 int i,info;
00048 double *b;
00049 DSDPFunctionBegin;
00050 DSDPValid(dsdp);
00051 if (dsdp->m < m) DSDPFunctionReturn(1);
00052 info=DSDPVecGetArray(dsdp->b,&b);DSDPCHKERR(info);
00053 for (i=0;i<m;i++) bb[i]=b[i+1];
00054 info=DSDPVecRestoreArray(dsdp->b,&b);DSDPCHKERR(info);
00055 DSDPFunctionReturn(0);
00056 }
00057
00058
00075 #undef __FUNCT__
00076 #define __FUNCT__ "DSDPSetY0"
00077 int DSDPSetY0(DSDP dsdp,int i, double yi0){
00078 int info;double scale;
00079 DSDPFunctionBegin;
00080 DSDPValid(dsdp);
00081 if (i>dsdp->m || i<=0){
00082 DSDPSETERR2(1,"Invalid variable number: Is 1<= %d <= %d\n",i,dsdp->m);}
00083 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00084 info=DSDPVecSetElement(dsdp->y,i,scale*yi0);DSDPCHKERR(info);
00085 DSDPFunctionReturn(0);
00086 }
00087
00098 #undef __FUNCT__
00099 #define __FUNCT__ "DSDPGetY"
00100 int DSDPGetY(DSDP dsdp,double y[], int m){
00101 int i,info;
00102 double scale,*yy;
00103 DSDPFunctionBegin;
00104 DSDPValid(dsdp);
00105 if (dsdp->m < m-1) DSDPFunctionReturn(1);
00106 if (dsdp->m > m) DSDPFunctionReturn(1);
00107 info=DSDPVecCopy(dsdp->xmaker[0].y,dsdp->ytemp); DSDPCHKERR(info);
00108 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00109 info=DSDPVecGetArray(dsdp->ytemp,&yy);DSDPCHKERR(info);
00110 for (i=0;i<m;i++) y[i]=yy[i+1]/scale;
00111 info=DSDPVecRestoreArray(dsdp->ytemp,&yy);DSDPCHKERR(info);
00112 DSDPFunctionReturn(0);
00113 }
00114
00127 #undef __FUNCT__
00128 #define __FUNCT__ "DSDPGetYMakeX"
00129 int DSDPGetYMakeX(DSDP dsdp,double y[], int m){
00130 int i,info;
00131 double scale,*yy;
00132 DSDPFunctionBegin;
00133 DSDPValid(dsdp);
00134 if (dsdp->m < m-1) DSDPFunctionReturn(1);
00135 if (dsdp->m > m) DSDPFunctionReturn(1);
00136 info=DSDPVecCopy(dsdp->xmaker[0].y,dsdp->ytemp); DSDPCHKERR(info);
00137 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00138 info=DSDPVecGetArray(dsdp->ytemp,&yy);DSDPCHKERR(info);
00139 for (i=0;i<m;i++) y[i]=yy[i+1]/scale;
00140 info=DSDPVecRestoreArray(dsdp->ytemp,&yy);DSDPCHKERR(info);
00141 DSDPFunctionReturn(0);
00142 }
00143
00155 #undef __FUNCT__
00156 #define __FUNCT__ "DSDPGetDYMakeX"
00157 int DSDPGetDYMakeX(DSDP dsdp,double dy[], int m){
00158 int i,info;
00159 double scale,*yy;
00160 DSDPFunctionBegin;
00161 DSDPValid(dsdp);
00162 if (dsdp->m < m-1) DSDPFunctionReturn(1);
00163 if (dsdp->m > m) DSDPFunctionReturn(1);
00164 info=DSDPVecCopy(dsdp->xmaker[0].dy,dsdp->ytemp); DSDPCHKERR(info);
00165 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00166 info=DSDPVecGetArray(dsdp->ytemp,&yy);DSDPCHKERR(info);
00167 for (i=0;i<m;i++) dy[i]=yy[i+1]/scale;
00168 info=DSDPVecRestoreArray(dsdp->ytemp,&yy);DSDPCHKERR(info);
00169 DSDPFunctionReturn(0);
00170 }
00171
00183 #undef __FUNCT__
00184 #define __FUNCT__ "DSDPGetMuMakeX"
00185 int DSDPGetMuMakeX(DSDP dsdp,double *mu){
00186 int info;
00187 double scale;
00188 DSDPFunctionBegin;
00189 DSDPValid(dsdp);
00190 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00191 *mu=dsdp->xmaker[0].mu/scale;
00192 DSDPFunctionReturn(0);
00193 }
00194
00195
00196
00206 #undef __FUNCT__
00207 #define __FUNCT__ "DSDPGetScale"
00208 int DSDPGetScale(DSDP dsdp,double *scale){
00209 int info;double sscale;
00210 DSDPFunctionBegin;
00211 DSDPValid(dsdp);
00212 info=DSDPVecGetC(dsdp->y,&sscale);DSDPCHKERR(info);
00213 *scale=fabs(sscale);
00214 if (sscale==0) *scale=1.0;
00215 DSDPFunctionReturn(0);
00216 }
00217
00231 #undef __FUNCT__
00232 #define __FUNCT__ "DSDPSetScale"
00233 int DSDPSetScale(DSDP dsdp,double scale){
00234 int info;double sscale;
00235 DSDPFunctionBegin;
00236 DSDPValid(dsdp);
00237 scale=fabs(scale);
00238 if (scale==0) scale=1.0;
00239 info=DSDPGetScale(dsdp,&sscale);DSDPCHKERR(info);
00240 sscale=scale/sscale;
00241 info=DSDPVecScale(sscale,dsdp->y);
00242 dsdp->mutarget*=sscale;
00243 dsdp->pobj*=sscale;
00244 dsdp->dobj*=sscale;
00245 dsdp->ppobj*=sscale;
00246 dsdp->ddobj*=sscale;
00247 dsdp->mu*=sscale;
00248 DSDPLogInfo(0,2,"Set DSDP C Scaling: %4.4e\n",scale);
00249 DSDPFunctionReturn(0);
00250 }
00251
00263 #undef __FUNCT__
00264 #define __FUNCT__ "DSDPAddObjectiveConstant"
00265 int DSDPAddObjectiveConstant(DSDP dsdp,double c){
00266 int info;
00267 DSDPFunctionBegin;
00268 DSDPValid(dsdp);
00269 info=DSDPVecSetC(dsdp->b,-c);DSDPCHKERR(info);
00270 DSDPLogInfo(0,2,"Add Objective Constant: %4.4e\n",c);
00271 DSDPFunctionReturn(0);
00272 }
00273
00284 #undef __FUNCT__
00285 #define __FUNCT__ "DSDPSetMaxIts"
00286 int DSDPSetMaxIts(DSDP dsdp,int its){
00287 DSDPFunctionBegin;
00288 DSDPValid(dsdp);
00289 if (its >= 0) dsdp->maxiter = its;
00290 DSDPLogInfo(0,2,"Set Maximum Iterates: %4d\n",its);
00291 DSDPFunctionReturn(0);
00292 }
00293
00303 #undef __FUNCT__
00304 #define __FUNCT__ "DSDPGetMaxIts"
00305 int DSDPGetMaxIts(DSDP dsdp,int *its){
00306 DSDPFunctionBegin;
00307 DSDPValid(dsdp);
00308 *its=dsdp->maxiter;
00309 DSDPFunctionReturn(0);
00310 }
00311
00312
00329 #undef __FUNCT__
00330 #define __FUNCT__ "DSDPGetPInfeasibility"
00331 int DSDPGetPInfeasibility(DSDP dsdp, double *pperror){
00332 DSDPFunctionBegin;
00333 DSDPValid(dsdp);
00334 if (pperror) *pperror=dsdp->pinfeas;
00335 DSDPFunctionReturn(0);
00336 }
00337
00351 #undef __FUNCT__
00352 #define __FUNCT__ "DSDPSetPTolerance"
00353 int DSDPSetPTolerance(DSDP dsdp,double inftol){
00354 DSDPFunctionBegin;
00355 DSDPValid(dsdp);
00356 if (inftol > 0) dsdp->pinfeastol = inftol;
00357 DSDPLogInfo(0,2,"Set P Infeasibility Tolerance: %4.4e\n",inftol);
00358 DSDPFunctionReturn(0);
00359 }
00360
00372 #undef __FUNCT__
00373 #define __FUNCT__ "DSDPGetPTolerance"
00374 int DSDPGetPTolerance(DSDP dsdp,double *inftol){
00375 DSDPFunctionBegin;
00376 DSDPValid(dsdp);
00377 if (inftol) *inftol=dsdp->pinfeastol;
00378 DSDPFunctionReturn(0);
00379 }
00380
00394 #undef __FUNCT__
00395 #define __FUNCT__ "DSDPSetRTolerance"
00396 int DSDPSetRTolerance(DSDP dsdp,double inftol){
00397 DSDPFunctionBegin;
00398 DSDPValid(dsdp);
00399 if (inftol > 0) dsdp->dinfeastol = inftol;
00400 DSDPLogInfo(0,2,"Set D Infeasibility Tolerance: %4.4e\n",inftol);
00401 DSDPFunctionReturn(0);
00402 }
00403
00419 #undef __FUNCT__
00420 #define __FUNCT__ "DSDPGetRTolerance"
00421 int DSDPGetRTolerance(DSDP dsdp,double *inftol){
00422 DSDPFunctionBegin;
00423 DSDPValid(dsdp);
00424 *inftol=dsdp->dinfeastol;
00425 DSDPFunctionReturn(0);
00426 }
00427
00439 #undef __FUNCT__
00440 #define __FUNCT__ "DSDPSetMaxTrustRadius"
00441 int DSDPSetMaxTrustRadius(DSDP dsdp,double rad){
00442 DSDPFunctionBegin;
00443 DSDPValid(dsdp);
00444 if (rad > 0) dsdp->maxtrustradius = rad;
00445 DSDPLogInfo(0,2,"Set Maximum Trust Radius: %4.4e\n",rad);
00446 DSDPFunctionReturn(0);
00447 }
00448
00458 #undef __FUNCT__
00459 #define __FUNCT__ "DSDPGetMaxTrustRadius"
00460 int DSDPGetMaxTrustRadius(DSDP dsdp,double *rad){
00461 DSDPFunctionBegin;
00462 DSDPValid(dsdp);
00463 *rad=dsdp->maxtrustradius;
00464 DSDPFunctionReturn(0);
00465 }
00466
00476 #undef __FUNCT__
00477 #define __FUNCT__ "DSDPSetZBar"
00478 int DSDPSetZBar(DSDP dsdp,double ppobj){
00479 int info;
00480 double scale;
00481 DSDPFunctionBegin;
00482 DSDPValid(dsdp);
00483 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00484 dsdp->ppobj=ppobj*scale;
00485 DSDPLogInfo(0,2,"Set Primal Objective and Upper bound on solution: %4.4e. \n",ppobj);
00486 DSDPFunctionReturn(0);
00487 }
00488
00504 #undef __FUNCT__
00505 #define __FUNCT__ "DSDPSetR0"
00506 int DSDPSetR0(DSDP dsdp,double res){
00507 int info;
00508 double scale;
00509 DSDPFunctionBegin;
00510 DSDPValid(dsdp);
00511 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00512 info=DSDPSetRR(dsdp,scale*res); DSDPCHKERR(info);
00513 if (res>=0)dsdp->goty0=DSDP_TRUE;
00514 DSDPLogInfo(0,2,"Set Dual Initial Infeasibility to %4.4e times Identity Matrix. \n",res);
00515 DSDPFunctionReturn(0);
00516 }
00517
00533 #undef __FUNCT__
00534 #define __FUNCT__ "DSDPSetBarrierParameter"
00535 int DSDPSetBarrierParameter(DSDP dsdp,double mu){
00536 int info;double scale;
00537 DSDPFunctionBegin;
00538 DSDPValid(dsdp);
00539 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00540 dsdp->mutarget = mu*scale;
00541 DSDPLogInfo(0,2,"Set InitialBarrierParameter: %4.4e \n",mu);
00542 DSDPFunctionReturn(0);
00543 }
00544
00557 #undef __FUNCT__
00558 #define __FUNCT__ "DSDPGetBarrierParameter"
00559 int DSDPGetBarrierParameter(DSDP dsdp, double *mu){
00560 int info;double scale;
00561 DSDPFunctionBegin;
00562 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00563 *mu=dsdp->mutarget/scale;
00564 DSDPFunctionReturn(0);
00565 }
00566
00567
00576 #undef __FUNCT__
00577 #define __FUNCT__ "DSDPUsePenalty"
00578 int DSDPUsePenalty(DSDP dsdp,int yesorno){
00579 DSDPPenalty UsePenalty;
00580 int info;
00581 DSDPFunctionBegin;
00582 DSDPValid(dsdp);
00583 if (yesorno>0){
00584 UsePenalty=DSDPAlways;
00585 } else if (yesorno<0){
00586 UsePenalty=DSDPNever;
00587 } else {
00588 UsePenalty=DSDPInfeasible;
00589 }
00590 dsdp->UsePenalty=UsePenalty;
00591 info=RConeSetType(dsdp->rcone,UsePenalty);DSDPCHKERR(info);
00592 DSDPLogInfo(0,2,"Set UsePenalty: %d \n",yesorno);
00593 DSDPFunctionReturn(0);
00594 }
00595
00611 #undef __FUNCT__
00612 #define __FUNCT__ "DSDPSetPenaltyParameter"
00613 int DSDPSetPenaltyParameter(DSDP dsdp,double Gamma){
00614 int info;
00615 double scale,ppenalty;
00616 DSDPFunctionBegin;
00617 DSDPValid(dsdp);
00618 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00619 ppenalty=fabs(Gamma*scale);
00620 info=DSDPVecSetR(dsdp->b,ppenalty);DSDPCHKERR(info);
00621 DSDPLogInfo(0,2,"Set Penalty Parameter: %4.4e\n",Gamma);
00622 DSDPFunctionReturn(0);
00623 }
00624
00636 #undef __FUNCT__
00637 #define __FUNCT__ "DSDPGetPenaltyParameter"
00638 int DSDPGetPenaltyParameter(DSDP dsdp,double *Gamma){
00639 int info;
00640 double ppenalty;
00641 DSDPFunctionBegin;
00642 DSDPValid(dsdp);
00643 info=DSDPVecGetR(dsdp->b,&ppenalty);DSDPCHKERR(info);
00644 *Gamma=fabs(ppenalty);
00645 DSDPFunctionReturn(0);
00646 }
00647
00648
00649
00650 #undef __FUNCT__
00651 #define __FUNCT__ "DSDPGetPenalty"
00652 int DSDPGetPenalty(DSDP dsdp,double *penalty){
00653 int info;double ppenalty;
00654 DSDPFunctionBegin;
00655 DSDPValid(dsdp);
00656 info=DSDPVecGetR(dsdp->b,&ppenalty);DSDPCHKERR(info);
00657 *penalty=fabs(ppenalty);
00658 DSDPFunctionReturn(0);
00659 }
00660
00661
00673 #undef __FUNCT__
00674 #define __FUNCT__ "DSDPGetPObjective"
00675 int DSDPGetPObjective(DSDP dsdp,double *pobj){
00676 int info;
00677 double scale;
00678 DSDPFunctionBegin;
00679 DSDPValid(dsdp);
00680 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00681 *pobj=(dsdp->pobj)/scale;
00682 DSDPFunctionReturn(0);
00683 }
00684
00685
00695 #undef __FUNCT__
00696 #define __FUNCT__ "DSDPGetPPObjective"
00697 int DSDPGetPPObjective(DSDP dsdp,double *ppobj){
00698 int info;
00699 double scale;
00700 DSDPFunctionBegin;
00701 DSDPValid(dsdp);
00702 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00703 *ppobj=(dsdp->ppobj)/scale;
00704 if (dsdp->cnorm==0) *ppobj=0;
00705 DSDPFunctionReturn(0);
00706 }
00707
00718 #undef __FUNCT__
00719 #define __FUNCT__ "DSDPGetDObjective"
00720 int DSDPGetDObjective(DSDP dsdp,double *dobj){
00721 int info; double scale;
00722 DSDPFunctionBegin;
00723 DSDPValid(dsdp);
00724 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00725 *dobj = (dsdp->dobj)/scale;
00726 if (dsdp->cnorm==0) *dobj=-fabs(*dobj);
00727 DSDPFunctionReturn(0);
00728 }
00739 #undef __FUNCT__
00740 #define __FUNCT__ "DSDPGetDDObjective"
00741 int DSDPGetDDObjective(DSDP dsdp,double *ddobj){
00742 int info; double scale;
00743 DSDPFunctionBegin;
00744 DSDPValid(dsdp);
00745 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00746 *ddobj = (dsdp->ddobj)/scale;
00747 if (dsdp->cnorm==0) *ddobj=-fabs(*ddobj);
00748 DSDPFunctionReturn(0);
00749 }
00750
00761 #undef __FUNCT__
00762 #define __FUNCT__ "DSDPGetDualityGap"
00763 int DSDPGetDualityGap(DSDP dsdp,double *dgap){
00764 int info; double scale;
00765 DSDPFunctionBegin;
00766 DSDPValid(dsdp);
00767 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00768 *dgap = (dsdp->dualitygap)/scale;
00769 DSDPFunctionReturn(0);
00770 }
00771
00780 #undef __FUNCT__
00781 #define __FUNCT__ "DSDPGetIts"
00782 int DSDPGetIts(DSDP dsdp,int *its){
00783 DSDPFunctionBegin;
00784 DSDPValid(dsdp);
00785 *its=dsdp->itnow;
00786 DSDPFunctionReturn(0);
00787 }
00788
00798 #undef __FUNCT__
00799 #define __FUNCT__ "DSDPStopReason"
00800 int DSDPStopReason(DSDP dsdp,DSDPTerminationReason *reason){
00801 DSDPFunctionBegin;
00802 DSDPValid(dsdp);
00803 *reason=dsdp->reason;
00804 DSDPFunctionReturn(0);
00805 }
00806
00817 #undef __FUNCT__
00818 #define __FUNCT__ "DSDPGetSolutionType"
00819 int DSDPGetSolutionType(DSDP dsdp,DSDPSolutionType *pdfeasible){
00820 DSDPFunctionBegin;
00821 DSDPValid(dsdp);
00822 *pdfeasible=dsdp->pdfeasible;
00823 DSDPFunctionReturn(0);
00824 }
00825
00835 #undef __FUNCT__
00836 #define __FUNCT__ "DSDPGetR"
00837 int DSDPGetR(DSDP dsdp, double *res){
00838 int info;double rr,scale;
00839 DSDPFunctionBegin;
00840 DSDPValid(dsdp);
00841 info=DSDPGetRR(dsdp,&rr);DSDPCHKERR(info);
00842 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00843 *res=rr/scale;
00844 DSDPFunctionReturn(0);
00845 }
00846
00855 #undef __FUNCT__
00856 #define __FUNCT__ "DSDPGetDataNorms"
00857 int DSDPGetDataNorms(DSDP dsdp, double dnorm[3]){
00858 int info;
00859 DSDPFunctionBegin;
00860 DSDPValid(dsdp);
00861 if (dsdp->setupcalled==DSDP_FALSE){
00862 info=DSDPComputeDataNorms(dsdp);DSDPCHKERR(info);
00863 }
00864 dnorm[0]=dsdp->cnorm;
00865 dnorm[1]=dsdp->anorm;
00866 dnorm[2]=dsdp->bnorm;
00867 DSDPFunctionReturn(0);
00868 }
00869
00886 #undef __FUNCT__
00887 #define __FUNCT__ "DSDPGetTraceX"
00888 int DSDPGetTraceX(DSDP dsdp, double *tracex){
00889 DSDPFunctionBegin;
00890 DSDPValid(dsdp);
00891 *tracex=dsdp->tracex;
00892 DSDPFunctionReturn(0);
00893 }
00894
00905 #undef __FUNCT__
00906 #define __FUNCT__ "DSDPGetFinalErrors"
00907 int DSDPGetFinalErrors(DSDP dsdp, double err[6]){
00908 int info;
00909 double scale,rr,bnorm,dobj=0,pobj=0;
00910 DSDPFunctionBegin;
00911 DSDPValid(dsdp);
00912 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00913 info=DSDPVecGetR(dsdp->y,&rr); DSDPCHKERR(info);
00914 info=DSDPGetPObjective(dsdp,&pobj);DSDPCHKERR(info);
00915 info=DSDPGetDObjective(dsdp,&dobj);DSDPCHKERR(info);
00916 err[0]=dsdp->perror;
00917 err[1]=0;
00918 err[2]=fabs(rr)/scale;
00919 err[3]=0;
00920 err[4]=pobj - dobj;
00921 err[5]=dsdp->tracexs/scale;
00922
00923 err[2] /= (1.0+dsdp->cnorm);
00924 info=DSDPVecCopy(dsdp->b,dsdp->ytemp);DSDPCHKERR(info);
00925 info=DSDPVecSetC(dsdp->ytemp,0);DSDPCHKERR(info);
00926 info=DSDPVecSetR(dsdp->ytemp,0);DSDPCHKERR(info);
00927 info=DSDPVecNormInfinity(dsdp->ytemp,&bnorm);
00928 err[0]=dsdp->perror/(1.0+bnorm);
00929
00930 err[4]=(err[4])/(1.0+fabs(pobj)+fabs(dobj));
00931 err[5]=(err[5])/(1.0+fabs(pobj)+fabs(dobj));
00932 DSDPFunctionReturn(0);
00933 }
00934
00943 #undef __FUNCT__
00944 #define __FUNCT__ "DSDPGetMaxYElement"
00945 int DSDPGetMaxYElement(DSDP dsdp,double* ymax){
00946 int info;
00947 DSDPFunctionBegin;
00948 info=DSDPGetYMaxNorm(dsdp,ymax);DSDPCHKERR(info);
00949 DSDPFunctionReturn(0);
00950 }
00951
00952 #undef __FUNCT__
00953 #define __FUNCT__ "DSDPGetDimension"
00954
00961 int DSDPGetDimension(DSDP dsdp, double *n){
00962 int info;
00963 DSDPFunctionBegin;
00964 info=DSDPGetConicDimension(dsdp,n);DSDPCHKERR(info);
00965 DSDPFunctionReturn(0);
00966 }
00967
00976 #undef __FUNCT__
00977 #define __FUNCT__ "DSDPGetYMaxNorm"
00978 int DSDPGetYMaxNorm(DSDP dsdp, double *ynorm){
00979 int info;
00980 double cc,rr,yy;
00981 DSDPFunctionBegin;
00982 DSDPValid(dsdp);
00983 info=DSDPVecGetC(dsdp->y,&cc);DSDPCHKERR(info);
00984 info=DSDPVecGetR(dsdp->y,&rr);DSDPCHKERR(info);
00985 info=DSDPVecSetC(dsdp->y,0);DSDPCHKERR(info);
00986 info=DSDPVecSetR(dsdp->y,0);DSDPCHKERR(info);
00987 info=DSDPVecNormInfinity(dsdp->y,&yy);DSDPCHKERR(info);
00988 info=DSDPVecSetC(dsdp->y,cc);DSDPCHKERR(info);
00989 info=DSDPVecSetR(dsdp->y,rr);DSDPCHKERR(info);
00990 if (cc) yy/=fabs(cc);
00991 if (ynorm) *ynorm=yy;
00992 DSDPFunctionReturn(0);
00993 }
00994
01005 #undef __FUNCT__
01006 #define __FUNCT__ "DSDPGetNumberOfVariables"
01007 int DSDPGetNumberOfVariables(DSDP dsdp, int *m){
01008 DSDPFunctionBegin;
01009 DSDPValid(dsdp);
01010 *m=dsdp->m;
01011 DSDPFunctionReturn(0);
01012 }
01013
01022 #undef __FUNCT__
01023 #define __FUNCT__ "DSDPGetPnorm"
01024 int DSDPGetPnorm(DSDP dsdp, double *pnorm){
01025 DSDPFunctionBegin;
01026 DSDPValid(dsdp);
01027 *pnorm=dsdp->pnorm;
01028 DSDPFunctionReturn(0);
01029 }
01030
01040 #undef __FUNCT__
01041 #define __FUNCT__ "DSDPGetStepLengths"
01042 int DSDPGetStepLengths(DSDP dsdp, double *pstep, double *dstep){
01043 DSDPFunctionBegin;
01044 DSDPValid(dsdp);
01045 *dstep=dsdp->dstep;
01046 *pstep=dsdp->pstep;
01047 DSDPFunctionReturn(0);
01048 }
01049
01063 #undef __FUNCT__
01064 #define __FUNCT__ "DSDPSetPotentialParameter"
01065 int DSDPSetPotentialParameter(DSDP dsdp, double rho){
01066 DSDPFunctionBegin;
01067 DSDPValid(dsdp);
01068 if (rho>1) dsdp->rhon=rho;
01069 DSDPLogInfo(0,2,"Set Potential Parameter %4.4f\n",rho);
01070 DSDPFunctionReturn(0);
01071 }
01072
01082 #undef __FUNCT__
01083 #define __FUNCT__ "DSDPGetPotentialParameter"
01084 int DSDPGetPotentialParameter(DSDP dsdp, double *rho){
01085 DSDPFunctionBegin;
01086 DSDPValid(dsdp);
01087 *rho=dsdp->rhon;
01088 DSDPFunctionReturn(0);
01089 }
01090
01101 #undef __FUNCT__
01102 #define __FUNCT__ "DSDPGetPotential"
01103 int DSDPGetPotential(DSDP dsdp, double *potential){
01104 DSDPFunctionBegin;
01105 DSDPValid(dsdp);
01106 *potential=dsdp->potential;
01107 DSDPFunctionReturn(0);
01108 }
01109
01119 #undef __FUNCT__
01120 #define __FUNCT__ "DSDPUseDynamicRho"
01121 int DSDPUseDynamicRho(DSDP dsdp, int yesorno){
01122 DSDPFunctionBegin;
01123 DSDPValid(dsdp);
01124 if (yesorno) dsdp->usefixedrho=DSDP_FALSE;
01125 else dsdp->usefixedrho=DSDP_TRUE;
01126 DSDPLogInfo(0,2,"Set UseDynamicRho: %d \n",yesorno);
01127 DSDPFunctionReturn(0);
01128 }
01129
01130
01131
01132 #undef __FUNCT__
01133 #define __FUNCT__ "DSDPBoundDualVariables"
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144 int DSDPBoundDualVariables(DSDP dsdp,double lbound, double ubound){
01145 int info;
01146 double bbound;
01147 DSDPFunctionBegin;
01148 bbound=DSDPMax(fabs(lbound),fabs(ubound));
01149 DSDPLogInfo(0,2,"Bound Variables between %4.4e and %4.4e \n",-bbound,bbound);
01150 info = BoundYConeSetBounds(dsdp->ybcone,-bbound,bbound);DSDPCHKERR(info);
01151 DSDPFunctionReturn(0);
01152 }
01153
01164 #undef __FUNCT__
01165 #define __FUNCT__ "DSDPGetYBounds"
01166 int DSDPGetYBounds(DSDP dsdp,double *lbound, double *ubound){
01167 int info;
01168 DSDPFunctionBegin;
01169 info=BoundYConeGetBounds(dsdp->ybcone,lbound,ubound);DSDPCHKERR(info);
01170 DSDPFunctionReturn(0);
01171 }
01172
01183 #undef __FUNCT__
01184 #define __FUNCT__ "DSDPSetYBounds"
01185 int DSDPSetYBounds(DSDP dsdp,double lbound, double ubound){
01186 int info;
01187 DSDPFunctionBegin;
01188 info=BoundYConeSetBounds(dsdp->ybcone,lbound,ubound);DSDPCHKERR(info);
01189 DSDPFunctionReturn(0);
01190 }
01191
01192
01193
01203 #undef __FUNCT__
01204 #define __FUNCT__ "DSDPReuseMatrix"
01205 int DSDPReuseMatrix(DSDP dsdp, int rm){
01206 DSDPFunctionBegin;
01207 DSDPValid(dsdp);
01208 dsdp->reuseM=rm;
01209 DSDPLogInfo(0,2,"Reuse the Schur Matrix: %d times\n",rm);
01210 DSDPFunctionReturn(0);
01211 }
01212
01213
01223 #undef __FUNCT__
01224 #define __FUNCT__ "DSDPGetReuseMatrix"
01225 int DSDPGetReuseMatrix(DSDP dsdp, int *rm){
01226 DSDPFunctionBegin;
01227 DSDPValid(dsdp);
01228 *rm=dsdp->reuseM;
01229 DSDPFunctionReturn(0);
01230 }
01231
01232
01243 #undef __FUNCT__
01244 #define __FUNCT__ "DSDPSetMonitor"
01245 int DSDPSetMonitor(DSDP dsdp, int (*monitor)(DSDP,void*), void* monitorctx){
01246 DSDPFunctionBegin;
01247 DSDPValid(dsdp);
01248 if (dsdp->nmonitors<MAX_DSDP_MONITORS){
01249 DSDPLogInfo(0,2,"Set Monitor\n");
01250 dsdp->dmonitor[dsdp->nmonitors].monitor=monitor;
01251 dsdp->dmonitor[dsdp->nmonitors].monitorctx=monitorctx;
01252 dsdp->nmonitors++;
01253 }
01254 DSDPFunctionReturn(0);
01255 }
01256
01266 #undef __FUNCT__
01267 #define __FUNCT__ "DSDPSetConvergenceFlag"
01268 int DSDPSetConvergenceFlag(DSDP dsdp, DSDPTerminationReason reason ){
01269 DSDPFunctionBegin;
01270 DSDPValid(dsdp);
01271 dsdp->reason=reason;
01272 if (reason==DSDP_INFEASIBLE_START){
01273 DSDPLogInfo(0,2,"Initial Point Infeasible, Check variable bounds? \n",0);
01274 }
01275 DSDPFunctionReturn(0);
01276 }
01277