COCONUT API: diffI_evaluator.h Source File

00001 // diffI Evaluator implementation -*- C++ -*-
00002 
00003 // $Id: diffI_evaluator.h 922 2009-11-12 17:06:54Z mihaly $
00004 // Copyright (C) 2001-2003 Hermann Schichl
00005 //
00006 // This file is part of the COCONUT API.  This library
00007 // is free software; you can redistribute it and/or modify it under the
00008 // terms of the Library GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // Library GNU General Public License for more details.
00016 
00017 // As a special exception, you may use this file as part of a free software
00018 // library without restriction.  Specifically, if other files instantiate
00019 // templates or use macros or inline functions from this file, or you compile
00020 // this file and link it with other files to produce an executable, this
00021 // file does not by itself cause the resulting executable to be covered by
00022 // the Library GNU General Public License.  This exception does not however
00023 // invalidate any other reasons why the executable file might be covered by
00024 // the Library GNU General Public License.
00025 
00028 #ifndef _DIFFI_EVALUATOR_H_
00029 #define _DIFFI_EVALUATOR_H_
00030 
00031 #include <coconut_config.h>
00032 #include <evaluator.h>
00033 #include <expression.h>
00034 #include <model.h>
00035 #include <eval_main.h>
00036 #include <linalg.h>
00037 #include <math.h>
00038 #include <api_exception.h>
00039 #include <diffI.h>
00040 
00041 using namespace vgtl;
00042 
00043 namespace coco {
00044 
00046 typedef diffI (*diffI_evaluator)(const std::vector<diffI>* __x,
00047                                  const variable_indicator& __v);
00048 
00050 
00055 //typedef diffI diffI_eval_rettype;
00056 
00057 struct diffI_eval_type
00058 {
00059   const std::vector<diffI>* x;
00060   std::vector<diffI>* cache;    
00061   const model* mod;     
00062   void *p;              
00063   diffI r;        
00064   unsigned int n;        
00065   int maxdeg;            
00066 };      
00067 
00069 
00075 class diffI_eval :
00076   public cached_forward_evaluator_base<diffI_eval_type,expression_node,
00077                                        diffI,
00078                                        expression_const_walker>
00079 {
00080 private:
00081 //  typedef diffI retval;
00082   typedef cached_forward_evaluator_base<diffI_eval_type,expression_node,
00083                                         diffI, expression_const_walker> _Base;
00084 
00085 protected:
00088   bool is_cached(const node_data_type& __data)
00089   { std::cout<<"diffI_evaluator.is_cached\n";
00090     if(__data.operator_type == EXPRINFO_LIN ||
00091        __data.operator_type == EXPRINFO_QUAD)
00092       return true;
00093     else
00094       return false;
00095 #if 0
00096     if(eval_data.cache && __data.n_parents > 1 && __data.n_children > 0)
00097       return true;
00098     else
00099       return false;
00100 #endif
00101   }
00102 
00103 private:
00106   diffI __power(double __coeff, diffI __x, int __exp)
00107   {
00108     if(__exp == 0)
00109       return 1.;
00110     else
00111     {
00112       diffI k = __coeff*__x;
00113       switch(__exp)
00114       {
00115         case 1:
00116           return k;
00117           break;
00118         case 2:
00119           return k*k;
00120           break;
00121         case -1:
00122           return 1./k;
00123           break;
00124         case -2:
00125           return 1./(k*k);
00126           break;
00127         default:
00128    //       return ipow(k, __exp);
00129           break;
00130       }
00131     }
00132     return diffI(0,eval_data.maxdeg);           // we never come here!
00133   }  
00134   
00135 public:
00143   diffI_eval(const std::vector<diffI>& __x, const variable_indicator& __v,
00144             const model& __m, std::vector<diffI>* __c, int __maxd) : _Base()
00145   {
00146     std::cout<<"diffI_eval\n";
00147     eval_data.x = &__x;
00148     eval_data.cache = __c;
00149     eval_data.mod = &__m;
00150     v_ind = &__v;
00151     eval_data.n = 0;
00152     eval_data.maxdeg=__maxd;
00153     eval_data.r.setDeg(__maxd);
00154     eval_data.r=diffI(0.,__maxd);
00155   }
00156 
00158   diffI_eval(const diffI_eval& __v) : _Base(__v) {}
00159   
00161   ~diffI_eval() {}
00162 
00164   expression_const_walker short_cut_to(const expression_node& __data)
00165   { 
00166           std::cout<<"short_cut_to\n";
00167           return eval_data.mod->node(0); }    // return anything
00168 
00172   void new_interval(const std::vector<diffI>& __x, const variable_indicator& __v)
00173   {
00174     eval_data.x = &__x;
00175     v_ind = &__v;
00176   }       
00177   
00179 
00180   void initialize() { return; }
00181   
00182   int initialize(const expression_node& __data)
00183   {
00184     std::cout<<"initialize\n";
00185     eval_data.n = 0;
00186     if(__data.ev && (*__data.ev)[FUNC_RANGE])
00187     // is there a short-cut evaluator defined?
00188     {
00189       eval_data.r =
00190         (*(diffI_evaluator)(*__data.ev)[FUNC_RANGE])(eval_data.x,
00191                                                                  *v_ind);
00192       return 0;     // don't perform the remaining graph walk
00193     }
00194     else
00195     {
00196       switch(__data.operator_type)
00197       {
00198         case EXPRINFO_VARIABLE:
00199           std::cout<<"variable "<<__data.params.nn()<<"\n";
00200           eval_data.r = (*eval_data.x)[__data.params.nn()];
00201           break;
00202         case EXPRINFO_SUM:
00203         case EXPRINFO_PROD:
00204         case EXPRINFO_MAX:
00205         case EXPRINFO_MIN:
00206         case EXPRINFO_INVERT:
00207         case EXPRINFO_DIV:
00208           eval_data.r = diffI(__data.params.nd(),eval_data.maxdeg);
00209           break;
00210         case EXPRINFO_MONOME:
00211         case EXPRINFO_IN:
00212         case EXPRINFO_AND:
00213         case EXPRINFO_NOGOOD:
00214           eval_data.r = diffI(1.,eval_data.maxdeg);
00215           break;
00216         case EXPRINFO_ALLDIFF:
00217    //       eval_data.u.p = (void*) new std::vector<interval>;
00218    //       ((std::vector<interval>*)eval_data.u.p)->reserve(__data.n_children);
00219           // no break!
00220         case EXPRINFO_MEAN:
00221         case EXPRINFO_IF:
00222         case EXPRINFO_OR:
00223         case EXPRINFO_NOT:
00224         case EXPRINFO_COUNT:
00225         case EXPRINFO_SCPROD:
00226         case EXPRINFO_NORM:
00227         case EXPRINFO_LEVEL:
00228           eval_data.r = diffI(0.,eval_data.maxdeg);
00229           break;
00230         case EXPRINFO_DET:
00231         case EXPRINFO_PSD:
00232           // here construct square interval matrix
00233           break;
00234         case EXPRINFO_COND:
00235         case EXPRINFO_FEM:
00236         case EXPRINFO_MPROD:
00237           // here construct rectangular interval matrix
00238           break;
00239       }
00240       return 1;
00241     }
00242   }
00243 
00244   void calculate(const expression_node& __data)
00245   {
00246    if(__data.operator_type > 0){
00247         std::cout<<"diffI_evaluator.calculate\n";
00248    }
00249   }
00250 
00251   void retrieve_from_cache(const expression_node& __data)
00252   {
00253    std::cout<<"diffI_evaluator.retrieve_from_cache\n";
00254   }
00255 
00256   int update(const diffI& __rval)
00257   {
00258     std::cout<<"diffI_evaluator.update\n";
00259     eval_data.r = __rval;
00260     return 0;
00261   }
00262 
00263   int update(const expression_node& __data, const diffI& __rval)
00264   {
00265     std::cout<<"diffI_evaluator.update2 ";
00266     std::cout<<__rval<<"\n";
00267           
00268     diffI __x(0.,eval_data.maxdeg);
00269     int ret = 0;
00270     if(__data.operator_type < 0)
00271     {
00272       switch(__data.operator_type)
00273       {
00274         case EXPRINFO_CONSTANT:
00275         case EXPRINFO_VARIABLE:
00276           break;
00277         case EXPRINFO_SUM:
00278         case EXPRINFO_MEAN:
00279         std::cout<<"sum: "<<eval_data.r<<" -> ";        
00280           eval_data.r = eval_data.r + __data.coeffs[eval_data.n++]*__rval;
00281         std::cout<<eval_data.r<<"\n";
00282           break;
00283         case EXPRINFO_PROD:
00284           // the coefficients MUST be collected in __data.params.nd()
00285         std::cout<<"prod";
00286           eval_data.r = eval_data.r * __rval;
00287         //  if(eval_data.r == diffI(0,4)) ret=-1;
00288           break;
00289         case EXPRINFO_MONOME:
00290         std::cout<<"monome";    
00291           eval_data.r = eval_data.r * __power(__data.coeffs[eval_data.n],
00292                         __rval, __data.params.n()[eval_data.n]);
00293         //  if(eval_data.r == diffI(0,4)) ret=-1;
00294           eval_data.n++;
00295           break;
00296     /*    case EXPRINFO_MAX:
00297           __x = __rval * __data.coeffs[eval_data.n++];
00298           if(__x > eval_data.r)
00299             eval_data.r = __x;
00300           break;
00301         case EXPRINFO_MIN:
00302           __x = __rval * __data.coeffs[eval_data.n++];
00303           if(__x < eval_data.r)
00304             eval_data.r = __x;
00305           break; */
00306   /*      case EXPRINFO_SCPROD:
00307           { double h = __data.coeffs[eval_data.n]*__rval;
00308             // if the number of children is odd, the list is implicitly
00309             // lengthened by one null element (i.e. implicitly shortened)
00310             if(eval_data.n & 1) // y_n
00311               eval_data.r += eval_data.u.d*h;
00312             else // x_n
00313               eval_data.u.d = h;
00314           }
00315           eval_data.n++;
00316           break; */
00317     /*    case EXPRINFO_NORM:
00318           if(__data.params.nd() == COCO_INF)
00319           {
00320             __x = fabs(__rval*__data.coeffs[eval_data.n]);
00321             if(__x > eval_data.r)
00322               eval_data.r = __x;
00323           }
00324           else
00325           { __x = fabs(__data.coeffs[eval_data.n]*__rval);
00326             eval_data.r += std::pow(__x, __data.params.nd());
00327           }
00328           eval_data.n++;
00329           if(eval_data.n == __data.n_children && __data.params.nd() != COCO_INF)
00330             eval_data.r = std::pow(eval_data.r, 1./__data.params.nd());
00331           break; */
00332         case EXPRINFO_INVERT:
00333           eval_data.r = eval_data.r / __rval;
00334           break;
00335         case EXPRINFO_DIV:
00336           // this evaluator requires, that the second coefficient
00337           // is put into the first.
00338           if(eval_data.n == 0)
00339           {
00340             eval_data.r = eval_data.r * __rval;
00341         //    if(eval_data.r == diffI(0,4)) ret=-1;
00342           }
00343           else
00344             eval_data.r = eval_data.r / __rval;
00345           ++eval_data.n;
00346           break;
00347         case EXPRINFO_SQUARE:
00348           std::cout<<"square :"<<__rval<<" -> ";
00349           __x = __data.coeffs[0]*__rval+__data.params.nd();
00350           eval_data.r = __x*__x;
00351           std::cout<<eval_data.r<<"\n";
00352           std::cout<<"coeffs: "<<__data.coeffs[0]<<" params: "<<__data.params.nd()<<"\n";
00353           break;
00354         case EXPRINFO_INTPOWER:
00355           std::cout<<"intpower \n";
00356           eval_data.r = __power(__data.coeffs[0], __rval, __data.params.nn());
00357           break;
00358         case EXPRINFO_SQROOT:
00359           eval_data.r = sqrt(__data.coeffs[0]*__rval+__data.params.nd());
00360           break;
00361   /*      case EXPRINFO_ABS:
00362           eval_data.r = fabs(__data.coeffs[0]*__rval+__data.params.nd());
00363           break; */
00364        /* case EXPRINFO_POW:
00365           __x = __rval * __data.coeffs[eval_data.n];
00366           if(eval_data.n == diffI(0,4))
00367             eval_data.r = __x+__data.params.nd();
00368           else
00369             eval_data.r = std::pow(eval_data.r, __x);
00370           ++eval_data.n;
00371           break; */
00372         case EXPRINFO_EXP:
00373           eval_data.r = exp(__rval*__data.coeffs[0]+__data.params.nd());
00374           break;
00375 /*      case EXPRINFO_LOG:
00376           eval_data.r = diffI::log(__rval*__data.coeffs[0]+__data.params.nd());
00377           break;  */
00378         case EXPRINFO_SIN:
00379           eval_data.r = sin(__rval*__data.coeffs[0]+__data.params.nd());
00380           break;
00381         case EXPRINFO_COS:
00382           eval_data.r = cos(__rval*__data.coeffs[0]+__data.params.nd());
00383           break;
00384         case EXPRINFO_ATAN2:
00385           __x = __rval * __data.coeffs[eval_data.n];
00386           if(eval_data.n == 0)
00387             eval_data.r = __x;
00388           else
00389             eval_data.r = atan2(eval_data.r, __x);
00390           ++eval_data.n;
00391           break;
00392    /*     case EXPRINFO_GAUSS:
00393           __x = (__data.coeffs[0]*__rval-__data.params.d()[0])/
00394                                 __data.params.d()[1];
00395           eval_data.r = std::exp(-__x*__x);
00396           break;
00397         case EXPRINFO_POLY:
00398           if(!__data.params.empty())
00399           {
00400             __x = __data.coeffs[eval_data.n]*__rval;
00401             eval_data.r = __data.params.d().back();
00402             for(int i = (int)__data.params.d().size()-2; i >= 0; --i)
00403             {
00404               eval_data.r *= __x;
00405               eval_data.r += __data.params.d()[i];
00406             }
00407           }
00408           else
00409             eval_data.r = 0;
00410           break;
00411         case EXPRINFO_LIN:
00412         case EXPRINFO_QUAD:
00413   */
00414           /* we will never come here! */ /*
00415           break;  */
00416    /*     case EXPRINFO_IN:
00417           {
00418             __x = __data.coeffs[eval_data.n]*__rval;
00419             const interval& i(__data.params.i()[eval_data.n]);
00420             if(eval_data.r != -1 && i.contains(__x))
00421             {
00422               if(eval_data.r == 1 && (__x == i.inf() || __x == i.sup()))
00423                 eval_data.r = 0;
00424             }
00425             else
00426             {
00427               eval_data.r = -1;
00428               ret = -1;
00429             }
00430           }
00431           eval_data.n++;
00432           break;
00433         case EXPRINFO_IF:
00434           __x = __rval * __data.coeffs[eval_data.n];
00435           if(eval_data.n == 0) // this is the condition
00436           {
00437             const interval& i(__data.params.ni());
00438             if(!i.contains(__x)) // go to else part
00439               ret = 1;           // don't walk the next child
00440           }
00441           else // this is either the if or the else part
00442           {
00443             eval_data.r = __x;
00444             ret = -1;            // don't continue walking
00445           }
00446           eval_data.n += ret+1;
00447           break;
00448         case EXPRINFO_AND:
00449           { __x = __data.coeffs[eval_data.n]*__rval;
00450             const interval& i(__data.params.i()[eval_data.n]);
00451             if(eval_data.r == 1 && !i.contains(__x))
00452             {
00453               eval_data.r = 0;
00454               ret = -1;         // result cannot become more false
00455             }
00456           }
00457           eval_data.n++;
00458           break;
00459         case EXPRINFO_OR:
00460           { __x = __data.coeffs[eval_data.n]*__rval;
00461             const interval& i(__data.params.i()[eval_data.n]);
00462             if(eval_data.r == 0 && i.contains(__x))
00463             {
00464               eval_data.r = 1;
00465               ret = -1;         // result cannot become more true
00466             }
00467           }
00468           eval_data.n++;
00469           break;
00470         case EXPRINFO_NOT:
00471           { __x = __data.coeffs[0]*__rval;
00472             const interval& i(__data.params.ni());
00473             if(i.contains(__x))
00474               eval_data.r = 0;
00475             else
00476               eval_data.r = 1;
00477           }
00478           break;
00479         case EXPRINFO_IMPLIES:
00480           { const interval& i(__data.params.i()[eval_data.n]);
00481             __x = __rval * __data.coeffs[eval_data.n];
00482             if(eval_data.n == 0)
00483             {
00484               if(!i.contains(__x))
00485               {
00486                 eval_data.r = 1;
00487                 ret = -1;        // ex falso quodlibet
00488               }
00489             }
00490             else // we only get here if first clause is true
00491               eval_data.r = i.contains(__x) ? 1 : 0;
00492             ++eval_data.n;
00493           }
00494           break; */
00495     /*    case EXPRINFO_COUNT:
00496           { __x = __data.coeffs[eval_data.n]*__rval;
00497             const interval& i(__data.params.i()[eval_data.n]);
00498             if(i.contains(__x))
00499               eval_data.r += 1;
00500           }
00501           eval_data.n++;
00502           break; */
00503    /*     case EXPRINFO_ALLDIFF:
00504           { __x = __data.coeffs[eval_data.n]*__rval;
00505             for(std::vector<double>::const_iterator _b =
00506                         ((std::vector<double>*)eval_data.u.p)->begin();
00507                 _b != ((std::vector<double>*)eval_data.u.p)->end(); ++_b)
00508             {
00509               if(fabs(__x-*_b) <= __data.params.nd())
00510               {
00511                 eval_data.r = 0;
00512                 ret = -1;
00513                 break;
00514               }
00515             }
00516             if(ret != -1)
00517               ((std::vector<double>*) eval_data.u.p)->push_back(__x);
00518           }
00519           eval_data.n++;
00520           if(eval_data.n == __data.n_children || ret == -1)
00521             delete (std::vector<double>*) eval_data.u.p;
00522           break; */
00523    /*     case EXPRINFO_HISTOGRAM:
00524           { __x = __data.coeffs[eval_data.n]*__rval;
00525             unsigned int ni = (__data.params.i().size()+1)>>1;
00526             for(unsigned int i=0; i<ni; i++)
00527             {
00528               if(__data.params.i()[i<<1].contains(__x))
00529                 (*(std::vector<unsigned int>*)eval_data.u.p)[i]++;
00530             }
00531             eval_data.n++;
00532             if(eval_data.n == __data.n_children || ret == -1)
00533             {
00534               for(unsigned int i=0; i<ni; i++)
00535               {
00536                 if(!__data.params.i()[i<<1].contains(
00537                       (*(std::vector<unsigned int>*)eval_data.u.p)[i]+0.))
00538                 {
00539                   eval_data.r = 0;
00540                   break;
00541                 }
00542               }
00543               delete (std::vector<unsigned int>*) eval_data.u.p;
00544             }
00545           }
00546           break; */
00547   /*      case EXPRINFO_LEVEL:
00548           { int h = (int)eval_data.r;
00549             __x = __data.coeffs[eval_data.n]*__rval;
00550             interval _h;
00551 
00552             if(h != INT_MAX)
00553             {
00554               while(h < __data.params.im().nrows())
00555               { 
00556                 _h = __data.params.im()[h][eval_data.n];
00557                 if(_h.contains(__x))
00558                   break;
00559                 h++;
00560               }
00561               if(h == __data.params.im().nrows())
00562               {
00563                 ret = -1;
00564                 eval_data.r = INT_MAX;
00565               }
00566               else
00567                 eval_data.r = h;
00568             }
00569           }
00570           eval_data.n++;
00571           break; */
00572   /*      case EXPRINFO_NEIGHBOR:
00573           if(eval_data.n == 0)
00574             eval_data.r = __data.coeffs[0]*__rval;
00575           else
00576           {
00577             double h = eval_data.r;
00578             eval_data.r = 0;
00579             __x = __data.coeffs[1]*__rval;
00580             for(unsigned int i = 0; i < __data.params.n().size(); i+=2)
00581             {
00582               if(h == __data.params.n()[i] && __x == __data.params.n()[i+1])
00583               {
00584                 eval_data.r = 1;
00585                 break;
00586               }
00587             }
00588           }
00589           eval_data.n++;
00590           break; */
00591    /*     case EXPRINFO_NOGOOD:
00592           {
00593             __x = __data.coeffs[eval_data.n]*__rval;
00594             if(eval_data.r == 0 || __data.params.n()[eval_data.n] != __x)
00595             {
00596               eval_data.r = 0;
00597               ret = -1;
00598             }
00599           }
00600           eval_data.n++;
00601           break; */
00602         case EXPRINFO_EXPECTATION:
00603           throw nyi_exception("func_evaluator: EXPECTATION");
00604           break;
00605         case EXPRINFO_INTEGRAL:
00606           throw nyi_exception("func_evaluator: INTEGRAL");
00607           break;
00608         case EXPRINFO_LOOKUP:
00609           throw nyi_exception("func_evaluator: LOOKUP");
00610           break;
00611     /*    case EXPRINFO_PWLIN:
00612           {
00613             int idx;
00614             __x = __data.coeffs[0]*__rval;
00615             for(idx=0; idx < __data.params.m().nrows(); ++idx)
00616               if(__x < __data.params.m()[idx][0]) break;
00617             if(idx == __data.params.m().nrows())
00618               eval_data.r = COCO_INF;
00619             else if(idx == 0)
00620               eval_data.r = -COCO_INF;
00621             else
00622             {
00623               double x0 = __data.params.m()[idx-1][0];
00624               double f0 = __data.params.m()[idx-1][1];
00625               eval_data.r = (__data.params.m()[idx][1]-f0)/(__data.params.m()[idx][0]-x0);
00626               eval_data.r *= __x-x0;
00627               eval_data.r += f0;
00628             }
00629           }
00630           break; */
00631         case EXPRINFO_SPLINE:
00632           throw nyi_exception("func_evaluator: SPLINE");
00633         break;
00634  /*       case EXPRINFO_PWCONSTLC:
00635           {
00636             int idx;
00637             __x = __data.coeffs[0]*__rval;
00638             for(idx=0; idx < __data.params.m().nrows(); ++idx)
00639               if(__x < __data.params.m()[idx][0]) break;
00640             if(idx == __data.params.m().nrows())
00641               eval_data.r = COCO_INF;
00642             else if(idx == 0)
00643               eval_data.r = -COCO_INF;
00644             else
00645               eval_data.r = __data.params.m()[idx-1][1];
00646           }
00647           break;*/
00648   /*      case EXPRINFO_PWCONSTRC:
00649           {
00650             int idx;
00651             __x = __data.coeffs[0]*__rval;
00652             for(idx=0; idx < __data.params.m().nrows(); ++idx)
00653               if(__x <= __data.params.m()[idx][0]) break;
00654             if(idx == __data.params.m().nrows())
00655               eval_data.r = COCO_INF;
00656             else if(idx == 0)
00657               eval_data.r = -COCO_INF;
00658             else
00659               eval_data.r = __data.params.m()[idx-1][1];
00660           }
00661           break; */
00662         case EXPRINFO_DET:
00663         case EXPRINFO_COND:
00664         case EXPRINFO_PSD:
00665         case EXPRINFO_MPROD:
00666         case EXPRINFO_FEM:
00667           throw nyi_exception("func_evaluator: Matrix Operations");
00668           break;
00669         case EXPRINFO_RE:
00670         case EXPRINFO_IM:
00671         case EXPRINFO_ARG:
00672         case EXPRINFO_CPLXCONJ:
00673           throw nyi_exception("func_evaluator: Complex Operations");
00674           break;
00675         case EXPRINFO_CMPROD:
00676         case EXPRINFO_CGFEM:
00677           throw nyi_exception("func_evaluator: Const Matrix Operations");
00678         default:
00679           throw api_exception(apiee_evaluator,
00680               std::string("func_evaluator: unknown function type ")+
00681               convert_to_str(__data.operator_type));
00682           break;
00683       }
00684     }
00685     else if(__data.operator_type > 0)
00686 
00687       // update the function arguments
00688       //eval_data.r = __data.f_evaluate(eval_data.n++, __data.params.nn(),
00689       //                                *eval_data.x, *v_ind, eval_data.r,
00690       //                                __rval, NULL);
00691     // use the cache only if it is worthwhile
00692     if(eval_data.cache && __data.n_parents > 1 && __data.n_children > 0)
00693       (*eval_data.cache)[__data.node_num] = eval_data.r; 
00694     return ret;
00695   }
00696 
00697   diffI calculate_value(bool eval_all)
00698   {
00699     std::cout<<"diffI_evaluator.calculate_value\n";
00700     return eval_data.r;
00701   }
00703 };
00704 
00705 } // namespace coco
00706 
00707 #endif /* _DIFFI_EVALUATOR_H_ */