printsdpa.c

Go to the documentation of this file.
00001 #include "dsdp5.h"
00006 static void DprintfD(FILE*fp, double d1){
00007   int i1=(int)d1,i2=(int)(d1*100),i3=(int)(d1*10000),i4=(int)(d1*10000000);
00008   if ( d1==(double)i1){ fprintf(fp,"%2.0f ",d1);
00009   } else if (d1==(double)i2/100.0){ fprintf(fp,"%4.2f ",d1);
00010   } else if (d1==(double)i3/10000.0){ fprintf(fp,"%6.4f ",d1);
00011   } else if (d1==(double)i4/1000000.0){ fprintf(fp,"%8.6f ",d1);
00012   } else { fprintf(fp,"%22.22e ",d1);
00013   }
00014   return;
00015 }
00016 
00017 static void Dprintf(FILE*fp, int i1, int i2, int i3, int i4, double d1){
00018   if (fabs(d1)<1e-30){return;}
00019   fprintf(fp,"%d %d %d %d ",i1,i2,i3+1,i4+1);
00020   if (i1==0)
00021     DprintfD(fp,-d1);
00022   else 
00023     DprintfD(fp,d1);
00024   fprintf(fp,"\n");
00025   return;
00026 }
00027 
00028 
00029 #undef __FUNCT__  
00030 #define __FUNCT__ "DPrintUpperRightMatrix"
00031 static void DPrintUpperRightMatrix(int constraint, int block, double amat[], int n, FILE*fp){
00032   int col,row;
00033   for (row=0;row<n;row++){
00034     for (col=0;col<=row;col++){
00035       if (fabs(amat[col])>1.0e-20){
00036         Dprintf(fp,constraint,block,col,row,amat[col]);
00037       }
00038     }
00039     amat+=(row+1);
00040   }
00041   return;
00042 }
00043 
00044 #undef __FUNCT__  
00045 #define __FUNCT__ "DPrintUpperFullMatrix"
00046 static void DPrintUpperFullMatrix(int constraint, int block, double amat[], int n, FILE*fp){
00047   int col,row;
00048   for (row=0;row<n;row++){
00049     for (col=0;col<=row;col++){
00050       if (fabs(amat[col])>1.0e-20){
00051         Dprintf(fp,constraint,block,col,row,amat[col]);
00052       }
00053     }
00054     amat+=n;
00055   }
00056   return;
00057 }
00058 
00059 #undef __FUNCT__  
00060 #define __FUNCT__ "DPrintMatrix"
00061 static void DPrintMatrix(char UPLQ, int constraint, int block, double amat[], int n, FILE*fp){
00062   if (UPLQ=='P'){
00063     DPrintUpperRightMatrix(constraint,block,amat,n,fp);
00064   } else if (UPLQ=='U'){
00065     DPrintUpperFullMatrix(constraint,block,amat,n,fp);
00066   }
00067   return;
00068 }
00069 
00070 #undef __FUNCT__  
00071 #define __FUNCT__ "DPrintLPArray"
00072 static int DPrintLPArray(int cc, int block, double *vv, int n, FILE *fp ){
00073   int i;
00074   for (i=0;i<n;i++){
00075     if ( fabs(vv[i]) > 0){
00076       Dprintf(fp,cc,block,i,i,vv[i]);
00077     }
00078   }
00079   return 0;
00080 }
00081 
00082 
00083 #undef __FUNCT__  
00084 #define __FUNCT__ "DSDPPrintSolution"
00085 
00094 int DSDPPrintSolution(FILE *fp,DSDP dsdp,SDPCone sdpcone, LPCone lpcone){
00095   int     i,kk,info,n,nn,lpn=0,nblocks,nvars;
00096   double  *ss,*xx,*y,*lparray;
00097   char UPLQ;
00098 
00099   info=DSDPGetNumberOfVariables(dsdp,&nvars);DSDPCHKERR(info);
00100   DSDPCALLOC2(&y,double,(nvars+2),&info);DSDPCHKERR(info);
00101   info=SDPConeGetNumberOfBlocks(sdpcone,&nblocks);DSDPCHKERR(info);
00102 
00103   if (lpcone){info=LPConeGetXArray(lpcone,&xx,&lpn);DSDPCHKERR(info);nblocks--;}
00104   DSDPCALLOC2(&lparray,double,(lpn+1),&info);DSDPCHKERR(info);
00105   /* Deleted at Borcher's request.
00106   fprintf(fp,"%d \n%d \n",nvars,nblocks);
00107   for (i=0;i<nblocks; i++){
00108     info=SDPConeGetBlockSize(sdpcone,i,&n);DSDPCHKERR(info);
00109     fprintf(fp,"%d ",n);
00110   }
00111   if (lpcone){ fprintf(fp,"%d ",-lpn); }
00112   fprintf(fp," \n");
00113   */
00114 
00115   info=DSDPGetY(dsdp,y+1,nvars);DSDPCHKERR(info);
00116   y[0]=1.0;y[nvars+1]=0;
00117   info=DSDPGetR(dsdp,y+nvars+1);DSDPCHKERR(info);
00118   for (i=0; i<nvars; i++){ DprintfD(fp,-y[i+1]);}
00119   fprintf(fp," \n");
00120 
00121   /* Print Dual Matrix Solution */
00122   for (kk=0;kk<nblocks;kk++){
00123     info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
00124     info=SDPConeGetXArray(sdpcone,kk,&ss,&nn);DSDPCHKERR(info);
00125     info=SDPConeComputeS(sdpcone,kk,y[0],y+1,nvars,y[nvars+1],n,ss,nn);DSDPCHKERR(info);
00126     info=SDPConeGetStorageFormat(sdpcone,kk,&UPLQ);DSDPCHKERR(info);
00127     DPrintMatrix(UPLQ,1,kk+1,ss,n,fp);
00128     info=SDPConeRestoreXArray(sdpcone,kk,&ss,&nn);DSDPCHKERR(info);
00129   }
00130   if (lpcone){
00131     info=LPConeCopyS(lpcone,lparray,lpn);DSDPCHKERR(info);
00132     info=DPrintLPArray(1,nblocks+1,lparray,lpn,fp);DSDPCHKERR(info);
00133   }
00134 
00135   info=DSDPComputeX(dsdp);DSDPCHKERR(info);
00136   /* Print Primal Solution */ 
00137   for (kk=0; kk<nblocks; kk++){
00138     info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
00139     info=SDPConeGetStorageFormat(sdpcone,kk,&UPLQ);DSDPCHKERR(info);
00140     info=SDPConeGetXArray(sdpcone,kk,&xx,&nn);DSDPCHKERR(info);
00141     DPrintMatrix(UPLQ,2,kk+1,xx,n,fp);
00142     info=SDPConeRestoreXArray(sdpcone,kk,&xx,&nn);DSDPCHKERR(info);
00143   }
00144   if (lpcone){
00145     info=LPConeGetXArray(lpcone,&xx,&nn);DSDPCHKERR(info);
00146     info=DPrintLPArray(2,nblocks+1,xx,nn,fp);DSDPCHKERR(info);
00147   }
00148 
00149   DSDPFREE(&y,&info);
00150   return 0;
00151 }
00152 
00153 
00154 #undef __FUNCT__  
00155 #define __FUNCT__ "DSDPPrintData"
00156 
00164 int DSDPPrintData(DSDP dsdp, SDPCone sdpcone, LPCone lpcone){
00165 
00166   int info,nblocks,i,nvars,n,nn,kk,lpblock=0,lpn=0;
00167   double *ss,*y=0,*vv=0;
00168   char filename[100]="";
00169   char UPLQ;
00170   FILE *fp;
00171 
00172   info=DSDPGetNumberOfVariables(dsdp,&nvars);DSDPCHKERR(info);
00173   DSDPCALLOC2(&y,double,(nvars+3),&info);DSDPCHKERR(info);
00174   info=SDPConeGetNumberOfBlocks(sdpcone,&nblocks);DSDPCHKERR(info);
00175   strncat(filename,"output.sdpa",50);
00176   /*  fp=fopen(filename,"w"); */
00177   fp=fopen("input.sdpa","w");
00178   if (lpcone){ 
00179     info=LPConeGetDimension(lpcone,&lpn);DSDPCHKERR(info);
00180     DSDPCALLOC2(&vv,double,lpn,&info);DSDPCHKERR(info);
00181     lpblock=1;
00182     info=SDPConeGetBlockSize(sdpcone,nblocks-1,&n);DSDPCHKERR(info);
00183     if (n==0){nblocks--;}
00184   }
00185   fprintf(fp,"%d \n%d\n",nvars,nblocks+lpblock);
00186   for (kk=0;kk<nblocks;kk++){ 
00187     info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
00188     fprintf(fp,"%d ",n);
00189   }
00190   if (lpcone){
00191     fprintf(fp,"%d ",-lpn);
00192   }
00193   fprintf(fp,"\n");
00194   info=DSDPCopyB(dsdp,y,nvars);
00195   for (i=0;i<nvars;i++){ 
00196     DprintfD(fp,y[i]);
00197   }
00198   fprintf(fp,"\n");
00199 
00200   for (i=0;i<=nvars;i++){
00201     for (kk=0;kk<nvars+2;kk++) y[kk]=0.0;
00202     if (i==0){y[i]=1.0;} else {y[i]=-1.0; }
00203     for (kk=0;kk<nblocks;kk++){
00204       info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
00205       info=SDPConeGetXArray(sdpcone,kk,&ss,&nn);DSDPCHKERR(info);
00206       info=SDPConeComputeS(sdpcone,kk,y[0],y+1,nvars,y[nvars+1],n,ss,nn);DSDPCHKERR(info);
00207       info=SDPConeGetStorageFormat(sdpcone,kk,&UPLQ);DSDPCHKERR(info);
00208       DPrintMatrix(UPLQ,i,kk+1,ss,n,fp);
00209     }
00210   }
00211   if (lpcone && lpn>0){
00212     info=LPConeGetDimension(lpcone,&lpn);DSDPCHKERR(info);
00213     for (i=0;i<=nvars;i++){
00214       info=LPConeGetData(lpcone,i,vv,lpn);DSDPCHKERR(info);
00215       info=DPrintLPArray(i,nblocks+1,vv,lpn,fp);DSDPCHKERR(info);
00216     }
00217   }
00218   DSDPFREE(&y,&info);
00219   if (vv){
00220     DSDPFREE(&vv,&info);
00221   }
00222   fclose(fp);
00223 
00224   return 0;
00225 }

Generated on Mon Nov 30 20:17:33 2009 for DSDP by  doxygen 1.6.1