COCONUT API: Islope_evaluator.h Source File

00001 // Islope Evaluator implementation -*- C++ -*-
00002 
00003 // $Id: Islope_evaluator.h 925 2009-11-12 17:09:47Z 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 _ISLOPE_EVALUATOR_H_
00029 #define _ISLOPE_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 <Islope.h>
00040 
00041 using namespace vgtl;
00042 
00043 namespace coco {
00044 
00046 typedef Islope (*Islope_evaluator)(const std::vector<Islope>* __x,
00047                                  const variable_indicator& __v);
00048 
00050 
00055 //typedef Islope Islope_eval_rettype;
00056 
00057 struct Islope_eval_type
00058 {
00059   const std::vector<Islope>* x;
00060   std::vector<Islope>* cache;   
00061   const model* mod;     
00062   void *p;              
00063   Islope r;       
00064   unsigned int n;        
00065   int deg;       
00066 };      
00067 
00069 
00075 class Islope_eval :
00076   public cached_forward_evaluator_base<Islope_eval_type,expression_node,
00077                                        Islope,
00078                                        expression_const_walker>
00079 {
00080 private:
00081 //  typedef Islope retval;
00082   typedef cached_forward_evaluator_base<Islope_eval_type,expression_node,
00083                                         Islope, expression_const_walker> _Base;
00084 
00085 protected:
00088   bool is_cached(const node_data_type& __data)
00089   { //cout<<"Islope_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   Islope __power(double __coeff, Islope __x, int __exp)
00107   {
00108     if(__exp == 0)
00109       return Islope(1.,__x.order);
00110     else
00111     {
00112       Islope 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 Islope(0,eval_data.deg);           // we never come here!
00133   }  
00134   
00135 public:
00143   Islope_eval(const std::vector<Islope>& __x, const variable_indicator& __v,
00144             const model& __m, std::vector<Islope>* __c, int __deg) : _Base()
00145   {
00146     //cout<<"Islope_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.deg=__deg;
00153     eval_data.r.setDeg(__deg);
00154     eval_data.r=Islope(0.,__deg);
00155   }
00156 
00158   Islope_eval(const Islope_eval& __v) : _Base(__v) {}
00159   
00161   ~Islope_eval() {}
00162 
00164   expression_const_walker short_cut_to(const expression_node& __data)
00165   { 
00166           //cout<<"short_cut_to\n";
00167           return eval_data.mod->node(0); }    // return anything
00168 
00172   void new_interval(const std::vector<Islope>& __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     //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         (*(Islope_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           //cout<<"variable "<<__data.params.nn()<<"\n";
00200           eval_data.r = (*eval_data.x)[__data.params.nn()];
00201           //cout<<eval_data.r<<"\n";
00202           break;
00203         case EXPRINFO_SUM:
00204         case EXPRINFO_PROD:
00205         case EXPRINFO_MAX:
00206         case EXPRINFO_MIN:
00207         case EXPRINFO_INVERT:
00208         case EXPRINFO_DIV:
00209           eval_data.r = Islope(__data.params.nd(),eval_data.deg);
00210           break;
00211         case EXPRINFO_MONOME:
00212         case EXPRINFO_IN:
00213         case EXPRINFO_AND:
00214         case EXPRINFO_NOGOOD:
00215           eval_data.r = Islope(1.,eval_data.deg);
00216           break;
00217         case EXPRINFO_ALLDIFF:
00218    //       eval_data.u.p = (void*) new std::vector<interval>;
00219    //       ((std::vector<interval>*)eval_data.u.p)->reserve(__data.n_children);
00220           // no break!
00221         case EXPRINFO_MEAN:
00222         case EXPRINFO_IF:
00223         case EXPRINFO_OR:
00224         case EXPRINFO_NOT:
00225         case EXPRINFO_COUNT:
00226         case EXPRINFO_SCPROD:
00227         case EXPRINFO_NORM:
00228         case EXPRINFO_LEVEL:
00229           eval_data.r = Islope(0.,eval_data.deg);
00230           break;
00231         case EXPRINFO_DET:
00232         case EXPRINFO_PSD:
00233           // here construct square interval matrix
00234           break;
00235         case EXPRINFO_COND:
00236         case EXPRINFO_FEM:
00237         case EXPRINFO_MPROD:
00238           // here construct rectangular interval matrix
00239           break;
00240       }
00241       return 1;
00242     }
00243   }
00244 
00245   void calculate(const expression_node& __data)
00246   {
00247    if(__data.operator_type > 0){
00248         //cout<<"Islope_evaluator.calculate\n";
00249    }
00250   }
00251 
00252   void retrieve_from_cache(const expression_node& __data)
00253   {
00254    //cout<<"Islope_evaluator.retrieve_from_cache\n";
00255   }
00256 
00257   int update(const Islope& __rval)
00258   {
00259     //cout<<"Islope_evaluator.update\n";
00260     eval_data.r = __rval;
00261     return 0;
00262   }
00263 
00264   int update(const expression_node& __data, const Islope& __rval)
00265   {
00266     //cout<<"Islope_evaluator.update2 ";
00267     //cout<<__rval<<"\n";
00268           
00269     Islope __x(0.,eval_data.deg);
00270     int ret = 0;
00271     if(__data.operator_type < 0)
00272     {
00273       switch(__data.operator_type)
00274       {
00275         case EXPRINFO_CONSTANT:
00276         case EXPRINFO_VARIABLE:
00277           break;
00278         case EXPRINFO_SUM:
00279         case EXPRINFO_MEAN:
00280         //cout<<"sum: "<<eval_data.r<<" -> ";   
00281           eval_data.r = eval_data.r + __data.coeffs[eval_data.n++]*__rval;
00282         //cout<<eval_data.r<<"\n";
00283           break;
00284         case EXPRINFO_PROD:
00285           // the coefficients MUST be collected in __data.params.nd()
00286         //cout<<"prod";
00287           eval_data.r = eval_data.r * __rval;
00288         //  if(eval_data.r == Islope(0,4)) ret=-1;
00289           break;
00290         case EXPRINFO_MONOME:
00291         //cout<<"monome";       
00292           eval_data.r = eval_data.r * __power(__data.coeffs[eval_data.n],
00293                         __rval, __data.params.n()[eval_data.n]);
00294         //  if(eval_data.r == Islope(0,4)) ret=-1;
00295           eval_data.n++;
00296           break;
00297     /*    case EXPRINFO_MAX:
00298           __x = __rval * __data.coeffs[eval_data.n++];
00299           if(__x > eval_data.r)
00300             eval_data.r = __x;
00301           break;
00302         case EXPRINFO_MIN:
00303           __x = __rval * __data.coeffs[eval_data.n++];
00304           if(__x < eval_data.r)
00305             eval_data.r = __x;
00306           break; */
00307   /*      case EXPRINFO_SCPROD:
00308           { double h = __data.coeffs[eval_data.n]*__rval;
00309             // if the number of children is odd, the list is implicitly
00310             // lengthened by one null element (i.e. implicitly shortened)
00311             if(eval_data.n & 1) // y_n
00312               eval_data.r += eval_data.u.d*h;
00313             else // x_n
00314               eval_data.u.d = h;
00315           }
00316           eval_data.n++;
00317           break; */
00318     /*    case EXPRINFO_NORM:
00319           if(__data.params.nd() == COCO_INF)
00320           {
00321             __x = fabs(__rval*__data.coeffs[eval_data.n]);
00322             if(__x > eval_data.r)
00323               eval_data.r = __x;
00324           }
00325           else
00326           { __x = fabs(__data.coeffs[eval_data.n]*__rval);
00327             eval_data.r += std::pow(__x, __data.params.nd());
00328           }
00329           eval_data.n++;
00330           if(eval_data.n == __data.n_children && __data.params.nd() != COCO_INF)
00331             eval_data.r = std::pow(eval_data.r, 1./__data.params.nd());
00332           break; */
00333         case EXPRINFO_INVERT:
00334           eval_data.r = eval_data.r / __rval;
00335           break;
00336         case EXPRINFO_DIV:
00337           // this evaluator requires, that the second coefficient
00338           // is put into the first.
00339           if(eval_data.n == 0)
00340           {
00341             eval_data.r = eval_data.r * __rval;
00342         //    if(eval_data.r == Islope(0,4)) ret=-1;
00343           }
00344           else
00345             eval_data.r = eval_data.r / __rval;
00346           ++eval_data.n;
00347           break;
00348         case EXPRINFO_SQUARE:
00349           //cout<<"square :"<<__rval<<" -> ";
00350           __x = __data.coeffs[0]*__rval+__data.params.nd();
00351           eval_data.r = power(__x,2);
00352           //cout<<eval_data.r<<"\n";
00353           //cout<<"coeffs: "<<__data.coeffs[0]<<" params: "<<__data.params.nd()<<"\n";
00354           break;
00355         case EXPRINFO_INTPOWER:
00356           //cout<<"intpower \n";
00357           eval_data.r = __power(__data.coeffs[0], __rval, __data.params.nn());
00358           break;
00359         case EXPRINFO_SQROOT:
00360           eval_data.r = sqrt(__data.coeffs[0]*__rval+__data.params.nd());
00361           break;
00362   /*      case EXPRINFO_ABS:
00363           eval_data.r = fabs(__data.coeffs[0]*__rval+__data.params.nd());
00364           break; */
00365        /* case EXPRINFO_POW:
00366           __x = __rval * __data.coeffs[eval_data.n];
00367           if(eval_data.n == Islope(0,4))
00368             eval_data.r = __x+__data.params.nd();
00369           else
00370             eval_data.r = std::pow(eval_data.r, __x);
00371           ++eval_data.n;
00372           break; */
00373         case EXPRINFO_EXP:
00374           eval_data.r = exp(__rval*__data.coeffs[0]+__data.params.nd());
00375           break;
00376 /*      case EXPRINFO_LOG:
00377           eval_data.r = Islope::log(__rval*__data.coeffs[0]+__data.params.nd());
00378           break;  */
00379         case EXPRINFO_SIN:
00380           eval_data.r = sin(__rval*__data.coeffs[0]+__data.params.nd());
00381           break;
00382         case EXPRINFO_COS:
00383           eval_data.r = cos(__rval*__data.coeffs[0]+__data.params.nd());
00384           break;
00385         case EXPRINFO_ATAN2:
00386           __x = __rval * __data.coeffs[eval_data.n];
00387           if(eval_data.n == 0)
00388             eval_data.r = __x;
00389           else
00390             eval_data.r = atan2(eval_data.r, __x);
00391           ++eval_data.n;
00392           break;
00393    /*     case EXPRINFO_GAUSS:
00394           __x = (__data.coeffs[0]*__rval-__data.params.d()[0])/
00395                                 __data.params.d()[1];
00396           eval_data.r = std::exp(-__x*__x);
00397           break;
00398         case EXPRINFO_POLY:
00399           if(!__data.params.empty())
00400           {
00401             __x = __data.coeffs[eval_data.n]*__rval;
00402             eval_data.r = __data.params.d().back();
00403             for(int i = (int)__data.params.d().size()-2; i >= 0; --i)
00404             {
00405               eval_data.r *= __x;
00406               eval_data.r += __data.params.d()[i];
00407             }
00408           }
00409           else
00410             eval_data.r = 0;
00411           break;
00412         case EXPRINFO_LIN:
00413         case EXPRINFO_QUAD:
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   Islope calculate_value(bool eval_all)
00698   {
00699     //cout<<"Islope_evaluator.calculate_value\n";
00700     return eval_data.r;
00701   }
00703 };
00704 
00705 } // namespace coco
00706 
00707 #endif /* _ISLOPE_EVALUATOR_H_ */