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.
struct DSDPDataMat_C DSDPDataMat
Represents a single symmetric data matrix for one block in this semidefinite cone.
Definition dsdpdatamat.h:25
Structure of function pointers that each SDP data matrix type (sparse, dense, constant,...
Error handling, printing, and profiling.
struct SDPConeVec_C SDPConeVec
SDPConeVec is a vector with the dimension of the block in the SDP cone.
Definition sdpconevec.h:26
Table of function pointers that operate on the data matrix.