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"
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"
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"
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"
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"
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"
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"
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"
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 
368 static struct DSDPVMat_Ops dsdpmatops2;
369 static 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"
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 
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 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.
Definition: dsdpxmat_impl.h:13
Vector whose length corresponds to dimension of a block in a cone.
Definition: sdpconevec.h:13