Actual source code: tron.c

  1: /*$Id: tron.c 1.143 05/05/10 15:21:37-05:00 sarich@zorak.(none) $*/

  3: #include "tron.h"       /*I "tao_solver.h" I*/

  5: /* TRON Routines */
  6: static int TaoGradProjections(TAO_SOLVER,TAO_TRON *);
  7: static int TronCheckOptimalFace(TaoVec*, TaoVec*, TaoVec*, TaoVec*, TaoVec*, 
  8:                                 TaoIndexSet*, TaoIndexSet*, TaoTruth *optimal);

 10: /*------------------------------------------------------------*/
 13: static int TaoSetDown_TRON(TAO_SOLVER tao, void*solver)
 14: {
 15:   TAO_TRON *tron = (TAO_TRON *)solver;
 16:   int      info;
 17:   /* Free allocated memory in TRON structure */
 18:   TaoFunctionBegin;
 19: 
 20:   info = TaoVecDestroy(tron->X_New);CHKERRQ(info);
 21:   info = TaoVecDestroy(tron->G_New);CHKERRQ(info);
 22:   info = TaoVecDestroy(tron->DX);CHKERRQ(info);tron->DX=0;
 23:   info = TaoVecDestroy(tron->Work);CHKERRQ(info);
 24:   info = TaoVecDestroy(tron->DXFree);CHKERRQ(info);
 25:   info = TaoVecDestroy(tron->R);CHKERRQ(info);
 26:   info = TaoVecDestroy(tron->G);CHKERRQ(info);
 27:   info = TaoVecDestroy(tron->PG);CHKERRQ(info);
 28:   info = TaoVecDestroy(tron->XL);CHKERRQ(info);
 29:   info = TaoVecDestroy(tron->XU);CHKERRQ(info);
 30: 
 31:   info = TaoIndexSetDestroy(tron->Free_Local);CHKERRQ(info);
 32:   info = TaoIndexSetDestroy(tron->TT);CHKERRQ(info);
 33:   info = TaoMatDestroy(tron->Hsub);CHKERRQ(info);
 34:   info = TaoDestroyLinearSolver(tao);CHKERRQ(info);

 36:   info = TaoSetLagrangianGradientVector(tao,0);CHKERRQ(info);
 37:   info = TaoSetStepDirectionVector(tao,0);CHKERRQ(info);
 38:   info = TaoSetVariableBounds(tao,0,0);CHKERRQ(info);

 40:   TaoFunctionReturn(0);
 41: }

 43: /*------------------------------------------------------------*/
 46: static int TaoSetOptions_TRON(TAO_SOLVER tao, void*solver)
 47: {
 48:   TAO_TRON  *tron = (TAO_TRON *)solver;
 49:   int        info,ival;
 50:   TaoTruth flg;

 52:   TaoFunctionBegin;

 54:   info = TaoOptionsHead("Newton Trust Region Method for bound constrained optimization");CHKERRQ(info);

 56:   info = TaoOptionInt("-tron_maxgpits","maximum number of gradient projections per TRON iterate","TaoSetMaxGPIts",tron->maxgpits,&tron->maxgpits,&flg);
 57:   CHKERRQ(info);

 59:   info = TaoOptionInt("-redistribute","Redistribute Free variables (> 1 processors, only)","TaoPetscISType",1,&ival,&flg); CHKERRQ(info);

 61:   info = TaoOptionName("-submatrixfree","Mask full matrix instead of extract submatrices","TaoPetscISType",&flg); CHKERRQ(info);

 63:   info = TaoOptionsTail();CHKERRQ(info);
 64:   info = TaoLineSearchSetFromOptions(tao);CHKERRQ(info);
 65:   /*  info = TaoSetLinearSolverOptions(tao);CHKERRQ(info); */

 67:   TaoFunctionReturn(0);
 68: }

 70: /*------------------------------------------------------------*/
 73: static int TaoView_TRON(TAO_SOLVER tao,void*solver)
 74: {
 75:   TAO_TRON  *tron = (TAO_TRON *)solver;
 76:   int        info;

 78:   TaoFunctionBegin;
 79:   /*
 80:   info = TaoPrintf1(tao," Variables, Total: %d,",tron->n);
 81:   info = TaoPrintf3(tao,"Free: %d,  Binding: %d \n",
 82:                     tron->n_free, tron->n - tron->n_free,
 83:                     tron->n_bind);CHKERRQ(info);
 84:   info = TaoPrintf1(tao,"            Equal lower bound: %d,",
 85:                     tron->n_lower);CHKERRQ(info);
 86:   info = TaoPrintf1(tao,"  Equal upper bound: %d \n",
 87:                     tron->n_upper);CHKERRQ(info);
 88:   */
 89:   info = TaoPrintInt(tao," Total PG its: %d,",tron->total_gp_its);CHKERRQ(info);
 90:   info = TaoPrintDouble(tao," PG tolerance: %4.3f \n",tron->pg_ftol);CHKERRQ(info);
 91:   info = TaoLineSearchView(tao);CHKERRQ(info);
 92:   info = TaoPrintStatement(tao,"  Linear Solver minimizes quadratic over Trust Region: \n");CHKERRQ(info);

 94:   TaoFunctionReturn(0);
 95: }


 98: /* ---------------------------------------------------------- */
