Actual source code: kt.c

  1: #include "src/bound/impls/kt/kt.h"
  2: #include "src/tao_impl.h"

  4: static int TaoSetDown_KT(TAO_SOLVER, void *);
  5: static int TaoMonitor_KT(TAO_SOLVER my_tao, void *solver);

  7: /* ---------------------------------------------------------- */
 10: int TaoSetUp_KT(TAO_SOLVER tao,void *solver)
 11: {
 12:   TAO_KT *kt = (TAO_KT *)solver;
 13:   TaoVec *xx;
 14:   TaoTruth flg;
 15:   int info;

 17:   TaoFunctionBegin;
 18:   info = TaoGetSolution(tao,&xx); CHKERRQ(info);

 20:   // Create new complementarity solver
 21:   info = TaoOptionString("-tao_kt_method",0,0,kt->comp_method,
 22:                          kt->comp_method,256,&flg);
 23:   CHKERRQ(info);
 24:   if (kt->csolver==0){
 25:     info = TaoCreateFull(kt->comp_method,"t",tao->comm, &kt->csolver); 
 26:     CHKERRQ(info);
 27:   }
 28:   kt->ktapp = new TaoKTApplication(tao,kt->csolver);
 29:   kt->ktapp->SetItUp1(); CHKERRQ(info);
 30:   kt->ktapp->SetItUp2(); CHKERRQ(info);
 31:   kt->setupcalled=1;
 32:   
 33:   TaoFunctionReturn(0);
 34: }

 36: /* ---------------------------------------------------------- */
 39: static int TaoSetDown_KT(TAO_SOLVER tao, void *solver)
 40: {
 41:   TAO_KT *kt = (TAO_KT *)solver;
 42:   int info;

 44:   TaoFunctionBegin;
 45:   info = TaoDestroy(kt->csolver); CHKERRQ(info); 
 46:   info = TaoDestroyApplication(kt->ktapp); CHKERRQ(info); 
 47:   kt->setupcalled=0;
 48:   kt->csolver=0;
 49:   kt->ktapp=0;
 50:   TaoFunctionReturn(0);
 51: }

 55: static int TaoMonitor_KT(TAO_SOLVER complementaritytao, void *solver)
 56: {
 57:   TaoKTApplication* ktapp= (TaoKTApplication*)solver;
 58:   TaoTerminateReason reason;
 59:   double f, fnorm, cnorm, xdiff;
 60:   int iterate, info;

 62:   TaoFunctionBegin;
 63:   info = TaoGetSolutionStatus(complementaritytao, &iterate, &f, &fnorm, 
 64:                              &cnorm, &xdiff, &reason); CHKERRQ(info);
 65:   f=ktapp->func;
 66:   info = TaoMonitor(ktapp->orig,iterate,f,fnorm,cnorm,xdiff,&reason); CHKERRQ(info);
 67:   info = TaoSetTerminationReason(complementaritytao,reason); CHKERRQ(info);
 68:   TaoFunctionReturn(0);
 69: }

 71: /*------------------------------------------------------------*/
 74: static int TaoSolve_KT(TAO_SOLVER tao, void *solver)
 75: {
 76:   TAO_KT *kt = (TAO_KT *)solver;
 77:   int info;

 79:   TaoFunctionBegin;
 80:   info = TaoSolve(kt->csolver);  CHKERRQ(info);
 81:   TaoFunctionReturn(0);
 82: }

 84: /*------------------------------------------------------------*/
 87: static int TaoSetOptions_KT(TAO_SOLVER tao, void*solver)
 88: {
 89:   TAO_KT *kt = (TAO_KT *)solver;
 90:   TAO_SOLVER csolver=kt->csolver;
 91:   TaoTruth flg;
 92:   int info;

 94:   TaoFunctionBegin;
 95:   info = TaoOptionString("-tao_kt_method",
 96:                          "Set method for solving kt conditions",
 97:                          "TaoKTSetMethod",kt->comp_method,
 98:                          kt->comp_method,256,&flg);
 99:   CHKERRQ(info);

101:   if (csolver==0){
102:     info = TaoCreateFull(kt->comp_method,"t",tao->comm, &kt->csolver); 
103:     CHKERRQ(info);
104:   }
105:   csolver=kt->csolver;
106:   if (csolver->setfromoptions) {
107:     info = (*csolver->setfromoptions)(csolver,csolver->data); CHKERRQ(info);
108:   }
109:   TaoFunctionReturn(0);
110: }

112: /*------------------------------------------------------------*/
115: static int TaoView_KT(TAO_SOLVER tao,void* solver)
116: {
117:   TAO_KT   *kt = (TAO_KT *)solver;
118:   int      info;

120:   TaoFunctionBegin;
121:   info = TaoPrintString(tao,"  kt method=%s\n", kt->comp_method); 
122:          CHKERRQ(info);
123:   TaoFunctionReturn(0);
124: }

