DSDP
printsdpa.c
Go to the documentation of this file.
1 #include "dsdp5.h"
6 static void DprintfD(FILE*fp, double d1){
7  int i1=(int)d1,i2=(int)(d1*100),i3=(int)(d1*10000),i4=(int)(d1*10000000);
8  if ( d1==(double)i1){ fprintf(fp,"%2.0f ",d1);
9  } else if (d1==(double)i2/100.0){ fprintf(fp,"%4.2f ",d1);
10  } else if (d1==(double)i3/10000.0){ fprintf(fp,"%6.4f ",d1);
11  } else if (d1==(double)i4/1000000.0){ fprintf(fp,"%8.6f ",d1);
12  } else { fprintf(fp,"%22.22e ",d1);
13  }
14  return;
15 }
16 
17 static void Dprintf(FILE*fp, int i1, int i2, int i3, int i4, double d1){
18  if (fabs(d1)<1e-30){return;}
19  fprintf(fp,"%d %d %d %d ",i1,i2,i3+1,i4+1);
20  if (i1==0)
21  DprintfD(fp,-d1);
22  else
23  DprintfD(fp,d1);
24  fprintf(fp,"\n");
25  return;
26 }
27 
28 
29 #undef __FUNCT__
30 #define __FUNCT__ "DPrintUpperRightMatrix"
31 static void DPrintUpperRightMatrix(int constraint, int block, double amat[], int n, FILE*fp){
32  int col,row;
33  for (row=0;row<n;row++){
34  for (col=0;col<=row;col++){
35  if (fabs(amat[col])>1.0e-20){
36  Dprintf(fp,constraint,block,col,row,amat[col]);
37  }
38  }
39  amat+=(row+1);
40  }
41  return;
42 }
43 
44 #undef __FUNCT__
45 #define __FUNCT__ "DPrintUpperFullMatrix"
46 static void DPrintUpperFullMatrix(int constraint, int block, double amat[], int n, FILE*fp){
47  int col,row;
48  for (row=0;row<n;row++){
49  for (col=0;col<=row;col++){
50  if (fabs(amat[col])>1.0e-20){
51  Dprintf(fp,constraint,block,col,row,amat[col]);
52  }
53  }
54  amat+=n;
55  }
56  return;
57 }
58 
59 #undef __FUNCT__
60 #define __FUNCT__ "DPrintMatrix"
61 static void DPrintMatrix(char UPLQ, int constraint, int block, double amat[], int n, FILE*fp){
62  if (UPLQ=='P'){
63  DPrintUpperRightMatrix(constraint,block,amat,n,fp);
64  } else if (UPLQ=='U'){
65  DPrintUpperFullMatrix(constraint,block,amat,n,fp);
66  }
67  return;
68 }
69 
70 #undef __FUNCT__
71 #define __FUNCT__ "DPrintLPArray"
72 static int DPrintLPArray(int cc, int block, double *vv, int n, FILE *fp ){
73  int i;
74  for (i=0;i<n;i++){
75  if ( fabs(vv[i]) > 0){
76  Dprintf(fp,cc,block,i,i,vv[i]);
77  }
78  }
79  return 0;
80 }
81 
82 
83 #undef __FUNCT__
84 #define __FUNCT__ "DSDPPrintSolution"
85 
94 int DSDPPrintSolution(FILE *fp,DSDP dsdp,SDPCone sdpcone, LPCone lpcone){
95  int i,kk,info,n,nn,lpn=0,nblocks,nvars;
96  double *ss,*xx,*y,*lparray;
97  char UPLQ;
98 
99  info=DSDPGetNumberOfVariables(dsdp,&nvars);DSDPCHKERR(info);
100  DSDPCALLOC2(&y,double,(nvars+2),&info);DSDPCHKERR(info);
101  info=SDPConeGetNumberOfBlocks(sdpcone,&nblocks);DSDPCHKERR(info);
102 
103  if (lpcone){info=LPConeGetXArray(lpcone,&xx,&lpn);DSDPCHKERR(info);nblocks--;}
104  DSDPCALLOC2(&lparray,double,(lpn+1),&info);DSDPCHKERR(info);
105  /* Deleted at Borcher's request.
106  fprintf(fp,"%d \n%d \n",nvars,nblocks);
107  for (i=0;i<nblocks; i++){
108  info=SDPConeGetBlockSize(sdpcone,i,&n);DSDPCHKERR(info);
109  fprintf(fp,"%d ",n);
110  }
111  if (lpcone){ fprintf(fp,"%d ",-lpn); }
112  fprintf(fp," \n");
113  */
114 
115  info=DSDPGetY(dsdp,y+1,nvars);DSDPCHKERR(info);
116  y[0]=1.0;y[nvars+1]=0;
117  info=DSDPGetR(dsdp,y+nvars+1);DSDPCHKERR(info);
118  for (i=0; i<nvars; i++){ DprintfD(fp,-y[i+1]);}
119  fprintf(fp," \n");
120 
121  /* Print Dual Matrix Solution */
122  for (kk=0;kk<nblocks;kk++){
123  info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
124  info=SDPConeGetXArray(sdpcone,kk,&ss,&nn);DSDPCHKERR(info);
125  info=SDPConeComputeS(sdpcone,kk,y[0],y+1,nvars,y[nvars+1],n,ss,nn);DSDPCHKERR(info);
126  info=SDPConeGetStorageFormat(sdpcone,kk,&UPLQ);DSDPCHKERR(info);
127  DPrintMatrix(UPLQ,1,kk+1,ss,n,fp);
128  info=SDPConeRestoreXArray(sdpcone,kk,&ss,&nn);DSDPCHKERR(info);
129  }
130  if (lpcone){
131  info=LPConeCopyS(lpcone,lparray,lpn);DSDPCHKERR(info);
132  info=DPrintLPArray(1,nblocks+1,lparray,lpn,fp);DSDPCHKERR(info);
133  }
134 
135  info=DSDPComputeX(dsdp);DSDPCHKERR(info);
136  /* Print Primal Solution */
137  for (kk=0; kk<nblocks; kk++){
138  info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
139  info=SDPConeGetStorageFormat(sdpcone,kk,&UPLQ);DSDPCHKERR(info);
140  info=SDPConeGetXArray(sdpcone,kk,&xx,&nn);DSDPCHKERR(info);
141  DPrintMatrix(UPLQ,2,kk+1,xx,n,fp);
142  info=SDPConeRestoreXArray(sdpcone,kk,&xx,&nn);DSDPCHKERR(info);
143  }
144  if (lpcone){
145  info=LPConeGetXArray(lpcone,&xx,&nn);DSDPCHKERR(info);
146  info=DPrintLPArray(2,nblocks+1,xx,nn,fp);DSDPCHKERR(info);
147  }
148 
149  DSDPFREE(&y,&info);
150  return 0;
151 }
152 
153 
154 #undef __FUNCT__
155 #define __FUNCT__ "DSDPPrintData"
156 
164 int DSDPPrintData(DSDP dsdp, SDPCone sdpcone, LPCone lpcone){
165 
166  int info,nblocks,i,nvars,n,nn,kk,lpblock=0,lpn=0;
167  double *ss,*y=0,*vv=0;
168  char filename[100]="";
169  char UPLQ;
170  FILE *fp;
171 
172  info=DSDPGetNumberOfVariables(dsdp,&nvars);DSDPCHKERR(info);
173  DSDPCALLOC2(&y,double,(nvars+3),&info);DSDPCHKERR(info);
174  info=SDPConeGetNumberOfBlocks(sdpcone,&nblocks);DSDPCHKERR(info);
175  strncat(filename,"output.sdpa",50);
176  /* fp=fopen(filename,"w"); */
177  fp=fopen("input.sdpa","w");
178  if (lpcone){
179  info=LPConeGetDimension(lpcone,&lpn);DSDPCHKERR(info);
180  DSDPCALLOC2(&vv,double,lpn,&info);DSDPCHKERR(info);
181  lpblock=1;
182  info=SDPConeGetBlockSize(sdpcone,nblocks-1,&n);DSDPCHKERR(info);
183  if (n==0){nblocks--;}
184  }
185  fprintf(fp,"%d \n%d\n",nvars,nblocks+lpblock);
186  for (kk=0;kk<nblocks;kk++){
187  info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
188  fprintf(fp,"%d ",n);
189  }
190  if (lpcone){
191  fprintf(fp,"%d ",-lpn);
192  }
193  fprintf(fp,"\n");
194  info=DSDPCopyB(dsdp,y,nvars);
195  for (i=0;i<nvars;i++){
196  DprintfD(fp,y[i]);
197  }
198  fprintf(fp,"\n");
199 
200  for (i=0;i<=nvars;i++){
201  for (kk=0;kk<nvars+2;kk++) y[kk]=0.0;
202  if (i==0){y[i]=1.0;} else {y[i]=-1.0; }
203  for (kk=0;kk<nblocks;kk++){
204  info=SDPConeGetBlockSize(sdpcone,kk,&n);DSDPCHKERR(info);
205  info=SDPConeGetXArray(sdpcone,kk,&ss,&nn);DSDPCHKERR(info);
206  info=SDPConeComputeS(sdpcone,kk,y[0],y+1,nvars,y[nvars+1],n,ss,nn);DSDPCHKERR(info);
207  info=SDPConeGetStorageFormat(sdpcone,kk,&UPLQ);DSDPCHKERR(info);
208  DPrintMatrix(UPLQ,i,kk+1,ss,n,fp);
209  }
210  }
211  if (lpcone && lpn>0){
212  info=LPConeGetDimension(lpcone,&lpn);DSDPCHKERR(info);
213  for (i=0;i<=nvars;i++){
214  info=LPConeGetData(lpcone,i,vv,lpn);DSDPCHKERR(info);
215  info=DPrintLPArray(i,nblocks+1,vv,lpn,fp);DSDPCHKERR(info);
216  }
217  }
218  DSDPFREE(&y,&info);
219  if (vv){
220  DSDPFREE(&vv,&info);
221  }
222  fclose(fp);
223 
224  return 0;
225 }
int LPConeGetDimension(LPCone lpcone, int *n)
Get the dimension is the number of variables x, which equals the number of slack variables s.
Definition: dsdplp.c:616
int SDPConeGetBlockSize(SDPCone sdpcone, int blockj, int *n)
Get the dimension of one block in the semidefinite cone.
Definition: dsdpadddata.c:560
int DSDPPrintSolution(FILE *fp, DSDP dsdp, SDPCone sdpcone, LPCone lpcone)
Print solution in SDPA format.
Definition: printsdpa.c:94
Internal structures for the DSDP solver.
Definition: dsdp.h:65
int LPConeCopyS(LPCone lpcone, double s[], int n)
Copy the variables s into the spedified array.
Definition: dsdplp.c:595
int SDPConeRestoreXArray(SDPCone sdpcone, int blockj, double *xx[], int *nn)
Restore the dense array and set these pointers to null.
Definition: dsdpadddata.c:351
int DSDPPrintData(DSDP dsdp, SDPCone sdpcone, LPCone lpcone)
Print data in SDPA format to a file named "output.sdpa".
Definition: printsdpa.c:164
int SDPConeGetXArray(SDPCone sdpcone, int blockj, double *xx[], int *nn)
After applying the solver, set a pointer to the array in the object with the solution X.
Definition: dsdpadddata.c:328
int LPConeGetXArray(LPCone lpcone, double *x[], int *n)
Get the array used to store the x variables.
Definition: dsdplp.c:556
The API to DSDP for those applications using DSDP as a subroutine library.
int SDPConeGetNumberOfBlocks(SDPCone sdpcone, int *nblocks)
Get the number of blocks in the semidefinite cone.
Definition: dsdpadddata.c:578
int LPConeGetData(LPCone lpcone, int vari, double vv[], int n)
Get one column (or row) of the LP data.
Definition: dsdplp.c:783
Internal structure for semidefinite cone.
Definition: dsdpsdp.h:80
int DSDPGetY(DSDP dsdp, double y[], int m)
Copies the variables y into an array.
Definition: dsdpsetdata.c:100
int DSDPGetNumberOfVariables(DSDP dsdp, int *m)
Copy the number of variables y.
Definition: dsdpsetdata.c:707
int SDPConeGetStorageFormat(SDPCone sdpcone, int blockj, char *format)
Get the storage format for the block.
Definition: dsdpadddata.c:505
int DSDPGetR(DSDP dsdp, double *res)
Copy the infeasibility in (D), or the variable r in (DD).
Definition: dsdpsetdata.c:601
int DSDPComputeX(DSDP dsdp)
Compute the X variables.
Definition: dsdpx.c:55
int SDPConeComputeS(SDPCone sdpcone, int blockj, double cc, double y[], int nvars, double r, int n, double s[], int nn)
Compute the dual matrix S.
Definition: sdpcone.c:42
int DSDPCopyB(DSDP dsdp, double bb[], int m)
Copies the variables b from solver into an array.
Definition: dsdpsetdata.c:46
struct LPCone_C * LPCone
The LPCone object points to blocks of data that specify linear scalar inequality constraints.
Definition: dsdp5.h:27