101: static int TaoSetUp_TRON(TAO_SOLVER tao, void*solver){

103:   int info;
104:   TAO_TRON *tron = (TAO_TRON *)solver;
105:   TaoVec* X;
106:   TaoMat *HH;
107:   TaoIndexSet *TIS;
108:   TaoLinearSolver *ksp;

110:   TaoFunctionBegin;
111:   info = TaoGetSolution(tao,&tron->X);CHKERRQ(info); X=tron->X;
112:   info = TaoGetHessian(tao,&tron->H);CHKERRQ(info);  HH=tron->H;

114:   /* Allocate some arrays */
115:   info = X->Clone(&tron->DX); CHKERRQ(info);
116:   info = X->Clone(&tron->X_New); CHKERRQ(info);
117:   info = X->Clone(&tron->G_New); CHKERRQ(info);
118:   info = X->Clone(&tron->Work); CHKERRQ(info);
119:   info = X->Clone(&tron->DXFree); CHKERRQ(info);
120:   info = X->Clone(&tron->R); CHKERRQ(info);
121:   info = X->Clone(&tron->G); CHKERRQ(info);
122:   info = X->Clone(&tron->PG); CHKERRQ(info);
123:   info = X->Clone(&tron->XL); CHKERRQ(info);
124:   info = X->Clone(&tron->XU); CHKERRQ(info);

126:   info = TaoSetLagrangianGradientVector(tao,tron->PG);CHKERRQ(info);
127:   info = TaoSetStepDirectionVector(tao,tron->DX);CHKERRQ(info);
128:   info = TaoSetVariableBounds(tao,tron->XL,tron->XU);CHKERRQ(info);

130:   info = X->GetDimension(&tron->n); CHKERRQ(info);
131: 
132:   info = X->CreateIndexSet(&tron->Free_Local); CHKERRQ(info);
133:   info = tron->Free_Local->Duplicate(&tron->TT); CHKERRQ(info);

135:   TIS=tron->Free_Local;
136:   info = tron->H->CreateReducedMatrix(TIS,TIS,&tron->Hsub); CHKERRQ(info);
137:   info = TaoCreateLinearSolver(tao,HH,220,0); CHKERRQ(info);
138:   info = TaoGetLinearSolver(tao,&ksp); CHKERRQ(info);
139:  //  info = TaoCreateLinearSolver(tao,tron->Hsub,220,&tron->kspMarker); CHKERRQ(info);

141:   info = ksp->SetTolerances(1e-2,1e-30,1e30,tron->n);CHKERRQ(info);

143:   info = TaoCheckFGH(tao);CHKERRQ(info);

145:   TaoFunctionReturn(0);
146: }