129: int TaoCreate_KT(TAO_SOLVER tao)
130: {
131:   TAO_KT *kt;
132:   int    info;

134:   TaoFunctionBegin;

136:   info = TaoNew(TAO_KT,&kt); CHKERRQ(info);

138:   kt->csolver = 0;
139:   kt->setupcalled=0;
140:   info = TaoStrcpy(kt->comp_method, "tao_ssils"); CHKERRQ(info);

142:   info=TaoSetTaoSolveRoutine(tao,TaoSolve_KT,(void*)kt); CHKERRQ(info);
143:   info=TaoSetTaoSetUpDownRoutines(tao,TaoSetUp_KT,TaoSetDown_KT); CHKERRQ(info);
144:   info=TaoSetTaoOptionsRoutine(tao,TaoSetOptions_KT); CHKERRQ(info);
145:   info=TaoSetTaoViewRoutine(tao,TaoView_KT); CHKERRQ(info);

147:   info = TaoSetMaximumIterates(tao,2000); CHKERRQ(info);
148:   info = TaoSetMaximumFunctionEvaluations(tao,4000); CHKERRQ(info);

150:   info = TaoSetTolerances(tao,0,0,0,0); CHKERRQ(info);
151:   info = TaoSetGradientTolerances(tao,1.0e-12,0.0,0.0); CHKERRQ(info);

153:   TaoFunctionReturn(0);
154: }

159: TaoKTApplication::TaoKTApplication(TAO_SOLVER outertao, TAO_SOLVER innertao) 
160: {
161:   this->orig=outertao;
162:   this->csolver=innertao;
163:   return;
164: }

168: int TaoKTApplication::SetItUp1() 
169: {
170:   int info;
171:   TaoFunctionBegin;
172:   info = TaoSetConvergenceTest(this->csolver, TAO_NULL, TAO_NULL); CHKERRQ(info);
173:   info = TaoSetTolerances(this->csolver,0,0,0,0); CHKERRQ(info);
174:   info = TaoSetGradientTolerances(this->csolver,0.0,0.0,0.0); CHKERRQ(info);
175:   info = TaoSetMaximumIterates(this->csolver,0); CHKERRQ(info);
176:   info = TaoSetMaximumFunctionEvaluations(this->csolver,0); CHKERRQ(info);
177:   info = TaoSetFunctionLowerBound(this->csolver,0); CHKERRQ(info);
178:   info = TaoSetMonitor(this->csolver, TaoMonitor_KT, (void*)this); CHKERRQ(info);
179:   TaoFunctionReturn(0);
180: }

184: int TaoKTApplication::SetItUp2() 
185: {
186:   int info;
187:   TaoVec *x1,*x2;
188:   TaoFunctionBegin;
189:   info = TaoSetApplication(this->csolver,this); CHKERRQ(info);
190:   info = TaoGetVariableBounds(this->csolver,&x1,&x2); CHKERRQ(info);
191:   info = TaoSetVariableBounds(this->orig,x1,x2); CHKERRQ(info);
192:   info = TaoGetStepDirectionVector(this->csolver,&x1); CHKERRQ(info);
193:   info = TaoSetStepDirectionVector(this->orig,x1); CHKERRQ(info);
194:   TaoFunctionReturn(0);
195: }

199: int TaoKTApplication::EvaluateConstraints(TaoVec *x, TaoVec *f) 
200: {
201:   int info;
202:   TaoFunctionBegin;
203:   info = TaoComputeFunctionGradient(this->orig, x, &this->func, f); 
204:          CHKERRQ(info);
205:   info = TaoSetLagrangianGradientVector(this->orig,f); CHKERRQ(info);
206:   TaoFunctionReturn(0);
207: }

211: int TaoKTApplication::EvaluateJacobian(TaoVec *x, TaoMat *J) 
212: {
213:   int info;
214:   TaoFunctionBegin;
215:   info = TaoComputeHessian(this->orig, x, J); CHKERRQ(info);
216:   TaoFunctionReturn(0);
217: }

221: int TaoKTApplication::InitializeVariables(TaoVec *x) 
222: {
223:   int info;
224:   TaoApplication* theapp;
225:   TaoFunctionBegin;
226:   info = TaoGetApplication(this->orig, &theapp); CHKERRQ(info);
227:   info = theapp->InitializeVariables(x); CHKERRQ(info);
228:   TaoFunctionReturn(0);
229: }

233: int TaoKTApplication::GetVariableVector(TaoVec **x) 
234: {
235:   int info;
236:   TaoFunctionBegin;
237:   info = TaoGetSolution(this->orig, x); CHKERRQ(info);
238:   TaoFunctionReturn(0);
239: }

243: int TaoKTApplication::EvaluateVariableBounds(TaoVec *l, TaoVec *u) 
244: {
245:   int info;
246:   TaoFunctionBegin;
247:   info = TaoEvaluateVariableBounds(this->orig, l, u); CHKERRQ(info);
248:   TaoFunctionReturn(0);
249: }

253: int TaoKTApplication::GetJacobianMatrix(TaoMat **J) 
254: {
255:   int info;
256:   TaoFunctionBegin;
257:   info = TaoGetHessian(this->orig, J); CHKERRQ(info);
258:   TaoFunctionReturn(0);
259: }

263: int TaoKTApplication::GetLinearSolver(TaoMat *H, int stype, TaoLinearSolver **tksp) {
264:   int info;
265:   TaoFunctionBegin;
266:   info = TaoCreateLinearSolver(this->orig, H, stype,tksp); CHKERRQ(info);
267:   TaoFunctionReturn(0);
268: }