COCONUT API: diffNumber_evaluator.h Source File

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