152: static int TaoSolve_TRON(TAO_SOLVER tao, void*solver){

154:   TAO_TRON *tron = (TAO_TRON *)solver;
155:   int info,lsflag,iter=0;
156:   TaoTerminateReason reason;
157:   TaoTruth optimal_face=TAO_FALSE,success;
158:   double prered,actred,delta,f,f_new,rhok,gnorm,gdx,xdiff,stepsize;
159:   TaoVec *XU, *XL;
160:   TaoVec *X,  *G;
161:   TaoVec *PG=tron->PG;
162:   TaoVec *R=tron->R, *DXFree=tron->DXFree;
163:   TaoVec *X_New=tron->X_New, *G_New=tron->G_New;
164:   TaoVec *DX=tron->DX, *Work=tron->Work;
165:   TaoMat *H, *Hsub=tron->Hsub;
166:   TaoIndexSet *Free_Local = tron->Free_Local, *TIS=tron->TT;

168:   TaoFunctionBegin;

170:   /* Check if upper bound greater than lower bound. */
171:   info = TaoGetSolution(tao,&X);CHKERRQ(info); tron->X=X;
172:   info = TaoGetGradient(tao,&G);CHKERRQ(info);
173:   info = TaoGetVariableBounds(tao,&XL,&XU);CHKERRQ(info);
174:   info = TaoEvaluateVariableBounds(tao,XL,XU); CHKERRQ(info);
175:   info = TaoGetHessian(tao,&H);CHKERRQ(info); tron->H=H;

177:   info = TaoGetInitialTrustRegionRadius(tao,&tron->delta); CHKERRQ(info);
178:   tron->pgstepsize=1.0;

180:   /*   Project the current point onto the feasible set */
181:   info = X->Median(XL,X,XU); CHKERRQ(info);
182: 
183:   info = TaoComputeMeritFunctionGradient(tao,X,&tron->f,G);CHKERRQ(info);
184:   info = Free_Local->WhichBetween(XL,X,XU); CHKERRQ(info);
185: 
186:   /* Project the gradient and calculate the norm */
187:   //  info = G_New->CopyFrom(G);CHKERRQ(info);
188:   info = PG->BoundGradientProjection(G,XL,X,XU);CHKERRQ(info);
189:   info = PG->Norm2(&tron->gnorm); CHKERRQ(info);

191:   if (tron->delta <= 0.0){
192:     tron->delta=TaoMax(tron->gnorm*tron->gnorm,1.0);
193:     //    tron->delta = TAO_INFINITY;
194:   }

196:   tron->stepsize=tron->delta;

198:   info = TaoMonitor(tao,iter++,tron->f,tron->gnorm,0.0,tron->delta,&reason);
199:   CHKERRQ(info);

201:   while (reason==TAO_CONTINUE_ITERATING){
202: 
203:     info = TaoGradProjections(tao,tron); CHKERRQ(info);

205:     info = Free_Local->WhichBetween(XL,X,XU); CHKERRQ(info);
206:     info = Free_Local->GetSize(&tron->n_free); CHKERRQ(info);
207:     f=tron->f; delta=tron->delta; gnorm=tron->gnorm;

209:     if (tron->n_free > 0){
210: 
211:       info = TaoComputeHessian(tao,X,H);CHKERRQ(info);

213:       /* Create a reduced linear system */
214:       info = R->SetReducedVec(G,Free_Local);CHKERRQ(info);
215:       info = R->Negate(); CHKERRQ(info);
216:       info = DXFree->SetReducedVec(DX,Free_Local);CHKERRQ(info);
217:       info = DXFree->SetToZero(); CHKERRQ(info);

219:       info = Hsub->SetReducedMatrix(H,Free_Local,Free_Local);CHKERRQ(info);

221:       info = TaoPreLinearSolve(tao,Hsub);CHKERRQ(info);

223:       while (1){

225:          /* Approximately solve the reduced linear system */
226:         //        info = Hsub->minQuadraticTrustRegion(R,DXFree,delta,&success); CHKERRQ(info);
227:         info = TaoMinQPTrust(tao, Hsub, R, DXFree, delta, &success); CHKERRQ(info);

229:         info=DX->SetToZero(); CHKERRQ(info);
230:         info=DX->ReducedXPY(DXFree,Free_Local);CHKERRQ(info);

232:         info = G->Dot(DX,&gdx); CHKERRQ(info);
233:         info = PetscLogInfo((tao,"Expected decrease in function value: %14.12e\n",gdx)); CHKERRQ(info);

235:         stepsize=1.0; f_new=f;
236:         info = X_New->CopyFrom(X); CHKERRQ(info);
237:         info = G_New->CopyFrom(G); CHKERRQ(info);
238: 
239:         info = TaoLineSearchApply(tao,X_New,G_New,DX,Work,
240:                                   &f_new,&stepsize,&lsflag);
241:         CHKERRQ(info);
242:         info = H->Multiply(DX,Work); CHKERRQ(info);
243:         info = Work->Aypx(0.5,G); CHKERRQ(info);
244:         info = Work->Dot(DX,&prered); CHKERRQ(info);
245:         actred = f_new - f;
246: 
247:         if (actred<0) rhok=TaoAbsScalar(-actred/prered);
248:         else rhok=0.0;

250:         /* Compare actual improvement to the quadratic model */
251:         if (rhok > tron->eta1) { /* Accept the point */

253:           info = DX->Waxpby(1.0,X_New,-1.0, X); CHKERRQ(info);
254:           info = DX->Norm2(&xdiff); CHKERRQ(info);
255:           xdiff*=stepsize;

257:           /* Adjust trust region size */
258:           if (rhok < tron->eta2 ){
259:             delta = TaoMin(xdiff,delta)*tron->sigma1;
260:           } else if (rhok > tron->eta4 ){
261:             delta= TaoMin(xdiff,delta)*tron->sigma3;
262:           } else if (rhok > tron->eta3 ){
263:             delta=TaoMin(xdiff,delta)*tron->sigma2;
264:           }

266:           info =  PG->BoundGradientProjection(G_New,XL,X_New,XU);
267:           CHKERRQ(info);
268:           info = PG->Norm2(&gnorm);  CHKERRQ(info);
269: 
270:           info = TaoMonitor(tao,iter,f_new,gnorm,0.0,delta,&reason);CHKERRQ(info);

272:           info = TronCheckOptimalFace(X_New,XL,XU,G_New,PG, Free_Local, TIS,
273:                                       &optimal_face); CHKERRQ(info);

275:           if (stepsize < 1 || optimal_face==TAO_FALSE || reason!=TAO_CONTINUE_ITERATING ){
276:             f=f_new;
277:             info = X->CopyFrom(X_New); CHKERRQ(info);
278:             info = G->CopyFrom(G_New); CHKERRQ(info);
279:             break;
280:           }
281:         }  else {
282:           delta /= 4.0;
283:           info = TaoMonitor(tao,iter,f,gnorm,0.0,delta,&reason);CHKERRQ(info);
284:           if (reason!=TAO_CONTINUE_ITERATING ){  break; }
285:         }

287:       } /* end linear solve loop */
288: 
289: 
290:     } else {
291: 
292:       actred=0;
293:       info =  Work->BoundGradientProjection(G,XL,X,XU);
294:       CHKERRQ(info);
295:       info = Work->Norm2(&gnorm);  CHKERRQ(info);
296:       /* if there were no free variables, no cg method */
297:       info = TaoMonitor(tao,iter,f,gnorm,0.0,delta,&reason); CHKERRQ(info);

299:     }

301:     tron->f=f;tron->gnorm=gnorm; tron->actred=actred; tron->delta=delta;
302:     if (reason!=TAO_CONTINUE_ITERATING) break;
303:     iter++;
304: 
305:   }  /* END MAIN LOOP  */

307:   TaoFunctionReturn(0);
308: }


