DSDP
dsdpxmat.c
Go to the documentation of this file.
1#include "dsdpxmat_impl.h"
2#include "dsdpxmat.h"
3#include "dsdpsys.h"
9#define DSDPNoOperationError(a); { DSDPSETERR1(1,"X Matrix type: %s, Operation not defined. Perhaps no X matrix has been set.\n",(a).dsdpops->matname); }
10#define DSDPChkMatError(a,b); { if (b){ DSDPSETERR1(b,"X Matrix type: %s,\n",(a).dsdpops->matname);} }
11
12static int sdpxmatevent=0;
13
14#undef __FUNCT__
15#define __FUNCT__ "DSDPVMatEventZero"
16int DSDPVMatEventZero(void){
17 DSDPFunctionBegin;
18 sdpxmatevent=0;
19 DSDPFunctionReturn(0);
20}
21
22#undef __FUNCT__
23#define __FUNCT__ "DSDPVMatEventInitialize"
24int DSDPVMatEventInitialize(void){
25 DSDPFunctionBegin;
26 if (sdpxmatevent==0){DSDPEventLogRegister("SDP X+vv'",&sdpxmatevent);}
27 DSDPFunctionReturn(0);
28}
29
30#undef __FUNCT__
31#define __FUNCT__ "DSDPVMatSetData"
39int DSDPVMatSetData(DSDPVMat *X, struct DSDPVMat_Ops* ops, void*data){
40 int info;
41 DSDPFunctionBegin;
42 (*X).dsdpops=ops;
43 (*X).matdata=data;
44 info=DSDPVMatTest(*X);DSDPCHKERR(info);
45 DSDPFunctionReturn(0);
46}
47
48#undef __FUNCT__
49#define __FUNCT__ "DSDPVMatGetType"
50int DSDPVMatGetType(DSDPVMat X, int *id){
51 DSDPFunctionBegin;
52 *id=X.dsdpops->id;
53 DSDPFunctionReturn(0);
54}
55
56
57#undef __FUNCT__
58#define __FUNCT__ "DSDPVMatGetSize"
66 int info;
67 DSDPFunctionBegin;
68 if (X.dsdpops->matgetsize){
69 info=(X.dsdpops->matgetsize)(X.matdata,n); DSDPChkMatError(X,info);
70 } else {
71 /*
72 DSDPNoOperationError(X);
73 */
74 }
75 DSDPFunctionReturn(0);
76}
77
78
79#undef __FUNCT__
80#define __FUNCT__ "DSDPVMatDestroy"
87 int info;
88 DSDPFunctionBegin;
89 if (!(*X).dsdpops){ return 0;}
90 if ((*X).dsdpops->matdestroy){
91 info=((*X).dsdpops->matdestroy)((*X).matdata); DSDPChkMatError(*X,info);
92 } else {
93 /* DSDPNoOperationError(*X); */
94 }
95 info=DSDPVMatInitialize(X); DSDPCHKERR(info);
96 DSDPFunctionReturn(0);
97}
98
99
100#undef __FUNCT__
101#define __FUNCT__ "DSDPVMatView"
108 int info;
109 if (X.dsdpops->matview){
110 info=(X.dsdpops->matview)(X.matdata); DSDPChkMatError(X,info);
111 } else {
112 printf("No viewer available for matrix type: %d",X.dsdpops->id);
113 }
114 DSDPFunctionReturn(0);
115}
116
117
118#undef __FUNCT__
119#define __FUNCT__ "DSDPVMatZeroEntries"
126 int info;
127 DSDPFunctionBegin;
128 if (X.dsdpops->matzeroentries){
129 info=(X.dsdpops->matzeroentries)(X.matdata); DSDPChkMatError(X,info);
130 } else {
131 DSDPNoOperationError(X);
132 }
133 DSDPFunctionReturn(0);
134}
135
136
137#undef __FUNCT__
138#define __FUNCT__ "DSDPVMatScaleDiagonal"
147int DSDPVMatScaleDiagonal(DSDPVMat X, double dscale){
148 int info;
149 DSDPFunctionBegin;
150 if (X.dsdpops->matscalediagonal){
151 info=(X.dsdpops->matscalediagonal)(X.matdata,dscale); DSDPChkMatError(X,info);
152 } else {
153 DSDPNoOperationError(X);
154 }
155 DSDPFunctionReturn(0);
156}
157
158#undef __FUNCT__
159#define __FUNCT__ "DSDPVMatShiftDiagonal"
166int DSDPVMatShiftDiagonal(DSDPVMat X, double dadd){
167 int info;
168 DSDPFunctionBegin;
169 if (X.dsdpops->matshiftdiagonal){
170 info=(X.dsdpops->matshiftdiagonal)(X.matdata,dadd); DSDPChkMatError(X,info);
171 } else {
172 DSDPNoOperationError(X);
173 }
174 DSDPFunctionReturn(0);
175}
176
177
178#undef __FUNCT__
179#define __FUNCT__ "DSDPVMatNormF2"
186int DSDPVMatNormF2(DSDPVMat X, double*normf2){
187 int info,n;
188 double *dd;
189 DSDPFunctionBegin;
190 if (X.dsdpops->matfnorm2){
191 info=DSDPVMatGetArray(X,&dd,&n); DSDPCHKERR(info);
192 info=(X.dsdpops->matfnorm2)(X.matdata,n,normf2); DSDPChkMatError(X,info);
193 info=DSDPVMatRestoreArray(X,&dd,&n); DSDPCHKERR(info);
194 } else {
195 DSDPNoOperationError(X);
196 }
197 DSDPFunctionReturn(0);
198}
199
200
201#undef __FUNCT__
202#define __FUNCT__ "DSDPVMatGetArray"
211int DSDPVMatGetArray(DSDPVMat X, double **v, int *nn){
212 int info;
213 DSDPFunctionBegin;
214 if (X.dsdpops->matgeturarray){
215 info=(X.dsdpops->matgeturarray)(X.matdata,v,nn); DSDPChkMatError(X,info);
216 } else {
217 *v=0;
218 *nn=0;
219 }
220 DSDPFunctionReturn(0);
221}
222
223#undef __FUNCT__
224#define __FUNCT__ "DSDPVMatRestoreArray"
233int DSDPVMatRestoreArray(DSDPVMat X, double **v, int *nn){
234 int info;
235 DSDPFunctionBegin;
236 if (X.dsdpops->matrestoreurarray){
237 info=(X.dsdpops->matrestoreurarray)(X.matdata,v,nn); DSDPChkMatError(X,info);
238 } else {
239 *v=0;
240 *nn=0;
241 }
242 DSDPFunctionReturn(0);
243}
244
245
246#undef __FUNCT__
247#define __FUNCT__ "DSDPVMatMinEigenvalue"
248int DSDPVMatMinEigenvalue(DSDPVMat X, SDPConeVec W1, SDPConeVec W2, double *mineig){
249 int n,info;
250 double *w,*iwork;
251 DSDPFunctionBegin;
252 if (X.dsdpops->matmineig){
253 info=SDPConeVecGetSize(W1,&n); DSDPCHKERR(info);
254 info=SDPConeVecGetArray(W1,&w); DSDPCHKERR(info);
255 info=SDPConeVecGetArray(W2,&iwork); DSDPCHKERR(info);
256 info=(X.dsdpops->matmineig)(X.matdata,w,iwork,n,mineig); DSDPChkMatError(X,info);
257 info=SDPConeVecRestoreArray(W1,&w); DSDPCHKERR(info);
258 info=SDPConeVecRestoreArray(W2,&iwork); DSDPCHKERR(info);
259 } else {
260 DSDPNoOperationError(X);
261 }
262 DSDPFunctionReturn(0);
263}
264
265
266#undef __FUNCT__
267#define __FUNCT__ "DSDPVMatAddOuterProduct"
276 int info,n;
277 double *v;
278 DSDPFunctionBegin;
279 DSDPEventLogBegin(sdpxmatevent);
280 info=SDPConeVecGetSize(V,&n); DSDPCHKERR(info);
281 if (X.dsdpops->mataddouterproduct){
282 info=SDPConeVecGetArray(V,&v); DSDPCHKERR(info);
283 info=(X.dsdpops->mataddouterproduct)(X.matdata,alpha,v,n); DSDPChkMatError(X,info);
284 info=SDPConeVecRestoreArray(V,&v); DSDPCHKERR(info);
285 } else {
286 DSDPNoOperationError(X);
287 }
288 DSDPEventLogEnd(sdpxmatevent);
289 DSDPFunctionReturn(0);
290}
291
292#undef __FUNCT__
293#define __FUNCT__ "DSDPVMatMult"
302 int info,n;
303 double *z,*y;
304 DSDPFunctionBegin;
305 info=SDPConeVecGetSize(Y,&n); DSDPCHKERR(info);
306 if (X.dsdpops->matmult){
307 info=SDPConeVecGetArray(Z,&z); DSDPCHKERR(info);
308 info=SDPConeVecGetArray(Y,&y); DSDPCHKERR(info);
309 info=(X.dsdpops->matmult)(X.matdata,z,y,n); DSDPChkMatError(X,info);
310 info=SDPConeVecRestoreArray(Z,&z); DSDPCHKERR(info);
311 info=SDPConeVecRestoreArray(Y,&y); DSDPCHKERR(info);
312 } else {
313 DSDPNoOperationError(X);
314 }
315 DSDPFunctionReturn(0);
316}
317
318#undef __FUNCT__
319#define __FUNCT__ "DSDPVMatCheck"
328 int info,i,n,nn;
329 double *xx,eig,eps=1e-13,one=1.0;
330 double fnorm0,fnorm1,fnorm2,fnorm3,fnorm4;
331 DSDPFunctionBegin;
332 info=DSDPVMatGetSize(X,&n);DSDPCHKERR(info);
333 info=SDPConeVecSet(one,W1);DSDPCHKERR(info);
334 info=DSDPVMatAddOuterProduct(X,1.23456,W1);DSDPCHKERR(info);
335 info=DSDPVMatZeroEntries(X);DSDPCHKERR(info);
336 info=DSDPVMatNormF2(X,&fnorm0);DSDPCHKERR(info);
337 if (fabs(fnorm0)>eps){ printf("Check DSDPVMatZero of DSDPVMatNorm\n");}
338
339 info=SDPConeVecSet(one,W1);DSDPCHKERR(info);
340 info=DSDPVMatAddOuterProduct(X,1.0,W1);DSDPCHKERR(info);
341 info=DSDPVMatNormF2(X,&fnorm1);DSDPCHKERR(info);
342 if (fabs(fnorm1-n*n)>eps) printf("Check DSDPVMatZero()\n");
343
344 info=DSDPVMatGetArray(X,&xx,&nn);DSDPCHKERR(info);
345 for (i=0;i<nn;i++){xx[i]=1.0;}
346 info=DSDPVMatRestoreArray(X,&xx,&nn);DSDPCHKERR(info);
347 info=DSDPVMatNormF2(X,&fnorm2);DSDPCHKERR(info);
348 if (fabs(fnorm2-n*n)>eps) printf("Check DSDPXGetArray()\n");
349
350 info=DSDPVMatAddOuterProduct(X,-1.0,W1);DSDPCHKERR(info);
351 info=DSDPVMatNormF2(X,&fnorm3);DSDPCHKERR(info);
352
353 info=DSDPVMatZeroEntries(X);DSDPCHKERR(info);
354 info=DSDPVMatAddOuterProduct(X,1.0,W1);DSDPCHKERR(info);
355 info=DSDPVMatScaleDiagonal(X,2.0);DSDPCHKERR(info);
356
357 info=DSDPVMatZeroEntries(X);DSDPCHKERR(info);
358 info=DSDPVMatAddOuterProduct(X,1.0,W1);DSDPCHKERR(info);
359 info=DSDPVMatShiftDiagonal(X,1.0);DSDPCHKERR(info);
360 info=DSDPVMatNormF2(X,&fnorm4);DSDPCHKERR(info);
361
362 info=DSDPVMatMult(X,W1,W2);DSDPCHKERR(info);
363 info=DSDPVMatMinEigenvalue(X,W1,W2,&eig);DSDPCHKERR(info);
364 if (fabs(fnorm0)>eps) printf("Check DSDPVMatZero()\n");
365 DSDPFunctionReturn(0);
366}
367
368static struct DSDPVMat_Ops dsdpmatops2;
369static const char *urmatname="NOT SET YET";
370#undef __FUNCT__
371#define __FUNCT__ "DSDPVMatOpsInitialize"
378 aops->matgetsize=0;
379 aops->matzeroentries=0;
380 aops->matfnorm2=0;
381 aops->mataddouterproduct=0;
382 aops->matmult=0;
383 aops->matgeturarray=0;
384 aops->matrestoreurarray=0;
385 aops->matview=0;
386 aops->matdestroy=0;
387 aops->matmineig=0;
388 aops->matshiftdiagonal=0;
389 aops->matscalediagonal=0;
390 aops->id=0;
391 aops->matname=urmatname;
392 return 0;
393}
394
395#undef __FUNCT__
396#define __FUNCT__ "DSDPVMatTest"
403 int info;
404 DSDPFunctionBegin;
405 if (X.dsdpops==0 || X.dsdpops==&dsdpmatops2){
406 } else if (X.dsdpops->mattest){
407 info=(X.dsdpops->mattest)(X.matdata); DSDPChkMatError(X,info);
408 } else {
409 /*
410 DSDPNoOperationError(X);
411 */
412 }
413 DSDPFunctionReturn(0);
414}
415
416
417#undef __FUNCT__
418#define __FUNCT__ "DSDPVMatInitialize"
425 int info;
426 DSDPFunctionBegin;
427 info=DSDPVMatOpsInitialize(&dsdpmatops2); DSDPCHKERR(info);
428 info=DSDPVMatSetData(B, &dsdpmatops2, 0); DSDPCHKERR(info);
429 DSDPFunctionReturn(0);
430}
431
432#undef __FUNCT__
433#define __FUNCT__ "DSDPVMatExist"
440int DSDPVMatExist(DSDPVMat X,int *flag){
441 DSDPFunctionBegin;
442 if (X.dsdpops && X.dsdpops!=&dsdpmatops2) *flag=1;
443 else *flag=0;
444 DSDPFunctionReturn(0);
445}
446
Error handling, printing, and profiling.
int DSDPVMatInitialize(DSDPVMat *B)
Set pointers to null.
Definition dsdpxmat.c:424
int DSDPVMatNormF2(DSDPVMat X, double *normf2)
Compute square of Frobenius norm of matrix.
Definition dsdpxmat.c:186
int DSDPVMatSetData(DSDPVMat *X, struct DSDPVMat_Ops *ops, void *data)
Set opaque pointer an function pointers.
Definition dsdpxmat.c:39
int DSDPVMatGetArray(DSDPVMat X, double **v, int *nn)
Get the array that stores the matrix.
Definition dsdpxmat.c:211
int DSDPVMatTest(DSDPVMat X)
Test validity of matrix.
Definition dsdpxmat.c:402
int DSDPVMatGetSize(DSDPVMat X, int *n)
Get number of rows and columns.
Definition dsdpxmat.c:65
int DSDPVMatRestoreArray(DSDPVMat X, double **v, int *nn)
Restore the array that stores the matrix.
Definition dsdpxmat.c:233
int DSDPVMatShiftDiagonal(DSDPVMat X, double dadd)
Add something to diagonal elements.
Definition dsdpxmat.c:166
int DSDPVMatZeroEntries(DSDPVMat X)
Zero matrix.
Definition dsdpxmat.c:125
int DSDPVMatAddOuterProduct(DSDPVMat X, double alpha, SDPConeVec V)
Add outer product of a vector to the matrix.
Definition dsdpxmat.c:275
int DSDPVMatExist(DSDPVMat X, int *flag)
Answer whether the array has been allocated or not.
Definition dsdpxmat.c:440
int DSDPVMatMult(DSDPVMat X, SDPConeVec Z, SDPConeVec Y)
Multiply X by a vector.
Definition dsdpxmat.c:301
int DSDPVMatCheck(DSDPVMat X, SDPConeVec W1, SDPConeVec W2)
Test correctness of operations.
Definition dsdpxmat.c:327
int DSDPVMatDestroy(DSDPVMat *X)
Deallocate matrix.
Definition dsdpxmat.c:86
int DSDPVMatScaleDiagonal(DSDPVMat X, double dscale)
Scaling diagonal is useful for inner products and norms.
Definition dsdpxmat.c:147
int DSDPVMatOpsInitialize(struct DSDPVMat_Ops *aops)
Set function pointers to null.
Definition dsdpxmat.c:377
int DSDPVMatView(DSDPVMat X)
Print matrix.
Definition dsdpxmat.c:107
The interface between the SDPCone and the dense matrix array.
Structure of function pointers that each dense matrix array type (upper full, packed symmetric,...
int SDPConeVecSet(double alpha, SDPConeVec V)
Set each element of vector to this number.
Definition sdpconevec.c:211
Dense symmetric matrix for one block in the semidefinite cone.
Definition dsdpxmat.h:17
Table of function pointers that operate on the dense matrix.
Vector whose length corresponds to dimension of a block in a cone.
Definition sdpconevec.h:13