4 static 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" 141 int DSDPBlockEventZero(
void){
143 sdpvecvecevent=0;sdpdotevent=0;
144 DSDPFunctionReturn(0);
148 #define __FUNCT__ "DSDPBlockEventInitialize" 149 int 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" 280 int 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){
389 info=DSDPDataMatSetData(&ADATA->A[ii], dsdpdataops, data);DSDPCHKVARERR(vari,info);
390 ADATA->nzmat[ii]=vari;
392 DSDPFunctionReturn(0);
396 #define __FUNCT__ "DSDPBlockSetDataMatrix" 410 info=DSDPBlockAddDataMatrix(ADATA,vari,dsdpdataops,data);DSDPCHKERR(info);
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 DSDPDataMatDot(DSDPDataMat A, double x[], int nn, int n, double *v)
Compute inner product of data with a dense matrix.
int DSDPBlockRemoveDataMatrix(DSDPBlockData *ADATA, int vari)
Remove a data matrix.
int DSDPDataMatFNorm2(DSDPDataMat A, int n, double *fnorm2)
Compute the square of the Frobenius norm.
struct DSDPVec_C DSDPVec
This object hold m+2 variables: a scaling of C, the y variables, and r.
int DSDPBlockASum(DSDPBlockData *ADATA, double aa, DSDPVec Yk, DSDPVMat XX)
Sum the data matrices.
int DSDPVMatGetArray(DSDPVMat X, double **v, int *nn)
Get the array that stores the matrix.
int DSDPBlockDataMarkNonzeroMatrices(DSDPBlockData *ADATA, int *annz)
Mark which variable in block have a data matrix.
Error handling, printing, and profiling.
int DSDPBlockView(DSDPBlockData *ADATA)
Print the structure of the block.
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 DSDPDataMatGetRank(DSDPDataMat A, int *rank, int n)
Get the number of nonzero eigenvalues/eigenvectors for the matrix.
int DSDPVMatScaleDiagonal(DSDPVMat X, double dscale)
Scaling diagonal is useful for inner products and norms.
int DSDPDataMatGetEig(DSDPDataMat A, int rr, SDPConeVec V, DSDPIndex S, double *eigenvalue)
Get an eigenvalue/vector pair.
int DSDPDataMatCheck(DSDPDataMat AA, SDPConeVec W, DSDPIndex IS, DSDPVMat XX)
Check correctness of operations on the 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 DSDPDataMatGetRowNonzeros(DSDPDataMat A, int nrow, int nmax, int *nz, int *nnz)
Get sparsity pattern of a row of the matrix.
int DSDPBlockADot(DSDPBlockData *ADATA, double aa, DSDPVec Alpha, DSDPVMat X, DSDPVec AX)
Compute inner product of XX with data matrices.
int DSDPBlockCountNonzeroMatrices(DSDPBlockData *ADATA, int *nzmats)
Count how many data matrices are in a block of data.
int DSDPDataMatInitialize(DSDPDataMat *A)
Set pointers to NULL;.
int DSDPBlockTakeDownData(DSDPBlockData *ADATA)
Free structures in block of data.
Internal structure for data in one block of semidefintie.
Vector whose length corresponds to dimension of a block in a cone.
Symmetric data matrix for one block in the semidefinite cone.
int DSDPBlockView2(DSDPBlockData *ADATA)
Print the data.
int DSDPDataMatAddMultiple(DSDPDataMat A, double ytmp, double *v, int nn, int n)
Add a multiple the data matrix to the array.
int DSDPBlockFactorData(DSDPBlockData *ADATA, DSDPVMat X, SDPConeVec W)
Factor the data matrices.
Table of function pointers that operate on the data matrix.
int DSDPDataMatDestroy(DSDPDataMat *A)
Free the data structures.
int SDPConeVecDot(SDPConeVec V1, SDPConeVec V2, double *ans)
Inner product of two vectors.
int DSDPSetDataMatZero(DSDPDataMat *A)
Make a data matrix a zero matrix.
int DSDPBlockDataAllocate(DSDPBlockData *ADATA, int nnz)
Allocate some structures.
int DSDPVMatZeroEntries(DSDPVMat X)
Zero matrix.
int DSDPVMatAddOuterProduct(DSDPVMat X, double alpha, SDPConeVec V)
Add outer product of a vector to the matrix.
int DSDPBlockDataRowSparsity(DSDPBlockData *ADATA, int row, int ai[], int rnnz[], int n)
Determine sparsity pattern of data.
int DSDPBlockGetMatrix(DSDPBlockData *ADATA, int id, int *vari, double *scl, DSDPDataMat *A)
Get a data matrix from a block of data.
int DSDPDataMatVecVec(DSDPDataMat A, SDPConeVec W, double *v)
Compute w' A w.
int DSDPVMatView(DSDPVMat X)
Print matrix.
Dense symmetric matrix for one block in the semidefinite cone.
int DSDPBlockDataDestroy(DSDPBlockData *ADATA)
Free the data matrices.
int DSDPDataMatView(DSDPDataMat A)
Print matrix.
int DSDPVMatNormF2(DSDPVMat X, double *normf2)
Compute square of Frobenius norm of matrix.
int DSDPBlockDataInitialize(DSDPBlockData *ADATA)
Set pointers to null.
Internal SDPCone data structures and routines.