313: static int TaoGradProjections(TAO_SOLVER tao,TAO_TRON *tron)
314: {
315:   int i,lsflag=0,info;
316:   TaoTruth sameface=TAO_FALSE;
317:   double actred=-1.0,actred_max=0.0;
318:   double f_new;
319:   TaoVec *DX=tron->DX,*XL=tron->XL,*XU=tron->XU,*Work=tron->Work;
320:   TaoVec *X=tron->X,*G=tron->G;
321:   TaoIndexSet *TT1=tron->Free_Local, *TT2=tron->TT, *TT3;
322:   /*
323:      The gradient and function value passed into and out of this
324:      routine should be current and correct.
325:      
326:      The free, active, and binding variables should be already identified
327:   */
328: 
329:   TaoFunctionBegin;
330: 
331:   info = TaoGetSolution(tao,&X);CHKERRQ(info);
332:   info = TaoGetGradient(tao,&G);CHKERRQ(info);
333:   info = TaoGetVariableBounds(tao,&XL,&XU);CHKERRQ(info);

335:   info = TT1->WhichBetween(XL,X,XU); CHKERRQ(info);

337:   for (i=0;i<tron->maxgpits;i++){

339:     if ( -actred <= (tron->pg_ftol)*actred_max) break;
340: 
341:     tron->gp_iterates++; tron->total_gp_its++;
342:     f_new=tron->f;

344:     info = DX->ScaleCopyFrom(-1.0,G); CHKERRQ(info);

346:     info = TaoLineSearchApply(tao,X,G,DX,Work,
347:                               &f_new,&tron->pgstepsize,&lsflag);
348:     CHKERRQ(info);

350:     /* Update the iterate */
351:     actred = f_new - tron->f;
352:     actred_max = TaoMax(actred_max,-(f_new - tron->f));
353:     tron->f = f_new;

355:     info = TT2->WhichBetween(XL,X,XU); CHKERRQ(info);
356:     info = TT2->IsSame(TT1,&sameface);  CHKERRQ(info);
357:     if (sameface==TAO_TRUE) {
358:       break;
359:     } else {
360:       //      info = TT1->WhichBetween(XL,X,XU); CHKERRQ(info);
361:       TT3=TT2;
362:       TT2=TT1;
363:       TT1=TT3;
364:     }

366:   }
367: 
368:   TaoFunctionReturn(0);
369: }


