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:   TaoInt n;
 12:   int info;

 14:   TaoFunctionBegin;

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

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

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

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

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

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

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

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

 54:   TaoFunctionBegin;

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

 69:   TaoFunctionReturn(0);
 70: }

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

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

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

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

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

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

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

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

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

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

158:   TaoFunctionReturn(0);
159: }

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

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

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

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