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 
12 static int sdpxmatevent=0;
13 
14 #undef __FUNCT__
15 #define __FUNCT__ "DSDPVMatEventZero"
16 int DSDPVMatEventZero(void){
17  DSDPFunctionBegin;
18  sdpxmatevent=0;
19  DSDPFunctionReturn(0);
20 }
21 
22 #undef __FUNCT__
23 #define __FUNCT__ "DSDPVMatEventInitialize"
24 int 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"
32 
39 int 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"
50 int 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"
59 
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"
81 
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"
102 
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"
120 
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"
139 
147 int 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"
160 
166 int 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"
180 
186 int 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"
203 
211 int 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"
225 
233 int 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"
248 int 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"
268 
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"
294 
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"
320 
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 
368 static struct DSDPVMat_Ops dsdpmatops2;
369 static const char *urmatname="NOT SET YET";
370 #undef __FUNCT__
371 #define __FUNCT__ "DSDPVMatOpsInitialize"
372 
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"
397 
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"
419 
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"
434 
440 int 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 
int DSDPVMatTest(DSDPVMat X)
Test validity of matrix.
Definition: dsdpxmat.c:402
int DSDPVMatExist(DSDPVMat X, int *flag)
Answer whether the array has been allocated or not.
Definition: dsdpxmat.c:440
Structure of function pointers that each dense matrix array type (upper full, packed symmetric,...
Table of function pointers that operate on the dense matrix.
Definition: dsdpxmat_impl.h:13
int DSDPVMatGetArray(DSDPVMat X, double **v, int *nn)
Get the array that stores the matrix.
Definition: dsdpxmat.c:211
Error handling, printing, and profiling.
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 DSDPVMatScaleDiagonal(DSDPVMat X, double dscale)
Scaling diagonal is useful for inner products and norms.
Definition: dsdpxmat.c:147
int DSDPVMatMult(DSDPVMat X, SDPConeVec Z, SDPConeVec Y)
Multiply X by a vector.
Definition: dsdpxmat.c:301
int DSDPVMatInitialize(DSDPVMat *B)
Set pointers to null.
Definition: dsdpxmat.c:424
Vector whose length corresponds to dimension of a block in a cone.
Definition: sdpconevec.h:13
int SDPConeVecSet(double alpha, SDPConeVec V)
Set each element of vector to this number.
Definition: sdpconevec.c:211
The interface between the SDPCone and the dense matrix array.
int DSDPVMatDestroy(DSDPVMat *X)
Deallocate matrix.
Definition: dsdpxmat.c:86
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 DSDPVMatCheck(DSDPVMat X, SDPConeVec W1, SDPConeVec W2)
Test correctness of operations.
Definition: dsdpxmat.c:327
int DSDPVMatView(DSDPVMat X)
Print matrix.
Definition: dsdpxmat.c:107
Dense symmetric matrix for one block in the semidefinite cone.
Definition: dsdpxmat.h:17
int DSDPVMatNormF2(DSDPVMat X, double *normf2)
Compute square of Frobenius norm of matrix.
Definition: dsdpxmat.c:186
int DSDPVMatShiftDiagonal(DSDPVMat X, double dadd)
Add something to diagonal elements.
Definition: dsdpxmat.c:166
int DSDPVMatOpsInitialize(struct DSDPVMat_Ops *aops)
Set function pointers to null.
Definition: dsdpxmat.c:377