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
00115
00116
00126 #undef __FUNCT__
00127 #define __FUNCT__ "DSDPGetScale"
00128 int DSDPGetScale(DSDP dsdp,double *scale){
00129 int info;double sscale;
00130 DSDPFunctionBegin;
00131 DSDPValid(dsdp);
00132 info=DSDPVecGetC(dsdp->y,&sscale);DSDPCHKERR(info);
00133 *scale=fabs(sscale);
00134 if (sscale==0) *scale=1.0;
00135 DSDPFunctionReturn(0);
00136 }
00137
00151 #undef __FUNCT__
00152 #define __FUNCT__ "DSDPSetScale"
00153 int DSDPSetScale(DSDP dsdp,double scale){
00154 int info;double sscale;
00155 DSDPFunctionBegin;
00156 DSDPValid(dsdp);
00157 scale=fabs(scale);
00158 if (scale==0) scale=1.0;
00159 info=DSDPGetScale(dsdp,&sscale);DSDPCHKERR(info);
00160 sscale=scale/sscale;
00161 info=DSDPVecScale(sscale,dsdp->y);
00162 dsdp->mutarget*=sscale;
00163 dsdp->pobj*=sscale;
00164 dsdp->dobj*=sscale;
00165 dsdp->ppobj*=sscale;
00166 dsdp->ddobj*=sscale;
00167 dsdp->mu*=sscale;
00168 DSDPLogInfo(0,2,"Set DSDP C Scaling: %4.4e\n",scale);
00169 DSDPFunctionReturn(0);
00170 }
00171
00183 #undef __FUNCT__
00184 #define __FUNCT__ "DSDPAddObjectiveConstant"
00185 int DSDPAddObjectiveConstant(DSDP dsdp,double c){
00186 int info;
00187 DSDPFunctionBegin;
00188 DSDPValid(dsdp);
00189 info=DSDPVecSetC(dsdp->b,-c);DSDPCHKERR(info);
00190 DSDPLogInfo(0,2,"Add Objective Constant: %4.4e\n",c);
00191 DSDPFunctionReturn(0);
00192 }
00193
00204 #undef __FUNCT__
00205 #define __FUNCT__ "DSDPSetMaxIts"
00206 int DSDPSetMaxIts(DSDP dsdp,int its){
00207 DSDPFunctionBegin;
00208 DSDPValid(dsdp);
00209 if (its >= 0) dsdp->maxiter = its;
00210 DSDPLogInfo(0,2,"Set Maximum Iterates: %4d\n",its);
00211 DSDPFunctionReturn(0);
00212 }
00213
00223 #undef __FUNCT__
00224 #define __FUNCT__ "DSDPGetMaxIts"
00225 int DSDPGetMaxIts(DSDP dsdp,int *its){
00226 DSDPFunctionBegin;
00227 DSDPValid(dsdp);
00228 *its=dsdp->maxiter;
00229 DSDPFunctionReturn(0);
00230 }
00231
00232
00244 #undef __FUNCT__
00245 #define __FUNCT__ "DSDPSetMaxTrustRadius"
00246 int DSDPSetMaxTrustRadius(DSDP dsdp,double rad){
00247 DSDPFunctionBegin;
00248 DSDPValid(dsdp);
00249 if (rad > 0) dsdp->maxtrustradius = rad;
00250 DSDPLogInfo(0,2,"Set Maximum Trust Radius: %4.4e\n",rad);
00251 DSDPFunctionReturn(0);
00252 }
00253
00263 #undef __FUNCT__
00264 #define __FUNCT__ "DSDPGetMaxTrustRadius"
00265 int DSDPGetMaxTrustRadius(DSDP dsdp,double *rad){
00266 DSDPFunctionBegin;
00267 DSDPValid(dsdp);
00268 *rad=dsdp->maxtrustradius;
00269 DSDPFunctionReturn(0);
00270 }
00271
00281 #undef __FUNCT__
00282 #define __FUNCT__ "DSDPSetZBar"
00283 int DSDPSetZBar(DSDP dsdp,double ppobj){
00284 int info;
00285 double scale;
00286 DSDPFunctionBegin;
00287 DSDPValid(dsdp);
00288 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00289 dsdp->ppobj=ppobj*scale;
00290 DSDPLogInfo(0,2,"Set Primal Objective and Upper bound on solution: %4.4e. \n",ppobj);
00291 DSDPFunctionReturn(0);
00292 }
00293
00309 #undef __FUNCT__
00310 #define __FUNCT__ "DSDPSetR0"
00311 int DSDPSetR0(DSDP dsdp,double res){
00312 int info;
00313 double scale;
00314 DSDPFunctionBegin;
00315 DSDPValid(dsdp);
00316 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00317 info=DSDPSetRR(dsdp,scale*res); DSDPCHKERR(info);
00318 if (res>=0)dsdp->goty0=DSDP_TRUE;
00319 DSDPLogInfo(0,2,"Set Dual Initial Infeasibility to %4.4e times Identity Matrix. \n",res);
00320 DSDPFunctionReturn(0);
00321 }
00322
00338 #undef __FUNCT__
00339 #define __FUNCT__ "DSDPSetBarrierParameter"
00340 int DSDPSetBarrierParameter(DSDP dsdp,double mu){
00341 int info;double scale;
00342 DSDPFunctionBegin;
00343 DSDPValid(dsdp);
00344 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00345 dsdp->mutarget = mu*scale;
00346 DSDPLogInfo(0,2,"Set InitialBarrierParameter: %4.4e \n",mu);
00347 DSDPFunctionReturn(0);
00348 }
00349
00362 #undef __FUNCT__
00363 #define __FUNCT__ "DSDPGetBarrierParameter"
00364 int DSDPGetBarrierParameter(DSDP dsdp, double *mu){
00365 int info;double scale;
00366 DSDPFunctionBegin;
00367 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00368 *mu=dsdp->mutarget/scale;
00369 DSDPFunctionReturn(0);
00370 }
00371
00372
00381 #undef __FUNCT__
00382 #define __FUNCT__ "DSDPUsePenalty"
00383 int DSDPUsePenalty(DSDP dsdp,int yesorno){
00384 DSDPPenalty UsePenalty;
00385 int info;
00386 DSDPFunctionBegin;
00387 DSDPValid(dsdp);
00388 if (yesorno>0){
00389 UsePenalty=DSDPAlways;
00390 } else if (yesorno<0){
00391 UsePenalty=DSDPNever;
00392 } else {
00393 UsePenalty=DSDPInfeasible;
00394 }
00395 dsdp->UsePenalty=UsePenalty;
00396 info=RConeSetType(dsdp->rcone,UsePenalty);DSDPCHKERR(info);
00397 DSDPLogInfo(0,2,"Set UsePenalty: %d \n",yesorno);
00398 DSDPFunctionReturn(0);
00399 }
00400
00416 #undef __FUNCT__
00417 #define __FUNCT__ "DSDPSetPenaltyParameter"
00418 int DSDPSetPenaltyParameter(DSDP dsdp,double Gamma){
00419 int info;
00420 double scale,ppenalty;
00421 DSDPFunctionBegin;
00422 DSDPValid(dsdp);
00423 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00424 ppenalty=fabs(Gamma*scale);
00425 info=DSDPVecSetR(dsdp->b,ppenalty);DSDPCHKERR(info);
00426 DSDPLogInfo(0,2,"Set Penalty Parameter: %4.4e\n",Gamma);
00427 DSDPFunctionReturn(0);
00428 }
00429
00441 #undef __FUNCT__
00442 #define __FUNCT__ "DSDPGetPenaltyParameter"
00443 int DSDPGetPenaltyParameter(DSDP dsdp,double *Gamma){
00444 int info;
00445 double ppenalty;
00446 DSDPFunctionBegin;
00447 DSDPValid(dsdp);
00448 info=DSDPVecGetR(dsdp->b,&ppenalty);DSDPCHKERR(info);
00449 *Gamma=fabs(ppenalty);
00450 DSDPFunctionReturn(0);
00451 }
00452
00453
00454
00455 #undef __FUNCT__
00456 #define __FUNCT__ "DSDPGetPenalty"
00457 int DSDPGetPenalty(DSDP dsdp,double *penalty){
00458 int info;double ppenalty;
00459 DSDPFunctionBegin;
00460 DSDPValid(dsdp);
00461 info=DSDPVecGetR(dsdp->b,&ppenalty);DSDPCHKERR(info);
00462 *penalty=fabs(ppenalty);
00463 DSDPFunctionReturn(0);
00464 }
00465
00466
00467
00477 #undef __FUNCT__
00478 #define __FUNCT__ "DSDPGetPPObjective"
00479 int DSDPGetPPObjective(DSDP dsdp,double *ppobj){
00480 int info;
00481 double scale;
00482 DSDPFunctionBegin;
00483 DSDPValid(dsdp);
00484 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00485 *ppobj=(dsdp->ppobj)/scale;
00486 if (dsdp->cnorm==0) *ppobj=0;
00487 DSDPFunctionReturn(0);
00488 }
00489
00500 #undef __FUNCT__
00501 #define __FUNCT__ "DSDPGetDObjective"
00502 int DSDPGetDObjective(DSDP dsdp,double *dobj){
00503 int info; double scale;
00504 DSDPFunctionBegin;
00505 DSDPValid(dsdp);
00506 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00507 *dobj = (dsdp->dobj)/scale;
00508 if (dsdp->cnorm==0) *dobj=-fabs(*dobj);
00509 DSDPFunctionReturn(0);
00510 }
00521 #undef __FUNCT__
00522 #define __FUNCT__ "DSDPGetDDObjective"
00523 int DSDPGetDDObjective(DSDP dsdp,double *ddobj){
00524 int info; double scale;
00525 DSDPFunctionBegin;
00526 DSDPValid(dsdp);
00527 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00528 *ddobj = (dsdp->ddobj)/scale;
00529 if (dsdp->cnorm==0) *ddobj=-fabs(*ddobj);
00530 DSDPFunctionReturn(0);
00531 }
00532
00543 #undef __FUNCT__
00544 #define __FUNCT__ "DSDPGetDualityGap"
00545 int DSDPGetDualityGap(DSDP dsdp,double *dgap){
00546 int info; double scale;
00547 DSDPFunctionBegin;
00548 DSDPValid(dsdp);
00549 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00550 *dgap = (dsdp->dualitygap)/scale;
00551 DSDPFunctionReturn(0);
00552 }
00553
00562 #undef __FUNCT__
00563 #define __FUNCT__ "DSDPGetIts"
00564 int DSDPGetIts(DSDP dsdp,int *its){
00565 DSDPFunctionBegin;
00566 DSDPValid(dsdp);
00567 *its=dsdp->itnow;
00568 DSDPFunctionReturn(0);
00569 }
00570
00580 #undef __FUNCT__
00581 #define __FUNCT__ "DSDPStopReason"
00582 int DSDPStopReason(DSDP dsdp,DSDPTerminationReason *reason){
00583 DSDPFunctionBegin;
00584 DSDPValid(dsdp);
00585 *reason=dsdp->reason;
00586 DSDPFunctionReturn(0);
00587 }
00588
00589
00599 #undef __FUNCT__
00600 #define __FUNCT__ "DSDPGetR"
00601 int DSDPGetR(DSDP dsdp, double *res){
00602 int info;double rr,scale;
00603 DSDPFunctionBegin;
00604 DSDPValid(dsdp);
00605 info=DSDPGetRR(dsdp,&rr);DSDPCHKERR(info);
00606 info=DSDPGetScale(dsdp,&scale);DSDPCHKERR(info);
00607 *res=rr/scale;
00608 DSDPFunctionReturn(0);
00609 }
00610
00619 #undef __FUNCT__
00620 #define __FUNCT__ "DSDPGetDataNorms"
00621 int DSDPGetDataNorms(DSDP dsdp, double dnorm[3]){
00622 int info;
00623 DSDPFunctionBegin;
00624 DSDPValid(dsdp);
00625 if (dsdp->setupcalled==DSDP_FALSE){
00626 info=DSDPComputeDataNorms(dsdp);DSDPCHKERR(info);
00627 }
00628 dnorm[0]=dsdp->cnorm;
00629 dnorm[1]=dsdp->anorm;
00630 dnorm[2]=dsdp->bnorm;
00631 DSDPFunctionReturn(0);
00632 }
00633
00634
00643 #undef __FUNCT__
00644 #define __FUNCT__ "DSDPGetMaxYElement"
00645 int DSDPGetMaxYElement(DSDP dsdp,double* ymax){
00646 int info;
00647 DSDPFunctionBegin;
00648 info=DSDPGetYMaxNorm(dsdp,ymax);DSDPCHKERR(info);
00649 DSDPFunctionReturn(0);
00650 }
00651
00652 #undef __FUNCT__
00653 #define __FUNCT__ "DSDPGetDimension"
00654
00661 int DSDPGetDimension(DSDP dsdp, double *n){
00662 int info;
00663 DSDPFunctionBegin;
00664 info=DSDPGetConicDimension(dsdp,n);DSDPCHKERR(info);
00665 DSDPFunctionReturn(0);
00666 }
00667
00676 #undef __FUNCT__
00677 #define __FUNCT__ "DSDPGetYMaxNorm"
00678 int DSDPGetYMaxNorm(DSDP dsdp, double *ynorm){
00679 int info;
00680 double cc,rr,yy;
00681 DSDPFunctionBegin;
00682 DSDPValid(dsdp);
00683 info=DSDPVecGetC(dsdp->y,&cc);DSDPCHKERR(info);
00684 info=DSDPVecGetR(dsdp->y,&rr);DSDPCHKERR(info);
00685 info=DSDPVecSetC(dsdp->y,0);DSDPCHKERR(info);
00686 info=DSDPVecSetR(dsdp->y,0);DSDPCHKERR(info);
00687 info=DSDPVecNormInfinity(dsdp->y,&yy);DSDPCHKERR(info);
00688 info=DSDPVecSetC(dsdp->y,cc);DSDPCHKERR(info);
00689 info=DSDPVecSetR(dsdp->y,rr);DSDPCHKERR(info);
00690 if (cc) yy/=fabs(cc);
00691 if (ynorm) *ynorm=yy;
00692 DSDPFunctionReturn(0);
00693 }
00694
00705 #undef __FUNCT__
00706 #define __FUNCT__ "DSDPGetNumberOfVariables"
00707 int DSDPGetNumberOfVariables(DSDP dsdp, int *m){
00708 DSDPFunctionBegin;
00709 DSDPValid(dsdp);
00710 *m=dsdp->m;
00711 DSDPFunctionReturn(0);
00712 }
00713
00722 #undef __FUNCT__
00723 #define __FUNCT__ "DSDPGetPnorm"
00724 int DSDPGetPnorm(DSDP dsdp, double *pnorm){
00725 DSDPFunctionBegin;
00726 DSDPValid(dsdp);
00727 *pnorm=dsdp->pnorm;
00728 DSDPFunctionReturn(0);
00729 }
00730
00740 #undef __FUNCT__
00741 #define __FUNCT__ "DSDPGetStepLengths"
00742 int DSDPGetStepLengths(DSDP dsdp, double *pstep, double *dstep){
00743 DSDPFunctionBegin;
00744 DSDPValid(dsdp);
00745 *dstep=dsdp->dstep;
00746 *pstep=dsdp->pstep;
00747 DSDPFunctionReturn(0);
00748 }
00749
00763 #undef __FUNCT__
00764 #define __FUNCT__ "DSDPSetPotentialParameter"
00765 int DSDPSetPotentialParameter(DSDP dsdp, double rho){
00766 DSDPFunctionBegin;
00767 DSDPValid(dsdp);
00768 if (rho>1) dsdp->rhon=rho;
00769 DSDPLogInfo(0,2,"Set Potential Parameter %4.4f\n",rho);
00770 DSDPFunctionReturn(0);
00771 }
00772
00782 #undef __FUNCT__
00783 #define __FUNCT__ "DSDPGetPotentialParameter"
00784 int DSDPGetPotentialParameter(DSDP dsdp, double *rho){
00785 DSDPFunctionBegin;
00786 DSDPValid(dsdp);
00787 *rho=dsdp->rhon;
00788 DSDPFunctionReturn(0);
00789 }
00790
00801 #undef __FUNCT__
00802 #define __FUNCT__ "DSDPGetPotential"
00803 int DSDPGetPotential(DSDP dsdp, double *potential){
00804 DSDPFunctionBegin;
00805 DSDPValid(dsdp);
00806 *potential=dsdp->potential;
00807 DSDPFunctionReturn(0);
00808 }
00809
00819 #undef __FUNCT__
00820 #define __FUNCT__ "DSDPUseDynamicRho"
00821 int DSDPUseDynamicRho(DSDP dsdp, int yesorno){
00822 DSDPFunctionBegin;
00823 DSDPValid(dsdp);
00824 if (yesorno) dsdp->usefixedrho=DSDP_FALSE;
00825 else dsdp->usefixedrho=DSDP_TRUE;
00826 DSDPLogInfo(0,2,"Set UseDynamicRho: %d \n",yesorno);
00827 DSDPFunctionReturn(0);
00828 }
00829
00830
00831
00832 #undef __FUNCT__
00833 #define __FUNCT__ "DSDPBoundDualVariables"
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844 int DSDPBoundDualVariables(DSDP dsdp,double lbound, double ubound){
00845 int info;
00846 double bbound;
00847 DSDPFunctionBegin;
00848 bbound=DSDPMax(fabs(lbound),fabs(ubound));
00849 DSDPLogInfo(0,2,"Bound Variables between %4.4e and %4.4e \n",-bbound,bbound);
00850 info = BoundYConeSetBounds(dsdp->ybcone,-bbound,bbound);DSDPCHKERR(info);
00851 DSDPFunctionReturn(0);
00852 }
00853
00864 #undef __FUNCT__
00865 #define __FUNCT__ "DSDPGetYBounds"
00866 int DSDPGetYBounds(DSDP dsdp,double *lbound, double *ubound){
00867 int info;
00868 DSDPFunctionBegin;
00869 info=BoundYConeGetBounds(dsdp->ybcone,lbound,ubound);DSDPCHKERR(info);
00870 DSDPFunctionReturn(0);
00871 }
00872
00883 #undef __FUNCT__
00884 #define __FUNCT__ "DSDPSetYBounds"
00885 int DSDPSetYBounds(DSDP dsdp,double lbound, double ubound){
00886 int info;
00887 DSDPFunctionBegin;
00888 info=BoundYConeSetBounds(dsdp->ybcone,lbound,ubound);DSDPCHKERR(info);
00889 DSDPFunctionReturn(0);
00890 }
00891
00892
00893
00903 #undef __FUNCT__
00904 #define __FUNCT__ "DSDPReuseMatrix"
00905 int DSDPReuseMatrix(DSDP dsdp, int rm){
00906 DSDPFunctionBegin;
00907 DSDPValid(dsdp);
00908 dsdp->reuseM=rm;
00909 DSDPLogInfo(0,2,"Reuse the Schur Matrix: %d times\n",rm);
00910 DSDPFunctionReturn(0);
00911 }
00912
00913
00923 #undef __FUNCT__
00924 #define __FUNCT__ "DSDPGetReuseMatrix"
00925 int DSDPGetReuseMatrix(DSDP dsdp, int *rm){
00926 DSDPFunctionBegin;
00927 DSDPValid(dsdp);
00928 *rm=dsdp->reuseM;
00929 DSDPFunctionReturn(0);
00930 }
00931
00932
00943 #undef __FUNCT__
00944 #define __FUNCT__ "DSDPSetMonitor"
00945 int DSDPSetMonitor(DSDP dsdp, int (*monitor)(DSDP,void*), void* monitorctx){
00946 DSDPFunctionBegin;
00947 DSDPValid(dsdp);
00948 if (dsdp->nmonitors<MAX_DSDP_MONITORS){
00949 DSDPLogInfo(0,2,"Set Monitor\n");
00950 dsdp->dmonitor[dsdp->nmonitors].monitor=monitor;
00951 dsdp->dmonitor[dsdp->nmonitors].monitorctx=monitorctx;
00952 dsdp->nmonitors++;
00953 }
00954 DSDPFunctionReturn(0);
00955 }
00956
00966 #undef __FUNCT__
00967 #define __FUNCT__ "DSDPSetConvergenceFlag"
00968 int DSDPSetConvergenceFlag(DSDP dsdp, DSDPTerminationReason reason ){
00969 DSDPFunctionBegin;
00970 DSDPValid(dsdp);
00971 dsdp->reason=reason;
00972 if (reason==DSDP_INFEASIBLE_START){
00973 DSDPLogInfo(0,2,"Initial Point Infeasible, Check variable bounds? \n",0);
00974 }
00975 DSDPFunctionReturn(0);
00976 }
00977