DSDP
printsdpa.c
Go to the documentation of this file.
1#include "dsdp5.h"
6static 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
17static 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"
31static 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"
46static 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"
61static 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"
72static 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"
94int 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"
164int 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}
The API to DSDP for those applications using DSDP as a subroutine library.
struct LPCone_C * LPCone
The LPCone object points to blocks of data that specify linear scalar inequality constraints.
Definition dsdp5.h:27
int LPConeGetData(LPCone lpcone, int vari, double vv[], int n)
Get one column (or row) of the LP data.
Definition dsdplp.c:783
Internal structures for the DSDP solver.
Definition dsdp.h:65
Internal structure for semidefinite cone.
Definition dsdpsdp.h:80