COCONUT API: bint_evaluator.h Source File

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