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

dsdpschurmat.c

00001 #include "dsdpschurmat_impl.h"
00002 #include "dsdpschurmat.h"
00003 #include "dsdpbasictypes.h"
00004 #include "dsdpsys.h"
00005 
00012 static int hfactorevent=0,hsolveevent=0;
00013 
00014 #define DSDPNoOperationError(a);  { DSDPSETERR1(10,"Schur matrix type: %s, Operation not defined\n",(a).dsdpops->matname); }
00015 #define DSDPChkMatError(a,b);  { if (b){ DSDPSETERR1(b,"Schur matrix type: %s,\n",(a).dsdpops->matname);} }
00016 
00017 static int DSDPApplySMW(DSDPSchurMat, DSDPVec, DSDPVec);
00018 static int DSDPSchurMatSolveM(DSDPSchurMat, DSDPVec, DSDPVec);
00019 
00020 #undef __FUNCT__
00021 #define __FUNCT__ "DSDPSchurMatSetData"
00022 
00029 int DSDPSchurMatSetData(DSDPSchurMat *M, struct DSDPSchurMat_Ops* ops,  void*data){
00030   DSDPFunctionBegin;
00031   (*M).dsdpops=ops;
00032   (*M).data=data;
00033   DSDPFunctionReturn(0); 
00034 }
00035 
00036 static const char* schurmatname="NOT NAMED YET";
00037 
00038 #undef __FUNCT__
00039 #define __FUNCT__ "DSDPSchurMatOpsInitialize"
00040 
00045 int DSDPSchurMatOpsInitialize(struct  DSDPSchurMat_Ops* dops){
00046   DSDPFunctionBegin;
00047   if (dops==NULL) return 0;
00048   dops->matzero=0;
00049   dops->matrownonzeros=0;
00050   dops->mataddrow=0;
00051   dops->mataddelement=0;
00052   dops->matadddiagonal=0;
00053   dops->matshiftdiagonal=0;
00054   dops->matassemble=0;
00055   dops->matscaledmultiply=0;
00056   dops->matmultr=0;
00057   dops->matfactor=0;
00058   dops->matsolve=0;
00059   dops->pmatonprocessor=0;
00060   dops->pmatwhichdiag=0;
00061   dops->pmatdistributed=0;
00062   dops->matdestroy=0;
00063   dops->matview=0; 
00064   dops->matsetup=0;
00065   dops->id=0;
00066   dops->matname=schurmatname;
00067   DSDPFunctionReturn(0); 
00068 }
00069 
00070 static struct  DSDPSchurMat_Ops dsdpmops;
00071 
00072 
00073 #undef __FUNCT__
00074 #define __FUNCT__ "DSDPSchurMatOpsInitialize"
00075 
00080 int DSDPSchurMatInitialize(DSDPSchurMat *M){
00081   int info;
00082   DSDPFunctionBegin;
00083   info=DSDPSchurMatOpsInitialize(&dsdpmops); DSDPCHKERR(info);
00084   info=DSDPSchurMatSetData(M,&dsdpmops,0); DSDPCHKERR(info);
00085   DSDPCALLOC1(&M->schur,DSDPSchurInfo,&info);DSDPCHKERR(info);
00086   M->schur->m=0;  M->schur->r=0;  M->schur->dd=0;
00087   info=DSDPInitializeFixedVariable(&M->schur->fv);DSDPCHKERR(info);
00088   DSDPFunctionReturn(0); 
00089 }
00090 
00091 #undef __FUNCT__
00092 #define __FUNCT__ "DSDPSchurMatZeroEntries"
00093 
00098 int DSDPSchurMatZeroEntries(DSDPSchurMat M){
00099   int info;
00100   DSDPFunctionBegin;
00101   if (M.dsdpops->matzero){
00102     info=(M.dsdpops->matzero)(M.data); DSDPChkMatError(M,info);
00103   } else {
00104     DSDPNoOperationError(M);
00105   }
00106   DSDPFunctionReturn(0);
00107 }
00108 
00109 
00110 #undef __FUNCT__
00111 #define __FUNCT__ "DSDPSchurMatShiftDiagonal"
00112 
00121 int DSDPSchurMatShiftDiagonal(DSDPSchurMat M, double dd){
00122   int info;
00123   DSDPFunctionBegin;
00124   if (dd==0){DSDPFunctionReturn(0);}
00125   M.schur->dd=dd;
00126   if (M.dsdpops->matshiftdiagonal){
00127     /* if(M.schur->r){info=DSDPVecAddR(M.schur->rhs3,dd);DSDPCHKERR(info);} */
00128     info=(M.dsdpops->matshiftdiagonal)(M.data,dd); DSDPChkMatError(M,info);
00129     DSDPLogInfo(0,2,"Add %4.4e to the Diagonal of Schur Matrix\n",dd);
00130   } else {
00131     DSDPNoOperationError(M);
00132   }
00133   DSDPFunctionReturn(0);
00134 }
00135 
00136 
00137 #undef __FUNCT__
00138 #define __FUNCT__ "DSDPSchurMatInParallel"
00139 
00150 int DSDPSchurMatInParallel(DSDPSchurMat M, DSDPTruth *flag){
00151   int info,flg;
00152   DSDPFunctionBegin;
00153   if (M.dsdpops->pmatdistributed){
00154     info=(M.dsdpops->pmatdistributed)(M.data,&flg); DSDPChkMatError(M,info);
00155     if (flg) *flag=DSDP_TRUE; else *flag=DSDP_FALSE;
00156   } else {
00157     *flag=DSDP_FALSE;
00158   }
00159   DSDPFunctionReturn(0);
00160 }
00161 
00162 
00163 
00164 #undef __FUNCT__
00165 #define __FUNCT__ "DSDPSchurMatAssemble"
00166 
00175 int DSDPSchurMatAssemble(DSDPSchurMat M){
00176   int info;
00177   DSDPFunctionBegin;
00178   if (M.dsdpops->matassemble){
00179     info=(M.dsdpops->matassemble)(M.data); DSDPChkMatError(M,info);
00180   } else {
00181     DSDPNoOperationError(M);
00182   }
00183   DSDPFunctionReturn(0);
00184 }
00185 
00186 #undef __FUNCT__
00187 #define __FUNCT__ "DSDPSchurMatFactor"
00188 
00197 int DSDPSchurMatFactor(DSDPSchurMat M, DSDPTruth *successful){
00198   int info,flag=0;
00199   DSDPVec rhs3=M.schur->rhs3,dy3=M.schur->dy3;
00200   DSDPFunctionBegin;
00201   *successful=DSDP_TRUE;
00202   DSDPEventLogBegin(hfactorevent);
00203   if (M.dsdpops->matfactor){
00204     info=(M.dsdpops->matfactor)(M.data,&flag); DSDPChkMatError(M,info);
00205     if (flag){ 
00206       *successful=DSDP_FALSE;
00207       DSDPLogInfo(0,2,"Indefinite Schur Matrix -- Bad Factorization\n");
00208     }
00209   } else {
00210     DSDPNoOperationError(M);
00211   }
00212   DSDPEventLogEnd(hfactorevent);
00213   if (M.schur->r){
00214     info=DSDPSchurMatSolveM(M,rhs3,dy3);DSDPCHKERR(info);}
00215   else {info=DSDPVecZero(dy3);DSDPCHKERR(info);}
00216   DSDPFunctionReturn(0);
00217 }
00218 
00219 
00220 #undef __FUNCT__
00221 #define __FUNCT__ "DSDPSchurMatMultiply"
00222 
00232 int DSDPSchurMatMultiply(DSDPSchurMat M, DSDPVec x, DSDPVec y){
00233   int info,n;
00234   double *xx,*yy,r=M.schur->r;
00235   double r1,r2,dd;
00236   DSDPVec rhs3;
00237   DSDPFunctionBegin;
00238 
00239   if (M.dsdpops->matscaledmultiply){
00240     info=DSDPVecGetSize(x,&n); DSDPCHKERR(info);
00241     info=DSDPVecGetArray(x,&xx); DSDPCHKERR(info);
00242     info=DSDPVecGetArray(y,&yy); DSDPCHKERR(info);
00243     info=(M.dsdpops->matscaledmultiply)(M.data,xx+1,yy+1,n-2); DSDPChkMatError(M,info);
00244     yy[0]=0;
00245     yy[n-1]=0;
00246     info=DSDPVecRestoreArray(y,&yy); DSDPCHKERR(info);
00247     info=DSDPVecRestoreArray(x,&xx); DSDPCHKERR(info);
00248   } else {
00249     DSDPNoOperationError(M);
00250   }
00251   if (r){
00252     rhs3=M.schur->rhs3;
00253     info=DSDPVecGetR(rhs3,&r2);DSDPCHKERR(info);
00254     info=DSDPVecGetR(x,&r1);DSDPCHKERR(info);
00255     info=DSDPVecAXPY(r1,rhs3,y);DSDPCHKERR(info);
00256     info=DSDPVecDot(rhs3,x,&dd);DSDPCHKERR(info);
00257     info=DSDPVecAddR(y,dd-r1*r2);DSDPCHKERR(info);
00258   }
00259   DSDPFunctionReturn(0);
00260 }
00261 
00262 #undef __FUNCT__
00263 #define __FUNCT__ "DSDPSchurMatMultR"
00264 int DSDPSchurMatMultR(DSDPSchurMat M, DSDPVec x, DSDPVec y){
00265   int info,n;
00266   double *xx,*yy,r=M.schur->r;
00267   double r1,r2,dd;
00268   DSDPVec rhs3;
00269   DSDPFunctionBegin;
00270 
00271   if (M.dsdpops->matmultr){
00272     info=DSDPVecGetSize(x,&n); DSDPCHKERR(info);
00273     info=DSDPVecGetArray(x,&xx); DSDPCHKERR(info);
00274     info=DSDPVecGetArray(y,&yy); DSDPCHKERR(info);
00275     info=(M.dsdpops->matmultr)(M.data,xx+1,yy+1,n-2); DSDPChkMatError(M,info);
00276     yy[0]=0;
00277     yy[n-1]=0;
00278     info=DSDPVecRestoreArray(y,&yy); DSDPCHKERR(info);
00279     info=DSDPVecRestoreArray(x,&xx); DSDPCHKERR(info);
00280     if (r){
00281       rhs3=M.schur->rhs3;
00282       info=DSDPVecGetR(rhs3,&r2);DSDPCHKERR(info);
00283       info=DSDPVecGetR(x,&r1);DSDPCHKERR(info);
00284       info=DSDPVecAXPY(r1,rhs3,y);DSDPCHKERR(info);
00285       info=DSDPVecDot(rhs3,x,&dd);DSDPCHKERR(info);
00286       info=DSDPVecAddR(y,dd-r1*r2);DSDPCHKERR(info);
00287     }
00288   } else {
00289     info=DSDPVecZero(y);DSDPCHKERR(info);
00290     /*    DSDPNoOperationError(M); */
00291   }
00292   DSDPFunctionReturn(0);
00293 }
00294 
00295 #undef __FUNCT__
00296 #define __FUNCT__ "DSDPSchurMatReducePVec"
00297 
00308 int DSDPSchurMatReducePVec(DSDPSchurMat M, DSDPVec x){
00309   int info,n;
00310   double *xx;
00311   DSDPTruth flag;
00312   DSDPFunctionBegin;
00313 
00314   if (M.dsdpops->pmatreduction){
00315     info=DSDPVecGetSize(x,&n); DSDPCHKERR(info);
00316     info=DSDPVecGetArray(x,&xx); DSDPCHKERR(info);
00317     info=(M.dsdpops->pmatreduction)(M.data,xx+1,n-2); DSDPChkMatError(M,info);
00318     info=DSDPVecRestoreArray(x,&xx); DSDPCHKERR(info);
00319   } else {
00320     info=DSDPSchurMatInParallel(M,&flag);DSDPChkMatError(M,info);
00321     if (flag==DSDP_TRUE){
00322       DSDPNoOperationError(M);
00323     }
00324   }
00325   info=DSDPZeroFixedVariables(M,x);DSDPCHKERR(info);
00326   DSDPFunctionReturn(0);
00327 }
00328 
00329 
00330 
00331 #undef __FUNCT__
00332 #define __FUNCT__ "DSDPSchurMatSetR"
00333 
00339 int DSDPSchurMatSetR(DSDPSchurMat M, double rr){
00340   DSDPFunctionBegin;
00341   M.schur->r=rr;
00342   DSDPFunctionReturn(0);
00343 }
00344 
00345 #undef __FUNCT__
00346 #define __FUNCT__ "DSDPSchurMatSetup"
00347 
00353 int DSDPSchurMatSetup(DSDPSchurMat M, DSDPVec Y){
00354   int info,m;
00355   DSDPFunctionBegin;
00356   info=DSDPVecDuplicate(Y,&M.schur->rhs3);
00357   info=DSDPVecDuplicate(Y,&M.schur->dy3);
00358   info=DSDPVecGetSize(Y,&m);DSDPCHKERR(info);
00359   if (M.dsdpops->matsetup){
00360     info=(M.dsdpops->matsetup)(M.data,m-2); DSDPChkMatError(M,info);
00361   } else {
00362     DSDPNoOperationError(M);
00363   }
00364   DSDPEventLogRegister("Factor Newton Eq.",&hfactorevent);
00365   DSDPEventLogRegister("Solve Newton Eq.",&hsolveevent);
00366   DSDPFunctionReturn(0);
00367 }
00368 
00369 
00370 #undef __FUNCT__
00371 #define __FUNCT__ "DSDPSchurMatView"
00372 
00377 int DSDPSchurMatView(DSDPSchurMat M){
00378   int info;
00379   DSDPFunctionBegin;
00380   if (M.dsdpops->matview){
00381     info=(M.dsdpops->matview)(M.data); DSDPChkMatError(M,info);
00382   } else {
00383     DSDPNoOperationError(M);
00384   }
00385   info=DSDPVecView(M.schur->rhs3);DSDPCHKERR(info);
00386   DSDPFunctionReturn(0);
00387 }
00388 
00389 
00390 #undef __FUNCT__
00391 #define __FUNCT__ "DSDPSchurMatRowScaling"
00392 
00400 int DSDPSchurMatRowScaling(DSDPSchurMat M, DSDPVec D){
00401   int info;
00402   DSDPFunctionBegin;
00403   info=DSDPSchurMatDiagonalScaling(M,D);DSDPCHKERR(info);
00404   info=DSDPZeroFixedVariables(M,D);DSDPCHKERR(info);
00405   DSDPFunctionReturn(0);
00406 }
00407 
00408 #undef __FUNCT__
00409 #define __FUNCT__ "DSDPSchurMatDestroy"
00410 
00415 int DSDPSchurMatDestroy(DSDPSchurMat *M){
00416   int info;
00417   DSDPFunctionBegin;
00418   if ((*M).dsdpops->matdestroy){
00419     info=((*M).dsdpops->matdestroy)((*M).data); DSDPChkMatError(*M,info);
00420   } else {
00421     /*
00422     DSDPNoOperationError(*M);
00423     */
00424   }
00425   info=DSDPVecDestroy(&M->schur->rhs3);DSDPCHKERR(info);
00426   info=DSDPVecDestroy(&M->schur->dy3);DSDPCHKERR(info);
00427   /*  info=DSDPSchurMatSetData(M,0,0); DSDPCHKERR(info); */
00428   info=DSDPSchurMatOpsInitialize(&dsdpmops); DSDPCHKERR(info);
00429   info=DSDPSchurMatSetData(M,&dsdpmops,0); DSDPCHKERR(info);
00430   DSDPFREE(&M->schur,&info);DSDPCHKERR(info);
00431   DSDPFunctionReturn(0);
00432 }
00433 
00434 #undef __FUNCT__
00435 #define __FUNCT__ "DSDPSchurMatSolveM"
00436 static int DSDPSchurMatSolveM(DSDPSchurMat M, DSDPVec b, DSDPVec x){
00437   int info,n;
00438   double *xx,*bb;
00439   DSDPFunctionBegin;
00440   info=DSDPEventLogBegin(hsolveevent);
00441   if (M.dsdpops->matsolve){
00442     info=DSDPVecGetArray(b,&bb); DSDPCHKERR(info);
00443     info=DSDPVecGetSize(x,&n); DSDPCHKERR(info);
00444     info=DSDPVecZero(x);DSDPCHKERR(info);
00445     info=DSDPVecGetArray(x,&xx); DSDPCHKERR(info);
00446     info=(M.dsdpops->matsolve)(M.data,bb+1,xx+1,n-2); DSDPChkMatError(M,info);
00447     info=DSDPVecRestoreArray(b,&bb); DSDPCHKERR(info);
00448     info=DSDPVecRestoreArray(x,&xx); DSDPCHKERR(info);
00449   } else {
00450     DSDPNoOperationError(M);
00451   }
00452   info=DSDPVecSetR(x,0.0);DSDPCHKERR(info);
00453   info=DSDPVecSetC(x,0.0);DSDPCHKERR(info);
00454   info=DSDPEventLogEnd(hsolveevent);
00455   DSDPFunctionReturn(0);
00456 }
00457 
00458 #undef __FUNCT__
00459 #define __FUNCT__ "DSDPSchurMatSolve"
00460 
00467 int DSDPSchurMatSolve(DSDPSchurMat M, DSDPVec b, DSDPVec x){
00468   int info;
00469   DSDPFunctionBegin;
00470   info=DSDPSchurMatSolveM(M,b,x);DSDPCHKERR(info);
00471   info=DSDPApplySMW(M,b,x);DSDPCHKERR(info);
00472   info=DSDPZeroFixedVariables(M,x);DSDPCHKERR(info);
00473   DSDPFunctionReturn(0);
00474 }
00475 
00476 #undef __FUNCT__  
00477 #define __FUNCT__ "DSDPApplySMW"
00478 static int DSDPApplySMW(DSDPSchurMat M, DSDPVec rhs, DSDPVec dy){
00479   int info;
00480   double r=M.schur->r,rr,dr,rhsr,rssr;
00481   double rhsnorm,rhsnorm3,rhs1mrhs3=0,rhs3mrhs3=0;
00482   DSDPVec rhs3=M.schur->rhs3,dy3=M.schur->dy3;
00483   DSDPFunctionBegin;
00484   
00485   info=DSDPVecNormInfinity(rhs,&rhsnorm);DSDPCHKERR(info);
00486   info=DSDPVecNormInfinity(rhs3,&rhsnorm3);DSDPCHKERR(info);
00487   if (r==0 || rhsnorm==0){
00488     info=DSDPVecSetR(dy,0); DSDPCHKERR(info);
00489     info=DSDPVecSetR(rhs,0); DSDPCHKERR(info);
00490   } else if (0 && rhsnorm3==0){ /* dsdp->UsePenalty==DSDPNever */
00491     info=DSDPVecGetR(rhs,&rr); DSDPCHKERR(info);
00492     info=DSDPVecSetR(dy,rr); DSDPCHKERR(info);
00493   } else {
00494     /* Use bigM penalty method and Sherman-Morrison-Woodbury */
00495     info=DSDPVecGetR(rhs,&rhsr); DSDPCHKERR(info); 
00496     info=DSDPVecGetR(rhs3,&rssr); DSDPCHKERR(info); 
00497     info=DSDPVecDot(rhs3,dy,&rhs1mrhs3); DSDPCHKERR(info);
00498     info=DSDPVecDot(rhs3,dy3,&rhs3mrhs3); DSDPCHKERR(info);
00499     if (rssr-rhs3mrhs3==0) rssr*=(1.00001);
00500     dr=-(rhs1mrhs3-rhsr    )/(rssr-rhs3mrhs3);
00501     info=DSDPVecAXPY(-dr,dy3,dy);DSDPCHKERR(info);
00502     info=DSDPVecSetR(dy,dr); DSDPCHKERR(info);
00503     info=DSDPVecSetR(rhs,rhsr); DSDPCHKERR(info);
00504     info=DSDPVecDot(rhs,dy,&rhs3mrhs3); DSDPCHKERR(info);
00505     if (rhs3mrhs3 <=0){ 
00506       DSDPLogInfo(0,3,"DSDP Step Direction Not Descent, Adjusting. \n");
00507       info=DSDPVecAddR(rhs3,rssr*0.1);DSDPCHKERR(info);
00508       info=DSDPVecAXPY(dr,dy3,dy);DSDPCHKERR(info);
00509       info=DSDPVecSetR(dy,0); DSDPCHKERR(info);
00510       info=DSDPApplySMW(M,rhs,dy);DSDPCHKERR(info);
00511     }
00512   }   
00513   DSDPFunctionReturn(0);
00514 }
00515 
00516 #undef __FUNCT__  
00517 #define __FUNCT__ "DSDPZeroFixedVariables"
00518 int DSDPZeroFixedVariables( DSDPSchurMat M, DSDPVec dy){
00519   int i,info; 
00520   FixedVariables *fv=&M.schur->fv;
00521   DSDPFunctionBegin;
00522   for (i=0;i<fv->nvars;i++){
00523     info=DSDPVecSetElement(dy,fv->var[i],0.0);DSDPCHKERR(info);
00524   }
00525   DSDPFunctionReturn(0);
00526 }
00527 
00528 #undef __FUNCT__  
00529 #define __FUNCT__ "DSDPApplyFixedVariables"
00530 int DSDPApplyFixedVariables( DSDPSchurMat M, DSDPVec y){
00531   int i,jj,info;
00532   double vv,scl;
00533   FixedVariables *fv=&M.schur->fv;
00534   info=DSDPVecGetC(y,&scl);DSDPCHKERR(info);
00535   DSDPFunctionBegin;
00536   for (i=0;i<fv->nvars;i++){
00537     vv=fv->fval[i]*fabs(scl);
00538     jj=fv->var[i];
00539     info=DSDPVecSetElement(y,jj,vv);DSDPCHKERR(info);
00540   }
00541   DSDPFunctionReturn(0);
00542 }
00543 
00544 #undef __FUNCT__  
00545 #define __FUNCT__ "DSDPFixedVariableNorm"
00546 int DSDPFixedVariablesNorm( DSDPSchurMat M, DSDPVec y){
00547   int i,jj,info;
00548   double vv;
00549   FixedVariables *fv=&M.schur->fv;
00550   DSDPFunctionBegin;
00551   for (i=0;i<fv->nvars;i++){
00552     jj=fv->var[i]; vv=fv->fval[i];
00553     info=DSDPVecAddC(y,1.0);DSDPCHKERR(info);
00554     info=DSDPVecAddElement(y,jj,vv*vv);DSDPCHKERR(info);
00555   }
00556   DSDPFunctionReturn(0);
00557 }
00558 
00559 #undef __FUNCT__  
00560 #define __FUNCT__ "DSDPComputeFixedYX"
00561 int DSDPComputeFixedYX( DSDPSchurMat M, DSDPVec berr){
00562   int i,jj,info;
00563   double vv;
00564   FixedVariables *fv=&M.schur->fv;
00565   DSDPFunctionBegin;
00566   for (i=0;i<fv->nvars;i++){
00567     jj=fv->var[i];
00568     info=DSDPVecGetElement(berr,jj,&vv);DSDPCHKERR(info);
00569     info=DSDPVecSetElement(berr,jj,0);DSDPCHKERR(info);
00570     info=DSDPVecAddC(berr,-vv*fv->fval[i]);DSDPCHKERR(info);
00571     info=DSDPVecAddR(berr,fabs(vv));DSDPCHKERR(info);
00572     fv->fdual[i]=-vv;
00573     if (fv->xout) fv->xout[i]=-vv;
00574     DSDPLogInfo(0,2,"FIXED VAR DUAL: %d %4.4f, ADD %4.4f to objective.\n",jj,vv,-vv*fv->fval[i]);
00575   }
00576   DSDPFunctionReturn(0);
00577 }
00578 
00579 #undef __FUNCT__  
00580 #define __FUNCT__ "DSDPIsFixed"
00581 int DSDPIsFixed( DSDPSchurMat M, int vari, DSDPTruth *flag){
00582   int i;
00583   FixedVariables *fv=&M.schur->fv;
00584   DSDPFunctionBegin;
00585   *flag=DSDP_FALSE;
00586   for (i=0;i<fv->nvars;i++){
00587     if (fv->var[i]==vari){
00588       *flag=DSDP_TRUE;
00589       break;
00590     }
00591   }
00592   DSDPFunctionReturn(0);
00593 }
00594 #undef __FUNCT__  
00595 #define __FUNCT__ "DSDPInitializeFixedVariables"
00596 int DSDPInitializeFixedVariable( FixedVariables *fv){
00597   DSDPFunctionBegin;
00598   fv->nmaxvars=0;
00599   fv->nvars=0;
00600   fv->fval=0;
00601   fv->var=0;
00602   fv->fdual=0;
00603   DSDPFunctionReturn(0);
00604 }
00605 
00606 #undef __FUNCT__  
00607 #define __FUNCT__ "DSDPAddFixedVariables"
00608 int DSDPAddFixedVariable( DSDPSchurMat M, int vari, double val){
00609   int i,t,*iinew,info,nvars;
00610   double *ddnew,*vvnew;
00611   FixedVariables *fv=&M.schur->fv;
00612   DSDPFunctionBegin;
00613   nvars=fv->nvars;
00614   if (nvars>=fv->nmaxvars){
00615     t=2*nvars + 2;
00616     DSDPCALLOC2(&iinew,int,t,&info);
00617     DSDPCALLOC2(&ddnew,double,t,&info);
00618     DSDPCALLOC2(&vvnew,double,t,&info);
00619     for (i=0;i<nvars;i++){
00620       iinew[i]=fv->var[i];
00621       ddnew[i]=fv->fval[i];
00622       vvnew[i]=fv->fdual[i];
00623     }
00624     DSDPFREE(&fv->var,&info);DSDPCHKERR(info);
00625     DSDPFREE(&fv->fval,&info);DSDPCHKERR(info);
00626     DSDPFREE(&fv->fdual,&info);DSDPCHKERR(info);
00627     fv->var=iinew;
00628     fv->fval=ddnew;
00629     fv->fdual=vvnew;
00630     fv->nmaxvars=t;
00631   }
00632   fv->var[fv->nvars]=vari;
00633   fv->fval[fv->nvars]=val;
00634   fv->nvars++;
00635   DSDPFunctionReturn(0);
00636 }
00637  
00638 #include "dsdp.h"
00639 
00640 #undef __FUNCT__
00641 #define __FUNCT__ "DSDPSparsityInSchurMat"
00642 
00650 int DSDPSparsityInSchurMat(DSDP dsdp, int row, int rnnz[], int mm){
00651   int info,*iptr,m=mm+2;
00652   double *dd;
00653   DSDPVec R=dsdp->M.schur->rhs3;
00654   DSDPFunctionBegin;
00655   info=DSDPVecZero(R);DSDPCHKERR(info);
00656   info=DSDPVecGetArray(R,&dd);DSDPCHKERR(info);
00657   iptr=(int*)dd;
00658   info=DSDPSchurSparsity(dsdp,row+1,iptr,m);DSDPCHKERR(info);
00659   memcpy((void*)rnnz,(void*)(iptr+1),(mm)*sizeof(int));
00660   info=DSDPVecRestoreArray(R,&dd);DSDPCHKERR(info);
00661   DSDPFunctionReturn(0);
00662 }
00663 
00664 #undef __FUNCT__
00665 #define __FUNCT__ "DSDPSetFixedVariable"
00666 
00675 int DSDPSetFixedVariable(DSDP dsdp, int vari, double val){
00676    int info;
00677    DSDPFunctionBegin;
00678    DSDPLogInfo(0,2,"Set Fixed Variable: %d, %12.8f\n",vari,val);
00679    info= DSDPAddFixedVariable(dsdp->M,vari,val);DSDPCHKERR(info);
00680    DSDPFunctionReturn(0);
00681  }
00682 
00683 #undef __FUNCT__
00684 #define __FUNCT__ "DSDPSetFixedVariables"
00685 
00695 int DSDPSetFixedVariables(DSDP dsdp, double vars[], double vals[], double xout[], int nvars){
00696    int i,info;
00697    DSDPFunctionBegin;
00698    for (i=0;i<nvars;i++){
00699      info=DSDPSetFixedVariable(dsdp,(int)vars[i],vals[i]);
00700      dsdp->M.schur->fv.xout=xout;
00701    }
00702    DSDPFunctionReturn(0);
00703  }
00704 
00705 #undef __FUNCT__  
00706 #define __FUNCT__ "DSDPGetFixedYX"
00707 int DSDPGetFixedYX( DSDP dsdp, int vari, double *dd){
00708   int i;
00709   FixedVariables *fv=&dsdp->M.schur->fv;
00710   DSDPFunctionBegin;
00711   for (i=0;i<fv->nvars;i++){
00712     if (vari==fv->var[i]){
00713       *dd=fv->fdual[i]; break;
00714     }
00715   }
00716   DSDPFunctionReturn(0);
00717 }

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