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
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
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
00423
00424 }
00425 info=DSDPVecDestroy(&M->schur->rhs3);DSDPCHKERR(info);
00426 info=DSDPVecDestroy(&M->schur->dy3);DSDPCHKERR(info);
00427
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){
00491 info=DSDPVecGetR(rhs,&rr); DSDPCHKERR(info);
00492 info=DSDPVecSetR(dy,rr); DSDPCHKERR(info);
00493 } else {
00494
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 }