DSDP
dsdpxmat.c
Go to the documentation of this file.
1#include "dsdpxmat_impl.h"
2#include "dsdpxmat.h"
3#include "dsdpsys.h"
8
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.
struct DSDPVMat_C DSDPVMat
Represents a dense symmetric matrix for one block in the semidefinite cone.
Definition dsdpxmat.h:26
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
struct SDPConeVec_C SDPConeVec
SDPConeVec is a vector with the dimension of the block in the SDP cone.
Definition sdpconevec.h:26
Table of function pointers that operate on the dense matrix.