Actual source code: taoabcapp.c
1: #include "src/tao_impl.h" /*I "tao_solver.h" I*/
2: #include "taoabcapp.h"
3: #include "src/vector/tvecdouble.h"
7: TaoABCApplication::TaoABCApplication(){
8: this->taox=0;
9: return;
10: }
15: TaoABCApplication::~TaoABCApplication(){
16: int info;
17: info = TaoVecDestroy(this->taox);
18: if (info) return;
19: return;
20: }
25: /* @C
26: SetDimension - Set the number of variables in this application.
28: Input Parameters:
29: . n - the number of variables
31: Note: This method should be called only once and be called before
32: the application is set to the solver.
34: Note: This routine creates a variables vector. Applications derived
35: from this object may create a TaoVec object and set the 'taox' field
36: another way.
38: Level: beginner
40: @ */
41: int TaoABCApplication::SetNumberOfVariables(int n){
42: TaoFunctionBegin;
43: this->taox = new TaoVecDoubleArray(n);
44: TaoFunctionReturn(0);
45: }
49: /* @C
50: GetSolutionAndGradient - Get the solution and and gradient arrays.
52: Output Parameters:
54: + n - the length of the arrays, which equals the number of variables
55: . x - variables vector
56: - g - gradient vector
58: Level: beginner
60: @ */
61: int TaoABCApplication::GetSolution(double* &x, int &n){
62: int info, nn;
63: double *xx;
64: TaoFunctionBegin;
65: info = this->taox->GetDoubles(&xx,&nn);CHKERRQ(info);
66: x=xx; n=nn;
67: info = this->taox->RestoreDoubles(&xx,&nn); CHKERRQ(info);
68: TaoFunctionReturn(0);
69: }
73: int TaoABCApplication::GetVariableVector(TaoVec **xx){
75: TaoFunctionBegin;
76: *xx= this->taox;
77: TaoFunctionReturn(0);
78: }
83: int TaoABCApplication::EvaluateObjectiveFunction(TaoVec *xx, double *ff){
84: TaoFunctionBegin;
85: TaoFunctionReturn(1);
86: }
91: int TaoABCApplication::EvaluateGradient(TaoVec *tx, TaoVec *tg){
92: int info,n;
93: double *xptr,*gptr;
94: double ff;
95: TaoVecDoubleArray *xx=(TaoVecDoubleArray*)tx, *gg=(TaoVecDoubleArray*)tg;
96: TaoFunctionBegin;
97: info = xx->GetDoubles(&xptr,&n);CHKERRQ(info);
98: info = gg->GetDoubles(&gptr,&n);CHKERRQ(info);
99: info = this->ComputeObjectiveAndGradient(xptr,n,&ff,gptr);CHKERRQ(info);
100: info = gg->RestoreDoubles(&gptr,&n);CHKERRQ(info);
101: info = xx->RestoreDoubles(&xptr,&n); CHKERRQ(info);
102: TaoFunctionReturn(0);
103: }
108: int TaoABCApplication::EvaluateObjectiveAndGradient(TaoVec *tx, double *ff, TaoVec *tg){
109: int info,n;
110: double *xptr, *gptr;
111: TaoVecDoubleArray *xx=(TaoVecDoubleArray*)tx, *gg=(TaoVecDoubleArray*)tg;
113: TaoFunctionBegin;
114: info = xx->GetDoubles(&xptr,&n);CHKERRQ(info);
115: info = gg->GetDoubles(&gptr,&n);CHKERRQ(info);
116: info = this->ComputeObjectiveAndGradient(xptr,n,ff,gptr);CHKERRQ(info);
117: info = gg->RestoreDoubles(&gptr,&n);CHKERRQ(info);
118: info = xx->RestoreDoubles(&xptr,&n); CHKERRQ(info);
119: TaoFunctionReturn(0);
120: }
125: /*@C
126: ComputeObjectiveAndGradient - Compute the objective function and its gradient.
128: Input Parameters:
129: . x - an array with the point at which the function and gradient should be evalutated.
130: . g - an array that will contain the gradient vector.
131: + n - the length of the arrays, which equals the number of variables
133: Output Parameters:
135: . f - function value
136: . g - gradient vector
138: Level: beginner
140: @*/
141: // virtual int TaoABCApplication::ComputeObjectiveAndGradient(double*x,int n,double*f,double *g){}
146: /*@C
147: StartingPoint - Define the starting point for the solver.
149: Collective on TAO_SOLVER
151: Input Parameters:
152: + x - vector to store initial variables
153: - n - length of variable vector array
155: Note: This virtual method should be implemented in the application
156: if a starting point other than 0 is desired.
158: Level: beginner
160: @*/
161: int TaoABCApplication::StartingPoint(double *x, int n){
162: int i;
163: TaoFunctionBegin;
164: for (i=0;i<n;i++) x[i]=0.0;
165: TaoFunctionReturn(0);
166: }
171: int TaoABCApplication::InitializeVariables(TaoVec *tx){
172: int info,n;
173: double *xptr;
174: TaoVecDoubleArray *xx=(TaoVecDoubleArray*)tx;
175: TaoFunctionBegin;
176: info = xx->GetDoubles(&xptr,&n);CHKERRQ(info);
177: info = this->StartingPoint(xptr,n);CHKERRQ(info);
178: info = xx->RestoreDoubles(&xptr,&n);CHKERRQ(info);
179: TaoFunctionReturn(0);
180: }
184: int TaoABCApplication::EvaluateVariableBounds(TaoVec *txl, TaoVec *txu){
185: int info,n;
186: double *xl,*xu;
187: TaoVecDoubleArray *xxll=(TaoVecDoubleArray*)txl, *xxuu=(TaoVecDoubleArray*)txu;
188: TaoFunctionBegin;
189:
190: info = xxll->GetDoubles(&xl,&n);CHKERRQ(info);
191: info = xxuu->GetDoubles(&xu,&n);CHKERRQ(info);
192: info = this->ComputeVariableBounds(xl, xu,n);CHKERRQ(info);
193: info = xxll->RestoreDoubles(&xu,&n);CHKERRQ(info);
194: info = xxuu->RestoreDoubles(&xl,&n); CHKERRQ(info);
196: TaoFunctionReturn(0);
197: }
202: /*@C
203: StartingPoint - Define the lower and upper bounds on the variables.
205: Collective on TAO_SOLVER
207: Input Parameters:
208: + xl - array to store lower bounds
209: . xu - array to store upper bounds
210: - n - length of these arrays, which equals the number of variables
212: Note: This virtual method should be implemented by the application
213: if there are lower or upper bounds on the variables.
215: Level: beginner
217: @*/
218: int TaoABCApplication::ComputeVariableBounds(double *xl, double *xu, int n){
219: int i;
220: TaoFunctionBegin;
221: for (i=0;i<n;i++){
222: xl[i]=TAO_NINFINITY;
223: xu[i]=TAO_INFINITY;
224: }
225: TaoFunctionReturn(0);
226: }