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
12static struct DSDPDataMat_Ops dsdpdatamatdefault;
13
14#undef __FUNCT__
15#define __FUNCT__ "DSDPDataMatSetData"
25int 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
38static 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"
112int DSDPDataMatGetType(DSDPDataMat A, int *id){
113 DSDPFunctionBegin;
114 *id=A.dsdpops->id;
115 DSDPFunctionReturn(0);
116}
117
118#undef __FUNCT__
119#define __FUNCT__ "DSDPDataMatGetRank"
129int 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"
152int 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"
175int 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"
204int 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"
240int 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"
273int 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
322Not needed.
323*/
324int 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"
355int 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"
371int 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"
402int 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.
int DSDPDataMatVecVec(DSDPDataMat A, SDPConeVec W, double *v)
Compute w' A w.
int DSDPDataMatDestroy(DSDPDataMat *A)
Free the data structures.
int DSDPDataMatGetRowNonzeros(DSDPDataMat A, int nrow, int nmax, int *nz, int *nnz)
Get sparsity pattern of a row of the matrix.
int DSDPDataMatGetEig(DSDPDataMat A, int rr, SDPConeVec V, DSDPIndex S, double *eigenvalue)
Get an eigenvalue/vector pair.
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.
int DSDPDataMatSetData(DSDPDataMat *A, struct DSDPDataMat_Ops *ops, void *data)
Set the opaque pointer and function pointers to the matrix.
Definition dsdpdatamat.c:25
int DSDPDataMatGetRank(DSDPDataMat A, int *rank, int n)
Get the number of nonzero eigenvalues/eigenvectors for the matrix.
int DSDPDataMatDot(DSDPDataMat A, double x[], int nn, int n, double *v)
Compute inner product of data with a dense matrix.
int DSDPDataMatCountNonzeros(DSDPDataMat A, int *nnz, int n)
Compute the square of the Frobenius norm.
int DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2)
Compute the square of the Frobenius norm.
int DSDPDataMatTest(DSDPDataMat A)
Test validity of matrix.
Definition dsdpdatamat.c:96
int DSDPDataMatFactor(DSDPDataMat A, SDPConeVec W, double *dworknn, int nn0, double *dwork3n, int nd, int *iwork, int ni)
Do eigenvalue/vector or other factorization.
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