DSDP
dsdpobjcone.c
Go to the documentation of this file.
1#include "dsdpcone_impl.h"
2#include "dsdpsys.h"
8typedef struct {
9 DSDPVec b,bb,T;
10 double dmin;
11 double pss,dss;
12 DSDP dsdp;
13 DSDPTruth useit;
14} BDCone;
15
16
17static int BComputeS(BDCone *K, DSDPVec v, double *ss){
18 int info;
19 DSDPFunctionBegin;
20 info=DSDPVecDot(K->bb,v,ss);DSDPCHKERR(info);
21 DSDPFunctionReturn(0);
22}
23
24#undef __FUNCT__
25#define __FUNCT__ "DSDPRHessian"
26static int DSDPRHessian( void *dspcone, double mu, DSDPSchurMat M, DSDPVec vrhs1, DSDPVec vrhs2){
27 BDCone *K=(BDCone*)dspcone;
28 double bb,dd,ss=K->dss;
29 int info,i,m,ncols;
30 DSDPVec T=K->T,b=K->bb;
31 DSDPFunctionBegin;
32 if (K->useit){
33 info=DSDPVecGetSize(b,&m);DSDPCHKERR(info);
34 for (i=0;i<m;i++){
35 info=DSDPVecGetElement(b,i,&bb);DSDPCHKERR(info);
36 if (bb==0) continue;
37
38 info=DSDPSchurMatRowColumnScaling(M,i,T,&ncols); DSDPCHKERR(info);
39 if (ncols==0) continue;
40
41 info=DSDPVecGetElement(T,i,&dd);DSDPCHKERR(info);
42 info=DSDPVecAddElement(vrhs2,i,-bb*dd*mu/ss);DSDPCHKERR(info);
43
44 info=DSDPVecPointwiseMult(T,b,T);DSDPCHKERR(info);
45
46 info=DSDPVecScale(mu*bb/(ss*ss),T);DSDPCHKERR(info);
47 info=DSDPSchurMatAddRow(M,i,1.0,T);DSDPCHKERR(info);
48 /*
49 info=DSDPSchurMatAddRow(M,i,mu*bb/(ss*ss),T);DSDPCHKERR(info);
50 */
51 if (i==-m-1){info=DSDPVecView(T);}
52 }
53 }
54 DSDPFunctionReturn(0);
55}
56
57static int DSDPRRHS( void *dcone, double mu, DSDPVec vrow, DSDPVec vrhs1, DSDPVec vrhs2){
58 BDCone *K=(BDCone*)dcone;
59 double bb,dd,ss=K->dss;
60 int info,i,m;
61 DSDPVec b=K->bb;
62 DSDPFunctionBegin;
63 if (K->useit){
64 info=DSDPVecGetSize(b,&m);DSDPCHKERR(info);
65 for (i=0;i<m;i++){
66 info=DSDPVecGetElement(b,i,&bb);DSDPCHKERR(info);
67 info=DSDPVecGetElement(vrow,i,&dd);DSDPCHKERR(info);
68 info=DSDPVecAddElement(vrhs2,i,-bb*dd*mu/ss);DSDPCHKERR(info);
69 }
70 /*
71 info=DSDPVecGetR(b,&bb);DSDPCHKERR(info);
72 info=DSDPVecGetR(vrhs3,&dd);DSDPCHKERR(info);
73 info=DSDPVecPointwiseMult(vrow,b,T);DSDPCHKERR(info);
74 info=DSDPVecScale(mu*bb/(ss*ss),T);DSDPCHKERR(info);
75 info=DSDPVecAXPY(dd,T,vrhs3);DSDPCHKERR(info);
76 */
77 }
78 DSDPFunctionReturn(0);
79}
80
81#undef __FUNCT__
82#define __FUNCT__ "DSDPSetupBCone"
83static int DSDPSetupBCone(void* dspcone,DSDPVec y){
84 DSDPFunctionBegin;
85 DSDPFunctionReturn(0);
86}
87
88
89#undef __FUNCT__
90#define __FUNCT__ "DSDPSetDRData"
91static int DSDPSetDRData(BDCone *K){
92 int info;
93 DSDPFunctionBegin;
94 info=DSDPVecCopy(K->b,K->bb);DSDPCHKERR(info);
95 info=DSDPVecSetC(K->bb,K->dmin);DSDPCHKERR(info);
96 info=DSDPVecSetR(K->bb,-1.0);DSDPCHKERR(info);
97 DSDPFunctionReturn(0);
98}
99
100#undef __FUNCT__
101#define __FUNCT__ "DSDPSetupBCone2"
102static int DSDPSetupBCone2(void* dspcone, DSDPVec y, DSDPSchurMat M){
103 BDCone *K=(BDCone*)dspcone;
104 int info;
105 DSDPFunctionBegin;
106 info=DSDPVecDuplicate(K->b,&K->T);DSDPCHKERR(info);
107 info=DSDPVecDuplicate(K->b,&K->bb);DSDPCHKERR(info);
108 info=DSDPSetDRData(K);DSDPCHKERR(info);
109 DSDPFunctionReturn(0);
110}
111
112
113#undef __FUNCT__
114#define __FUNCT__ "DSDPDestroyBCone"
115static int DSDPDestroyBCone(void* dspcone){
116 BDCone *K=(BDCone*)dspcone;
117 int info;
118 DSDPFunctionBegin;
119 info=DSDPVecDestroy(&K->T);DSDPCHKERR(info);
120 info=DSDPVecDestroy(&K->bb);DSDPCHKERR(info);
121 DSDPFREE(&dspcone,&info);DSDPCHKERR(info);
122 DSDPFunctionReturn(0);
123}
124
125
126#undef __FUNCT__
127#define __FUNCT__ "DSDPRSize"
128static int DSDPRSize(void*dspcone,double*n){
129 DSDPFunctionBegin;
130 *n=1.0;
131 DSDPFunctionReturn(0);
132}
133
134#undef __FUNCT__
135#define __FUNCT__ "DSDPRSparsity"
136static int DSDPRSparsity(void*dspcone,int row, int *tnnz, int rnnz[], int m){
137 BDCone *K=(BDCone*)dspcone;
138 int i,info;double dd;
139 DSDPFunctionBegin;
140 *tnnz=0;
141
142 info=DSDPVecGetElement(K->b,row,&dd);DSDPCHKERR(info);
143 if (dd){
144 for (i=0;i<m;i++){
145 info=DSDPVecGetElement(K->b,i,&dd);DSDPCHKERR(info);
146 if (dd!=0){rnnz[i]++; (*tnnz)++;}
147 }
148 }
149 DSDPFunctionReturn(0);
150}
151
152#undef __FUNCT__
153#define __FUNCT__ "DSDPComputeRS"
154static int DSDPComputeRS(void *dspcone, DSDPVec Y, DSDPDualFactorMatrix flag, DSDPTruth *ispsdefinite){
155 BDCone *K=(BDCone*)dspcone;
156 int info;
157 double ss;
158 DSDPFunctionBegin;
159 info=BComputeS(K,Y,&ss);DSDPCHKERR(info);
160 if (ss>0){ *ispsdefinite=DSDP_TRUE; } else { *ispsdefinite=DSDP_FALSE;}
161 if (flag==DUAL_FACTOR){ K->dss=ss; } else { K->pss=ss;}
162 DSDPLogInfo(0,2,"DOBJCone SS: %4.4e \n",ss);
163 DSDPFunctionReturn(0);
164}
165
166#undef __FUNCT__
167#define __FUNCT__ "DSDPInvertRS"
168static int DSDPInvertRS(void *dspcone){
169 DSDPFunctionBegin;
170 DSDPFunctionReturn(0);
171}
172
173
174#undef __FUNCT__
175#define __FUNCT__ "DSDPComputeRStepLength"
176static int DSDPComputeRStepLength(void *dspcone, DSDPVec DY, DSDPDualFactorMatrix flag, double *maxsteplength){
177 BDCone *K=(BDCone*)dspcone;
178 double ds,ss,rt=1.0e30;
179 int info;
180
181 DSDPFunctionBegin;
182 info=BComputeS(K,DY,&ds);DSDPCHKERR(info);
183 if (flag==DUAL_FACTOR){ ss=K->dss; } else { ss=K->pss;}
184 if (ds<0) rt=-ss/ds;
185 if (K->useit){
186 *maxsteplength=rt;
187 }
188 DSDPFunctionReturn(0);
189}
190
191#undef __FUNCT__
192#define __FUNCT__ "DSDPSetX"
193static int DSDPSetX( void *dspcone, double mu, DSDPVec y, DSDPVec dy){
194 DSDPFunctionBegin;
195 DSDPFunctionReturn(0);
196}
197#undef __FUNCT__
198#define __FUNCT__ "DSDPRX"
199static int DSDPRX( void *dspcone, double mu, DSDPVec y, DSDPVec dy, DSDPVec AX,double*tracxs){
200 BDCone *K=(BDCone*)dspcone;
201 double x,dss,ss=K->dss;
202 int info;
203 DSDPFunctionBegin;
204
205 info=BComputeS(K,y,&ss);DSDPCHKERR(info);
206 ss=1.0/ss;
207 info=BComputeS(K,dy,&dss);DSDPCHKERR(info);
208 x=mu*(ss+ss*dss*ss);
209 DSDPLogInfo(0,2,"DOBJCone SS: %4.4e, RESIDUAL X: %4.4e\n",1.0/ss,x);
210 if (fabs(x*ss)>1.0 && mu < 1) printf("Check Dual Min Bound\n");
211 info=DSDPVecAXPY(-x,K->bb,AX);DSDPCHKERR(info);
212 DSDPFunctionReturn(0);
213}
214
215#undef __FUNCT__
216#define __FUNCT__ "DSDPComputeRLog"
217static int DSDPComputeRLog(void *dspcone, double *logobj, double *logdet){
218 BDCone *K=(BDCone*)dspcone;
219 DSDPFunctionBegin;
220 *logobj=0;
221 *logdet=log(K->dss);
222 DSDPFunctionReturn(0);
223}
224
225#undef __FUNCT__
226#define __FUNCT__ "DSDPRANorm2"
227static int DSDPRANorm2(void *dspcone, DSDPVec Anorm2){
228 DSDPFunctionBegin;
229 DSDPFunctionReturn(0);
230}
231
232
233#undef __FUNCT__
234#define __FUNCT__ "DSDPRMultiplyAdd"
235static int DSDPRMultiplyAdd(void *dspcone,double mu,DSDPVec vrow,DSDPVec vin,DSDPVec vout){
236 BDCone *K=(BDCone*)dspcone;
237 DSDPVec T=K->T;
238 int info;
239 double dd,ss=K->dss;
240 DSDPFunctionBegin;
241 info=DSDPVecDot(vin,K->bb,&dd);DSDPCHKERR(info);
242 dd=-mu*dd/(ss*ss);
243 info=DSDPVecPointwiseMult(K->bb,vrow,T);DSDPCHKERR(info);
244 info=DSDPVecAXPY(dd,T,vout);DSDPCHKERR(info);
245 DSDPFunctionReturn(0);
246}
247
248
249#undef __FUNCT__
250#define __FUNCT__ "DSDPRMonitor"
251static int DSDPRMonitor( void *dspcone, int tag){
252 DSDPFunctionBegin;
253 DSDPFunctionReturn(0);
254}
255
256static struct DSDPCone_Ops kops;
257static const char* matname="Dual Obj Cone";
258
259#undef __FUNCT__
260#define __FUNCT__ "BConeOperationsInitialize"
261static int BConeOperationsInitialize(struct DSDPCone_Ops* coneops){
262 int info;
263 if (coneops==NULL) return 0;
264 info=DSDPConeOpsInitialize(coneops); DSDPCHKERR(info);
265 coneops->conehessian=DSDPRHessian;
266 coneops->conesetup=DSDPSetupBCone;
267 coneops->conesetup2=DSDPSetupBCone2;
268 coneops->conedestroy=DSDPDestroyBCone;
269 coneops->conecomputes=DSDPComputeRS;
270 coneops->coneinverts=DSDPInvertRS;
271 coneops->conecomputex=DSDPRX;
272 coneops->conesetxmaker=DSDPSetX;
273 coneops->conemaxsteplength=DSDPComputeRStepLength;
274 coneops->conelogpotential=DSDPComputeRLog;
275 coneops->conesize=DSDPRSize;
276 coneops->conesparsity=DSDPRSparsity;
277 coneops->coneanorm2=DSDPRANorm2;
278 coneops->conemonitor=DSDPRMonitor;
279 coneops->conehmultiplyadd=DSDPRMultiplyAdd;
280 coneops->conerhs=DSDPRRHS;
281 coneops->id=119;
282 coneops->name=matname;
283 return 0;
284}
285
286#undef __FUNCT__
287#define __FUNCT__ "DSDPAddBCone"
288int DSDPAddBCone(DSDP dsdp, DSDPVec bb, double dmin){
289 BDCone *rcone;
290 int info;
291 DSDPFunctionBegin;
292 info=BConeOperationsInitialize(&kops); DSDPCHKERR(info);
293 DSDPCALLOC1(&rcone,BDCone,&info); DSDPCHKERR(info);
294 rcone->b=bb;
295 rcone->dmin=dmin;
296 rcone->dsdp=dsdp;
297 rcone->useit=DSDP_TRUE;
298 info=DSDPAddCone(dsdp,&kops,(void*)rcone); DSDPCHKERR(info);
299 DSDPFunctionReturn(0);
300}
301
302#include "dsdp.h"
303#include "dsdp5.h"
304
305#undef __FUNCT__
306#define __FUNCT__ "DSDPSetDualLowerBound"
307int DSDPSetDualLowerBound(DSDP dsdp, double dobjmin){
308 int info;
309 DSDPFunctionBegin;
310 info = DSDPAddBCone(dsdp,dsdp->b,dobjmin);DSDPCHKERR(info);
311 DSDPFunctionReturn(0);
312}
The API to DSDP for those applications using DSDP as a subroutine library.
Internal data structure for the DSDP solver.
DSDPDualFactorMatrix
DSDP requires two instances of the data structures S.
@ DUAL_FACTOR
DSDPTruth
Boolean variables.
@ DSDP_FALSE
@ DSDP_TRUE
int DSDPConeOpsInitialize(struct DSDPCone_Ops *dops)
Initialize the function pointers to 0.
Definition dsdpcone.c:443
Implementations of a cone (SDP,LP,...) must provide a structure of function pointers.
int DSDPAddCone(DSDP, struct DSDPCone_Ops *, void *)
Apply DSDP to a conic structure.
Definition dsdpcops.c:569
int DSDPSchurMatRowColumnScaling(DSDPSchurMat, int, DSDPVec, int *)
Get the scaling and nonzero pattern of each column in this row of the matrix.
int DSDPSchurMatAddRow(DSDPSchurMat, int, double, DSDPVec)
Add elements to a row of the Schur matrix.
Error handling, printing, and profiling.
struct DSDPVec_C DSDPVec
This object hold m+2 variables: a scaling of C, the y variables, and r.
Definition dsdpvec.h:25
Schur complement matrix whose solution is the Newton direction.
Internal structures for the DSDP solver.
Definition dsdp.h:65