374: static int TronCheckOptimalFace(TaoVec *X,TaoVec *XL,TaoVec*XU,TaoVec *PG,TaoVec*W,
375:                                 TaoIndexSet*Free_Local, TaoIndexSet*TT,
376:                                 TaoTruth *optimal)
377: {
378:   int info,n_free;
379:   double rr;
380:   TaoTruth same;

382:   TaoFunctionBegin;
383:   *optimal = TAO_FALSE;

385:   /* Also check to see if the active set is the same */

387:   info = TT->WhichBetween(XL,X,XU); CHKERRQ(info);
388:   info = Free_Local->IsSame(TT,&same); CHKERRQ(info);
389:   info = Free_Local->GetSize(&n_free); CHKERRQ(info);
390:   if (same == TAO_FALSE){
391:     info = Free_Local->WhichBetween(XL,X,XU); CHKERRQ(info);
392:     *optimal = TAO_FALSE;
393:     TaoFunctionReturn(0);
394:   } else {
395:     *optimal = TAO_TRUE;
396:   }

398:   info = W->CopyFrom(PG); CHKERRQ(info);
399:   info = W->Negate(); CHKERRQ(info);

401:   info = W->BoundGradientProjection(W,XL,X,XU); CHKERRQ(info);
402:   info = W->Axpy(1.0,PG); CHKERRQ(info);

404:   info = W->Norm2(&rr); CHKERRQ(info);
405:   if (rr>0) *optimal = TAO_FALSE;

407:   *optimal = TAO_FALSE;
408:   /*
409:     info = tron->TT->whichNonNegative(W); CHKERRQ(info);
410:     info = tron->TT->GetSize(&n); CHKERRQ(info);
411:     if (n==0) *optimal = TAO_TRUE;
412:   */
413:   TaoFunctionReturn(0);
414: }



420: int TaoDefaultMonitor_TRON(TAO_SOLVER tao,void *dummy)
421: {
422:   int info;
423:   int its,nfree,nbind;
424:   double fct,gnorm;
425:   TAO_TRON *tron;

427:   TaoFunctionBegin;
428:   info = TaoGetSolutionStatus(tao,&its,&fct,&gnorm,0,0,0);CHKERRQ(info);
429:   info = TaoGetSolverContext(tao,"tao_tron",(void**)&tron); CHKERRQ(info);
430:   if (tron){
431:     nfree=tron->n_free;
432:     nbind=tron->n_bind;
433:     info=TaoPrintInt(tao,"iter = %d,",its); CHKERRQ(info);
434:     info=TaoPrintDouble(tao," Function value: %g,",fct); CHKERRQ(info);
435:     info=TaoPrintDouble(tao,"  Residual: %g \n",gnorm);CHKERRQ(info);
436: 
437:     info=TaoPrintInt(tao," free vars = %d,",nfree); CHKERRQ(info);
438:     info=TaoPrintInt(tao," binding vars = %d\n",nbind); CHKERRQ(info);
439:   }
440:   TaoFunctionReturn(0);
441: }

443: int TaoSetMaxGPIts(TAO_SOLVER tao, int its){
444:   int info;
445:   TAO_TRON  *tron;

447:   TaoFunctionBegin;

449:   info = TaoGetSolverContext(tao,"tao_tron",(void**)&tron); CHKERRQ(info);
450:   if (tron){
451:     tron->maxgpits     = its;
452:   }
453:   TaoFunctionReturn(0);
454: }


