Actual source code: ssls.c

  1: #include "src/complementarity/impls/ssls/ssls.h"

  3: /* ---------------------------------------------------------- */
  6: int TaoSetUp_SSLS(TAO_SOLVER tao, void *solver)
  7: {
  8:   TAO_SSLS *ssls = (TAO_SSLS *)solver;
  9:   TaoVec *x;
 10:   TaoMat *J;
 11:   int n,info;

 13:   TaoFunctionBegin;

 15:   info = TaoGetSolution(tao, &x); CHKERRQ(info);
 16:   info = TaoGetJacobian(tao, &J); CHKERRQ(info);

 18:   info = x->GetDimension(&n); CHKERRQ(info);

 20:   info = x->Clone(&(ssls->f)); CHKERRQ(info);
 21:   info = x->Clone(&(ssls->g)); CHKERRQ(info);
 22:   info = x->Clone(&(ssls->ff)); CHKERRQ(info);
 23:   info = x->Clone(&(ssls->dpsi)); CHKERRQ(info);
 24:   info = x->Clone(&(ssls->d)); CHKERRQ(info);
 25:   info = x->Clone(&(ssls->w)); CHKERRQ(info);
 26:   info = x->Clone(&(ssls->da)); CHKERRQ(info);
 27:   info = x->Clone(&(ssls->db)); CHKERRQ(info);
 28:   info = x->Clone(&(ssls->t1)); CHKERRQ(info);
 29:   info = x->Clone(&(ssls->t2)); CHKERRQ(info);
 30:   info = x->Clone(&(ssls->xl)); CHKERRQ(info);
 31:   info = x->Clone(&(ssls->xu)); CHKERRQ(info);

 33:   info = TaoSetVariableBounds(tao,ssls->xl,ssls->xu); CHKERRQ(info);
 34:   info = TaoCheckBounds(tao); CHKERRQ(info);

 36:   info = TaoSetStepDirectionVector(tao,ssls->d);CHKERRQ(info);
 37:   info = TaoSetLagrangianGradientVector(tao,ssls->g);CHKERRQ(info);

 39:   info = TaoCreateLinearSolver(tao,J,210,0); CHKERRQ(info);

 41:   info = TaoLineSearchSetUp(tao);CHKERRQ(info);
 42:   TaoFunctionReturn(0);
 43: }

 45: /* ---------------------------------------------------------- */
 48: int TaoSetDown_SSLS(TAO_SOLVER tao, void *solver)
 49: {
 50:   TAO_SSLS *ssls = (TAO_SSLS *)solver;
 51:   int info;

 53:   TaoFunctionBegin;

 55:   info=TaoVecDestroy(ssls->f); CHKERRQ(info);
 56:   info=TaoVecDestroy(ssls->g); CHKERRQ(info);
 57:   info=TaoVecDestroy(ssls->ff); CHKERRQ(info);
 58:   info=TaoVecDestroy(ssls->dpsi); CHKERRQ(info);
 59:   info=TaoVecDestroy(ssls->d); CHKERRQ(info);
 60:   info=TaoVecDestroy(ssls->w); CHKERRQ(info);
 61:   info=TaoVecDestroy(ssls->da); CHKERRQ(info);
 62:   info=TaoVecDestroy(ssls->db); CHKERRQ(info);
 63:   info=TaoVecDestroy(ssls->t1); CHKERRQ(info);
 64:   info=TaoVecDestroy(ssls->t2); CHKERRQ(info);
 65:   info=TaoVecDestroy(ssls->xl); CHKERRQ(info);
 66:   info=TaoVecDestroy(ssls->xu); CHKERRQ(info);

 68:   TaoFunctionReturn(0);
 69: }

 71: /*------------------------------------------------------------*/
 74: int TaoSetOptions_SSLS(TAO_SOLVER tao, void *solver)
 75: {
 76:   TAO_SSLS *ssls = (TAO_SSLS *)solver;
 77:   int info;
 78:   TaoTruth flg;

 80:   TaoFunctionBegin;
 81:   info = TaoOptionsHead("Semismooth method with a linesearch for "
 82:                           "complementarity problems"); CHKERRQ(info);
 83:   info = TaoOptionDouble("-ssls_delta", "descent test fraction", "",
 84:                          ssls->delta, &(ssls->delta), &flg);CHKERRQ(info);
 85:   info = TaoOptionDouble("-ssls_rho", "descent test power", "",
 86:                          ssls->rho, &(ssls->rho), &flg);CHKERRQ(info);
 87:   info = TaoLineSearchSetFromOptions(tao);CHKERRQ(info);
 88:   info = TaoOptionsTail(); CHKERRQ(info);
 89:   TaoFunctionReturn(0);
 90: }

 92: /*------------------------------------------------------------*/
 95: int TaoView_SSLS(TAO_SOLVER tao, void *solver)
 96: {
 97:   int info;

 99:   TaoFunctionBegin;
100:   info = TaoLineSearchView(tao); CHKERRQ(info);
101:   TaoFunctionReturn(0);
102: }

