Main Page | Modules | Alphabetical List | Data Structures | Directories | File List | Globals | Related Pages

dsdpsetdata.c

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 /* Not current; not documented
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 /* Not Current or documented
01131 */
01132 #undef __FUNCT__
01133 #define __FUNCT__ "DSDPBoundDualVariables"
01134 /* !
01135 \fn int DSDPBoundDualVariables(DSDP dsdp, double lbound, double ubound)
01136 \brief Bounds on the variables y.
01137 
01138 \param dsdp is the solver
01139 \param lbound will be the lower bound of the variables y
01140 \param ubound will be the upper bound of the variables y
01141 \sa DSDPSetYBounds()
01142 \ingroup DSDPSolver
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 

Generated on Sat Oct 15 11:05:39 2005 for DSDP by  doxygen 1.4.2