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

dsdpsetup.c

00001 #include "dsdp.h"
00002 #include "dsdpsys.h"
00003 #include "dsdp5.h"
00028 #undef __FUNCT__  
00029 #define __FUNCT__ "DSDPCreate"
00030 int DSDPCreate(int m,DSDP* dsdpnew){
00031 
00032   DSDP dsdp;
00033   int info;
00034 
00035   DSDPFunctionBegin;
00036 
00037   DSDPCALLOC1(&dsdp,PD_DSDP,&info);DSDPCHKERR(info);
00038   *dsdpnew=dsdp;
00039   dsdp->keyid=DSDPKEY;
00040 
00041   /* Initialize some parameters */
00042   DSDPEventLogInitialize();
00043   dsdp->m=m;
00044   dsdp->maxcones=0;
00045   dsdp->ncones=0;
00046   dsdp->K=0;
00047   dsdp->setupcalled=DSDP_FALSE;
00048   dsdp->ybcone=0;
00049   dsdp->ndroutines=0;
00050   /*  info = DSDPSetStandardMonitor(dsdp);DSDPCHKERR(info);  */
00051   info = DSDPVecCreateSeq(m+2,&dsdp->b);DSDPCHKERR(info);
00052   info = DSDPVecZero(dsdp->b);DSDPCHKERR(info);
00053   info = DSDPVecDuplicate(dsdp->b,&dsdp->y);DSDPCHKERR(info);
00054   info = DSDPVecDuplicate(dsdp->b,&dsdp->ytemp);DSDPCHKERR(info);
00055   info = DSDPVecZero(dsdp->y);DSDPCHKERR(info);
00056   info = DSDPVecSetC(dsdp->y,-1.0);DSDPCHKERR(info);
00057 
00058   info = DSDPAddRCone(dsdp,&dsdp->rcone);DSDPCHKERR(info);
00059   info = DSDPCreateLUBoundsCone(dsdp,&dsdp->ybcone);DSDPCHKERR(info);
00060 
00061   info=DSDPSetDefaultStatistics(dsdp);DSDPCHKERR(info);
00062   info=DSDPSetDefaultParameters(dsdp);DSDPCHKERR(info);
00063   info=DSDPSetDefaultMonitors(dsdp);DSDPCHKERR(info);
00064 
00065   /*  info = DSDPMatInitialize(m,m,&dsdp->Q);DSDPCHKERR(info); */
00066   info = DSDPSchurMatInitialize(&dsdp->M);DSDPCHKERR(info);
00067   info = DSDPSetDefaultSchurMatrixStructure(dsdp); DSDPCHKERR(info);
00068   info = DSDPCGInitialize(&dsdp->sles); DSDPCHKERR(info);
00069 
00070   /* Set the one global variable
00071      sdat=dsdp;
00072   */
00073   DSDPFunctionReturn(0);
00074 }
00075 
00076 
00077 #undef __FUNCT__  
00078 #define __FUNCT__ "DSDPSetDefaultStatistics"
00079 
00084 int DSDPSetDefaultStatistics(DSDP dsdp){
00085   
00086   int i;
00087   DSDPFunctionBegin;
00088   DSDPValid(dsdp);
00089   dsdp->reason=CONTINUE_ITERATING;
00090   dsdp->pdfeasible=DSDP_PDUNKNOWN;
00091   dsdp->itnow=0;
00092   dsdp->pobj=  1.0e10;
00093   dsdp->ppobj=  1.0e10;
00094   dsdp->dobj= -1.0e+9;
00095   dsdp->ddobj= -1.0e+9;
00096   dsdp->dualitygap=dsdp->ppobj-dsdp->ddobj;
00097   dsdp->pstep=1.0;
00098   dsdp->dstep=0.0;
00099   for (i=0;i<MAX_XMAKERS;i++){
00100     dsdp->xmaker[i].mu=1.0e200;
00101     dsdp->xmaker[i].pstep=0.0;
00102   }
00103   dsdp->pnorm=0.001;
00104   dsdp->mu=1000.0;
00105   dsdp->np=0;
00106   dsdp->anorm=0;
00107   dsdp->bnorm=0;
00108   dsdp->cnorm=0;
00109   dsdp->tracex=0;
00110   dsdp->tracexs=0;
00111   dsdp->Mshift=0;
00112   dsdp->goty0=DSDP_FALSE;
00113   DSDPFunctionReturn(0);
00114 }
00115 #undef __FUNCT__  
00116 #define __FUNCT__ "DSDPSetDefaultParameters"
00117 
00122 int DSDPSetDefaultParameters(DSDP dsdp){
00123   
00124   int info;
00125   DSDPFunctionBegin;
00126   DSDPValid(dsdp);
00127 
00128   /* Stopping parameters */
00129   info=DSDPSetMaxIts(dsdp,500);DSDPCHKERR(info);
00130   info=DSDPSetGapTolerance(dsdp,1.0e-6);DSDPCHKERR(info);
00131   info=DSDPSetPNormTolerance(dsdp,1.0e30);DSDPCHKERR(info);
00132   if (dsdp->m<100){info=DSDPSetGapTolerance(dsdp,1.0e-7);DSDPCHKERR(info);}
00133   if (dsdp->m>3000){info=DSDPSetGapTolerance(dsdp,5.0e-6);DSDPCHKERR(info);}
00134   info=RConeSetType(dsdp->rcone,DSDPInfeasible);DSDPCHKERR(info);
00135   info=DSDPSetDualBound(dsdp,1.0e20);DSDPCHKERR(info);
00136   info=DSDPSetStepTolerance(dsdp,5.0e-2);DSDPCHKERR(info);
00137   info=DSDPSetRTolerance(dsdp,1.0e-6);DSDPCHKERR(info);
00138   info=DSDPSetPTolerance(dsdp,1.0e-4);DSDPCHKERR(info);
00139   /* Solver options */
00140   info=DSDPSetMaxTrustRadius(dsdp,1.0e10);DSDPCHKERR(info);
00141   info=DSDPUsePenalty(dsdp,0);DSDPCHKERR(info);
00142   info=DSDPSetInitialBarrierParameter(dsdp,-1.0);DSDPCHKERR(info);
00143   info=DSDPSetPotentialParameter(dsdp,3.0);DSDPCHKERR(info);
00144   info=DSDPUseDynamicRho(dsdp,1);DSDPCHKERR(info);
00145   info=DSDPSetR0(dsdp,-1.0);DSDPCHKERR(info);
00146   info=DSDPSetPenaltyParameter(dsdp,1.0e8);DSDPCHKERR(info);
00147   info=DSDPReuseMatrix(dsdp,4);DSDPCHKERR(info);
00148   if (dsdp->m>100){info=DSDPReuseMatrix(dsdp,7);DSDPCHKERR(info);}
00149   if (dsdp->m>1000){info=DSDPReuseMatrix(dsdp,10);DSDPCHKERR(info);}
00150   if (dsdp->m<=100){info=DSDPSetPotentialParameter(dsdp,5.0);DSDPCHKERR(info);DSDPCHKERR(info);}
00151   dsdp->maxschurshift=1.0e-11;
00152   dsdp->mu0=-1.0;
00153   dsdp->slestype=2;
00154   info = DSDPSetYBounds(dsdp,-1e7,1e7);DSDPCHKERR(info);
00155   DSDPFunctionReturn(0);
00156 }
00157 
00158 #undef __FUNCT__  
00159 #define __FUNCT__ "DSDPSetDefaultMonitors"
00160 
00165 int DSDPSetDefaultMonitors(DSDP dsdp){
00166   
00167   int info;
00168 
00169   DSDPFunctionBegin;
00170   DSDPValid(dsdp);
00171   dsdp->nmonitors=0;
00172   info=DSDPSetMonitor(dsdp,DSDPDefaultConvergence,(void*)&dsdp->conv); DSDPCHKERR(info);
00173   DSDPFunctionReturn(0);
00174 }
00175 
00191 #undef __FUNCT__  
00192 #define __FUNCT__ "DSDPSetUp"
00193 int DSDPSetup(DSDP dsdp){
00194   
00195   int i,info;
00196   DSDPFunctionBegin;
00197   DSDPValid(dsdp);
00198   
00199   /* Create the Work Vectors */
00200   info = DSDPVecDuplicate(dsdp->y,&dsdp->rhs1);DSDPCHKERR(info);
00201   info = DSDPVecDuplicate(dsdp->y,&dsdp->rhs2);DSDPCHKERR(info);
00202   info = DSDPVecDuplicate(dsdp->y,&dsdp->rhs);DSDPCHKERR(info);
00203   info = DSDPVecDuplicate(dsdp->y,&dsdp->rhstemp);DSDPCHKERR(info);
00204   info = DSDPVecDuplicate(dsdp->y,&dsdp->dy1);DSDPCHKERR(info);
00205   info = DSDPVecDuplicate(dsdp->y,&dsdp->dy2);DSDPCHKERR(info);
00206   info = DSDPVecDuplicate(dsdp->y,&dsdp->dy);DSDPCHKERR(info);
00207   info = DSDPVecDuplicate(dsdp->y,&dsdp->y0);DSDPCHKERR(info);
00208   info = DSDPVecDuplicate(dsdp->y,&dsdp->xmakerrhs);DSDPCHKERR(info);
00209   for (i=0;i<MAX_XMAKERS;i++){
00210     info = DSDPVecDuplicate(dsdp->y,&dsdp->xmaker[i].y);DSDPCHKERR(info);
00211     info = DSDPVecDuplicate(dsdp->y,&dsdp->xmaker[i].dy);DSDPCHKERR(info);
00212     info = DSDPVecDuplicate(dsdp->y,&dsdp->xmaker[i].rhs);DSDPCHKERR(info);
00213   }
00214 
00215   /* Create M */
00216   info = DSDPSetUpCones(dsdp);DSDPCHKERR(info);
00217   info = DSDPSchurMatSetup(dsdp->M,dsdp->ytemp);DSDPCHKERR(info); 
00218 
00219   info = DSDPCGSetup(dsdp->sles,dsdp->ytemp); DSDPCHKERR(info);
00220 
00221   info = DSDPSetUpCones2(dsdp,dsdp->y,dsdp->M);DSDPCHKERR(info);
00222   info = DSDPGetConicDimension(dsdp,&dsdp->np);DSDPCHKERR(info);
00223 
00224   info=DSDPComputeDataNorms(dsdp);DSDPCHKERR(info);
00225   dsdp->pinfeas=dsdp->bnorm+1;
00226   dsdp->perror=dsdp->bnorm+1;
00227   info=DSDPScaleData(dsdp);DSDPCHKERR(info);
00228 
00229   info=DSDPGetConicDimension(dsdp,&dsdp->np);DSDPCHKERR(info);
00230   dsdp->solvetime=0;
00231   dsdp->cgtime=0;
00232   dsdp->ptime=0;
00233   dsdp->dtime=0;
00234   dsdp->ctime=0;
00235   info=DSDPEventLogRegister("Primal Step",&dsdp->ptime);
00236   info=DSDPEventLogRegister("Dual Step",&dsdp->dtime);
00237   info=DSDPEventLogRegister("Corrector Step",&dsdp->ctime);
00238   info=DSDPEventLogRegister("CG Solve",&dsdp->cgtime);
00239   info=DSDPEventLogRegister("DSDP Solve",&dsdp->solvetime);
00240   dsdp->setupcalled=DSDP_TRUE;
00241   DSDPFunctionReturn(0);
00242 }
00243 
00244 
00245 
00246 #undef __FUNCT__
00247 #define __FUNCT__ "DSDPGetSchurMatrix"
00248 int DSDPGetSchurMatrix(DSDP dsdp, DSDPSchurMat *M){
00249   DSDPFunctionBegin;
00250   DSDPValid(dsdp);
00251   *M=dsdp->M;
00252   DSDPFunctionReturn(0);
00253 }
00254 
00255 #undef __FUNCT__  
00256 #define __FUNCT__ "DSDPGetConvergenceMonitor"
00257 
00268 int DSDPGetConvergenceMonitor(DSDP dsdp, ConvergenceMonitor**ctx){
00269   DSDPFunctionBegin;
00270   DSDPValid(dsdp);
00271   *ctx=&dsdp->conv;
00272   DSDPFunctionReturn(0);
00273 }
00274 
00275 
00276 #undef __FUNCT__  
00277 #define __FUNCT__ "DSDPComputeDataNorms"
00278 
00283 int DSDPComputeDataNorms(DSDP dsdp){
00284   int info;
00285   DSDPVec ytemp=dsdp->ytemp;
00286   DSDPFunctionBegin;
00287   DSDPValid(dsdp);
00288   info = DSDPComputeANorm2(dsdp,ytemp);DSDPCHKERR(info);
00289   info = DSDPFixedVariablesNorm(dsdp->M,ytemp);DSDPCHKERR(info);
00290   info = DSDPVecGetC(ytemp,&dsdp->cnorm);DSDPCHKERR(info);
00291   dsdp->cnorm=sqrt(dsdp->cnorm);
00292   info = DSDPVecSetR(ytemp,0);DSDPCHKERR(info);
00293   info = DSDPVecSetC(ytemp,0);DSDPCHKERR(info);
00294   info = DSDPVecNorm1(ytemp,&dsdp->anorm);DSDPCHKERR(info);
00295   dsdp->anorm=sqrt(dsdp->anorm);
00296   DSDPLogInfo(0,2,"Norm of data: %4.2e\n",dsdp->anorm);
00297   info=DSDPVecCopy(dsdp->b,ytemp);DSDPCHKERR(info);
00298   info = DSDPVecSetR(ytemp,0);DSDPCHKERR(info);
00299   info = DSDPVecSetC(ytemp,0);DSDPCHKERR(info);
00300   info = DSDPVecNorm2(ytemp,&dsdp->bnorm);DSDPCHKERR(info);
00301   DSDPFunctionReturn(0);
00302 }
00303 
00304 #undef __FUNCT__  
00305 #define __FUNCT__ "DSDPScaleData"
00306 
00311 int DSDPScaleData(DSDP dsdp){
00312   int info;
00313   double scale;
00314   DSDPFunctionBegin;
00315   DSDPValid(dsdp);
00316   scale=1.0*dsdp->anorm;
00317   if (dsdp->bnorm){ scale/=dsdp->bnorm;}
00318   if (dsdp->cnorm){ scale/=dsdp->cnorm;}
00319   scale=DSDPMin(scale,1.0);
00320   scale=DSDPMax(scale,1.0e-6);
00321   if (dsdp->cnorm==0){  scale=1;}
00322   info=DSDPSetScale(dsdp,scale);DSDPCHKERR(info);
00323   DSDPFunctionReturn(0);
00324 }
00325 
00341 #undef __FUNCT__
00342 #define __FUNCT__ "DSDPSolve"
00343 int DSDPSolve(DSDP dsdp){
00344   int info;
00345   DSDPFunctionBegin;
00346   info=DSDPEventLogBegin(dsdp->solvetime);
00347   dsdp->pdfeasible=DSDP_PDUNKNOWN;
00348   info=DSDPSetConvergenceFlag(dsdp,CONTINUE_ITERATING);DSDPCHKERR(info); 
00349   info=DSDPInitializeVariables(dsdp);DSDPCHKERR(info);
00350   info=DSDPSolveDynamicRho(dsdp);DSDPCHKERR(info);
00351   if (dsdp->pstep==1){info=DSDPRefineStepDirection(dsdp,dsdp->xmakerrhs,dsdp->xmaker[0].dy);DSDPCHKERR(info);}
00352   if (dsdp->pdfeasible==DSDP_PDUNKNOWN) dsdp->pdfeasible=DSDP_PDFEASIBLE;
00353   info=DSDPEventLogEnd(dsdp->solvetime);
00354   DSDPFunctionReturn(0);
00355 }
00356 
00357 
00358 /* ---------------------------------------------------------- */
00359 #undef __FUNCT__  
00360 #define __FUNCT__ "DSDPCheckConvergence"
00361 
00367 int DSDPCheckConvergence(DSDP dsdp,DSDPTerminationReason *reason){
00368   int i,info;
00369   double dd=0;
00370   DSDPTruth unbounded;
00371 
00372   DSDPFunctionBegin;
00373   info = DSDPGetConicDimension(dsdp,&dsdp->np);DSDPCHKERR(info);
00374   dsdp->rgap=(dsdp->ppobj-dsdp->ddobj)/(1.0+fabs(dsdp->ppobj)+fabs(dsdp->ddobj));
00375   dsdp->pstepold=dsdp->pstep;
00376   if (dsdp->pstep==1){
00377     info=DSDPPassXVectors(dsdp,dsdp->xmaker[0].mu,dsdp->xmaker[0].y,dsdp->xmaker[0].dy); DSDPCHKERR(info);
00378     info=DSDPVecZero(dsdp->rhstemp); DSDPCHKERR(info);
00379     info=BoundYConeAddX(dsdp->ybcone,dsdp->xmaker[0].mu,dsdp->xmaker[0].y,dsdp->xmaker[0].dy,dsdp->rhstemp,&dd); DSDPCHKERR(info);
00380     info=DSDPVecSetC(dsdp->rhstemp,0);
00381     info=DSDPVecSetR(dsdp->rhstemp,0);
00382     info=DSDPVecNormInfinity(dsdp->rhstemp,&dsdp->pinfeas); DSDPCHKERR(info);
00383     if (0==1){info=DSDPVecView(dsdp->rhstemp);}
00384   }
00385   if (dsdp->reason==CONTINUE_ITERATING){
00386     if (dsdp->itnow>0){
00387       info=DSDPCheckForUnboundedObjective(dsdp,&unbounded);DSDPCHKERR(info);
00388       if (unbounded==DSDP_TRUE){
00389         dsdp->pdfeasible=DSDP_UNBOUNDED;
00390         info=DSDPSetConvergenceFlag(dsdp,DSDP_CONVERGED); DSDPCHKERR(info); 
00391       }
00392     }
00393     if (dsdp->reason==CONTINUE_ITERATING){
00394       if (dsdp->muold<dsdp->mutarget && dsdp->pstep==1 && dsdp->dstep==1 && dsdp->rgap<1e-5){
00395         info=DSDPSetConvergenceFlag(dsdp,DSDP_NUMERICAL_ERROR); DSDPCHKERR(info);
00396         DSDPLogInfo(0,2,"DSDP Finished: Numerical issues: Increase in Barrier function. \n");}
00397       if (dsdp->itnow >= dsdp->maxiter){
00398         info=DSDPSetConvergenceFlag(dsdp,DSDP_MAX_IT); DSDPCHKERR(info);} 
00399       if (dsdp->Mshift>dsdp->maxschurshift){
00400         info = DSDPSetConvergenceFlag(dsdp,DSDP_INDEFINITE_SCHUR_MATRIX); DSDPCHKERR(info);
00401       }
00402     } 
00403     for (i=0; i<dsdp->nmonitors;i++){
00404       info=(dsdp->dmonitor[i].monitor)(dsdp,dsdp->dmonitor[i].monitorctx);  DSDPCHKERR(info);
00405     }
00406     info=DSDPMonitorCones(dsdp,0); DSDPCHKERR(info);
00407   }
00408   dsdp->muold=dsdp->mutarget;
00409   info = DSDPStopReason(dsdp,reason); DSDPCHKERR(info);
00410   DSDPFunctionReturn(0);
00411 }
00412 
00413 
00414 #undef __FUNCT__  
00415 #define __FUNCT__ "DSDPInspectXY"
00416 int DSDPInspectXY(DSDP dsdp, double xmakermu, DSDPVec xmakery, DSDPVec xmakerdy, DSDPVec AX, double *tracexs2, double *pobj2, double *rpinfeas2){
00417   int info;
00418   DSDPFunctionBegin;
00419 
00420   info=BoundYConeAddX(dsdp->ybcone,xmakermu,xmakery,xmakerdy,AX,tracexs2); DSDPCHKERR(info);
00421   info=DSDPVecGetC(AX,pobj2);DSDPCHKERR(info);
00422 
00423   info=DSDPVecSetC(AX,0);DSDPCHKERR(info);
00424   info=DSDPVecSetR(AX,0);DSDPCHKERR(info);
00425   info=DSDPVecNorm1(AX,rpinfeas2); DSDPCHKERR(info);
00426   DSDPFunctionReturn(0); 
00427 }
00428 
00458 #undef __FUNCT__  
00459 #define __FUNCT__ "DSDPComputeX"
00460 int DSDPComputeX(DSDP dsdp){
00461   int i,info;
00462   double pobj=0,ppobj2=0,ddobj,tracexs=0,tracexs2=0,rpinfeas=0,rpinfeas2=0,rpobjerr=0;
00463   double err1,cc,rrr,bigM,ymax,pfeastol=dsdp->pinfeastol;
00464   DSDPTerminationReason reason;
00465   DSDPVec AX=dsdp->ytemp;
00466 
00467   DSDPFunctionBegin;
00468   info=DSDPStopReason(dsdp,&reason);DSDPCHKERR(info);
00469   info=DSDPGetDDObjective(dsdp,&ddobj);DSDPCHKERR(info);
00470   info=DSDPGetMaxYElement(dsdp,&ymax);DSDPCHKERR(info);
00471   info=DSDPGetR(dsdp,&rrr); DSDPCHKERR(info);
00472   info=DSDPGetPenalty(dsdp,&bigM);DSDPCHKERR(info);
00473   info=DSDPGetScale(dsdp,&cc);DSDPCHKERR(info);
00474 
00475   dsdp->pdfeasible=DSDP_PDFEASIBLE;
00476   for (i=0;i<MAX_XMAKERS;i++){
00477     if (i>0 && dsdp->xmaker[i].pstep<1) continue;
00478     info=DSDPComputeXVariables(dsdp,dsdp->xmaker[i].mu,dsdp->xmaker[i].y,dsdp->xmaker[i].dy,AX,&tracexs);DSDPCHKERR(info);
00479     info=DSDPVecGetC(AX,&pobj); DSDPCHKERR(info);    
00480     info=DSDPVecGetR(AX,&dsdp->tracex); DSDPCHKERR(info);
00481     info=DSDPVecSetC(AX,0);DSDPCHKERR(info);
00482     info=DSDPVecSetR(AX,0);DSDPCHKERR(info);
00483     info=DSDPVecNormInfinity(AX,&rpinfeas);DSDPCHKERR(info);
00484     rpinfeas=rpinfeas/(dsdp->tracex+1);
00485 
00486     DSDPLogInfo(0,2,"POBJ: %4.4e, DOBJ:  %4.4e\n",pobj,ddobj/cc);
00487     
00488     info=DSDPVecNorm2(AX,&err1);DSDPCHKERR(info);
00489     dsdp->tracexs=tracexs;
00490     dsdp->perror=err1;
00491     dsdp->pobj=cc*pobj;
00492     
00493     info=DSDPInspectXY(dsdp,dsdp->xmaker[i].mu,dsdp->xmaker[i].y,dsdp->xmaker[i].dy,AX,&tracexs2,&ppobj2,&rpinfeas2);DSDPCHKERR(info);
00494     rpinfeas2=rpinfeas2/(dsdp->tracex+1);
00495     /* rpinfeas is infeasibility of (P) while rpinfeas2 is infeasibility of (PP) */
00496 
00497     DSDPLogInfo(0,2,"X P Infeas: %4.2e , PObj: %4.8e\n",rpinfeas,pobj*(cc));
00498     DSDPLogInfo(0,2,"TOTAL  P Infeas: %4.2e PObj: %4.8e\n",rpinfeas2,ppobj2*(cc));
00499     rpobjerr= fabs(pobj-dsdp->ppobj)/(1+fabs(dsdp->ppobj));
00500     
00501     if (rpinfeas2 < pfeastol){ /* (PP) must be close to feasible */
00502       
00503       if (dsdp->rgap<0.1){
00504         if (rpinfeas>pfeastol/100 && fabs(rrr)>dsdp->dinfeastol){
00505           dsdp->pdfeasible=DSDP_PDUNKNOWN;
00506           DSDPLogInfo(0,2,"Warning: Try Increasing penalty parameter\n");
00507         } else if (rpinfeas>pfeastol && ddobj>0 && ppobj2<0 && fabs(rrr)<dsdp->dinfeastol){
00508           dsdp->pdfeasible=DSDP_UNBOUNDED;
00509           DSDPLogInfo(0,2,"Warning: D probably unbounded\n");
00510           
00511         } else if (/* fabs(bigM)-dsdp->tracex < fabs(rrr) && rpinfeas<pfeastol */ fabs(rrr)>dsdp->dinfeastol){
00512           dsdp->pdfeasible=DSDP_INFEASIBLE;
00513           DSDPLogInfo(0,2,"Warning: D probably infeasible \n");
00514         }
00515       }
00516       i=i+10;
00517       break;
00518 
00519     } else { 
00520       /* Step direction was not accurate enough to compute X from Schur complement */
00521       DSDPLogInfo(0,2,"Try backup X\n");
00522       info=DSDPSetConvergenceFlag(dsdp,DSDP_NUMERICAL_ERROR); DSDPCHKERR(info); 
00523     }
00524     
00525   }
00526 
00527   DSDPFunctionReturn(0);
00528 }
00529 
00530 
00531 
00532 /* ---------------------------------------------------------- */ 
00533 #undef __FUNCT__  
00534 #define __FUNCT__ "DSDPTakeDown"
00535 
00540 int DSDPTakeDown(DSDP dsdp){
00541 
00542   int i,info;
00543 
00544   DSDPFunctionBegin;
00545   DSDPValid(dsdp);
00546   info = DSDPVecDestroy(&dsdp->rhs);DSDPCHKERR(info);
00547   info = DSDPVecDestroy(&dsdp->rhs1);DSDPCHKERR(info);
00548   info = DSDPVecDestroy(&dsdp->rhs2);DSDPCHKERR(info);
00549   info = DSDPVecDestroy(&dsdp->rhstemp);DSDPCHKERR(info);
00550   info = DSDPVecDestroy(&dsdp->y);DSDPCHKERR(info);
00551   info = DSDPVecDestroy(&dsdp->ytemp);DSDPCHKERR(info);
00552   info = DSDPVecDestroy(&dsdp->dy1);DSDPCHKERR(info);
00553   info = DSDPVecDestroy(&dsdp->dy2);DSDPCHKERR(info);
00554   info = DSDPVecDestroy(&dsdp->dy);DSDPCHKERR(info);
00555   for (i=0;i<MAX_XMAKERS;i++){
00556     info = DSDPVecDestroy(&dsdp->xmaker[i].y);DSDPCHKERR(info);
00557     info = DSDPVecDestroy(&dsdp->xmaker[i].dy);DSDPCHKERR(info);
00558     info = DSDPVecDestroy(&dsdp->xmaker[i].rhs);DSDPCHKERR(info);
00559   }
00560   info = DSDPVecDestroy(&dsdp->xmakerrhs);DSDPCHKERR(info);
00561   info = DSDPVecDestroy(&dsdp->y0);DSDPCHKERR(info);
00562   info = DSDPVecDestroy(&dsdp->b);DSDPCHKERR(info);
00563 
00564   info = DSDPCGDestroy(&dsdp->sles);DSDPCHKERR(info);
00565   info = DSDPDestroyCones(dsdp);DSDPCHKERR(info);
00566   info = DSDPSchurMatDestroy(&dsdp->M);DSDPCHKERR(info);
00567   info = DSDPGetConicDimension(dsdp,&dsdp->np);DSDPCHKERR(info);
00568   dsdp->setupcalled=DSDP_FALSE;
00569   DSDPFunctionReturn(0);
00570 }
00571 
00581 int DSDPSetDestroyRoutine(DSDP dsdp, int (*fd)(void*), void* ctx){
00582   int nd=dsdp->ndroutines;
00583   if (nd<10){
00584     dsdp->droutine[nd].f=fd;
00585     dsdp->droutine[nd].ptr=ctx;
00586     dsdp->ndroutines++;
00587   } else {
00588     printf("TOO MANY Destroy routines\n");
00589     return 1;
00590   }
00591   return 0;
00592 }
00593 
00594 
00606 #undef __FUNCT__  
00607 #define __FUNCT__ "DSDPDestroy"
00608 int DSDPDestroy(DSDP dsdp){
00609   int i,info;
00610   DSDPFunctionBegin;
00611   DSDPValid(dsdp);
00612   for (i=0;i<dsdp->ndroutines;i++){
00613     info=(*dsdp->droutine[i].f)(dsdp->droutine[i].ptr);DSDPCHKERR(info);
00614   }
00615   info=DSDPTakeDown(dsdp);DSDPCHKERR(info);
00616   DSDPFREE(&dsdp,&info);DSDPCHKERR(info);
00617   DSDPFunctionReturn(0);
00618 }

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