Main Page | Modules | Alphabetical List | Data Structures | Directories | File List | Globals | Related Pages

dsdpxmat.c

00001 #include "dsdpxmat_impl.h"
00002 #include "dsdpxmat.h"
00003 #include "dsdpsys.h"
00009 #define DSDPNoOperationError(a);  { DSDPSETERR1(1,"X Matrix type: %s, Operation not defined. Perhaps no X matrix has been set.\n",(a).dsdpops->matname); }
00010 #define DSDPChkMatError(a,b);  { if (b){ DSDPSETERR1(b,"X Matrix type: %s,\n",(a).dsdpops->matname);} }
00011 
00012 static int sdpxmatevent=0;
00013 
00014 #undef __FUNCT__
00015 #define __FUNCT__ "DSDPVMatEventZero"
00016 int DSDPVMatEventZero(void){
00017   DSDPFunctionBegin;
00018   sdpxmatevent=0;
00019   DSDPFunctionReturn(0);
00020 }
00021 
00022 #undef __FUNCT__
00023 #define __FUNCT__ "DSDPVMatEventInitialize"
00024 int DSDPVMatEventInitialize(void){
00025   DSDPFunctionBegin;
00026   if (sdpxmatevent==0){DSDPEventLogRegister("SDP X+vv'",&sdpxmatevent);}
00027   DSDPFunctionReturn(0);
00028 }
00029 
00030 #undef __FUNCT__
00031 #define __FUNCT__ "DSDPVMatSetData"
00032 
00039 int DSDPVMatSetData(DSDPVMat *X, struct DSDPVMat_Ops* ops,  void*data){
00040   int info;
00041   DSDPFunctionBegin;
00042   (*X).dsdpops=ops;
00043   (*X).matdata=data;
00044   info=DSDPVMatTest(*X);DSDPCHKERR(info);
00045   DSDPFunctionReturn(0); 
00046 }
00047 
00048 #undef __FUNCT__
00049 #define __FUNCT__ "DSDPVMatGetType"
00050 int DSDPVMatGetType(DSDPVMat X, int *id){
00051   DSDPFunctionBegin;
00052   *id=X.dsdpops->id;
00053   DSDPFunctionReturn(0); 
00054 }
00055 
00056 
00057 #undef __FUNCT__
00058 #define __FUNCT__ "DSDPVMatGetSize"
00059 
00065 int DSDPVMatGetSize(DSDPVMat X,int*n){
00066   int info;
00067   DSDPFunctionBegin;
00068   if (X.dsdpops->matgetsize){
00069     info=(X.dsdpops->matgetsize)(X.matdata,n); DSDPChkMatError(X,info);
00070   } else {
00071     /*
00072     DSDPNoOperationError(X);
00073     */
00074   }
00075   DSDPFunctionReturn(0);
00076 }
00077 
00078 
00079 #undef __FUNCT__
00080 #define __FUNCT__ "DSDPVMatDestroy"
00081 
00086 int DSDPVMatDestroy(DSDPVMat *X){
00087   int info;
00088   DSDPFunctionBegin;
00089   if (!(*X).dsdpops){ return 0;}
00090   if ((*X).dsdpops->matdestroy){
00091     info=((*X).dsdpops->matdestroy)((*X).matdata); DSDPChkMatError(*X,info);
00092   } else {
00093     /*  DSDPNoOperationError(*X); */
00094   }
00095   info=DSDPVMatInitialize(X); DSDPCHKERR(info);
00096   DSDPFunctionReturn(0);
00097 }
00098 
00099 
00100 #undef __FUNCT__
00101 #define __FUNCT__ "DSDPVMatView"
00102 
00107 int DSDPVMatView(DSDPVMat X){
00108   int info;
00109   if (X.dsdpops->matview){
00110     info=(X.dsdpops->matview)(X.matdata); DSDPChkMatError(X,info);
00111   } else {
00112     printf("No viewer available for matrix type: %d",X.dsdpops->id);
00113   }
00114   DSDPFunctionReturn(0);
00115 }
00116 
00117 
00118 #undef __FUNCT__
00119 #define __FUNCT__ "DSDPVMatZeroEntries"
00120 
00125 int DSDPVMatZeroEntries(DSDPVMat X){
00126   int info;
00127   DSDPFunctionBegin;
00128   if (X.dsdpops->matzeroentries){
00129     info=(X.dsdpops->matzeroentries)(X.matdata); DSDPChkMatError(X,info);
00130   } else {
00131     DSDPNoOperationError(X);
00132   }
00133   DSDPFunctionReturn(0);
00134 }
00135 
00136 
00137 #undef __FUNCT__
00138 #define __FUNCT__ "DSDPVMatScaleDiagonal"
00139 
00147 int DSDPVMatScaleDiagonal(DSDPVMat X, double dscale){
00148   int info;
00149   DSDPFunctionBegin;
00150   if (X.dsdpops->matscalediagonal){
00151     info=(X.dsdpops->matscalediagonal)(X.matdata,dscale); DSDPChkMatError(X,info);
00152   } else {
00153     DSDPNoOperationError(X);
00154   }
00155   DSDPFunctionReturn(0);
00156 }
00157 
00158 #undef __FUNCT__
00159 #define __FUNCT__ "DSDPVMatShiftDiagonal"
00160 
00166 int DSDPVMatShiftDiagonal(DSDPVMat X, double dadd){
00167   int info;
00168   DSDPFunctionBegin;
00169   if (X.dsdpops->matshiftdiagonal){
00170     info=(X.dsdpops->matshiftdiagonal)(X.matdata,dadd); DSDPChkMatError(X,info);
00171   } else {
00172     DSDPNoOperationError(X);
00173   }
00174   DSDPFunctionReturn(0);
00175 }
00176 
00177 
00178 #undef __FUNCT__
00179 #define __FUNCT__ "DSDPVMatNormF2"
00180 
00186 int DSDPVMatNormF2(DSDPVMat X, double*normf2){
00187   int info,n;
00188   double *dd;
00189   DSDPFunctionBegin;
00190   if (X.dsdpops->matfnorm2){
00191     info=DSDPVMatGetArray(X,&dd,&n); DSDPCHKERR(info);
00192     info=(X.dsdpops->matfnorm2)(X.matdata,n,normf2); DSDPChkMatError(X,info);
00193     info=DSDPVMatRestoreArray(X,&dd,&n); DSDPCHKERR(info);
00194   } else {
00195     DSDPNoOperationError(X);
00196   }
00197   DSDPFunctionReturn(0);
00198 }
00199 
00200 
00201 #undef __FUNCT__
00202 #define __FUNCT__ "DSDPVMatGetArray"
00203 
00211 int DSDPVMatGetArray(DSDPVMat X, double **v, int *nn){
00212   int info;
00213   DSDPFunctionBegin;
00214   if (X.dsdpops->matgeturarray){
00215     info=(X.dsdpops->matgeturarray)(X.matdata,v,nn); DSDPChkMatError(X,info);
00216   } else {
00217     *v=0;
00218     *nn=0;
00219   }
00220   DSDPFunctionReturn(0);
00221 }
00222 
00223 #undef __FUNCT__
00224 #define __FUNCT__ "DSDPVMatRestoreArray"
00225 
00233 int DSDPVMatRestoreArray(DSDPVMat X, double **v, int *nn){
00234   int info;
00235   DSDPFunctionBegin;
00236   if (X.dsdpops->matrestoreurarray){
00237     info=(X.dsdpops->matrestoreurarray)(X.matdata,v,nn); DSDPChkMatError(X,info);
00238   } else {
00239     *v=0;
00240     *nn=0;
00241   }
00242   DSDPFunctionReturn(0);
00243 }
00244 
00245 
00246 #undef __FUNCT__
00247 #define __FUNCT__ "DSDPVMatMinEigenvalue"
00248 int DSDPVMatMinEigenvalue(DSDPVMat X, SDPConeVec W1, SDPConeVec W2, double *mineig){
00249   int n,info;
00250   double *w,*iwork;
00251   DSDPFunctionBegin;
00252   if (X.dsdpops->matmineig){
00253     info=SDPConeVecGetSize(W1,&n); DSDPCHKERR(info);
00254     info=SDPConeVecGetArray(W1,&w); DSDPCHKERR(info);
00255     info=SDPConeVecGetArray(W2,&iwork); DSDPCHKERR(info);
00256     info=(X.dsdpops->matmineig)(X.matdata,w,iwork,n,mineig); DSDPChkMatError(X,info);
00257     info=SDPConeVecRestoreArray(W1,&w); DSDPCHKERR(info);
00258     info=SDPConeVecRestoreArray(W2,&iwork); DSDPCHKERR(info);
00259   } else {
00260     DSDPNoOperationError(X);
00261   }
00262   DSDPFunctionReturn(0);
00263 }
00264 
00265 
00266 #undef __FUNCT__
00267 #define __FUNCT__ "DSDPVMatAddOuterProduct"
00268 
00275 int DSDPVMatAddOuterProduct(DSDPVMat X, double alpha, SDPConeVec V){
00276   int info,n;
00277   double *v;
00278   DSDPFunctionBegin;
00279   DSDPEventLogBegin(sdpxmatevent);
00280   info=SDPConeVecGetSize(V,&n); DSDPCHKERR(info);
00281   if (X.dsdpops->mataddouterproduct){
00282     info=SDPConeVecGetArray(V,&v); DSDPCHKERR(info);
00283     info=(X.dsdpops->mataddouterproduct)(X.matdata,alpha,v,n); DSDPChkMatError(X,info);
00284     info=SDPConeVecRestoreArray(V,&v); DSDPCHKERR(info);
00285   } else {
00286     DSDPNoOperationError(X);
00287   }
00288   DSDPEventLogEnd(sdpxmatevent);
00289   DSDPFunctionReturn(0);
00290 }
00291 
00292 #undef __FUNCT__
00293 #define __FUNCT__ "DSDPVMatMult"
00294 
00301 int DSDPVMatMult(DSDPVMat X, SDPConeVec Z, SDPConeVec Y){
00302   int info,n;
00303   double *z,*y;
00304   DSDPFunctionBegin;
00305   info=SDPConeVecGetSize(Y,&n); DSDPCHKERR(info);
00306   if (X.dsdpops->matmult){
00307     info=SDPConeVecGetArray(Z,&z); DSDPCHKERR(info);
00308     info=SDPConeVecGetArray(Y,&y); DSDPCHKERR(info);
00309     info=(X.dsdpops->matmult)(X.matdata,z,y,n); DSDPChkMatError(X,info);
00310     info=SDPConeVecRestoreArray(Z,&z); DSDPCHKERR(info);
00311     info=SDPConeVecRestoreArray(Y,&y); DSDPCHKERR(info);
00312   } else {
00313     DSDPNoOperationError(X);
00314   }
00315   DSDPFunctionReturn(0);
00316 }
00317  
00318 #undef __FUNCT__
00319 #define __FUNCT__ "DSDPVMatCheck"
00320 
00327 int DSDPVMatCheck(DSDPVMat X, SDPConeVec W1, SDPConeVec W2){
00328   int info,i,n,nn;
00329   double *xx,eig,eps=1e-13,one=1.0;
00330   double fnorm0,fnorm1,fnorm2,fnorm3,fnorm4;
00331   DSDPFunctionBegin;
00332   info=DSDPVMatGetSize(X,&n);DSDPCHKERR(info);
00333   info=SDPConeVecSet(one,W1);DSDPCHKERR(info);
00334   info=DSDPVMatAddOuterProduct(X,1.23456,W1);DSDPCHKERR(info);
00335   info=DSDPVMatZeroEntries(X);DSDPCHKERR(info);
00336   info=DSDPVMatNormF2(X,&fnorm0);DSDPCHKERR(info);
00337   if (fabs(fnorm0)>eps){ printf("Check DSDPVMatZero of DSDPVMatNorm\n");}
00338   
00339   info=SDPConeVecSet(one,W1);DSDPCHKERR(info);
00340   info=DSDPVMatAddOuterProduct(X,1.0,W1);DSDPCHKERR(info);
00341   info=DSDPVMatNormF2(X,&fnorm1);DSDPCHKERR(info);
00342   if (fabs(fnorm1-n*n)>eps) printf("Check DSDPVMatZero()\n");
00343 
00344   info=DSDPVMatGetArray(X,&xx,&nn);DSDPCHKERR(info);
00345   for (i=0;i<nn;i++){xx[i]=1.0;}
00346   info=DSDPVMatRestoreArray(X,&xx,&nn);DSDPCHKERR(info);
00347   info=DSDPVMatNormF2(X,&fnorm2);DSDPCHKERR(info);
00348   if (fabs(fnorm2-n*n)>eps) printf("Check DSDPXGetArray()\n");
00349 
00350   info=DSDPVMatAddOuterProduct(X,-1.0,W1);DSDPCHKERR(info);
00351   info=DSDPVMatNormF2(X,&fnorm3);DSDPCHKERR(info);
00352 
00353   info=DSDPVMatZeroEntries(X);DSDPCHKERR(info);
00354   info=DSDPVMatAddOuterProduct(X,1.0,W1);DSDPCHKERR(info);
00355   info=DSDPVMatScaleDiagonal(X,2.0);DSDPCHKERR(info);
00356 
00357   info=DSDPVMatZeroEntries(X);DSDPCHKERR(info);
00358   info=DSDPVMatAddOuterProduct(X,1.0,W1);DSDPCHKERR(info);
00359   info=DSDPVMatShiftDiagonal(X,1.0);DSDPCHKERR(info);
00360   info=DSDPVMatNormF2(X,&fnorm4);DSDPCHKERR(info);
00361 
00362   info=DSDPVMatMult(X,W1,W2);DSDPCHKERR(info);
00363   info=DSDPVMatMinEigenvalue(X,W1,W2,&eig);DSDPCHKERR(info);
00364   if (fabs(fnorm0)>eps) printf("Check DSDPVMatZero()\n");
00365   DSDPFunctionReturn(0);
00366 }
00367 
00368 static struct  DSDPVMat_Ops dsdpmatops2;
00369 static const char *urmatname="NOT SET YET";
00370 #undef __FUNCT__
00371 #define __FUNCT__ "DSDPVMatOpsInitialize"
00372 
00377 int DSDPVMatOpsInitialize(struct  DSDPVMat_Ops*aops){
00378   aops->matgetsize=0;
00379   aops->matzeroentries=0;
00380   aops->matfnorm2=0;
00381   aops->mataddouterproduct=0;
00382   aops->matmult=0;
00383   aops->matgeturarray=0;
00384   aops->matrestoreurarray=0;
00385   aops->matview=0;
00386   aops->matdestroy=0;
00387   aops->matmineig=0;
00388   aops->matshiftdiagonal=0;
00389   aops->matscalediagonal=0;
00390   aops->id=0;
00391   aops->matname=urmatname;
00392   return 0;
00393 }
00394 
00395 #undef __FUNCT__
00396 #define __FUNCT__ "DSDPVMatTest"
00397 
00402 int DSDPVMatTest(DSDPVMat X){
00403   int info;
00404   DSDPFunctionBegin;
00405   if (X.dsdpops==0 || X.dsdpops==&dsdpmatops2){
00406   } else if (X.dsdpops->mattest){
00407     info=(X.dsdpops->mattest)(X.matdata); DSDPChkMatError(X,info);
00408   } else {
00409     /*
00410     DSDPNoOperationError(X);
00411     */
00412   }
00413   DSDPFunctionReturn(0);
00414 }
00415  
00416 
00417 #undef __FUNCT__
00418 #define __FUNCT__ "DSDPVMatInitialize"
00419 
00424 int DSDPVMatInitialize(DSDPVMat *B){
00425   int info;
00426   DSDPFunctionBegin;
00427   info=DSDPVMatOpsInitialize(&dsdpmatops2); DSDPCHKERR(info);
00428   info=DSDPVMatSetData(B, &dsdpmatops2, 0); DSDPCHKERR(info);
00429   DSDPFunctionReturn(0);
00430 }
00431 
00432 #undef __FUNCT__
00433 #define __FUNCT__ "DSDPVMatExist"
00434 
00440 int DSDPVMatExist(DSDPVMat X,int *flag){
00441   DSDPFunctionBegin;
00442   if (X.dsdpops && X.dsdpops!=&dsdpmatops2) *flag=1;
00443   else *flag=0;
00444   DSDPFunctionReturn(0);
00445 }
00446 

Generated on Sat Oct 15 11:05:37 2005 for DSDP by  doxygen 1.4.2