4static int sdpvecvecevent=0,sdpdotevent=0;
11#define __FUNCT__ "DSDPBlockASum"
22 double *xx,ytmp,scl=ADATA->scl;
23 int ii,vari,n,nn,info;
28 for (ii=0;ii<ADATA->nnzmats;ii++){
29 vari=ADATA->nzmat[ii];
30 info=DSDPVecGetElement(Yk,vari,&ytmp);DSDPCHKVARERR(vari,info);
31 if (ytmp==0)
continue;
35 DSDPFunctionReturn(0);
39#define __FUNCT__ "DSDPBlockADot"
51 int ii,vari,n,nn,info;
52 double *x,sum=0,aalpha=0,scl=ADATA->scl;
55 DSDPEventLogBegin(sdpdotevent);
59 for (ii=0;ii<ADATA->nnzmats; ii++){
60 vari=ADATA->nzmat[ii];
61 info=DSDPVecGetElement(Alpha,vari,&aalpha);DSDPCHKVARERR(vari,info);
62 if (aalpha==0.0)
continue;
63 info=
DSDPDataMatDot(ADATA->A[ii],x,nn,n,&sum);DSDPCHKVARERR(vari,info);
64 info=DSDPVecAddElement(AX,vari,aa*aalpha*sum*scl);DSDPCHKVARERR(vari,info);
68 DSDPEventLogEnd(sdpdotevent);
69 DSDPFunctionReturn(0);
73#define __FUNCT__ "DSDPBlockvAv"
87 double sum=0,aalpha=0,scl=ADATA->scl;
90 DSDPEventLogBegin(sdpvecvecevent);
91 if (aa==0){DSDPFunctionReturn(0);}
92 for (ii=0;ii<ADATA->nnzmats; ii++){
93 vari=ADATA->nzmat[ii];
94 info=DSDPVecGetElement(Alpha,vari,&aalpha);DSDPCHKVARERR(vari,info);
95 if (aalpha==0.0)
continue;
97 info=DSDPVecAddElement(VAV,vari,aa*aalpha*sum*scl);DSDPCHKVARERR(vari,info);
99 DSDPEventLogEnd(sdpvecvecevent);
100 DSDPFunctionReturn(0);
104#define __FUNCT__ "DSDPBlockFactorData"
116 int ii,vari,n,nn,info,*iwork3n,i13,n26;
122 i13=13*n+1;n26=26*n+1;
123 DSDPCALLOC2(&dwork3n,
double,n26,&info);DSDPCHKERR(info);
124 DSDPCALLOC2(&iwork3n,
int,i13,&info);DSDPCHKERR(info);
126 for (ii=0;ii<ADATA->nnzmats; ii++){
128 DSDPLogInfo(0,39,
"SDP Data Mat Setup: %d\n",vari);
129 if (vari==0)
continue;
130 info=
DSDPDataMatFactor(AA,W,x,nn,dwork3n,n26,iwork3n,i13); DSDPCHKVARERR(vari,info);
133 DSDPFREE(&dwork3n,&info);DSDPCHKERR(info);
134 DSDPFREE(&iwork3n,&info);DSDPCHKERR(info);
135 DSDPFunctionReturn(0);
140#define __FUNCT__ "DSDPBlockEventZero"
141int DSDPBlockEventZero(
void){
143 sdpvecvecevent=0;sdpdotevent=0;
144 DSDPFunctionReturn(0);
148#define __FUNCT__ "DSDPBlockEventInitialize"
149int DSDPBlockEventInitialize(
void){
151 if (sdpvecvecevent==0){DSDPEventLogRegister(
"SDP VecMatVec",&sdpvecvecevent);}
152 if (sdpdotevent==0){DSDPEventLogRegister(
"SDP Dot",&sdpdotevent);}
153 DSDPFunctionReturn(0);
157#define __FUNCT__ "DSDPBlockDataInitialize"
172 DSDPFunctionReturn(0);
176#define __FUNCT__ "DSDPBlockTakeDownData"
184 DSDPFunctionReturn(0);
189#define __FUNCT__ "DSDPBlockDataDestroy"
198 if (!ADATA){DSDPFunctionReturn(0);}
199 DSDPLogInfo(0,18,
"Destroying All Existing Data Matrices \n");
200 for (ii=0; ii<ADATA->nnzmats; ii++){
201 vari=ADATA->nzmat[ii];
207 DSDPFREE(&ADATA->nzmat,&info);DSDPCHKERR(info);
208 DSDPFREE(&ADATA->A,&info);DSDPCHKERR(info);
210 DSDPFunctionReturn(0);
214#define __FUNCT__ "DSDPBlockDataAllocate"
225 if (!ADATA){DSDPFunctionReturn(0);}
226 if (nnz<=ADATA->maxnnzmats){DSDPFunctionReturn(0);}
227 DSDPLogInfo(0,18,
"REALLOCATING SPACE FOR %d SDP BLOCK MATRICES! Previously allocated: %d \n",nnz,ADATA->maxnnzmats);
228 DSDPCALLOC2(&A,
struct DSDPDataMat_C,nnz,&info);DSDPCHKERR(info);
229 DSDPCALLOC2(&nzmat,
int,nnz,&info);DSDPCHKERR(info);
230 for (j=0;j<nnz;j++){nzmat[j]=0;}
232 if (ADATA->maxnnzmats>0){
233 for (j=0;j<ADATA->nnzmats;j++){nzmat[j]=ADATA->nzmat[j];}
234 for (j=0;j<ADATA->nnzmats;j++){A[j]=ADATA->A[j];}
235 DSDPFREE(&ADATA->A,&info);DSDPCHKERR(info);
236 DSDPFREE(&ADATA->nzmat,&info);DSDPCHKERR(info);
240 ADATA->maxnnzmats=nnz;
243 DSDPFunctionReturn(0);
247#define __FUNCT__ "DSDPBlockDataMarkNonzeroMatrices"
257 for (i=0; i<ADATA->nnzmats; i++){
258 annz[ADATA->nzmat[i]]++;
260 DSDPFunctionReturn(0);
264#define __FUNCT__ "DSDPBlockCountNonzerosMatrices"
274 *nzmats=ADATA->nnzmats;
275 DSDPFunctionReturn(0);
279#define __FUNCT__ "DSDPBlockDataRank"
280int DSDPBlockDataRank(
DSDPBlockData *ADATA,
int *trank,
int n){
281 int ii,vari,info,ri,r2=0;
285 for (ii=0;ii<ADATA->nnzmats;ii++){
287 if (vari==0)
continue;
292 DSDPFunctionReturn(0);
296#define __FUNCT__ "DSDPBlockGetMatrix"
309 if (
id>=0 && id < ADATA->nnzmats){
310 if (vari) *vari=ADATA->nzmat[id];
311 if (scl) *scl=ADATA->scl;
312 if (A) *A=ADATA->A[id];
314 DSDPSETERR2(2,
"Invalid Matrix request. 0 <= %d < %d\n",
id,ADATA->nnzmats);
316 DSDPFunctionReturn(0);
320#define __FUNCT__ "DSDPBlockDataRowSparsity"
334 for (i=0; i<ADATA->nnzmats; i++){
335 vari=ADATA->nzmat[i];
336 if (ai[vari]==0){
continue;}
340 DSDPFunctionReturn(0);
344#define __FUNCT__ "DSDPBlockRemoveDataMatrix"
354 for (ii=0;ii<ADATA->nnzmats;ii++){
355 if (ADATA->nzmat[ii]==vari){
358 for (k=ii;k<ADATA->nnzmats;k++){
359 ADATA->A[k]=ADATA->A[k+1];
360 ADATA->nzmat[k]=ADATA->nzmat[k+1];
364 DSDPFunctionReturn(0);
367 DSDPFunctionReturn(0);
371#define __FUNCT__ "DSDPBlockAddDataMatrix"
384 if (ADATA->nnzmats>=ADATA->maxnnzmats){
390 ADATA->nzmat[ii]=vari;
392 DSDPFunctionReturn(0);
396#define __FUNCT__ "DSDPBlockSetDataMatrix"
411 DSDPFunctionReturn(0);
415#define __FUNCT__ "DSDPBlockNorm2"
420 for (ii=0;ii<ADATA->nnzmats;ii++){
424 DSDPFunctionReturn(0);
428#define __FUNCT__ "DSDPBlockANorm2"
431 double fn2,scl=ADATA->scl;
435 info=DSDPBlockNorm2(ADATA,n);DSDPCHKERR(info);
437 for (ii=0;ii<ADATA->nnzmats;ii++){
438 vari=ADATA->nzmat[ii];
440 info=DSDPVecAddElement(ANorm2,vari,fn2*scl);DSDPCHKVARERR(vari,info);
442 DSDPFunctionReturn(0);
447#define __FUNCT__ "DSDPBlockView"
458 for (ii=0;ii<ADATA->nnzmats;ii++){
460 if (kk==0){ printf(
"+ C\n");}
461 else { printf(
" - A[%d] y%d\n",kk,kk);}
463 printf(
" = S >= 0\n");
464 DSDPFunctionReturn(0);
467#define __FUNCT__ "DSDPBlockView2"
478 for (ii=0;ii<ADATA->nnzmats;ii++){
479 vari=ADATA->nzmat[ii];
480 printf(
"A[%d] y%d \n",vari,vari);
483 DSDPFunctionReturn(0);
488#define __FUNCT__ "DSDPDataMatCheck"
500 double *xx,ack,vAv=0,esum=0,sum,eignorm,fnorm22,dnorm,scl=1;
501 int k,n,nn,rank,info;
504 info=SDPConeVecGetSize(W,&n);DSDPCHKERR(info);
508 for (k=0; k<rank; k++){
513 vAv+=ack*ack*eignorm*eignorm*scl;
528 printf(
" %4.4e, %4.4e %4.4e\n",esum,vAv,fnorm22);
529 printf(
" error1: %4.4e, error2: %4.4e, error3: %4.4e\n",sqrt(dnorm),fabs(esum-vAv),fabs(fnorm22-vAv));
530 if (dnorm>1) printf(
"Check Add or eigs\n");
531 if (fabs(esum-vAv) > 1.0) printf(
"Check vAv \n");
532 if (fabs(fnorm22-vAv) > 1.0) printf(
"Check fnorm22\n");
534 DSDPFunctionReturn(0);
int DSDPSetDataMatZero(DSDPDataMat *A)
Make a data matrix a zero matrix.
int DSDPDataMatCheck(DSDPDataMat AA, SDPConeVec W, DSDPIndex IS, DSDPVMat XX)
Check correctness of operations on the data.
int DSDPBlockView2(DSDPBlockData *ADATA)
Print the data.
int DSDPBlockDataDestroy(DSDPBlockData *ADATA)
Free the data matrices.
int DSDPBlockDataAllocate(DSDPBlockData *ADATA, int nnz)
Allocate some structures.
int DSDPBlockGetMatrix(DSDPBlockData *ADATA, int id, int *vari, double *scl, DSDPDataMat *A)
Get a data matrix from a block of data.
int DSDPBlockDataInitialize(DSDPBlockData *ADATA)
Set pointers to null.
int DSDPBlockDataMarkNonzeroMatrices(DSDPBlockData *ADATA, int *annz)
Mark which variable in block have a data matrix.
int DSDPBlockAddDataMatrix(DSDPBlockData *ADATA, int vari, struct DSDPDataMat_Ops *dsdpdataops, void *data)
Add data matrix into SDP block.
int DSDPBlockSetDataMatrix(DSDPBlockData *ADATA, int vari, struct DSDPDataMat_Ops *dsdpdataops, void *data)
Set data matrix into SDP block.
int DSDPBlockASum(DSDPBlockData *ADATA, double aa, DSDPVec Yk, DSDPVMat XX)
Sum the data matrices.
int DSDPBlockRemoveDataMatrix(DSDPBlockData *ADATA, int vari)
Remove a data matrix.
int DSDPBlockCountNonzeroMatrices(DSDPBlockData *ADATA, int *nzmats)
Count how many data matrices are in a block of data.
int DSDPBlockDataRowSparsity(DSDPBlockData *ADATA, int row, int ai[], int rnnz[], int n)
Determine sparsity pattern of data.
int DSDPBlockvAv(DSDPBlockData *ADATA, double aa, DSDPVec Alpha, SDPConeVec V, DSDPVec VAV)
Set VAV[i] to aa * Alpha[i] * V' A[i] V.
int DSDPBlockFactorData(DSDPBlockData *ADATA, DSDPVMat X, SDPConeVec W)
Factor the data matrices.
int DSDPBlockADot(DSDPBlockData *ADATA, double aa, DSDPVec Alpha, DSDPVMat X, DSDPVec AX)
Compute inner product of XX with data matrices.
int DSDPBlockView(DSDPBlockData *ADATA)
Print the structure of the block.
int DSDPBlockTakeDownData(DSDPBlockData *ADATA)
Free structures in block of data.
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 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.
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 DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2)
Compute the square of the Frobenius norm.
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;.
Internal SDPCone data structures and routines.
Error handling, printing, and profiling.
struct DSDPVec_C DSDPVec
This object hold m+2 variables: a scaling of C, the y variables, and r.
int DSDPVMatNormF2(DSDPVMat X, double *normf2)
Compute square of Frobenius norm of matrix.
int DSDPVMatGetArray(DSDPVMat X, double **v, int *nn)
Get the array that stores the matrix.
int DSDPVMatGetSize(DSDPVMat X, int *n)
Get number of rows and columns.
int DSDPVMatRestoreArray(DSDPVMat X, double **v, int *nn)
Restore the array that stores the matrix.
int DSDPVMatZeroEntries(DSDPVMat X)
Zero matrix.
int DSDPVMatAddOuterProduct(DSDPVMat X, double alpha, SDPConeVec V)
Add outer product of a vector to the matrix.
int DSDPVMatScaleDiagonal(DSDPVMat X, double dscale)
Scaling diagonal is useful for inner products and norms.
int DSDPVMatView(DSDPVMat X)
Print matrix.
int SDPConeVecDot(SDPConeVec V1, SDPConeVec V2, double *ans)
Inner product of two vectors.
Internal structure for data in one block of semidefintie.
Symmetric data matrix for one block in the semidefinite cone.
Table of function pointers that operate on the data matrix.
Dense symmetric matrix for one block in the semidefinite cone.
Vector whose length corresponds to dimension of a block in a cone.