Actual source code: tao_fghj.c

      1: #include "src/tao_impl.h"      /*I "tao_solver.h"  I*/

      4: /* --------------------------------------------------------------- */
      7: /*@C
      8:    TaoComputeFunction - Computes the function that has been
      9:    set with TaoSetFunction().

     11:    Collective on TAO_SOLVER

     13:    Input Parameters:
     14: +  solver - the TAO_SOLVER solver context
     15: -  xx - input vector

     17:    Output Parameter:
     18: .  y - function value

     20:    TaoComputeFunction() is typically used within minimization
     21:    implementations, so most users would not generally call this routine
     22:    themselves.

     24:    Level: developer

     26: .keywords: TAO_SOLVER, compute, minimization, function

     28: .seealso: TaoApplication::EvaluateObjectiveFunction(),
     29:           TaoComputeFunctionGradient(), TaoComputeHessian()
     30: @*/
     31: int TaoComputeFunction(TAO_SOLVER solver,TaoVec* xx,double *y)
     32: {
     33:   int    info;

     35:   TaoFunctionBegin;
     36:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);

     38:   if ( solver->taoappl){
     39:     info = solver->taoappl->EvaluateObjectiveFunction(xx,y); CHKERRQ(info);
     40:   }
     41:   solver->nfuncs++;
     42:   TaoFunctionReturn(0);
     43: }

     49: /*@
     50:    TaoIncrementGradientsCounter - Increments the gradient
     51:    counted by TAO.

     53:    Not Collective

     55:    Input Parameter:
     56: +  solver -  TAO_SOLVER context
     57: -  nevals - number of gradient evaluations to be added

     59:    Notes:
     60:    This counter is reset to zero for each successive call to TaoSolve().

     62:    Level: developer

     64: .keywords: Linear Solver, Objective Function
     65: @*/
     66: int TaoIncrementGradientsCounter(TAO_SOLVER solver,int nevals)
     67: {
     68:   TaoFunctionBegin;
     69:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
     70:   solver->ngrads += nevals ;
     71:   TaoFunctionReturn(0);
     72: }

     76: /*@C
     77:    TaoComputeGradient - Computes the function value and its gradient

     79:    Collective on TAO_SOLVER

     81:    Input Parameters:
     82: +  solver - the TAO_SOLVER solver context
     83: -  xx - input vector

     85:    Output Parameter:
     86: .  gg - gradient vector

     88:    Notes:
     89:    TaoComputeGradient() is typically used within minimization
     90:    implementations, so most users would not generally call this routine
     91:    themselves.

     93:    Level: developer

     95: .keywords: TAO_SOLVER, compute, gradient

     97: .seealso:  TaoApplication::EvaluateGradient(), TaoComputeFunction()
     98: @*/
     99: int TaoComputeGradient(TAO_SOLVER solver,TaoVec* xx, TaoVec* gg)
    100: {
    101:   int    info;

    103:   TaoFunctionBegin;
    104:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);

    106:   if ( solver->taoappl){
    107:     info = solver->taoappl->EvaluateGradient(xx,gg); CHKERRQ(info);
    108:   }
    109:   solver->ngrads++;

    111:   if (solver->viewgradient) {info=gg->View();CHKERRQ(info);}

    113:   TaoFunctionReturn(0);
    114: }

    119: /*@C
    120:    TaoComputeFunctionGradient - Computes the function value and its gradient

    122:    Collective on TAO_SOLVER

    124:    Input Parameters:
    125: +  solver - the TAO_SOLVER solver context
    126: -  xx - input vector

    128:    Output Parameter:
    129: +  f - function value
    130: -  gg - gradient vector

    132:    Notes:
    133:    TaoComputeFunctionGradient() is typically used within minimization
    134:    implementations, so most users would not generally call this routine
    135:    themselves.

    137:    Level: developer

    139: .keywords: TAO_SOLVER, compute, gradient

    141: .seealso:  TaoApplication::EvaluateObjectiveAndGradient(), TaoComputeFunction()
    142: @*/
    143: int TaoComputeFunctionGradient(TAO_SOLVER solver,TaoVec* xx, double *f, TaoVec* gg)
    144: {
    145:   int    info;

    147:   TaoFunctionBegin;
    148:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);

    150:   if ( solver->taoappl){
    151:     info = solver->taoappl->EvaluateObjectiveAndGradient(xx,f,gg); CHKERRQ(info);
    152:   }
    153:   solver->ngrads++;

    155:   if (solver->viewgradient) {info=gg->View();CHKERRQ(info);}

    157:   TaoFunctionReturn(0);
    158: }

    162: /*@C
    163:    TaoComputeHessian - Computes the Hessian matrix that has been
    164:    set with TaoSetHessian().

    166:    Collective on TAO_SOLVER and Mat

    168:    Input Parameters:
    169: +  solver - the TAO_SOLVER solver context
    170: -  xx - input vector

    172:    Output Parameters:
    173: .  HH - Hessian matrix

    175:    Notes:
    176:    Most users should not need to explicitly call this routine, as it
    177:    is used internally within the minimization solvers.

    179:    TaoComputeHessian() is typically used within minimization
    180:    implementations, so most users would not generally call this routine
    181:    themselves.

    183:    Level: developer

    185: .keywords: TAO_SOLVER, compute, Hessian, matrix

    187: .seealso:  TaoApplication::EvaluateHessian(), TaoComputeFunctionGradient(),
    188:            TaoComputeFunction()
    189: @*/
    190: int TaoComputeHessian(TAO_SOLVER solver,TaoVec *xx,TaoMat *HH)
    191: {
    192:   int    info;
    193:   TaoTruth flg;

    195:   TaoFunctionBegin;
    196:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    197:   if ( solver->taoappl){
    198:     info = solver->taoappl->EvaluateHessian(xx,HH); CHKERRQ(info);
    199:   }
    200:   solver->nhesss++;

    202:   info = HH->Compatible(xx,xx,&flg); CHKERRQ(info);
    203:   if (flg==TAO_FALSE){
    204:     SETERRQ(1,"Hessian Matrix not Compatible with solution vector");
    205:   }

    207:   if (solver->viewhessian){
    208:     info=HH->View();CHKERRQ(info);
    209:   }

    211:   TaoFunctionReturn(0);
    212: }

    218: /*@C
    219:    TaoGetHessian - Sets the pointer to a TaoMat equal to the address
    220:    a the TaoMat containing the Hessian matrix.

    222:    Input Parameter:
    223: +  solver - the TAO_SOLVER solver context
    224: -  HH - address of a pointer to a TaoMat

    226:    Output Parameters:
    227: .  HH - address of pointer to the Hessian matrix (or TAO_NULL)

    229:    Note:  This routine does not create a matrix.  It sets a pointer
    230:    to the location of an existing matrix.

    232:    Level: developer

    234: .seealso: TaoApplication::EvaluateHessian(), TaoComputeHessian()

    236: .keywords: TAO_SOLVER, get, Hessian
    237: @*/
    238: int TaoGetHessian(TAO_SOLVER solver,TaoMat **HH)
    239: {
    240:   int info;
    241:   TaoFunctionBegin;
    242:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    243:   if (!solver->hessian){
    244:     info = solver->taoappl->GetHessianMatrix(&solver->hessian); CHKERRQ(info);
    245:   }
    246:   if (HH)   *HH = solver->hessian;
    247:   TaoFunctionReturn(0);
    248: }

    253: /*@C
    254:    TaoComputeJacobian - Computes the Jacobian matrix that has been
    255:    set.

    257:    Collective on TAO_SOLVER and Mat

    259:    Input Parameters:
    260: +  solver - the TAO_SOLVER solver context
    261: .  xx - input vector

    263:    Output Parameters:
    264: +  JJ - Jacobian matrix

    266:    Notes:
    267:    TaoComputeJacobian() is typically used within minimization
    268:    implementations, so most users would not generally call this routine
    269:    themselves.

    271:    Level: developer

    273: .keywords: TAO_SOLVER, compute, Jacobian, matrix

    275: .seealso:  TaoApplication::EvaluateJacobian()
    276: @*/
    277: int TaoComputeJacobian(TAO_SOLVER solver,TaoVec* xx,TaoMat *JJ)
    278: {
    279:   int    info;

    281:   TaoFunctionBegin;
    282:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    283:   if ( solver->taoappl){
    284:     info = solver->taoappl->EvaluateJacobian(xx,JJ); CHKERRQ(info);
    285:   }
    286:   solver->njac++;

    288:   if (solver->viewjacobian){ info=JJ->View();CHKERRQ(info);}

    290:   TaoFunctionReturn(0);
    291: }

    297: /*@
    298:    TaoEvaluateVariableBounds - Evaluate the  lower and upper bounds on the variables.

    300:    Collective on TAO_SOLVER

    302:    Input Parameters:
    303: +  tao - the TAO_SOLVER solver context
    304: .  xxll - vector of lower bounds upon the solution vector
    305: -  xxuu - vector of upper bounds upon the solution vector

    307:    Level: developer

    309: .keywords: bounds

    311: .seealso: TaoGetVariableBounds()
    312: @*/
    313: int TaoEvaluateVariableBounds(TAO_SOLVER tao,TaoVec *xxll,TaoVec *xxuu)
    314: {
    315:   int info;
    316:   TaoFunctionBegin;
    317:   TaoValidHeaderSpecific(tao,TAO_COOKIE,1);
    318:   info = tao->taoappl->EvaluateVariableBounds(xxll,xxuu); CHKERRQ(info);
    319:   info = TaoCheckBounds(tao); CHKERRQ(info);
    320:   TaoFunctionReturn(0);
    321: }

    324: /*
    327: int TaoAppSetConstraintsBounds(TAO_SOLVER solver,TaoVec *RXL,TaoMat *AA, TaoVec *RXU)
    328: {
    329:   TaoFunctionBegin;
    330:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    331:   solver->RXL=RXL;
    332:   solver->CA=AA;
    333:   solver->RXU=RXU;
    334:   TaoFunctionReturn(0);
    335: }
    336: */

    340: /*@C
    341:    TaoComputeConstraints - Computes the constraint vector that has been
    342:    set in the application.

    344:    Collective on TAO_SOLVER and Mat

    346:    Input Parameters:
    347: +  solver - the TAO_SOLVER solver context
    348: -  xx - input vector

    350:    Output Parameters:
    351: .  rr - Constraint values

    353:    Notes:
    354:    TaoComputeConstraints() is typically used within minimization
    355:    implementations, so most users would not generally call this routine
    356:    themselves.

    358:    Level: developer

    360: .keywords: TAO_SOLVER, compute, constraint

    362: .seealso:  TaoAppSetConstraintRoutine()
    363: @*/
    364: int TaoComputeConstraints(TAO_SOLVER solver,TaoVec* xx,TaoVec* rr)
    365: {
    366:   int    info;

    368:   TaoFunctionBegin;
    369:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    370:   if ( solver->taoappl){
    371:     info = solver->taoappl->EvaluateConstraints(xx,rr); CHKERRQ(info);
    372:   }
    373:   solver->nvfunc++;
    374:   if (solver->viewvfunc){ info=rr->View(); CHKERRQ(info); }

    376:   TaoFunctionReturn(0);
    377: }

    381: /*@C
    382:    TaoGetConstraints - Get the constraint vector that has been
    383:    set.

    385:    Collective on TAO_SOLVER and Mat

    387:    Input Parameters:
    388: .  solver - the TAO_SOLVER solver context

    390:    Output Parameters:
    391: .  rr - Constraint values

    393:    Level: developer

    395: .keywords: TAO_SOLVER, compute, constraints

    397: .seealso:  TaoApplication::EvaluateConstraints()
    398: @*/
    399: int TaoGetConstraints(TAO_SOLVER solver, TaoVec** rr)
    400: {
    401:   TaoFunctionBegin;
    402:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    403:   *rr = solver->vfunc;
    404:   TaoFunctionReturn(0);
    405: }

    409: /*@C
    410:    TaoGetJacobian - Get the Jacobian matrix

    412:    Collective on TAO_SOLVER and Mat

    414:    Input Parameters:
    415: .  solver - the TAO_SOLVER solver context

    417:    Output Parameters:
    418: .  JJ - Jacobian Matrix

    420:    Level: advanced

    422: .keywords: TAO_SOLVER, compute, constraint

    424: .seealso:  TaoApplication::EvaluateJacobian(), TaoAppSetConstraintRoutine()
    425: @*/
    426: int TaoGetJacobian(TAO_SOLVER solver, TaoMat **JJ)
    427: {
    428:   TaoFunctionBegin;
    429:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    430:   *JJ = solver->jacobian;
    431:   TaoFunctionReturn(0);
    432: }

    439: /*@C
    440:    TaoGetSolution - Sets a pointer to a TaoVec to the address of the
    441:    vector containing the current solution.

    443:    Input Parameter:
    444: +  solver - the TAO_SOLVER solver context
    445: -  xx - the address of a pointer to a TaoVec

    447:    Output Parameter:
    448: .  xx - the solution

    450:    Level: advanced
    451:
    452:    Note:  This routine does not create a vector.  It sets a pointer
    453:    to the location of an existing vector.

    455:    Note:
    456:    This vector is a reference to the vector set in the application and passed
    457:    to TAO in TaoSetApplication().

    459: .keywords: solve, solution

    461: .seealso: TaoCreate(), TaoGetGradient(), TaoSetApplication()
    462: @*/
    463: int TaoGetSolution(TAO_SOLVER solver,TaoVec** xx)
    464: {
    465:   TaoFunctionBegin;
    466:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    467:   *xx=solver->vec_sol;
    468:   TaoFunctionReturn(0);
    469: }

    474: /*@
    475:    TaoSetLagrangianGradientVector - Sets a pointer to the address of a TaoVector that
    476:    contains the gradient of the Lagrangian function.

    478:    Input Parameter:
    479: +  solver - the TAO_SOLVER solver context
    480: -  gg - the gradient of the Lagrangian function

    482:    Level: developer

    484:    Note:  This routine does not create a vector.  The vector specified
    485:    here will be returned whenever TaoGetGradient() is called.

    487: .keywords: Gradient

    489: .seealso: TaoGetGradient()

    491: @*/
    492: int TaoSetLagrangianGradientVector(TAO_SOLVER solver,TaoVec* gg)
    493: {
    494:   TaoFunctionBegin;
    495:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    496:   solver->vec_grad =gg;
    497:   TaoFunctionReturn(0);
    498: }

    502: /*@C
    503:    TaoGetGradient - Sets a pointer to the address of a TaoVector that
    504:    contains the gradient of the Lagrangian function.

    506:    Input Parameter:
    507: .  solver - the TAO_SOLVER solver context

    509:    Output Parameter:
    510: .  gg - the gradient of the Lagrangian function

    512:    Level: advanced

    514:    Note:  This routine does not create a vector.  It sets a pointer
    515:    to the location of an existing vector.

    517: .keywords: Gradient

    519: .seealso: TaoGetSolution(), TaoGetSolutionStatus(), TaoGetHessian(), TaoSetApplication()

    521: @*/
    522: int TaoGetGradient(TAO_SOLVER solver,TaoVec** gg)
    523: {
    524:   TaoFunctionBegin;
    525:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    526:   *gg = solver->vec_grad;
    527:   TaoFunctionReturn(0);
    528: }

    531: /* --------------------------------------------------------------- */
    534: /*@C
    535:    TaoComputeMeritFunction - Computes the function that has been
    536:    set with TaoSetMeritFunction().

    538:    Collective on TAO_SOLVER

    540:    Input Parameters:
    541: +  solver - the TAO_SOLVER solver context
    542: -  xx - input vector

    544:    Output Parameter:
    545: .  y - merit function value

    547:    TaoComputeMeritFunction() is typically used within minimization
    548:    implementations, so most users would not generally call this routine
    549:    themselves.

    551:    Level: developer

    553: .keywords: TAO_SOLVER, compute, minimization, function

    555: .seealso: TaoSetMeritFunction()
    556: @*/
    557: int TaoComputeMeritFunction(TAO_SOLVER solver,TaoVec* xx,double *y)
    558: {
    559:   int    info;

    561:   TaoFunctionBegin;
    562:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);

    564:   if ( solver->MeritFunctionApply){
    565:     info = solver->MeritFunctionApply(solver,xx,y,solver->meritctx); CHKERRQ(info);
    566:   }
    567:   TaoFunctionReturn(0);
    568: }

    573: /*@C
    574:    TaoSetMeritFunction - Sets the routine that evaluates the merit
    575:    function.

    577:    Collective on TAO_SOLVER

    579:    Input Parameters:
    580: +  solver - the TAO_SOLVER solver context
    581: .  func - merit function evaluation routine
    582: .  funcgrad - merit function and gradient evalution routine
    583: .  grad - merit gradient evaluation routine
    584: .  destroy - context destructor routine
    585: -  ctx - [optional] user-defined context for private data for the
    586:          function and gradient evaluation routine (may be TAO_NULL)

    588:    Calling sequence of func:
    589: $     func (TAO_SOLVER solver,TaoVec *xx,double *f,void *ctx);

    591: +  solver - the TAO_SOLVER solver context
    592: .  xx - variable vector
    593: .  f - objective function value
    594: -  ctx - [optional] user-defined function context

    596:    Calling sequence of funcgrad:
    597: $     funcgrad (TAO_SOLVER solver,TaoVec *xx,double *f,TaoVec *gg, void *ctx);

    599: +  solver - the TAO_SOLVER solver context
    600: .  xx - variable vector
    601: .  f - objective function value
    602: .  gg - gradient vector
    603: -  ctx - [optional] user-defined function context

    605:    Calling sequence of grad:
    606: $     grad (TAO_SOLVER solver,TaoVec *xx,TaoVec *gg,void *ctx);

    608: +  solver - the TAO_SOLVER solver context
    609: .  xx - variable vector
    610: .  gg - gradient vector
    611: -  ctx - [optional] user-defined function context

    613:    Calling sequence of destroy:
    614: $     destroy (TAO_SOLVER solver, void *ctx);

    616: +  solver - the TAO_SOLVER solver context
    617: -  ctx - [optional] user-defined function context

    619:    Level: developer

    621: .keywords: TAO_SOLVER, merit function

    623: .seealso:  TaoComputeMeritFunction()
    624: @*/
    625: int TaoSetMeritFunction(TAO_SOLVER solver,int (*func)(TAO_SOLVER,TaoVec*,double*,void*),
    626:                         int (*funcgrad)(TAO_SOLVER,TaoVec*,double*,TaoVec*,void*),
    627:                         int (*grad)(TAO_SOLVER,TaoVec*,TaoVec*,void*),
    628:                         int (*destroy)(TAO_SOLVER,void*),
    629:                         void *ctx)
    630: {
    631:   int info;
    632:   TaoFunctionBegin;

    634:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);
    635:   info = TaoMeritFunctionDestroy(solver); CHKERRQ(info);
    636:   solver->MeritFunctionApply =func;
    637:   solver->MeritFunctionGradientApply =funcgrad;
    638:   solver->MeritGradientApply =grad;
    639:   solver->MeritFunctionDestroy =destroy;
    640:   solver->meritctx           = ctx;

    642:   TaoFunctionReturn(0);
    643: }

    646: /* --------------------------------------------------------------- */
    649: /*@C
    650:    TaoComputeMeritFunctionGradient - Computes the function that has been
    651:    set with TaoSetMeritFunction().

    653:    Collective on TAO_SOLVER

    655:    Input Parameters:
    656: +  solver - the TAO_SOLVER solver context
    657: -  xx - input vector

    659:    Output Parameter:
    660: .  y - merit function value
    661: .  gg - merit gradient vector

    663:    TaoComputeMeritFunctionGradient() is typically used within minimization
    664:    implementations, so most users would not generally call this routine
    665:    themselves.

    667:    Level: developer

    669: .keywords: TAO_SOLVER, compute, minimization, function

    671: .seealso: TaoSetMeritFunctionGradient()
    672: @*/
    673: int TaoComputeMeritFunctionGradient(TAO_SOLVER solver,TaoVec* xx,double *y,TaoVec*gg)
    674: {
    675:   int    info;

    677:   TaoFunctionBegin;
    678:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);

    680:   if ( solver->MeritFunctionGradientApply){
    681:     info = solver->MeritFunctionGradientApply(solver,xx,y,gg,solver->meritctx); CHKERRQ(info);
    682:   }
    683:   TaoFunctionReturn(0);
    684: }

    687: /* --------------------------------------------------------------- */
    690: /*@C
    691:    TaoComputeMeritGradient - Computes the function that has been
    692:    set with TaoSetMeritFunction().

    694:    Collective on TAO_SOLVER

    696:    Input Parameters:
    697: +  solver - the TAO_SOLVER solver context
    698: -  xx - input vector

    700:    Output Parameter:
    701: .  gg - merit gradient vector

    703:    TaoComputeMeritFunctionGradient() is typically used within minimization
    704:    implementations, so most users would not generally call this routine
    705:    themselves.

    707:    Level: developer

    709: .keywords: TAO_SOLVER, compute, minimization, function

    711: .seealso: TaoSetMeritFunction()
    712: @*/
    713: int TaoComputeMeritGradient(TAO_SOLVER solver,TaoVec* xx,TaoVec*gg)
    714: {
    715:   int    info;

    717:   TaoFunctionBegin;
    718:   TaoValidHeaderSpecific(solver,TAO_COOKIE,1);

    720:   if ( solver->MeritGradientApply){
    721:     info = solver->MeritGradientApply(solver,xx,gg,solver->meritctx); CHKERRQ(info);
    722:   }
    723:   TaoFunctionReturn(0);
    724: }

    729: /*@C
    730:    TaoMeritFunctionDestroy - Destroy the data structures associated with
    731:    the merit function and set associated function pointers to NULL.

    733:    Collective on TAO_SOLVER

    735:    Input Parameters:
    736: .  solver - the TAO_SOLVER solver context

    739:    Level: developer

    741: .keywords: TAO_SOLVER, compute, minimization, function

    743: .seealso: TaoSetMeritFunction()
    744: @*/
    745: int TaoMeritFunctionDestroy(TAO_SOLVER solver){
    746:   int info;
    747:   TaoFunctionBegin;
    748:   if (solver->MeritFunctionDestroy){
    749:     info=solver->MeritFunctionDestroy(solver,solver->meritctx); CHKERRQ(info);
    750:   }
    751:   solver->MeritFunctionApply=0;
    752:   solver->MeritFunctionGradientApply=0;
    753:   solver->MeritGradientApply=0;
    754:   solver->MeritFunctionDestroy=0;
    755:   solver->meritctx=0;
    756:   TaoFunctionReturn(0);
    757: }

    762: /*@C
    763:    TaoSetApplication - Sets the user defined context for
    764:    use by the optimization solver.  The application provides
    765:    the solver with function and derivative information as
    766:    well as data structures uses to store this information.

    768:    Collective on TAO_SOLVER

    770:    Input Parameters:
    771: +  tao - the TAO_SOLVER solver context
    772: -  taoapp - user application context

    774:    Note:
    775:    For PETSc users the TaoApplication* object is actually
    776:    TAO_APPLICATION structure.

    778:
    779:    Level: advanced

    781: .keywords: application, context

    783: @*/
    784: int TaoSetApplication(TAO_SOLVER tao, TaoApplication *myapp){
    785:   int info;
    786:   TaoVec *xx,*RR;
    787:   TaoMat *HH, *JJ;
    788:   TaoVec *RXL, *RXU;
    789:   TaoMat *CA;

    791:   TaoFunctionBegin;
    792:   tao->taoappl=myapp;
    793:   info = myapp->GetVariableVector(&xx);CHKERRQ(info);
    794:   info = myapp->GetHessianMatrix(&HH);CHKERRQ(info);
    795:   info = myapp->GetJacobianMatrix(&JJ); CHKERRQ(info);
    796:   info = myapp->GetConstraintVector(&RR);CHKERRQ(info);
    797:   info = myapp->GetInequalityConstraints(&RXL,&CA,&RXU);

    799:   tao->hessian=HH;
    800:   tao->vec_sol=xx;
    801:   tao->jacobian=JJ;
    802:   tao->vfunc=RR;
    803:   tao->RXL=RXL;
    804:   tao->RXU=RXU;
    805:   tao->CA=CA;

    807:   info = TaoSetUp(tao);CHKERRQ(info);

    809:   TaoFunctionReturn(0);
    810: }

    812: class TaoH0Mat: public TaoMat{
    813:  protected:
    814:   TaoApplication *H0;
    815:  public:
    816:   TaoH0Mat(TaoApplication*);
    817:   ~TaoH0Mat();
    818:   int Solve(TaoVec*, TaoVec*, TaoTruth*);
    819: };

    823: TaoH0Mat::TaoH0Mat(TaoApplication* theappobject){
    824:   this->H0=theappobject;
    825:   return;
    826: }

    830: TaoH0Mat::~TaoH0Mat(){
    831:   return;
    832: }

    836: int TaoH0Mat::Solve(TaoVec* tb, TaoVec* dx, TaoTruth *tt){
    837:   int info;
    838:   info=this->H0->HessianSolve(tb,dx,tt); CHKERRQ(info);
    839:   return 0;
    840: }

    842:  #include src/bound/impls/blmvm/blmvm.h

    846: int TaoBLMVMSetH0(TAO_SOLVER tao, TaoTruth flag){
    847:   int info;
    848:   TAO_BLMVM *blmvm=0;
    849:   TaoMat *H0;

    851:   TaoFunctionBegin;
    852:   info = TaoGetSolverContext(tao,"tao_blmvm",(void**)&blmvm); CHKERRQ(info);
    853:   if (blmvm==0 || !(blmvm->M)){
    854:     TaoFunctionReturn(0);
    855:   }
    856:   if (flag==TAO_TRUE){
    857:     H0=new  TaoH0Mat(tao->taoappl);
    858:     info = blmvm->M->SetH0( H0 );CHKERRQ(info);
    859:   } else {
    860:     info = blmvm->M->SetH0(0);CHKERRQ(info);
    861:   }
    862:   TaoFunctionReturn(0);
    863: }

    865:  #include src/unconstrained/impls/lmvm/lmvm.h
    868: int TaoLMVMSetH0(TAO_SOLVER tao, TaoTruth flag){
    869:   int info;
    870:   TAO_LMVM *lmvm=0;
    871:   TaoMat *H0;
    872:
    873:   TaoFunctionBegin;
    874:   info = TaoGetSolverContext(tao,"tao_lmvm",(void**)&lmvm); CHKERRQ(info);
    875:   if (lmvm==0 || !(lmvm->M)){
    876:     TaoFunctionReturn(0);
    877:   }
    878:   if (flag==TAO_TRUE){
    879:     H0=new  TaoH0Mat(tao->taoappl);
    880:     info = lmvm->M->SetH0( H0 );CHKERRQ(info);
    881:   }  else {
    882:     info = lmvm->M->SetH0( 0 );CHKERRQ(info);
    883:   }
    884:   TaoFunctionReturn(0);
    885: }