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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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 DSDPDataMatAddMultiple(DSDPDataMat A, double ytmp, double *v, int nn, int n)
Add a multiple the data matrix to the array.
Definition: dsdpdatamat.c:402
int DSDPDataMatVecVec(DSDPDataMat A, SDPConeVec W, double *v)
Compute w' A w.
Definition: dsdpdatamat.c:297
int DSDPDataMatDestroy(DSDPDataMat *A)
Free the data structures.
Definition: dsdpdatamat.c:444
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 DSDPDataMatGetEig(DSDPDataMat A, int rr, SDPConeVec V, DSDPIndex S, double *eigenvalue)
Get an eigenvalue/vector pair.
Definition: dsdpdatamat.c:204
int DSDPDataMatOpsInitialize(struct DSDPDataMat_Ops *dops)
Initialize the table of function pointers for SDP Data matrices.
Definition: dsdpdatamat.c:47
int DSDPDataMatView(DSDPDataMat A)
Print matrix.
Definition: dsdpdatamat.c:423
int DSDPDataMatGetRank(DSDPDataMat A, int *rank, int n)
Get the number of nonzero eigenvalues/eigenvectors for the matrix.
Definition: dsdpdatamat.c:129
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 DSDPDataMatCountNonzeros(DSDPDataMat A, int *nnz, int n)
Compute the square of the Frobenius norm.
Definition: dsdpdatamat.c:152
int DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2)
Compute the square of the Frobenius norm.
Definition: dsdpdatamat.c:175
int DSDPDataMatTest(DSDPDataMat A)
Test validity of matrix.
Definition: dsdpdatamat.c:96
int DSDPDataMatInitialize(DSDPDataMat *A)
Set pointers to NULL;.
Definition: dsdpdatamat.c:78
The interface between the SDPCone and the data matrices.
Structure of function pointers that each SDP data matrix type (sparse, dense, constant,...
Error handling, printing, and profiling.
Symmetric data matrix for one block in the semidefinite cone.
Definition: dsdpdatamat.h:15
Table of function pointers that operate on the data matrix.
Vector whose length corresponds to dimension of a block in a cone.
Definition: sdpconevec.h:13