DSDP
dsdpdatamat.c
Go to the documentation of this file.
1 #include "dsdpdatamat_impl.h"
2 #include "dsdpdatamat.h"
3 #include "dsdpsys.h"
8 #define DSDPNoOperationError(a); { DSDPSETERR1(1,"Data natrix type: %s, Operation not defined\n",(a).dsdpops->matname); }
9 #define DSDPChkDataError(a,b); { if (b){ DSDPSETERR1(b,"Data natrix type: %s,\n",(a).dsdpops->matname);} }
10 
11 
12 static struct DSDPDataMat_Ops dsdpdatamatdefault;
13 
14 #undef __FUNCT__
15 #define __FUNCT__ "DSDPDataMatSetData"
16 
25 int DSDPDataMatSetData(DSDPDataMat *A, struct DSDPDataMat_Ops* ops, void*data){
26  int info;
27  DSDPFunctionBegin;
28  (*A).dsdpops=ops;
29  (*A).matdata=data;
30  if (ops==NULL){
31  (*A).dsdpops=&dsdpdatamatdefault;
32  }
33  info = DSDPDataMatOpsInitialize(&dsdpdatamatdefault); DSDPCHKERR(info);
34  info=DSDPDataMatTest(*A);DSDPCHKERR(info);
35  DSDPFunctionReturn(0);
36 }
37 
38 static char datamatnoname[20]="MATRIX NOT SET";
39 #undef __FUNCT__
40 #define __FUNCT__ "DSDPDataMatOpsInitialize"
41 
48  DSDPFunctionBegin;
49  if (dops==NULL) return 0;
50  dops->matfactor1=0;
51  dops->matfactor2=0;
52  dops->matgetrank=0;
53  dops->matgeteig=0;
54  dops->matvecvec=0;
55  dops->matdot=0;
56  dops->mataddrowmultiple=0;
57  dops->mataddallmultiple=0;
58  dops->matdestroy=0;
59  dops->matview=0;
60  dops->matrownz=0;
61  dops->matnnz=0;
62  dops->matfnorm2=0;
63  dops->id=0;
64  dops->matname=datamatnoname;
65  DSDPFunctionReturn(0);
66 }
67 
68 
69 #undef __FUNCT__
70 #define __FUNCT__ "DSDPDataMatInitialize"
71 
79  int info;
80  DSDPFunctionBegin;
81  info = DSDPDataMatOpsInitialize(&dsdpdatamatdefault); DSDPCHKERR(info);
82  info = DSDPDataMatSetData(A, &dsdpdatamatdefault,0); DSDPCHKERR(info);
83  DSDPFunctionReturn(0);
84 }
85 
86 
87 #undef __FUNCT__
88 #define __FUNCT__ "DSDPDataMatTest"
89 
97  int info;
98  DSDPFunctionBegin;
99  if (A.dsdpops==0 || A.dsdpops==&dsdpdatamatdefault){
100  } else if (A.dsdpops->mattest){
101  info=(A.dsdpops->mattest)(A.matdata); DSDPChkDataError(A,info);
102  } else {
103  /*
104  DSDPNoOperationError(A);
105  */
106  }
107  DSDPFunctionReturn(0);
108 }
109 
110 #undef __FUNCT__
111 #define __FUNCT__ "DSDPDataMatGetType"
112 int DSDPDataMatGetType(DSDPDataMat A, int *id){
113  DSDPFunctionBegin;
114  *id=A.dsdpops->id;
115  DSDPFunctionReturn(0);
116 }
117 
118 #undef __FUNCT__
119 #define __FUNCT__ "DSDPDataMatGetRank"
120 
129 int DSDPDataMatGetRank(DSDPDataMat A, int *rank, int n){
130  int info;
131  DSDPFunctionBegin;
132  if (A.dsdpops->matgetrank){
133  info=(A.dsdpops->matgetrank)(A.matdata,rank,n); DSDPChkDataError(A,info);
134  } else {
135  DSDPNoOperationError(A);
136  }
137  DSDPFunctionReturn(0);
138 }
139 
140 #undef __FUNCT__
141 #define __FUNCT__ "DSDPDataMatCountNonzeros"
142 
152 int DSDPDataMatCountNonzeros(DSDPDataMat A, int *nnz, int n){
153  int info;
154  DSDPFunctionBegin;
155  if (A.dsdpops->matnnz){
156  info=(A.dsdpops->matnnz)(A.matdata,nnz,n); DSDPChkDataError(A,info);
157  } else {
158  DSDPNoOperationError(A);
159  }
160  DSDPFunctionReturn(0);
161 }
162 
163 #undef __FUNCT__
164 #define __FUNCT__ "DSDPDataMatFNorm2"
165 
175 int DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2){
176  int info;
177  DSDPFunctionBegin;
178  if (A.dsdpops->matfnorm2){
179  *fnorm2=0.0;
180  info=(A.dsdpops->matfnorm2)(A.matdata,n,fnorm2); DSDPChkDataError(A,info);
181  } else {
182  DSDPNoOperationError(A);
183  }
184  DSDPFunctionReturn(0);
185 }
186 
187 
188 #undef __FUNCT__
189 #define __FUNCT__ "DSDPDataMatGetEig"
190 
204 int DSDPDataMatGetEig(DSDPDataMat A, int rr, SDPConeVec V, DSDPIndex S, double *eigenvalue){
205  int info,n;
206  double *vv;
207  DSDPFunctionBegin;
208  if (A.dsdpops->matgeteig){
209  info=SDPConeVecGetArray(V,&vv); DSDPCHKERR(info);
210  info=SDPConeVecGetSize(V,&n); DSDPCHKERR(info);
211  info=(A.dsdpops->matgeteig)(A.matdata,rr, eigenvalue, vv,n,S.indx+1,S.indx); DSDPChkDataError(A,info);
212  info=SDPConeVecRestoreArray(V,&vv); DSDPCHKERR(info);
213  } else {
214  DSDPNoOperationError(A);
215  }
216  DSDPFunctionReturn(0);
217 }
218 
219 #undef __FUNCT__
220 #define __FUNCT__ "DSDPDataMatFactor"
221 
240 int DSDPDataMatFactor(DSDPDataMat A, SDPConeVec W, double*dworknn, int nn0,
241  double *dwork3n, int nd, int* iwork, int ni){
242  int info,n;
243  double *dvecwork;
244  DSDPFunctionBegin;
245  if (A.dsdpops->matfactor1){
246  info=(A.dsdpops->matfactor1)(A.matdata); DSDPChkDataError(A,info);
247  } else if (A.dsdpops->matfactor2){
248  info=SDPConeVecGetSize(W,&n);
249  info=SDPConeVecGetArray(W,&dvecwork);
250  info=(A.dsdpops->matfactor2)(A.matdata,dworknn,nn0,dvecwork,n,dwork3n,nd,iwork,ni); DSDPChkDataError(A,info);
251  info=SDPConeVecRestoreArray(W,&dvecwork);
252  } else {
253  DSDPNoOperationError(A);
254  }
255  DSDPFunctionReturn(0);
256 }
257 
258 #undef __FUNCT__
259 #define __FUNCT__ "DSDPDataMatDot"
260 
273 int DSDPDataMatDot(DSDPDataMat A, double x[], int nn, int n, double *v){
274  int info;
275 
276  DSDPFunctionBegin;
277  if (A.dsdpops->matdot){
278  info=(A.dsdpops->matdot)(A.matdata,x,nn,n,v); DSDPChkDataError(A,info);
279  } else {
280  DSDPNoOperationError(A);
281  }
282  DSDPFunctionReturn(0);
283 }
284 
285 #undef __FUNCT__
286 #define __FUNCT__ "DSDPDataMatVecVec"
287 
298  int info,n;
299  double *x;
300 
301  DSDPFunctionBegin;
302  if (A.dsdpops->matvecvec){
303  info=SDPConeVecGetSize(W,&n); DSDPCHKERR(info);
304  info=SDPConeVecGetArray(W,&x); DSDPCHKERR(info);
305  info=(A.dsdpops->matvecvec)(A.matdata,x,n,v); DSDPChkDataError(A,info);
306  info=SDPConeVecRestoreArray(W,&x); DSDPCHKERR(info);
307  } else {
308  DSDPNoOperationError(A);
309  }
310  DSDPFunctionReturn(0);
311 }
312 
313 #undef __FUNCT__
314 #define __FUNCT__ "DSDPDataMatMultiply"
315 /*
316 \fn int DSDPDataMatMultiply(DSDPDataMat A, SDPConeVec V1, SDPConeVec V2);
317 
318 \brief Compute V2 = A*V1;
319 \param A symmetric data matrix
320 \param V1 in vector
321 \param V2 the product
322 Not needed.
323 */
324 int DSDPDataMatMultiply(DSDPDataMat A, SDPConeVec V1, SDPConeVec V2){
325  int info,n;
326  double *vv1,*vv2;
327 
328  DSDPFunctionBegin;
329  if (A.dsdpops->matmultiply){
330  info=SDPConeVecGetSize(V1,&n); DSDPCHKERR(info);
331  info=SDPConeVecGetArray(V1,&vv1); DSDPCHKERR(info);
332  info=SDPConeVecGetArray(V2,&vv2); DSDPCHKERR(info);
333  info=(A.dsdpops->matmultiply)(A.matdata,vv1,vv2,n); DSDPChkDataError(A,info);
334  info=SDPConeVecRestoreArray(V1,&vv1); DSDPCHKERR(info);
335  info=SDPConeVecRestoreArray(V2,&vv2); DSDPCHKERR(info);
336  } else {
337  DSDPNoOperationError(A);
338  }
339  DSDPFunctionReturn(0);
340 }
341 
342 #undef __FUNCT__
343 #define __FUNCT__ "DSDPDataMatGetRowNonzeros"
344 
355 int DSDPDataMatGetRowNonzeros(DSDPDataMat A, int nrow, int nmax, int *nz, int *nnz){
356  int i,info;
357  DSDPFunctionBegin;
358  if (A.dsdpops->matrownz){
359  info=(A.dsdpops->matrownz)(A.matdata,nrow,nz,nnz,nmax); DSDPChkDataError(A,info);
360  } else {
361  *nnz=nmax;
362  for (i=0;i<nmax;i++){
363  nz[i]++;
364  }
365  }
366  DSDPFunctionReturn(0);
367 }
368 
369 #undef __FUNCT__
370 #define __FUNCT__ "DSDPDataMatAddRowMultipleToVector"
371 int DSDPDataMatAddRowMultipleToVector(DSDPDataMat A, int nrow, double ytmp, SDPConeVec R){
372  int info,n;
373  double *vv;
374  DSDPFunctionBegin;
375  if (A.dsdpops->mataddrowmultiple){
376  info=SDPConeVecGetArray(R,&vv);DSDPCHKERR(info);
377  info=SDPConeVecGetSize(R,&n);DSDPCHKERR(info);
378  info=(A.dsdpops->mataddrowmultiple)(A.matdata,nrow,ytmp,vv,n); DSDPChkDataError(A,info);
379  info=SDPConeVecRestoreArray(R,&vv);DSDPCHKERR(info);
380  } else {
381  DSDPNoOperationError(A);
382  }
383  DSDPFunctionReturn(0);
384 }
385 
386 
387 #undef __FUNCT__
388 #define __FUNCT__ "DSDPDataMatAddMultiple"
389 
402 int DSDPDataMatAddMultiple(DSDPDataMat A, double ytmp, double *v, int nn, int n){
403  int info;
404  DSDPFunctionBegin;
405  if (A.dsdpops->mataddallmultiple){
406  info=(A.dsdpops->mataddallmultiple)(A.matdata,ytmp,v,nn,n); DSDPChkDataError(A,info);
407  } else {
408  DSDPNoOperationError(A);
409  }
410  DSDPFunctionReturn(0);
411 }
412 
413 
414 #undef __FUNCT__
415 #define __FUNCT__ "DSDPDataMatView"
416 
424  int info;
425  DSDPFunctionBegin;
426  if (A.dsdpops->matview){
427  info=(A.dsdpops->matview)(A.matdata); DSDPChkDataError(A,info);
428  } else {
429  printf("No matrix view available for matrix type %s.\n",A.dsdpops->matname);
430  }
431  DSDPFunctionReturn(0);
432 }
433 
434 
435 #undef __FUNCT__
436 #define __FUNCT__ "DSDPDataMatDestroy"
437 
445  int info;
446  DSDPFunctionBegin;
447  if ( (*A).dsdpops->matdestroy){
448  info=((*A).dsdpops->matdestroy)((*A).matdata); DSDPChkDataError(*A,info);
449  } else {
450  /* DSDPNoOperationError(*A); */
451  }
452  info=DSDPDataMatInitialize(A); DSDPCHKERR(info);
453  /* info=DSDPZeroMatCreate(0,A); DSDPCHKERR(info); */
454 
455  DSDPFunctionReturn(0);
456 }
457 
int DSDPDataMatDot(DSDPDataMat A, double x[], int nn, int n, double *v)
Compute inner product of data with a dense matrix.
Definition: dsdpdatamat.c:273
int DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2)
Compute the square of the Frobenius norm.
Definition: dsdpdatamat.c:175
Error handling, printing, and profiling.
int DSDPDataMatTest(DSDPDataMat A)
Test validity of matrix.
Definition: dsdpdatamat.c:96
int DSDPDataMatOpsInitialize(struct DSDPDataMat_Ops *dops)
Initialize the table of function pointers for SDP Data matrices.
Definition: dsdpdatamat.c:47
int DSDPDataMatGetRank(DSDPDataMat A, int *rank, int n)
Get the number of nonzero eigenvalues/eigenvectors for the matrix.
Definition: dsdpdatamat.c:129
int DSDPDataMatGetEig(DSDPDataMat A, int rr, SDPConeVec V, DSDPIndex S, double *eigenvalue)
Get an eigenvalue/vector pair.
Definition: dsdpdatamat.c:204
int DSDPDataMatGetRowNonzeros(DSDPDataMat A, int nrow, int nmax, int *nz, int *nnz)
Get sparsity pattern of a row of the matrix.
Definition: dsdpdatamat.c:355
int DSDPDataMatInitialize(DSDPDataMat *A)
Set pointers to NULL;.
Definition: dsdpdatamat.c:78
Vector whose length corresponds to dimension of a block in a cone.
Definition: sdpconevec.h:13
Structure of function pointers that each SDP data matrix type (sparse, dense, constant,...
Symmetric data matrix for one block in the semidefinite cone.
Definition: dsdpdatamat.h:15
int DSDPDataMatCountNonzeros(DSDPDataMat A, int *nnz, int n)
Compute the square of the Frobenius norm.
Definition: dsdpdatamat.c:152
int DSDPDataMatAddMultiple(DSDPDataMat A, double ytmp, double *v, int nn, int n)
Add a multiple the data matrix to the array.
Definition: dsdpdatamat.c:402
The interface between the SDPCone and the data matrices.
Table of function pointers that operate on the data matrix.
int DSDPDataMatDestroy(DSDPDataMat *A)
Free the data structures.
Definition: dsdpdatamat.c:444
int DSDPDataMatVecVec(DSDPDataMat A, SDPConeVec W, double *v)
Compute w' A w.
Definition: dsdpdatamat.c:297
int DSDPDataMatView(DSDPDataMat A)
Print matrix.
Definition: dsdpdatamat.c:423