dsdpsetdata.c

Go to the documentation of this file.
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 /* Not current; not documented
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 /* Not Current or documented
00831 */
00832 #undef __FUNCT__
00833 #define __FUNCT__ "DSDPBoundDualVariables"
00834 /* !
00835 \fn int DSDPBoundDualVariables(DSDP dsdp, double lbound, double ubound)
00836 \brief Bounds on the variables y.
00837 
00838 \param dsdp is the solver
00839 \param lbound will be the lower bound of the variables y
00840 \param ubound will be the upper bound of the variables y
00841 \sa DSDPSetYBounds()
00842 \ingroup DSDPSolver
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 

Generated on Sun Mar 23 07:30:49 2008 for DSDP by  doxygen 1.5.5