1 /* _________________________________________________________________________
2 *
3 * Acro: A Common Repository for Optimizers
4 * Copyright (c) 2008 Sandia Corporation.
5 * This software is distributed under the BSD License.
6 * Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
7 * the U.S. Government retains certain rights in this software.
8 * For more information, see the README.txt file in the top Acro directory.
9 * _________________________________________________________________________
10 */
11
12 /**
13 * \file DirectFuncApplication.h
14 *
15 * Defines the colin::DirectFuncApplication class, along with
16 * template instances of the function colin::derived_compute_response,
17 * which are used by this class.
18 */
19
20 #ifndef colin_DirectFuncApplication_h
21 #define colin_DirectFuncApplication_h
22
23 #include <acro_config.h>
24 #include <colin/ConfigurableApplication.h>
25 #include <colin/SynchronousApplication.h>
26
27 namespace colin
28 {
29
30 /**
31 * This application class calls the function \c derived_compute_response to
32 * perform the evaluation of the user's objective function FuncT.
33 */
34 template <class ProblemT>
35 class DirectFuncApplication
36 : public Synchronous<ConfigurableApplication<ProblemT> >
37 {};
38
39
40 template <class ProblemT, class DomainT, class FuncT>
41 class DirectFuncApplicationImpl : public DirectFuncApplication<ProblemT>
42 {
43 public:
44
45 /// Generic constructor.
DirectFuncApplicationImpl(FuncT _fn)46 DirectFuncApplicationImpl(FuncT _fn)
47 { fn = _fn; }
48
49 protected:
50
51 /// Convert the domain supplied by the solver to the application domain
52 virtual bool
map_domain(const utilib::Any & src,utilib::Any & native,bool forward)53 map_domain(const utilib::Any &src, utilib::Any &native, bool forward) const
54 {
55 static_cast<void>(forward);
56 return utilib::TypeManager()->lexical_cast
57 (src, native, typeid(DomainT)) == 0;
58 }
59
60
61 virtual void
perform_evaluation_impl(const utilib::Any & domain,const AppRequest::request_map_t & requests,utilib::seed_t & seed,AppResponse::response_map_t & responses)62 perform_evaluation_impl( const utilib::Any &domain,
63 const AppRequest::request_map_t &requests,
64 utilib::seed_t &seed,
65 AppResponse::response_map_t &responses )
66 {
67 derived_compute_response(domain, requests, responses, seed, fn);
68 }
69
70 protected:
71 ///
72 FuncT fn;
73 };
74
75
76 ///
77 template <class FuncT>
derived_compute_response(const utilib::Any & domain,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,FuncT fn)78 void derived_compute_response
79 (const utilib::Any& domain,
80 const AppRequest::request_map_t& request_map,
81 AppResponse::response_map_t& response_map,
82 utilib::seed_t &seed,
83 FuncT fn)
84 {
85 EXCEPTION_MNGR(std::runtime_error, "Undefined direct application");
86 }
87
88
89
90
91 #if !defined(DOXYGEN)
92
93 ///
derived_compute_response(const utilib::Any & domain,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const utilib::Any &,const AppRequest::request_map_t &,AppResponse::response_map_t &,utilib::seed_t &))94 inline void derived_compute_response
95 (const utilib::Any& domain,
96 const AppRequest::request_map_t& request_map,
97 AppResponse::response_map_t& response_map,
98 utilib::seed_t &seed,
99 void(*eval_fn)(const utilib::Any& ,
100 const AppRequest::request_map_t& ,
101 AppResponse::response_map_t&,
102 utilib::seed_t&))
103 {
104 (*eval_fn)(domain, request_map, response_map, seed);
105 }
106
107
108
109
110 ///
111 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,double (* eval_fn)(DomainT &))112 void derived_compute_response
113 (const utilib::Any& point,
114 const AppRequest::request_map_t& request_map,
115 AppResponse::response_map_t& response_map,
116 utilib::seed_t &seed,
117 double(*eval_fn)(DomainT&))
118 {
119 AppRequest::request_map_t::const_iterator it;
120
121 if ((it = request_map.find(f_info)) != request_map.end())
122 {
123 seed = 0; // this form doesn't support random seeds
124 const DomainT& pt = utilib::anyref_cast<DomainT>(point);
125 response_map.insert( AppResponse::response_pair_t
126 ( f_info, (*eval_fn)(const_cast<DomainT&>(pt)) ) );
127 }
128 }
129
130
131 ///
132 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,double (* eval_fn)(const DomainT &))133 void derived_compute_response
134 (const utilib::Any& point,
135 const AppRequest::request_map_t& request_map,
136 AppResponse::response_map_t& response_map,
137 utilib::seed_t &seed,
138 double(*eval_fn)(const DomainT&))
139 {
140 AppRequest::request_map_t::const_iterator it;
141
142 if ((it = request_map.find(f_info)) != request_map.end())
143 {
144 seed = 0; // this form doesn't support random seeds
145 response_map.insert( AppResponse::response_pair_t
146 ( f_info, (*eval_fn)(point.expose<DomainT>()) ) );
147 }
148 }
149
150
151 ///
152 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(DomainT &,double &))153 void derived_compute_response
154 (const utilib::Any& point,
155 const AppRequest::request_map_t& request_map,
156 AppResponse::response_map_t& response_map,
157 utilib::seed_t &seed,
158 void(*eval_fn)(DomainT&, double&))
159 {
160 AppRequest::request_map_t::const_iterator it;
161
162 if ((it = request_map.find(f_info)) != request_map.end())
163 {
164 seed = 0; // this form doesn't support random seeds
165 utilib::Any f_ans;
166 real& tmp = f_ans.set<real>();
167 double ans;
168 (*eval_fn)(point.expose<DomainT>(), ans);
169 tmp = ans;
170 response_map.insert(std::make_pair(f_info, f_ans));
171 }
172 }
173
174
175 ///
176 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const DomainT &,double &))177 void derived_compute_response
178 (const utilib::Any& point,
179 const AppRequest::request_map_t& request_map,
180 AppResponse::response_map_t& response_map,
181 utilib::seed_t &seed,
182 void(*eval_fn)(const DomainT&, double&))
183 {
184 AppRequest::request_map_t::const_iterator it;
185
186 if ((it = request_map.find(f_info)) != request_map.end())
187 {
188 seed = 0; // this form doesn't support random seeds
189 utilib::Any f_ans;
190 real& tmp = f_ans.set<real>();
191 double ans;
192 (*eval_fn)(point.expose<DomainT>(), ans);
193 tmp = ans;
194 response_map.insert(std::make_pair(f_info, f_ans));
195 }
196 }
197
198
199 ///
200 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(DomainT &,real &))201 void derived_compute_response
202 (const utilib::Any& point,
203 const AppRequest::request_map_t& request_map,
204 AppResponse::response_map_t& response_map,
205 utilib::seed_t &seed,
206 void(*eval_fn)(DomainT&, real&))
207 {
208 AppRequest::request_map_t::const_iterator it;
209
210 if ((it = request_map.find(f_info)) != request_map.end())
211 {
212 seed = 0; // this form doesn't support random seeds
213 utilib::Any f_ans;
214 real& tmp = f_ans.set<real>();
215 const DomainT& pt = utilib::anyref_cast<DomainT>(point);
216 (*eval_fn)(const_cast<DomainT&>(pt), tmp);
217 response_map.insert(std::make_pair(f_info, f_ans));
218 }
219 }
220
221
222 ///
223 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const DomainT &,real &))224 void derived_compute_response
225 (const utilib::Any& point,
226 const AppRequest::request_map_t& request_map,
227 AppResponse::response_map_t& response_map,
228 utilib::seed_t &seed,
229 void(*eval_fn)(const DomainT&, real&))
230 {
231 AppRequest::request_map_t::const_iterator it;
232 if ((it = request_map.find(f_info)) != request_map.end())
233 {
234 seed = 0; // this form doesn't support random seeds
235 utilib::Any f_ans;
236 real& tmp = f_ans.set<real>();
237 (*eval_fn)(point.expose<DomainT>(), tmp);
238 response_map.insert(std::make_pair(f_info, f_ans));
239 }
240 }
241
242
243 ///
244 template <class DomainT, class CArrayT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(DomainT &,real &,CArrayT &))245 void derived_compute_response
246 (const utilib::Any& point,
247 const AppRequest::request_map_t& request_map,
248 AppResponse::response_map_t& response_map,
249 utilib::seed_t &seed,
250 void(*eval_fn)(DomainT&, real&, CArrayT&))
251 {
252 AppRequest::request_map_t::const_iterator it;
253
254 if (((it = request_map.find(f_info)) != request_map.end()) ||
255 ((it = request_map.find(nlcf_info)) != request_map.end()))
256 {
257 seed = 0; // this form doesn't support random seeds
258 utilib::Any f_ans;
259 utilib::Any nlcf_ans;
260 real& tmp = f_ans.set<real>();
261 CArrayT& ctmp = nlcf_ans.set<CArrayT>();
262 (*eval_fn)(point.expose<DomainT>(), tmp, ctmp);
263 response_map.insert(std::make_pair(f_info, f_ans));
264 response_map.insert(std::make_pair(nlcf_info, nlcf_ans));
265 }
266 // As this problem type supports linear consrtaints, we MUST
267 // return an empty lcf_info if asked for
268 if ( request_map.find(lcf_info) != request_map.end() )
269 response_map[lcf_info].set<CArrayT>();
270 }
271
272
273 ///
274 template <class DomainT, class CArrayT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const DomainT &,real &,CArrayT &))275 void derived_compute_response
276 (const utilib::Any& point,
277 const AppRequest::request_map_t& request_map,
278 AppResponse::response_map_t& response_map,
279 utilib::seed_t &seed,
280 void(*eval_fn)(const DomainT&, real&, CArrayT&))
281 {
282 AppRequest::request_map_t::const_iterator it;
283
284 if (((it = request_map.find(f_info)) != request_map.end()) ||
285 ((it = request_map.find(nlcf_info)) != request_map.end()))
286 {
287 seed = 0; // this form doesn't support random seeds
288 utilib::Any f_ans;
289 utilib::Any nlcf_ans;
290 real& tmp = f_ans.set<real>();
291 CArrayT& ctmp = nlcf_ans.set<CArrayT>();
292 (*eval_fn)(point.expose<DomainT>(), tmp, ctmp);
293 response_map.insert(std::make_pair(f_info, f_ans));
294 response_map.insert(std::make_pair(nlcf_info, nlcf_ans));
295 }
296 // As this problem type supports linear consrtaints, we MUST
297 // return an empty lcf_info if asked for
298 if ( request_map.find(lcf_info) != request_map.end() )
299 response_map.insert(AppResponse::response_pair_t(lcf_info, CArrayT()));
300 }
301
302
303 ///
304 template <class DomainT, class CArrayT, class GArrayT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(DomainT &,int,real &,CArrayT &,GArrayT &))305 void derived_compute_response
306 (const utilib::Any& point,
307 const AppRequest::request_map_t& request_map,
308 AppResponse::response_map_t& response_map,
309 utilib::seed_t &seed,
310 void(*eval_fn)(DomainT&, int, real&, CArrayT&, GArrayT&))
311 {
312 AppRequest::request_map_t::const_iterator it;
313
314 int ctr = 0;
315 if ((it = request_map.find(f_info)) != request_map.end())
316 ctr += 1;
317 if ((it = request_map.find(nlcf_info)) != request_map.end())
318 ctr += 2;
319 if ((it = request_map.find(g_info)) != request_map.end())
320 ctr += 4;
321
322 if (ctr > 0)
323 {
324 seed = 0; // this form doesn't support random seeds
325
326 /// JDS: you can't do the following: if you are using a caching
327 /// system, this will result in inserting empty vectors into the
328 /// cache if the function actually listened to the 'ctr' ASV.
329
330 //real& tmp = response_map[f_info].set<real>();
331 //CArrayT& ctmp = response_map[nlcf_info].set<CArrayT>();
332 //GArrayT& gtmp = response_map[g_info].set<GArrayT>();
333 //(*eval_fn)(point.expose<DomainT>(),ctr,tmp,ctmp,gtmp);
334
335 // JDS: instead, do the following:
336 // (it also has a side benefit of saving a copy)
337 utilib::Any f_ans;
338 utilib::Any cf_ans;
339 utilib::Any g_ans;
340 real& tmp = f_ans.set<real>();
341 CArrayT& ctmp = cf_ans.set<CArrayT>();
342 GArrayT& gtmp = g_ans.set<GArrayT>();
343
344 (*eval_fn)(point.expose<DomainT>(), ctr, tmp, ctmp, gtmp);
345
346 if (ctr & 1)
347 response_map.insert(AppResponse::response_pair_t(f_info, f_ans));
348 if ((ctr & 2) || ! ctmp.empty())
349 response_map.insert(AppResponse::response_pair_t(nlcf_info, cf_ans));
350 if ((ctr & 4) || ! gtmp.empty())
351 response_map.insert(AppResponse::response_pair_t(g_info, g_ans));
352 }
353
354 // As this problem type supports linear consrtaints, we MUST
355 // return an empty lcf_info if asked for
356 if ( request_map.find(lcf_info) != request_map.end() )
357 response_map.insert(AppResponse::response_pair_t(lcf_info, CArrayT()));
358
359 }
360
361
362 ///
363 template <class DomainT, class CArrayT, class GArrayT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const DomainT &,int,real &,CArrayT &,GArrayT &))364 void derived_compute_response
365 (const utilib::Any& point,
366 const AppRequest::request_map_t& request_map,
367 AppResponse::response_map_t& response_map,
368 utilib::seed_t &seed,
369 void(*eval_fn)(const DomainT&, int, real&, CArrayT&, GArrayT&))
370 {
371 AppRequest::request_map_t::const_iterator it;
372
373 int ctr = 0;
374 if ((it = request_map.find(f_info)) != request_map.end())
375 ctr += 1;
376 if ((it = request_map.find(nlcf_info)) != request_map.end())
377 ctr += 2;
378 if ((it = request_map.find(g_info)) != request_map.end())
379 ctr += 4;
380
381 if (ctr > 0)
382 {
383 seed = 0; // this form doesn't support random seeds
384
385 /// JDS: you can't do the following: if you are using a caching
386 /// system, this will result in inserting empty vectors into the
387 /// cache if the function actually listened to the 'ctr' ASV.
388
389 //real tmp;
390 //CArrayT ctmp;
391 //GArrayT gtmp;
392 //(*eval_fn)(point.expose<DomainT>(),ctr,tmp,ctmp,gtmp);
393 //utilib::TypeManager()->lexical_cast(tmp, response_map[f_info].data);
394 //utilib::TypeManager()->lexical_cast(ctmp, response_map[nlcf_info].data);
395 //utilib::TypeManager()->lexical_cast(gtmp, response_map[g_info].data);
396
397 // JDS: instead, do the following:
398 // (it also has a side benefit of saving a copy)
399 utilib::Any f_ans;
400 utilib::Any cf_ans;
401 utilib::Any g_ans;
402 real& tmp = f_ans.set<real>();
403 CArrayT& ctmp = cf_ans.set<CArrayT>();
404 GArrayT& gtmp = g_ans.set<GArrayT>();
405
406 (*eval_fn)(point.expose<DomainT>(), ctr, tmp, ctmp, gtmp);
407
408 if (ctr & 1)
409 response_map.insert(AppResponse::response_pair_t(f_info, f_ans));
410 if ((ctr & 2) || ! ctmp.empty())
411 response_map.insert(AppResponse::response_pair_t(nlcf_info, cf_ans));
412 if ((ctr & 4) || ! gtmp.empty())
413 response_map.insert(AppResponse::response_pair_t(g_info, g_ans));
414 }
415
416 // As this problem type supports linear consrtaints, we MUST
417 // return an empty lcf_info if asked for
418 if ( request_map.find(lcf_info) != request_map.end() )
419 response_map.insert(AppResponse::response_pair_t(lcf_info, CArrayT()));
420 }
421
422
423 ///
424 template <class DomainT, class CArrayT, class GArrayT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(DomainT &,int,real &,CArrayT &,CArrayT &,GArrayT &))425 void derived_compute_response
426 (const utilib::Any& point,
427 const AppRequest::request_map_t& request_map,
428 AppResponse::response_map_t& response_map,
429 utilib::seed_t &seed,
430 void(*eval_fn)(DomainT&, int, real&, CArrayT&, CArrayT&, GArrayT&))
431 {
432 AppRequest::request_map_t::const_iterator it;
433
434 int ctr = 0;
435 if ((it = request_map.find(f_info)) != request_map.end())
436 ctr += 1;
437 if ((it = request_map.find(nlcf_info)) != request_map.end())
438 ctr += 2;
439 if ((it = request_map.find(g_info)) != request_map.end())
440 ctr += 4;
441 if ((it = request_map.find(lcf_info)) != request_map.end())
442 ctr += 8;
443
444 if (ctr > 0)
445 {
446 seed = 0; // this form doesn't support random seeds
447
448 /// JDS: you can't do the following: if you are using a caching
449 /// system, this will result in inserting empty vectors into the
450 /// cache if the function actually listened to the 'ctr' ASV.
451
452 //real& tmp = response_map[f_info].set<real>();
453 //CArrayT& ctmp = response_map[cf_info].set<CArrayT>();
454 //GArrayT& gtmp = response_map[g_info].set<GArrayT>();
455 //(*eval_fn)(point.expose<DomainT>(),ctr,tmp,ctmp,gtmp);
456
457 // JDS: instead, do the following:
458 // (it also has a side benefit of saving a copy)
459 utilib::Any f_ans;
460 utilib::Any cf_ans;
461 utilib::Any lcf_ans;
462 utilib::Any g_ans;
463 real& tmp = f_ans.set<real>();
464 CArrayT& lctmp = lcf_ans.set<CArrayT>();
465 CArrayT& nlctmp = cf_ans.set<CArrayT>();
466 GArrayT& gtmp = g_ans.set<GArrayT>();
467
468 (*eval_fn)(point.expose<DomainT>(), ctr, tmp, lctmp, nlctmp, gtmp);
469
470 if (ctr & 1)
471 response_map.insert(AppResponse::response_pair_t(f_info, f_ans));
472 if ((ctr & 2) || ! nlctmp.empty())
473 response_map.insert(std::make_pair(nlcf_info, cf_ans));
474 if ((ctr & 8) || ! lctmp.empty())
475 response_map.insert(std::make_pair(lcf_info, lcf_ans));
476 if ((ctr & 4) || ! gtmp.empty())
477 response_map.insert(std::make_pair(g_info, g_ans));
478 }
479 }
480
481 ///
482 template <class DomainT, class CArrayT, class GArrayT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const DomainT &,int,real &,CArrayT &,CArrayT &,GArrayT &))483 void derived_compute_response
484 (const utilib::Any& point,
485 const AppRequest::request_map_t& request_map,
486 AppResponse::response_map_t& response_map,
487 utilib::seed_t &seed,
488 void(*eval_fn)(const DomainT&, int, real&, CArrayT&, CArrayT&, GArrayT&))
489 {
490 AppRequest::request_map_t::const_iterator it;
491
492 int ctr = 0;
493 if ((it = request_map.find(f_info)) != request_map.end())
494 ctr += 1;
495 if ((it = request_map.find(nlcf_info)) != request_map.end())
496 ctr += 2;
497 if ((it = request_map.find(g_info)) != request_map.end())
498 ctr += 4;
499 if ((it = request_map.find(lcf_info)) != request_map.end())
500 ctr += 8;
501
502 if (ctr > 0)
503 {
504 seed = 0; // this form doesn't support random seeds
505
506 /// JDS: you can't do the following: if you are using a caching
507 /// system, this will result in inserting empty vectors into the
508 /// cache if the function actually listened to the 'ctr' ASV.
509
510 //real& tmp = response_map[f_info].set<real>();
511 //CArrayT& ctmp = response_map[cf_info].set<CArrayT>();
512 //GArrayT& gtmp = response_map[g_info].set<GArrayT>();
513 //(*eval_fn)(point.expose<DomainT>(),ctr,tmp,ctmp,gtmp);
514
515 // JDS: instead, do the following:
516 // (it also has a side benefit of saving a copy)
517 utilib::Any f_ans;
518 utilib::Any nlcf_ans;
519 utilib::Any lcf_ans;
520 utilib::Any g_ans;
521 real& tmp = f_ans.set<real>();
522 CArrayT& lctmp = lcf_ans.set<CArrayT>();
523 CArrayT& nlctmp = nlcf_ans.set<CArrayT>();
524 GArrayT& gtmp = g_ans.set<GArrayT>();
525
526 (*eval_fn)(point.expose<DomainT>(), ctr, tmp, lctmp, nlctmp, gtmp);
527
528 if (ctr & 1)
529 response_map.insert(std::make_pair(f_info, f_ans));
530 if ((ctr & 2) || ! nlctmp.empty())
531 response_map.insert(std::make_pair(nlcf_info, nlcf_ans));
532 if ((ctr & 8) || ! lctmp.empty())
533 response_map.insert(std::make_pair(lcf_info, lcf_ans));
534 if ((ctr & 4) || ! gtmp.empty())
535 response_map.insert(std::make_pair(g_info, g_ans));
536 }
537 }
538
539
540 ///
541 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(DomainT &,real &,utilib::seed_t))542 void derived_compute_response
543 (const utilib::Any& point,
544 const AppRequest::request_map_t& request_map,
545 AppResponse::response_map_t& response_map,
546 utilib::seed_t &seed,
547 void(*eval_fn)(DomainT&, real&, utilib::seed_t))
548 {
549 AppRequest::request_map_t::const_iterator it;
550
551 if ((it = request_map.find(f_info)) != request_map.end())
552 {
553 utilib::Any f_ans;
554 real& tmp = f_ans.set<real>();
555 (*eval_fn)(const_cast<DomainT&>(point.expose<DomainT>()), tmp, seed);
556 response_map.insert(std::make_pair(f_info, f_ans));
557 }
558 }
559
560
561 ///
562 template <class DomainT>
derived_compute_response(const utilib::Any & point,const AppRequest::request_map_t & request_map,AppResponse::response_map_t & response_map,utilib::seed_t & seed,void (* eval_fn)(const DomainT &,real &,utilib::seed_t))563 void derived_compute_response
564 (const utilib::Any& point,
565 const AppRequest::request_map_t& request_map,
566 AppResponse::response_map_t& response_map,
567 utilib::seed_t &seed,
568 void(*eval_fn)(const DomainT&, real&, utilib::seed_t))
569 {
570 AppRequest::request_map_t::const_iterator it;
571
572 if ((it = request_map.find(f_info)) != request_map.end())
573 {
574 utilib::Any f_ans;
575 real& tmp = f_ans.set<real>();
576 (*eval_fn)(point.expose<DomainT>(), tmp, seed);
577 response_map.insert(std::make_pair(f_info, f_ans));
578 }
579 }
580
581
582
583
584 }
585
586 #endif
587 #endif
588