459: static int TaoGetDualVariables_TRON(TAO_SOLVER tao, TaoVec* DXL, TaoVec* DXU, void *solver){

461:   TAO_TRON *tron = (TAO_TRON *) solver;
462:   TaoVec  *G=tron->G,*GP=tron->Work;
463:   TaoVec  *X,*XL,*XU;
464:   int       info;

466:   TaoFunctionBegin;
467:   info = TaoGetSolution(tao,&X); CHKERRQ(info);
468:   info = TaoGetVariableBounds(tao,&XL,&XU); CHKERRQ(info);
469:   info = GP->BoundGradientProjection(G,XL,X,XU); CHKERRQ(info);

471:   info = DXL->Waxpby(-1.0,G,1.0,GP); CHKERRQ(info);
472:   info = DXU->SetToZero(); CHKERRQ(info);
473:   info = DXL->PointwiseMaximum(DXL,DXU); CHKERRQ(info);

475:   info = DXU->Waxpby(-1.0,GP,1.0,G); CHKERRQ(info);
476:   info = GP->SetToZero(); CHKERRQ(info);
477:   info = DXU->PointwiseMinimum(GP,DXU); CHKERRQ(info);

479:   TaoFunctionReturn(0);
480: }

482: /*------------------------------------------------------------*/
486: int TaoCreate_TRON(TAO_SOLVER tao)
487: {
488:   TAO_TRON *tron;
489:   int      info;

491:   TaoFunctionBegin;

493:   info = TaoNew(TAO_TRON,&tron); CHKERRQ(info);
494:   info = PetscLogObjectMemory(tao,sizeof(TAO_TRON)); CHKERRQ(info);

496:   info=TaoSetTaoSolveRoutine(tao,TaoSolve_TRON,(void*)tron); CHKERRQ(info);
497:   info=TaoSetTaoSetUpDownRoutines(tao,TaoSetUp_TRON,TaoSetDown_TRON); CHKERRQ(info);
498:   info=TaoSetTaoOptionsRoutine(tao,TaoSetOptions_TRON); CHKERRQ(info);
499:   info=TaoSetTaoViewRoutine(tao,TaoView_TRON); CHKERRQ(info);
500:   info=TaoSetTaoDualVariablesRoutine(tao,TaoGetDualVariables_TRON); CHKERRQ(info);

502:   info = TaoSetMaximumIterates(tao,500); CHKERRQ(info);
503:   info = TaoSetTolerances(tao,1e-12,1e-12,0,0); CHKERRQ(info);
504:   /*
505:   tao->defaultmonitor     = TaoDefaultMonitor_TRON;
506:   */
507:   info = TaoSetTrustRegionTolerance(tao,1.0e-12);CHKERRQ(info);
508:   //  info = TaoSetTrustRegionRadius(tao,-1.0);CHKERRQ(info);
509:   info = TaoSetTrustRegionRadius(tao,1);CHKERRQ(info);

511:   /* Initialize pointers and variables */
512:   tron->n            = 0;
513:   tron->delta        = -1.0;
514:   tron->maxgpits     = 3;
515:   tron->pg_ftol      = 0.001;
516:   tron->eta1         = 0.001;
517:   tron->eta2         = 0.3;
518:   tron->eta3         = 0.5;
519:   tron->eta4         = 0.9;
520:   tron->sigma1       = 0.5;
521:   tron->sigma2       = 2.0;
522:   tron->sigma3       = 4.0;

524:   tron->gp_iterates  = 0; /* Cumulative number */
525:   tron->cgits        = 0; /* Current iteration */
526:   tron->total_gp_its = 0;
527:   tron->cg_iterates  = 0;
528:   tron->total_cgits  = 0;
529: 
530:   tron->n_bind       = 0;
531:   tron->n_free       = 0;
532:   tron->n_upper      = 0;
533:   tron->n_lower      = 0;

535:   tron->DX=0;
536:   tron->DXFree=0;
537:   tron->R=0;
538:   tron->X_New=0;
539:   tron->G_New=0;
540:   tron->Work=0;
541:   tron->Free_Local=0;
542:   tron->TT=0;
543:   tron->Hsub=0;

545:   //  info = TaoCreateProjectedLineSearch(tao); CHKERRQ(info);
546:   info = TaoCreateMoreThuenteBoundLineSearch(tao,0,0.9); CHKERRQ(info);

548:   TaoFunctionReturn(0);
549: }