Actual source code: taofloatapp.c
1: #include "src/tao_impl.h" /*I "tao_solver.h" I*/
2: #include "taofloatapp.h"
3: #include "src/vector/tvecsingle.h"
7: TaoABCFloatApplication::TaoABCFloatApplication(){
8: this->taox=0;
9: return;
10: }
15: TaoABCFloatApplication::~TaoABCFloatApplication(){
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 TaoABCFloatApplication::SetNumberOfVariables(int n){
42: TaoFunctionBegin;
43: this->taox = new TaoVecFloatArray(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 TaoABCFloatApplication::GetSolutionAndGradient(float* &x, float* &g, int &n){
62: int info, nn;
63: float *xx;
64: TaoFunctionBegin;
65: info = this->taox->GetFloats(&xx,&nn);CHKERRQ(info);
66: x=xx; n=nn;
67: g=0;
68: info = this->taox->RestoreFloats(&xx,&nn); CHKERRQ(info);
69: TaoFunctionReturn(0);
70: }
74: int TaoABCFloatApplication::GetVariableVector(TaoVec **xx){
76: TaoFunctionBegin;
77: *xx= this->taox;
78: TaoFunctionReturn(0);
79: }
84: int TaoABCFloatApplication::EvaluateObjectiveFunction(TaoVec *xx, double *ff){
85: TaoFunctionBegin;
86: TaoFunctionReturn(1);
87: }
92: int TaoABCFloatApplication::EvaluateGradient(TaoVec *tx, TaoVec *tg){
93: int info,n;
94: float *xptr,*gptr;
95: float ff;
96: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
97: TaoVecFloatArray* gg = (TaoVecFloatArray*)(tg);
98: TaoFunctionBegin;
99: info = xx->GetFloats(&xptr,&n);CHKERRQ(info);
100: info = gg->GetFloats(&gptr,&n);CHKERRQ(info);
101: info = this->ComputeObjectiveAndGradient(xptr,n,&ff,gptr);CHKERRQ(info);
102: info = gg->RestoreFloats(&gptr,&n);CHKERRQ(info);
103: info = xx->RestoreFloats(&xptr,&n); CHKERRQ(info);
104: TaoFunctionReturn(0);
105: }
110: int TaoABCFloatApplication::EvaluateObjectiveAndGradient(TaoVec *tx, double *ff, TaoVec *tg){
111: int info,n;
112: float *xptr, *gptr;
113: float f;
114: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
115: TaoVecFloatArray* gg = (TaoVecFloatArray*)(tg);
117: TaoFunctionBegin;
118: info = xx->GetFloats(&xptr,&n);CHKERRQ(info);
119: info = gg->GetFloats(&gptr,&n);CHKERRQ(info);
120: info = this->ComputeObjectiveAndGradient(xptr,n,&f,gptr);CHKERRQ(info);
121: info = gg->RestoreFloats(&gptr,&n);CHKERRQ(info);
122: info = xx->RestoreFloats(&xptr,&n); CHKERRQ(info);
123: *ff=(double)f;
124: TaoFunctionReturn(0);
125: }
130: /*@C
131: ComputeObjectiveAndGradient - Compute the objective function and its gradient.
133: Input Parameters:
134: . x - an array with the point at which the function and gradient should be evalutated.
135: . g - an array that will contain the gradient vector.
136: + n - the length of the arrays, which equals the number of variables
138: Output Parameters:
140: . f - function value
141: . g - gradient vector
143: Level: beginner
145: @*/
146: // virtual int TaoABCFloatApplication::ComputeObjectiveAndGradient(float*x,int n,float*f,float *g){}
151: /*@C
152: StartingPoint - Define the starting point for the solver.
154: Collective on TAO_SOLVER
156: Input Parameters:
157: + x - vector to store initial variables
158: - n - length of variable vector array
160: Note: This virtual method should be implemented in the application
161: if a starting point other than 0 is desired.
163: Level: beginner
165: @*/
166: int TaoABCFloatApplication::StartingPoint(float *x, int n){
167: int i;
168: TaoFunctionBegin;
169: for (i=0;i<n;i++) x[i]=0.0;
170: TaoFunctionReturn(0);
171: }
176: int TaoABCFloatApplication::InitializeVariables(TaoVec *tx){
177: int info,n;
178: float *xptr;
179: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
180: TaoFunctionBegin;
181: info = xx->GetFloats(&xptr,&n);CHKERRQ(info);
182: info = this->StartingPoint(xptr,n);CHKERRQ(info);
183: info = xx->RestoreFloats(&xptr,&n);CHKERRQ(info);
184: TaoFunctionReturn(0);
185: }
189: int TaoABCFloatApplication::EvaluateVariableBounds(TaoVec *txl, TaoVec *txu){
190: int info,n;
191: float *xl,*xu;
192: TaoVecFloatArray* xxll = (TaoVecFloatArray*)(txl);
193: TaoVecFloatArray* xxuu = (TaoVecFloatArray*)(txu);
195: TaoFunctionBegin;
196:
197: info = xxll->GetFloats(&xl,&n);CHKERRQ(info);
198: info = xxuu->GetFloats(&xu,&n);CHKERRQ(info);
199: info = this->ComputeVariableBounds(xl, xu,n);CHKERRQ(info);
200: info = xxuu->RestoreFloats(&xu,&n);CHKERRQ(info);
201: info = xxll->RestoreFloats(&xl,&n); CHKERRQ(info);
202:
203: TaoFunctionReturn(0);
204: }
209: /*@C
210: StartingPoint - Define the lower and upper bounds on the variables.
212: Collective on TAO_SOLVER
214: Input Parameters:
215: + xl - array to store lower bounds
216: . xu - array to store upper bounds
217: - n - length of these arrays, which equals the number of variables
219: Note: This virtual method should be implemented by the application
220: if there are lower or upper bounds on the variables.
222: Level: beginner
224: @*/
225: int TaoABCFloatApplication::ComputeVariableBounds(float *xl, float *xu, int n){
226: int i;
227: TaoFunctionBegin;
228: for (i=0;i<n;i++){
229: xl[i]=TAO_NINFINITY;
230: xu[i]=TAO_INFINITY;
231: }
232: TaoFunctionReturn(0);
233: }