104: /*------------------------------------------------------------*/
107: int Tao_SSLS_Function(TAO_SOLVER tao, TaoVec *X, double *fcn, void *solver) 
108: {
109:   TAO_SSLS *ssls = (TAO_SSLS *)solver;
110:   TaoVec *f, *l, *u, *ff;
111:   int info;

113:   TaoFunctionBegin;
114:   info = TaoGetVariableBounds(tao, &l, &u); CHKERRQ(info);
115:   f  = ssls->f;
116:   ff = ssls->ff;
117:   
118:   info = TaoComputeConstraints(tao, X, f); CHKERRQ(info);
119:   info = ff->Fischer(X, f, l, u); CHKERRQ(info);
120:   info = ff->Norm2(&ssls->merit); CHKERRQ(info);
121:   *fcn = 0.5*ssls->merit*ssls->merit;
122:   TaoFunctionReturn(0);
123: }

125: /*------------------------------------------------------------*/
128: int Tao_SSLS_FunctionGradient(TAO_SOLVER tao, TaoVec *X, double *fcn, 
129:                               TaoVec *G, void *solver)
130: {
131:   TAO_SSLS *ssls = (TAO_SSLS *)solver;
132:   TaoVec *f, *l, *u, *ff, *da, *db, *t1, *t2;
133:   TaoMat *J;
134:   int info;

136:   TaoFunctionBegin;
137:   info = TaoGetVariableBounds(tao, &l, &u); CHKERRQ(info);
138:   info = TaoGetJacobian(tao, &J); CHKERRQ(info);
139:   f  = ssls->f;
140:   ff = ssls->ff;
141:   da = ssls->da;
142:   db = ssls->db;
143:   t1 = ssls->t1;
144:   t2 = ssls->t2;

146:   info = TaoComputeConstraints(tao, X, f); CHKERRQ(info);
147:   info = ff->Fischer(X, f, l, u); CHKERRQ(info);
148:   info = ff->Norm2(&ssls->merit); CHKERRQ(info);
149:   *fcn = 0.5*ssls->merit*ssls->merit;

151:   info = TaoComputeJacobian(tao, X, J); CHKERRQ(info);
152:   info = J->D_Fischer(X, f, l, u, t1, t2, da, db); CHKERRQ(info);
153:   info = J->RowScale(db); CHKERRQ(info);
154:   info = J->AddDiagonal(da); CHKERRQ(info);
155:   info = J->MultiplyTranspose(ff, G); CHKERRQ(info);

157:   TaoFunctionReturn(0);
158: }

160: /*------------------------------------------------------------*/
163: int Tao_ASLS_FunctionGradient(TAO_SOLVER tao, TaoVec *X, double *fcn, 
164:                               TaoVec *G, void *solver)
165: {
166:   TAO_SSLS *asls = (TAO_SSLS *)solver;
167:   TaoVec *f, *l, *u, *ff, *da, *db, *t1, *t2;
168:   TaoMat *J;
169:   int info;

171:   TaoFunctionBegin;
172:   info = TaoGetVariableBounds(tao, &l, &u); CHKERRQ(info);
173:   info = TaoGetJacobian(tao, &J); CHKERRQ(info);
174:   f  = asls->f;
175:   ff = asls->ff;
176:   da = asls->da;
177:   db = asls->db;
178:   t1 = asls->t1;
179:   t2 = asls->t2;

181:   info = TaoComputeConstraints(tao, X, f); CHKERRQ(info);
182:   info = ff->Fischer(X, f, l, u); CHKERRQ(info);
183:   info = ff->Norm2(&asls->merit); CHKERRQ(info);
184:   *fcn = 0.5*asls->merit*asls->merit;

186:   info = TaoComputeJacobian(tao, X, J); CHKERRQ(info);
187:   info = J->D_Fischer(X, f, l, u, t1, t2, da, db); CHKERRQ(info);
188:   info = t1->PointwiseMultiply(ff, db);
189:   info = J->MultiplyTranspose(t1, G); CHKERRQ(info);
190:   info = t1->PointwiseMultiply(ff, da); CHKERRQ(info);
191:   info = G->Axpy(1.0, t1); CHKERRQ(info);
192:   TaoFunctionReturn(0);
193: }