dsdpadddata.c

Go to the documentation of this file.
00001 #include "dsdpsdp.h"
00002 #include "dsdpsys.h"
00007 #undef __FUNCT__  
00008 #define __FUNCT__ "SDPConeCheckI"
00009 
00015 int SDPConeCheckI(SDPCone sdpcone,int vari){
00016   DSDPFunctionBegin;
00017   SDPConeValid(sdpcone);
00018   if (vari<0 || vari>sdpcone->m) {
00019     DSDPSETERR2(1,"Bad Data Matrix: variable: %d (Max: %d)\n",vari,sdpcone->m+1);}
00020   DSDPFunctionReturn(0);
00021 }
00022 
00023 #undef __FUNCT__  
00024 #define __FUNCT__ "SDPConeCheckJ"
00025 
00031 int SDPConeCheckJ(SDPCone sdpcone,int blockj){
00032   DSDPFunctionBegin;
00033   SDPConeValid(sdpcone);
00034   if (blockj<0 || blockj>= sdpcone->nblocks) {
00035     DSDPSETERR2(2,"Bad Data Matrix: Block: %d (Max: %d)\n",blockj,sdpcone->nblocks-1);}
00036   DSDPFunctionReturn(0);
00037 }
00038 
00039 #undef __FUNCT__  
00040 #define __FUNCT__ "SDPConeCheckN"
00041 
00048 int SDPConeCheckN(SDPCone sdpcone,int blockj, int n){
00049   int info;
00050   DSDPFunctionBegin;
00051   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00052   if (sdpcone->blk[blockj].n==0 && n>0){info=SDPConeSetBlockSize(sdpcone,blockj,n);DSDPCHKERR(info);}
00053   if (sdpcone->blk[blockj].n != n){
00054     DSDPSETERR3(3,"Check Dimension of Data Matrix: Block: %d, %d -- expecting %d\n",
00055                 blockj,n,sdpcone->blk[blockj].n);
00056   }
00057   DSDPFunctionReturn(0);
00058 }
00059 
00060 #undef __FUNCT__  
00061 #define __FUNCT__ "SDPConeCheckM"
00062 
00068 int SDPConeCheckM(SDPCone sdpcone,int m){
00069   DSDPFunctionBegin;
00070   SDPConeValid(sdpcone);
00071   if (m!=sdpcone->m){
00072     DSDPSETERR1(4,"Check dimension of array. This problem has %d variables\n",sdpcone->m);}
00073   DSDPFunctionReturn(0);
00074 }
00075 
00076 #undef __FUNCT__  
00077 #define __FUNCT__ "SDPConeValidStorageFormat"
00078 
00084 int SDPConeValidStorageFormat(SDPCone sdpcone, char format){
00085   DSDPFunctionBegin;
00086   if (format!='P' && format != 'U'){
00087     DSDPSETERR1(4,"Check format of Block: %c is not supported! Use P or U. \n",format);
00088   }
00089   DSDPFunctionReturn(0);
00090 }
00091 
00092 #undef __FUNCT__  
00093 #define __FUNCT__ "SDPConeCheckStorageFormat"
00094 
00101 int SDPConeCheckStorageFormat(SDPCone sdpcone,int blockj, char format){
00102   int info;
00103   DSDPFunctionBegin;
00104   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00105   info=SDPConeValidStorageFormat(sdpcone,format);DSDPCHKERR(info);
00106   if (sdpcone->blk[blockj].format=='N'){
00107     sdpcone->blk[blockj].format = format;
00108   }
00109   if (sdpcone->blk[blockj].format != format){
00110     DSDPSETERR3(4,"Check format of Data Matrix: Block: %d, %c -- expecting %c\n",
00111                 blockj,format,sdpcone->blk[blockj].format);
00112   }
00113   DSDPFunctionReturn(0);
00114 }
00115 
00116 #undef __FUNCT__  
00117 #define __FUNCT__ "SDPConeRemoveDataMatrix"
00118 
00127 int SDPConeRemoveDataMatrix(SDPCone sdpcone,int blockj, int vari){
00128   int info;
00129   DSDPFunctionBegin;
00130   info=SDPConeCheckI(sdpcone,vari);DSDPCHKERR(info);
00131   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00132   info=DSDPBlockRemoveDataMatrix(&sdpcone->blk[blockj].ADATA,vari);DSDPCHKERR(info);
00133   DSDPFunctionReturn(0);
00134 }
00135   
00136 #undef __FUNCT__  
00137 #define __FUNCT__ "SDPConeAddDataMatrix"
00138 
00154 int SDPConeAddDataMatrix(SDPCone sdpcone,int blockj, int vari, int n, char format, struct DSDPDataMat_Ops* dsdpdataops, void* data){ 
00155   int info;
00156   DSDPFunctionBegin;
00157   info=SDPConeCheckI(sdpcone,vari);DSDPCHKERR(info);
00158   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00159   info=SDPConeCheckN(sdpcone,blockj,n);DSDPCHKERR(info);
00160   info=SDPConeCheckStorageFormat(sdpcone,blockj,format);DSDPCHKERR(info);
00161   info=DSDPBlockAddDataMatrix(&sdpcone->blk[blockj].ADATA,vari,dsdpdataops,data);DSDPCHKERR(info);
00162   DSDPFunctionReturn(0);
00163 }
00164 
00165 #undef __FUNCT__  
00166 #define __FUNCT__ "SDPConeSetRMatrix"
00167 
00181 int SDPConeSetRMatrix(SDPCone sdpcone,int blockj, int n, char format, struct DSDPDataMat_Ops* dsdpdataops, void* data){ 
00182   int info;
00183   int vari=sdpcone->m+1;
00184   DSDPFunctionBegin;
00185   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00186   info=SDPConeCheckN(sdpcone,blockj,n);DSDPCHKERR(info);
00187   info=SDPConeCheckStorageFormat(sdpcone,blockj,format);DSDPCHKERR(info);
00188   info=DSDPBlockRemoveDataMatrix(&sdpcone->blk[blockj].ADATA,vari);DSDPCHKERR(info);
00189   info=DSDPBlockSetDataMatrix(&sdpcone->blk[blockj].ADATA,vari,dsdpdataops,data);DSDPCHKERR(info);
00190   DSDPFunctionReturn(0);
00191 }
00192 
00193 
00194 #undef __FUNCT__
00195 #define __FUNCT__ "SDPConeViewDataMatrix"
00196 
00205 int SDPConeViewDataMatrix(SDPCone sdpcone,int blockj, int vari){ 
00206   int info,ii,vari2,nnzmats;
00207   DSDPDataMat AA;
00208   DSDPFunctionBegin;
00209   info=SDPConeCheckI(sdpcone,vari);DSDPCHKERR(info);
00210   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00211   info=DSDPBlockCountNonzeroMatrices(&sdpcone->blk[blockj].ADATA,&nnzmats);DSDPCHKERR(info);
00212   for (ii=0;ii<nnzmats; ii++){  /* Matrix Entries */
00213     info=DSDPBlockGetMatrix(&sdpcone->blk[blockj].ADATA,ii,&vari2,0,&AA);DSDPCHKVARERR(vari,info);
00214     if (vari2==vari){ info = DSDPDataMatView(AA);DSDPCHKERR(info);}
00215   }
00216   DSDPFunctionReturn(0);
00217 }
00218 
00219 #undef __FUNCT__  
00220 #define __FUNCT__ "SDPConeClearVMatrix"
00221 
00228 int SDPConeClearVMatrix(SDPCone sdpcone,int blockj, int n){
00229   int info;
00230   DSDPFunctionBegin;
00231   SDPConeValid(sdpcone);
00232   info=DSDPVMatDestroy(&sdpcone->blk[blockj].T);DSDPCHKERR(info);
00233   info=DSDPVMatInitialize(&sdpcone->blk[blockj].T);DSDPCHKERR(info);
00234   DSDPFunctionReturn(0);
00235 }
00236 
00237 
00238 #undef __FUNCT__  
00239 #define __FUNCT__ "SDPConeSetXMat"
00240 
00247 int SDPConeSetXMat(SDPCone sdpcone,int blockj, int n){ 
00248   int info;
00249   char UPLQ;
00250   DSDPVMat T;
00251 
00252   DSDPFunctionBegin;
00253   SDPConeValid(sdpcone);
00254   info=SDPConeClearVMatrix(sdpcone,blockj,n);DSDPCHKERR(info);
00255   DSDPLogInfo(0,10,"Create block X Mat:  Block: %d, size: %d.\n",blockj,n);
00256   info=SDPConeGetStorageFormat(sdpcone,blockj,&UPLQ); DSDPCHKERR(info);
00257   info=DSDPMakeVMat(UPLQ,n,&T);DSDPCHKERR(info);
00258   sdpcone->blk[blockj].T=T;
00259   DSDPFunctionReturn(0);
00260 }
00261 
00262 #undef __FUNCT__  
00263 #define __FUNCT__ "SDPConeSetXArray"
00264 
00278 int SDPConeSetXArray(SDPCone sdpcone,int blockj, int n, double xx[], int nn){ 
00279   int info;
00280   char UPLQ;
00281   DSDPVMat T;
00282   DSDPFunctionBegin;
00283   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00284   info=SDPConeCheckN(sdpcone,blockj,n);DSDPCHKERR(info);
00285   info=SDPConeClearVMatrix(sdpcone,blockj,n);DSDPCHKERR(info);
00286   DSDPLogInfo(0,10,"Set block X array:  Block: %d, size: %d.\n",blockj,n);
00287   info=SDPConeGetStorageFormat(sdpcone,blockj,&UPLQ); DSDPCHKERR(info);
00288   info=DSDPMakeVMatWithArray(UPLQ,xx,nn,n,&T);DSDPCHKERR(info);
00289   sdpcone->blk[blockj].T=T;
00290   DSDPFunctionReturn(0);
00291 }
00292 
00293 #undef __FUNCT__  
00294 #define __FUNCT__ "SDPConeGetXArray"
00295 
00328 int SDPConeGetXArray(SDPCone sdpcone,int blockj, double* xx[], int *nn){ 
00329   int info,flag;
00330   DSDPFunctionBegin;
00331   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00332   info=DSDPVMatExist(sdpcone->blk[blockj].T,&flag);DSDPCHKERR(info);
00333   if (flag==0){
00334     DSDPSETERR(6,"No X Array available, Call DSDPSetup() or SDPConeSetXArray.\n");}
00335   info=DSDPVMatGetArray(sdpcone->blk[blockj].T,xx,nn);DSDPCHKERR(info); 
00336   DSDPFunctionReturn(0);
00337 }
00338 
00339 #undef __FUNCT__  
00340 #define __FUNCT__ "SDPConeRestoreXArray"
00341 
00351 int SDPConeRestoreXArray(SDPCone sdpcone,int blockj, double* xx[], int *nn){ 
00352   int info,flag;
00353   DSDPFunctionBegin;
00354   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00355   info=DSDPVMatExist(sdpcone->blk[blockj].T,&flag);DSDPCHKERR(info);
00356   if (flag==0){
00357     DSDPSETERR(6,"No X Array available, Call DSDPSetup() or SDPConeSetXArray.\n");}
00358   info=DSDPVMatRestoreArray(sdpcone->blk[blockj].T,xx,nn);DSDPCHKERR(info); 
00359   DSDPFunctionReturn(0);
00360 }
00361 
00362 #undef __FUNCT__
00363 #define __FUNCT__ "SDPConeMatrixView"
00364 
00372 int SDPConeMatrixView(SDPCone sdpcone, int blockj){
00373   int info;
00374   DSDPFunctionBegin;
00375   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00376   info=DSDPVMatView(sdpcone->blk[blockj].T);DSDPCHKERR(info);
00377   DSDPFunctionReturn(0); 
00378 }
00379 
00380 #undef __FUNCT__
00381 #define __FUNCT__ "SDPConeUseFullSymmetricFormat"
00382 
00414 int SDPConeUseFullSymmetricFormat(SDPCone sdpcone, int blockj){
00415   int info;
00416   DSDPFunctionBegin;
00417   info=SDPConeSetStorageFormat(sdpcone,blockj,'U');DSDPCHKERR(info);
00418   DSDPFunctionReturn(0); 
00419 }
00420 
00421 #undef __FUNCT__
00422 #define __FUNCT__ "SDPConeUsePackedFormat"
00423 
00452 int SDPConeUsePackedFormat(SDPCone sdpcone, int blockj){
00453   int info;
00454   DSDPFunctionBegin;
00455   info=SDPConeSetStorageFormat(sdpcone,blockj,'P');DSDPCHKERR(info);
00456   DSDPFunctionReturn(0); 
00457 }
00458 
00459 #undef __FUNCT__
00460 #define __FUNCT__ "SDPConeSetStorageFormat"
00461 
00479 int SDPConeSetStorageFormat(SDPCone sdpcone, int blockj, char format){
00480   int info;
00481   DSDPFunctionBegin;
00482   info=SDPConeValidStorageFormat(sdpcone,format);DSDPCHKERR(info);
00483   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00484   sdpcone->blk[blockj].format=format;
00485   DSDPFunctionReturn(0); 
00486 }
00487 
00488 #undef __FUNCT__
00489 #define __FUNCT__ "SDPConeGetStorageFormat"
00490 
00505 int SDPConeGetStorageFormat(SDPCone sdpcone, int blockj, char *format){
00506   int info;
00507   DSDPFunctionBegin;
00508   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00509   *format=sdpcone->blk[blockj].format;
00510   if (*format=='N') *format='P';
00511   DSDPFunctionReturn(0); 
00512 }
00513 
00514 #undef __FUNCT__  
00515 #define __FUNCT__ "SDPConeScaleBarrier"
00516 int SDPConeScaleBarrier(SDPCone sdpcone,int blockj, double ggamma){ 
00517   int info;
00518   DSDPFunctionBegin;
00519   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00520   sdpcone->blk[blockj].gammamu=ggamma;
00521   DSDPFunctionReturn(0);
00522 }
00523 
00524 #undef __FUNCT__  
00525 #define __FUNCT__ "SDPConeSetBlockSize"
00526 
00535 int SDPConeSetBlockSize(SDPCone sdpcone, int blockj, int n){
00536   int info,n0;
00537   DSDPFunctionBegin;
00538   DSDPLogInfo(0,10,"Set block size:  Block: %d, size: %d.\n",blockj,n);
00539   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00540   n0=sdpcone->blk[blockj].n;
00541   if (n0==n){DSDPFunctionReturn(0);}
00542   if (n0!=0 &&n0!=n){
00543     DSDPSETERR2(5,"Block %d Size previously set to %d \n",blockj,n0);  } 
00544   sdpcone->blk[blockj].n=n;
00545   sdpcone->nn+=n-n0;
00546   DSDPFunctionReturn(0);
00547 }
00548 
00549 #undef __FUNCT__  
00550 #define __FUNCT__ "SDPConeGetBlockSize"
00551 
00560 int SDPConeGetBlockSize(SDPCone sdpcone, int blockj, int *n){
00561   int info;
00562   DSDPFunctionBegin;
00563   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00564   *n=sdpcone->blk[blockj].n;
00565   DSDPFunctionReturn(0);
00566 }
00567 
00576 #undef __FUNCT__  
00577 #define __FUNCT__ "SDPConeGetNumberOfBlocks"
00578 int SDPConeGetNumberOfBlocks(SDPCone sdpcone, int *nblocks){
00579   DSDPFunctionBegin;
00580   SDPConeValid(sdpcone);
00581   *nblocks=sdpcone->nblocks;
00582   DSDPFunctionReturn(0);
00583 }
00584 
00585 #undef __FUNCT__  
00586 #define __FUNCT__ "SDPConeSetSparsity"
00587 
00596 int SDPConeSetSparsity(SDPCone sdpcone, int blockj, int nnz){
00597   int info;
00598   DSDPFunctionBegin;
00599   DSDPLogInfo(0,10,"Set block nonzeros:  Block: %d, Nonzero Matrices: %d.\n",blockj,nnz);
00600   info=SDPConeCheckJ(sdpcone,blockj);DSDPCHKERR(info);
00601   if (nnz>sdpcone->m) nnz=sdpcone->m;
00602   info=DSDPBlockDataAllocate(&sdpcone->blk[blockj].ADATA,nnz+2); DSDPCHKERR(info);
00603   DSDPFunctionReturn(0);
00604 }
00605 
00606 
00607 #undef __FUNCT__  
00608 #define __FUNCT__ "SDPConeView"
00609 
00617 int SDPConeView(SDPCone sdpcone){  
00618   int blockj,info;
00619   DSDPFunctionBegin;
00620   for (blockj=0; blockj<sdpcone->nblocks; blockj++){
00621     printf("Block: %d, Dimension: %d\n",blockj,sdpcone->blk[blockj].n);
00622     info=DSDPBlockView(&sdpcone->blk[blockj].ADATA);DSDPCHKERR(info);
00623   }
00624   DSDPFunctionReturn(0);
00625 }
00626 
00627 #undef __FUNCT__  
00628 #define __FUNCT__ "SDPConeView2"
00629 
00637 int SDPConeView2(SDPCone sdpcone){  
00638   int blockj,info;
00639   DSDPFunctionBegin;
00640   for (blockj=0; blockj<sdpcone->nblocks; blockj++){
00641     printf("Block: %d, Dimension: %d\n",blockj,sdpcone->blk[blockj].n);
00642     info=DSDPBlockView2(&sdpcone->blk[blockj].ADATA);DSDPCHKERR(info);
00643   }
00644   DSDPFunctionReturn(0);
00645 }
00646 
00647 #undef __FUNCT__  
00648 #define __FUNCT__ "SDPConeView3"
00649 
00657 int SDPConeView3(SDPCone sdpcone){  
00658   int blockj,id,n,info,nnzmats;
00659   DSDPFunctionBegin;
00660   for (blockj=0; blockj<sdpcone->nblocks; blockj++){
00661     n=sdpcone->blk[blockj].n;
00662     printf("Block: %d \n",blockj);
00663     printf(" Dimension: %d\n",n);
00664     info=DSDPDSMatGetType(sdpcone->blk[blockj].DS,&id);
00665     if (id==1){
00666       printf(" DS Matrix Type: Dense, Using LAPACK\n");
00667     } else {
00668       printf(" DS Matrix Type: %d\n",id);
00669     }
00670     info=DSDPDualMatGetType(sdpcone->blk[blockj].S,&id);
00671     if (id==1){
00672       printf(" Dual Matrix Type: Dense, Using LAPACK\n");
00673     } else {
00674       printf(" Dual Matrix Type: %d\n",id);
00675     }
00676     info=DSDPBlockCountNonzeroMatrices(&sdpcone->blk[blockj].ADATA,&nnzmats);DSDPCHKERR(info);
00677     printf(" Number of Data Matrices: %d of %d\n",nnzmats-1,sdpcone->m+1);
00678     printf(" Number of Data Nonzeros: %d\n",sdpcone->blk[blockj].nnz);
00679   }
00680   DSDPFunctionReturn(0);
00681 }
00682 
00683 
00684 #undef __FUNCT__  
00685 #define __FUNCT__ "SDPConeCheckData"
00686 
00692 int SDPConeCheckData(SDPCone sdpcone){  
00693   int i,ii,blockj,nnzmats,info;
00694   double scl=0;
00695   DSDPDataMat AA;
00696   DSDPIndex IS;
00697   DSDPVMat T;
00698   DSDPDSMat DS;
00699   DSDPDualMat S1,S2;
00700   SDPConeVec W,W2;
00701   DSDPFunctionBegin;
00702   for (blockj=0; blockj<sdpcone->nblocks; blockj++){
00703     T=sdpcone->blk[blockj].T;DS=sdpcone->blk[blockj].DS;
00704     W=sdpcone->blk[blockj].W;W2=sdpcone->blk[blockj].W2;
00705     S1=sdpcone->blk[blockj].S;S2=sdpcone->blk[blockj].SS;
00706     IS=sdpcone->blk[blockj].IS;
00707     printf("Block: %d\n",blockj);
00708     info=DSDPVMatCheck(T,W,W2);DSDPCHKERR(info);
00709     info=DSDPDSMatCheck(DS,W,W2,T);DSDPCHKERR(info);
00710     info=DSDPDualMatCheck(S1,W,W2,IS,T);DSDPCHKERR(info);
00711     info=DSDPDualMatCheck(S2,W,W2,IS,T);DSDPCHKERR(info);
00712 
00713     info=DSDPBlockCountNonzeroMatrices(&sdpcone->blk[blockj].ADATA,&nnzmats);DSDPCHKERR(info);
00714     for (ii=0;ii<nnzmats;ii++){
00715       info=DSDPBlockGetMatrix(&sdpcone->blk[blockj].ADATA,ii,&i,&scl,&AA);DSDPCHKERR(info);
00716       if (i==0) continue;
00717       printf(" Variable: %d, \n",i);
00718       info=DSDPDataMatCheck(AA,W,IS,T);DSDPCHKERR(info);
00719     }
00720   }
00721   DSDPFunctionReturn(0);
00722 }

Generated on Wed May 21 19:31:18 2008 for DSDP by  doxygen 1.5.5