git-svn-id: file:///home/svn/opt_utilities@1 ed2142bd-67ad-457f-ba7c-d818d4011675

author: astrojhgu <astrojhgu@ed2142bd-67ad-457f-ba7c-d818d4011675> 2008-12-15 07:26:12 +0000
committer: astrojhgu <astrojhgu@ed2142bd-67ad-457f-ba7c-d818d4011675> 2008-12-15 07:26:12 +0000
commit: 1f4a944064bc42284c33e6b755353d191cf288e8 (patch)
tree: c8cb2253dea5f395e0f867aa6976433bd3eb00de
download: opt-utilities-1f4a944064bc42284c33e6b755353d191cf288e8.tar.bz2
85 files changed, 16661 insertions, 0 deletions
diff --git a/core/default_data_set.hpp b/core/default_data_set.hpp
new file mode 100644
index 0000000..be06c04
--- /dev/null
+++ b/core/default_data_set.hpp
@@ -0,0 +1,47 @@
+#ifndef DEFAULT_DATA_SET
+#define DEFAULT_DATA_SET
+#include "fitter.hpp"
+#include <vector>
+
+
+namespace opt_utilities
+{
+
+template <typename Ty,typename Tx>
+class default_data_set
+  :public data_set<Ty,Tx>
+{
+private:
+  std::vector<data<Ty,Tx> > data_vec;
+
+  data_set<Ty,Tx>* do_clone()const
+  {
+    return new default_data_set<Ty,Tx>(*this);
+  }
+
+
+  const data<Ty,Tx>& do_get_data(int i)const
+  {
+    return data_vec.at(i);
+  }
+  
+  int do_size()const
+  {
+    return data_vec.size();
+  }
+  
+  void do_push_back(const data<Ty,Tx>& d)
+  {
+    data_vec.push_back(d);
+  }
+  
+  void do_clear()
+  {
+    data_vec.clear();
+  }
+  
+};
+}
+
+#endif
+//EOF
diff --git a/core/fitter.hpp b/core/fitter.hpp
new file mode 100644
index 0000000..ed90a83
--- /dev/null
+++ b/core/fitter.hpp
@@ -0,0 +1,1043 @@
+#ifndef FITTER_HPP
+#define FITTER_HPP
+#include "opt_exception.hpp"
+#include "optimizer.hpp"
+#include <vector>
+#include <string>
+#include <cstdlib>
+#include <cassert>
+#include <iostream>
+namespace opt_utilities
+{
+
+  ///////////////////////////////////
+  //////class data///////////////////
+  //////contain single data point////
+  ///////////////////////////////////
+  template<typename Ty,typename Tx,typename Tp,typename Ts,typename Tstr>
+  class statistic;
+
+  template<typename Ty,typename Tx,typename Tp,typename Tstr>
+  class param_modifier;
+
+
+  template<typename Ty,typename Tx>
+  class data
+  {
+  private:
+    Tx x,x_lower_err,x_upper_err;
+    Ty y,y_lower_err,y_upper_err;
+  public:
+    data(const Tx& _x,const Ty& _y,const Ty& _y_lower_err,const Ty& _y_upper_err,const Tx& _x_lower_err,const Tx& _x_upper_err)
+    {
+      opt_eq(x,_x);
+      opt_eq(x_lower_err,_x_lower_err);
+      opt_eq(x_upper_err,_x_upper_err);
+      opt_eq(y,_y);
+      opt_eq(y_lower_err,_y_lower_err);
+      opt_eq(y_upper_err,_y_upper_err);
+ 
+    }
+
+    data()
+      :x(),
+       x_lower_err(),
+       x_upper_err(),
+       y(),
+       y_lower_err(),
+       y_upper_err()
+    {}
+
+    data(const data& rhs)
+    {
+      opt_eq(x,rhs.x);
+      opt_eq(x_lower_err,rhs.x_lower_err);
+      opt_eq(x_upper_err,rhs.x_upper_err);
+      opt_eq(y,rhs.y);
+      opt_eq(y_lower_err,rhs.y_lower_err);
+      opt_eq(y_upper_err,rhs.y_upper_err);
+    }
+
+    data& operator=(const data& rhs)
+    {
+      opt_eq(x,rhs.x);
+      opt_eq(x_lower_err,rhs.x_lower_err);
+      opt_eq(x_upper_err,rhs.x_upper_err);
+      opt_eq(y,rhs.y);
+      opt_eq(y_lower_err,rhs.y_lower_err);
+      opt_eq(y_upper_err,rhs.y_upper_err);
+      return *this;
+    }
+
+  public:
+    const Tx& get_x()const
+    {
+      return x;
+    }
+    
+    const Tx& get_x_lower_err()const
+    {
+      return x_lower_err;
+    }
+    
+    const Tx& get_x_upper_err()const
+    {
+      return x_upper_err;
+    }
+
+    const Ty& get_y()const
+    {
+      return y;
+    }
+    
+    const Ty& get_y_lower_err()const
+    {
+      return y_lower_err;
+    }
+    
+    const Ty& get_y_upper_err()const
+    {
+      return y_upper_err;
+    }
+
+
+    void set_x(const Tx& _x)
+    {
+      opt_eq(x,_x);
+    }
+    
+    void set_x_lower_err(const Tx& _x)
+    {
+      opt_eq(x_lower_err,_x);
+    }
+    
+    void set_x_upper_err(const Tx& _x)
+    {
+      opt_eq(x_upper_err,_x);
+    }
+
+    void set_y(const Ty& _y)
+    {
+      opt_eq(y,_y);
+    }
+    
+    void set_y_lower_err(const Ty& _y)
+    {
+      opt_eq(y_lower_err,_y);
+    }
+    
+    void set_y_upper_err(const Ty& _y)
+    {
+      opt_eq(y_upper_err,_y);
+    }
+    
+
+  };
+
+  ////////////////////////////////////
+  ///class data_set///////////////////
+  ///contain a set of data////////////
+  ////////////////////////////////////
+  
+  
+  template <typename Ty,typename Tx>
+  class data_set
+  {
+  private:
+    
+    virtual const data<Ty,Tx>& do_get_data(int i)const=0;
+    virtual int do_size()const=0;
+    virtual void do_push_back(const data<Ty,Tx>&)=0;
+    virtual void do_clear()=0;
+    virtual data_set<Ty,Tx>* do_clone()const=0;
+
+    virtual void do_destroy()
+    {
+      delete this;
+    }
+  public:
+    const data<Ty,Tx>& get_data(int i)const
+    {
+      return this->do_get_data(i);
+    }
+    int size()const
+    {
+      return do_size();
+    }
+    void push_back(const data<Ty,Tx>& d)
+    {
+      return do_push_back(d);
+    }
+    void clear()
+    {
+      do_clear();
+    }
+    
+    data_set<Ty,Tx>* clone()const
+    {
+      return this->do_clone();
+    }
+
+    void destroy()
+    {
+      do_destroy();
+    }
+
+    virtual ~data_set(){}
+      
+  };
+
+  ///////////////////////////////////////////////
+  /////class param_info//////////////////////////
+  /////record the information of one parameter///
+  /////including the name, default value/////////
+  ///////////////////////////////////////////////
+
+  
+  template <typename Tp,typename Tstr=std::string>
+  class param_info
+  {
+  private:
+    Tstr name;
+    //bool frozen;
+    typename element_type_trait<Tp>::element_type default_value;
+    
+  public:
+    param_info(const Tstr& _name,
+	       const typename element_type_trait<Tp>::element_type& _v)
+      :name(_name),default_value(_v){}
+
+    param_info()
+      :name()
+    {}
+
+    param_info(const param_info& rhs)
+      :name(rhs.name)
+    {
+      opt_eq(default_value,rhs.default_value);
+    }
+    
+    param_info& operator=(const param_info& rhs)
+    {
+      name=rhs.name;
+      opt_eq(default_value,rhs.default_value);
+      return *this;
+    }
+
+    const Tstr& get_name()const
+    {
+      return this->name;
+    }
+
+    const typename element_type_trait<Tp>::element_type& get_default_value()const
+    {
+      return default_value;
+    }
+
+    void set_default_value(const typename element_type_trait<Tp>::element_type& x)
+    {
+      opt_eq(default_value,x);
+    }
+
+    void set_name(const Tstr& _name)
+    {
+      name=_name;
+    }
+  };
+
+
+
+
+
+  template <typename Ty,typename Tx,typename Tp,typename Tstr=std::string>
+  class model
+  {
+  private:
+    std::vector<param_info<Tp> > param_info_list;
+    param_info<Tp> null_param;
+    //    int num_free_params;
+    param_modifier<Ty,Tx,Tp,Tstr>* p_param_modifier;
+  private:
+    virtual model<Ty,Tx,Tp,Tstr>* do_clone()const=0;
+
+    virtual void do_destroy()
+    {
+      delete this;
+    }
+  public:
+    model<Ty,Tx,Tp,Tstr>* clone()const
+    {
+      return do_clone();
+    }
+
+    void destroy()
+    {
+      do_destroy();
+    }
+  public:
+    model()
+      :p_param_modifier(0)
+    {}
+    
+    model(const model& rhs)
+      :p_param_modifier(0)
+    {
+      if(rhs.p_param_modifier!=0)
+	{
+	  set_param_modifier(*(rhs.p_param_modifier));
+	}
+      param_info_list=rhs.param_info_list;
+      null_param=rhs.null_param;
+      
+    }
+    
+    model& operator=(const model& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      if(rhs.p_param_modifier!=0)
+	{
+	  set_param_modifier(*(rhs.p_param_modifier));
+	}
+      param_info_list=rhs.param_info_list;
+      null_param=rhs.null_param;
+      return *this;
+    }
+    
+    virtual ~model()
+    {
+      if(p_param_modifier)
+	{
+	  //delete p_param_modifier;
+	  p_param_modifier->destroy();
+	}
+    }
+    
+    void set_param_modifier(const param_modifier<Ty,Tx,Tp,Tstr>& pm)
+    {
+      if(p_param_modifier!=0)
+	{
+	  //delete p_param_modifier;
+	  p_param_modifier->destroy();
+	}
+      p_param_modifier=pm.clone();
+      p_param_modifier->set_model(*this);
+    }
+
+    void set_param_modifier()
+    {
+      if(p_param_modifier!=0)
+	{
+	  //delete p_param_modifier;
+	  p_param_modifier->destroy();
+	}
+      p_param_modifier=0;
+    }
+    
+    param_modifier<Ty,Tx,Tp,Tstr>& get_param_modifier()
+    {
+      if(p_param_modifier==0)
+	{
+	  throw param_modifier_undefined();
+	}
+      return *p_param_modifier;
+    }
+
+    Tstr report_param_status(const Tstr& s)const
+    {
+      if(p_param_modifier==0)
+	{
+	  return Tstr();
+	}
+      
+      return p_param_modifier->report_param_status(s);
+	
+    }
+    
+
+    const param_info<Tp,Tstr>& get_param_info(const Tstr& pname)
+    {
+      for(typename std::vector<param_info<Tp,Tstr> >::iterator i=param_info_list.begin();
+	  i!=param_info_list.end();++i)
+	{
+	  if(i->get_name()==pname)
+	    {
+	      return *i;
+	    }
+	}
+      std::cerr<<"Param unfound!"<<std::endl;
+      assert(false);
+      throw param_not_found();
+      return null_param;
+    }
+
+    const param_info<Tp,Tstr>& get_param_info(int n)const
+    {
+      return param_info_list[n%get_num_params()];
+    }
+
+    
+    Tp get_all_params()const
+    {
+      Tp result;
+      resize(result,param_info_list.size());
+      for(size_t i=0;i<param_info_list.size();++i)
+	{
+	  //opt_eq(get_element(result,i),param_info_list[i].get_default_value());
+	  set_element(result,i,param_info_list[i].get_default_value());
+	  //get_element((Tp)result,i);
+	}
+      return result;
+    }
+
+  
+    int get_num_params()const
+    {
+      return (int)param_info_list.size();
+    }
+
+    int get_num_free_params()const
+    {
+      if(p_param_modifier)
+	{
+	  return (int)p_param_modifier->get_num_free_params();
+	}
+      return get_num_params();
+    }
+
+    void set_param_value(const Tstr& pname,
+			 const typename element_type_trait<Tp>::element_type& v)
+    {
+      //int porder=0;
+      for(typename std::vector<param_info<Tp,Tstr> >::iterator i=param_info_list.begin();
+	  i!=param_info_list.end();++i)
+	{
+	  if(i->get_name()==pname)
+	    {
+	      i->set_default_value(v);
+	      return;
+	    }
+	}
+      std::cerr<<"param "<<pname<<" unfound"<<std::endl;
+      throw param_not_found();
+    }
+
+    void set_param_value(const Tp& param)
+    {
+      for(size_t i=0;i<param_info_list.size();++i)
+	{
+	  param_info_list[i].set_default_value(get_element(param,i));
+	}
+    }
+
+    int get_param_order(const Tstr& pname)const
+    {
+      for(int i=0;i<(int)param_info_list.size();++i)
+	{
+	  if(param_info_list[i].get_name()==pname)
+	    {
+	      return i;
+	    }
+	}
+      //      std::cerr<<"param name invalid!"<<std::endl;
+      // assert(false);
+      throw param_not_found();
+      return -1;
+    }
+    
+
+		
+  protected:
+    void push_param_info(const param_info<Tp,Tstr>& pinfo)
+    {
+      param_info_list.push_back(pinfo);
+      //      this->num_free_params++;
+    }
+    
+    void clear_param_info()
+    {
+      //      this->num_free_params=0;
+      param_info_list.clear();
+    }
+
+
+
+  public:
+    Tstr to_string()const
+    {
+      return do_to_string();
+    }
+
+    Tp reform_param(const Tp& p)const
+    {
+      if(p_param_modifier==0)
+	{
+	  return p;
+	}
+      return p_param_modifier->reform(p);
+    }
+
+    Tp deform_param(const Tp& p)const
+    {
+      if(p_param_modifier==0)
+	{
+	  return p;
+	}
+      return p_param_modifier->deform(p);
+    }
+
+    
+    Ty eval(const Tx& x,const Tp& p)
+    {
+      return do_eval(x,reform_param(p));
+    }
+
+    virtual Ty do_eval(const Tx& x,const Tp& p)=0;
+
+  private:
+    virtual Tstr do_to_string()const
+    {
+      return Tstr();
+    }
+    
+  };
+
+
+
+  template<typename Ty,typename Tx,typename Tp,typename Ts=Ty,typename Tstr=std::string>
+  class fitter
+  {
+  public:
+    model<Ty,Tx,Tp,Tstr>* p_model;
+    statistic<Ty,Tx,Tp,Ts,Tstr>* p_statistic;
+    data_set<Ty,Tx>* p_data_set;
+    optimizer<Ts,Tp> optengine;
+  public:
+    fitter()
+      :p_model(0),p_statistic(0),p_data_set(0),optengine()
+    {}
+
+    
+    fitter(const fitter& rhs)
+      :p_model(0),p_statistic(0),p_data_set(0),optengine()
+    {
+      if(rhs.p_model!=0)
+	{
+	  set_model(*(rhs.p_model));
+	}
+      if(rhs.p_statistic!=0)
+	{
+	  set_statistic(*(rhs.p_statistic));
+	  assert(p_statistic->p_fitter!=0);
+	}
+      if(rhs.p_data_set!=0)
+	{
+	  load_data(*(rhs.p_data_set));
+	}
+      optengine=rhs.optengine;
+    }
+    
+    fitter& operator=(const fitter& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      if(rhs.p_model!=0)
+	{
+	  set_model(*(rhs.p_model));
+	}
+      if(rhs.p_statistic!=0)
+	{
+	  set_statistic(*(rhs.p_statistic));
+	}
+      if(rhs.p_data_set!=0)
+	{
+	  load_data(*(rhs.p_data_set));
+	}
+      optengine=rhs.optengine;
+      return *this;
+    }
+    
+    virtual ~fitter()
+    {
+      if(p_model!=0)
+	{
+	  //delete p_model;
+	  p_model->destroy();
+	}
+      if(p_statistic!=0)
+	{
+	  //delete p_statistic;
+	  p_statistic->destroy();
+	}
+      if(p_data_set!=0)
+	{
+	  //delete p_data_set;
+	  p_data_set->destroy();
+	}
+    }
+    
+
+    Ty eval_model(const Tx& x,const Tp& p)
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->eval(x,p);
+    }
+    
+
+  public:
+    void set_model(const model<Ty,Tx,Tp,Tstr>& m)
+    {
+      if(p_model!=0)
+	{
+	  //delete p_model;
+	  p_model->destroy();
+	}
+      p_model=m.clone();
+      //p_model=&m;
+      //  current_param.resize(m.get_num_params());
+    }
+    /*
+    void set(const model<Ty,Tx,Tp>& m)
+    {
+      set_model(m);
+    }
+    */
+    void set_statistic(const statistic<Ty,Tx,Tp,Ts,Tstr>& s)
+    {
+      if(p_statistic!=0)
+	{
+	  //delete p_statistic;
+	  p_statistic->destroy();
+	}
+      p_statistic=s.clone();
+      //p_statistic=&s;
+      p_statistic->set_fitter(*this);
+    }
+    /*
+    void set(const statistic<Ty,Tx,Tp>& s)
+    {
+      set_statistic(s);
+    }
+    */
+
+    void set_param_modifier(const param_modifier<Ty,Tx,Tp,Tstr>& pm)
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      p_model->set_param_modifier(pm);
+    }
+
+    void set_param_modifier()
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      p_model->set_param_modifier();
+    }
+
+    param_modifier<Ty,Tx,Tp,Tstr>& get_param_modifier()
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->get_param_modifier();
+    }
+
+    Tstr report_param_status(const Tstr& s)const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->report_param_status(s);
+    }
+    
+    /*
+    void set(const param_modifier<Ty,Tx,Tp>& pm)
+    {
+      set_param_modifier(pm);
+    }
+    */
+    void load_data(const data_set<Ty,Tx>& da)
+    {
+      if(p_data_set!=0)
+	{
+	  //delete p_data_set;
+	  p_data_set->destroy();
+	}
+      p_data_set=da.clone();
+      if(p_statistic!=0)
+	{
+	  p_statistic->set_fitter(*this);
+	}
+    }
+	
+    const data_set<Ty,Tx>& datas()const
+    {
+      if(p_data_set==0)
+	{
+	  throw data_unloaded();
+	}
+      return *(this->p_data_set);
+    }
+
+    model<Ty,Tx,Tp,Tstr>& model()
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return *(this->p_model);
+    }
+
+    statistic<Ty,Tx,Tp,Ts,Tstr>& statistic()
+    {
+      if(p_statistic==0)
+	{
+	  throw statistic_undefined();
+	}
+      return *(this->p_statistic);
+    }
+
+    opt_method<Ts,Tp>& method()
+    {
+      return optengine.method();
+    }
+    
+
+  public:
+    void set_param_value(const Tstr& pname,
+			 const typename element_type_trait<Tp>::element_type& v)
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      p_model->set_param_value(pname,v);
+    }
+
+    void set_param_value(const Tp& param)
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      p_model->set_param_value(param);
+    }
+
+    typename element_type_trait<Tp>::element_type get_param_value(const Tstr& pname)const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->get_param_info(pname).get_default_value();
+    }
+
+    const param_info<Tp,Tstr>& get_param_info(const Tstr& pname)const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->get_param_info(pname);
+    }
+
+    const param_info<Tp,Tstr>& get_param_info(int n)const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->get_param_info(n);
+    }
+
+    const int get_param_order(const Tstr& pname)const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->get_param_order(pname);
+    }
+
+    int get_num_params()const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      return p_model->get_num_params();
+    }
+
+    Tp get_all_params()const
+    {
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      //return current_param;
+      return p_model->get_all_params();
+    }
+
+    void set_method(const opt_method<Ts,Tp>& pm)
+    {
+      //assert(p_optimizer!=0);
+      optengine.set_opt_method(pm);
+    }
+    /*
+    void set(const opt_method<Ty,Tp>& pm)
+    {
+      set_method(pm);
+    }
+    */
+    void set_precision(typename element_type_trait<Tp>::element_type y)
+    {
+      optengine.set_precision(y);
+    }
+
+    Tp fit()
+    {
+      //      assert(p_model!=0);
+      if(p_model==0)
+	{
+	  throw model_undefined();
+	}
+      if(p_data_set==0)
+	{
+	  throw data_unloaded();
+	}
+      //assert(p_optimizer!=0);
+      //assert(p_data_set!=0);
+      //assert(p_statistic!=0);
+      if(p_statistic==0)
+	{
+	  throw statistic_undefined();
+	}
+
+      optengine.set_func_obj(*p_statistic);
+      Tp current_param;
+      opt_eq(current_param,p_model->get_all_params());
+      Tp start_point;
+      opt_eq(start_point,p_model->deform_param(current_param));
+      //      std::cout<<start_point.size()<<std::endl;
+      
+      
+      //for(int i=0;i<(int)start_point.size();++i)
+      //	{
+      //	  std::cout<<start_point[i]<<",";
+      //	}
+      //std::cout<<std::endl;
+      //assert(start_point.size()!=0);
+      if(get_size(start_point)==0)
+	{
+	  //return start_point;
+	  return p_model->get_all_params();
+	}
+      optengine.set_start_point(start_point);
+      
+      Tp result;
+      opt_eq(result,optengine.optimize());
+
+      Tp decurrent_param;
+      opt_eq(decurrent_param,p_model->reform_param(result));
+      //current_param.resize(decurrent_param.size());
+      resize(current_param,get_size(decurrent_param));
+      opt_eq(current_param,decurrent_param);
+      p_model->set_param_value(current_param);
+      //   return current_param;
+      return p_model->get_all_params();
+    }
+
+  };
+
+
+  template<typename Ty,typename Tx,typename Tp,typename Ts,typename Tstr=std::string>
+  class statistic
+    :public func_obj<Ts,Tp>
+  {
+  public:
+    fitter<Ty,Tx,Tp,Ts,Tstr>* p_fitter;
+  
+  private:
+    virtual statistic<Ty,Tx,Tp,Ts,Tstr>* do_clone()const=0;
+
+    virtual void do_destroy()
+    {
+      delete this;
+    }
+
+  public:
+    statistic<Ty,Tx,Tp,Ts,Tstr>* clone()const
+    {
+      return this->do_clone();
+    }
+    
+    void destroy()
+    {
+      return do_destroy();
+    }
+    statistic()
+      :p_fitter(0)
+    {}
+    
+    statistic(const statistic& rhs)
+      :p_fitter(rhs.p_fitter)
+    {}
+
+    statistic& operator=(const statistic& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      p_fitter=rhs.p_fitter;
+      return *this;
+    }
+    
+    virtual ~statistic()
+    {}
+
+    virtual void set_fitter(fitter<Ty,Tx,Tp,Ts,Tstr>& pfitter)
+    {
+      p_fitter=&pfitter;
+    }
+
+    virtual const fitter<Ty,Tx,Tp,Ts,Tstr>& get_fitter()const
+    {
+      if(p_fitter==0)
+	{
+	  throw fitter_unset();
+	}
+      return *p_fitter;
+    }
+		
+    Ty eval_model(const Tx& x,const Tp& p)
+    {
+      if(p_fitter==0)
+	{
+	  throw fitter_unset();
+	}
+      return p_fitter->eval_model(x,p);
+    }
+
+		
+    const data_set<Ty,Tx>& datas()const
+    {
+      if(p_fitter==0)
+	{
+	  throw fitter_unset();
+	}
+      return p_fitter->datas();
+    }
+
+  };
+
+  template <typename Ty,typename Tx,typename Tp,typename Tstr=std::string>
+  class param_modifier
+  {
+  private:
+    model<Ty,Tx,Tp,Tstr>* p_model;
+  public:
+    Tp reform(const Tp& p)const
+    {
+      return do_reform(p);
+    }
+    Tp deform(const Tp& p)const
+    {
+      return do_deform(p);
+    }
+
+    param_modifier<Ty,Tx,Tp,Tstr>* clone()const
+    {
+      return do_clone();
+    }
+
+    void destroy()
+    {
+      do_destroy();
+    }
+
+  public:
+
+    param_modifier()
+      :p_model(0)
+    {}
+    
+    param_modifier(const param_modifier& rhs)
+      :p_model(rhs.p_model)
+    {}
+
+    param_modifier& operator=(const param_modifier& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      p_model=rhs.p_model;
+      return *this;
+    }
+    
+  public:
+    void set_model(model<Ty,Tx,Tp,Tstr>& pf)
+    {
+      p_model=&pf;
+      update();
+    }
+
+    const model<Ty,Tx,Tp,Tstr>& get_model()const
+    {
+      if(p_model==0)
+	{
+	  std::cout<<"dajf;asdjfk;";
+	  throw model_undefined();
+	}
+      return *(this->p_model);
+    }
+
+    int get_num_free_params()const
+    {
+      return do_get_num_free_params();
+    }
+
+    Tstr report_param_status(const Tstr& name)const
+    {
+      return do_report_param_status(name);
+    }
+
+
+    virtual ~param_modifier(){}
+  private:
+    virtual Tp do_reform(const Tp& p)const=0;
+    virtual Tp do_deform(const Tp& p)const=0;
+    virtual int do_get_num_free_params()const=0;
+    virtual Tstr do_report_param_status(const Tstr&)const=0;
+    virtual void update(){}
+
+    virtual param_modifier<Ty,Tx,Tp,Tstr>* do_clone()const=0;
+    
+    virtual void do_destroy()
+    {
+      delete this;
+    }
+
+  };
+  
+
+  
+};
+
+
+#endif
+//EOF
diff --git a/core/freeze_param.hpp b/core/freeze_param.hpp
new file mode 100644
index 0000000..8ba677a
--- /dev/null
+++ b/core/freeze_param.hpp
@@ -0,0 +1,204 @@
+#ifndef FREEZE_PARAM_HPP
+#define FREEZE_PARAM_HPP
+#include "fitter.hpp"
+#include <vector>
+#include <set>
+
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx,typename Tp,typename Tstr=std::string>
+  class freeze_param
+    :public param_modifier<Ty,Tx,Tp,Tstr>
+  {
+  private:
+    std::set<Tstr> param_names;
+    std::vector<int> param_num;
+    int num_free;
+    
+  public:
+    freeze_param()
+    {
+      
+    }
+
+    freeze_param(const Tstr& name)
+    {
+      param_names.insert(name);
+    }
+    
+  private:
+    freeze_param<Ty,Tx,Tp,Tstr>* do_clone()const
+    {
+      return new freeze_param<Ty,Tx,Tp,Tstr>(*this);
+    }
+    
+    
+
+    void update()
+    {
+      param_num.clear();
+      for(typename std::set<Tstr>::const_iterator  i=param_names.begin();
+	  i!=param_names.end();++i)
+	{
+	  try
+	    {
+	      param_num.push_back(this->get_model().get_param_order(*i));
+	    }
+	  catch(opt_exception& e)
+	    {
+	      param_names.erase(*i);
+	      throw;
+	    }
+	  
+	}
+    }
+
+    int do_get_num_free_params()const
+    {
+      return this->get_model().get_num_params()-param_num.size();
+    }
+
+    bool is_frozen(int i)const
+    {
+      if(find(param_num.begin(),param_num.end(),i)==param_num.end())
+	{
+	  return false;
+	}
+      return true;
+    }
+
+
+    Tp do_reform(const Tp& p)const
+    {
+      int nparams=(this->get_model().get_num_params());
+      Tp reformed_p(nparams);
+      int i=0,j=0;
+      for(i=0;i<(int)nparams;++i)
+	{
+	  if(this->is_frozen(i))
+	    {
+	      const param_info<Tp,Tstr>& pinf=this->get_model().get_param_info(i);
+	      //std::cout<<"frozen:"<<pinf.get_name()
+	      //	       <<i<<"\t"<<j
+	      //       <<std::endl;
+	      //opt_eq(get_element(reformed_p,i),pinf.get_default_value());
+	      set_element(reformed_p,i,pinf.get_default_value());
+	    }
+	  else
+	    {
+	      //opt_eq(get_element(reformed_p,i),get_element(p,j));
+	      set_element(reformed_p,i,get_element(p,j));
+	      j++;
+	    }
+	}
+      /*
+      for(int i=0;i<reformed_p.size();++i)
+      {
+      std::cout<<get_element(reformed_p,i)<<",";
+      }
+      */
+      //std::cout<<"\n";
+      return reformed_p;
+      // return p;
+    }
+
+    Tp do_deform(const Tp& p)const
+    {
+      Tp deformed_p(do_get_num_free_params());
+      int i(0),j(0);
+      assert(get_size(p)==this->get_model().get_num_params());
+      for(;i<(int)get_size(p);++i)
+	{
+	  //std::cout<<is_frozen(j)<<"\n";
+	  if(!this->is_frozen(i))
+	    {
+	      //opt_eq(get_element(deformed_p,j),get_element(p,i));
+	      set_element(deformed_p,j,get_element(p,i));
+	      j++;
+	    }
+	}
+      
+      assert(j==do_get_num_free_params());
+      return deformed_p;
+    }
+
+
+    Tstr do_report_param_status(const Tstr& name)const
+    {
+      if(param_names.find(name)==param_names.end())
+	{
+	  return "thawed";
+	}
+      return "frozen";
+    }
+
+  public:
+    freeze_param operator+(const freeze_param& fp)const
+    {
+      freeze_param result(*this);
+      for(typename std::set<Tstr>::const_iterator i=fp.param_names.begin();
+	  i!=fp.param_names.end();
+	  ++i)
+	{
+	  result.param_names.insert(*i);
+	}
+      return result;
+    }
+
+    freeze_param& operator+=(const freeze_param& fp)
+    {
+      //param_names.insert(param_names.end(),
+      //fp.param_names.begin(),
+      //fp.param_names.end());
+      for(typename std::set<Tstr>::const_iterator i=fp.param_names.begin();
+	  i!=fp.param_names.end();
+	  ++i)
+	{
+	  param_names.insert(*i);
+	}
+      try
+	{
+	  update();
+	}
+      catch(opt_exception& e)
+	{
+	  throw;
+	}
+      return *this;
+    }
+
+    freeze_param& operator-=(const freeze_param& fp)
+    {
+      //param_names.insert(param_names.end(),
+      //fp.param_names.begin(),
+      //fp.param_names.end());
+      for(typename std::set<Tstr>::const_iterator i=fp.param_names.begin();
+	  i!=fp.param_names.end();
+	  ++i)
+	{
+	  param_names.erase(*i);
+	}
+      try
+	{
+	  update();
+	}
+      catch(opt_exception& e)
+	{
+	  throw;
+	}
+      return *this;
+    }
+
+  };
+
+  template <typename Ty,typename Tx,typename Tp,typename Tstr>
+  freeze_param<Ty,Tx,Tp,Tstr> freeze(const Tstr& name)
+  {
+    return freeze_param<Ty,Tx,Tp,Tstr>(name);
+  }
+
+};
+
+
+#endif
+//EOF
diff --git a/core/opt_exception.hpp b/core/opt_exception.hpp
new file mode 100644
index 0000000..925e4b5
--- /dev/null
+++ b/core/opt_exception.hpp
@@ -0,0 +1,106 @@
+#ifndef OPT_EXCEPTION
+#define OPT_EXCEPTION
+#include <string>
+#include <exception>
+namespace opt_utilities
+{
+  class opt_exception
+    :public std::exception
+  {
+  private:
+    std::string _what;
+  public:
+    opt_exception()
+    {};
+    
+    ~opt_exception()throw()
+    {}
+    
+    opt_exception(const std::string& str)
+      :_what(str)
+    {}
+
+    const char* what()const throw()
+    {
+      return _what.c_str();
+    }
+  };
+  
+  class target_function_undefined
+    :public opt_exception
+  {
+  public:
+    target_function_undefined()
+      :opt_exception("target function undefined")
+    {}
+  };
+
+  class opt_method_undefined
+    :public opt_exception
+  {
+  public:
+    opt_method_undefined()
+      :opt_exception("opt method undefined")
+    {}
+  };
+  
+  class fitter_unset
+    :public opt_exception
+  {
+  public:
+    fitter_unset()
+      :opt_exception("fitter_unset")
+    {}
+  };
+
+  class model_undefined
+    :public opt_exception
+  {
+  public:
+    model_undefined()
+      :opt_exception("model_undefined")
+    {}
+  };
+
+  class data_unloaded
+    :public opt_exception
+  {
+  public:
+    data_unloaded()
+      :opt_exception("data not loaded")
+    {}
+  };
+
+
+  class statistic_undefined
+    :public opt_exception
+  {
+  public:
+    statistic_undefined()
+      :opt_exception("statistic undefined")
+    {}
+  };
+  
+  class param_not_found
+    :public opt_exception
+  {
+  public:
+    param_not_found()
+      :opt_exception("param name invalid")
+    {}
+  };
+  
+  class param_modifier_undefined
+    :public opt_exception
+  {
+  public:
+    param_modifier_undefined()
+      :opt_exception("param modifier undefined")
+    {}
+  };
+
+};
+
+
+#endif
+//EOF
diff --git a/core/opt_traits.hpp b/core/opt_traits.hpp
new file mode 100644
index 0000000..c539a63
--- /dev/null
+++ b/core/opt_traits.hpp
@@ -0,0 +1,64 @@
+#ifndef ARRAY_OPERATION
+#define ARRAY_OPERATION
+#include <cstddef>
+namespace opt_utilities
+{
+  /////////Useful function///////////////////////////////////
+  template <typename T>
+  inline size_t get_size(const T& x)
+  {
+    return x.size();
+  }
+  
+  template <typename T>
+  class element_type_trait
+  {
+  public:
+    typedef typename T::value_type element_type;
+  };
+
+  template <typename T>
+  class return_type_trait
+  {
+  public:
+    typedef T value_type;
+    typedef T& reference_type;
+    typedef const T& const_reference_type;
+  };
+  
+  template <typename T>
+  inline typename return_type_trait<typename element_type_trait<T>::element_type>::const_reference_type get_element(const T& x,size_t i)
+  {
+    return x[i];
+  }
+  /*
+  template <typename T>
+  inline typename element_type_trait<T>::element_type& get_element(T& x,size_t i)
+  {
+    return x[i];
+  }
+  */
+
+  template<typename T,typename TX>
+  inline void set_element(T& x,size_t i,
+			  const TX& v)
+  {
+    x[i]=v;
+  }
+
+  template <typename T>
+  inline void resize(T& x,size_t s)
+  {
+    x.resize(s);
+  }
+
+  template <typename Tl,typename Tr>
+  inline Tl& opt_eq(Tl& lhs,const Tr& rhs)
+  {
+    return (lhs=rhs);
+  }
+};
+
+
+
+#endif
diff --git a/core/optimizer.hpp b/core/optimizer.hpp
new file mode 100644
index 0000000..ca73775
--- /dev/null
+++ b/core/optimizer.hpp
@@ -0,0 +1,289 @@
+#ifndef OPTIMZER_H_
+#define OPTIMZER_H_
+//#define DEBUG
+#include <cstddef>
+#include "opt_traits.hpp"
+#include "opt_exception.hpp"
+#include <cstdlib>
+#include <functional>
+#ifdef DEBUG
+#include <iostream>
+using namespace std;
+#endif
+
+namespace opt_utilities
+{
+  /////////Forward declare///////////////////////////////////
+  template <typename rT,typename pT>
+  class optimizer;
+  
+  template <typename rT,typename pT>
+  class func_obj;
+  
+  template <typename rT,typename pT>
+  class opt_method;
+
+
+  //////////////Target Function/////////////////////
+  ///An eval function should be implemented/////////
+  ///The eval function return the function value////
+  ///which is wrapped by the func_obj///////////////
+  //////////////////////////////////////////////////
+  template <typename rT,typename pT>
+  class func_obj
+    :public std::unary_function<pT,rT>
+  {
+  private:
+    virtual rT do_eval(const pT&)=0;
+    virtual func_obj<rT,pT>* do_clone()const=0;
+    virtual void do_destroy()
+    {
+      delete this;
+    }
+
+  public:
+  public:
+    func_obj<rT,pT>* clone()const
+    {
+      return do_clone();
+    }
+
+    void destroy()
+    {
+      do_destroy();
+    }
+
+    rT operator()(const pT& p)
+    {
+      return do_eval(p);
+    }
+    
+
+    rT eval(const pT& p)
+    {
+      return do_eval(p);
+    };
+    virtual ~func_obj(){};
+    //    virtual XT walk(XT,YT)=0;
+  };
+  
+
+  ///////////////Optimization method//////////////////////
+  
+  template <typename rT,typename pT>
+  class opt_method
+  {
+  public:
+    virtual void do_set_optimizer(optimizer<rT,pT>&)=0;
+    virtual void do_set_precision(rT)=0;
+    virtual pT do_optimize()=0;
+    virtual void do_set_start_point(const pT& p)=0;
+    virtual opt_method<rT,pT>* do_clone()const=0;
+
+    virtual void do_destroy()
+    {
+      delete this;
+    }
+  public:
+    void  set_optimizer(optimizer<rT,pT>& op)
+      {
+	do_set_optimizer(op);
+      };
+
+    void set_precision(rT x)
+    {
+      do_set_precision(x);
+    }
+
+    void set_start_point(const pT& p)
+    {
+      do_set_start_point(p);
+    }
+    
+    pT optimize()
+      {
+	return do_optimize();
+      };
+    
+    opt_method<rT,pT>* clone()const
+    {
+      return do_clone();
+    }
+
+    void destroy()
+    {
+      do_destroy();
+    }
+
+    virtual ~opt_method(){};
+  };
+  
+  
+  ///////////Optimizer////////////////////////////////////
+  template <typename rT,typename pT>
+  class optimizer
+  {
+  public:
+
+  private:
+
+    ////////////pointer to an optimization method objection////////////
+    ////////////The optimization method implements a certain method ///
+    ////////////Currently only Mont-carlo method is implemented////////
+    opt_method<rT,pT>* p_opt_method;
+    func_obj<rT,pT>* p_func_obj;
+    
+  public:
+     optimizer()
+      :p_opt_method(0),p_func_obj(0)
+    {}
+
+    optimizer(func_obj<rT,pT>& fc,const opt_method<rT,pT>& om)
+      :p_func_obj(fc.clone()),p_opt_method(om.clone())
+    {
+      p_opt_method->set_optimizer(*this);
+    }
+    
+    optimizer(const optimizer& rhs)
+      :p_opt_method(0),p_func_obj(0)
+    {
+      if(rhs.p_func_obj!=0)
+	{
+	  set_func_obj(*(rhs.p_func_obj));
+	}
+      if(rhs.p_opt_method!=0)
+	{
+	  set_opt_method(*(rhs.p_opt_method));
+	}
+    }
+
+    optimizer& operator=(const optimizer& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      if(rhs.p_func_obj!=0)
+	{
+	  set_func_obj(*(rhs.p_func_obj));
+	}
+      if(rhs.p_opt_method!=0)
+	{
+	  set_opt_method(*(rhs.p_opt_method));
+	}
+      return *this;
+    }
+    
+
+    virtual ~optimizer()
+    {
+      if(p_func_obj!=0)
+	{
+	  //delete p_func_obj;
+	  p_func_obj->destroy();
+	}
+      if(p_opt_method!=0)
+	{
+	  //delete p_opt_method;
+	  p_opt_method->destroy();
+	}
+    };
+
+  public:
+    ////////////Re-set target function object///////////////////////////
+    void set_func_obj(const func_obj<rT,pT>& fc)
+    {
+      if(p_func_obj!=0)
+	{
+	  //delete p_func_obj;
+	  p_func_obj->destroy();
+	}
+      p_func_obj=fc.clone();
+      if(p_opt_method!=0)
+	{
+	  p_opt_method->set_optimizer(*this);
+	}
+    }
+
+    ////////////Re-set optimization method//////////////////////////////
+    void set_opt_method(const opt_method<rT,pT>& om)
+    {
+      if(p_opt_method!=0)
+	{
+	  //delete p_opt_method;
+	  p_opt_method->destroy();
+	}
+      
+      p_opt_method=om.clone();
+      p_opt_method->set_optimizer(*this);
+    }
+
+    opt_method<rT,pT>& method()
+    {
+      if(p_opt_method==0)
+	{
+	  throw opt_method_undefined();
+	}
+      return *(this->p_opt_method);
+    }
+
+    void set_precision(rT x)
+    {
+      if(p_opt_method==0)
+	{
+	  throw opt_method_undefined();
+	}
+      p_opt_method->set_precision(x);
+    }
+
+    void set_start_point(const pT& x)
+    {
+      if(p_opt_method==0)
+	{
+	  throw opt_method_undefined();
+	}
+      p_opt_method->set_start_point(x);
+    }
+    
+    ////////////Just call the eval function in the target function object///
+    ////////////In case the pointer to a target function is uninitialed/////
+    ////////////a zero-value is returned////////////////////////////////////
+    rT eval(const pT& x)
+    {
+      if(p_func_obj==0)
+	{
+	  throw target_function_undefined();
+	}
+      return p_func_obj->eval(x);
+    }
+
+	
+
+    ////////////Just call the optimize() function in the optimization method//
+    ////////////If no optimization method is given, an zero-value is returned/
+    pT optimize()
+    {
+      if(p_opt_method==0)
+	{
+	  throw opt_method_undefined();
+	}
+      if(p_func_obj==0)
+	{
+	  throw target_function_undefined();
+	}
+      return p_opt_method->optimize();
+    }
+    
+    ////////////Function that offers the access to the target function object///
+    func_obj<rT,pT>* ptr_func_obj()
+    {
+      return p_func_obj;
+    }
+    
+  };
+};
+  
+#endif
+//EOF
+
+
diff --git a/guide.pdf b/guide.pdf
new file mode 100644
index 0000000..3a8a39d
--- /dev/null
+++ b/guide.pdf
diff --git a/history.log b/history.log
new file mode 100644
index 0000000..7adefdd
--- /dev/null
+++ b/history.log
@@ -0,0 +1,239 @@
+2008 Jan 21 
+	changed all std::string in parameter table to const std::string&
+	version 2.9.12
+2008 Jan 22
+	changed optimizer::eval(pT& x) -> optimizer::eval(const pT& x)
+	version 2.9 13
+2008 Jan 22
+	changed data::set_x(Tx x)->data::set_x(const Tx& x)
+	version 2.9.14
+2008 Jan 22
+	changed the parameter set_param_value to a const reference.
+	version 2.10.1
+
+2008 Jan 23
+	removed the declaration of init_model_map etc. in models.hpp
+	version 2.10.2
+
+2008 Jan 24
+	added get_strm1d() interface to models.hpp and models.cc
+	version 2.10.3
+
+2008 Feb 11
+	modified some mistakes in models/ modified the nr_util, add T() in '?' expressions
+	version 2.11.1
+2008 Feb 12
+	modified powell_method.hpp to enable the lib work around apfloat
+	version 2.11.2
+
+2008 Feb 19
+	modified the design of the data_loaders, add members:load_from, deleted the friend template declear in the class.
+	modified the fitter class, corrected a bug which happens when all parameters are frozen, the fitter will crash.
+	version 2.11.3
+
+
+2008 March 14
+	Added a condition compiling to the dynamical load model
+	
+
+2008 March 21
+	Modified a contition compiling to the dynamical load model, changed the marco from LINUX__ to __linux__
+
+2008 March 27
+	Made std::unary_function the base class of func_obj
+	version 2.12.1
+	
+2008 April 18
+	Added nbeta1d into the model list
+	version 2.12.2
+
+2008 May 10
+	Added a bremss model
+	Added an opt_type.hpp
+	version 2.12.3
+
+2008 May 12
+	Added the declearation of virtual dstr function to some class
+	version 2.12.4
+	
+
+2008 May 13
+	Modified the makefile, to generate liboptutil.a
+	version 2.12.5
+
+2008 May 14
+	Updated the c/fortran callable interface
+	version 2.12.6
+
+2008 May 22
+	Modified the symbol definition of interface
+	version 2.12.7
+
+2008 June 1
+	Added the <cassert> in the file fitter.hpp
+	version 2.12.8
+
+2008 June 12
+	Added NFW1D model
+	Cleaned some warnings
+	version 2.12.9
+
+2008 Jun 19
+	Modified fit2d task. Enables it to write fits file.
+	version 2.12.10
+
+2008 Jun 23
+	Modified the LINUX marco in models.cc
+	version 2.12.11
+
+2008 Jun 25
+	Added a pow_model, to enable power computation on models.
+	version 2.12.12
+
+2008 Jun 27
+	Added the function to query the number of build-in 1d and 2d models. 
+	version 2.12.13
+
+
+2008 Jul 1
+	Added a to_string and corresponding do_to_string method to class model. 
+	version 2.13.0
+	
+
+2008 Jul 1
+	Implemented the do_to_string method in most 1d models
+	version 2.13.1
+
+
+2008 Jul 7
+	Added another gsl_simplex method to perform the optimization.
+	version 2.14.0
+
+2008 Jul 8
+	Modified one bug caused by the head inclusion. The <cmath> should be included.
+	version 2.14.1
+
+
+2008 Jul 8
+	Enables the optcli program to display model infomation
+	version 2.14.2
+
+2008 Jul 8
+	Changed the methods include of head files.
+	Version 2.14.3
+
+2008 Jul 10
+	Corrected the include of optimizer.hpp in gsl_methods/gsl_simplex.hpp
+	version 2.14.4
+
+2008 Jul 12
+     	 Corrected the ``comparison between signed and unsigned integer'' warning
+	 version 2.14.5
+
+2008 Jul 14
+     	 Modified the interface get_data in data_set class. 
+	 Changed the return value from data to const data&
+	 version 2.15.0
+
+2008 Jul 19
+     	 Corrected a bug in gsl_simplex.hpp
+	 version 2.15.1
+	 
+2008 Jul 21
+     	 Corrected the makefile in interface/
+	 version 2.15.2
+
+2008 Jul 22
+     	 Moved some files from core/ to separated folder.
+	 version 2.15.3
+
+2008 Jul 22
+     	 version 2.15.4
+
+2008 Jul 24
+     	 Modified the makefile
+	 version 2.15.5
+
+2008 Jul 24
+     	 Changed the project name from optimizer to opt_utilities
+	 version 2.15.6
+
+2008 Jul 25
+     	 Enable the 'ls' command to display with color
+	 version 2.15.7
+
+2008 Aug 15
+     	 Changed the x[i] into get_element(x,i), 
+	 Changed the x.size() into get_size(x).
+	 version 2.16.0
+
+2008 Aug 15
+     	 Some further modification, added opt_eq function to represent '=' operation. 
+	 version 2.16.1
+
+2008 Aug 15
+     	 Modified some bugs
+	 version 2.16.2
+
+2008 Aug 16
+     	 Added a set_element function
+	 version 2.16.3
+
+2008 Aug 17
+     	 Changed the argument type of opt_get from single 'T' to 'Tl'  and 'Tr' 
+	 version 2.16.4
+
+2008 Aug 18
+     	 Make the makefile more standard.
+	 version 2.16.5
+
+2008 Aug 22
+     	 Added the inclusion of <cstddef> in array_operation.h
+	 version 2.16.6
+
+2008 Aug 24
+     	 Added ./termcap to the inclusion of CFLAG
+	 version 2.16.7
+
+2008 Aug 25
+     	 Modified the return type of param_info::get_default_value from T to const T&
+	 version 2.16.8
+2008 Aug 25
+     	 modifier a return type, added a const
+	 version 2.16.9
+
+2008 Aug 26
+     	 Enabled the chisq statistic to take account of the x error
+	 version 2.16.10
+
+2008 Sep 2
+     	 added a virtual function to some classes to enable them to destroy themselves.
+	 version 2.16.11
+
+2008 Sep 5
+     	 changed the name value_type_trait to element_type_trait, added a return_type_trait
+	 version 2.16.12
+
+2008 Sep 27
+     	 Corrected two bugs in the add_model.hpp and mul_model.hpp
+	 version 2.16.13
+
+2008 Oct 3
+     	 Stripped the subpackages that uses GPL from it
+	 version 2.17.0
+
+2008 Nov 24
+     	 Replaced all std::string with an extra template parameter Tstr, enables the ability of treating Unicode strings
+	 version 2.18.0
+
+2008 Nov 25
+     	 Completed the exception tree
+	 version 2.19.0
+
+2008 Nov 25
+     	 modified some string type related codes
+	 version 2.19.1
+
+2008 Nov 27
+     	 corrected const correction in freeze_param.hpp
+	 version 2.19.2
diff --git a/interface/makefile b/interface/makefile
new file mode 100644
index 0000000..5cf7a99
--- /dev/null
+++ b/interface/makefile
@@ -0,0 +1,13 @@
+INC=-I../
+
+
+libopt.a:opt.o
+	$(AR) $@ opt.o
+
+opt.o:opt.cc opt.h
+	$(CPP) $< -o $@ $(INC) $(CPPFLAGS)
+
+
+clean:
+	$(RM) *.o
+	$(RM) *~
diff --git a/interface/opt.cc b/interface/opt.cc
new file mode 100644
index 0000000..51762f5
--- /dev/null
+++ b/interface/opt.cc
@@ -0,0 +1,181 @@
+#include "opt.h"
+#include <utilities/opt_types.hpp>
+#include <models/models.hpp>
+#include <map>
+#include <core/freeze_param.hpp>
+#include <core/default_data_set.hpp>
+//#include <iostream>
+
+using namespace std;
+using namespace opt_utilities;
+const static int max_fit_space_num=100;
+struct fit_space;
+static map<int,fit_space> fit_space_map;
+struct fit_space
+{
+  dopt::fitter fit;
+  ///  dopt::model model;
+  fit_space()
+  {
+    fit.set_method(dopt::powell_method());
+    dopt::chisq cq;
+    //  cq.verbose(true);
+    fit.set_statistic(cq);
+  }
+  
+};
+
+
+extern "C"
+{
+
+void alloc_fit_(int& n)
+{
+  n=0;
+  for(int i=1;i<max_fit_space_num;++i)
+    {
+      if(fit_space_map.find(i)==fit_space_map.end())
+	{
+	  fit_space_map.insert(make_pair(i,fit_space()));
+	  //cout<<i<<endl;
+	  //return i;
+	  n=i;
+	  break;
+	}
+    }
+  
+  return;
+}
+
+
+void free_fit_(const int& n)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(n);
+  if(iter==fit_space_map.end())
+    {
+      return;
+    }
+  fit_space_map.erase(iter);
+}
+
+void load_data_(const int& nfit,const int& ndatas,double* x,double* y,double* yl,double* yu,double* xl,double* xu)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  if(iter==fit_space_map.end())
+    {
+      return;
+    }
+  //  cout<<x[0]<<endl;
+  default_data_set<double,double> ds;
+  for(int i=0;i<ndatas;++i)
+    {
+      data<double,double> d(x[i],y[i],yl[i],(yu==0?yl[i]:yu[i]),(xl==0?0:xl[i]),(xu==0?0:xu[i]));
+      //  cout<<x[i]<<" "<<y[i]<<endl;
+      ds.push_back(d);
+    }
+  iter->second.fit.load_data(ds);
+}
+
+
+void set_model_(const int& nfit,const char* model_name)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  
+  if(iter==fit_space_map.end())
+    {
+      cerr<<"fit not found"<<endl;
+      return;
+    }
+  try
+    {
+      iter->second.fit.set_model(opt_utilities::get_1dmodel_by_name(model_name));
+    }
+  catch(opt_exception& e)
+  {
+    //cout<<model_name<<endl;
+    cout<<e.what()<<endl;
+    throw e;
+  }
+}
+
+void set_param_(const int& nfit,const char* pname,const double& value)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  cerr<<"pname="<<pname<<endl;
+  cerr<<"value="<<value<<endl;
+  if(iter==fit_space_map.end())
+    {
+      cerr<<"fit not found"<<endl;
+      return;
+    }
+  iter->second.fit.set_param_value(pname,value);
+}
+
+
+void freeze_param_(const int& nfit,const char* pname)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  if(iter==fit_space_map.end())
+    {
+      return;
+    }
+  opt_utilities::freeze_param<double,double,std::vector<double> > fp(pname);
+  try
+    {
+      dynamic_cast<opt_utilities::freeze_param<double,double,vector<double> >& >(iter->second.fit.get_param_modifier())+=fp;
+    }
+  catch(opt_exception& e)
+    {
+      iter->second.fit.set_param_modifier(fp);
+    }
+}
+
+
+void thaw_param_(const int& nfit,const char* pname)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  if(iter==fit_space_map.end())
+    {
+      return;
+    }
+  opt_utilities::freeze_param<double,double,std::vector<double> > fp(pname);
+  try
+    {
+      dynamic_cast<opt_utilities::freeze_param<double,double,vector<double> >& >(iter->second.fit.get_param_modifier())-=fp;
+    }
+  catch(opt_exception& e)
+    {
+      //iter->second.fit.set_param_modifier(fp);
+    }
+}
+
+void perform_fit_(const int& nfit)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  if(iter==fit_space_map.end())
+    {
+      return;
+    }
+  iter->second.fit.fit();
+}
+
+
+void get_param_(const int& nfit,double& r,const char* pname)
+{
+  map<int,fit_space>::iterator iter=fit_space_map.find(nfit);
+  if(iter==fit_space_map.end())
+    {
+      //return 0;
+      cerr<<"fit not found"<<endl;
+      r=0;
+      return;
+    }
+  //  cerr<<"fdsaf"<<r<<endl;
+  r=iter->second.fit.get_param_value(pname);
+  
+}
+
+
+
+}
+
diff --git a/interface/opt.h b/interface/opt.h
new file mode 100644
index 0000000..e9c3221
--- /dev/null
+++ b/interface/opt.h
@@ -0,0 +1,29 @@
+#ifndef OPT_H
+#define OPT_H
+#define F77
+#ifdef F77
+#define alloc_fit_ alloc_fit__
+#define free_fit_ free_fit__
+#define load_data_ load_data__
+#define set_model_ set_model__
+#define set_param_ set_param__
+#define freeze_param_ freeze_param__
+#define thaw_param_ thaw_param__
+#define perform_fit_ perform_fit__
+#define get_param_ get_param__
+#endif
+
+extern "C"
+{
+  void alloc_fit_(int&);
+  void free_fit_(const int& nxc);
+  void load_data_(const int& nfit,const int& ndatas,double* x,double* y,double* yl,double* yu=0,double* xl=0,double* xu=0);
+  void set_model_(const int& nfit,const char* model_name);
+  void set_param_(const int& nfit,const char* param_name,const double& value);
+  void freeze_param_(const int& nfit,const char* param_name);
+  void thraw_param_(const int& nfit,const char* param_name);
+  void perform_fit_(const int& nfit);
+  void get_param_(const int& nfit,double& r,const char* param_name);
+}
+
+#endif
diff --git a/makefile b/makefile
new file mode 100644
index 0000000..e40ac11
--- /dev/null
+++ b/makefile
@@ -0,0 +1,67 @@
+OPT_HEADS=models/beta1d.hpp  statistics/chisq.hpp    models/lin1d.hpp\
+      models/pl1d.hpp models/bl1d.hpp\
+	core/fitter.hpp models/models.hpp\
+	core/opt_traits.hpp\
+	methods/powell/powell_method.hpp models/bpl1d.hpp\
+	core/freeze_param.hpp\
+	models/gauss1d.hpp core/optimizer.hpp\
+	misc/bootstrap.hpp\
+	models/dl_model.hpp\
+	models/mul_model.hpp\
+	models/add_model.hpp\
+
+LDL=-ldl
+
+export CPP=g++
+export CC=gcc
+export AR = ar rv
+export RANLIB = ranlib
+export RM=rm -f
+export CFLAGS=-DNDEBUG -g -O2 -Wall -c -I . 
+export CPPFLAGS=-DNDEBUG -g -O2 -Wall -c -I . --ansi -DHAVE_X_ERROR
+
+
+INC=-I. -I/usr/include/gsl/
+LIB= -L./muparser  $(LDL) -lmuparser -g -lgsl -lgslcblas
+OPT_OBJ=models/models.o version_ctrl.o models/strmodel1d.o
+
+TARGET=liboptcall test_dl.so models/strmodel1d.o models/models.o
+
+all: $(TARGET)
+
+models/models.o:models/models.cc ${OPT_HEADS}
+	$(CPP) -c $< -o $@ ${INC} ${CPPFLAGS}
+
+version_ctrl.o:version_ctrl.cc
+	$(CPP) -c $< ${CPPFLAGS}
+
+bin/test.o:test.cc ${OPT_HEADS}
+	$(CPP) -c $< -o $@ ${INC} ${CPPFLAGS} --ansi
+
+test:${OPT_OBJ} bin/test.o
+	$(CPP) bin/test.o models/strmodel1d.o models/models.o version_ctrl.o -o $@ ${LIB}
+
+test_dl.so:models/dlmodel_template.c
+	gcc $< --shared -o $@
+
+
+models/strmodel1d.o:models/strmodel1d.cc models/strmodel1d.hpp
+	$(CPP) -c $< -o $@ -I./muparser $(INC) $(CPPFLAGS)
+
+
+libmuparser:
+	make -C muparser
+
+liboptcall:
+	make -C interface
+
+clean:
+	rm -f `find .|grep \~`
+	rm -f `find .|grep '\.o'`
+	rm -f muparser/libmuparser.a
+	make -C muparser clean
+	make -C interface clean
+
+distclean:clean
+	rm -f `find . -iname *.a`
+	rm -f $(TARGET)
diff --git a/methods/gsl_simplex/gsl_simplex.hpp b/methods/gsl_simplex/gsl_simplex.hpp
new file mode 100644
index 0000000..442c9f0
--- /dev/null
+++ b/methods/gsl_simplex/gsl_simplex.hpp
@@ -0,0 +1,199 @@
+#ifndef GSL_SIMPLEX_METHOD
+#define GSL_SIMPLEX_METHOD
+#include <core/optimizer.hpp>
+//#include <blitz/array.h>
+#include <vector>
+#include <limits>
+#include <cassert>
+#include <cmath>
+#include <algorithm>
+#include <gsl_multimin.h>
+/*
+ *
+*/
+#include <iostream>
+
+
+namespace opt_utilities
+{
+  template <typename rT,typename pT>
+  double gsl_func_adapter(const gsl_vector* v,void* params)
+  {
+    pT temp;
+    temp.resize(v->size);
+    for(size_t i=0;i<get_size(temp);++i)
+      {
+	set_element(temp,i,gsl_vector_get(v,i));
+      }
+    return ((func_obj<rT,pT>*)params)->eval(temp);
+  }
+
+
+  template <typename rT,typename pT>
+  class gsl_simplex
+    :public opt_method<rT,pT>
+  {
+  public:
+    typedef pT array1d_type;
+    typedef rT T;
+  private:
+    func_obj<rT,pT>* p_fo;
+    optimizer<rT,pT>* p_optimizer;
+    
+    //typedef blitz::Array<rT,2> array2d_type;
+    
+    
+  private:
+    array1d_type start_point;
+    array1d_type end_point;
+    
+  private:
+    rT threshold;
+  private:
+    rT func(const pT& x)
+    {
+      assert(p_fo!=0);
+      return p_fo->eval(x);
+    }
+
+   
+  public:
+    gsl_simplex()
+      :threshold(1e-4)
+    {}
+
+    virtual ~gsl_simplex()
+    {
+    };
+
+    gsl_simplex(const gsl_simplex<rT,pT>& rhs)
+      :p_fo(rhs.p_fo),p_optimizer(rhs.p_optimizer),
+       start_point(rhs.start_point),
+       end_point(rhs.end_point),
+       threshold(rhs.threshold)
+    {
+    }
+
+    gsl_simplex<rT,pT>& operator=(const gsl_simplex<rT,pT>& rhs)
+    {
+      threshold=rhs.threshold;
+      p_fo=rhs.p_fo;
+      p_optimizer=rhs.p_optimizer;
+      opt_eq(start_point,rhs.start_point);
+      opt_eq(end_point,rhs.end_point);
+    }
+    
+    opt_method<rT,pT>* do_clone()const
+    {
+      return new gsl_simplex<rT,pT>(*this);
+    }
+    
+    void do_set_start_point(const array1d_type& p)
+    {
+      start_point.resize(get_size(p));
+      opt_eq(start_point,p);
+      
+    }
+
+    void do_set_precision(rT t)
+    {
+      threshold=t;
+    }
+
+    void do_set_optimizer(optimizer<rT,pT>& o)
+    {
+      p_optimizer=&o;
+      p_fo=p_optimizer->ptr_func_obj();
+    }
+    
+    
+    
+    pT do_optimize()
+    {
+      const gsl_multimin_fminimizer_type *T = 
+	gsl_multimin_fminimizer_nmsimplex;
+      gsl_multimin_fminimizer *s = NULL;
+      gsl_vector *ss, *x;
+      gsl_multimin_function minex_func;
+      
+      size_t iter = 0;
+      int status;
+      double size;
+      
+      /* Starting point */
+      x = gsl_vector_alloc (get_size(start_point));
+      //      gsl_vector_set (x, 0, 5.0);
+      //gsl_vector_set (x, 1, 7.0);
+      for(size_t i=0;i!=get_size(start_point);++i)
+	{
+	  gsl_vector_set(x,i,get_element(start_point,i));
+	}
+
+
+      /* Set initial step sizes to 1 */
+      ss = gsl_vector_alloc (get_size(start_point));
+      gsl_vector_set_all (ss, 1.0);
+
+
+      //foo f;
+      /* Initialize method and iterate */
+      minex_func.n = get_size(start_point);
+      minex_func.f = &gsl_func_adapter<double,std::vector<double> >;
+      minex_func.params = (void *)p_fo;
+      
+      s = gsl_multimin_fminimizer_alloc (T, get_size(start_point));
+      gsl_multimin_fminimizer_set (s, &minex_func, x, ss);
+      
+      do
+	{
+	  iter++;
+	  status = gsl_multimin_fminimizer_iterate(s);
+	  
+	  if (status) 
+	    break;
+	  //std::cerr<<"threshold="<<threshold<<std::endl;
+	  size = gsl_multimin_fminimizer_size (s);
+	  status = gsl_multimin_test_size (size, threshold);
+	  
+	  if (status == GSL_SUCCESS)
+	    {
+	      //printf ("converged to minimum at\n");
+	    }
+	  
+	  //printf ("%5d %10.3e %10.3ef f() = %7.3f size = %.3f\n", 
+	  //iter,
+	  //gsl_vector_get (s->x, 0), 
+	  //gsl_vector_get (s->x, 1), 
+	  //  s->fval, size);
+	}
+      while (status == GSL_CONTINUE && iter < 100);
+      
+      /*
+	foo f;
+	gsl_vector_set (x, 0, 0.0);
+	gsl_vector_set (x, 1, 0.0);
+	cout<<"fdsa ";
+	cout<<gsl_func_adapter<double,vector<double> >(x,(void*)&f)<<endl;;
+	
+      */
+      
+      end_point.resize(get_size(start_point));
+      for(size_t i=0;i<get_size(start_point);++i)
+	{
+	  set_element(end_point,i,gsl_vector_get(s->x,i));
+	}
+
+      gsl_vector_free(x);
+      gsl_vector_free(ss);
+      gsl_multimin_fminimizer_free (s);
+      
+      
+      return end_point;
+    } 
+  };
+  
+};
+
+
+#endif
+//EOF
diff --git a/methods/powell/bas_util.hpp b/methods/powell/bas_util.hpp
new file mode 100644
index 0000000..743dc3c
--- /dev/null
+++ b/methods/powell/bas_util.hpp
@@ -0,0 +1,63 @@
+#ifndef BAS_UTIL
+#define BAS_UTIL
+#include <core/opt_traits.hpp>
+namespace opt_utilities
+{
+  template <typename T>
+  T tabs(T x)
+  {
+    return T(x)<T(0)?T(-x):T(x);
+  }
+
+  template <typename T>
+  T sqr(T x)
+  {
+    return x*x;
+  }
+  
+  
+  template <typename T>
+  void shft3(T&a,T& b,T& c,T d)
+  {
+    opt_eq(a,b);
+    opt_eq(b,c);
+    opt_eq(c,d);
+  }
+
+  template <typename T>
+  void shft(T& a,T& b,T& c,T d)
+  {
+    opt_eq(a,b);
+    opt_eq(b,c);
+    opt_eq(c,d);
+  }
+  template <typename T>  
+  void swap(T& ax,T& bx)
+  {
+    //  swap(ax,bx);
+    T temp;
+    opt_eq(temp,ax);
+    opt_eq(ax,bx);
+    opt_eq(bx=temp);
+  }
+  
+  template <typename T>
+  T sign(const T& a,const T& b)
+  {
+    return b>=0?T(a>=0?T(a):T(-a)):T(a>=0?T(-a):T(a));
+  }
+  
+  template <typename T>
+  T max(T a,T b)
+  {
+    return b>a?T(b):T(a);
+  }
+
+  template <typename T>
+  void mov3(T& a,T& b,T& c, T& d,T& e,T& f)
+  {
+    opt_eq(a,d);opt_eq(b,e);opt_eq(c,f);
+  }
+}
+
+#endif
diff --git a/methods/powell/brent.hpp b/methods/powell/brent.hpp
new file mode 100644
index 0000000..cb3b962
--- /dev/null
+++ b/methods/powell/brent.hpp
@@ -0,0 +1,110 @@
+#ifndef BRENT_HPP
+#define BRENT_HPP
+#include <iostream>
+#include "bas_util.hpp"
+//#include "optimizer.hpp"
+namespace opt_utilities
+{
+  template<typename T>
+  T brent(T ax,T bx,T cx,func_obj<T,T>& f,T tol,T& xmin)
+  {
+    const int ITMAX=100;
+    const T CGOLD=0.3819660;
+    const T ZEPS=std::numeric_limits<T>::epsilon()*1.e-3;
+    
+    int iter;
+    T a=0,b=0,d(0),etemp=0,fu=0,fv=0,fw=0,fx=0,p=0,q=0
+      ,r=0,tol1=0,tol2=0,u=0,v=0,w=0,x=0,xm=0;
+    T e=0.;
+    a=(ax<cx?ax:cx);
+    b=(ax>cx?ax:cx);
+    x=w=v=bx;
+    fw=fv=fx=f.eval(x);
+    for(iter=0;iter<ITMAX;++iter)
+      {
+	xm=.5*(a+b);
+	tol2=2.*(tol1=tol*tabs(x)+ZEPS);
+	if(tabs(T(x-xm))<=(tol2-.5*(b-a)))
+	  {
+	    xmin=x;
+	    return fx;
+	  }
+	if(tabs(e)>tol1)
+	  {
+	    r=(x-w)*(fx-fv);
+	    q=(x-v)*(fx-fw);
+	    p=(x-v)*q-(x-w)*r;
+	    q=2.*(q-r);
+	    if(q>0.)
+	      {
+		p=-p;
+	      }
+	    q=tabs(q);
+	    etemp=e;
+	    e=d;
+	    if(tabs(p)>=tabs(T(T(.5)*p*etemp))||p<=q*(a-x)||p>=q*(b-x))
+	      {
+		d=CGOLD*(e=(x>=xm?a-x:b-x));
+	      }
+	    else
+	      {
+		d=p/q;
+		u=x+d;
+		if(u-a<tol2||b-u<tol2)
+		  {
+		    d=sign(tol1,T(xm-x));
+		  }
+	      }
+	    
+	  }
+	else
+	  {
+	    d=CGOLD*(e=(x>=xm?a-x:b-x));
+	  }
+	u=(tabs(d)>=tol1?x+d:x+sign(tol1,d));
+	fu=f.eval(u);
+	if(fu<=fx)
+	  {
+	    if(u>=x)
+	      {
+		a=x;
+	      }
+	    else
+	      {
+		b=x;
+	      }
+	    shft3(v,w,x,u);
+	    shft3(fv,fw,fx,fu);
+	  }
+	else
+	  {
+	    if(u<x)
+	      {
+		a=u;
+	      }
+	    else
+	      {
+		b=u;
+	      }
+	    if(fu<=fw||w==x)
+	      {
+		v=w;
+		w=u;
+		fv=fw;
+		fw=fu;
+	      }
+	    else if(fu<=fv||v==x||v==w)
+	      {
+		v=u;
+		fv=fu;
+	      }
+	  }
+      }
+    std::cerr<<"Too many iterations in brent"<<std::endl;
+    xmin=x;
+    return fx;
+    
+  }
+}
+
+#endif
diff --git a/methods/powell/linmin.hpp b/methods/powell/linmin.hpp
new file mode 100644
index 0000000..5ab5af0
--- /dev/null
+++ b/methods/powell/linmin.hpp
@@ -0,0 +1,102 @@
+#ifndef LINMIN_HPP
+#define LINMIN_HPP
+#include "mnbrak.hpp"
+#include "brent.hpp"
+#include <core/opt_traits.hpp>
+
+namespace opt_utilities
+{
+  template <typename rT,typename pT>
+  class func_adaptor
+    :public func_obj<rT,rT>
+  {
+  private:
+    const pT p1,xi1;
+    const func_obj<rT,pT>* pfoo;
+    func_adaptor(){}
+    func_adaptor(const func_adaptor&){}
+    
+  public:
+    /*
+    void set_origin(pT& p2)
+    {
+      p1=p2;
+    }
+    
+    void set_direction(pT& xi2)
+    {
+      xi1=xi2;
+    }
+    
+    void set_func_obj(func_obj<rT,pT>& foo)
+    {
+      pfoo=&foo;
+      }*/
+  public:
+    func_adaptor(const pT& _p,const pT& _xi,const func_obj<rT,pT>& pf)
+      :p1(_p),xi1(_xi),pfoo(&pf)
+    {}
+    
+  private:
+    func_obj<rT,rT>* do_clone()const
+    {
+      return new func_adaptor(*this);
+    }
+      
+    rT do_eval(const rT& x)
+    {
+      //assert(p1.size()==xi1.size());
+      
+      pT xt;
+      opt_eq(xt,p1);
+      for(size_t i=0;i<get_size(xt);++i)
+	{
+	  //get_element(xt,i)+=x*get_element((pT)xi1,i);
+	  set_element(xt,i,
+		      get_element(xt,i)+x*get_element((pT)xi1,i));
+	  //get_element((pT)xi1,i);
+	}
+      return const_cast<func_obj<rT,pT>&>(*pfoo).eval(xt);
+      //return x;
+    }
+  };
+  
+
+  template<typename rT,typename pT>
+  void linmin(pT& p,pT& xi,rT& fret,func_obj<rT,pT>& func)
+  {
+
+    //  assert(p.size()==10);
+    //assert(xi.size()==10);
+    func_adaptor<rT,pT> fadpt(p,xi,func);
+
+    int j=0;
+    const rT TOL=sqrt(std::numeric_limits<rT>::epsilon());
+    rT xx=0,xmin=0,fx=0,fb=0,fa=0,bx=0,ax=0;
+    int n=(int)get_size(p);
+
+
+    ax=0.;
+    xx=1.;
+    
+
+    mnbrak(ax,xx,bx,fa,fx,fb,fadpt);
+    //cout<<xx<<endl;
+    fret=brent(ax,xx,bx,fadpt,TOL,xmin);
+    //cout<<xmin<<endl;
+    for(j=0;j<n;++j)
+      {
+	//get_element(xi,j)*=xmin;
+	set_element(xi,j,
+		    get_element(xi,j)*xmin);
+	//get_element(p,j)+=get_element(xi,j);
+	set_element(p,j,
+		    get_element(p,j)+get_element(xi,j));
+      }
+    //  delete xicom_p;
+    //delete pcom_p;
+  }
+}
+
+
+#endif
diff --git a/methods/powell/mnbrak.hpp b/methods/powell/mnbrak.hpp
new file mode 100644
index 0000000..4887bec
--- /dev/null
+++ b/methods/powell/mnbrak.hpp
@@ -0,0 +1,81 @@
+#ifndef MNBRAK_HPP
+#define MNBRAK_HPP 
+//#include "optimizer.hpp"
+#include "bas_util.hpp"
+namespace opt_utilities
+{
+
+  
+  template <typename T>
+  void mnbrak(T& ax,T& bx,T& cx,T& fa,T& fb,T& fc,func_obj<T,T>& func)
+  {
+    const T GOLD=1.618034;
+    const T GLIMIT=100;
+    const T TINY=std::numeric_limits<T>::epsilon();
+    T ulim,u,r,q,fu;
+    fa=func.eval(ax);
+    fb=func.eval(bx);
+    
+    if(fb>fa)
+      {
+	//shft(dum,ax,bx,dum);
+	//shft(dum,fb,fa,dum);
+	std::swap(ax,bx);
+	std::swap(fa,fb);
+      }
+
+    cx=bx+GOLD*(bx-ax);
+    fc=func.eval(cx);
+    while(fb>fc)
+      {
+	r=(bx-ax)*(fb-fc);
+	q=(bx-cx)*(fb-fa);
+	u=bx-T((bx-cx)*q-(bx-ax)*r)/
+	  T(T(2.)*sign(T(max(T(tabs(T(q-r))),T(TINY))),T(q-r)));
+	ulim=bx+GLIMIT*(cx-bx);
+	if((bx-u)*(u-cx)>0.)
+	  {
+	    fu=func.eval(u);
+	    if(fu<fc)
+	      {
+		ax=bx;
+		bx=u;
+		fa=fb;
+		fb=fu;
+		return;
+	      }
+	    else if(fu>fb)
+	      {
+		cx=u;
+		fc=fu;
+		return;
+	      }
+	    u=cx+GOLD*(cx-bx);
+	    fu=func.eval(u);
+	  }
+	else if((cx-u)*(u-ulim)>0.)
+	  {
+	    fu=func.eval(u);
+	    if(fu<fc)
+	      {
+		shft3(bx,cx,u,T(cx+GOLD*(cx-bx)));
+		shft3(fb,fc,fu,func.eval(u));
+	      }
+	  }
+	else if((u-ulim)*(ulim-cx)>=0)
+	  {
+	    u=ulim;
+	    fu=func.eval(u);
+	  }
+	else
+	  {
+	    u=cx+GOLD*(cx-bx);
+	    fu=func.eval(u);
+	  }
+	shft3(ax,bx,cx,u);
+	shft3(fa,fb,fc,fu);
+      }
+  }
+}
+
+#endif
diff --git a/methods/powell/powell_method.hpp b/methods/powell/powell_method.hpp
new file mode 100644
index 0000000..bec12b7
--- /dev/null
+++ b/methods/powell/powell_method.hpp
@@ -0,0 +1,251 @@
+#ifndef POWELL_METHOD
+#define POWELL_METHOD
+#include <core/optimizer.hpp>
+//#include <blitz/array.h>
+#include <limits>
+#include <cassert>
+#include <cmath>
+#include "linmin.hpp"
+#include <algorithm>
+/*
+ *
+*/
+#include <iostream>
+
+namespace opt_utilities
+{
+  /*
+  template <typename T>
+  T tabs(T x)
+  {
+    return x<0?-x:x;
+  }
+  */
+
+  template <typename rT,typename pT>
+  class powell_method
+    :public opt_method<rT,pT>
+  {
+  public:
+    typedef pT array1d_type;
+    typedef rT T;
+  private:
+    func_obj<rT,pT>* p_fo;
+    optimizer<rT,pT>* p_optimizer;
+    
+    //typedef blitz::Array<rT,2> array2d_type;
+    
+    
+  private:
+    array1d_type start_point;
+    array1d_type end_point;
+    
+  private:
+    int ncom;
+    array1d_type pcom_p;
+    array1d_type xicom_p;
+    rT threshold;
+    T** xi;
+    T* xi_1d;
+  private:
+    rT func(const pT& x)
+    {
+      assert(p_fo!=0);
+      return p_fo->eval(x);
+    }
+
+   
+  private:
+    void clear_xi()
+    {
+      if(xi_1d!=0)
+	{
+	  delete[] xi_1d;
+	}
+      if(xi!=0)
+	{
+	  delete[] xi;
+	}
+    }
+
+    void init_xi(int n)
+    {
+      clear_xi();
+      xi_1d=new T[n*n];
+      xi=new T*[n];
+      for(int i=0;i!=n;++i)
+	{
+	  xi[i]=xi_1d+i*n;
+	}
+      for(int i=0;i!=n;++i)
+	{
+	  for(int j=0;j!=n;++j)
+	    {
+	      xi[i][j]=(j==i?1:0);
+	    }
+	}
+    }
+
+
+
+    void powell(array1d_type& p,const T ftol,
+	   int& iter,T& fret)
+    {
+      const int ITMAX=200;
+      const T TINY=std::numeric_limits<T>::epsilon();
+      int i,j,ibig;
+      T del,fp,fptt,t;
+      int n=(int)get_size(p);
+      array1d_type pt(n);
+      array1d_type ptt(n);
+      array1d_type xit(n);
+      fret=p_fo->eval(p);
+      
+      for(j=0;j<n;++j)
+	{
+	  //get_element(pt,j)=get_element(p,j);
+	  set_element(pt,j,get_element(p,j));
+	}
+      for(iter=0;;++iter)
+	{
+	  fp=fret;
+	  ibig=0;
+	  del=0.0;
+	  for(i=0;i<n;++i)
+	    {
+	      for(j=0;j<n;++j)
+		{
+		  //get_element(xit,j)=xi[j][i];
+		  set_element(xit,j,xi[j][i]);
+		}
+	      fptt=fret;
+	      linmin(p,xit,fret,(*p_fo));
+	      if((fptt-fret)>del)
+		{
+		  del=fptt-fret;
+		  ibig=i+1;
+		}
+	    }
+	  if(T(2.)*(fp-fret)<=ftol*(tabs(fp)+tabs(fret))+TINY)
+	    {
+	      return;
+	    }
+	  if(iter==ITMAX)
+	    {
+	      std::cerr<<"powell exceeding maximun iterations."<<std::endl;
+	      return;
+	    }
+	  for(j=0;j<n;++j)
+	    {
+	      //get_element(ptt,j)=T(2.)*get_element(p,j)-get_element(pt,j);
+	      set_element(ptt,j,T(2.)*get_element(p,j)-get_element(pt,j));
+	      //get_element(xit,j)=
+	      //get_element(p,j)-get_element(pt,j);
+	      set_element(xit,j,get_element(p,j)-get_element(pt,j));
+	      //get_element(pt,j)=get_element(p,j);
+	      set_element(pt,j,get_element(p,j));
+	    }
+	  fptt=func(ptt);
+	  if(fptt<fp)
+	    {
+	      t=T(2.)*(fp-T(2.)*fret+fptt)*sqr(T(fp-fret-del))-del*sqr(T(fp-fptt));
+	      if(t<T(0.))
+		{
+		  linmin(p,xit,fret,*p_fo);
+		  for(j=0;j<n;++j)
+		    {
+		      xi[j][ibig-1]=xi[j][n-1];
+		      xi[j][n-1]=get_element(xit,j);
+		      
+		    }
+		}
+	    }
+	}
+    }
+
+    
+  public:
+    
+    powell_method()
+      :threshold(1e-4),xi(0),xi_1d(0)
+    {}
+
+    virtual ~powell_method()
+    {
+      clear_xi();
+    };
+
+    powell_method(const powell_method<rT,pT>& rhs)
+      :p_fo(rhs.p_fo),p_optimizer(rhs.p_optimizer),
+       start_point(rhs.start_point),
+       end_point(rhs.end_point),
+       ncom(rhs.ncom),
+       threshold(rhs.threshold),xi(0),xi_1d(0)
+    {
+    }
+
+    powell_method<rT,pT>& operator=(const powell_method<rT,pT>& rhs)
+    {
+      threshold=rhs.threshold;
+      xi=0;
+      xi_1d=0;
+      p_fo=rhs.p_fo;
+      p_optimizer=rhs.p_optimizer;
+      start_point=rhs.start_point;
+      end_point=rhs.end_point;
+      ncom=rhs.ncom;
+      threshold=rhs.threshold;
+    }
+    
+    opt_method<rT,pT>* do_clone()const
+    {
+      return new powell_method<rT,pT>(*this);
+    }
+    
+    void do_set_start_point(const array1d_type& p)
+    {
+      resize(start_point,get_size(p));
+      opt_eq(start_point,p);
+      
+    }
+
+    void do_set_precision(rT t)
+    {
+      threshold=t;
+    }
+
+    void do_set_optimizer(optimizer<rT,pT>& o)
+    {
+      p_optimizer=&o;
+      p_fo=p_optimizer->ptr_func_obj();
+    }
+    
+    
+    
+    pT do_optimize()
+    {
+
+      init_xi((int)get_size(start_point));
+
+
+      for(int i=0;i<(int)get_size(start_point);++i)
+	{
+	  for(int j=0;j<(int)get_size(start_point);++j)
+	    {
+	      xi[i][j]=(i==j)?1:0;
+	    }
+	}
+      
+      int iter=100;
+      opt_eq(end_point,start_point);
+      rT fret;
+      powell(end_point,threshold,iter,fret);
+      return end_point;
+    } 
+  };
+
+};
+
+
+#endif
+//EOF
diff --git a/misc/bootstrap.hpp b/misc/bootstrap.hpp
new file mode 100644
index 0000000..b46748d
--- /dev/null
+++ b/misc/bootstrap.hpp
@@ -0,0 +1,132 @@
+#ifndef BOOT_STRIP
+#define BOOT_STRIP
+#include <core/fitter.hpp>
+#include <vector>
+#include <cstdlib>
+#include <iostream>
+#include <utility>
+#include <algorithm>
+#include <core/default_data_set.hpp>
+using std::cout;
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx,typename Tp>
+  class bootstrap
+  {
+  private:
+    Ty rand_norm(Ty y0,Ty y_err)const
+    {
+      Ty y;
+      do
+	{
+	  y=(rand()/(Ty)RAND_MAX-(Ty).5)*(10*y_err)+y0;
+	}
+      while(rand()/(Ty)RAND_MAX>exp(-(y-y0)*(y-y0)/(y_err*y_err)));
+      return y;
+      
+    }
+  public:
+    std::vector<Tp> param_pool;
+    default_data_set<Ty,Tx> current_data_set;
+    default_data_set<Ty,Tx> origin_data_set;
+    fitter<Ty,Tx,Tp>* p_fitter;
+    Tp origin_param;
+  public:
+    bootstrap()
+      :p_fitter(NULL)
+    {}
+
+    void set_fitter(fitter<Ty,Tx,Tp>& pf)
+    {
+      param_pool.clear();
+      p_fitter=&pf;
+      origin_data_set=dynamic_cast<const default_data_set<Ty,Tx>&>(pf.datas());
+      origin_param=pf.get_all_params();
+    }
+    
+
+
+    void sample(int n)
+    {
+      if(p_fitter!=NULL)
+	{
+	  for(int i=0;i<n;++i)
+	    {
+	      sample();
+	    }
+	  
+	  p_fitter->load_data(origin_data_set);
+	  p_fitter->set_param_value(origin_param);
+	}
+      else
+	{
+	  throw opt_exception("Fitter unset");
+	}
+    }
+
+    const Tp& get_param(int i)const
+    {
+      return param_pool.at(i);
+    }
+    
+  private:
+    void sample()
+    {
+      current_data_set=default_data_set<Ty,Tx>();
+      for(int i=0;i<origin_data_set.size();++i)
+	{
+	  data<Ty,Tx> d;
+	  d=origin_data_set.get_data(i);
+	  d.set_y(rand_norm(d.get_y(),(d.get_y_upper_err()+d.get_y_lower_err())/2));
+	  current_data_set.push_back(d);
+	}
+      p_fitter->load_data(current_data_set);
+      p_fitter->set_param_value(origin_param);
+      param_pool.push_back(p_fitter->fit());
+      for(size_t i=0;i<(param_pool.back()).size();++i)
+	{
+	  cout<<param_pool.back()[i]<<",";
+	}
+      std::cout<<std::endl;
+    }
+    
+  public:
+    std::pair<typename element_type_trait<Tp>::element_type,typename element_type_trait<Tp>::element_type>
+    interval(std::string param_name,double level)
+    {
+      if(p_fitter==NULL)
+	{
+	  throw opt_exception("Fitter unset");
+	}
+      if(param_pool.empty())
+	{
+	  throw opt_exception("Bootstrap not done");
+	}
+      //sample();
+      std::vector<typename element_type_trait<Tp>::element_type> _tmp;
+      int order=p_fitter->get_param_order(param_name);
+      for(typename std::vector<Tp>::iterator i=param_pool.begin();
+	  i!=param_pool.end();++i)
+	{
+	  _tmp.push_back((*i)[order]);
+	}
+      sort(_tmp.begin(),_tmp.end());
+      std::pair<typename std::vector<typename element_type_trait<Tp>::element_type>::iterator,
+	typename std::vector<typename element_type_trait<Tp>::element_type>::iterator> 
+	itv=equal_range(_tmp.begin(),_tmp.end(),origin_param[order]);
+      int current_param_position=itv.second-_tmp.begin();
+      std::cout<<_tmp.size()<<std::endl;
+      return std::pair<typename element_type_trait<Tp>::element_type,
+	typename element_type_trait<Tp>::element_type>(
+				 _tmp.at((int)((1-level)*current_param_position)),
+				 _tmp.at((int)(current_param_position+level*(_tmp.size()-current_param_position)))
+				 );
+      
+    }
+
+  };
+  
+};
+
+#endif
+//EOF
diff --git a/misc/data_loaders.hpp b/misc/data_loaders.hpp
new file mode 100644
index 0000000..6d2195d
--- /dev/null
+++ b/misc/data_loaders.hpp
@@ -0,0 +1,180 @@
+#ifndef DATA_LOADERS_H
+#define DATA_LOADERS_H
+#include <core/fitter.hpp>
+#include <core/default_data_set.hpp>
+#include <iostream>
+#include <fstream>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx>
+  class dl_x_y_ye;
+
+  template <typename Ty,typename Tx>
+  std::istream& operator>>(std::istream& ifs,dl_x_y_ye<Ty,Tx>& dl);
+
+  template <typename Ty,typename Tx>
+  class dl_x_xe_y_ye;
+
+  template <typename Ty,typename Tx>
+  std::istream& operator>>(std::istream& ifs,dl_x_xe_y_ye<Ty,Tx>& dl);
+
+  template <typename Ty,typename Tx>
+  class dl_x_xu_xl_y_yu_yl;
+  
+  template <typename Ty,typename Tx>
+  std::istream& operator>> (std::istream& ifs,dl_x_xu_xl_y_yu_yl<Ty,Tx>& dl);
+
+  template <typename Ty,typename Tx>
+  class dl_x_y_ye
+  {
+  private:
+    default_data_set<Ty,Tx> ds;
+  public:
+    data_set<Ty,Tx>& get_data_set()
+    {
+      return ds;
+    }
+
+    void load_from(std::istream& ifs)
+    {
+      for(;;)
+	{
+	  Tx x;
+	  Tx x_err;
+	  Ty y;
+	  Ty y_err(1);
+	  
+	  ifs>>x>>y>>y_err;
+	  
+	  if(!ifs.good())
+	    {
+	      break;
+	    }
+	  data<Ty,Tx> d(x,y,y_err,y_err,x_err,x_err);
+	  ds.push_back(d);
+	}
+      //return ifs;
+    }
+
+    void load_from(const char* name)
+    {
+      std::ifstream ifs(name);
+      load_from(ifs);
+
+    }
+    //friend std::istream& operator>> <>(std::istream& ifs,dl_x_y_ye<Ty,Tx>& dl);
+  };
+
+  template <typename Ty,typename Tx>
+  std::istream& operator>>(std::istream& ifs,dl_x_y_ye<Ty,Tx>& dl)
+  {
+    dl.load_from(ifs);
+    return ifs;
+  }
+
+
+  template <typename Ty,typename Tx>
+  class dl_x_xe_y_ye
+  {
+  private:
+    default_data_set<Ty,Tx> ds;
+  public:
+    data_set<Ty,Tx>& get_data_set()
+    {
+      return ds;
+    }
+
+    void load_from(std::istream& ifs)
+    {
+      for(;;)
+	{
+	  Tx x;
+	  Tx x_err;
+	  Ty y;
+	  Ty y_err(1);
+	  
+	  ifs>>x>>x_err>>y>>y_err;
+	  
+	  if(!ifs.good())
+	    {
+	      break;
+	    }
+	  data<Ty,Tx> d(x,y,y_err,y_err,x_err,x_err);
+	  ds.push_back(d);
+	}
+    }
+
+    void load_from(const char* name)
+    {
+      std::ifstream ifs(name);
+      load_from(ifs); 
+    }
+  };
+
+  template <typename Ty,typename Tx>
+  std::istream& operator>>(std::istream& ifs,dl_x_xe_y_ye<Ty,Tx>& dl)
+  {
+    dl.load_from(ifs);
+    return ifs;
+  }
+
+  template <typename Ty,typename Tx>
+  class dl_x_xu_xl_y_yu_yl
+  {
+  private:
+  
+    default_data_set<Ty,Tx> ds;
+  public:
+    data_set<Ty,Tx>& get_data_set()
+    {
+      return ds;
+    }
+    
+    void load_from(std::istream& ifs)
+    {
+      for(;;)
+	{
+	  Tx x;
+	  Tx xl,xu;
+	  Ty y;
+	  Ty yl(1),yu(1);
+	  
+	  ifs>>x>>xu>>xl>>y>>yu>>yl;
+	  
+	  xu=std::abs(xu);
+	  xl=std::abs(xl);
+	  yu=std::abs(yu);
+	  yl=std::abs(yl);
+	  
+	  if(!ifs.good())
+	    {
+	      break;
+	    }
+	  data<Ty,Tx> d(x,y,yl,yu,xl,xu);
+	  ds.push_back(d);
+	}
+    }
+
+    void load_from(const char* name)
+    {
+      std::ifstream ifs(name);
+      load_from(ifs);
+    }
+  };
+
+  template <typename Ty,typename Tx>
+  std::istream& operator>> (std::istream& ifs,dl_x_xu_xl_y_yu_yl<Ty,Tx>& dl)
+  {
+    dl.load_from(ifs);
+    return ifs;
+  }
+
+  
+
+}
+
+
+#endif
+//EOF
diff --git a/models/add_model.hpp b/models/add_model.hpp
new file mode 100644
index 0000000..ffac9dc
--- /dev/null
+++ b/models/add_model.hpp
@@ -0,0 +1,169 @@
+#ifndef ADD_MODEL_H_
+#define ADD_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx,typename Tp,typename Tstr>
+  class add_model
+    :public model<Ty,Tx,Tp,Tstr>
+  {
+  private:
+    model<Ty,Tx,Tp,Tstr>* do_clone()const
+    {
+      return new add_model<Ty,Tx,Tp,Tstr>(*this);
+    }
+  private:
+    add_model()
+    {
+    }
+
+  private:
+    model<Ty,Tx,Tp,Tstr>* pm1;
+    model<Ty,Tx,Tp,Tstr>* pm2;
+
+  public:
+    add_model(const model<Ty,Tx,Tp,Tstr>& m1,
+	      const model<Ty,Tx,Tp,Tstr>& m2)
+      :pm1(m1.clone()),pm2(m2.clone())
+    {
+      int np1=m1.get_num_params();
+      int np2=m2.get_num_params();
+      for(int i=0;i<np1;++i)
+	{
+	  param_info<Tp,Tstr> p(m1.get_param_info(i));
+	  param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	  this->push_param_info(p1);
+	}
+      for(int i=0;i<np2;++i)
+	{
+	  param_info<Tp,Tstr> p(m2.get_param_info(i));
+	  param_info<Tp,Tstr> p2(p.get_name()+"2",p.get_default_value());
+	  this->push_param_info(p2);
+	}
+    }
+
+    add_model(const add_model& rhs)
+      :pm1(NULL),pm2(NULL)
+    {
+      int np1(0),np2(0);
+      if(rhs.pm1)
+	{
+	  pm1=rhs.pm1->clone();
+	  np1=rhs.pm1->get_num_params();
+	  for(int i=0;i<np1;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm1->get_param_info(i));
+	      param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	      this->push_param_info(p1);
+	    }
+	}
+      if(rhs.pm2)
+	{
+	  pm2=rhs.pm2->clone();
+	  np2=rhs.pm2->get_num_params();
+	  for(int i=0;i<np2;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm2->get_param_info(i));
+	      param_info<Tp,Tstr> p2(p.get_name()+"2",p.get_default_value());
+	      this->push_param_info(p2);
+	    }
+	}
+    }
+
+    add_model& operator=(const add_model& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      if(!pm1)
+	{
+	  //delete pm1;
+	  pm1->destroy();
+	}
+      if(!pm2)
+	{
+	  //delete pm2;
+	  pm2->destroy();
+	}
+      int np1(0),np2(0);
+      if(rhs.pm1)
+	{
+	  pm1=rhs.pm1->clone();
+	  np1=rhs.pm1->get_num_params();
+	  for(int i=0;i<np1;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm1->get_param_info(i));
+	      param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	      this->push_param_info(p1);
+	    }
+	}
+      if(rhs.pm2)
+	{
+	  pm2=rhs.pm2->clone();
+	  np2=rhs.pm2->get_num_params();
+	  for(int i=0;i<np2;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm2->get_param_info(i));
+	      param_info<Tp,Tstr> p2(p.get_name()+"2",p.get_default_value());
+	      this->push_param_info(p2);
+	    }
+	}
+      return *this;
+    }
+
+    ~add_model()
+    {
+      if(!pm1)
+	{
+	  //delete pm1;
+	  pm1->destroy();
+	}
+      if(!pm2)
+	{
+	  //delete pm2;
+	  pm2->destroy();
+	}
+    }
+
+  public:
+    Ty do_eval(const Tx& x,const Tp& param)
+    {
+      if(!pm1)
+	{
+	  throw opt_exception("incomplete model!");
+	}
+      if(!pm2)
+	{
+	  throw opt_exception("incomplete model!");
+	}
+      Tp p1(pm1->get_num_params());
+      Tp p2(pm2->get_num_params());
+      int i=0;
+      int j=0;
+      for(i=0;i<pm1->get_num_params();++i,++j)
+	{
+	  set_element(p1,i,get_element(param,j));
+	}
+      for(i=0;i<pm2->get_num_params();++i,++j)
+	{
+	  set_element(p2,i,get_element(param,j));
+	}
+      return pm1->eval(x,p1)+pm2->eval(x,p2);
+    }
+  };
+  
+  template <typename Ty,typename Tx,typename Tp,typename Tstr>
+  add_model<Ty,Tx,Tp,Tstr> operator+(const model<Ty,Tx,Tp,Tstr>& m1,
+				     const model<Ty,Tx,Tp,Tstr>& m2)
+  {
+    return add_model<Ty,Tx,Tp,Tstr>(m1,m2);
+  }
+};
+
+
+
+#endif
+//EOF
diff --git a/models/beta1d.hpp b/models/beta1d.hpp
new file mode 100644
index 0000000..e18aa34
--- /dev/null
+++ b/models/beta1d.hpp
@@ -0,0 +1,49 @@
+#ifndef BETA_MODEL_H_
+#define BETA_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <iostream>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class beta1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new beta1d<T>(*this);
+    }
+  public:
+    beta1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("S0",1));
+      this->push_param_info(param_info<std::vector<T> >("rc",10));
+      this->push_param_info(param_info<std::vector<T> >("beta",2./3.));
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));
+    }
+
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T S0=get_element(param,0);
+      T r_c=get_element(param,1);
+      T beta=get_element(param,2);
+      T bkg=get_element(param,3);
+
+      return bkg+S0*pow(1+(x*x)/(r_c*r_c),-3*beta+static_cast<T>(.5));
+    }
+
+    std::string do_to_string()const
+    {
+      return "Beta model\n"
+	"S=S0*(1+(r/rc)^2)^(-3*beta+0.5)\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/beta2d.hpp b/models/beta2d.hpp
new file mode 100644
index 0000000..abb6da1
--- /dev/null
+++ b/models/beta2d.hpp
@@ -0,0 +1,60 @@
+#ifndef BETA_MODEL2d_H_
+#define BETA_MODEL2d_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <cassert>
+#include "vecn.hpp"
+
+
+namespace opt_utilities
+{
+  
+  template <typename T>
+  class beta2d
+    :public model<T,vecn<T,2>,std::vector<T>,std::string>
+  {
+  private:
+    model<T,vecn<T,2>,std::vector<T> >* do_clone()const
+    {
+      return new beta2d<T>(*this);
+    }
+  public:
+    beta2d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("S0",1));
+      this->push_param_info(param_info<std::vector<T> >("rc1",100));
+      this->push_param_info(param_info<std::vector<T> >("rc2",100));
+      this->push_param_info(param_info<std::vector<T> >("rho",0));
+      this->push_param_info(param_info<std::vector<T> >("x0",100));
+      this->push_param_info(param_info<std::vector<T> >("y0",100));
+      this->push_param_info(param_info<std::vector<T> >("beta",2./3.));
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));
+    }
+
+
+    T do_eval(const vecn<T,2>& xy,const std::vector<T>& param)
+    {
+      T S0=get_element(param,0);
+      T rc1=get_element(param,1);
+      T rc2=get_element(param,2);
+      T rho=get_element(param,3);
+      T x0=get_element(param,4);
+      T y0=get_element(param,5);
+      T beta=get_element(param,6);
+      T bkg=get_element(param,7);
+      T x=xy[0];
+      T y=xy[1];
+
+      T r=(x-x0)*(x-x0)/(rc1*rc1)+(y-y0)*(y-y0)/(rc2*rc2)
+	-2*rho*(x-x0)*(y-y0)/(rc1*rc2);
+      r=r<0?0:r;
+      
+      return bkg+S0*pow(1+r,-3*beta+static_cast<T>(.5));
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/beta2d2.hpp b/models/beta2d2.hpp
new file mode 100644
index 0000000..bb473a3
--- /dev/null
+++ b/models/beta2d2.hpp
@@ -0,0 +1,73 @@
+#ifndef BETA_MODEL2d2_H_
+#define BETA_MODEL2d2_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <cassert>
+#include "vecn.hpp"
+
+
+namespace opt_utilities
+{
+  
+  template <typename T>
+  class beta2d2
+    :public model<T,vecn<T,2>,std::vector<T>,std::string>
+  {
+  private:
+    model<T,vecn<T,2>,std::vector<T> >* do_clone()const
+    {
+      return new beta2d2<T>(*this);
+    }
+  public:
+    beta2d2()
+    {
+      this->push_param_info(param_info<std::vector<T> >("r0",20));
+      this->push_param_info(param_info<std::vector<T> >("x0",100));
+      this->push_param_info(param_info<std::vector<T> >("y0",100));
+      this->push_param_info(param_info<std::vector<T> >("epsilon",0));
+      this->push_param_info(param_info<std::vector<T> >("theta",100));
+      this->push_param_info(param_info<std::vector<T> >("ampl",3));
+      this->push_param_info(param_info<std::vector<T> >("beta",2./3.));
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));
+    }
+
+
+    T do_eval(const vecn<T,2>& xy,const std::vector<T>& param)
+    {
+      T x=xy[0];
+      T y=xy[1];
+
+      T r0=get_element(param,0);
+      T x0=get_element(param,1);
+      T y0=get_element(param,2);
+      T epsilon=get_element(param,3);
+      T theta=get_element(param,4);
+      T ampl=get_element(param,5);
+      T beta=get_element(param,6);
+      T bkg=get_element(param,7);
+
+      T x_new=(x-x0)*cos(theta)+(y-y0)*sin(theta);
+      T y_new=(y-y0)*cos(theta)-(x-x0)*sin(theta);
+      
+      //T _epsilon=sin(epsilon)-0.00001;
+      
+      T _epsilon=epsilon;
+
+      //      T r=sqrt(x_new*x_new*(1-_epsilon)*(1-_epsilon)
+      //	       + y_new*y_new);
+      
+      //r/=(1-_epsilon);
+      T r_r=x_new*x_new/exp(_epsilon)+y_new*y_new/exp(-_epsilon);
+      
+      
+      return bkg+ampl*pow(1+r_r/r0/r0,-3*beta+static_cast<T>(.5));
+    }
+
+
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/bl1d.hpp b/models/bl1d.hpp
new file mode 100644
index 0000000..bd0ce7d
--- /dev/null
+++ b/models/bl1d.hpp
@@ -0,0 +1,56 @@
+#ifndef BROKEN_LINE_MODEL_H_
+#define BROKEN_LINE_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class bl1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new bl1d<T>(*this);
+    }
+  public:
+    bl1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("break point y value",1));
+      this->push_param_info(param_info<std::vector<T> >("break point x value",1));
+      this->push_param_info(param_info<std::vector<T> >("slop 1",1));
+      this->push_param_info(param_info<std::vector<T> >("slop 2",1));
+    }
+
+  public:
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T x_b=get_element(param,0);
+      T f_b=get_element(param,1);
+      T k1=get_element(param,2);
+      T k2=get_element(param,3);
+      if(x<x_b)
+	{
+	  return k1*(x-x_b)+f_b;
+	}
+      else
+	{
+	  return k2*(x-x_b)+f_b;
+	}
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "broken linear model\n"
+	"y=k1*(x-x_b)+y_b for x<x_b\n"
+	"y=k2*(x-x_b)+y_b otherwise\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/bpl1d.hpp b/models/bpl1d.hpp
new file mode 100644
index 0000000..faf1336
--- /dev/null
+++ b/models/bpl1d.hpp
@@ -0,0 +1,56 @@
+#ifndef BROKEN_POWER_LAW_MODEL_H_
+#define BROKEN_POWER_LAW_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class bpl1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new bpl1d<T>(*this);
+    }
+  public:
+    bpl1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("bpx",1));
+      this->push_param_info(param_info<std::vector<T> >("bpy",1));
+      this->push_param_info(param_info<std::vector<T> >("gamma1",1));
+      this->push_param_info(param_info<std::vector<T> >("gamma2",1));
+    }
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T x_b=get_element(param,0);
+      T f_b=get_element(param,1);
+      T gamma1=get_element(param,2);
+      T gamma2=get_element(param,3);
+      if(x<x_b)
+	{
+	  return f_b*pow(x,gamma1)/pow(x_b,gamma1);
+	}
+      else
+	{
+	  return f_b*pow(x,gamma2)/pow(x_b,gamma2);
+	}
+    }
+
+
+  private:
+    std::string do_to_string()const
+    {
+      return "broken power law\n"
+	"y=y_b*(x/x_b)^gamma1 for x<x_b\n"
+	"y=y_b*(x/x_b)^gamma2 otherwise\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/bremss.hpp b/models/bremss.hpp
new file mode 100644
index 0000000..9956a3e
--- /dev/null
+++ b/models/bremss.hpp
@@ -0,0 +1,44 @@
+#ifndef BREMSS_MODEL_H_
+#define BREMSS_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class bremss
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new bremss<T>(*this);
+    }
+  public:
+    bremss()
+    {
+      this->push_param_info(param_info<std::vector<T> >("norm",1));
+      this->push_param_info(param_info<std::vector<T> >("kT",1));
+    }
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T norm=get_element(param,0);
+      T kT=get_element(param,1);
+      
+      return norm*sqrt(kT)*exp(-x/kT);
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "Simplified bremss model\n"
+	"flux=norm*kT^0.5*e^{-E/kT}\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/constant.hpp b/models/constant.hpp
new file mode 100644
index 0000000..8d06279
--- /dev/null
+++ b/models/constant.hpp
@@ -0,0 +1,42 @@
+#ifndef CONSTANT_MODEL_H_
+#define CONSTANT_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class constant
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new constant<T>(*this);
+    }
+  public:
+    constant()
+    {
+      this->push_param_info(param_info<std::vector<T> >("c",1));
+    }
+
+  public:
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      //return x*param[0]+param[1];
+      return get_element(param,0);
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "Constant\n"
+	"y=C\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/dbeta1d.hpp b/models/dbeta1d.hpp
new file mode 100644
index 0000000..71a1f52
--- /dev/null
+++ b/models/dbeta1d.hpp
@@ -0,0 +1,62 @@
+#ifndef DBETA_MODEL_H_
+#define DBETA_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <iostream>
+namespace opt_utilities
+{
+  template <typename T>
+  class dbeta1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new dbeta1d<T>(*this);
+    }
+  public:
+    dbeta1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("S01",1));
+      this->push_param_info(param_info<std::vector<T> >("rc1",30));
+      this->push_param_info(param_info<std::vector<T> >("beta1",.6));
+
+      this->push_param_info(param_info<std::vector<T> >("S02",.5));
+      this->push_param_info(param_info<std::vector<T> >("rc2",20));
+      this->push_param_info(param_info<std::vector<T> >("beta2",.4));
+
+
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));
+    }
+
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T S01=get_element(param,0);
+      T r_c1=get_element(param,1);
+      T beta1=get_element(param,2);
+
+      T S02=get_element(param,3);
+      T r_c2=get_element(param,4);
+      T beta2=get_element(param,5);
+
+
+      T bkg=get_element(param,6);
+
+      return bkg+S01*pow(1+(x*x)/(r_c1*r_c1),-3*beta1+static_cast<T>(.5))
+	+S02*pow(1+(x*x)/(r_c2*r_c2),-3*beta2+static_cast<T>(.5));
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "double 1d beta model\n"
+	"S=beta(S01,beta1,rc1)+beta(S02,beta2,rc2)\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/dbeta2d.hpp b/models/dbeta2d.hpp
new file mode 100644
index 0000000..6811270
--- /dev/null
+++ b/models/dbeta2d.hpp
@@ -0,0 +1,92 @@
+#ifndef DBETA_MODEL2d_H_
+#define DBETA_MODEL2d_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <cassert>
+#include "vecn.hpp"
+
+namespace opt_utilities
+{
+  
+  template <typename T>
+  class dbeta2d
+    :public model<T,vecn<T,2>,std::vector<T>,std::string>
+  {
+  private:
+    model<T,vecn<T,2>,std::vector<T> >* do_clone()const
+    {
+      return new dbeta2d<T>(*this);
+    }
+    
+    
+    
+  public:
+    dbeta2d()
+    {
+      push_param_info(param_info<std::vector<T> >("S01",1));
+      push_param_info(param_info<std::vector<T> >("rc11",50));
+      push_param_info(param_info<std::vector<T> >("rc21",50));
+      push_param_info(param_info<std::vector<T> >("rho1",0));
+      push_param_info(param_info<std::vector<T> >("x01",200));
+      push_param_info(param_info<std::vector<T> >("y01",200));
+      push_param_info(param_info<std::vector<T> >("beta1",2./3.));
+      
+      push_param_info(param_info<std::vector<T> >("S02",1));
+      push_param_info(param_info<std::vector<T> >("rc12",60));
+      push_param_info(param_info<std::vector<T> >("rc22",60));
+      push_param_info(param_info<std::vector<T> >("rho2",0));
+      push_param_info(param_info<std::vector<T> >("x02",200));
+      push_param_info(param_info<std::vector<T> >("y02",200));
+      push_param_info(param_info<std::vector<T> >("beta2",2./2.5));
+      push_param_info(param_info<std::vector<T> >("bkg",0));
+    }
+    
+    T do_eval(const vecn<T,2>& xy,const std::vector<T>& param)
+    {
+      T S01=get_element(param,0);
+      T rc11=get_element(param,1);
+      T rc21=get_element(param,2);
+      T rho1=get_element(param,3);
+      T x01=get_element(param,4);
+      T y01=get_element(param,5);
+      T beta1=get_element(param,6);
+      T S02=get_element(param,7);
+      T rc12=get_element(param,8);
+      T rc22=get_element(param,9);
+      T rho2=get_element(param,10);
+      T x02=get_element(param,11);
+      T y02=get_element(param,12);
+      T beta2=get_element(param,13);
+      T bkg=get_element(param,14);
+      
+      
+      T x=xy[0];
+      T y=xy[1];
+
+      rho1=rho1>1?1:rho1;
+      rho1=rho1<-1?-1:rho1;
+      rho2=rho2>1?1:rho2;
+      rho2=rho2<-1?-1:rho2;
+      
+      T r1=(x-x01)*(x-x01)/(rc11*rc11)+(y-y01)*(y-y01)/(rc21*rc21)
+	-2*rho1*(x-x01)*(y-y01)/(rc11*rc21);
+
+      T r2=(x-x02)*(x-x02)/(rc12*rc12)+(y-y02)*(y-y02)/(rc22*rc22)
+	-2*rho2*(x-x02)*(y-y02)/(rc12*rc22);
+      //      r1=r1<0?0:r1;
+      //r2=r2<0?0:r2;
+      assert(r1>=0);
+      assert(r2>=0);
+      
+
+      return bkg+S01*pow(1+r1,-3*beta1+static_cast<T>(.5))+
+	S02*pow(1+r2,-3*beta2+static_cast<T>(.5));
+    }
+  };
+};
+
+
+
+#endif
+//EOF
+
diff --git a/models/dbeta2d2.hpp b/models/dbeta2d2.hpp
new file mode 100644
index 0000000..d968dbc
--- /dev/null
+++ b/models/dbeta2d2.hpp
@@ -0,0 +1,100 @@
+#ifndef DDBETA_OOOMODEL2d2_H_
+#define DDBETA_OOOMODEL2d2_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <cassert>
+#include "vecn.hpp"
+
+
+namespace opt_utilities
+{
+  
+  template <typename T>
+  class dbeta2d2
+    :public model<T,vecn<T,2>,std::vector<T>,std::string>
+  {
+  private:
+    model<T,vecn<T,2>,std::vector<T> >* do_clone()const
+    {
+      return new dbeta2d2<T>(*this);
+    }
+  public:
+    dbeta2d2()
+    {
+      this->push_param_info(param_info<std::vector<T> >("ampl1",1));//0
+      this->push_param_info(param_info<std::vector<T> >("r01",1));//1
+      this->push_param_info(param_info<std::vector<T> >("x01",100));//2
+      this->push_param_info(param_info<std::vector<T> >("y01",100));//3      
+      this->push_param_info(param_info<std::vector<T> >("theta1",0));//4      
+      this->push_param_info(param_info<std::vector<T> >("beta1",2./3.));//5
+      this->push_param_info(param_info<std::vector<T> >("epsilon1",0));//6
+
+
+      this->push_param_info(param_info<std::vector<T> >("ampl2",1));//7
+      this->push_param_info(param_info<std::vector<T> >("r02",1));//8
+      this->push_param_info(param_info<std::vector<T> >("x02",100));//9
+      this->push_param_info(param_info<std::vector<T> >("y02",100));//10
+      this->push_param_info(param_info<std::vector<T> >("theta2",0));//11
+      this->push_param_info(param_info<std::vector<T> >("beta2",2./4.));//12
+      this->push_param_info(param_info<std::vector<T> >("epsilon2",0));//13
+
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));//14
+    }
+
+
+    T do_eval(const vecn<T,2>& xy,const std::vector<T>& param)
+    {
+      T x=xy[0];
+      T y=xy[1];
+
+      T ampl1=get_element(param,0);
+      T r01=get_element(param,1);
+      T x01=get_element(param,2);
+      T y01=get_element(param,3);
+
+      T theta1=get_element(param,4);
+
+      T beta1=get_element(param,5);
+      T epsilon1=get_element(param,6);
+
+      T ampl2=get_element(param,7);      
+      T r02=get_element(param,8);
+      T x02=get_element(param,9);
+      T y02=get_element(param,10);
+   
+      T theta2=get_element(param,11);
+
+      T beta2=get_element(param,12);
+
+      T epsilon2=get_element(param,13);
+      T bkg=get_element(param,14);
+
+      T x_new1=(x-x01)*cos(theta1)+(y-y01)*sin(theta1);
+      T y_new1=(y-y01)*cos(theta1)-(x-x01)*sin(theta1);
+      
+      //T r1=sqrt(x_new1*x_new1*(1-epsilon1)*(1-epsilon1)
+      //       + y_new1*y_new1);
+      //r1/=(1-epsilon1);
+
+      T r1_r1=x_new1*x_new1/exp(epsilon1/30)+y_new1*y_new1/exp(-epsilon1/30);
+
+      T x_new2=(x-x02)*cos(theta2)+(y-y02)*sin(theta2);
+      T y_new2=(y-y02)*cos(theta2)-(x-x02)*sin(theta2);
+      
+      T r2_r2=x_new2*x_new2/exp(epsilon2/30)+y_new2*y_new2/exp(-epsilon2/30);
+      //   T r2=sqrt(x_new2*x_new2*(1-epsilon2)*(1-epsilon2)
+      //	       + y_new2*y_new2);
+      //r2/=(1-epsilon2);
+      
+      
+      
+      return bkg+ampl1*pow(1+(r1_r1/r01/r01),-3*beta1+static_cast<T>(.5))
+	+ampl2*pow(1+(r2_r2/r02/r02),-3*beta2+static_cast<T>(.5));
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/dbeta2d3.hpp b/models/dbeta2d3.hpp
new file mode 100644
index 0000000..e2edb78
--- /dev/null
+++ b/models/dbeta2d3.hpp
@@ -0,0 +1,91 @@
+#ifndef DDBETA3_MODEL2d2_H_
+#define DDBETA3_MODEL2d2_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <cassert>
+#include "vecn.hpp"
+
+
+namespace opt_utilities
+{
+  
+  template <typename T>
+  class dbeta2d3
+    :public model<T,vecn<T,2>,std::vector<T>,std::string>
+  {
+  private:
+    model<T,vecn<T,2>,std::vector<T> >* do_clone()const
+    {
+      return new dbeta2d3<T>(*this);
+    }
+  public:
+    dbeta2d3()
+    {
+
+      this->push_param_info(param_info<std::vector<T> >("x0",256));//1
+      this->push_param_info(param_info<std::vector<T> >("y0",256));//2      
+      this->push_param_info(param_info<std::vector<T> >("epsilon",0));//3
+      this->push_param_info(param_info<std::vector<T> >("theta",0));//4      
+      
+      this->push_param_info(param_info<std::vector<T> >("ampl1",1));//5
+      this->push_param_info(param_info<std::vector<T> >("beta1",0.6));//6
+      this->push_param_info(param_info<std::vector<T> >("r01",30));//7
+      
+      this->push_param_info(param_info<std::vector<T> >("ampl2",.5));//8
+      this->push_param_info(param_info<std::vector<T> >("beta2",.4));//9
+      this->push_param_info(param_info<std::vector<T> >("r02",20));//10
+      
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));//11
+
+
+    }
+
+
+    T do_eval(const vecn<T,2>& xy,const std::vector<T>& param)
+    {
+      T x=xy[0];
+      T y=xy[1];
+      
+      T x0=get_element(param,0);
+      T y0=get_element(param,1);
+      T epsilon=get_element(param,2);
+      T theta=get_element(param,3);
+ 
+      T ampl1=(get_element(param,4));
+      T beta1=(get_element(param,5));
+      T r01=(get_element(param,6));
+
+      T ampl2=(get_element(param,7));
+      T beta2=(get_element(param,8));
+      T r02=(get_element(param,9));
+
+      T bkg=get_element(param,10);
+
+      T x_new1=(x-x0)*cos(theta)+(y-y0)*sin(theta);
+      T y_new1=(y-y0)*cos(theta)-(x-x0)*sin(theta);
+      
+ 
+      T r1_r1=x_new1*x_new1/exp(epsilon/30)+y_new1*y_new1/exp(-epsilon/30);
+      //T r1=sqrt(x_new1*x_new1*(1-epsilon)*(1-epsilon)+y_new1*y_new1)/(1-epsilon);
+
+      T x_new2=(x-x0)*cos(theta)+(y-y0)*sin(theta);
+      T y_new2=(y-y0)*cos(theta)-(x-x0)*sin(theta);
+      
+      T r2_r2=x_new2*x_new2/exp(epsilon/30)+y_new2*y_new2/exp(-epsilon/30);
+      //T r2=sqrt(x_new2*x_new2*(1-epsilon)*(1-epsilon)+y_new2*y_new2)/(1-epsilon);
+
+      
+      
+      return bkg+ampl1*pow(1+(r1_r1/r01/r01),-3*beta1+static_cast<T>(.5))
+      	+ampl2*pow(1+(r2_r2/r02/r02),-3*beta2+static_cast<T>(.5));
+
+      //return bkg+pow(1+r1*r1/r01/r01,-3*beta1+static_cast<T>(.5))+
+      //pow(1+r2*r2/r02/r02,-3*beta2+static_cast<T>(.5));
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/dl_model.hpp b/models/dl_model.hpp
new file mode 100644
index 0000000..2fcf227
--- /dev/null
+++ b/models/dl_model.hpp
@@ -0,0 +1,178 @@
+#ifdef __linux__
+
+#ifndef DL_MODEL_H_
+#define DL_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <dlfcn.h>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class dl_model
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    T (*calc_model)(T x,const T* p);
+    int nparams;
+    mutable void* handle;
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      dl_model<T>* result=new dl_model<T>(*this);
+      this->handle=NULL;
+      return result;
+    }
+
+    //  public:
+  public:
+    dl_model()
+      :handle(NULL)
+    {}
+
+
+  public:
+    dl_model(const char* file_name)
+      :handle(NULL)
+    {
+      
+      handle=dlopen(file_name,RTLD_LAZY);
+      
+      if(!handle)
+	{
+	  throw opt_exception("faild loading object");
+	}
+      
+      calc_model=(T (*)(T,const T*))dlsym(handle,"calc_model");
+      
+      if(!calc_model)
+	{
+	  throw opt_exception("symble undefined");
+	}
+
+      const char* (*get_param_name)(int)
+	=(const char* (*)(int))dlsym(handle,"get_param_name");
+      
+      if(!get_param_name)
+	{
+	  throw opt_exception("symble undefined");
+	}
+
+      int (*get_num_params)()
+	=(int (*)())dlsym(handle,"get_num_params");
+      
+      if(!get_num_params)
+	{
+	  throw opt_exception("symble undefined");
+      if(!get_num_params)
+	{
+	  throw opt_exception("symble undefined");
+	}	}
+
+      T (*get_default_value)(int)
+	=(T (*)(int))dlsym(handle,"get_default_value");
+      
+      if(!get_default_value)
+	{
+	  throw opt_exception("symble undefined");
+	}
+
+      nparams=get_num_params();
+      
+      for(int i=0;i!=nparams;++i)
+	{
+	  this->push_param_info(param_info<std::vector<T> >(get_param_name(i),
+				get_default_value(i)));
+	}
+    }
+
+    ~dl_model()
+    {
+      if(handle)
+	{
+	  dlclose(handle);
+	}
+    }
+
+    void bind(const char* file_name)
+    {
+      if(handle)
+	{
+	  dlclose(handle);
+	}
+      this->clear_param_info();
+      handle=dlopen(file_name,RTLD_LAZY);
+
+      if(!handle)
+	{
+	  throw opt_exception("faild loading object");
+	}
+
+      calc_model=(T (*)(T,const T*))dlsym(handle,"calc_model");
+      
+      if(!calc_model)
+	{
+	  throw opt_exception("symble undefined");
+	}
+
+      const char* (*get_param_name)(int)
+	=(const char* (*)(int))dlsym(handle,"get_param_name");
+      
+      if(!get_param_name)
+	{
+	  throw opt_exception("symble undefined");
+	}
+
+
+      int (*get_num_params)()
+	=(int (*)())dlsym(handle,"get_num_params");
+      
+      if(!get_num_params)
+	{
+	  throw opt_exception("symble undefined");
+	}      
+
+
+      T (*get_default_value)(int)
+	=(T (*)(int))dlsym(handle,"get_default_value");
+     
+
+      if(!get_default_value)
+	{
+	  throw opt_exception("symble undefined");
+	}
+
+      
+      nparams=get_num_params();
+      for(int i=0;i!=nparams;++i)
+	{
+	  this->push_param_info(param_info<std::vector<T> >(get_param_name(i),
+				get_default_value(i)));
+	}
+    }
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      if(handle==NULL)
+	{
+	  throw opt_exception("dl object unloaded");
+	}
+      return calc_model(x,&get_element(param,0));
+    }
+
+    std::string do_to_string()const
+    {
+      return "Dynamical load model\n"
+	"Should be loaded from an shared object file\n";
+    }
+  };
+};
+
+
+
+#endif
+#endif
+//EOF
diff --git a/models/dlmodel_template.c b/models/dlmodel_template.c
new file mode 100644
index 0000000..fd7aadb
--- /dev/null
+++ b/models/dlmodel_template.c
@@ -0,0 +1,36 @@
+#include <math.h>
+
+char p1name[2]="k";
+char p2name[2]="b";
+
+int main(int argc,char* argv[])
+{}
+
+
+int get_num_params()
+{
+  return 2;
+}
+
+const char* get_param_name(int n)
+{
+  if(n==0)
+    {
+      return p1name;
+    }
+  return p2name;
+}
+
+double get_default_value(int n)
+{
+  if(n==0)
+    return 1;
+  return 0;
+}
+
+double calc_model(double x,double p[])
+{
+  return p[0]*x+p[1];
+}
+
+
diff --git a/models/func_model.hpp b/models/func_model.hpp
new file mode 100644
index 0000000..4eda8d5
--- /dev/null
+++ b/models/func_model.hpp
@@ -0,0 +1,57 @@
+#ifndef FUNC_MODEL_H_
+#define FUNC_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <sstream>
+namespace opt_utilities
+{
+  template <typename T>
+  class func_model
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    T (*func)(T x,const T* const& p);
+    int nparams;
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new func_model<T>(*this);
+    }
+
+    //  public:
+  private:
+    func_model()
+    {}
+
+
+  public:
+    func_model(T (*_func)(T x,const T* const& p),int n)
+      :func(_func),nparams(n)
+    {
+      for(int i=0;i!=n;++i)
+	{
+	  std::ostringstream oss;
+	  oss<<i;
+	  this->push_param_info(param_info<std::vector<T> >(oss.str(),0));
+	}
+    }
+
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      return func(x,&get_element(param,0));
+    }
+  private:
+    std::string do_to_string()const
+    {
+      return "Wrapper for necked C function\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/gauss1d.hpp b/models/gauss1d.hpp
new file mode 100644
index 0000000..958cec9
--- /dev/null
+++ b/models/gauss1d.hpp
@@ -0,0 +1,47 @@
+#ifndef GAUSS_MODEL_H_
+#define GAUSS_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class gauss1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new gauss1d<T>(*this);
+    }
+  public:
+    gauss1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("N",1));
+      this->push_param_info(param_info<std::vector<T> >("x0",0));
+      this->push_param_info(param_info<std::vector<T> >("sigma",1));
+    }
+
+  public:
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T N=get_element(param,0);
+      T x0=get_element(param,1);
+      T sigma=get_element(param,2);
+      T y=(x-x0)/sigma;
+      return N*exp(-y*y);
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "Gaussian model\n"
+	"y=N*exp(-(x-x0)^2/sigma^2\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/lin1d.hpp b/models/lin1d.hpp
new file mode 100644
index 0000000..b0ddd31
--- /dev/null
+++ b/models/lin1d.hpp
@@ -0,0 +1,42 @@
+#ifndef LINEAR_MODEL_H_
+#define LINEAR_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class lin1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new lin1d<T>(*this);
+    }
+  public:
+    lin1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("k",1));
+      this->push_param_info(param_info<std::vector<T> >("b",0));
+    }
+
+  public:
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      return x*get_element(param,0)+get_element(param,1);
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "linear model\n"
+	"y=k*x+b\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/models.cc b/models/models.cc
new file mode 100644
index 0000000..7481b88
--- /dev/null
+++ b/models/models.cc
@@ -0,0 +1,176 @@
+#include "models.hpp"
+#include <core/opt_exception.hpp>
+#include "gauss1d.hpp"
+#include "bl1d.hpp"
+#include "nfw1d.hpp"
+#include "bpl1d.hpp"
+#include "beta1d.hpp"
+#include "nbeta1d.hpp"
+#include "dbeta1d.hpp"
+#include "lin1d.hpp"
+#include "pl1d.hpp"
+#include "poly1d.hpp"
+#include "bremss.hpp"
+#include "beta2d2.hpp"
+#include "beta2d.hpp"
+#include "dbeta2d2.hpp"
+#include "dbeta2d3.hpp"
+#include "dbeta2d.hpp"
+#include "dl_model.hpp"
+#include <iostream>
+using namespace std;
+
+
+namespace opt_utilities
+{
+  strmodel1d strm1d;
+  std::map<std::string,model<double,double,std::vector<double>,std::string>* > model_map;
+  std::map<std::string,model<double,vecn<double,2>,std::vector<double>,std::string>* > model2d_map;
+  std::list<std::string> get_model_name_list()
+  {
+    std::list<std::string> result;
+    for(std::map<std::string,model<double,double,std::vector<double>,std::string>* >::iterator i=model_map.begin();
+	i!=model_map.end();++i)
+      {
+	result.push_back(i->first);
+      }
+	return result;
+  }
+
+  std::list<std::string> get_model2d_name_list()
+  {
+    std::list<std::string> result;
+    for(map<std::string,model<double,vecn<double,2>,std::vector<double>,std::string>* > ::iterator i=model2d_map.begin();
+	i!=model2d_map.end();++i)
+      {
+	result.push_back(i->first);
+      }
+    return result;
+  }
+
+model<double,double,std::vector<double>,std::string>& get_1dmodel_by_name(const char* name)
+  {
+    std::map<std::string,model<double,double,std::vector<double>,std::string >* >::iterator iter;
+    iter=model_map.find(name);
+    if(iter==model_map.end()||iter->second==0)
+      {
+	throw opt_exception("model does not exist");
+      }
+    return *(iter->second);
+  }
+
+  strmodel1d& get_strm1d()
+  {
+    return strm1d;
+  }
+
+model<double,vecn<double,2>,std::vector<double>,std::string>& get_2dmodel_by_name(const char* name)
+  {
+    std::map<std::string,model<double,vecn<double,2>,std::vector<double>,std::string>* >::iterator iter;
+    iter=model2d_map.find(name);
+    if(iter==model2d_map.end()||iter->second==0)
+      {
+	throw opt_exception("model does not exist");
+      }
+    return *(iter->second);
+  }
+
+  int get_n_1dmodels()
+  {
+    return model_map.size();
+  }
+
+  int get_n_2dmodels()
+  {
+    return model2d_map.size();
+  }
+
+  class model_map_keeper_class
+  {
+  private:
+    void init_model_map()
+    {
+
+      //#define DECL_POLY(n) model_map["poly1d##n"]=new poly1d<double,n>;
+
+
+      model_map["lin1d"]=new lin1d<double>;
+      model_map["pl1d"]=new pl1d<double>;
+      model_map["bl1d"]=new bl1d<double>;
+      model_map["bpl1d"]=new bpl1d<double>;
+      model_map["beta1d"]=new beta1d<double>;  
+      model_map["bremss"]=new bremss<double>;
+      model_map["nbeta1d"]=new nbeta1d<double>;  
+      model_map["2beta1d"]=new dbeta1d<double>;
+      model_map["nfw"]=new nfw1d<double>;
+      model_map["gauss1d"]=new gauss1d<double>;  
+      model_map["poly1d2"]=new poly1d<double,2>;
+      model_map["poly1d3"]=new poly1d<double,3>;
+      model_map["poly1d4"]=new poly1d<double,4>;
+      model_map["poly1d5"]=new poly1d<double,5>;
+#ifdef __linux__
+      model_map["dlmodel"]=new dl_model<double>;
+#endif
+      //DECL_POLY(7)
+    }
+    
+    void release_model_map()
+    {
+      for(std::map<std::string,model<double,double,std::vector<double>,std::string>* >::iterator i=model_map.begin();
+	  i!=model_map.end();++i)
+	{
+	  delete i->second;
+	}
+    }
+  public:
+    model_map_keeper_class()
+    {
+      init_model_map();
+	  std::cerr<<"1d models Initialized"<<std::endl;
+    }
+    
+    ~model_map_keeper_class()
+    {
+      release_model_map();
+	  std::cerr<<"1d models Released"<<std::endl;
+    }
+
+  }model_map_keeper;
+
+  class model2d_map_keeper_class
+  {
+  private:
+    void init_model_map()
+    {
+      model2d_map["beta2d"]=new beta2d<double>;
+      model2d_map["beta2d2"]=new beta2d2<double>;
+      model2d_map["dbeta2d"]=new dbeta2d<double>;
+      model2d_map["dbeta2d2"]=new dbeta2d2<double>;
+      model2d_map["dbeta2d3"]=new dbeta2d3<double>;  
+    }
+    
+    void release_model_map()
+    {
+      for(std::map<std::string,model<double,vecn<double,2>,std::vector<double>,std::string>* >::iterator i=model2d_map.begin();
+	  i!=model2d_map.end();++i)
+	{
+	  delete i->second;
+	}
+    }
+  public:
+    model2d_map_keeper_class()
+    {
+      init_model_map();
+      std::cerr<<"2d models Initialized"<<std::endl;
+    }
+    
+    ~model2d_map_keeper_class()
+    {
+      release_model_map();
+      std::cerr<<"2d models Released"<<std::endl;
+    }
+
+  }model2d_map_keeper;
+
+
+};
diff --git a/models/models.hpp b/models/models.hpp
new file mode 100644
index 0000000..79201e8
--- /dev/null
+++ b/models/models.hpp
@@ -0,0 +1,36 @@
+#ifndef MODELS_HPP
+#define MODELS_HPP
+
+#include <core/fitter.hpp>
+#include <map>
+#include <string>
+#include <list>
+#include "vecn.hpp"
+#include "strmodel1d.hpp"
+
+
+
+namespace opt_utilities
+{
+  extern std::map<std::string,model<double,double,std::vector<double>,std::string>* > model_map;
+  extern std::map<std::string,model<double,vecn<double,2>,std::vector<double>,std::string >* > model2d_map;
+
+  extern strmodel1d strm1d;
+  extern std::list<std::string> get_model_name_list();
+  extern int get_n_1dmodels();
+  //  extern void init_model_map();
+  //  extern void release_model_map();
+  
+  extern std::list<std::string> get_model2d_name_list();
+  //  extern void init_model2d_map();
+  //  extern void release_model2d_map();
+  extern int get_n_2dmodels();
+  
+  extern model<double,double,std::vector<double>,std::string >& get_1dmodel_by_name(const char*);
+  extern  model<double,vecn<double,2>,std::vector<double>,std::string >& get_2dmodel_by_name(const char*);
+
+  extern strmodel1d& get_strm1d();
+}
+
+
+#endif
diff --git a/models/mul_model.hpp b/models/mul_model.hpp
new file mode 100644
index 0000000..0e64c1b
--- /dev/null
+++ b/models/mul_model.hpp
@@ -0,0 +1,171 @@
+#ifndef MUL_MODEL_H_
+#define MUL_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx,typename Tp,typename Tstr>
+  class mul_model
+    :public model<Ty,Tx,Tp,Tstr>
+  {
+  private:
+    model<Ty,Tx,Tp,Tstr>* do_clone()const
+    {
+      return new mul_model<Ty,Tx,Tp,Tstr>(*this);
+    }
+  private:
+    mul_model()
+    {
+    }
+
+  private:
+    model<Ty,Tx,Tp,Tstr>* pm1;
+    model<Ty,Tx,Tp,Tstr>* pm2;
+
+  public:
+    mul_model(const model<Ty,Tx,Tp,Tstr>& m1,
+		 const model<Ty,Tx,Tp,Tstr>& m2)
+      :pm1(m1.clone()),pm2(m2.clone())
+    {
+      int np1=m1.get_num_params();
+      int np2=m2.get_num_params();
+      for(int i=0;i<np1;++i)
+	{
+	  param_info<Tp,Tstr> p(m1.get_param_info(i));
+	  param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	  this->push_param_info(p1);
+	}
+      for(int i=0;i<np2;++i)
+	{
+	  param_info<Tp,Tstr> p(m2.get_param_info(i));
+	  param_info<Tp,Tstr> p2(p.get_name()+"2",p.get_default_value());
+	  this->push_param_info(p2);
+	}
+    }
+
+    mul_model(const mul_model& rhs)
+      :pm1(NULL),pm2(NULL)
+    {
+      int np1(0),np2(0);
+      if(rhs.pm1)
+	{
+	  pm1=rhs.pm1->clone();
+	  np1=rhs.pm1->get_num_params();
+	  for(int i=0;i<np1;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm1->get_param_info(i));
+	      param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	      this->push_param_info(p1);
+	    }
+	}
+      if(rhs.pm2)
+	{
+	  pm2=rhs.pm2->clone();
+	  np2=rhs.pm2->get_num_params();
+	  for(int i=0;i<np2;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm2->get_param_info(i));
+	      param_info<Tp,Tstr> p2(p.get_name()+"2",p.get_default_value());
+	      this->push_param_info(p2);
+	    }
+	}
+    }
+
+    mul_model& operator=(const mul_model& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      if(!pm1)
+	{
+	  //delete pm1;
+	  pm1->destroy();
+	}
+      if(!pm2)
+	{
+	  //delete pm2;
+	  pm2->destroy();
+	}
+      int np1(0),np2(0);
+      if(rhs.pm1)
+	{
+	  pm1=rhs.pm1->clone();
+	  np1=rhs.pm1->get_num_params();
+	  for(int i=0;i<np1;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm1->get_param_info(i));
+	      param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	      this->push_param_info(p1);
+	    }
+	}
+      if(rhs.pm2)
+	{
+	  pm2=rhs.pm2->clone();
+	  np2=rhs.pm2->get_num_params();
+	  for(int i=0;i<np2;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm2->get_param_info(i));
+	      param_info<Tp,Tstr> p2(p.get_name()+"2",p.get_default_value());
+	      this->push_param_info(p2);
+	    }
+	}
+      return *this;
+    }
+
+
+    ~mul_model()
+    {
+      if(!pm1)
+	{
+	  //delete pm1;
+	  pm1->destroy();
+	}
+      if(!pm2)
+	{
+	  //delete pm2;
+	  pm2->destroy();
+	}
+    }
+
+  public:
+    Ty do_eval(const Tx& x,const Tp& param)
+    {
+      if(!pm1)
+	{
+	  throw opt_exception("incomplete model!");
+	}
+      if(!pm2)
+	{
+	  throw opt_exception("incomplete model!");
+	}
+      Tp p1(pm1->get_num_params());
+      Tp p2(pm2->get_num_params());
+      int i=0;
+      int j=0;
+      for(i=0;i<pm1->get_num_params();++i,++j)
+	{
+	  set_element(p1,i,get_element(param,j));
+	}
+      for(i=0;i<pm2->get_num_params();++i,++j)
+	{
+	  set_element(p2,i,get_element(param,j));
+	}
+      return pm1->eval(x,p1)*pm2->eval(x,p2);
+    }
+  };
+
+  template <typename Ty,typename Tx,typename Tp>
+  mul_model<Ty,Tx,Tp,Tstr> operator*(const model<Ty,Tx,Tp,Tstr>& m1,
+				const model<Ty,Tx,Tp,Tstr>& m2)
+  {
+    return mul_model<Ty,Tx,Tp,Tstr>(m1,m2);
+  }
+
+};
+
+
+
+#endif
+//EOF
diff --git a/models/nbeta1d.hpp b/models/nbeta1d.hpp
new file mode 100644
index 0000000..3806fe9
--- /dev/null
+++ b/models/nbeta1d.hpp
@@ -0,0 +1,49 @@
+#ifndef NBETA_MODEL_H_
+#define NBETA_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <iostream>
+namespace opt_utilities
+{
+  template <typename T>
+  class nbeta1d
+    :public model<T,T,std::vector<T> ,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new nbeta1d<T>(*this);
+    }
+  public:
+    nbeta1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("S0",1));
+      this->push_param_info(param_info<std::vector<T> >("rc",10));
+      this->push_param_info(param_info<std::vector<T> >("beta",2./3.));
+      this->push_param_info(param_info<std::vector<T> >("bkg",0));
+    }
+
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T S0=get_element(param,0);
+      T r_c=get_element(param,1);
+      T beta=get_element(param,2);
+      T bkg=get_element(param,3);
+
+      return bkg+S0*pow(1+(x*x)/(r_c*r_c),-3./2.*beta);
+    }
+    
+  private:
+    std::string do_to_string()const
+    {
+      return "density beta model\n"
+	"n=n0*(1+(r/rc)^2)^(-1.5*beta)\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/nfw1d.hpp b/models/nfw1d.hpp
new file mode 100644
index 0000000..9c2dfd4
--- /dev/null
+++ b/models/nfw1d.hpp
@@ -0,0 +1,45 @@
+#ifndef NFW_MODEL_H_
+#define NFW_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <iostream>
+namespace opt_utilities
+{
+  template <typename T>
+  class nfw1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new nfw1d<T>(*this);
+    }
+  public:
+    nfw1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("rho0",1.));
+      this->push_param_info(param_info<std::vector<T> >("rs",1.));
+    }
+
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T rho0=get_element(param,0);
+      T rs=get_element(param,1);
+      
+
+      return rho0/(x/rs*(1+x/rs)*(1+x/rs));
+    }
+
+    std::string do_to_string()const
+    {
+      return "NFW model\n"
+	"y=rho0/(r/rs*(1+r/rs)^2\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/pl1d.hpp b/models/pl1d.hpp
new file mode 100644
index 0000000..50b4c50
--- /dev/null
+++ b/models/pl1d.hpp
@@ -0,0 +1,43 @@
+#ifndef POWER_LAW_MODEL_H_
+#define POWER_LAW_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename T>
+  class pl1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new pl1d<T>(*this);
+    }
+  public:
+    pl1d()
+    {
+      this->push_param_info(param_info<std::vector<T> >("Ampl",1));
+      this->push_param_info(param_info<std::vector<T> >("gamma",1));
+    }
+
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      T A=get_element(param,0);
+      T gamma=get_element(param,1);
+      return A*pow(x,gamma);
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      return "Simple power law model\n"
+	"y=A*x^gamma\n";
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/poly1d.hpp b/models/poly1d.hpp
new file mode 100644
index 0000000..a8c994b
--- /dev/null
+++ b/models/poly1d.hpp
@@ -0,0 +1,67 @@
+#ifndef POLY_MODEL_H_
+#define POLY_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+#include <sstream>
+#include <cassert>
+
+namespace opt_utilities
+{
+  template <typename T,int n>
+  class poly1d
+    :public model<T,T,std::vector<T>,std::string>
+  {
+  private:
+    model<T,T,std::vector<T> >* do_clone()const
+    {
+      return new poly1d<T,n>(*this);
+    }
+  public:
+    poly1d()
+    {
+      assert(n>=0);
+      for(int i=0;i<=n;++i)
+	{
+	  std::ostringstream ostr;
+	  ostr<<"a"<<i;
+	  this->push_param_info(param_info<std::vector<T> >(ostr.str().c_str(),1));  
+	}
+      
+    }
+
+  public:
+    T do_eval(const T& x,const std::vector<T>& param)
+    {
+      //      return x*get_element(param,0)+get_element(param,1);
+      T result(0);
+      for(int i=0;i<=n;++i)
+	{
+	  T xn(1);
+	  for(int j=0;j<i;++j)
+	    {
+	      xn*=x;
+	    }
+	  result+=get_element(param,i)*xn;
+	}
+      return result;
+    }
+
+  private:
+    std::string do_to_string()const
+    {
+      std::ostringstream ostr;
+      ostr<<n<<"-order polynorminal model\n";
+      for(int i=0;i<n;++i)
+	{
+	  ostr<<"a"<<i<<"*x^"<<i<<"+";
+	}
+      ostr<<"a"<<n<<"*x^"<<n;
+      return ostr.str();
+    }
+  };
+};
+
+
+
+#endif
+//EOF
diff --git a/models/pow_model.hpp b/models/pow_model.hpp
new file mode 100644
index 0000000..79baa4b
--- /dev/null
+++ b/models/pow_model.hpp
@@ -0,0 +1,120 @@
+#ifndef POW_MODEL_H_
+#define POW_MODEL_H_
+#include <core/fitter.hpp>
+#include <cmath>
+
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx,typename Tp,typename Tstr>
+  class pow_model
+    :public model<Ty,Tx,Tp,Tstr>
+  {
+  private:
+    model<Ty,Tx,Tp,Tstr>* do_clone()const
+    {
+      return new pow_model<Ty,Tx,Tp,Tstr>(*this);
+    }
+  private:
+    pow_model()
+    {
+    }
+
+  private:
+    model<Ty,Tx,Tp,Tstr>* pm1;
+    typename value_type_trait<Tp>::value_type idx;
+
+  public:
+    pow_model(const model<Ty,Tx,Tp,Tstr>& m1,
+	      const typename value_type_trait<Tp>::value_type& index)
+      :pm1(m1.clone()),idx(index)
+    {
+      int np1=m1.get_num_params();
+      
+      for(int i=0;i<np1;++i)
+	{
+	  param_info<Tp,Tstr> p(m1.get_param_info(i));
+	  //param_info<Tp,Tstr> p1(p.get_name(),p.get_default_value());
+	  this->push_param_info(p);
+	}
+    }
+
+    pow_model(const pow_model& rhs)
+      :pm1(NULL),idx(0)
+    {
+      int np1(0);
+      if(rhs.pm1)
+	{
+	  pm1=rhs.pm1->clone();
+	  np1=rhs.pm1->get_num_params();
+	  for(int i=0;i<np1;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm1->get_param_info(i));
+	      param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	      this->push_param_info(p1);
+	    }
+	}
+      idx=rhs.idx;
+    }
+
+    pow_model& operator=(const pow_model& rhs)
+    {
+      if(this==&rhs)
+	{
+	  return *this;
+	}
+      if(!pm1)
+	{
+	  //delete pm1;
+	  pm1->destroy();
+	}
+
+      int np1(0);
+      if(rhs.pm1)
+	{
+	  pm1=rhs.pm1->clone();
+	  np1=rhs.pm1->get_num_params();
+	  for(int i=0;i<np1;++i)
+	    {
+	      param_info<Tp,Tstr> p(rhs.pm1->get_param_info(i));
+	      // param_info<Tp,Tstr> p1(p.get_name()+"1",p.get_default_value());
+	      this->push_param_info(p);
+	    }
+	}
+      idx=rhs.idx;
+
+      return *this;
+    }
+
+    ~pow_model()
+    {
+      if(!pm1)
+	{
+	  //delete pm1;
+	  pm1->destroy();
+	}
+    }
+
+  public:
+    Ty do_eval(const Tx& x,const Tp& param)
+    {
+      if(!pm1)
+	{
+	  throw opt_exception("incomplete model!");
+	}
+
+      return std::pow(pm1->eval(x,param),idx);
+    }
+  };
+  
+  template <typename Ty,typename Tx,typename Tp,typename Tstr>
+  pow_model<Ty,Tx,Tp,Tstr> pow(const model<Ty,Tx,Tp,Tstr>& m1,
+			  const typename value_type_trait<Tp>::value_type& idx)
+  {
+    return pow_model<Ty,Tx,Tp,Tstr>(m1,idx);
+  }
+};
+
+
+
+#endif
+//EOF
diff --git a/models/strmodel1d.cc b/models/strmodel1d.cc
new file mode 100644
index 0000000..df3cd40
--- /dev/null
+++ b/models/strmodel1d.cc
@@ -0,0 +1,82 @@
+#include "strmodel1d.hpp"
+
+using namespace mu;
+using namespace std;
+using namespace opt_utilities;
+
+strmodel1d* strmodel1d::do_clone()const
+{
+  return new strmodel1d(*this);
+}
+
+strmodel1d::strmodel1d()
+{
+  set_buildin_fun();  
+}
+
+strmodel1d::strmodel1d(const strmodel1d& rhs)
+  :expr(rhs.expr),
+   par_names(rhs.par_names),
+   var_name(rhs.var_name),
+   par_vec(rhs.par_vec)
+{
+  set_buildin_fun();
+  set_expr(expr,par_names,var_name);
+}
+
+strmodel1d& strmodel1d::operator=(const strmodel1d& rhs)
+{
+  set_buildin_fun();
+  expr=rhs.expr;
+  par_names=rhs.par_names;
+  var_name=rhs.var_name;
+  par_vec=rhs.par_vec;
+  set_expr(expr,par_names,var_name);
+  return *this;
+}
+
+void strmodel1d::set_buildin_fun()
+{
+  mp.DefineFun("sin",sin);
+  mp.DefineFun("cos",cos);
+  mp.DefineFun("exp",exp);
+  mp.DefineFun("tan",tan);
+  mp.DefineFun("log",log);
+}
+
+
+void strmodel1d::set_expr(const string& _expr,
+			  const std::vector<std::string>& _par_names,
+			  const std::string& _var_name)
+{
+  expr=_expr;
+  par_names=_par_names;
+  var_name=_var_name;
+  this->clear_param_info();
+  par_vec.resize(par_names.size());
+  mp.ClearVar();
+  //  mp.ClearFun();
+  for(int i=0;i<par_vec.size();++i)
+    {
+      mp.DefineVar(par_names[i].c_str(),&par_vec[i]);
+      this->push_param_info(param_info<std::vector<double> >(par_names[i],0));
+    }
+  mp.DefineVar(var_name.c_str(),&x);
+  mp.SetExpr(expr.c_str());
+}
+
+
+double strmodel1d::do_eval(const double& _x,const vector<double>& p)
+{
+  for(int i=0;i<par_vec.size();++i)
+    {
+      //get_element(par_vec,i)=get_element(p,i);
+      set_element(par_vec,i,get_element(p,i));
+      //      cout<<par_vec[i]<<" ";
+    }
+  x=_x;
+  //  cout<<x<<" ";
+  double result(mp.Eval());
+  //  cout<<result<<endl;
+  return result;
+}
diff --git a/models/strmodel1d.hpp b/models/strmodel1d.hpp
new file mode 100644
index 0000000..8d992a0
--- /dev/null
+++ b/models/strmodel1d.hpp
@@ -0,0 +1,39 @@
+#ifndef STRMODEL1D_HPP
+#define STRMODEL1D_HPP
+#include <core/fitter.hpp>
+#include <cmath>
+#include <sstream>
+#include <cassert>
+#include <muparser/muParser.h>
+#include <vector>
+#include <string>
+
+class strmodel1d
+  :public opt_utilities::model<double,double,std::vector<double>,std::string>
+{
+private:
+  mu::Parser mp;
+  strmodel1d* do_clone()const;
+  std::vector<double> par_vec;
+  std::vector<std::string> par_names;
+  std::string expr;
+  std::string var_name;
+  double x;
+  void set_buildin_fun();
+public:
+  double do_eval(const double& x,const std::vector<double>& p);
+  strmodel1d();
+  strmodel1d(const strmodel1d& rhs);
+  strmodel1d& operator=(const strmodel1d& rhs);
+  
+
+  void set_expr(const std::string& _expr,
+		const std::vector<std::string>& _par_names,
+		const std::string& _var_name);
+
+};
+
+
+
+#endif
+//EOF
diff --git a/models/vecn.hpp b/models/vecn.hpp
new file mode 100644
index 0000000..cac1436
--- /dev/null
+++ b/models/vecn.hpp
@@ -0,0 +1,62 @@
+#ifndef VECN_HPP
+#define VECN_HPP
+#include <iostream>
+namespace opt_utilities
+{
+  template <typename T,int n>
+  class vecn
+  {
+  public:
+    T data[n];
+  public:
+    T& operator[](int i)
+    {
+      return data[i];
+    }
+    
+    const T& operator[](int i)const
+    {
+      return data[i];
+    }
+    
+    vecn()
+    {
+      for(int i=0;i<n;++i)
+	{
+	  data[i]=0;
+	}
+    }
+    
+  };
+
+  template <typename T,int n>
+  std::istream& operator>>(std::istream& is,vecn<T,n>& p)
+  {
+    for(int i=0;i<n;++i)
+      {
+	is>>p[i];
+	//	std::cout<<i<<std::endl;
+      }
+    return is;
+  }
+
+
+  template <typename T,int n>
+  std::ostream& operator<<(std::ostream& os,const vecn<T,n>& p)
+  {
+    os<<'[';
+    for(int i=0;i<n;++i)
+      {
+	os<<p[i]<<",";
+	//	std::cout<<i<<std::endl;
+      }
+    os<<']';
+    return os;
+  }
+
+
+  
+};
+
+#endif
+//EOF
diff --git a/muparser/makefile b/muparser/makefile
new file mode 100644
index 0000000..83d2cd5
--- /dev/null
+++ b/muparser/makefile
@@ -0,0 +1,16 @@
+MUP_OBJ=muParserBase.o muParser.o muParserInt.o\
+	muParserBytecode.o muParserDLL.o\
+	 muParserTest.o\
+	muParserCallback.o muParserError.o\
+	 muParserTokenReader.o
+
+libmuparser.a:$(MUP_OBJ)
+	$(AR) $@ *.o
+
+.cpp.o:
+	$(CPP) $< $(CPPFLAGS)
+
+clean:
+	$(RM) *.o
+
+
diff --git a/muparser/muParser.cpp b/muparser/muParser.cpp
new file mode 100644
index 0000000..e92b1a2
--- /dev/null
+++ b/muparser/muParser.cpp
@@ -0,0 +1,259 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+#include "muParser.h"
+
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+
+/** \brief Pi (what else?). */
+#define PARSER_CONST_PI  3.141592653589793238462643
+
+/** \brief The eulerian number. */
+#define PARSER_CONST_E   2.718281828459045235360287
+
+using namespace std;
+
+
+/** \brief Namespace for mathematical applications. */
+namespace mu
+{
+
+//---------------------------------------------------------------------------
+// Trigonometric function
+value_type Parser::Sin(value_type v)   { return sin(v);  }
+value_type Parser::Cos(value_type v)   { return cos(v);  }
+value_type Parser::Tan(value_type v)   { return tan(v);  }
+value_type Parser::ASin(value_type v)  { return asin(v); }
+value_type Parser::ACos(value_type v)  { return acos(v); }
+value_type Parser::ATan(value_type v)  { return atan(v); }
+value_type Parser::Sinh(value_type v)  { return sinh(v); }
+value_type Parser::Cosh(value_type v)  { return cosh(v); }
+value_type Parser::Tanh(value_type v)  { return tanh(v); }
+value_type Parser::ASinh(value_type v) { return log(v + sqrt(v * v + 1)); }
+value_type Parser::ACosh(value_type v) { return log(v + sqrt(v * v - 1)); }
+value_type Parser::ATanh(value_type v) { return ((value_type)0.5 * log((1 + v) / (1 - v))); }
+
+//---------------------------------------------------------------------------
+// Logarithm functions
+value_type Parser::Log2(value_type v)  { return log(v)/log((value_type)2); } // Logarithm base 2
+value_type Parser::Log10(value_type v) { return log10(v); } // Logarithm base 10
+value_type Parser::Ln(value_type v)    { return log(v);   } // Logarithm base e (natural logarithm)
+
+//---------------------------------------------------------------------------
+//  misc
+value_type Parser::Exp(value_type v)  { return exp(v);   }
+value_type Parser::Abs(value_type v)  { return fabs(v);  }
+value_type Parser::Sqrt(value_type v) { return sqrt(v);  }
+value_type Parser::Rint(value_type v) { return floor(v + (value_type)0.5); }
+value_type Parser::Sign(value_type v) { return (value_type)((v<0) ? -1 : (v>0) ? 1 : 0); }
+
+//---------------------------------------------------------------------------
+// Conditional (if then else)
+value_type Parser::Ite(value_type v1, value_type v2, value_type v3) { return (v1==1) ? v2 : v3; }
+
+//---------------------------------------------------------------------------
+// Unary operator Callbacks: Infix operators
+value_type Parser::UnaryMinus(value_type v) { return -v; }
+
+//---------------------------------------------------------------------------
+// Functions with variable number of arguments
+// sum
+value_type Parser::Sum(const value_type *a_afArg, int a_iArgc)
+{ 
+  if (!a_iArgc)	
+    throw exception_type(_T("too few arguments for function sum."));
+
+  value_type fRes=0;
+  for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
+  return fRes;
+}
+
+//---------------------------------------------------------------------------
+// mean value
+value_type Parser::Avg(const value_type *a_afArg, int a_iArgc)
+{ 
+  if (!a_iArgc)	
+    throw exception_type(_T("too few arguments for function sum."));
+
+  value_type fRes=0;
+  for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
+  return fRes/(double)a_iArgc;
+}
+
+//---------------------------------------------------------------------------
+// minimum
+value_type Parser::Min(const value_type *a_afArg, int a_iArgc)
+{ 
+    if (!a_iArgc)	
+        throw exception_type(_T("too few arguments for function min."));
+
+    value_type fRes=a_afArg[0];
+    for (int i=0; i<a_iArgc; ++i) fRes = std::min(fRes, a_afArg[i]);
+
+    return fRes;
+}
+
+//---------------------------------------------------------------------------
+// maximum
+value_type Parser::Max(const value_type *a_afArg, int a_iArgc)
+{ 
+    if (!a_iArgc)	
+        throw exception_type(_T("too few arguments for function min."));
+
+    value_type fRes=a_afArg[0];
+    for (int i=0; i<a_iArgc; ++i) fRes = std::max(fRes, a_afArg[i]);
+
+    return fRes;
+}
+
+//---------------------------------------------------------------------------
+// Default value recognition callback
+bool Parser::IsVal(const char_type *a_szExpr, int &a_iPos, value_type &a_fVal)
+{
+  value_type fVal(0);
+
+// thanks to CodeProject member sailorickm for writing this fix:
+// http://www.codeproject.com/cpp/FastMathParser.asp?msg=1354598#xx1354598xx
+// i cant test it myself, if you see problems please contact me.
+#if defined (__hpux) || (defined __GNUC__ && (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 )))
+  int iEnd = 0;
+  int nAssigned = sscanf(a_szExpr, "%lf%n", &fVal, &iEnd);
+  if (nAssigned == 0)
+  iEnd = -1;
+#else
+  stringstream_type stream(a_szExpr);
+  stream.seekg(0); // todo:  check if this really is necessary
+  stream >> fVal;
+  int iEnd = stream.tellg(); // Position after reading
+#endif
+
+  if (iEnd==-1)
+    return false;
+
+  a_iPos += iEnd;
+  a_fVal = fVal;
+  return true;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Constructor. 
+
+  Call ParserBase class constructor and trigger Function, Operator and Constant initialization.
+*/
+Parser::Parser()
+  :ParserBase()
+  ,m_fEpsilon((value_type)1e-7)
+{
+  AddValIdent(IsVal);
+
+  InitCharSets();
+  InitFun();
+  InitConst();
+  InitOprt();
+}
+
+//---------------------------------------------------------------------------
+/** Define the character sets. */
+void Parser::InitCharSets()
+{
+  DefineNameChars( _T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") );
+  DefineOprtChars( _T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_") );
+  DefineInfixOprtChars( _T("/+-*^?<>=#!$%&|~'_") );
+}
+
+//---------------------------------------------------------------------------
+/** \brief Initialize the default functions. */
+void Parser::InitFun()
+{
+  // trigonometric functions
+  DefineFun(_T("sin"), Sin);
+  DefineFun(_T("cos"), Cos);
+  DefineFun(_T("tan"), Tan);
+  // arcus functions
+  DefineFun(_T("asin"), ASin);
+  DefineFun(_T("acos"), ACos);
+  DefineFun(_T("atan"), ATan);
+  // hyperbolic functions
+  DefineFun(_T("sinh"), Sinh);
+  DefineFun(_T("cosh"), Cosh);
+  DefineFun(_T("tanh"), Tanh);
+  // arcus hyperbolic functions
+  DefineFun(_T("asinh"), ASinh);
+  DefineFun(_T("acosh"), ACosh);
+  DefineFun(_T("atanh"), ATanh);
+  // Logarithm functions
+  DefineFun(_T("log2"), Log2);
+  DefineFun(_T("log10"), Log10);
+  DefineFun(_T("log"), Log10);
+  DefineFun(_T("ln"), Ln);
+  // misc
+  DefineFun(_T("exp"), Exp);
+  DefineFun(_T("sqrt"), Sqrt);
+  DefineFun(_T("sign"), Sign);
+  DefineFun(_T("rint"), Rint);
+  DefineFun(_T("abs"), Abs);
+  DefineFun(_T("if"), Ite);
+  // Functions with variable number of arguments
+  DefineFun(_T("sum"), Sum);
+  DefineFun(_T("avg"), Avg);
+  DefineFun(_T("min"), Min);
+  DefineFun(_T("max"), Max);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Initialize operators. */
+void Parser::InitConst()
+{
+  DefineConst(_T("_pi"), (value_type)PARSER_CONST_PI);
+  DefineConst(_T("_e"), (value_type)PARSER_CONST_E);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Initialize operators. */
+void Parser::InitOprt()
+{
+  DefineInfixOprt(_T("-"), UnaryMinus);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Numerically differentiate with regard to a variable. */
+value_type Parser::Diff(value_type *a_Var, value_type a_fPos) const
+{
+  assert(m_fEpsilon);
+  value_type fEpsilon( (a_fPos==0) ? (value_type)1e-10 : m_fEpsilon * a_fPos ),
+             fRes(0), fBuf(*a_Var), f[4] = {0,0,0,0};
+
+ *a_Var = a_fPos+2*fEpsilon;  f[0] = Eval();
+ *a_Var = a_fPos+1*fEpsilon;  f[1] = Eval();
+ *a_Var = a_fPos-1*fEpsilon;  f[2] = Eval();
+ *a_Var = a_fPos-2*fEpsilon;  f[3] = Eval();
+ *a_Var = fBuf; // restore variable
+
+  fRes = (-f[0] + 8*f[1] - 8*f[2] + f[3]) / (12*fEpsilon);
+  return fRes;
+}
+
+} // namespace mu
diff --git a/muparser/muParser.h b/muparser/muParser.h
new file mode 100644
index 0000000..5aff62d
--- /dev/null
+++ b/muparser/muParser.h
@@ -0,0 +1,104 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+#ifndef MU_PARSER_H
+#define MU_PARSER_H
+
+#include "muParserBase.h"
+#include <vector>
+
+
+namespace mu
+{
+
+/** \brief Mathematical expressions parser (reference implementation).
+  
+  Standard implementation of the mathematical expressions parser. 
+  Can be used as a reference implementation for subclassing the parser.
+
+  <small>
+  (C) 2004-2006 Ingo Berg<br>
+  ingo_berg(at)gmx.de
+  </small>
+*/
+class Parser : public ParserBase
+{
+private:
+    // Trigonometric functions
+    static value_type  Sin(value_type);
+	  static value_type  Cos(value_type);
+	  static value_type  Tan(value_type);
+	  // arcus functions
+	  static value_type  ASin(value_type);
+	  static value_type  ACos(value_type);
+	  static value_type  ATan(value_type);
+	  // hyperbolic functions
+	  static value_type  Sinh(value_type);
+	  static value_type  Cosh(value_type);
+	  static value_type  Tanh(value_type);
+	  // arcus hyperbolic functions
+	  static value_type  ASinh(value_type);
+	  static value_type  ACosh(value_type);
+	  static value_type  ATanh(value_type);
+	  // Logarithm functions
+	  static value_type  Log2(value_type);  // Logarithm Base 2
+	  static value_type  Log10(value_type); // Logarithm Base 10
+	  static value_type  Ln(value_type);    // Logarithm Base e (natural logarithm)
+	  // misc
+	  static value_type  Exp(value_type);
+	  static value_type  Abs(value_type);
+	  static value_type  Sqrt(value_type);
+	  static value_type  Rint(value_type);
+	  static value_type  Sign(value_type);
+    static value_type  Ite(value_type, value_type, value_type);
+
+    // Prefix operators
+    // !!! Unary Minus is a MUST if you want to use negative signs !!!
+    static value_type  UnaryMinus(value_type);
+
+    // Functions with variable number of arguments
+    static value_type Sum(const value_type*, int);  // sum
+    static value_type Avg(const value_type*, int);  // mean value
+    static value_type Min(const value_type*, int);  // minimum
+    static value_type Max(const value_type*, int);  // maximum
+
+    static bool IsVal(const char_type *a_szExpr, int &a_iPos, value_type &a_fVal);
+
+    value_type m_fEpsilon; ///< Epsilon used for numerical differentiation.
+
+public:
+	  Parser();
+
+    virtual void InitCharSets();
+    virtual void InitFun();
+	  virtual void InitConst();
+	  virtual void InitOprt();
+
+    value_type Diff(value_type *a_Var, value_type a_fPos) const;
+};
+
+} // namespace mu
+
+#endif
+
diff --git a/muparser/muParserBase.cpp b/muparser/muParserBase.cpp
new file mode 100644
index 0000000..e81e53e
--- /dev/null
+++ b/muparser/muParserBase.cpp
@@ -0,0 +1,1364 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#include "muParser.h"
+
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <vector>
+#include <sstream>
+
+using namespace std;
+
+
+namespace mu
+{
+
+//------------------------------------------------------------------------------
+/** \brief Identifiers for built in binary operators. 
+
+    When defining custom binary operators with #AddOprt(...) make sure not to choose 
+    names conflicting with these definitions. 
+*/
+const char_type* ParserBase::c_DefaultOprt[] = 
+{ 
+  _T("<="), _T(">="), _T("!="), 
+  _T("=="), _T("<"),  _T(">"), 
+  _T("+"),  _T("-"),  _T("*"), 
+  _T("/"),  _T("^"), _T("and"), 
+  _T("or"), _T("xor"), _T("="), 
+  _T("("), _T(")"), _T(","), 0 
+};
+
+//------------------------------------------------------------------------------
+/** \brief Constructor.
+  \param a_szFormula the formula to interpret.
+  \throw ParserException if a_szFormula is null.
+*/
+ParserBase::ParserBase()
+  :m_pParseFormula(&ParserBase::ParseString)
+  ,m_pCmdCode(0)
+  ,m_vByteCode()
+  ,m_vStringBuf()
+  ,m_pTokenReader()
+  ,m_FunDef()
+  ,m_PostOprtDef()
+  ,m_InfixOprtDef()
+  ,m_OprtDef()
+  ,m_ConstDef()
+  ,m_StrVarDef()
+  ,m_VarDef()
+  ,m_bOptimize(true)
+  ,m_bUseByteCode(true)
+  ,m_bBuiltInOp(true)
+  ,m_sNameChars()
+  ,m_sOprtChars()
+  ,m_sInfixOprtChars()
+{
+  InitTokenReader();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Copy constructor. 
+
+ Implemented by calling Assign(a_Parser)
+*/
+ParserBase::ParserBase(const ParserBase &a_Parser)
+  :m_pParseFormula(&ParserBase::ParseString)
+  ,m_pCmdCode(0)
+  ,m_vByteCode()
+  ,m_vStringBuf()
+  ,m_pTokenReader()
+  ,m_FunDef()
+  ,m_PostOprtDef()
+  ,m_InfixOprtDef()
+  ,m_OprtDef()
+  ,m_ConstDef()
+  ,m_StrVarDef()
+  ,m_VarDef()
+  ,m_bOptimize(true)
+  ,m_bUseByteCode(true)
+  ,m_bBuiltInOp(true)
+{
+  m_pTokenReader.reset(new token_reader_type(this));
+  Assign(a_Parser);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Assignement operator. 
+
+   Implemented by calling Assign(a_Parser). Self assignement is suppressed.
+   \param a_Parser Object to copy to this.
+   \return *this
+   \throw nothrow
+*/
+ParserBase& ParserBase::operator=(const ParserBase &a_Parser)
+{
+  Assign(a_Parser);
+  return *this;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Copy state of a parser object to this. 
+
+  Clears Variables and Functions of this parser.
+  Copies the states of all internal variables.
+  Resets parse function to string parse mode.
+
+  \param a_Parser the source object.
+*/
+void ParserBase::Assign(const ParserBase &a_Parser)
+{
+  if (&a_Parser==this)
+    return;
+
+  // Don't copy bytecode instead cause the parser to create new bytecode
+  // by resetting the parse function.
+  ReInit();
+
+  m_ConstDef = a_Parser.m_ConstDef;         // Copy user define constants
+  m_VarDef = a_Parser.m_VarDef;             // Copy user defined variables
+  m_bOptimize  = a_Parser.m_bOptimize;
+  m_bUseByteCode = a_Parser.m_bUseByteCode;
+  m_bBuiltInOp = a_Parser.m_bBuiltInOp;
+  m_vStringBuf = a_Parser.m_vStringBuf;
+  m_pTokenReader.reset(a_Parser.m_pTokenReader->Clone(this));
+  m_StrVarDef = a_Parser.m_StrVarDef;
+  m_vStringVarBuf = a_Parser.m_vStringVarBuf;
+
+  // Copy function and operator callbacks
+  m_FunDef = a_Parser.m_FunDef;             // Copy function definitions
+  m_PostOprtDef = a_Parser.m_PostOprtDef;   // post value unary operators
+  m_InfixOprtDef = a_Parser.m_InfixOprtDef; // unary operators for infix notation
+
+  m_sNameChars = a_Parser.m_sNameChars;
+  m_sOprtChars = a_Parser.m_sOprtChars;
+  m_sInfixOprtChars = a_Parser.m_sInfixOprtChars;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Initialize the token reader. 
+
+   Create new token reader object and submit pointers to function, operator,
+   constant and variable definitions.
+
+   \post m_pTokenReader.get()!=0
+   \throw nothrow
+*/
+void ParserBase::InitTokenReader()
+{
+  m_pTokenReader.reset(new token_reader_type(this));
+}
+
+//---------------------------------------------------------------------------
+/** \brief Reset parser to string parsing mode and clear internal buffers.
+
+    Clear bytecode, reset the token reader.
+    \throw nothrow
+*/
+void ParserBase::ReInit() const
+{
+  m_pParseFormula = &ParserBase::ParseString;
+  m_vStringBuf.clear();
+  m_vByteCode.clear();
+  m_pTokenReader->ReInit();
+}
+
+//---------------------------------------------------------------------------
+void ParserBase::AddValIdent(identfun_type a_pCallback)
+{
+  m_pTokenReader->AddValIdent(a_pCallback);
+}
+
+//---------------------------------------------------------------------------
+void ParserBase::SetVarFactory(facfun_type a_pFactory, void *pUserData)
+{
+  m_pTokenReader->SetVarCreator(a_pFactory, pUserData);  
+}
+
+//---------------------------------------------------------------------------
+/** \brief Add a function or operator callback to the parser.
+*/
+void ParserBase::AddCallback( const string_type &a_strName,
+                              const ParserCallback &a_Callback, 
+                              funmap_type &a_Storage,
+                              const char_type *a_szCharSet )
+{
+  if (a_Callback.GetAddr()==0)
+      Error(ecINVALID_FUN_PTR);
+
+  const funmap_type *pFunMap = &a_Storage;
+
+  // Check for conflicting operator or function names
+  if ( pFunMap!=&m_FunDef && m_FunDef.find(a_strName)!=m_FunDef.end() )
+    Error(ecNAME_CONFLICT);
+
+  if ( pFunMap!=&m_PostOprtDef && m_PostOprtDef.find(a_strName)!=m_PostOprtDef.end() )
+    Error(ecNAME_CONFLICT);
+
+  if ( pFunMap!=&m_InfixOprtDef && pFunMap!=&m_OprtDef && m_InfixOprtDef.find(a_strName)!=m_InfixOprtDef.end() )
+    Error(ecNAME_CONFLICT);
+
+  if ( pFunMap!=&m_InfixOprtDef && pFunMap!=&m_OprtDef && m_OprtDef.find(a_strName)!=m_OprtDef.end() )
+    Error(ecNAME_CONFLICT);
+
+  CheckName(a_strName, a_szCharSet);
+  a_Storage[a_strName] = a_Callback;
+  ReInit();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Check if a name contains invalid characters. 
+
+    \throw ParserException if the name contains invalid charakters.
+*/
+void ParserBase::CheckName(const string_type &a_sName,
+                           const string_type &a_szCharSet) const
+{
+  if ( !a_sName.length() ||
+       (a_sName.find_first_not_of(a_szCharSet)!=string_type::npos) ||
+       (a_sName[0]>='0' && a_sName[0]<='9'))
+  {
+    Error(ecINVALID_NAME);
+  }
+}
+
+//---------------------------------------------------------------------------
+/** \brief Set the formula. 
+    Triggers first time calculation thus the creation of the bytecode and
+    scanning of used variables.
+
+    \param a_strFormula Formula as string_type
+    \throw ParserException in case of syntax errors.
+*/
+void ParserBase::SetExpr(const string_type &a_sExpr)
+{
+  // <ibg> 20060222: Bugfix for Borland-Kylix:
+  // adding a space to the expression will keep Borlands KYLIX from going wild
+  // when calling tellg on a stringstream created from the expression after 
+  // reading a value at the end of an expression. (mu::Parser::IsVal function)
+  // (tellg returns -1 otherwise causing the parser to ignore the value)
+  string_type sBuf(a_sExpr + _T(" ") );
+  m_pTokenReader->SetFormula(sBuf);
+  ReInit();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Add a user defined operator. 
+    \post Will reset the Parser to string parsing mode.
+*/
+void ParserBase::DefinePostfixOprt(const string_type &a_sName, 
+                                   fun_type1 a_pFun,
+                                   bool a_bAllowOpt)
+{
+  AddCallback( a_sName, 
+               ParserCallback(a_pFun, a_bAllowOpt, prPOSTFIX, cmOPRT_POSTFIX),
+               m_PostOprtDef, 
+               ValidOprtChars() );
+}
+
+//---------------------------------------------------------------------------
+/** \brief Add a user defined operator. 
+    \post Will reset the Parser to string parsing mode.
+    \param a_sName [in] operator Identifier 
+    \param a_pFun [in] Operator callback function
+    \param a_iPrec [in] Operator Precedence (default=prSIGN)
+    \param a_bAllowOpt [in] True if operator is volatile (default=false)
+
+    \sa EPrec
+*/
+void ParserBase::DefineInfixOprt(const string_type &a_sName, 
+                                 fun_type1 a_pFun, 
+                                 int a_iPrec, 
+                                 bool a_bAllowOpt)
+{
+  AddCallback( a_sName, 
+               ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_INFIX), 
+               m_InfixOprtDef, 
+               ValidOprtChars() );
+}
+
+//---------------------------------------------------------------------------
+void ParserBase::DefineOprt( const string_type &a_sName, 
+                             fun_type2 a_pFun, 
+                             unsigned a_iPrec, 
+                             bool a_bAllowOpt )
+{
+  // Check for conflicts with built in operator names
+  for (int i=0; m_bBuiltInOp && i<cmCOMMA; ++i)
+    if (a_sName == string_type(c_DefaultOprt[i]))
+      Error(ecBUILTIN_OVERLOAD);
+
+  AddCallback( a_sName, 
+               ParserCallback(a_pFun, a_bAllowOpt, a_iPrec, cmOPRT_BIN), 
+               m_OprtDef, 
+               ValidOprtChars() );
+}
+
+//---------------------------------------------------------------------------
+void ParserBase::DefineStrConst(const string_type &a_strName, const string_type &a_strVal)
+{
+  // Test if a constant with that names already exists
+  if (m_StrVarDef.find(a_strName)!=m_StrVarDef.end())
+    Error(ecNAME_CONFLICT);
+
+  CheckName(a_strName, ValidNameChars());
+  
+  // Store variable string in internal buffer
+  m_vStringVarBuf.push_back(a_strVal);
+
+  // bind buffer index to variable name
+  m_StrVarDef[a_strName] = m_vStringBuf.size();
+
+  ReInit();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Add a user defined variable. 
+    \post Will reset the Parser to string parsing mode.
+    \pre [assert] a_fVar!=0
+    \throw ParserException in case the name contains invalid signs.
+*/
+void ParserBase::DefineVar(const string_type &a_sName, value_type *a_pVar)
+{
+  if (a_pVar==0)
+    Error(ecINVALID_VAR_PTR);
+
+  // Test if a constant with that names already exists
+  if (m_ConstDef.find(a_sName)!=m_ConstDef.end())
+    Error(ecNAME_CONFLICT);
+
+  if (m_FunDef.find(a_sName)!=m_FunDef.end())
+    Error(ecNAME_CONFLICT);
+
+  CheckName(a_sName, ValidNameChars());
+  m_VarDef[a_sName] = a_pVar;
+  ReInit();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Add a user defined constant. 
+    \post Will reset the Parser to string parsing mode.
+    \throw ParserException in case the name contains invalid signs.
+*/
+void ParserBase::DefineConst(const string_type &a_sName, value_type a_fVal)
+{
+  CheckName(a_sName, ValidNameChars());
+  m_ConstDef[a_sName] = a_fVal;
+  ReInit();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Get operator priority.
+
+ \throw ParserException if a_Oprt is no operator code
+*/
+int ParserBase::GetOprtPri(const token_type &a_Tok) const
+{
+  switch (a_Tok.GetCode())
+  {
+    // built in operators
+    case cmEND:        return -5;
+	  case cmCOMMA:      return -4;
+    case cmBO :	
+    case cmBC :        return -2;
+    case cmASSIGN:     return -1;               
+    case cmAND:
+    case cmXOR:
+    case cmOR:         return  prLOGIC;  
+    case cmLT :
+    case cmGT :
+    case cmLE :
+    case cmGE :
+    case cmNEQ:
+    case cmEQ :        return  prCMP; 
+    case cmADD:
+    case cmSUB:        return  prADD_SUB;
+    case cmMUL:
+    case cmDIV:        return  prMUL_DIV;
+    case cmPOW:        return  prPOW;
+
+    // user defined binary operators
+    case cmOPRT_INFIX: 
+    case cmOPRT_BIN:   return a_Tok.GetPri();
+    default:  Error(ecINTERNAL_ERROR, 5);
+              return 999;
+  }  
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return a map containing the used variables only. */
+const varmap_type& ParserBase::GetUsedVar() const
+{
+  try
+  {
+    m_pTokenReader->IgnoreUndefVar(true);
+    ParseString(); // implicitely create or update the map with the
+                   // used variables stored in the token reader if not already done
+    m_pTokenReader->IgnoreUndefVar(false);
+  }
+  catch(exception_type &e)
+  {
+    m_pTokenReader->IgnoreUndefVar(false);
+    throw e;
+  }
+  
+  // Make sure to stay in string parse mode, dont call ReInit()
+  // because it deletes the array with the used variables
+  m_pParseFormula = &ParserBase::ParseString;
+  
+  return m_pTokenReader->GetUsedVar();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return a map containing the used variables only. */
+const varmap_type& ParserBase::GetVar() const
+{
+  return m_VarDef;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return a map containing all parser constants. */
+const valmap_type& ParserBase::GetConst() const
+{
+  return m_ConstDef;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return prototypes of all parser functions.
+    
+    The return type is a map of the public type #funmap_type containing the prototype
+    definitions for all numerical parser functions. String functions are not part of 
+    this map. The Prototype definition is encapsulated in objects of the class FunProt
+    one per parser function each associated with function names via a map construct.
+    \return #m_FunDef
+    \sa FunProt
+    \throw nothrow
+*/
+const funmap_type& ParserBase::GetFunDef() const
+{
+  return m_FunDef;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Retrieve the formula. */
+const string_type& ParserBase::GetExpr() const
+{
+  return m_pTokenReader->GetFormula();
+}
+
+//---------------------------------------------------------------------------
+ParserBase::token_type ParserBase::ApplyNumFunc( const token_type &a_FunTok,
+                                                 const std::vector<token_type> &a_vArg) const
+{
+  token_type  valTok;
+  int  iArgCount = (unsigned)a_vArg.size();
+  void  *pFunc = a_FunTok.GetFuncAddr();
+  assert(pFunc);
+
+  // Collect the function arguments from the value stack
+  switch(a_FunTok.GetArgCount())
+  {
+    case -1:
+          // Function with variable argument count
+ 		      // copy arguments into a vector<value_type>
+	        {
+            /** \todo remove the unnecessary argument vector by changing order in stArg. */
+            std::vector<value_type> vArg;
+		        for (int i=0; i<iArgCount; ++i)
+		          vArg.push_back(a_vArg[i].GetVal());
+
+	          valTok.SetVal( ((multfun_type)a_FunTok.GetFuncAddr())(&vArg[0], (int)vArg.size()) );  
+	        }
+	        break;
+
+    case 1: valTok.SetVal( ((fun_type1)pFunc)(a_vArg[0].GetVal()) );  break;
+    case 2: valTok.SetVal( ((fun_type2)pFunc)(a_vArg[1].GetVal(),
+		                                          a_vArg[0].GetVal()) );  break;
+    case 3: valTok.SetVal( ((fun_type3)pFunc)(a_vArg[2].GetVal(), 
+		                                          a_vArg[1].GetVal(), 
+														                  a_vArg[0].GetVal()) ); break;
+    case 4: valTok.SetVal( ((fun_type4)pFunc)(a_vArg[3].GetVal(),
+	                                            a_vArg[2].GetVal(), 
+				   	  	                              a_vArg[1].GetVal(),
+													                    a_vArg[0].GetVal()) );  break;
+    case 5: valTok.SetVal( ((fun_type5)pFunc)(a_vArg[4].GetVal(), 
+														                  a_vArg[3].GetVal(), 
+	                                            a_vArg[2].GetVal(), 
+				   	  	                              a_vArg[1].GetVal(),
+													                    a_vArg[0].GetVal()) );  break;
+    default: Error(ecINTERNAL_ERROR, 6);
+  }
+
+  // Find out if the result will depend on a variable
+  /** \todo remove this loop, put content in the loop that takes the argument values.
+    
+      (Attention: SetVal will reset Flags.)
+  */
+  bool bVolatile = a_FunTok.IsFlagSet(token_type::flVOLATILE);
+  for (int i=0; (bVolatile==false) && (i<iArgCount); ++i)
+    bVolatile |= a_vArg[i].IsFlagSet(token_type::flVOLATILE);
+
+  if (bVolatile)
+    valTok.AddFlags(token_type::flVOLATILE);
+
+#if defined(_MSC_VER)
+  #pragma warning( disable : 4311 ) 
+#endif
+
+  // Formula optimization
+  if ( m_bOptimize && 
+       !valTok.IsFlagSet(token_type::flVOLATILE) &&
+       !a_FunTok.IsFlagSet(token_type::flVOLATILE) ) 
+	{
+    m_vByteCode.RemoveValEntries(iArgCount);
+    m_vByteCode.AddVal( valTok.GetVal() );
+	}
+	else 
+	{ 
+    // operation dosnt depends on a variable or the function is flagged unoptimizeable
+    // we cant optimize here...
+    m_vByteCode.AddFun(pFunc, (a_FunTok.GetArgCount()==-1) ? -iArgCount : iArgCount);
+	}
+
+  return valTok;
+
+#if defined(_MSC_VER)
+  #pragma warning( default : 4311 )
+#endif
+}
+
+//---------------------------------------------------------------------------
+/** \brief Execute a function that takes a single string argument.
+      
+    \param a_FunTok Function token.
+    \throw exception_type If the function token is not a string function
+*/
+ParserBase::token_type ParserBase::ApplyStrFunc(const token_type &a_FunTok,
+                                                const std::vector<token_type> &a_vArg) const
+{
+  if (a_vArg.back().GetCode()!=cmSTRING)
+    Error(ecSTRING_EXPECTED, m_pTokenReader->GetPos(), a_FunTok.GetAsString());
+
+  token_type  valTok;
+  int  iArgCount = (unsigned)a_vArg.size();
+  void  *pFunc = a_FunTok.GetFuncAddr();
+  assert(pFunc);
+
+  try
+  {
+    // Collect the function arguments from the value stack
+    switch(a_FunTok.GetArgCount())
+    {
+      case 0: valTok.SetVal( ((strfun_type1)pFunc)(a_vArg[0].GetAsString().c_str()) );  break;
+      case 1: valTok.SetVal( ((strfun_type2)pFunc)(a_vArg[1].GetAsString().c_str(),
+		                                               a_vArg[0].GetVal()) );  break;
+      case 2: valTok.SetVal( ((strfun_type3)pFunc)(a_vArg[2].GetAsString().c_str(), 
+		                                               a_vArg[1].GetVal(), 
+														                       a_vArg[0].GetVal()) );  break;
+      default: Error(ecINTERNAL_ERROR);
+    }
+  }
+  catch(ParserError& /*e*/)
+  {
+    Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), a_FunTok.GetAsString());
+  }
+
+  // Find out if the result will depend on a variable
+  /** \todo remove this loop, put content in the loop that takes the argument values.
+    
+      (Attention: SetVal will reset Flags.)
+  */
+  bool bVolatile = a_FunTok.IsFlagSet(token_type::flVOLATILE);
+  for (int i=0; (bVolatile==false) && (i<iArgCount); ++i)
+    bVolatile |= a_vArg[i].IsFlagSet(token_type::flVOLATILE);
+
+  if (bVolatile)
+    valTok.AddFlags(token_type::flVOLATILE);
+
+  // string functions won't be optimized
+  m_vByteCode.AddStrFun((void*)pFunc, a_FunTok.GetArgCount(), a_vArg.back().GetIdx());
+  
+  return valTok;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Apply a function token. 
+
+    \param iArgCount Number of Arguments actually gathered used only for multiarg functions.
+    \post Function have been taken from the stack, the result has been pushed 
+    \post The function token is removed from the stack
+    \throw exception_type if Argument count does not mach function requirements.
+*/
+void ParserBase::ApplyFunc( ParserStack<token_type> &a_stOpt,
+                            ParserStack<token_type> &a_stVal, 
+                            int a_iArgCount) const
+{ 
+  assert(m_pTokenReader.get());
+
+  // Operator stack empty or does not contain tokens with callback functions
+  if (a_stOpt.empty() || a_stOpt.top().GetFuncAddr()==0 )
+    return;
+
+  token_type funTok = a_stOpt.pop();
+  assert(funTok.GetFuncAddr());
+
+  // Binary operators must rely on their internal operator number
+  // since counting of operators relies on commas for function arguments
+  // binary operators do not have commas in their expression
+  int iArgCount = ( funTok.GetCode()==cmOPRT_BIN ) ? funTok.GetArgCount() : a_iArgCount;
+
+  if (funTok.GetArgCount()>0 && iArgCount>funTok.GetArgCount()) 
+	    Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos()-1, funTok.GetAsString());
+
+	if ( funTok.GetCode()!=cmOPRT_BIN && iArgCount<funTok.GetArgCount() )
+	    Error(ecTOO_FEW_PARAMS, m_pTokenReader->GetPos()-1, funTok.GetAsString());
+
+  if ( funTok.GetCode()==cmFUNC_STR && iArgCount>funTok.GetArgCount() )
+	    Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos()-1, funTok.GetAsString());
+
+  // Collect the numeric function arguments from the value stack and store them
+  // in a vector
+  std::vector<token_type> stArg;  
+  for (int i=0; i<iArgCount; ++i)
+  {
+    stArg.push_back( a_stVal.pop() );
+    if ( stArg.back().GetType()==tpSTR && funTok.GetType()!=tpSTR )
+      Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString());
+  }
+
+  // for string functions add the string argument
+  if (funTok.GetCode()==cmFUNC_STR)
+  {
+    stArg.push_back( a_stVal.pop() );
+    if ( stArg.back().GetType()==tpSTR && funTok.GetType()!=tpSTR )
+      Error(ecVAL_EXPECTED, m_pTokenReader->GetPos(), funTok.GetAsString());
+  }
+
+  // String functions accept only one parameter
+  if (funTok.GetType()==tpSTR)
+  {
+    token_type token( ApplyStrFunc(funTok, stArg)  );
+    a_stVal.push( token );
+  }
+  else
+  {
+    token_type token( ApplyNumFunc(funTok, stArg) );
+    a_stVal.push( token );
+  }
+/*
+#ifdef __BORLANDC__
+  // Borland C++ Compiler does not support taking references on
+  // unnamed temporaries
+  if (funTok.GetType()==tpSTR)
+  {
+    ParserToken<value_type, string_type> pt( ApplyStrFunc(funTok, stArg.back()) );
+    a_stVal.push(pt);
+  }
+  else
+  {
+    ParserToken<value_type, string_type> pt( ApplyNumFunc(funTok, stArg) );
+    a_stVal.push(pt);
+  }
+#else
+  // String functions accept only one parameter
+  a_stVal.push( (funTok.GetType()==tpSTR) ? ApplyStrFunc(funTok, stArg) :
+                                            ApplyNumFunc(funTok, stArg) );
+#endif // __BORLANDC__
+*/
+}
+
+//---------------------------------------------------------------------------
+void ParserBase::ApplyBinOprt( ParserStack<token_type> &a_stOpt,
+                               ParserStack<token_type> &a_stVal) const
+{
+  assert(a_stOpt.size());
+
+  // user defined binary operator
+  if (a_stOpt.top().GetCode()==cmOPRT_BIN)
+  {
+     ApplyFunc(a_stOpt, a_stVal, 2);
+  }
+  else
+  {
+    // internal binary operator
+    MUP_ASSERT(a_stVal.size()>=2);
+
+    token_type valTok1 = a_stVal.pop(),
+               valTok2 = a_stVal.pop(),
+               optTok = a_stOpt.pop(),
+               resTok; 
+
+    if ( valTok1.GetType()!=valTok2.GetType() || 
+         (valTok1.GetType()==tpSTR && valTok2.GetType()==tpSTR) )
+      Error(ecOPRT_TYPE_CONFLICT, m_pTokenReader->GetPos(), optTok.GetAsString());
+
+    value_type x = valTok2.GetVal(),
+	             y = valTok1.GetVal();
+
+    switch (optTok.GetCode())
+    {
+      // built in binary operators
+      case cmAND: resTok.SetVal( (int)x & (int)y ); break;
+      case cmOR:  resTok.SetVal( (int)x | (int)y ); break;
+      case cmXOR: resTok.SetVal( (int)x ^ (int)y ); break;
+      case cmLT:  resTok.SetVal( x < y ); break;
+      case cmGT:  resTok.SetVal( x > y ); break;
+      case cmLE:  resTok.SetVal( x <= y ); break;
+      case cmGE:  resTok.SetVal( x >= y ); break;
+      case cmNEQ: resTok.SetVal( x != y ); break;
+      case cmEQ:  resTok.SetVal( x == y ); break;
+      case cmADD: resTok.SetVal( x + y ); break;
+      case cmSUB: resTok.SetVal( x - y ); break;
+      case cmMUL: resTok.SetVal( x * y ); break;
+      case cmDIV: resTok.SetVal( x / y ); break;
+  	  case cmPOW: resTok.SetVal(pow(x, y)); break;
+
+      case cmASSIGN: 
+                // The assignement operator needs special treatment
+                // it uses a different format when stored in the bytecode!
+                {
+                  if (valTok2.GetCode()!=cmVAR)
+                    Error(ecINTERNAL_ERROR, 7);
+                    
+                  value_type *pVar = valTok2.GetVar();
+                  resTok.SetVal( *pVar = y );
+                  a_stVal.push( resTok );
+
+                  m_vByteCode.AddAssignOp(pVar);
+                  return;  // we must return since the following 
+                           // stuff does not apply
+                }
+
+      default:  Error(ecINTERNAL_ERROR, 8);
+    }
+
+    // Create the bytecode entries
+    if (!m_bOptimize)
+    {
+      // Optimization flag is not set
+      m_vByteCode.AddOp(optTok.GetCode());
+    }
+    else if ( valTok1.IsFlagSet(token_type::flVOLATILE) || 
+              valTok2.IsFlagSet(token_type::flVOLATILE) )
+    {
+      // Optimization flag is not set, but one of the value
+      // depends on a variable
+      m_vByteCode.AddOp(optTok.GetCode());
+      resTok.AddFlags(token_type::flVOLATILE);
+    }
+    else
+    {
+      // operator call can be optimized; If optimization is possible 
+      // the two previous tokens must be value tokens / they will be removed
+      // and replaced with the result of the pending operation.
+      m_vByteCode.RemoveValEntries(2);
+      m_vByteCode.AddVal(resTok.GetVal());
+    }
+
+    a_stVal.push( resTok );
+  }
+}
+
+//---------------------------------------------------------------------------
+/** \brief Parse the command code.
+
+  Command code contains precalculated stack positions of the values and the
+  associated operators.  
+  The Stack is filled beginning from index one the value at index zero is
+  not used at all.
+
+  \sa ParseString(), ParseValue()
+*/
+value_type ParserBase::ParseCmdCode() const
+{
+#if defined(_MSC_VER)
+  #pragma warning( disable : 4312 )
+#endif
+
+  value_type Stack[99];
+  ECmdCode iCode;
+  bytecode_type idx(0);
+  int i(0);
+
+  __start:
+
+  idx = m_pCmdCode[i];
+  iCode = (ECmdCode)m_pCmdCode[i+1];
+  i += 2;
+
+#ifdef _DEBUG
+  if (idx>=99)
+    throw exception_type(ecGENERIC, _T(""), m_pTokenReader->GetFormula(), -1);
+#endif
+
+  switch (iCode)
+  {
+    // built in binary operators
+    case cmAND: Stack[idx]  = (int)Stack[idx] & (int)Stack[idx+1]; goto __start;
+    case cmOR:  Stack[idx]  = (int)Stack[idx] | (int)Stack[idx+1]; goto __start;
+    case cmXOR: Stack[idx]  = (int)Stack[idx] ^ (int)Stack[idx+1]; goto __start;
+    case cmLE:  Stack[idx]  = Stack[idx] <= Stack[idx+1]; goto __start;
+    case cmGE:  Stack[idx]  = Stack[idx] >= Stack[idx+1]; goto __start;
+    case cmNEQ: Stack[idx]  = Stack[idx] != Stack[idx+1]; goto __start;
+    case cmEQ:  Stack[idx]  = Stack[idx] == Stack[idx+1]; goto __start;
+	  case cmLT:  Stack[idx]  = Stack[idx] < Stack[idx+1];  goto __start;
+	  case cmGT:  Stack[idx]  = Stack[idx] > Stack[idx+1];  goto __start;
+    case cmADD: Stack[idx] += Stack[1+idx]; goto __start;
+ 	  case cmSUB: Stack[idx] -= Stack[1+idx]; goto __start;
+	  case cmMUL: Stack[idx] *= Stack[1+idx]; goto __start;
+	  case cmDIV: Stack[idx] /= Stack[1+idx]; goto __start;
+    case cmPOW: Stack[idx]  = pow(Stack[idx], Stack[1+idx]); goto __start;
+
+    // Assignement needs special treatment
+    case cmASSIGN:
+           {
+             // next is a pointer to the target
+             value_type **pDest = (value_type**)(&m_pCmdCode[i]);
+
+             // advance index according to pointer size
+             i += m_vByteCode.GetPtrSize();
+             // assign the value
+             Stack[idx] = **pDest = Stack[idx+1];
+           }
+           goto __start;
+
+    // user defined binary operators
+    case cmOPRT_BIN:
+           Stack[idx] = (**(fun_type2**)(&m_pCmdCode[i]))(Stack[idx], Stack[idx+1]);
+           ++i;
+           goto __start;
+
+    // variable tokens
+	  case cmVAR:
+		        Stack[idx] = **(value_type**)(&m_pCmdCode[i]);
+		        i += m_vByteCode.GetValSize();
+		        goto __start;
+
+    // value tokens
+	  case cmVAL:
+            Stack[idx] = *(value_type*)(&m_pCmdCode[i]);
+ 	          i += m_vByteCode.GetValSize();
+            goto __start;
+
+    // Next is treatment of string functions
+    case cmFUNC_STR:
+            {
+		          // The function argument count
+              int iArgCount = (int)m_pCmdCode[ i++ ];  
+
+              // The index of the string argument in the string table
+              int iIdxStack = (int)m_pCmdCode[ i++ ];  
+              MUP_ASSERT( iIdxStack>=0 && iIdxStack<(int)m_vStringBuf.size() );
+
+              switch(iArgCount)  // switch according to argument count
+		          {
+                case 0: Stack[idx] = (*(strfun_type1*)(&m_pCmdCode[i]))(m_vStringBuf[iIdxStack].c_str()); break;
+			          case 1: Stack[idx] = (*(strfun_type2*)(&m_pCmdCode[i]))(m_vStringBuf[iIdxStack].c_str(), Stack[idx]); break;
+			          case 2: Stack[idx] = (*(strfun_type3*)(&m_pCmdCode[i]))(m_vStringBuf[iIdxStack].c_str(), Stack[idx], Stack[idx+1]); break;
+              }
+		          i += m_vByteCode.GetPtrSize();
+            }
+            goto __start;
+
+    // Next is treatment of numeric functions
+    case cmFUNC:
+		        {
+		          int iArgCount = (int)m_pCmdCode[i++];
+
+              switch(iArgCount)  // switch according to argument count
+		          {
+                case 1: Stack[idx] = (*(fun_type1*)(&m_pCmdCode[i]))(Stack[idx]); break;
+			          case 2: Stack[idx] = (*(fun_type2*)(&m_pCmdCode[i]))(Stack[idx], Stack[idx+1]); break;
+			          case 3: Stack[idx] = (*(fun_type3*)(&m_pCmdCode[i]))(Stack[idx], Stack[idx+1], Stack[idx+2]); break;
+			          case 4: Stack[idx] = (*(fun_type4*)(&m_pCmdCode[i]))(Stack[idx], Stack[idx+1], Stack[idx+2], Stack[idx+3]); break;
+  		          case 5: Stack[idx] = (*(fun_type5*)(&m_pCmdCode[i]))(Stack[idx], Stack[idx+1], Stack[idx+2], Stack[idx+3], Stack[idx+4]); break;
+                default:
+				          if (iArgCount>0) // function with variable arguments store the number as a negative value
+                    Error(ecINTERNAL_ERROR, 1);
+
+                  Stack[idx] =(*(multfun_type*)(&m_pCmdCode[i]))(&Stack[idx], -iArgCount);
+                  break;
+		          }
+		          i += m_vByteCode.GetPtrSize();
+		        }
+		        goto __start;
+
+	  case cmEND:
+		        return Stack[1];
+
+	  default:
+            Error(ecINTERNAL_ERROR, 2);
+            return 0;
+  }
+
+#if defined(_MSC_VER)
+  #pragma warning( default : 4312 )
+#endif
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return result for constant functions.
+
+  Seems pointless, but for parser functions that are made up of only a value, which occur
+  in real world applications, this speeds up things by removing the parser overhead almost
+  completely.
+*/
+value_type ParserBase::ParseValue() const
+{
+  return *(value_type*)(&m_pCmdCode[2]);
+}
+
+//---------------------------------------------------------------------------
+/** \brief One of the two main parse functions.
+
+ Parse expression from input string. Perform syntax checking and create bytecode.
+ After parsing the string and creating the bytecode the function pointer 
+ #m_pParseFormula will be changed to the second parse routine the uses bytecode instead of string parsing.
+
+ \sa ParseCmdCode(), ParseValue()
+*/
+value_type ParserBase::ParseString() const
+{
+#if defined(_MSC_VER)
+  #pragma warning( disable : 4311 )
+#endif
+  if (!m_pTokenReader->GetFormula().length())
+      Error(ecUNEXPECTED_EOF, 0);
+
+  ParserStack<token_type> stOpt, stVal;
+  ParserStack<int> stArgCount;
+  token_type opta, opt;  // for storing operators
+  token_type val, tval;  // for storing value
+  string_type strBuf;    // buffer for string function arguments
+
+  ReInit();
+
+  for(;;)
+  {
+    opt = m_pTokenReader->ReadNextToken();
+
+    switch (opt.GetCode())
+    {
+      //
+      // Next three are different kind of value entries
+      //
+      case cmSTRING:
+              opt.SetIdx((int)m_vStringBuf.size()); // Assign buffer index to token 
+              stVal.push(opt);
+		          m_vStringBuf.push_back(opt.GetAsString()); // Store string in internal buffer
+              break;
+ 
+      case cmVAR:
+   		        stVal.push(opt);
+              m_vByteCode.AddVar( static_cast<value_type*>(opt.GetVar()) );
+              break;
+
+      case cmVAL:
+		          stVal.push(opt);
+              m_vByteCode.AddVal( opt.GetVal() );
+              break;
+
+      case cmCOMMA:
+              if (stArgCount.empty())
+                Error(ecUNEXPECTED_COMMA, m_pTokenReader->GetPos());
+              ++stArgCount.top(); // Record number of arguments
+              // fall through...
+      case cmEND:
+      case cmBC:
+              {
+                while ( stOpt.size() && stOpt.top().GetCode() != cmBO)
+                {
+                  if (stOpt.top().GetCode()==cmOPRT_INFIX)
+                    ApplyFunc(stOpt, stVal, 1);  // infix operator
+                  else
+                    ApplyBinOprt(stOpt, stVal);
+                }
+
+                // <ibg> 20060218 infix operator treatment moved here
+                if (stOpt.size() && stOpt.top().GetCode()==cmOPRT_INFIX) 
+                  ApplyFunc(stOpt, stVal, 1);  // infix operator
+
+                if ( opt.GetCode()!=cmBC || stOpt.size()==0 || stOpt.top().GetCode()!=cmBO )
+                  break;
+
+                // if opt is ")" and opta is "(" the bracket has been evaluated, now its time to check
+			          // if there is either a function or a sign pending
+		   	        // neither the opening nor the closing bracket will be pushed back to
+			          // the operator stack
+			          // Check if a function is standing in front of the opening bracket, 
+                // if yes evaluate it afterwards check for infix operators
+			          assert(stArgCount.size());
+			          int iArgCount = stArgCount.pop();
+                
+                stOpt.pop(); // Take opening bracket from stack
+
+                if (iArgCount>1 && ( stOpt.size()==0 || 
+                                     (stOpt.top().GetCode()!=cmFUNC && 
+                                     stOpt.top().GetCode()!=cmFUNC_STR) ) )
+                  Error(ecUNEXPECTED_ARG, m_pTokenReader->GetPos());
+                
+                if (stOpt.size() && stOpt.top().GetCode()!=cmOPRT_INFIX)
+                  ApplyFunc(stOpt, stVal, iArgCount);
+			        } // if bracket content is evaluated
+              break;
+
+      //
+      // Next are the binary operator entries
+      //
+      case cmAND:   // built in binary operators
+      case cmOR:
+      case cmXOR:
+      case cmLT:
+      case cmGT:
+      case cmLE:
+      case cmGE:
+      case cmNEQ:
+      case cmEQ:
+      case cmADD:
+      case cmSUB:
+      case cmMUL:
+      case cmDIV:
+      case cmPOW:
+      case cmASSIGN:
+      case cmOPRT_BIN:
+              // A binary operator (user defined or built in) has been found. 
+              while ( stOpt.size() && stOpt.top().GetCode() != cmBO)
+              {
+                if (GetOprtPri(stOpt.top()) < GetOprtPri(opt))
+                  break;
+
+                if (stOpt.top().GetCode()==cmOPRT_INFIX)
+                  ApplyFunc(stOpt, stVal, 1);  // infix operator
+                else
+                  ApplyBinOprt(stOpt, stVal);
+              } // while ( ... )
+
+    			    // The operator can't be evaluated right now, push back to the operator stack
+              stOpt.push(opt);
+              break;
+
+      //
+      // Last section contains functions and operators implicitely mapped to functions
+      //
+	    case cmBO:
+              stArgCount.push( (stOpt.size() && stOpt.top().GetCode()==cmFUNC_STR) ? 0 : 1 );
+              stOpt.push(opt);
+		    	    break;
+
+      case cmFUNC_STR:  
+      case cmFUNC:
+      case cmOPRT_INFIX:
+              stOpt.push(opt);
+		    	    break;
+
+      case cmOPRT_POSTFIX:
+              stOpt.push(opt);
+              ApplyFunc(stOpt, stVal, 1);  // this is the postfix operator
+              break;
+
+	    default:  Error(ecINTERNAL_ERROR, 3);
+    } // end of switch operator-token
+
+    if ( opt.GetCode() == cmEND )
+    {
+      m_vByteCode.Finalize();
+      break;
+    }
+
+#if defined(MUP_DUMP_STACK)
+    StackDump(stVal, stOpt);
+    m_vByteCode.AsciiDump();
+#endif
+  } // while (true)
+
+  // Store pointer to start of bytecode
+  m_pCmdCode = m_vByteCode.GetRawData();
+
+#if defined(MUP_DUMP_CMDCODE)
+  m_vByteCode.AsciiDump();
+#endif
+
+  // get the last value (= final result) from the stack
+  if (stVal.size()!=1)
+    Error(ecEMPTY_EXPRESSION);
+
+  if (stVal.top().GetType()!=tpDBL)
+    Error(ecSTR_RESULT);
+
+  // no error, so change the function pointer for the main parse routine
+  value_type fVal = stVal.top().GetVal();   // Result from String parsing
+
+  if (m_bUseByteCode)
+  {
+    m_pParseFormula = (m_pCmdCode[1]==cmVAL && m_pCmdCode[6]==cmEND) ? 
+                            &ParserBase::ParseValue :
+                            &ParserBase::ParseCmdCode;
+  }
+
+  return fVal;
+
+#if defined(_MSC_VER)
+  #pragma warning( default : 4311 )
+#endif
+}
+
+
+//---------------------------------------------------------------------------
+/** \brief Create an error containing the parse error position.
+
+  This function will create an Parser Exception object containing the error text and
+  its position.
+
+  \param a_iErrc [in] The error code of type #EErrorCodes.
+  \param a_iPos [in] The position where the error was detected.
+  \param a_strTok [in] The token string representation associated with the error.
+  \throw ParserException always throws thats the only purpose of this function.
+*/
+void  ParserBase::Error(EErrorCodes a_iErrc, int a_iPos, const string_type &a_sTok) const
+{
+  throw exception_type(a_iErrc, a_sTok, m_pTokenReader->GetFormula(), a_iPos);
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear all user defined variables.
+
+    Resets the parser to string parsing mode by calling #ReInit.
+    \throw nothrow
+*/
+void ParserBase::ClearVar()
+{
+  m_VarDef.clear();
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Remove a variable from internal storage.
+
+Removes a variable if it exists. If the Variable does not exist nothing will be done.
+
+\throw nothrow
+*/
+void ParserBase::RemoveVar(const string_type &a_strVarName)
+{
+  varmap_type::iterator item = m_VarDef.find(a_strVarName);
+  if (item!=m_VarDef.end())
+  {
+    m_VarDef.erase(item);
+    ReInit();
+  }
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear the formula. 
+
+Clear the formula and existing bytecode.
+
+\post Resets the parser to string parsing mode.
+\throw nothrow
+*/
+void ParserBase::ClearFormula()
+{
+  m_vByteCode.clear();
+  m_pCmdCode = 0;
+  m_pTokenReader->SetFormula(_T(""));
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear all functions.
+    \post Resets the parser to string parsing mode.
+    \throw nothrow
+*/
+void ParserBase::ClearFun()
+{
+  m_FunDef.clear();
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear all user defined constants.
+
+    Both numeric and string constants will be removed from the internal storage.
+    \post Resets the parser to string parsing mode.
+    \throw nothrow
+*/
+void ParserBase::ClearConst()
+{
+  m_ConstDef.clear();
+  m_StrVarDef.clear();
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear all user defined postfix operators.
+    \post Resets the parser to string parsing mode.
+    \throw nothrow
+*/
+void ParserBase::ClearPostfixOprt()
+{
+  m_PostOprtDef.clear();
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear all user defined binary operators.
+    \post Resets the parser to string parsing mode.
+    \throw nothrow
+*/
+void ParserBase::ClearOprt()
+{
+  m_OprtDef.clear();
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Clear the user defined Prefix operators. 
+    \post Resets the parser to string parser mode.
+    \throw nothrow
+*/
+void ParserBase::ClearInfixOprt()
+{
+  m_InfixOprtDef.clear();
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Enable or disable the formula optimization feature. 
+    \post Resets the parser to string parser mode.
+    \throw nothrow
+*/
+void ParserBase::EnableOptimizer(bool a_bIsOn)
+{
+  m_bOptimize = a_bIsOn;
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Enable or disable parsing from Bytecode. 
+
+    \attention There is no reason to disable bytecode. It will 
+               drastically decrease parsing speed.
+*/
+void ParserBase::EnableByteCode(bool a_bIsOn)
+{
+  m_bUseByteCode = a_bIsOn;
+  if (!a_bIsOn)
+    ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Enable or disable the built in binary operators.
+    \throw nothrow
+    \sa m_bBuiltInOp, ReInit()
+
+   If you disable the built in binary operators there will be no binary operators
+   defined. Thus you must add them manually one by one. It is not possible to
+   disable built in operators selectively. This function will Reinitialize the
+   parser by calling ReInit().
+*/
+void ParserBase::EnableBuiltInOprt(bool a_bIsOn)
+{
+  m_bBuiltInOp = a_bIsOn;
+  ReInit();
+}
+
+//------------------------------------------------------------------------------
+/** \brief Query status of built in variables.
+    \return #m_bBuiltInOp; true if built in operators are enabled.
+    \throw nothrow
+*/
+bool ParserBase::HasBuiltInOprt() const
+{
+  return m_bBuiltInOp;
+}
+
+#if defined(MUP_DUMP_STACK) | defined(MUP_DUMP_CMDCODE)
+
+//------------------------------------------------------------------------------
+/** \brief Dump stack content. 
+
+    This function is used for debugging only.
+*/
+void ParserBase::StackDump( const ParserStack<token_type> &a_stVal, 
+				             			  const ParserStack<token_type> &a_stOprt ) const
+{
+  ParserStack<token_type> stOprt(a_stOprt), 
+                          stVal(a_stVal);
+
+  mu::console() << _T("\nValue stack:\n");
+  while ( !stVal.empty() ) 
+  {
+    token_type val = stVal.pop();
+    if (val.GetType()==tpSTR)
+      mu::console() << _T(" \"") << val.GetAsString() << _T("\" ");
+    else
+      mu::console() << _T(" ") << val.GetVal() << _T(" ");
+  }
+  mu::console() << "\nOperator stack:\n";
+
+  while ( !stOprt.empty() )
+  {
+     if (stOprt.top().GetCode()<=cmASSIGN) 
+  	 {
+	  	 mu::console() << _T("OPRT_INTRNL \"")
+                     << ParserBase::c_DefaultOprt[stOprt.top().GetCode()] 
+                     << _T("\" \n");
+	   }
+     else
+     {
+		    switch(stOprt.top().GetCode())
+		    {
+        case cmVAR:   mu::console() << _T("VAR\n");  break;
+		    case cmVAL:   mu::console() << _T("VAL\n");  break;
+		    case cmFUNC:  mu::console() << _T("FUNC_NUM \"") 
+                                    << stOprt.top().GetAsString() 
+                                    << _T("\"\n");   break;
+		    case cmOPRT_INFIX: mu::console() << _T("OPRT_INFIX \"")
+                                         << stOprt.top().GetAsString() 
+                                         << _T("\"\n");   break;
+        case cmOPRT_BIN:   mu::console() << _T("OPRT_BIN \"") 
+                                         << stOprt.top().GetAsString() 
+                                         << _T("\"\n");        break;
+        case cmFUNC_STR: mu::console() << _T("FUNC_STR\n");  break;
+		    case cmEND:      mu::console() << _T("END\n");       break;
+		    case cmUNKNOWN:  mu::console() << _T("UNKNOWN\n");   break;
+		    case cmBO:       mu::console() << _T("BRACKET \"(\"\n");  break;
+		    case cmBC:       mu::console() << _T("BRACKET \")\"\n");  break;
+        default:         mu::console() << stOprt.top().GetType() << _T(" ");  break;
+		    }
+     }	
+     stOprt.pop();
+  }
+
+  mu::console() << dec << endl;
+}
+
+#endif // defined(MUP_DUMP_STACK) | defined(MUP_DUMP_CMDCODE)
+
+} // namespace mu
+
+
diff --git a/muparser/muParserBase.h b/muparser/muParserBase.h
new file mode 100644
index 0000000..c4cc433
--- /dev/null
+++ b/muparser/muParserBase.h
@@ -0,0 +1,324 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+#ifndef MU_PARSER_BASE_H
+#define MU_PARSER_BASE_H
+
+#include <cmath>
+#include <string>
+#include <iostream>
+#include <map>
+#include <memory>
+
+#include "muParserDef.h"
+#include "muParserStack.h"
+#include "muParserTokenReader.h"
+#include "muParserBytecode.h"
+#include "muParserError.h"
+
+
+namespace mu
+{
+
+/** \brief Mathematical expressions parser (base parser engine).
+  
+  Version 1.27 (20061201)
+
+  This is the implementation of a bytecode based mathematical expressions parser. 
+  The formula will be parsed from string and converted into a bytecode. 
+  Future calculations will be done with the bytecode instead the formula string
+  resulting in a significant performance increase. 
+  Complementary to a set of internally implemented functions the parser is able to handle 
+  user defined functions and variables. 
+
+  \author (C) 2004-2006 Ingo Berg
+*/
+class ParserBase 
+{
+friend class ParserTokenReader;
+
+private:
+    typedef value_type (ParserBase::*ParseFunction)() const;  
+    typedef ParserToken<value_type, string_type> token_type;
+    typedef std::vector<string_type> stringbuf_type;
+    typedef ParserTokenReader token_reader_type;
+
+    static const char_type *c_DefaultOprt[]; 
+
+ public:
+    /** \brief Type of the error class. 
+    
+      Included for backwards compatibility.
+    */
+    typedef ParserError exception_type;
+
+    ParserBase(); 
+    ParserBase( const ParserBase &a_Parser );
+    ParserBase& operator=(const ParserBase &a_Parser);
+
+    //---------------------------------------------------------------------------
+    /** \brief Destructor. (trivial) 
+
+        \throw nothrow
+    */
+    virtual ~ParserBase()
+    {}
+    
+    //---------------------------------------------------------------------------
+    /** \brief Calculate the result.
+
+      A note on const correctness: 
+      I consider it important that Calc is a const function.
+      Due to caching operations Calc changes only the state of internal variables with one exception
+      m_UsedVar this is reset during string parsing and accessible from the outside. Instead of making
+      Calc non const GetUsedVar is non const because it explicitely calls Eval() forcing this update. 
+
+      \pre A formula must be set.
+      \pre Variables must have been set (if needed)
+  
+      \sa #m_pParseFormula
+      \return The evaluation result
+      \throw ParseException if no Formula is set or in case of any other error related to the formula.
+    */
+  	inline value_type Eval() const
+    {
+      return (this->*m_pParseFormula)(); 
+    }
+
+    void SetExpr(const string_type &a_sExpr);
+    void SetVarFactory(facfun_type a_pFactory, void *pUserData = NULL);
+
+    void EnableOptimizer(bool a_bIsOn=true);
+    void EnableByteCode(bool a_bIsOn=true);
+    void EnableBuiltInOprt(bool a_bIsOn=true);
+
+    bool HasBuiltInOprt() const;
+    void AddValIdent(identfun_type a_pCallback);
+
+#define MUP_DEFINE_FUNC(TYPE)                                                           \
+    inline void DefineFun(const string_type &a_strName, TYPE a_pFun, bool a_bAllowOpt = true)  \
+    {                                                                                   \
+      AddCallback( a_strName, ParserCallback(a_pFun, a_bAllowOpt),                      \
+                   m_FunDef, ValidNameChars() );                                        \
+    }
+
+    MUP_DEFINE_FUNC(fun_type1)
+    MUP_DEFINE_FUNC(fun_type2)
+    MUP_DEFINE_FUNC(fun_type3)
+    MUP_DEFINE_FUNC(fun_type4)
+    MUP_DEFINE_FUNC(fun_type5)
+    MUP_DEFINE_FUNC(multfun_type)
+    MUP_DEFINE_FUNC(strfun_type1)
+    MUP_DEFINE_FUNC(strfun_type2)
+    MUP_DEFINE_FUNC(strfun_type3)
+#undef MUP_DEFINE_FUNC
+
+    void DefineOprt(const string_type &a_strName, fun_type2 a_pFun, unsigned a_iPri=0, bool a_bAllowOpt = false);
+    void DefineConst(const string_type &a_sName, value_type a_fVal);
+    void DefineStrConst(const string_type &a_sName, const string_type &a_strVal);
+    void DefineVar(const string_type &a_sName, value_type *a_fVar);
+    void DefinePostfixOprt(const string_type &a_strFun, fun_type1 a_pOprt, bool a_bAllowOpt=true);
+    void DefineInfixOprt(const string_type &a_strName, fun_type1 a_pOprt, int a_iPrec=prINFIX, bool a_bAllowOpt=true);
+
+    // Clear user defined variables, constants or functions
+    void ClearVar();
+    void ClearFun();
+    void ClearConst();
+    void ClearInfixOprt();
+    void ClearPostfixOprt();
+    void ClearOprt();
+    
+    void RemoveVar(const string_type &a_strVarName);
+    const varmap_type& GetUsedVar() const;
+    const varmap_type& GetVar() const;
+    const valmap_type& GetConst() const;
+    const string_type& GetExpr() const;
+    const funmap_type& GetFunDef() const;
+
+    //---------------------------------------------------------------------------
+    /** \brief Return the strings of all Operator identifiers. 
+    
+        GetOprt is a const function returning a pinter to an array of const char pointers.
+        
+        \return Returns a pointer to the c_DefaultOprt array of const char *.
+        \throw nothrow
+    */
+    const char_type ** GetOprtDef() const
+    {
+      return (const char_type **)(&c_DefaultOprt[0]);
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Define the set of valid characters to be used in names of
+               functions, variables, constants.
+    */
+    void DefineNameChars(const char_type *a_szCharset)
+    {
+      m_sNameChars = a_szCharset;
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Define the set of valid characters to be used in names of
+               binary operators and postfix operators.
+    */
+    void DefineOprtChars(const char_type *a_szCharset)
+    {
+      m_sOprtChars = a_szCharset;
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Define the set of valid characters to be used in names of
+               infix operators.
+    */
+    void DefineInfixOprtChars(const char_type *a_szCharset)
+    {
+      m_sInfixOprtChars = a_szCharset;
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Virtual function that defines the characters allowed in name identifiers. 
+        \sa #ValidOprtChars, #ValidPrefixOprtChars
+    */ 
+    const char_type* ValidNameChars() const
+    {
+      assert(m_sNameChars.size());
+      return m_sNameChars.c_str();
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Virtual function that defines the characters allowed in operator definitions. 
+        \sa #ValidNameChars, #ValidPrefixOprtChars
+    */
+    const char_type* ValidOprtChars() const
+    {
+      assert(m_sOprtChars.size());
+      return m_sOprtChars.c_str();
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Virtual function that defines the characters allowed in infix operator definitions.
+        \sa #ValidNameChars, #ValidOprtChars
+    */
+    const char_type* ValidInfixOprtChars() const
+    {
+      assert(m_sInfixOprtChars.size());
+      return m_sInfixOprtChars.c_str();
+    }
+
+    void  Error( EErrorCodes a_iErrc, 
+                 int a_iPos = (int)mu::string_type::npos, 
+                 const string_type &a_strTok = string_type() ) const;
+
+ protected:
+	  
+    //---------------------------------------------------------------------------
+    /** \brief Initialize user defined functions. 
+     
+      Calls the virtual functions InitFun(), InitConst() and InitOprt().
+    */
+    void Init()
+    {
+      InitCharSets();
+      InitFun();
+      InitConst();
+      InitOprt();
+    }
+
+    //---------------------------------------------------------------------------
+    virtual void InitCharSets() = 0;
+    virtual void InitFun() = 0;
+    virtual void InitConst() = 0;
+    virtual void InitOprt() = 0; 
+
+ private:
+    void Assign(const ParserBase &a_Parser);
+    void InitTokenReader();
+    void ReInit() const;
+
+    void AddCallback( const string_type &a_strName, 
+                      const ParserCallback &a_Callback, 
+                      funmap_type &a_Storage,
+                      const char_type *a_szCharSet );
+
+    void ApplyBinOprt(ParserStack<token_type> &a_stOpt,
+                      ParserStack<token_type> &a_stVal) const;
+
+    void ApplyFunc(ParserStack<token_type> &a_stOpt,
+                   ParserStack<token_type> &a_stVal, 
+                   int iArgCount) const; 
+
+    token_type ApplyNumFunc(const token_type &a_FunTok,
+                            const std::vector<token_type> &a_vArg) const;
+
+    token_type ApplyStrFunc(const token_type &a_FunTok,
+                            const std::vector<token_type> &a_vArg) const;
+
+    int GetOprtPri(const token_type &a_Tok) const;
+
+    value_type ParseString() const; 
+    value_type ParseCmdCode() const;
+    value_type ParseValue() const;
+
+    void  ClearFormula();
+    void  CheckName(const string_type &a_strName, const string_type &a_CharSet) const;
+
+#if defined(MUP_DUMP_STACK) | defined(MUP_DUMP_CMDCODE)
+    void StackDump(const ParserStack<token_type > &a_stVal, 
+                   const ParserStack<token_type > &a_stOprt) const;
+#endif
+
+    /** \brief Pointer to the parser function. 
+    
+      Eval() calls the function whose address is stored there.
+    */
+    mutable ParseFunction  m_pParseFormula;
+    mutable const ParserByteCode::map_type *m_pCmdCode; ///< Formula converted to bytecode, points to the data of the bytecode class.
+    mutable ParserByteCode m_vByteCode;   ///< The Bytecode class.
+    mutable stringbuf_type  m_vStringBuf; ///< String buffer, used for storing string function arguments
+    stringbuf_type  m_vStringVarBuf;
+
+    /** \brief Managed pointer to the token reader object. */
+    std::auto_ptr<token_reader_type> m_pTokenReader; 
+
+    funmap_type  m_FunDef;        ///< Map of function names and pointers.
+    funmap_type  m_PostOprtDef;   ///< Postfix operator callbacks
+    funmap_type  m_InfixOprtDef;  ///< unary infix operator.
+    funmap_type  m_OprtDef;       ///< Binary operator callbacks
+    valmap_type  m_ConstDef;      ///< user constants.
+    strmap_type  m_StrVarDef;     ///< user defined string constants
+    varmap_type  m_VarDef;        ///< user defind variables.
+
+    bool m_bOptimize;             ///< Flag that indicates if the optimizer is on or off.
+    bool m_bUseByteCode;          ///< Flag that indicates if bytecode parsing is on or off.
+    bool m_bBuiltInOp;            ///< Flag that can be used for switching built in operators on and off
+
+    string_type m_sNameChars;      ///< Charset for names
+    string_type m_sOprtChars;      ///< Charset for postfix/ binary operator tokens
+    string_type m_sInfixOprtChars; ///< Charset for infix operator tokens
+};
+
+} // namespace mu
+
+#endif
+
diff --git a/muparser/muParserBytecode.cpp b/muparser/muParserBytecode.cpp
new file mode 100644
index 0000000..7c8db24
--- /dev/null
+++ b/muparser/muParserBytecode.cpp
@@ -0,0 +1,396 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#include "muParserBytecode.h"
+
+#include <cassert>
+#include <string>
+#include <stack>
+#include <vector>
+#include <iostream>
+
+#include "muParserDef.h"
+#include "muParserError.h"
+#include "muParserToken.h"
+
+
+namespace mu
+{
+
+  //---------------------------------------------------------------------------
+  /** \brief Bytecode default constructor. 
+     
+      \pre [assert] sizeof(value_type)>=sizeof(map_type)
+      \pre [assert] sizeof(value_type*)>=sizeof(map_type)
+  */
+  ParserByteCode::ParserByteCode()
+    :m_iStackPos(0)
+    ,m_vBase()
+    ,mc_iSizeVal( sizeof(value_type) / sizeof(map_type) )
+    ,mc_iSizePtr( std::max( (int)sizeof(value_type*) / 
+                            (int)sizeof(map_type), 1 ) )
+    ,mc_iSizeValEntry( 2 + mc_iSizeVal)
+  {
+    m_vBase.reserve(1000);
+    assert( sizeof(value_type)>=sizeof(map_type) );
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Destructor (trivial).*/
+  ParserByteCode::~ParserByteCode()
+  {}
+
+  //---------------------------------------------------------------------------
+  /** \brief Copy constructor. 
+    
+      Implemented in Terms of Assign(const ParserByteCode &a_ByteCode)
+  */
+  ParserByteCode::ParserByteCode(const ParserByteCode &a_ByteCode)
+    :mc_iSizeVal( sizeof(value_type)/sizeof(map_type) )
+    ,mc_iSizePtr( sizeof(value_type*) / sizeof(map_type) )
+    ,mc_iSizeValEntry( 2 + mc_iSizeVal)
+  {
+    Assign(a_ByteCode);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Assignment operator.
+    
+      Implemented in Terms of Assign(const ParserByteCode &a_ByteCode)
+  */
+  ParserByteCode& ParserByteCode::operator=(const ParserByteCode &a_ByteCode)
+  {
+    Assign(a_ByteCode);
+    return *this;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Store an address in bytecode.
+  
+      \param a_pAddr Address to be stored.
+      \throw nothrow
+  */
+  void ParserByteCode::StorePtr(void *a_pAddr)
+  {
+    #if defined(_MSC_VER)
+      #pragma warning( disable : 4311 )
+    #endif
+
+    // demo code for packing / unpacking pointers into bytecode
+//    void *ptr(NULL);
+//    double **pVal;
+//    double fVal;
+//    map_type dbg[2]; 
+//    dbg[0] = *( reinterpret_cast<map_type*>(&a_pAddr) ), 
+//    dbg[1] = *( reinterpret_cast<map_type*>(&a_pAddr) + 1 );     
+// Version 1:
+//    *( (map_type*)&ptr+0) = dbg[0];
+//    *( (map_type*)&ptr+1) = dbg[1];
+// Version 2:
+//    memcpy(&ptr, dbg, sizeof(dbg));
+// Version 3:    
+//    pVal = (double**)dbg;
+//    fVal = **(double**)dbg;
+
+    for (int i=0; i<mc_iSizePtr; ++i)
+    {
+        m_vBase.push_back( *( reinterpret_cast<map_type*>(&a_pAddr) + i ) );
+    }
+
+    #if defined(_MSC_VER)
+      #pragma warning( default : 4311 )
+    #endif
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Copy state of another object to this. 
+    
+      \throw nowthrow
+  */
+  void ParserByteCode::Assign(const ParserByteCode &a_ByteCode)
+  {
+    if (this==&a_ByteCode)    
+      return;
+
+    m_iStackPos = a_ByteCode.m_iStackPos;
+    m_vBase = a_ByteCode.m_vBase;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add a Variable pointer to bytecode. 
+      \param a_pVar Pointer to be added.
+      \throw nothrow
+  */
+  void ParserByteCode::AddVar(value_type *a_pVar)
+  {
+    m_vBase.push_back( ++m_iStackPos );
+    m_vBase.push_back( cmVAR );
+
+    StorePtr(a_pVar);
+
+    int iSize = GetValSize()-GetPtrSize();
+    assert(iSize>=0);
+
+    // Make sure variable entries have the same size like value entries.
+    // (necessary for optimization; fill with zeros)
+    for (int i=0; i<iSize; ++i)
+      m_vBase.push_back(0);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add a Variable pointer to bytecode. 
+
+      Value entries in byte code consist of:
+      <ul>
+        <li>value array position of the value</li>
+        <li>the operator code according to ParserToken::cmVAL</li>
+        <li>the value stored in #mc_iSizeVal number of bytecode entries.</li>
+      </ul>
+
+      \param a_pVal Value to be added.
+      \throw nothrow
+  */
+  void ParserByteCode::AddVal(value_type a_fVal)
+  {
+    m_vBase.push_back( ++m_iStackPos );
+    m_vBase.push_back( cmVAL );
+
+    for (int i=0; i<mc_iSizeVal; ++i)
+      m_vBase.push_back( *(reinterpret_cast<map_type*>(&a_fVal) + i) );
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add an operator identifier to bytecode. 
+    
+      Operator entries in byte code consist of:
+      <ul>
+        <li>value array position of the result</li>
+        <li>the operator code according to ParserToken::ECmdCode</li>
+      </ul>
+
+      \sa  ParserToken::ECmdCode
+  */
+  void ParserByteCode::AddOp(ECmdCode a_Oprt)
+  {
+    m_vBase.push_back(--m_iStackPos);
+    m_vBase.push_back(a_Oprt);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add an assignement operator
+    
+      Operator entries in byte code consist of:
+      <ul>
+        <li>cmASSIGN code</li>
+        <li>the pointer of the destination variable</li>
+      </ul>
+
+      \sa  ParserToken::ECmdCode
+  */
+  void ParserByteCode::AddAssignOp(value_type *a_pVar)
+  {
+    m_vBase.push_back(--m_iStackPos);
+    m_vBase.push_back(cmASSIGN);
+    StorePtr(a_pVar);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add function to bytecode. 
+
+      \param a_iArgc Number of arguments, negative numbers indicate multiarg functions.
+      \param a_pFun Pointer to function callback.
+  */
+  void ParserByteCode::AddFun(void *a_pFun, int a_iArgc)
+  {
+    if (a_iArgc>=0)
+    {
+      m_iStackPos = m_iStackPos - a_iArgc + 1; 
+    }
+    else
+    {
+      m_iStackPos = m_iStackPos + a_iArgc + 1; 
+    }
+
+    m_vBase.push_back(m_iStackPos);
+    m_vBase.push_back(cmFUNC);
+	  m_vBase.push_back(a_iArgc);
+
+    StorePtr(a_pFun);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add Strung function entry to the parser bytecode. 
+      \throw nothrow
+
+      A string function entry consists of the stack position of the return value,
+      followed by a cmSTRFUNC code, the function pointer and an index into the 
+      string buffer maintained by the parser.
+  */
+  void ParserByteCode::AddStrFun(void *a_pFun, int a_iArgc, int a_iIdx)
+  {
+    m_iStackPos = m_iStackPos - a_iArgc + 1;
+    m_vBase.push_back(m_iStackPos);
+    m_vBase.push_back(cmFUNC_STR);
+	  m_vBase.push_back(a_iArgc);
+    m_vBase.push_back(a_iIdx);
+
+    StorePtr(a_pFun);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Add end marker to bytecode.
+      
+      \throw nothrow 
+  */
+  void ParserByteCode::Finalize()
+  {
+    // yes we need the end code three times!! (I forgot why)
+    m_vBase.push_back(cmEND);	
+    m_vBase.push_back(cmEND);	
+    m_vBase.push_back(cmEND);	
+
+    // shrink bytecode vector to fit
+    storage_type(m_vBase).swap(m_vBase);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Get Pointer to bytecode data storage. */
+  const ParserByteCode::map_type* ParserByteCode::GetRawData() const
+  {
+    assert(m_vBase.size());
+    return &m_vBase[0];
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Delete the bytecode. 
+  
+      \throw nothrow
+
+      The name of this function is a violation of my own coding guidelines
+      but this way it's more in line with the STL functions thus more 
+      intuitive.
+  */
+  void ParserByteCode::clear()
+  {
+    m_vBase.clear();
+    m_iStackPos = 0;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Remove a value number of entries from the bytecode. 
+    
+      \attention Currently I don't test if the entries are really value entries.
+  */
+  void ParserByteCode::RemoveValEntries(unsigned a_iNumber)
+  {
+    unsigned iSize = a_iNumber * mc_iSizeValEntry;   
+    assert( m_vBase.size() >= iSize );
+    m_vBase.resize(m_vBase.size()-iSize);
+
+    assert(m_iStackPos >= a_iNumber);
+    m_iStackPos -= (a_iNumber);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Dump bytecode (for debugging only!). */
+  void ParserByteCode::AsciiDump()
+  {
+    if (!m_vBase.size()) 
+    {
+      std::cout << "No bytecode available\n";
+      return;
+    }
+
+    std::cout << "Entries:" << (int)m_vBase.size() 
+              << " (ValSize:" << mc_iSizeVal 
+              << " entries, PtrSize:" << mc_iSizePtr 
+              << " entries, MapSize:" << sizeof(map_type) 
+              << " byte)\n";
+    int i = 0;
+
+    while ( m_vBase[i] != cmEND && i<(int)m_vBase.size())
+    {
+      std::cout << "IDX[" << m_vBase[i++] << "]\t";
+      switch (m_vBase[i])
+      {
+        case cmVAL: std::cout << "VAL "; ++i;
+                    std::cout << "[" << *( reinterpret_cast<double*>(&m_vBase[i]) ) << "]\n";
+                    i += mc_iSizeVal;
+                    break;
+
+        case cmVAR: std::cout << "VAR "; ++i;
+  	                std::cout << "[ADDR: 0x" << std::hex << *(value_type**)&m_vBase[i] << "]\n"; 
+                    i += mc_iSizePtr;
+
+                    // Variable entries have the same size like value entries
+                    // the remaining spave must be skipped
+                    i+= std::max(mc_iSizeVal - mc_iSizePtr, 0);
+                    break;
+      			
+        case cmFUNC:
+                    std::cout << "CALL\t"; ++i;
+                    std::cout << "[ARG:" << std::dec << m_vBase[i] << "]"; ++i;
+	                  std::cout << "[ADDR: 0x" << std::hex << *(value_type**)&m_vBase[i] << "]\n"; 
+                    i += mc_iSizePtr;
+                    break;
+
+        case cmFUNC_STR:
+                    std::cout << "CALL STRFUNC\t"; ++i;
+                    std::cout << "[ARG:" << std::dec << m_vBase[i] << "]"; ++i;
+                    std::cout << "[IDX:" << std::dec << m_vBase[i] << "]"; ++i;
+                    std::cout << "[ADDR: 0x" << *(value_type**)&m_vBase[i] << "]\n"; 
+                    i += mc_iSizePtr;
+                    break;
+
+        case cmLT:  std::cout << "LT\n"; ++i; break;
+        case cmGT:  std::cout << "GT\n"; ++i; break;
+        case cmLE:  std::cout << "LE\n"; ++i; break;
+        case cmGE:  std::cout << "GE\n"; ++i; break;
+        case cmEQ:  std::cout << "EQ\n"; ++i; break;
+        case cmNEQ: std::cout << "NEQ\n"; ++i; break;
+        case cmADD: std::cout << "ADD\n"; ++i; break;
+        case cmAND: std::cout << "AND\n"; ++i; break;
+        case cmOR:  std::cout << "OR\n";  ++i; break;
+        case cmXOR: std::cout << "XOR\n"; ++i; break;
+        case cmSUB: std::cout << "SUB\n"; ++i; break;
+        case cmMUL: std::cout << "MUL\n"; ++i; break;
+        case cmDIV: std::cout << "DIV\n"; ++i; break;
+        case cmPOW: std::cout << "POW\n"; ++i; break;
+
+        case cmASSIGN: 
+                    std::cout << "ASSIGN\t"; ++i; 
+                    std::cout << "[ADDR: 0x" << *(value_type**)&m_vBase[i] << "]\n"; 
+                    i += mc_iSizePtr;
+                    break; 
+
+        default:    std::cout << "(unknown code: " << m_vBase[i] << ")\n"; 
+                    ++i;	
+                    break;
+      } // switch cmdCode
+    } // while bytecode
+
+    std::cout << "END" << std::endl;
+  }
+} // namespace mu
diff --git a/muparser/muParserBytecode.h b/muparser/muParserBytecode.h
new file mode 100644
index 0000000..d425990
--- /dev/null
+++ b/muparser/muParserBytecode.h
@@ -0,0 +1,148 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+#ifndef MU_PARSER_BYTECODE_H
+#define MU_PARSER_BYTECODE_H
+
+#include <cassert>
+#include <string>
+#include <stack>
+#include <vector>
+
+#include "muParserDef.h"
+#include "muParserError.h"
+#include "muParserToken.h"
+
+
+namespace mu
+{
+
+
+/** \brief Bytecode implementation of the Math Parser.
+
+  The bytecode contains the formula converted to revers polish notation stored in a continious
+  memory area. Associated with this data are operator codes, variable pointers, constant 
+  values and function pointers. Those are necessary in order to calculate the result.
+  All those data items will be casted to the underlying datatype of the bytecode.
+
+  \author (C) 2004, 2005 Ingo Berg 
+*/
+class ParserByteCode
+{
+public:
+    /** \brief Underlying type of the container.
+
+       The bytecode is a vector of this type containing control codes,
+       values and pointers. Values and pointer will be casted to this 
+       type before their storage.
+    */
+    typedef bytecode_type map_type;
+
+private:
+
+    /** \brief Token type for internal use only. */
+    typedef ParserToken<value_type, string_type> token_type;
+
+    /** \brief Core type of the bytecode. */
+    typedef std::vector<map_type> storage_type;
+
+    /** \brief Position in the Calculation array. */
+    unsigned m_iStackPos;
+
+    /** \brief Core type of the bytecode. */
+    storage_type m_vBase;
+
+    /** \brief Size of a value entry in the bytecode, relative to TMapType size. */
+    const int mc_iSizeVal;
+
+    /** \brief Size of a pointer, relative to size of underlying TMapType.
+       
+        \attention The size is related to the size of TMapType not bytes!
+    */
+    const int mc_iSizePtr;
+
+    /** \brief A value entry requires that much entires in the bytecode. 
+        
+        Value entry consists of:
+        <ul>
+          <li>One entry for Stack index</li>
+          <li>One entry for Token identifier</li>
+          <li>mc_iSizeVal entries for the value</li>
+        <ul>
+
+        \sa AddVal(TBaseData a_fVal)
+    */
+    const int mc_iSizeValEntry;
+
+    void StorePtr(void *a_pAddr);
+
+public:
+    ParserByteCode();
+   ~ParserByteCode();
+    ParserByteCode(const ParserByteCode &a_ByteCode);
+    ParserByteCode& operator=(const ParserByteCode &a_ByteCode);
+    void Assign(const ParserByteCode &a_ByteCode);
+
+    void AddVar(value_type *a_pVar);
+    void AddVal(value_type a_fVal);
+    void AddOp(ECmdCode a_Oprt);
+    void AddAssignOp(value_type *a_pVar);
+    void AddFun(void *a_pFun, int a_iArgc);
+    void AddStrFun(void *a_pFun, int a_iArgc, int a_iIdx);
+
+    void Finalize();
+    void clear();
+    const map_type* GetRawData() const;
+
+    /** \brief Return size of a value entry. 
+    
+      That many bytecode entries are necessary to store a value.
+
+      \sa mc_iSizeVal
+    */
+    unsigned GetValSize() const 
+    {
+      return mc_iSizeVal;
+    }
+
+    /** \brief Return size of a pointer entry. 
+    
+      That many bytecode entries are necessary to store a pointer.
+
+      \sa mc_iSizePtr
+    */
+    unsigned GetPtrSize() const 
+    {
+      return mc_iSizePtr;
+    }
+
+    void RemoveValEntries(unsigned a_iNumber);
+    void AsciiDump();
+};
+
+} // namespace mu
+
+#endif
+
+
diff --git a/muparser/muParserCallback.cpp b/muparser/muParserCallback.cpp
new file mode 100644
index 0000000..1312ad7
--- /dev/null
+++ b/muparser/muParserCallback.cpp
@@ -0,0 +1,198 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#include "muParserCallback.h"
+
+
+namespace mu
+{
+
+  ParserCallback::ParserCallback(fun_type1 a_pFun, bool a_bAllowOpti, int a_iPrec, ECmdCode a_iCode)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(1)
+    ,m_iPri(a_iPrec)
+    ,m_iCode(a_iCode)
+    ,m_iType(tpDBL)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+
+  ParserCallback::ParserCallback( fun_type2 a_pFun, bool a_bAllowOpti, int a_iPrec, ECmdCode a_iCode)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(2)
+    ,m_iPri(a_iPrec)
+    ,m_iCode(a_iCode)
+    ,m_iType(tpDBL)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+
+  ParserCallback::ParserCallback(fun_type3 a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(3)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC)
+    ,m_iType(tpDBL)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+
+  ParserCallback::ParserCallback(fun_type4 a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(4)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC)
+    ,m_iType(tpDBL)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+  ParserCallback::ParserCallback(fun_type5 a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(5)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC)
+    ,m_iType(tpDBL)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+  ParserCallback::ParserCallback(multfun_type a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(-1)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC)
+    ,m_iType(tpDBL)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+  ParserCallback::ParserCallback(strfun_type1 a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(0)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC_STR)
+    ,m_iType(tpSTR)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+  ParserCallback::ParserCallback(strfun_type2 a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(1)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC_STR)
+    ,m_iType(tpSTR)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+  ParserCallback::ParserCallback(strfun_type3 a_pFun, bool a_bAllowOpti)
+    :m_pFun((void*)a_pFun)
+    ,m_iArgc(2)
+    ,m_iPri(-1)
+    ,m_iCode(cmFUNC_STR)
+    ,m_iType(tpSTR)
+    ,m_bAllowOpti(a_bAllowOpti)
+  {}
+
+  /** \brief Default constructor. 
+
+      \throw nothrow
+  */
+  ParserCallback::ParserCallback()
+    :m_pFun(0)
+    ,m_iArgc(0)
+    ,m_iCode(cmUNKNOWN)
+    ,m_iType(tpVOID)
+    ,m_bAllowOpti(0)
+  {}
+
+  /** \brief Copy constructor. 
+
+      \throw nothrow
+  */
+  ParserCallback::ParserCallback(const ParserCallback &a_Fun)
+  {
+    m_pFun = a_Fun.m_pFun;
+    m_iArgc = a_Fun.m_iArgc;
+    m_bAllowOpti = a_Fun.m_bAllowOpti;
+    m_iCode = a_Fun.m_iCode;
+    m_iType = a_Fun.m_iType;
+    m_iPri = a_Fun.m_iPri;
+  }
+    
+  /** \brief Clone this instance and return a pointer to the new instance. */
+  ParserCallback* ParserCallback::Clone() const
+  {
+    return new ParserCallback(*this);
+  }
+
+
+  /** \brief Return tru if the function is conservative.
+
+      Conservative functions return always the same result for the same argument.
+      \throw nothrow
+  */
+  bool ParserCallback::IsOptimizable() const  
+  { 
+    return m_bAllowOpti; 
+  }
+
+  /** \brief Get the callback address for the parser function. 
+  
+      The type of the address is void. It needs to be recasted according to the
+      argument number to the right type.
+
+      \throw nothrow
+      \return #pFun
+  */
+  void* ParserCallback::GetAddr() const 
+  { 
+    return m_pFun;  
+  }
+  
+  /** \brief Return the callback code. */
+  ECmdCode  ParserCallback::GetCode() const 
+  { 
+    return m_iCode; 
+  }
+  
+  
+  ETypeCode ParserCallback::GetType() const 
+  { 
+    return m_iType; 
+  }
+
+  /** \brief Return the operator priority. 
+  
+     Only valid if the callback token is an operator token (binary or infix).
+  */
+  int ParserCallback::GetPri()  const 
+  { 
+    return m_iPri;  
+  }
+    
+  /** \brief Returns the number of function Arguments. */
+  int ParserCallback::GetArgc() const 
+  { 
+    return m_iArgc; 
+  }
+} // namespace mu
diff --git a/muparser/muParserCallback.h b/muparser/muParserCallback.h
new file mode 100644
index 0000000..9fecddb
--- /dev/null
+++ b/muparser/muParserCallback.h
@@ -0,0 +1,94 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_CALLBACK_H
+#define MU_PARSER_CALLBACK_H
+
+#include "muParserDef.h"
+
+
+namespace mu
+{
+
+/** \brief Encapsulation of prototypes for a numerical parser function.
+
+    Encapsulates the prototyp for numerical parser functions. The class
+    stores the number of arguments for parser functions as well
+    as additional flags indication the function is non optimizeable.
+    The pointer to the callback function pointer is stored as void* 
+    and needs to be casted according to the argument count.
+    Negative argument counts indicate a parser function with a variable number
+    of arguments. 
+    This class is not used for string function prototyping.
+
+    \author (C) 2004-2006 Ingo Berg
+*/
+class ParserCallback
+{
+public:
+    ParserCallback(fun_type1 a_pFun, bool a_bAllowOpti, int a_iPrec = -1, ECmdCode a_iCode=cmFUNC);
+    ParserCallback(fun_type2 a_pFun, bool a_bAllowOpti, int a_iPrec = -1, ECmdCode a_iCode=cmFUNC);
+    ParserCallback(fun_type3 a_pFun, bool a_bAllowOpti);
+    ParserCallback(fun_type4 a_pFun, bool a_bAllowOpti);
+    ParserCallback(fun_type5 a_pFun, bool a_bAllowOpti);
+    ParserCallback(multfun_type a_pFun, bool a_bAllowOpti);
+    ParserCallback(strfun_type1 a_pFun, bool a_bAllowOpti);
+    ParserCallback(strfun_type2 a_pFun, bool a_bAllowOpti);
+    ParserCallback(strfun_type3 a_pFun, bool a_bAllowOpti);
+    ParserCallback();
+    ParserCallback(const ParserCallback &a_Fun);
+    
+    ParserCallback* Clone() const;
+
+    bool  IsOptimizable() const;
+    void* GetAddr() const;
+    ECmdCode  GetCode() const;
+    ETypeCode GetType() const;
+    int GetPri()  const;
+    int GetArgc() const;
+
+private:
+    void *m_pFun;       ///< Pointer to the callback function, casted to void
+    
+    /** \brief Number of numeric function arguments
+    
+        This number is negative for functions with variable number of arguments. in this cases
+        they represent the actual number of arguments found.
+    */
+    int   m_iArgc;      
+    int   m_iPri;       ///< Valid only for binary and infix operators; Operator precedence.
+    ECmdCode  m_iCode;
+    ETypeCode m_iType;
+    bool  m_bAllowOpti; ///< Flag indication optimizeability 
+};
+
+//------------------------------------------------------------------------------
+/** \brief Container for Callback objects. */
+typedef std::map<string_type, ParserCallback> funmap_type; 
+
+} // namespace mu
+
+#endif
+
diff --git a/muparser/muParserDLL.cpp b/muparser/muParserDLL.cpp
new file mode 100644
index 0000000..0f85cb7
--- /dev/null
+++ b/muparser/muParserDLL.cpp
@@ -0,0 +1,657 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+
+#if defined(MUPARSER_DLL) && defined(_WIN32)
+
+#include "muParserDLL.h"
+#include "muParser.h"
+#include "muParserError.h"
+
+
+#define MU_PARSER_TRY  \
+        try            \
+        {
+
+#define MU_PARSER_CATCH          \
+        }                        \
+        catch(exception_type &e) \
+        {                        \
+          g_bError = true;       \
+          g_ParserError = e;     \
+          if (g_pErrHandler)     \
+            g_pErrHandler();     \
+        }                        \
+        catch(...)               \
+        {                        \
+          g_bError = true;       \
+          g_ParserError = exception_type(mu::ecINTERNAL_ERROR); \
+          if (g_pErrHandler)     \
+            g_pErrHandler();     \
+        }
+
+//---------------------------------------------------------------------------
+typedef mu::ParserBase::exception_type exception_type;
+typedef mu::ParserBase* parser_type;
+
+#if !defined(_UNICODE)
+  typedef std::string string_type;
+#else
+  typedef std::wstring string_type;
+#endif
+
+typedef string_type::value_type char_type;
+
+//---------------------------------------------------------------------------
+//
+//
+//  unexported variables
+//
+//
+//---------------------------------------------------------------------------
+
+/** \brief The last exception that was caught.
+*/
+exception_type g_ParserError;
+errhandler_type g_pErrHandler;
+
+//---------------------------------------------------------------------------
+/** \brief Flags indicating an error occured.
+*/
+bool g_bError;
+
+//---------------------------------------------------------------------------
+//
+//
+//  unexported functions
+//
+//
+//---------------------------------------------------------------------------
+
+parser_type GetPtr(parser_handle a_hParser)
+{
+  return static_cast<parser_type>(a_hParser);
+}
+
+//---------------------------------------------------------------------------
+/** \brief DLL entry point.
+*/
+BOOL APIENTRY DllMain( HANDLE /*hModule*/, DWORD  ul_reason_for_call, LPVOID /*lpReserved*/ )
+{
+	switch (ul_reason_for_call)
+	{
+	case DLL_PROCESS_ATTACH:
+	case DLL_THREAD_ATTACH:
+        g_pErrHandler = 0;
+        g_bError = false;
+        break;
+
+  case DLL_THREAD_DETACH:
+	case DLL_PROCESS_DETACH:
+    		break;
+	}
+
+  return TRUE;
+}
+
+//---------------------------------------------------------------------------
+//
+//
+//  exported functions
+//
+//
+//---------------------------------------------------------------------------
+
+MU_PARSER_API void mupSetErrorHandler(errhandler_type a_pHandler)
+{
+  g_pErrHandler = a_pHandler;
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupSetVarFactory(parser_handle a_hParser, facfun_type a_pFactory, void *pUserData)
+{
+  parser_type p(GetPtr(a_hParser));
+  p->SetVarFactory(a_pFactory, pUserData);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Create a new Parser instance and return its handle.
+*/
+MU_PARSER_API parser_handle mupInit()
+{
+  return (void*)(new mu::Parser());
+}
+
+//---------------------------------------------------------------------------
+/** \brief Release the parser instance related with a parser handle.
+*/
+MU_PARSER_API void mupRelease(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    delete p;
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+/** \brief Evaluate the expression.
+*/
+MU_PARSER_API double mupEval(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    return p->Eval();
+  MU_PARSER_CATCH
+
+  return 0;
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupSetExpr(parser_handle a_hParser, const char *a_szExpr)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->SetExpr(a_szExpr);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupRemoveVar(parser_handle a_hParser, const char *a_szName)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->RemoveVar( string_type(a_szName) );
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+/** \brief Release all parser variables.
+    \param a_hParser Handle to the parser instance.
+*/
+MU_PARSER_API void mupClearVar(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->ClearVar();
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+/** \brief Release all parser variables.
+    \param a_hParser Handle to the parser instance.
+*/
+MU_PARSER_API void mupClearConst(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->ClearConst();
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+/** \brief Clear all user defined operators.
+    \param a_hParser Handle to the parser instance.
+*/
+MU_PARSER_API void mupClearOprt(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->ClearOprt();
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineFun1(parser_handle a_hParser, const char *a_szName, fun_type1 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineFun2(parser_handle a_hParser, const char *a_szName, fun_type2 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineFun3(parser_handle a_hParser, const char *a_szName, fun_type3 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineFun4(parser_handle a_hParser, const char *a_szName, fun_type4 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineFun5(parser_handle a_hParser, const char *a_szName, fun_type5 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineStrFun1(parser_handle a_hParser, const char *a_szName, strfun_type1 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineStrFun2(parser_handle a_hParser, const char *a_szName, strfun_type2 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineStrFun3(parser_handle a_hParser, const char *a_szName, strfun_type3 a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineMultFun(parser_handle a_hParser, const char *a_szName, multfun_type a_pFun, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineFun(a_szName, a_pFun, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineOprt(parser_handle a_hParser, const char *a_szName, fun_type2 a_pFun, int a_iPri, bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineOprt(a_szName, a_pFun, a_iPri, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineVar(parser_handle a_hParser, const char *a_szName, double *a_pVar)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineVar(a_szName, a_pVar);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineConst(parser_handle a_hParser, const char *a_szName, double a_fVal)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineConst(a_szName, a_fVal);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineStrConst(parser_handle a_hParser, const char *a_szName, const char *a_szVal)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineStrConst(a_szName, a_szVal);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API const char* mupGetExpr(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    return p->GetExpr().c_str();
+  MU_PARSER_CATCH
+
+  return "";
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefinePostfixOprt(parser_handle a_hParser,
+                                        const char *a_szName,
+                                        fun_type1 a_pOprt,
+                                        bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefinePostfixOprt(a_szName, a_pOprt, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineInfixOprt(parser_handle a_hParser,
+                                      const char *a_szName,
+                                      fun_type1 a_pOprt,
+                                      bool a_bAllowOpt)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->DefineInfixOprt(a_szName, a_pOprt, a_bAllowOpt);
+  MU_PARSER_CATCH
+}
+
+// Define character sets for identifiers
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineNameChars(parser_handle a_hParser, const char *a_szCharset)
+{
+  parser_type p(GetPtr(a_hParser));
+  p->DefineNameChars(a_szCharset);
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineOprtChars(parser_handle a_hParser, const char *a_szCharset)
+{
+  parser_type p(GetPtr(a_hParser));
+  p->DefineOprtChars(a_szCharset);
+}
+
+//---------------------------------------------------------------------------
+MU_PARSER_API void mupDefineInfixOprtChars(parser_handle a_hParser, const char *a_szCharset)
+{
+  parser_type p(GetPtr(a_hParser));
+  p->DefineInfixOprtChars(a_szCharset);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Get the number of variables defined in the parser.
+    \param a_hParser [in] Must be a valid parser handle.
+    \return The number of used variables.
+    \sa mupGetExprVar
+*/
+MU_PARSER_API int mupGetVarNum(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    const mu::varmap_type VarMap = p->GetVar();
+    return (int)VarMap.size();
+  MU_PARSER_CATCH
+
+  return 0; // never reached
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return a variable that is used in an expression.
+
+    Prior to calling this function call mupGetExprVarNum in order to get the
+    number of variables in the expression. If the parameter a_iVar is greater
+    than the number of variables both a_szName and a_pVar will be set to zero.
+    As a side effect this function will trigger an internal calculation of the
+    expression undefined variables will be set to zero during this calculation.
+    During the calculation user defined callback functions present in the expression
+    will be called, this is unavoidable.
+
+    \param a_hParser [in] A valid parser handle.
+    \param a_iVar [in] The index of the variable to return.
+    \param a_szName [out] Pointer to the variable name.
+    \param a_pVar [out] Pointer to the variable.
+    \throw nothrow
+*/
+MU_PARSER_API void mupGetVar(parser_handle a_hParser, unsigned a_iVar, const char **a_szName, double **a_pVar)
+{
+  // A static buffer is needed for the name since i cant return the
+  // pointer from the map.
+  static char  szName[1024];
+
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    const mu::varmap_type VarMap = p->GetVar();
+
+    if (a_iVar>=VarMap.size())
+    {
+     *a_szName = 0;
+     *a_pVar = 0;
+      return;
+    }
+    mu::varmap_type::const_iterator item;
+
+    item = VarMap.begin();
+    for (unsigned i=0; i<a_iVar; ++i)
+      item++;
+
+     strncpy(szName, item->first.c_str(), sizeof(szName));
+     szName[sizeof(szName)-1] = 0;
+
+    *a_szName = &szName[0];
+    *a_pVar = item->second;
+     return;
+
+  MU_PARSER_CATCH
+
+  *a_szName = 0;
+  *a_pVar = 0;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Get the number of variables used in the expression currently set in the parser.
+    \param a_hParser [in] Must be a valid parser handle.
+    \return The number of used variables.
+    \sa mupGetExprVar
+*/
+MU_PARSER_API int mupGetExprVarNum(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    const mu::varmap_type VarMap = p->GetUsedVar();
+    return (int)VarMap.size();
+  MU_PARSER_CATCH
+
+  return 0; // never reached
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return a variable that is used in an expression.
+
+    Prior to calling this function call mupGetExprVarNum in order to get the
+    number of variables in the expression. If the parameter a_iVar is greater
+    than the number of variables both a_szName and a_pVar will be set to zero.
+    As a side effect this function will trigger an internal calculation of the
+    expression undefined variables will be set to zero during this calculation.
+    During the calculation user defined callback functions present in the expression
+    will be called, this is unavoidable.
+
+    \param a_hParser [in] A valid parser handle.
+    \param a_iVar [in] The index of the variable to return.
+    \param a_szName [out] Pointer to the variable name.
+    \param a_pVar [out] Pointer to the variable.
+    \throw nothrow
+*/
+MU_PARSER_API void mupGetExprVar(parser_handle a_hParser, unsigned a_iVar, const char **a_szName, double **a_pVar)
+{
+  // A static buffer is needed for the name since i cant return the
+  // pointer from the map.
+  static char  szName[1024];
+
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    const mu::varmap_type VarMap = p->GetUsedVar();
+
+    if (a_iVar>=VarMap.size())
+    {
+     *a_szName = 0;
+     *a_pVar = 0;
+      return;
+    }
+    mu::varmap_type::const_iterator item;
+
+    item = VarMap.begin();
+    for (unsigned i=0; i<a_iVar; ++i)
+      item++;
+
+     strncpy(szName, item->first.c_str(), sizeof(szName));
+     szName[sizeof(szName)-1] = 0;
+
+    *a_szName = &szName[0];
+    *a_pVar = item->second;
+     return;
+
+  MU_PARSER_CATCH
+
+  *a_szName = 0;
+  *a_pVar = 0;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return the number of constants defined in a parser. */
+MU_PARSER_API int mupGetConstNum(parser_handle a_hParser)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    const mu::valmap_type ValMap = p->GetConst();
+    return (int)ValMap.size();
+  MU_PARSER_CATCH
+
+  return 0; // never reached
+}
+
+//---------------------------------------------------------------------------
+/** \brief Retrieve name and value of a single parser constant.
+    \param a_hParser [in] a valid parser handle
+    \param a_iVar [in] Index of the constant to query
+    \param a_pszName [out] pointer to a null terminated string with the constant name
+    \param [out] The constant value
+*/
+MU_PARSER_API void mupGetConst(parser_handle a_hParser, unsigned a_iVar,
+                               const char **a_pszName, double &a_fVal)
+{
+  // A static buffer is needed for the name since i cant return the
+  // pointer from the map.
+  static char  szName[1024];
+
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    const mu::valmap_type ValMap = p->GetConst();
+
+    if (a_iVar>=ValMap.size())
+    {
+     *a_pszName = 0;
+      a_fVal = 0;
+      return;
+    }
+
+    mu::valmap_type::const_iterator item;
+    item = ValMap.begin();
+    for (unsigned i=0; i<a_iVar; ++i)
+      item++;
+
+    strncpy(szName, item->first.c_str(), sizeof(szName));
+    szName[sizeof(szName)-1] = 0;
+
+    *a_pszName = &szName[0];
+     a_fVal = item->second;
+     return;
+
+  MU_PARSER_CATCH
+
+  *a_pszName = 0;
+   a_fVal = 0;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Add a custom value regognition function.
+*/
+MU_PARSER_API void mupAddValIdent(parser_handle a_hParser, identfun_type a_pFun)
+{
+  MU_PARSER_TRY
+    parser_type p(GetPtr(a_hParser));
+    p->AddValIdent(a_pFun);
+  MU_PARSER_CATCH
+}
+
+//---------------------------------------------------------------------------
+/** \brief Query if an error occured.
+
+    After querying the internal error bit will be reset. So a consecutive call
+    will return false.
+*/
+MU_PARSER_API bool mupError()
+{
+  bool bError(g_bError);
+  g_bError = false;
+  return bError;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Reset the internal error flag.
+*/
+MU_PARSER_API void mupErrorReset()
+{
+  g_bError = false;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return the message associated with the last error.
+*/
+MU_PARSER_API const char* mupGetErrorMsg()
+{
+  return g_ParserError.GetMsg().c_str();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return the message associated with the last error.
+*/
+MU_PARSER_API const char* mupGetErrorToken()
+{
+  return g_ParserError.GetToken().c_str();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return the code associated with the last error.
+*/
+MU_PARSER_API int mupGetErrorCode()
+{
+  return g_ParserError.GetCode();
+}
+
+//---------------------------------------------------------------------------
+/** \brief Return the postion associated with the last error. */
+MU_PARSER_API int mupGetErrorPos()
+{
+  return (int)g_ParserError.GetPos();
+}
+
+
+#endif      // MUPARSER_DLL
diff --git a/muparser/muParserDLL.h b/muparser/muParserDLL.h
new file mode 100644
index 0000000..20e2db8
--- /dev/null
+++ b/muparser/muParserDLL.h
@@ -0,0 +1,123 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+// Folgender ifdef-Block ist die Standardmethode zum Erstellen von Makros, die das Exportieren 
+// aus einer DLL vereinfachen. Alle Dateien in der DLL werden mit dem MUPARSERLIB_EXPORTS-Symbol
+// kompiliert, das in der Befehlszeile definiert wurde. Das Symbol darf nicht f�r ein Projekt definiert werden,
+// das diese DLL verwendet. Alle anderen Projekte, deren Quelldateien diese Datei beinhalten, erkennen 
+// MUPARSERLIB_API-Funktionen als aus einer DLL importiert, w�hrend die DLL mit diesem Makro
+// definierte Symbole als exportiert ansieht.
+#ifndef MU_PARSER_DLL_H
+#define MU_PARSER_DLL_H
+
+#ifdef MUPARSERLIB_EXPORTS
+#define MU_PARSER_API __declspec(dllexport) 
+#else
+#define MU_PARSER_API __declspec(dllimport) 
+#endif
+
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+typedef void* parser_handle;
+typedef double (*fun_type1)(double); 
+typedef double (*fun_type2)(double, double); 
+typedef double (*fun_type3)(double, double, double); 
+typedef double (*fun_type4)(double, double, double, double); 
+typedef double (*fun_type5)(double, double, double, double, double); 
+typedef double (*multfun_type)(const double*, int);
+typedef double (*strfun_type1)(const char*);
+typedef double (*strfun_type2)(const char*, double);
+typedef double (*strfun_type3)(const char*, double, double);
+typedef void (*errhandler_type)();
+typedef double* (*facfun_type)(const char*, void *);
+typedef bool (*identfun_type)(const char*, int&, double&);
+
+extern "C"
+{
+
+// Basic operations / initialization  
+MU_PARSER_API parser_handle mupInit();
+MU_PARSER_API void mupRelease(parser_handle a_hParser);
+MU_PARSER_API const char* mupGetExpr(parser_handle a_hParser);
+MU_PARSER_API void mupSetExpr(parser_handle a_hParser, const char *a_szExpr);
+MU_PARSER_API void mupSetErrorHandler(errhandler_type a_pErrHandler);
+MU_PARSER_API void mupSetVarFactory(parser_handle a_hParser, facfun_type a_pFactory, void *pUserData);
+
+MU_PARSER_API double mupEval(parser_handle a_hParser);
+
+// Defining callbacks / variables / constants
+MU_PARSER_API void mupDefineFun1(parser_handle a_hParser, const char *a_szName, fun_type1 a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineFun2(parser_handle a_hParser, const char *a_szName, fun_type2 a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineFun3(parser_handle a_hParser, const char *a_szName, fun_type3 a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineFun4(parser_handle a_hParser, const char *a_szName, fun_type4 a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineFun5(parser_handle a_hParser, const char *a_szName, fun_type5 a_pFun, bool a_bAllowOpt = true);
+// string functions
+MU_PARSER_API void mupDefineStrFun1(parser_handle a_hParser, const char *a_szName, strfun_type1 a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineStrFun2(parser_handle a_hParser, const char *a_szName, strfun_type2 a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineStrFun3(parser_handle a_hParser, const char *a_szName, strfun_type3 a_pFun, bool a_bAllowOpt = true);
+
+MU_PARSER_API void mupDefineMultFun(parser_handle a_hParser, const char *a_szName, multfun_type a_pFun, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineOprt(parser_handle a_hParser, const char *a_szName, fun_type2 a_pFun, int a_iPri = 0, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineConst(parser_handle a_hParser, const char *a_szName, double a_fVal);
+MU_PARSER_API void mupDefineStrConst(parser_handle a_hParser, const char *a_szName, const char *a_sVal);
+MU_PARSER_API void mupDefineVar(parser_handle a_hParser, const char *a_szName, double *a_fVar);
+MU_PARSER_API void mupDefinePostfixOprt(parser_handle a_hParser, const char *a_szName, fun_type1 a_pOprt, bool a_bAllowOpt = true);
+MU_PARSER_API void mupDefineInfixOprt(parser_handle a_hParser, const char *a_szName, fun_type1 a_pOprt, bool a_bAllowOpt=true);
+
+// Define character sets for identifiers
+MU_PARSER_API void mupDefineNameChars(parser_handle a_hParser, const char *a_szCharset);
+MU_PARSER_API void mupDefineOprtChars(parser_handle a_hParser, const char *a_szCharset);
+MU_PARSER_API void mupDefineInfixOprtChars(parser_handle a_hParser, const char *a_szCharset);
+
+// Remove all / single variables
+MU_PARSER_API void mupRemoveVar(parser_handle a_hParser, const char *a_szName);
+MU_PARSER_API void mupClearVar(parser_handle a_hParser);
+MU_PARSER_API void mupClearConst(parser_handle a_hParser);
+MU_PARSER_API void mupClearOprt(parser_handle a_hParser);
+
+// Querying variables / expression variables / constants
+MU_PARSER_API int mupGetExprVarNum(parser_handle a_hParser);
+MU_PARSER_API int mupGetVarNum(parser_handle a_hParser);
+MU_PARSER_API int mupGetConstNum(parser_handle a_hParser);
+MU_PARSER_API void mupGetExprVar(parser_handle a_hParser, unsigned a_iVar, const char **a_pszName, double **a_pVar);
+MU_PARSER_API void mupGetVar(parser_handle a_hParser, unsigned a_iVar, const char **a_pszName, double **a_pVar);
+MU_PARSER_API void mupGetConst(parser_handle a_hParser, unsigned a_iVar, const char **a_pszName, double &a_pVar);
+
+// Add value recognition callbacks
+MU_PARSER_API void mupAddValIdent(parser_handle a_hParser, identfun_type);
+
+// Error handling
+MU_PARSER_API bool mupError();
+MU_PARSER_API void mupErrorReset();
+MU_PARSER_API const char* mupGetErrorMsg();
+MU_PARSER_API int mupGetErrorCode();
+MU_PARSER_API int mupGetErrorPos();
+MU_PARSER_API const char* mupGetErrorToken();
+
+} // extern "C"
+
+#endif
diff --git a/muparser/muParserDef.h b/muparser/muParserDef.h
new file mode 100644
index 0000000..164b882
--- /dev/null
+++ b/muparser/muParserDef.h
@@ -0,0 +1,239 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+#ifndef MUP_DEF_H
+#define MUP_DEF_H
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <map>
+
+#include "muParserFixes.h"
+
+/** \brief Define the base datatype for values.
+
+  This datatype must be a built in value type. You can not use custom classes.
+  It has been tested with float, double and long double types, int should
+  work as well.
+*/
+#define MUP_BASETYPE double
+
+
+/** \brief Definition of the basic bytecode datatype. */
+#define MUP_BYTECODE_TYPE long
+
+/** \brief Maybe I use this for unicode support later. */
+#if defined(_UNICODE)
+  /** \brief Definition of the basic parser string type. */
+  #define MUP_STRING_TYPE std::wstring
+
+  #if !defined(_T)
+    #define _T(x) L##x
+  #endif // not defined _T
+#else
+  #ifndef _T
+  #define _T
+  #endif
+  
+  /** \brief Definition of the basic parser string type. */
+  #define MUP_STRING_TYPE std::string
+#endif
+
+#if defined(_DEBUG)
+  /** \brief Debug macro to force an abortion of the programm with a certain message.
+  */
+  #define MUP_FAIL(MSG)    \
+          bool MSG=false;  \
+          assert(MSG);
+
+  #ifndef _UNICODE
+    /** \brief An assertion that does not kill the program.
+
+        This macro is neutralised in UNICODE builds. It's
+        too difficult to translate.
+    */
+    #define MUP_ASSERT(COND)                         \
+            if (!(COND))                             \
+            {                                        \
+              stringstream_type ss;                  \
+              ss << "Assertion \""#COND"\" failed: " \
+                 << __FILE__ << " line "             \
+                 << __LINE__ << ".";                 \
+              throw ParserError( ss.str() );         \
+            }
+  #else
+    #define MUP_ASSERT(COND)
+  #endif // _UNICODE
+#else
+  #define MUP_FAIL(MSG)
+  #define MUP_ASSERT(COND)
+#endif
+
+//------------------------------------------------------------------------------
+//
+// do not change anything beyond this point...
+//
+// !!! This section is devoted to macros that are used for debugging
+// !!! or for features that are not fully implemented yet.
+//
+//#define MUP_DUMP_STACK
+//#define MUP_DUMP_CMDCODE
+
+
+namespace mu
+{
+#if defined(_UNICODE)
+
+  //------------------------------------------------------------------------------
+  /** \brief Encapsulate wcout. */
+  inline std::wostream& console()
+  {
+    return std::wcout;
+  }
+
+  /** \brief Encapsulate cin. */
+  inline std::wistream& console_in()
+  {
+    return std::wcin;
+  }
+
+#else
+
+  /** \brief Encapsulate cout. */
+  inline std::ostream& console()
+  {
+    return std::cout;
+  }
+
+  /** \brief Encapsulate cin. */
+  inline std::istream& console_in()
+  {
+    return std::cin;
+  }
+
+#endif
+
+  //------------------------------------------------------------------------------
+  /** \brief Bytecode values.
+
+      \attention The order of the operator entries must match the order in ParserBase::c_DefaultOprt!
+  */
+  enum ECmdCode
+  {
+    // The following are codes for built in binary operators
+    // apart from built in operators the user has the opportunity to
+    // add user defined operators.
+    cmLE            = 0,   ///< Operator item:  less or equal
+    cmGE            = 1,   ///< Operator item:  greater or equal
+    cmNEQ           = 2,   ///< Operator item:  not equal
+    cmEQ            = 3,   ///< Operator item:  equals
+    cmLT            = 4,   ///< Operator item:  less than
+    cmGT            = 5,   ///< Operator item:  greater than
+    cmADD           = 6,   ///< Operator item:  add
+    cmSUB           = 7,   ///< Operator item:  subtract
+    cmMUL           = 8,   ///< Operator item:  multiply
+    cmDIV           = 9,   ///< Operator item:  division
+    cmPOW           = 10,  ///< Operator item:  y to the power of ...
+    cmAND           = 11,  ///< Operator item:  logical and
+    cmOR            = 12,  ///< Operator item:  logical or
+    cmXOR           = 13,  ///< Operator item:  logical xor
+    cmASSIGN        = 14,  ///< Operator item:  Assignment operator
+    cmBO            = 15,  ///< Operator item:  opening bracket
+    cmBC            = 16,  ///< Operator item:  closing bracket
+    cmCOMMA         = 17,  ///< Operator item:  comma
+    cmVAR           = 18,  ///< variable item
+    cmSTRVAR        = 19,
+    cmVAL           = 20,  ///< value item
+
+    cmFUNC          = 21,  ///< Code for a function item
+    cmFUNC_STR      = 22,  ///< Code for a function with a string parameter
+
+    cmSTRING        = 23,  ///< Code for a string token
+    cmOPRT_BIN      = 24,  ///< user defined binary operator
+    cmOPRT_POSTFIX  = 25,  ///< code for postfix operators
+    cmOPRT_INFIX    = 26,  ///< code for infix operators
+    cmEND           = 27,  ///< end of formula
+    cmUNKNOWN       = 28   ///< uninitialized item
+  };
+
+  //------------------------------------------------------------------------------
+  /** \brief Types internally used by the parser.
+  */
+  enum ETypeCode
+  {
+    tpSTR  = 0,     ///> String type (Function arguments and constants only, no string variables)
+    tpDBL  = 1,     ///> Floating point variables
+    tpVOID = 2      ///> Undefined type.
+  };
+
+  //------------------------------------------------------------------------------
+  /** \brief Parser operator precedence values. */
+  enum EPrec
+  {
+    // binary operators
+    prLOGIC   = 1,  ///> logic operators
+    prCMP     = 2,  ///> comparsion operators
+    prADD_SUB = 3,  ///> addition
+    prMUL_DIV = 4,  ///> multiplication/division
+    prPOW     = 5,  ///> power operator priority (highest)
+
+    // infix operators
+    prINFIX    = 4, ///> Signs have a higher priority than ADD_SUB, but lower than power operator
+    prPOSTFIX  = 4  ///> Postfix operator priority (currently unused)
+  };
+
+  //------------------------------------------------------------------------------
+  // basic types
+  typedef MUP_BASETYPE value_type;
+  typedef MUP_STRING_TYPE string_type;
+  typedef MUP_BYTECODE_TYPE bytecode_type;
+  typedef string_type::value_type char_type;
+  typedef std::basic_stringstream<char_type,
+                                  std::char_traits<char_type>,
+                                  std::allocator<char_type> > stringstream_type;
+
+  // Data container types
+  typedef std::map<string_type, value_type*> varmap_type;
+  typedef std::map<string_type, value_type> valmap_type;
+  typedef std::map<string_type, std::size_t> strmap_type;
+
+  // Parser callbacks
+  typedef value_type (*fun_type1)(value_type);
+  typedef value_type (*fun_type2)(value_type, value_type);
+  typedef value_type (*fun_type3)(value_type, value_type, value_type);
+  typedef value_type (*fun_type4)(value_type, value_type, value_type, value_type);
+  typedef value_type (*fun_type5)(value_type, value_type, value_type, value_type, value_type);
+  typedef value_type (*multfun_type)(const value_type*, int);
+  typedef value_type (*strfun_type1)(const char_type*);
+  typedef value_type (*strfun_type2)(const char_type*, value_type);
+  typedef value_type (*strfun_type3)(const char_type*, value_type, value_type);
+
+  // Parser utility callback functions (unrelated to the math callbacks)
+  typedef bool (*identfun_type)(const char_type*, int&, value_type&);
+  typedef value_type* (*facfun_type)(const char_type*, void*);
+} // end fo namespace
+
+#endif
+
diff --git a/muparser/muParserError.cpp b/muparser/muParserError.cpp
new file mode 100644
index 0000000..237f529
--- /dev/null
+++ b/muparser/muParserError.cpp
@@ -0,0 +1,300 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+#include "muParserError.h"
+
+
+namespace mu
+{
+  const ParserErrorMsg ParserErrorMsg::m_Instance;
+
+  //------------------------------------------------------------------------------
+  const ParserErrorMsg& ParserErrorMsg::Instance()
+  {
+    return m_Instance;
+  }
+
+  //------------------------------------------------------------------------------
+  string_type ParserErrorMsg::operator[](unsigned a_iIdx) const
+  {
+    return (a_iIdx<m_vErrMsg.size()) ? m_vErrMsg[a_iIdx] : string_type();
+  }
+
+
+  //---------------------------------------------------------------------------
+  ParserErrorMsg::~ParserErrorMsg()
+  {}
+
+  //---------------------------------------------------------------------------
+  /** \brief Assignement operator is deactivated.
+  */
+  ParserErrorMsg& ParserErrorMsg::operator=(const ParserErrorMsg& )
+  {
+    assert(false);
+    return *this;
+  }
+
+  //---------------------------------------------------------------------------
+  ParserErrorMsg::ParserErrorMsg(const ParserErrorMsg&)
+  {}
+
+  //---------------------------------------------------------------------------
+  ParserErrorMsg::ParserErrorMsg()
+    :m_vErrMsg(0)
+  {
+    m_vErrMsg.resize(ecCOUNT);
+
+    m_vErrMsg[ecUNASSIGNABLE_TOKEN]  = _T("Undefined token \"$TOK$\" found at position $POS$.");
+    m_vErrMsg[ecINTERNAL_ERROR]      = _T("Internal error");
+    m_vErrMsg[ecINVALID_NAME]        = _T("Invalid function-, variable- or constant name.");
+    m_vErrMsg[ecINVALID_FUN_PTR]     = _T("Invalid pointer to callback function.");
+    m_vErrMsg[ecEMPTY_EXPRESSION]    = _T("Expression is empty.");
+    m_vErrMsg[ecINVALID_VAR_PTR]     = _T("Invalid pointer to variable.");
+    m_vErrMsg[ecUNEXPECTED_OPERATOR] = _T("Unexpected operator \"$TOK$\" found at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_EOF]      = _T("Unexpected end of formula at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_COMMA]    = _T("Unexpected comma at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_PARENS]   = _T("Unexpected parenthesis \"$TOK$\" at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_FUN]      = _T("Unexpected function \"$TOK$\" at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_VAL]      = _T("Unexpected value \"$TOK$\" found at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_VAR]      = _T("Unexpected variable \"$TOK$\" found at position $POS$");
+    m_vErrMsg[ecUNEXPECTED_ARG]      = _T("Function arguments used without a function (position: $POS$)");
+    m_vErrMsg[ecMISSING_PARENS]      = _T("Missing parenthesis");
+    m_vErrMsg[ecTOO_MANY_PARAMS]     = _T("Too many parameters for function \"$TOK$\" at formula position $POS$");
+    m_vErrMsg[ecTOO_FEW_PARAMS]      = _T("Too few parameters for function \"$TOK$\" at formula position $POS$");
+    m_vErrMsg[ecDIV_BY_ZERO]         = _T("Divide by zero");
+    m_vErrMsg[ecDOMAIN_ERROR]        = _T("Domain error");
+    m_vErrMsg[ecNAME_CONFLICT]       = _T("Name conflict");
+    m_vErrMsg[ecOPT_PRI]             = _T("Invalid value for operator priority (must be greater or equal to zero).");
+    m_vErrMsg[ecBUILTIN_OVERLOAD]    = _T("Binary operator identifier conflicts with a built in operator.");
+    m_vErrMsg[ecUNEXPECTED_STR]      = _T("Unexpected string token found at position $POS$.");
+    m_vErrMsg[ecUNTERMINATED_STRING] = _T("Unterminated string starting at position $POS$.");
+    m_vErrMsg[ecSTRING_EXPECTED]     = _T("String function called with a non string type of argument.");
+    m_vErrMsg[ecVAL_EXPECTED]        = _T("String value used where a numerical argument is expected.");
+    m_vErrMsg[ecOPRT_TYPE_CONFLICT]  = _T("No suitable overload for operator \"$TOK$\" at position $POS$.");
+    m_vErrMsg[ecGENERIC]             = _T("Parser error.");
+    m_vErrMsg[ecSTR_RESULT]          = _T("Function result is a string.");
+
+    #if defined(_DEBUG)
+      for (int i=0; i<ecCOUNT; ++i)
+        if (!m_vErrMsg[i].length())
+          assert(false);
+    #endif
+  }
+
+  //---------------------------------------------------------------------------
+  //
+  //
+  //
+  //  ParserError class
+  //
+  //
+  //
+  //---------------------------------------------------------------------------
+
+  //------------------------------------------------------------------------------
+  ParserError::ParserError()
+    :m_strMsg()
+    ,m_strFormula()
+    ,m_strTok()
+    ,m_iPos(-1)
+    ,m_iErrc(ecUNDEFINED)
+    ,m_ErrMsg(ParserErrorMsg::Instance())
+  {
+  }
+
+  //------------------------------------------------------------------------------
+  /** \brief This Constructor is used for internal exceptions only. 
+      
+    It does not contain any information but the error code.
+  */
+  ParserError::ParserError(EErrorCodes /*a_iErrc*/) 
+    :m_ErrMsg(ParserErrorMsg::Instance())
+  {
+    Reset();
+    m_strMsg = _T("parser error");
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError::ParserError(const string_type &sMsg) 
+    :m_ErrMsg(ParserErrorMsg::Instance())
+  {
+    Reset();
+    m_strMsg = sMsg;
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError::ParserError( EErrorCodes a_iErrc,
+                            const string_type &sTok,
+                            const string_type &sFormula,
+                            int a_iPos )
+    :m_strMsg()
+    ,m_strFormula(sFormula)
+    ,m_strTok(sTok)
+    ,m_iPos(a_iPos)
+    ,m_iErrc(a_iErrc)
+    ,m_ErrMsg(ParserErrorMsg::Instance())
+  {
+    m_strMsg = m_ErrMsg[m_iErrc];
+    stringstream_type stream;
+    stream << (int)m_iPos;
+    ReplaceSubString(m_strMsg, _T("$POS$"), stream.str());
+    ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok);
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError::ParserError( EErrorCodes a_iErrc, int a_iPos, const string_type &sTok) 
+    :m_strMsg()
+    ,m_strFormula()
+    ,m_strTok(sTok)
+    ,m_iPos(a_iPos)
+    ,m_iErrc(a_iErrc)
+    ,m_ErrMsg(ParserErrorMsg::Instance())
+  {
+    m_strMsg = m_ErrMsg[m_iErrc];
+    stringstream_type stream;
+    stream << (int)m_iPos;
+    ReplaceSubString(m_strMsg, _T("$POS$"), stream.str());
+    ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok);
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError::ParserError( const char_type *a_szMsg, int a_iPos, const string_type &sTok) 
+    :m_strMsg(a_szMsg)
+    ,m_strFormula()
+    ,m_strTok(sTok)
+    ,m_iPos(a_iPos)
+    ,m_iErrc(ecGENERIC)
+    ,m_ErrMsg(ParserErrorMsg::Instance())
+  {
+    stringstream_type stream;
+    stream << (int)m_iPos;
+    ReplaceSubString(m_strMsg, _T("$POS$"), stream.str());
+    ReplaceSubString(m_strMsg, _T("$TOK$"), m_strTok);
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError::ParserError(const ParserError &a_Obj)
+    :m_strMsg(a_Obj.m_strMsg)
+    ,m_strFormula(a_Obj.m_strFormula)
+    ,m_strTok(a_Obj.m_strTok)
+    ,m_iPos(a_Obj.m_iPos)
+    ,m_iErrc(a_Obj.m_iErrc)
+    ,m_ErrMsg(ParserErrorMsg::Instance())
+  {
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError& ParserError::operator=(const ParserError &a_Obj)
+  {
+    if (this==&a_Obj)
+      return *this;
+
+    m_strMsg = a_Obj.m_strMsg;
+    m_strFormula = a_Obj.m_strFormula;
+    m_strTok = a_Obj.m_strTok;
+    m_iPos = a_Obj.m_iPos;
+    m_iErrc = a_Obj.m_iErrc;
+    return *this;
+  }
+
+  //------------------------------------------------------------------------------
+  ParserError::~ParserError()
+  {
+  }
+
+  /** \brief Replace all ocuurences of a substring with another string. */
+  void ParserError::ReplaceSubString( string_type &strSource,
+                                      const string_type &strFind,
+                                      const string_type &strReplaceWith)
+  {
+    string_type strResult;
+    string_type::size_type iPos(0), iNext(0);
+
+    for(;;)
+    {
+      iNext = strSource.find(strFind, iPos);
+      strResult.append(strSource, iPos, iNext-iPos);
+
+      if( iNext==string_type::npos )
+        break;
+
+      strResult.append(strReplaceWith);
+      iPos = iNext + strFind.length();
+    } 
+
+    strSource.swap(strResult);
+  }
+
+  //------------------------------------------------------------------------------
+  void ParserError::Reset()
+  {
+    m_strMsg = _T("");
+    m_strFormula = _T("");
+    m_strTok = _T("");
+    m_iPos = -1;
+    m_iErrc = ecUNDEFINED;
+  }
+      
+  //------------------------------------------------------------------------------
+  void ParserError::SetFormula(const string_type &a_strFormula)
+  {
+    m_strFormula = a_strFormula;
+  }
+
+  //------------------------------------------------------------------------------
+  const string_type& ParserError::GetExpr() const 
+  {
+    return m_strFormula;
+  }
+
+  //------------------------------------------------------------------------------
+  const string_type& ParserError::GetMsg() const
+  {
+    return m_strMsg;
+  }
+
+  //------------------------------------------------------------------------------
+  /** \brief Return the formula position related to the error. 
+
+    If the error is not related to a distinct position this will return -1
+  */
+  std::size_t ParserError::GetPos() const
+  {
+    return m_iPos;
+  }
+
+  //------------------------------------------------------------------------------
+  /** \brief Return string related with this token (if available). */
+  const string_type& ParserError::GetToken() const
+  {
+    return m_strTok;
+  }
+
+  //------------------------------------------------------------------------------
+  /** \brief Return the error code. */
+  EErrorCodes ParserError::GetCode() const
+  {
+    return m_iErrc;
+  }
+} // namespace mu
diff --git a/muparser/muParserError.h b/muparser/muParserError.h
new file mode 100644
index 0000000..c550eff
--- /dev/null
+++ b/muparser/muParserError.h
@@ -0,0 +1,160 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_ERROR_H
+#define MU_PARSER_ERROR_H
+
+#include <cassert>
+#include <stdexcept>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+#include "muParserDef.h"
+
+
+namespace mu
+{
+
+/** \brief Error codes. */
+enum EErrorCodes
+{
+  // Formula syntax errors
+  ecUNEXPECTED_OPERATOR = 0,  ///< Unexpected binary operator found
+  ecUNASSIGNABLE_TOKEN  = 1,  ///< Token cant be identified.
+  ecUNEXPECTED_EOF      = 2,  ///< Unexpected end of formula. (Example: "2+sin(")
+  ecUNEXPECTED_COMMA    = 3,  ///< An unexpected comma has been found. (Example: "1,23")
+  ecUNEXPECTED_ARG      = 4,  ///< An unexpected argument has been found
+  ecUNEXPECTED_VAL      = 5,  ///< An unexpected value token has been found
+  ecUNEXPECTED_VAR      = 6,  ///< An unexpected variable token has been found
+  ecUNEXPECTED_PARENS   = 7,  ///< Unexpected Parenthesis, opening or closing
+  ecUNEXPECTED_STR      = 8,  ///< A string has been found at an inapropriate position
+  ecSTRING_EXPECTED     = 9,  ///< A string function has been called with a different type of argument
+  ecVAL_EXPECTED        = 10, ///< A numerical function has been called with a non value type of argument
+  ecMISSING_PARENS      = 11, ///< Missing parens. (Example: "3*sin(3")
+  ecUNEXPECTED_FUN      = 12, ///< Unexpected function found. (Example: "sin(8)cos(9)")
+  ecUNTERMINATED_STRING = 13, ///< unterminated string constant. (Example: "3*valueof("hello)")
+  ecTOO_MANY_PARAMS     = 14, ///< Too many function parameters
+  ecTOO_FEW_PARAMS      = 15, ///< Too few function parameters. (Example: "ite(1<2,2)")
+  ecOPRT_TYPE_CONFLICT  = 16, ///< binary operators may only be applied to value items of the same type
+  ecSTR_RESULT          = 17, ///< result is a string
+
+  // Invalid Parser input Parameters
+  ecINVALID_NAME        = 18, ///< Invalid function, variable or constant name.
+  ecBUILTIN_OVERLOAD    = 19, ///< Trying to overload builtin operator
+  ecINVALID_FUN_PTR     = 20, ///< Invalid callback function pointer 
+  ecINVALID_VAR_PTR     = 21, ///< Invalid variable pointer 
+  ecEMPTY_EXPRESSION    = 22, ///< The Expression is empty
+  ecNAME_CONFLICT       = 23, ///< Name conflict
+  ecOPT_PRI             = 24, ///< Invalid operator priority
+  // 
+  ecDOMAIN_ERROR        = 25, ///< catch division by zero, sqrt(-1), log(0) (currently unused)
+  ecDIV_BY_ZERO         = 26, ///< Division by zero (currently unused)
+  ecGENERIC             = 27, ///< Generic error
+
+  // internal errors
+  ecINTERNAL_ERROR      = 28, ///< Internal error of any kind.
+
+  // The last two are special entries 
+  ecCOUNT,                    ///< This is no error code, It just stores just the total number of error codes
+  ecUNDEFINED           = -1  ///< Undefined message, placeholder to detect unassigned error messages
+};
+
+//---------------------------------------------------------------------------
+class ParserErrorMsg
+{
+public:
+    typedef ParserErrorMsg self_type;
+
+    ParserErrorMsg& operator=(const ParserErrorMsg &);
+    ParserErrorMsg(const ParserErrorMsg&);
+    ParserErrorMsg();
+
+   ~ParserErrorMsg();
+
+    static const ParserErrorMsg& Instance();
+    string_type operator[](unsigned a_iIdx) const;
+
+private:
+    std::vector<string_type>  m_vErrMsg;
+    static const self_type m_Instance;
+};
+
+//---------------------------------------------------------------------------
+/** \brief Error class of the parser. 
+
+  Part of the math parser package.
+
+  \author Ingo Berg
+*/
+/* final */ class ParserError
+{
+private:
+    //------------------------------------------------------------------------------
+    /** \brief Replace all ocuurences of a substring with another string. */
+    void ReplaceSubString( string_type &strSource, 
+                           const string_type &strFind,
+                           const string_type &strReplaceWith);
+    void Reset();
+
+public:
+    ParserError();
+    explicit ParserError(EErrorCodes a_iErrc);
+    explicit ParserError(const string_type &sMsg);
+    ParserError( EErrorCodes a_iErrc,
+                 const string_type &sTok,
+                 const string_type &sFormula = string_type(_T("(formula is not available)")),
+                 int a_iPos = -1);
+    ParserError( EErrorCodes a_iErrc, 
+                 int a_iPos, 
+                 const string_type &sTok);
+    ParserError( const char_type *a_szMsg, 
+                 int a_iPos = -1, 
+                 const string_type &sTok = string_type());
+    ParserError(const ParserError &a_Obj);
+    ParserError& operator=(const ParserError &a_Obj);
+   ~ParserError();
+
+    void SetFormula(const string_type &a_strFormula);
+    const string_type& GetExpr() const;
+    const string_type& GetMsg() const;
+    std::size_t GetPos() const;
+    const string_type& GetToken() const;
+    EErrorCodes GetCode() const;
+
+private:
+    string_type m_strMsg;     ///< The message string
+    string_type m_strFormula; ///< Formula string
+    string_type m_strTok;     ///< Token related with the error
+    int m_iPos;               ///< Formula position related to the error 
+    EErrorCodes m_iErrc;      ///< Error code
+    const ParserErrorMsg &m_ErrMsg;
+};		
+
+} // namespace mu
+
+#endif
+
diff --git a/muparser/muParserFixes.h b/muparser/muParserFixes.h
new file mode 100644
index 0000000..02ca007
--- /dev/null
+++ b/muparser/muParserFixes.h
@@ -0,0 +1,196 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_FIXES_H
+#define MU_PARSER_FIXES_H
+
+//
+// Compatibility fixes
+//
+
+//---------------------------------------------------------------------------
+//
+// Intel Compiler
+//
+//---------------------------------------------------------------------------
+
+#ifdef __INTEL_COMPILER
+
+// remark #981: operands are evaluated in unspecified order
+// disabled -> completely pointless if the functions do not have side effects
+//
+#pragma warning(disable:981)
+
+// remark #383: value copied to temporary, reference to temporary used
+#pragma warning(disable:383)
+
+// remark #1572: floating-point equality and inequality comparisons are unreliable
+// disabled -> everyone knows it, the parser passes this problem
+//             deliberately to the user
+#pragma warning(disable:1572)
+
+#endif
+
+
+//---------------------------------------------------------------------------
+//
+// MSVC6
+//
+//---------------------------------------------------------------------------
+
+
+#if _MSC_VER==1200
+
+/** \brief Macro to replace the MSVC6 auto_ptr with the _my_auto_ptr class.
+
+    Hijack auto_ptr and replace it with a version that actually does
+    what an auto_ptr normally does. If you use std::auto_ptr in your other code
+    it might either explode or work much better. The original crap created
+    by Microsoft, called auto_ptr and bundled with MSVC6 is not standard compliant.
+*/
+#define auto_ptr _my_auto_ptr
+
+// This is another stupidity that needs to be undone in order to de-pollute
+// the global namespace!
+#undef min
+#undef max
+
+
+namespace std
+{
+  typedef ::size_t size_t;
+
+  //---------------------------------------------------------------------------
+  /** \brief MSVC6 fix: Dummy function to put rand into namespace std.
+
+    This is a hack for MSVC6 only. It's dirty, it's ugly and it works, provided
+    inlining is enabled. Necessary because I will not pollute or change my
+    code in order to adopt it to MSVC6 interpretation of how C++ should look like!
+  */
+  inline int rand(void)
+  {
+    return ::rand();
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief MSVC6 fix: Dummy function to put strlen into namespace std.
+
+    This is a hack for MSVC6 only. It's dirty, it's ugly and it works, provided
+    inlining is enabled. Necessary because I will not pollute or change my
+    code in order to adopt it to MSVC6 interpretation of how C++ should look like!
+  */
+  inline size_t strlen(const char *szMsg)
+  {
+    return ::strlen(szMsg);
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief MSVC6 fix: Dummy function to put strncmp into namespace std.
+
+    This is a hack for MSVC6 only. It's dirty, it's ugly and it works, provided
+    inlining is enabled. Necessary because I will not pollute or change my
+    code in order to adopt it to MSVC6 interpretation of how C++ should look like!
+  */
+  inline int strncmp(const char *a, const char *b, size_t len)
+  {
+    return ::strncmp(a,b,len);
+  }
+
+  //---------------------------------------------------------------------------
+  template<typename T>
+  T max(T a, T b)
+  {
+    return (a>b) ? a : b;
+  }
+
+  //---------------------------------------------------------------------------
+  template<typename T>
+  T min(T a, T b)
+  {
+    return (a<b) ? a : b;
+  }
+
+  //---------------------------------------------------------------------------
+  /** Standard compliant auto_ptr redefinition for MSVC6.
+
+    The code is taken from VS.NET 2003, slightly modified to reduce
+    it's dependencies from other classes.
+  */
+  template<class _Ty>
+  class _my_auto_ptr
+  {
+  public:
+    typedef _Ty element_type;
+
+	  explicit _my_auto_ptr(_Ty *_Ptr = 0)
+	    :_Myptr(_Ptr)
+	  {}
+
+	  _my_auto_ptr(_my_auto_ptr<_Ty>& _Right)
+	    :_Myptr(_Right.release())
+	  {}
+
+	  template<class _Other>
+    operator _my_auto_ptr<_Other>()
+	  {
+      return (_my_auto_ptr<_Other>(*this));
+	  }
+
+	  template<class _Other>
+	  _my_auto_ptr<_Ty>& operator=(_my_auto_ptr<_Other>& _Right)
+	  {
+      reset(_Right.release());
+	    return (*this);
+	  }
+
+	 ~auto_ptr()              { delete _Myptr;    }
+	  _Ty& operator*() const  { return (*_Myptr); }
+	  _Ty *operator->() const	{ return (&**this);	}
+	  _Ty *get() const        { return (_Myptr);	}
+
+    _Ty *release()
+    {
+		  _Ty *_Tmp = _Myptr;
+		  _Myptr = 0;
+		  return (_Tmp);
+		}
+
+	  void reset(_Ty* _Ptr = 0)
+		{
+		  if (_Ptr != _Myptr)
+			  delete _Myptr;
+		  _Myptr = _Ptr;
+    }
+
+  private:
+	    _Ty *_Myptr;
+	}; // class _my_auto_ptr
+} // namespace std
+
+#endif // Microsoft Visual Studio Version 6.0
+
+#endif // include guard
+
+
diff --git a/muparser/muParserInt.cpp b/muparser/muParserInt.cpp
new file mode 100644
index 0000000..1b072bc
--- /dev/null
+++ b/muparser/muParserInt.cpp
@@ -0,0 +1,264 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#include "muParserInt.h"
+
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+
+using namespace std;
+
+
+/** \brief Namespace for mathematical applications. */
+namespace mu
+{
+
+value_type ParserInt::Abs(value_type v)  { return  Round(fabs(v)); }
+value_type ParserInt::Sign(value_type v) { return (Round(v)<0) ? -1 : (Round(v)>0) ? 1 : 0; }
+value_type ParserInt::Ite(value_type v1, 
+                          value_type v2, 
+                          value_type v3) { return (Round(v1)==1) ? Round(v2) : Round(v3); }
+value_type ParserInt::Add(value_type v1, value_type v2) { return Round(v1)  + Round(v2); }
+value_type ParserInt::Sub(value_type v1, value_type v2) { return Round(v1)  - Round(v2); }
+value_type ParserInt::Mul(value_type v1, value_type v2) { return Round(v1)  * Round(v2); }
+value_type ParserInt::Div(value_type v1, value_type v2) { return Round(v1)  / Round(v2); }
+value_type ParserInt::Mod(value_type v1, value_type v2) { return Round(v1)  % Round(v2); }
+value_type ParserInt::Shr(value_type v1, value_type v2) { return Round(v1) >> Round(v2); }
+value_type ParserInt::Shl(value_type v1, value_type v2) { return Round(v1) << Round(v2); }
+value_type ParserInt::LogAnd(value_type v1, value_type v2) { return Round(v1) & Round(v2); }
+value_type ParserInt::LogOr(value_type v1, value_type v2)  { return Round(v1) | Round(v2); }
+value_type ParserInt::LogXor(value_type v1, value_type v2) { return Round(v1) ^ Round(v2); }
+value_type ParserInt::And(value_type v1, value_type v2) { return Round(v1) && Round(v2); }
+value_type ParserInt::Or(value_type v1, value_type v2)  { return Round(v1) || Round(v2); }
+value_type ParserInt::Less(value_type v1, value_type v2)      { return Round(v1)  < Round(v2); }
+value_type ParserInt::Greater(value_type v1, value_type v2)   { return Round(v1)  > Round(v2); }
+value_type ParserInt::LessEq(value_type v1, value_type v2)    { return Round(v1) <= Round(v2); }
+value_type ParserInt::GreaterEq(value_type v1, value_type v2) { return Round(v1) >= Round(v2); }
+value_type ParserInt::Equal(value_type v1, value_type v2)     { return Round(v1) == Round(v2); }
+value_type ParserInt::NotEqual(value_type v1, value_type v2)  { return Round(v1) != Round(v2); }
+value_type ParserInt::Not(value_type v) { return !Round(v); }
+
+//---------------------------------------------------------------------------
+// Unary operator Callbacks: Infix operators
+value_type ParserInt::UnaryMinus(value_type v) 
+{ 
+  return -Round(v); 
+}
+
+//---------------------------------------------------------------------------
+value_type ParserInt::Sum(const value_type* a_afArg, int a_iArgc)
+{ 
+  if (!a_iArgc)	
+    throw ParserError(_T("too few arguments for function sum."));
+
+  value_type fRes=0;
+  for (int i=0; i<a_iArgc; ++i) 
+    fRes += a_afArg[i];
+
+  return fRes;
+}
+
+//---------------------------------------------------------------------------
+value_type ParserInt::Min(const value_type* a_afArg, int a_iArgc)
+{ 
+    if (!a_iArgc)	
+        throw ParserError( _T("too few arguments for function min.") );
+
+    value_type fRes=a_afArg[0];
+    for (int i=0; i<a_iArgc; ++i) 
+      fRes = std::min(fRes, a_afArg[i]);
+
+    return fRes;
+}
+
+//---------------------------------------------------------------------------
+value_type ParserInt::Max(const value_type* a_afArg, int a_iArgc)
+{ 
+    if (!a_iArgc)	
+        throw ParserError(_T("too few arguments for function min."));
+
+    value_type fRes=a_afArg[0];
+    for (int i=0; i<a_iArgc; ++i) 
+      fRes = std::max(fRes, a_afArg[i]);
+
+    return fRes;
+}
+
+//---------------------------------------------------------------------------
+// Default value recognition callback
+bool ParserInt::IsVal(const char_type *a_szExpr, int &a_iPos, value_type &a_fVal)
+{
+  stringstream_type stream(a_szExpr);
+  int iVal(0);
+
+  stream >> iVal;
+  int iEnd = stream.tellg();   // Position after reading
+
+  if (iEnd==-1)
+    return false;
+
+  a_iPos += iEnd;
+  a_fVal = (value_type)iVal;
+  return true;
+}
+
+//---------------------------------------------------------------------------
+bool ParserInt::IsHexVal(const char_type *a_szExpr, int &a_iPos, value_type &a_fVal)
+{
+  if (a_szExpr[0]!='$') 
+    return false;
+
+  unsigned iVal(0);
+
+// New code based on streams for UNICODE compliance:
+  stringstream_type::pos_type nPos(0);
+  stringstream_type ss(a_szExpr+1);
+  ss >> std::hex >> iVal;
+  nPos = ss.tellg();
+
+  if (nPos==(stringstream_type::pos_type)0)
+    return false;
+
+  a_iPos += 1 + nPos;
+  
+/*
+  // original code based on sscanf. Working but not UNICODE compliant!
+  int iLen(0);
+  if (sscanf(a_szExpr+1, "%x%n", &iVal, &iLen)==0)
+    return false;
+
+  a_iPos += iLen+1;
+*/
+
+  a_fVal = iVal;
+  return true;
+}
+
+//---------------------------------------------------------------------------
+bool ParserInt::IsBinVal(const char_type *a_szExpr, int &a_iPos, value_type &a_fVal)
+{
+  if (a_szExpr[0]!='#') 
+    return false;
+
+  unsigned iVal(0), 
+           iBits(sizeof(iVal)*8),
+           i(0);
+
+  for (i=0; (a_szExpr[i+1]=='0' || a_szExpr[i+1]=='1') && i<iBits; ++i)
+    iVal |= (int)(a_szExpr[i+1]=='1') << ((iBits-1)-i);
+
+  if (i==0) 
+    return false;
+
+  if (i==iBits)
+    throw exception_type(_T("Binary to integer conversion error (overflow)."));
+
+  a_fVal = (unsigned)(iVal >> (iBits-i) );
+  a_iPos += i+1;
+
+  return true;
+}
+
+//---------------------------------------------------------------------------
+/** \brief Constructor. 
+
+  Call ParserBase class constructor and trigger Function, Operator and Constant initialization.
+*/
+ParserInt::ParserInt()
+:ParserBase()
+{
+  AddValIdent(IsVal);
+  AddValIdent(IsHexVal);
+  AddValIdent(IsBinVal);
+
+  InitCharSets();
+  InitFun();
+  InitOprt();
+}
+
+//---------------------------------------------------------------------------
+void ParserInt::InitConst()
+{
+}
+
+//---------------------------------------------------------------------------
+void ParserInt::InitCharSets()
+{
+  DefineNameChars( _T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") );
+  DefineOprtChars( _T("+-*^/?<>=!%&|~'_") );
+  DefineInfixOprtChars( _T("/+-*^?<>=!%&|~'_") );
+}
+
+//---------------------------------------------------------------------------
+/** \brief Initialize the default functions. */
+void ParserInt::InitFun()
+{
+  DefineFun( _T("sign"), Sign);
+  DefineFun( _T("abs"), Abs);
+  DefineFun( _T("if"), Ite);
+  DefineFun( _T("sum"), Sum);
+  DefineFun( _T("min"), Min);
+  DefineFun( _T("max"), Max);
+}
+
+//---------------------------------------------------------------------------
+/** \brief Initialize operators. */
+void ParserInt::InitOprt()
+{
+  // disable all built in operators, not all of them usefull for integer numbers
+  // (they don't do rounding of values)
+  EnableBuiltInOprt(false);
+
+  // Disable all built in operators, they wont work with integer numbers
+  // since they are designed for floating point numbers
+  DefineInfixOprt( _T("-"), UnaryMinus);
+  DefineInfixOprt( _T("!"), Not);
+
+  DefineOprt( _T("&"), LogAnd, prLOGIC);
+  DefineOprt( _T("|"), LogOr, prLOGIC);
+  DefineOprt( _T("^"), LogXor, prLOGIC);
+  DefineOprt( _T("&&"), And, prLOGIC);
+  DefineOprt( _T("||"), Or, prLOGIC);
+
+  DefineOprt( _T("<"), Less, prCMP);
+  DefineOprt( _T(">"), Greater, prCMP);
+  DefineOprt( _T("<="), LessEq, prCMP);
+  DefineOprt( _T(">="), GreaterEq, prCMP);
+  DefineOprt( _T("=="), Equal, prCMP);
+  DefineOprt( _T("!="), NotEqual, prCMP);
+
+  DefineOprt( _T("+"), Add, prADD_SUB);
+  DefineOprt( _T("-"), Sub, prADD_SUB);
+
+  DefineOprt( _T("*"), Mul, prMUL_DIV);
+  DefineOprt( _T("/"), Div, prMUL_DIV);
+  DefineOprt( _T("%"), Mod, prMUL_DIV);
+
+  DefineOprt( _T(">>"), Shr, prMUL_DIV+1);
+  DefineOprt( _T("<<"), Shl, prMUL_DIV+1);
+}
+
+} // namespace mu
diff --git a/muparser/muParserInt.h b/muparser/muParserInt.h
new file mode 100644
index 0000000..008792d
--- /dev/null
+++ b/muparser/muParserInt.h
@@ -0,0 +1,93 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_INT_H
+#define MU_PARSER_INT_H
+
+#include "muParserBase.h"
+#include <vector>
+
+
+namespace mu
+{
+
+/** \brief Mathematical expressions parser.
+  
+  This version of the parser handles only integer numbers. It disables the built in operators thus it is 
+  slower than muParser. Integer values are stored in the double value_type and converted if needed.
+*/
+class ParserInt : public ParserBase
+{
+private:
+    static int  Round(value_type v) { return (int)(v + ((v>=0) ? 0.5 : -0.5) ); };
+  
+    static value_type  Abs(value_type);
+	  static value_type  Sign(value_type);
+    static value_type  Ite(value_type, value_type, value_type);
+    // !! The unary Minus is a MUST, otherwise you cant use negative signs !!
+    static value_type  UnaryMinus(value_type);
+    // Functions with variable number of arguments
+    static value_type  Sum(const value_type* a_afArg, int a_iArgc);  // sum
+    static value_type  Min(const value_type* a_afArg, int a_iArgc);  // minimum
+    static value_type  Max(const value_type* a_afArg, int a_iArgc);  // maximum
+    // binary operator callbacks
+    static value_type  Add(value_type v1, value_type v2);
+    static value_type  Sub(value_type v1, value_type v2);
+    static value_type  Mul(value_type v1, value_type v2);
+    static value_type  Div(value_type v1, value_type v2);
+    static value_type  Mod(value_type v1, value_type v2);
+    static value_type  Shr(value_type v1, value_type v2);
+    static value_type  Shl(value_type v1, value_type v2);
+    static value_type  LogAnd(value_type v1, value_type v2);
+    static value_type  LogOr(value_type v1, value_type v2);
+    static value_type  LogXor(value_type v1, value_type v2);
+    static value_type  And(value_type v1, value_type v2);
+    static value_type  Or(value_type v1, value_type v2);
+    static value_type  Xor(value_type v1, value_type v2);
+    static value_type  Less(value_type v1, value_type v2);
+    static value_type  Greater(value_type v1, value_type v2);
+    static value_type  LessEq(value_type v1, value_type v2);
+    static value_type  GreaterEq(value_type v1, value_type v2);
+    static value_type  Equal(value_type v1, value_type v2);
+    static value_type  NotEqual(value_type v1, value_type v2);
+    static value_type  Not(value_type v1);
+
+    static bool IsHexVal(const char_type *a_szExpr, int &a_iPos, value_type &a_iVal);
+    static bool IsBinVal(const char_type *a_szExpr, int &a_iPos, value_type &a_iVal);
+    static bool IsVal(const char_type *a_szExpr, int &a_iPos, value_type &a_iVal);
+
+public:
+    ParserInt();
+
+    virtual void InitFun();
+	  virtual void InitOprt();
+    virtual void InitConst();
+    virtual void InitCharSets();
+};
+
+} // namespace mu
+
+#endif
+
diff --git a/muparser/muParserStack.h b/muparser/muParserStack.h
new file mode 100644
index 0000000..e035582
--- /dev/null
+++ b/muparser/muParserStack.h
@@ -0,0 +1,120 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_STACK_H
+#define MU_PARSER_STACK_H
+
+#include <cassert>
+#include <string>
+#include <stack>
+#include <vector>
+
+#include "muParserError.h"
+#include "muParserToken.h"
+
+
+namespace mu
+{
+
+  /** \brief Parser stack implementation. 
+
+  Stack implementation based on a std::stack. The behaviour of pop() had been
+  slightly changed in order to get an error code if the stack is empty.
+  The stack is used within the Parser both as a value stack and as an operator stack.
+
+  \author (C) 2004, 2005 Ingo Berg 
+  */
+  template <typename TValueType>
+  class ParserStack 
+  {
+    private:
+      /** \brief Type of the underlying stack implementation. */
+      typedef std::stack<TValueType, std::vector<TValueType> > impl_type;
+      impl_type m_Stack;
+
+    public:	
+  	 
+      //---------------------------------------------------------------------------
+      ParserStack()
+        :m_Stack()
+      {}
+
+      //---------------------------------------------------------------------------
+      virtual ~ParserStack()
+      {}
+
+      //---------------------------------------------------------------------------
+      /** \brief Pop a value from the stack.
+       
+        Unlike the standard implementation this function will return the value that
+        is going to be taken from the stack.
+
+        \throw ParserException in case the stack is empty.
+        \sa pop(int &a_iErrc)
+      */
+	    TValueType pop()
+      {
+        if (empty())
+          throw ParserError( _T("stack is empty.") );
+
+        TValueType el = top();
+        m_Stack.pop();
+        return el;
+      }
+
+      /** \brief Push an object into the stack. 
+
+          \param a_Val object to push into the stack.
+          \throw nothrow
+      */
+      void push(const TValueType& a_Val) 
+      { 
+        m_Stack.push(a_Val); 
+      }
+
+      /** \brief Return the number of stored elements. */
+      unsigned size() const
+      { 
+        return (unsigned)m_Stack.size(); 
+      }
+
+      /** \brief Returns true if stack is empty false otherwise. */
+      bool empty() const
+      {
+        return m_Stack.size()==0; 
+      }
+       
+      /** \brief Return reference to the top object in the stack. 
+       
+          The top object is the one pushed most recently.
+      */
+      TValueType& top() 
+      { 
+        return m_Stack.top(); 
+      }
+  };
+} // namespace MathUtils
+
+#endif
diff --git a/muparser/muParserTest.cpp b/muparser/muParserTest.cpp
new file mode 100644
index 0000000..eed6cc4
--- /dev/null
+++ b/muparser/muParserTest.cpp
@@ -0,0 +1,1125 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#include "muParserTest.h"
+
+#include <cstdio>
+#include <cmath>
+#include <iostream>
+
+#define PARSER_CONST_PI  3.141592653589793238462643
+#define PARSER_CONST_E   2.718281828459045235360287
+
+using namespace std;
+
+
+namespace mu
+{
+  namespace Test
+  {
+    int ParserTester::c_iCount = 0;
+
+    //---------------------------------------------------------------------------
+    ParserTester::ParserTester()
+      :m_vTestFun()
+    {
+      AddTest(&ParserTester::TestNames);
+      AddTest(&ParserTester::TestSyntax);
+      AddTest(&ParserTester::TestPostFix);
+      AddTest(&ParserTester::TestInfixOprt);
+      AddTest(&ParserTester::TestVarConst);
+      AddTest(&ParserTester::TestVolatile);
+      AddTest(&ParserTester::TestMultiArg);
+      AddTest(&ParserTester::TestFormula);
+      AddTest(&ParserTester::TestInterface);
+      AddTest(&ParserTester::TestBinOprt);
+      AddTest(&ParserTester::TestException);
+      AddTest(&ParserTester::TestStrArg);
+
+      ParserTester::c_iCount = 0;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestInterface()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing member functions...");
+   
+      // Test RemoveVar
+      value_type afVal[3] = {1,2,3};
+      Parser p;
+  
+      try
+      {
+        p.DefineVar( _T("a"), &afVal[0]);
+        p.DefineVar( _T("b"), &afVal[1]);
+        p.DefineVar( _T("c"), &afVal[2]);
+        p.SetExpr( _T("a+b+c") );
+        p.Eval();
+      }
+      catch(...)
+      {
+        iStat += 1;  // this is not supposed to happen 
+      }
+
+      try
+      {
+        p.RemoveVar( _T("c") );
+        p.Eval();
+        iStat += 1;  // not supposed to reach this, nonexisting variable "c" deleted...
+      }
+      catch(...)
+      {
+        // failure is expected...
+      }
+
+      if (iStat==0) 
+        mu::console() << _T("passed") << endl;
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestStrArg()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing string arguments...");
+ 
+      iStat += EqnTest(_T("valueof(\"aaa\")+valueof(\"bbb\")  "), 246, true);
+      iStat += EqnTest(_T("2*(valueof(\"aaa\")-23)+valueof(\"bbb\")"), 323, true);
+      // use in expressions with variables
+      iStat += EqnTest(_T("a*(atof(\"10\")-b)"), 8, true);
+      iStat += EqnTest(_T("a-(atof(\"10\")*b)"), -19, true);
+      // string + numeric arguments
+      iStat += EqnTest(_T("strfun1(\"100\")"), 100, true);
+      iStat += EqnTest(_T("strfun2(\"100\",1)"), 101, true);
+      iStat += EqnTest(_T("strfun3(\"99\",1,2)"), 102, true);
+
+      if (iStat==0)
+        mu::console() << _T("passed") << endl;
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestBinOprt()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing binary operators...");
+   
+      // built in operators
+      // xor operator
+      iStat += EqnTest(_T("1 xor 2"), 3, true); 
+      iStat += EqnTest(_T("a xor b"), 3, true);            // with a=1 and b=2
+      iStat += EqnTest(_T("1 xor 2 xor 3"), 0, true); 
+      iStat += EqnTest(_T("a xor b xor 3"), 0, true);      // with a=1 and b=2
+      iStat += EqnTest(_T("a xor b xor c"), 0, true);      // with a=1 and b=2
+      iStat += EqnTest(_T("(1 xor 2) xor 3"), 0, true); 
+      iStat += EqnTest(_T("(a xor b) xor c"), 0, true);    // with a=1 and b=2
+      iStat += EqnTest(_T("(a) xor (b) xor c"), 0, true);  // with a=1 and b=2
+      iStat += EqnTest(_T("1 or 2"), 3, true); 
+      iStat += EqnTest(_T("a or b"), 3, true);             // with a=1 and b=2
+
+      // Assignement operator
+      iStat += EqnTest(_T("a = b"), 2, true); 
+      iStat += EqnTest(_T("a = sin(b)"), 0.909297, true); 
+      iStat += EqnTest(_T("a = 1+sin(b)"), 1.909297, true); 
+
+      // Test user defined binary operators
+      iStat += EqnTestInt(_T("1 | 2"), 3, true);          
+      iStat += EqnTestInt(_T("1 || 2"), 1, true);          
+      iStat += EqnTestInt(_T("123 & 456"), 72, true);          
+      iStat += EqnTestInt(_T("(123 & 456) % 10"), 2, true);
+      iStat += EqnTestInt(_T("1 && 0"), 0, true);          
+      iStat += EqnTestInt(_T("123 && 456"), 1, true);          
+      iStat += EqnTestInt(_T("1 << 3"), 8, true);          
+      iStat += EqnTestInt(_T("8 >> 3"), 1, true);          
+      iStat += EqnTestInt(_T("10 ^ 10"), 0, true);          
+      iStat += EqnTestInt(_T("10 * 10 ^ 99"), 7, true);          
+      iStat += EqnTestInt(_T("9 / 4"), 2, true);  
+      iStat += EqnTestInt(_T("9 % 4"), 1, true);  
+      iStat += EqnTestInt(_T("if(5%2,1,0)"), 1, true);
+      iStat += EqnTestInt(_T("if(4%2,1,0)"), 0, true);
+      iStat += EqnTestInt(_T("-10+1"), -9, true);
+      iStat += EqnTestInt(_T("1+2*3"), 7, true);
+      iStat += EqnTestInt(_T("const1 != const2"), 1, true);
+      iStat += EqnTestInt(_T("const1 != const2"), 0, false);
+      iStat += EqnTestInt(_T("const1 == const2"), 0, true);
+      iStat += EqnTestInt(_T("const1 == 1"), 1, true);
+      iStat += EqnTestInt(_T("10*(const1 == 1)"), 10, true);
+      iStat += EqnTestInt(_T("2*(const1 | const2)"), 6, true);
+      iStat += EqnTestInt(_T("2*(const1 | const2)"), 7, false);
+      iStat += EqnTestInt(_T("const1 < const2"), 1, true);
+      iStat += EqnTestInt(_T("const2 > const1"), 1, true);
+      iStat += EqnTestInt(_T("const1 <= 1"), 1, true);
+      iStat += EqnTestInt(_T("const2 >= 2"), 1, true);
+      iStat += EqnTestInt(_T("2*(const1 + const2)"), 6, true);
+      iStat += EqnTestInt(_T("2*(const1 - const2)"), -2, true);
+
+      iStat += EqnTestInt(_T("a != b"), 1, true);
+      iStat += EqnTestInt(_T("a != b"), 0, false);
+      iStat += EqnTestInt(_T("a == b"), 0, true);
+      iStat += EqnTestInt(_T("a == 1"), 1, true);
+      iStat += EqnTestInt(_T("10*(a == 1)"), 10, true);
+      iStat += EqnTestInt(_T("2*(a | b)"), 6, true);
+      iStat += EqnTestInt(_T("2*(a | b)"), 7, false);
+      iStat += EqnTestInt(_T("a < b"), 1, true);
+      iStat += EqnTestInt(_T("b > a"), 1, true);
+      iStat += EqnTestInt(_T("a <= 1"), 1, true);
+      iStat += EqnTestInt(_T("b >= 2"), 1, true);
+      iStat += EqnTestInt(_T("2*(a + b)"), 6, true);
+      iStat += EqnTestInt(_T("2*(a - b)"), -2, true);
+      iStat += EqnTestInt(_T("a + (a << b)"), 5, true);
+      iStat += EqnTestInt(_T("-2^2"), -4, true);
+// incorrect: '^' is yor here, not power
+//    iStat += EqnTestInt("-(1+2)^2", -9, true);
+//    iStat += EqnTestInt("-1^3", -1, true);          
+
+      // Test precedence
+      // a=1, b=2, c=3
+      iStat += EqnTestInt(_T("a + b * c"), 7, true);
+      iStat += EqnTestInt(_T("a * b + c"), 5, true);
+      iStat += EqnTestInt(_T("a<b && b>10"), 0, true);
+      iStat += EqnTestInt(_T("a<b && b<10"), 1, true);
+
+      iStat += EqnTestInt(_T("a + b << c"), 17, true);
+      iStat += EqnTestInt(_T("a << b + c"), 7, true);
+      iStat += EqnTestInt(_T("c * b < a"), 0, true);
+      iStat += EqnTestInt(_T("c * b == 6 * a"), 1, true);
+
+      if (iStat==0)
+        mu::console() << _T("passed") << endl;
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Check muParser name restriction enforcement. */
+    int ParserTester::TestNames()
+    {
+      int  iStat= 0,
+           iErr = 0;
+
+     mu::console() << "testing name restriction enforcement...";
+    
+      Parser p;
+
+  #define PARSER_THROWCHECK(DOMAIN, FAIL, EXPR, ARG) \
+      iErr = 0;                                      \
+      ParserTester::c_iCount++;                      \
+      try                                            \
+      {                                              \
+        p.Define##DOMAIN(EXPR, ARG);                 \
+      }                                              \
+      catch(Parser::exception_type&)                 \
+      {                                              \
+        iErr = (FAIL==false) ? 0 : 1;                \
+      }                                              \
+      iStat += iErr;      
+      
+      // constant names
+      PARSER_THROWCHECK(Const, false, _T("0a"), 1)
+      PARSER_THROWCHECK(Const, false, _T("9a"), 1)
+      PARSER_THROWCHECK(Const, false, _T("+a"), 1)
+      PARSER_THROWCHECK(Const, false, _T("-a"), 1)
+      PARSER_THROWCHECK(Const, false, _T("a-"), 1)
+      PARSER_THROWCHECK(Const, false, _T("a*"), 1)
+      PARSER_THROWCHECK(Const, false, _T("a?"), 1)
+      PARSER_THROWCHECK(Const, true, _T("a"), 1)
+      PARSER_THROWCHECK(Const, true, _T("a_min"), 1)
+      PARSER_THROWCHECK(Const, true, _T("a_min0"), 1)
+      PARSER_THROWCHECK(Const, true, _T("a_min9"), 1)
+      // variable names
+      value_type a;
+      p.ClearConst();
+      PARSER_THROWCHECK(Var, false, _T("123abc"), &a)
+      PARSER_THROWCHECK(Var, false, _T("9a"), &a)
+      PARSER_THROWCHECK(Var, false, _T("0a"), &a)
+      PARSER_THROWCHECK(Var, false, _T("+a"), &a)
+      PARSER_THROWCHECK(Var, false, _T("-a"), &a)
+      PARSER_THROWCHECK(Var, false, _T("?a"), &a)
+      PARSER_THROWCHECK(Var, false, _T("!a"), &a)
+      PARSER_THROWCHECK(Var, false, _T("a+"), &a)
+      PARSER_THROWCHECK(Var, false, _T("a-"), &a)
+      PARSER_THROWCHECK(Var, false, _T("a*"), &a)
+      PARSER_THROWCHECK(Var, false, _T("a?"), &a)
+      PARSER_THROWCHECK(Var, true, _T("a"), &a)
+      PARSER_THROWCHECK(Var, true, _T("a_min"), &a)
+      PARSER_THROWCHECK(Var, true, _T("a_min0"), &a)
+      PARSER_THROWCHECK(Var, true, _T("a_min9"), &a)
+      PARSER_THROWCHECK(Var, false, _T("a_min9"), 0)
+      // Postfix operators
+      // fail
+      PARSER_THROWCHECK(PostfixOprt, false, _T("(k"), f1of1)
+      PARSER_THROWCHECK(PostfixOprt, false, _T("9+"), f1of1)
+      PARSER_THROWCHECK(PostfixOprt, false, _T("+"), 0)
+      // pass
+      PARSER_THROWCHECK(PostfixOprt, true, _T("-a"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("?a"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("_"),   f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("#"),   f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("&&"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("||"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("&"),   f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("|"),   f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("++"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("--"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("?>"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("?<"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("**"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("xor"), f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("and"), f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("or"),  f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("not"), f1of1)
+      PARSER_THROWCHECK(PostfixOprt, true, _T("!"),   f1of1)
+      // Binary operator
+      // The following must fail with builtin operators activated
+      // p.EnableBuiltInOp(true); -> this is the default
+      PARSER_THROWCHECK(Oprt, false, _T("+"),  f1of2)
+      PARSER_THROWCHECK(Oprt, false, _T("-"),  f1of2)
+      PARSER_THROWCHECK(Oprt, false, _T("*"),  f1of2)
+      PARSER_THROWCHECK(Oprt, false, _T("/"),  f1of2)
+      // without activated built in operators it should work
+      p.EnableBuiltInOprt(false);
+      PARSER_THROWCHECK(Oprt, true, _T("+"),  f1of2)
+      PARSER_THROWCHECK(Oprt, true, _T("-"),  f1of2)
+      PARSER_THROWCHECK(Oprt, true, _T("*"),  f1of2)
+      PARSER_THROWCHECK(Oprt, true, _T("/"),  f1of2)
+  #undef PARSER_THROWCHECK
+
+      if (iStat==0) 
+        mu::console() << _T("passed") << endl;
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestSyntax()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing syntax engine...");
+
+      iStat += EqnTest(_T("(1+ 2*a)"), 3, true);   // Spaces within formula
+      iStat += EqnTest(_T("(2+"), 0, false);       // missing closing bracket 
+      iStat += EqnTest(_T("2++4"), 0, false);      // unexpected operator
+      iStat += EqnTest(_T("2+-4"), 0, false);      // unexpected operator
+      iStat += EqnTest(_T("(2+)"), 0, false);      // unexpected closing bracket
+      iStat += EqnTest(_T("--2"), 0, false);       // double sign
+      iStat += EqnTest(_T("ksdfj"), 0, false);     // unknown token
+      iStat += EqnTest(_T("()"), 0, false);        // empty bracket
+      iStat += EqnTest(_T("sin(cos)"), 0, false);  // unexpected function
+      iStat += EqnTest(_T("5t6"), 0, false);       // unknown token
+      iStat += EqnTest(_T("5 t 6"), 0, false);     // unknown token
+      iStat += EqnTest(_T("8*"), 0, false);        // unexpected end of formula
+      iStat += EqnTest(_T(",3"), 0, false);        // unexpected comma
+      iStat += EqnTest(_T("3,5"), 0, false);       // unexpected comma
+      iStat += EqnTest(_T("sin(8,8)"), 0, false);  // too many function args
+      iStat += EqnTest(_T("(7,8)"), 0, false);     // too many function args
+      iStat += EqnTest(_T("sin)"), 0, false);      // unexpected closing bracket
+      iStat += EqnTest(_T("a)"), 0, false);        // unexpected closing bracket
+      iStat += EqnTest(_T("pi)"), 0, false);       // unexpected closing bracket
+      iStat += EqnTest(_T("sin(())"), 0, false);   // unexpected closing bracket
+      iStat += EqnTest(_T("sin()"), 0, false);     // unexpected closing bracket
+
+      if (iStat==0)
+        mu::console() << _T("passed") << endl;
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestVarConst()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing variable/constant name recognition...");
+
+      // distinguish constants with same basename
+      iStat += EqnTest( _T("const"), 1, true);
+      iStat += EqnTest( _T("const1"), 2, true);
+      iStat += EqnTest( _T("const2"), 3, true);
+      iStat += EqnTest( _T("2*const"), 2, true);
+      iStat += EqnTest( _T("2*const1"), 4, true);
+      iStat += EqnTest( _T("2*const2"), 6, true);
+      iStat += EqnTest( _T("2*const+1"), 3, true);
+      iStat += EqnTest( _T("2*const1+1"), 5, true);
+      iStat += EqnTest( _T("2*const2+1"), 7, true);
+      iStat += EqnTest( _T("const"), 0, false);
+      iStat += EqnTest( _T("const1"), 0, false);
+      iStat += EqnTest( _T("const2"), 0, false);
+
+      // distinguish variables with same basename
+      iStat += EqnTest( _T("a"), 1, true);
+      iStat += EqnTest( _T("aa"), 2, true);
+      iStat += EqnTest( _T("2*a"), 2, true);
+      iStat += EqnTest( _T("2*aa"), 4, true);
+      iStat += EqnTest( _T("2*a-1"), 1, true);
+      iStat += EqnTest( _T("2*aa-1"), 3, true);
+
+      // Finally test querying of used variables
+      try
+      {
+        int idx;
+        mu::Parser p;
+        mu::value_type vVarVal[] = { 1, 2, 3, 4, 5};
+        p.DefineVar( _T("a"), &vVarVal[0]);
+        p.DefineVar( _T("b"), &vVarVal[1]);
+        p.DefineVar( _T("c"), &vVarVal[2]);
+        p.DefineVar( _T("d"), &vVarVal[3]);
+        p.DefineVar( _T("e"), &vVarVal[4]);
+
+        // Test lookup of defined variables
+        // 4 used variables
+        p.SetExpr( _T("a+b+c+d") );
+        mu::varmap_type UsedVar = p.GetUsedVar();
+        int iCount = (int)UsedVar.size();
+        if (iCount!=4) throw false;
+
+        mu::varmap_type::const_iterator item = UsedVar.begin();
+        for (idx=0; item!=UsedVar.end(); ++item)
+        {
+          if (&vVarVal[idx++]!=item->second) 
+            throw false;
+        }
+
+        // Test lookup of undefined variables
+        p.SetExpr( _T("undef1+undef2+undef3") );
+        UsedVar = p.GetUsedVar();
+        iCount = (int)UsedVar.size();
+        if (iCount!=3) throw false;
+
+        for (item = UsedVar.begin(); item!=UsedVar.end(); ++item)
+        {
+          if (item->second!=0) 
+            throw false; // all pointers to undefined variables must be null
+        }
+
+        // 1 used variables
+        p.SetExpr( _T("a+b") );
+        UsedVar = p.GetUsedVar();
+        iCount = (int)UsedVar.size();
+        if (iCount!=2) throw false;
+        item = UsedVar.begin();
+        for (idx=0; item!=UsedVar.end(); ++item)
+          if (&vVarVal[idx++]!=item->second) throw false;
+
+      }
+      catch(...)
+      {
+        iStat += 1;
+      }
+
+      if (iStat==0)  
+        mu::console() << _T("passed") << endl;
+      else
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestMultiArg()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing multiarg functions...");
+    
+      // picking the right argument
+      iStat += EqnTest( _T("f1of1(1)"), 1, true);
+      iStat += EqnTest( _T("f1of2(1, 2)"), 1, true);
+      iStat += EqnTest( _T("f2of2(1, 2)"), 2, true);
+      iStat += EqnTest( _T("f1of3(1, 2, 3)"), 1, true);
+      iStat += EqnTest( _T("f2of3(1, 2, 3)"), 2, true);
+      iStat += EqnTest( _T("f3of3(1, 2, 3)"), 3, true);
+      iStat += EqnTest( _T("f1of4(1, 2, 3, 4)"), 1, true);
+      iStat += EqnTest( _T("f2of4(1, 2, 3, 4)"), 2, true);
+      iStat += EqnTest( _T("f3of4(1, 2, 3, 4)"), 3, true);
+      iStat += EqnTest( _T("f4of4(1, 2, 3, 4)"), 4, true);
+      iStat += EqnTest( _T("f1of5(1, 2, 3, 4, 5)"), 1, true);
+      iStat += EqnTest( _T("f2of5(1, 2, 3, 4, 5)"), 2, true);
+      iStat += EqnTest( _T("f3of5(1, 2, 3, 4, 5)"), 3, true);
+      iStat += EqnTest( _T("f4of5(1, 2, 3, 4, 5)"), 4, true);
+      iStat += EqnTest( _T("f5of5(1, 2, 3, 4, 5)"), 5, true);
+      // Too few arguments / Too many arguments
+      iStat += EqnTest( _T("f1of1(1,2)"), 0, false);
+      iStat += EqnTest( _T("f1of1()"), 0, false);
+      iStat += EqnTest( _T("f1of2(1, 2, 3)"), 0, false);
+      iStat += EqnTest( _T("f1of2(1)"), 0, false);
+      iStat += EqnTest( _T("f1of3(1, 2, 3, 4)"), 0, false);
+      iStat += EqnTest( _T("f1of3(1)"), 0, false);
+      iStat += EqnTest( _T("f1of4(1, 2, 3, 4, 5)"), 0, false);
+      iStat += EqnTest( _T("f1of4(1)"), 0, false);
+      iStat += EqnTest( _T("(1,2,3)"), 0, false);
+      iStat += EqnTest( _T("1,2,3"), 0, false);
+      iStat += EqnTest( _T("(1*a,2,3)"), 0, false);
+      iStat += EqnTest( _T("1,2*a,3"), 0, false);
+     
+      // correct calculation of arguments
+      iStat += EqnTest( _T("min(a, 1)"),  1, true);
+      iStat += EqnTest( _T("min(3*2, 1)"),  1, true);
+      iStat += EqnTest( _T("min(3*2, 1)"),  6, false);
+      // correct calculation of arguments
+      iStat += EqnTest( _T("min(3*a+1, 1)"),  1, true);
+      iStat += EqnTest( _T("max(3*a+1, 1)"),  4, true);
+      iStat += EqnTest( _T("max(3*a+1, 1)*2"),  8, true);
+      iStat += EqnTest( _T("2*max(3*a+1, 1)+2"),  10, true);
+
+      // functions with Variable argument count
+      iStat += EqnTest( _T("sum(1,2,3)"),  6, true);
+      iStat += EqnTest( _T("2*sum(1,2,3)"),  12, true);
+      iStat += EqnTest( _T("2*sum(1,2,3)+2"),  14, true);
+      iStat += EqnTest( _T("2*sum(-1,2,3)+2"),  10, true);
+      iStat += EqnTest( _T("2*sum(-1,2,-(-a))+2"),  6, true);
+      iStat += EqnTest( _T("2*sum(-1,10,-a)+2"),  18, true);
+      iStat += EqnTest( _T("2*sum(1,2,3)*2"),  24, true);
+      iStat += EqnTest( _T("sum(1,-max(1,2),3)*2"),  4, true);
+      iStat += EqnTest( _T("sum(1*3, 4, a+2)"),  10, true);
+      iStat += EqnTest( _T("sum(1*3, 2*sum(1,2,2), a+2)"),  16, true);
+      iStat += EqnTest( _T("sum(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2)"), 24, true);
+
+      // some failures
+      iStat += EqnTest( _T("sum()"),  0, false);
+      iStat += EqnTest( _T("sum(,)"),  0, false);
+      iStat += EqnTest( _T("sum(1,2,)"),  0, false);
+      iStat += EqnTest( _T("sum(,1,2)"),  0, false);
+
+      if (iStat==0) 
+        mu::console() << _T("passed") << endl;
+      else
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+  
+      return iStat;
+    }
+
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestInfixOprt()
+    {
+      int iStat = 0;
+      mu::console() << "testing infix operators...";
+
+      iStat += EqnTest( _T("-1"),    -1, true);
+      iStat += EqnTest( _T("-(-1)"),  1, true);
+      iStat += EqnTest( _T("-(-1)*2"),  2, true);
+      iStat += EqnTest( _T("-(-2)*sqrt(4)"),  4, true);
+      iStat += EqnTest( _T("-a"),  -1, true);
+      iStat += EqnTest( _T("-(a)"),  -1, true);
+      iStat += EqnTest( _T("-(-a)"),  1, true);
+      iStat += EqnTest( _T("-(-a)*2"),  2, true);
+      iStat += EqnTest( _T("-(8)"), -8, true);
+      iStat += EqnTest( _T("-8"), -8, true);
+      iStat += EqnTest( _T("-(2+1)"), -3, true);
+      iStat += EqnTest( _T("-(f1of1(1+2*3)+1*2)"), -9, true);
+      iStat += EqnTest( _T("-(-f1of1(1+2*3)+1*2)"), 5, true);
+      iStat += EqnTest( _T("-sin(8)"), -0.989358, true);
+      iStat += EqnTest( _T("3-(-a)"), 4, true);
+      iStat += EqnTest( _T("3--a"), 4, true);
+  
+      // Postfix / infix priorities
+      iStat += EqnTest( _T("~2#"), 8, true);
+      iStat += EqnTest( _T("~f1of1(2)#"), 8, true);
+      iStat += EqnTest( _T("~(b)#"), 8, true);
+      iStat += EqnTest( _T("(~b)#"), 12, true);
+      iStat += EqnTest( _T("~(2#)"), 8, true);
+      iStat += EqnTest( _T("~(f1of1(2)#)"), 8, true);
+      //
+      iStat += EqnTest( _T("-2^2"),-4, true);
+      iStat += EqnTest( _T("-(a+b)^2"),-9, true);
+      iStat += EqnTest( _T("(-3)^2"),9, true);
+      iStat += EqnTest( _T("-(-2^2)"),4, true);
+      iStat += EqnTest( _T("3+-3^2"),-6, true);
+      // The following assumes use of sqr as postfix operator ("?") together
+      // tiwth a sign operator of low priority:
+      iStat += EqnTest( _T("-2?"), -4, true);
+      iStat += EqnTest( _T("-(1+1)?"),-4, true);
+      iStat += EqnTest( _T("2+-(1+1)?"),-2, true);
+      iStat += EqnTest( _T("2+-2?"), -2, true);
+      // This is the classic behaviour of the infix sign operator (here: "$") which is
+      // now deprecated:
+      iStat += EqnTest( _T("$2^2"),4, true);
+      iStat += EqnTest( _T("$(a+b)^2"),9, true);
+      iStat += EqnTest( _T("($3)^2"),9, true);
+      iStat += EqnTest( _T("$($2^2)"),-4, true);
+      iStat += EqnTest( _T("3+$3^2"),12, true);
+
+      if (iStat==0)
+        mu::console() << _T("passed") << endl;
+      else
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestPostFix()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing postfix operators...");
+
+      // application
+      iStat += EqnTest( _T("3m+5"), 5.003, true);
+      iStat += EqnTest( _T("1000m"), 1, true);
+      iStat += EqnTest( _T("1000 m"), 1, true);
+      iStat += EqnTest( _T("(a)m"), 1e-3, true);
+      iStat += EqnTest( _T("-(a)m"), -1e-3, true);
+      iStat += EqnTest( _T("-2m"), -2e-3, true);
+      iStat += EqnTest( _T("f1of1(1000)m"), 1, true);
+      iStat += EqnTest( _T("-f1of1(1000)m"), -1, true);
+      iStat += EqnTest( _T("-f1of1(-1000)m"), 1, true);
+      iStat += EqnTest( _T("f4of4(0,0,0,1000)m"), 1, true);
+      iStat += EqnTest( _T("2+(a*1000)m"), 3, true);
+      // some incorrect results
+      iStat += EqnTest( _T("1000m"), 0.1, false);
+      iStat += EqnTest( _T("(a)m"), 2, false);
+      // failure due to syntax checking
+      iStat += EqnTest( _T("a m"), 0, false);
+      iStat += EqnTest( _T("4 + m"), 0, false);
+      iStat += EqnTest( _T("m4"), 0, false);
+      iStat += EqnTest( _T("sin(m)"), 0, false);
+      iStat += EqnTest( _T("m m"), 0, false);
+      iStat += EqnTest( _T("m(8)"), 0, false);
+      iStat += EqnTest( _T("4,m"), 0, false);
+      iStat += EqnTest( _T("-m"), 0, false);
+      iStat += EqnTest( _T("2(-m)"), 0, false);
+      iStat += EqnTest( _T("2(m)"), 0, false);
+
+      if (iStat==0)
+        mu::console() << _T("passed") << endl;
+      else
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Test volatile (nonoptimizeable functions). */
+    int ParserTester::TestVolatile()
+    {
+      int iStat = 0;
+      mu::console() << "testing volatile/nonvolatile functions...";
+
+      // First test with volatile flag turned on
+      try
+      {
+        mu::Parser p;
+        p.DefineFun( _T("rnd"), Rnd, false);
+        p.DefineFun( _T("valueof"), RndWithString, false);
+
+        // 1st test, compare results from sucessive calculations
+        p.SetExpr( _T("3+rnd(8)") );
+        if (p.Eval()==p.Eval()) iStat += 1;
+
+        // 2nd test, force bytecode creation, compare two results both 
+        // calculated from bytecode
+        p.SetExpr( _T("3+rnd(8)") ); 
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()==p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("3*rnd(8)+3") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()==p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("10+3*sin(rnd(8))-1") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()==p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("3+rnd(rnd(8))*2") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()==p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("valueof(\"Das ist ein Test\")") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()==p.Eval()) iStat += 1;
+      }
+      catch(Parser::exception_type &e)
+      {
+        mu::console() << _T("\n  ") << e.GetExpr() << _T(" : ") << e.GetMsg();
+        iStat += 1;
+      }
+
+      // Second test with volatile flag turned off
+      try
+      {
+        mu::Parser p;
+        p.DefineFun( _T("rnd"), Rnd);
+        p.DefineFun( _T("valueof"), RndWithString);
+
+        // compare string parsing with bytecode
+        p.SetExpr( _T("3+rnd(8)") ); 
+        if (p.Eval()!=p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("3+rnd(8)") ); 
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()!=p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("3*rnd(8)+3") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()!=p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("10+3*sin(rnd(8))-1") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()!=p.Eval()) iStat += 1;
+
+        p.SetExpr( _T("3+rnd(rnd(8))*2") );
+        p.Eval(); //<- Force bytecode creation
+        if (p.Eval()!=p.Eval()) iStat += 1;
+      }
+      catch(Parser::exception_type &e)
+      {
+        mu::console() << _T("\n  ") << e.GetExpr() << _T(" : ") << e.GetMsg();
+        iStat += 1;
+      }
+      
+      if (iStat==0)
+        mu::console() << _T("passed") << endl;
+      else
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestFormula()
+    {
+      int iStat = 0;
+      mu::console() << _T("testing sample formulas...");
+
+      // operator precedencs
+      iStat += EqnTest( _T("1+2-3*4/5^6"), 2.99923, true);
+      iStat += EqnTest( _T("1^2/3*4-5+6"), 2.3333, true);
+      iStat += EqnTest( _T("1+2*3"), 7, true);
+      iStat += EqnTest( _T("1+2*3"), 7, true);
+      iStat += EqnTest( _T("(1+2)*3"), 9, true);
+      iStat += EqnTest( _T("(1+2)*(-3)"), -9, true);
+      iStat += EqnTest( _T("2/4"), 0.5, true);
+
+      iStat += EqnTest( _T("exp(ln(7))"), 7, true);
+      iStat += EqnTest( _T("e^ln(7)"), 7, true);
+      iStat += EqnTest( _T("e^(ln(7))"), 7, true);
+      iStat += EqnTest( _T("(e^(ln(7)))"), 7, true);
+      iStat += EqnTest( _T("1-(e^(ln(7)))"), -6, true);
+      iStat += EqnTest( _T("2*(e^(ln(7)))"), 14, true);
+      iStat += EqnTest( _T("10^log(5)"), 5, true);
+      iStat += EqnTest( _T("10^log10(5)"), 5, true);
+      iStat += EqnTest( _T("2^log2(4)"), 4, true);
+      iStat += EqnTest( _T("-(sin(0)+1)"), -1, true);
+      iStat += EqnTest( _T("-(2^1.1)"), -2.14354692, true);
+
+      iStat += EqnTest( _T("(cos(2.41)/b)"), -0.372056, true);
+
+#if !defined(_UNICODE)
+      // I can't translate the following two tests to unicode without loosing 
+      // readability.
+
+      // long formula (Reference: Matlab)
+      iStat += EqnTest(
+        "(((-9))-e/(((((((pi-(((-7)+(-3)/4/e))))/(((-5))-2)-((pi+(-0))*(sqrt((e+e))*(-8))*(((-pi)+(-pi)-(-9)*(6*5))"
+        "/(-e)-e))/2)/((((sqrt(2/(-e)+6)-(4-2))+((5/(-2))/(1*(-pi)+3))/8)*pi*((pi/((-2)/(-6)*1*(-1))*(-6)+(-e)))))/"
+        "((e+(-2)+(-e)*((((-3)*9+(-e)))+(-9)))))))-((((e-7+(((5/pi-(3/1+pi)))))/e)/(-5))/(sqrt((((((1+(-7))))+((((-"
+        "e)*(-e)))-8))*(-5)/((-e)))*(-6)-((((((-2)-(-9)-(-e)-1)/3))))/(sqrt((8+(e-((-6))+(9*(-9))))*(((3+2-8))*(7+6"
+        "+(-5))+((0/(-e)*(-pi))+7)))+(((((-e)/e/e)+((-6)*5)*e+(3+(-5)/pi))))+pi))/sqrt((((9))+((((pi))-8+2))+pi))/e"
+        "*4)*((-5)/(((-pi))*(sqrt(e)))))-(((((((-e)*(e)-pi))/4+(pi)*(-9)))))))+(-pi)", -12.23016549, true);
+
+      // long formula (Reference: Matlab)
+      iStat += EqnTest(
+          "(atan(sin((((((((((((((((pi/cos((a/((((0.53-b)-pi)*e)/b))))+2.51)+a)-0.54)/0.98)+b)*b)+e)/a)+b)+a)+b)+pi)/e"
+          ")+a)))*2.77)", -2.16995656, true);
+#endif
+
+      // long formula (Reference: Matlab)
+      iStat += EqnTest( _T("1+2-3*4/5^6*(2*(1-5+(3*7^9)*(4+6*7-3)))+12"), -7995810.09926, true);
+	  
+      if (iStat==0) 
+        mu::console() << _T("passed") << endl;  
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+
+    //---------------------------------------------------------------------------
+    int ParserTester::TestException()
+    {
+      int  iStat = 0;
+      mu::console() << _T("testing error codes...");
+    
+      iStat += ThrowTest(_T("3+"),           ecUNEXPECTED_EOF);
+      iStat += ThrowTest(_T("3+)"),          ecUNEXPECTED_PARENS);
+      iStat += ThrowTest(_T("sin(3,4)"),     ecTOO_MANY_PARAMS);
+      iStat += ThrowTest(_T("3,4"),          ecUNEXPECTED_COMMA);
+      iStat += ThrowTest(_T("if(3)"),        ecTOO_FEW_PARAMS);
+      iStat += ThrowTest(_T("(1+2"),         ecMISSING_PARENS);
+      iStat += ThrowTest(_T("sin(3)3"),      ecUNEXPECTED_VAL);
+      iStat += ThrowTest(_T("sin(3)xyz"),    ecUNASSIGNABLE_TOKEN);
+      iStat += ThrowTest(_T("sin(3)cos(3)"), ecUNEXPECTED_FUN);
+
+      // String function related
+      iStat += ThrowTest( _T("valueof(\"xxx\")"),  999, false);
+      iStat += ThrowTest( _T("valueof()"),          ecUNEXPECTED_PARENS);
+      iStat += ThrowTest( _T("1+valueof(\"abc\""),  ecMISSING_PARENS);
+      iStat += ThrowTest( _T("valueof(\"abc\""),    ecMISSING_PARENS);
+      iStat += ThrowTest( _T("valueof(\"abc"),      ecUNTERMINATED_STRING);
+      iStat += ThrowTest( _T("valueof(\"abc\",3)"), ecTOO_MANY_PARAMS);
+      iStat += ThrowTest( _T("valueof(3)"),         ecSTRING_EXPECTED);
+      iStat += ThrowTest( _T("sin(\"abc\")"),       ecVAL_EXPECTED);
+      iStat += ThrowTest( _T("valueof(\"\\\"abc\\\"\")"),  999, false);
+      iStat += ThrowTest( _T("\"hello world\""),    ecSTR_RESULT);
+      iStat += ThrowTest( _T("(\"hello world\")"),  ecSTR_RESULT);
+      iStat += ThrowTest( _T("\"abcd\"+100"),       ecOPRT_TYPE_CONFLICT);
+      iStat += ThrowTest( _T("\"a\"+\"b\""),        ecOPRT_TYPE_CONFLICT);
+      iStat += ThrowTest( _T("strfun1(\"100\",3)"),     ecTOO_MANY_PARAMS);
+      iStat += ThrowTest( _T("strfun2(\"100\",3,5)"),   ecTOO_MANY_PARAMS);
+      iStat += ThrowTest( _T("strfun3(\"100\",3,5,6)"), ecTOO_MANY_PARAMS);
+      iStat += ThrowTest( _T("strfun2(\"100\")"),       ecTOO_FEW_PARAMS);
+      iStat += ThrowTest( _T("strfun3(\"100\",6)"),   ecTOO_FEW_PARAMS);
+      iStat += ThrowTest( _T("strfun2(1,1)"),         ecSTRING_EXPECTED);
+      iStat += ThrowTest( _T("strfun2(a,1)"),         ecSTRING_EXPECTED);
+      iStat += ThrowTest( _T("strfun2(1,1,1)"),       ecTOO_MANY_PARAMS);
+      iStat += ThrowTest( _T("strfun2(a,1,1)"),       ecTOO_MANY_PARAMS);
+      iStat += ThrowTest( _T("strfun3(1,2,3)"),         ecSTRING_EXPECTED);
+      iStat += ThrowTest( _T("strfun3(1, \"100\",3)"),  ecSTRING_EXPECTED);
+      iStat += ThrowTest( _T("strfun3(\"1\", \"100\",3)"),  ecVAL_EXPECTED);
+      iStat += ThrowTest( _T("strfun3(\"1\", 3, \"100\")"),  ecVAL_EXPECTED);
+      iStat += ThrowTest( _T("strfun3(\"1\", \"100\", \"100\", \"100\")"),  ecTOO_MANY_PARAMS);
+
+      // assignement operator
+//      iStat += ThrowTest("maxspec=0", 0, false);
+      iStat += ThrowTest( _T("3=4"), ecUNEXPECTED_OPERATOR);
+      iStat += ThrowTest( _T("sin(8)=4"), ecUNEXPECTED_OPERATOR);
+      iStat += ThrowTest( _T("\"test\"=a"), ecUNEXPECTED_OPERATOR);
+      iStat += ThrowTest( _T("sin=9"), ecUNEXPECTED_OPERATOR);
+      iStat += ThrowTest( _T("(8)=5"), ecUNEXPECTED_OPERATOR);
+      iStat += ThrowTest( _T("(a)=5"), ecUNEXPECTED_OPERATOR);
+      iStat += ThrowTest( _T("a=\"tttt\""), ecOPRT_TYPE_CONFLICT);
+
+      if (iStat==0) 
+        mu::console() << _T("passed") << endl;
+      else 
+        mu::console() << _T("\n  failed with ") << iStat << _T(" errors") << endl;
+
+      return iStat;
+    }
+
+
+    //---------------------------------------------------------------------------
+    void ParserTester::AddTest(testfun_type a_pFun)
+    {
+      m_vTestFun.push_back(a_pFun);
+    }
+
+    //---------------------------------------------------------------------------
+    void ParserTester::Run()
+    {
+      int iStat = 0;
+      try
+      {
+        for (int i=0; i<(int)m_vTestFun.size(); ++i)
+          iStat += (this->*m_vTestFun[i])();
+      }
+      catch(Parser::exception_type &e)
+      {
+        mu::console() << "\n" << e.GetMsg() << endl;
+        mu::console() << e.GetToken() << endl;
+        Abort();
+      }
+      catch(std::exception &e)
+      {
+        mu::console() << e.what() << endl;
+        Abort();
+      }
+      catch(...)
+      {
+        mu::console() << "Internal error";
+        Abort();
+      }
+
+      if (iStat==0) 
+      {
+        mu::console() << "Test passed (" <<  ParserTester::c_iCount << " expressions)" << endl;
+      }
+      else 
+      {
+        mu::console() << "Test failed with " << iStat 
+                  << " errors (" <<  ParserTester::c_iCount 
+                  << " expressions)" << endl;
+      }
+      ParserTester::c_iCount = 0;
+    }
+
+
+    //---------------------------------------------------------------------------
+    int ParserTester::ThrowTest(const string_type &a_str, int a_iErrc, bool a_bFail)
+    {
+      ParserTester::c_iCount++;
+
+      try
+      {
+        double fVal=0;
+        Parser p;
+
+        p.DefineVar( _T("a"), &fVal);
+        p.DefineFun( _T("valueof"), ValueOf);
+        p.DefineFun( _T("strfun1"), StrFun1);
+        p.DefineFun( _T("strfun2"), StrFun2);
+        p.DefineFun( _T("strfun3"), StrFun3);
+        p.SetExpr(a_str);
+        p.Eval();
+      }
+      catch(Parser::exception_type &e)
+      {
+        // output the formula in case of an failed test
+        if (a_bFail==true && a_iErrc!=e.GetCode() )
+        {
+          mu::console() << _T("\n  ") 
+                        << _T("Expression: ") << a_str 
+                        << _T("  Code:") << e.GetCode() 
+                        << _T("  Expected:") << a_iErrc;
+        }
+
+        return (a_iErrc==e.GetCode()) ? 0 : 1;
+      }
+
+      // if a_bFail==false no exception is expected
+      bool bRet((a_bFail==false) ? 0 : 1);
+      if (bRet==1)
+      {
+        mu::console() << _T("\n  ") 
+                      << _T("Expression: ") << a_str 
+                      << _T("  did evaluate; Expected error:") << a_iErrc;
+      }
+
+      return bRet; 
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Evaluate a tet expression. 
+
+        \return 1 in case of a failure, 0 otherwise.
+    */
+    int ParserTester::EqnTest(const string_type &a_str, double a_fRes, bool a_fPass)
+    {
+      ParserTester::c_iCount++;
+      int iRet(0);
+
+      try
+      {
+        Parser *p1, p2, p3;   // three parser objects
+                              // they will be used for testing copy and assihnment operators
+        // p1 is a pointer since i'm going to delete it in order to test if
+        // parsers after copy construction still refer to members of it.
+        // !! If this is the case this function will crash !!
+      
+        p1 = new mu::Parser(); 
+        // Add constants
+        p1->DefineConst( _T("pi"), (value_type)PARSER_CONST_PI);
+        p1->DefineConst( _T("e"), (value_type)PARSER_CONST_E);
+        p1->DefineConst( _T("const"), 1);
+        p1->DefineConst( _T("const1"), 2);
+        p1->DefineConst( _T("const2"), 3);
+        // variables
+        value_type vVarVal[] = { 1, 2, 3, -2};
+        p1->DefineVar( _T("a"), &vVarVal[0]);
+        p1->DefineVar( _T("aa"), &vVarVal[1]);
+        p1->DefineVar( _T("b"), &vVarVal[1]);
+        p1->DefineVar( _T("c"), &vVarVal[2]);
+        p1->DefineVar( _T("d"), &vVarVal[3]);
+        // functions
+        p1->DefineFun( _T("f1of1"), f1of1);  // one parameter
+        p1->DefineFun( _T("f1of2"), f1of2);  // two parameter
+        p1->DefineFun( _T("f2of2"), f2of2);
+        p1->DefineFun( _T("f1of3"), f1of3);  // three parameter
+        p1->DefineFun( _T("f2of3"), f2of3);
+        p1->DefineFun( _T("f3of3"), f3of3);
+        p1->DefineFun( _T("f1of4"), f1of4);  // four parameter
+        p1->DefineFun( _T("f2of4"), f2of4);
+        p1->DefineFun( _T("f3of4"), f3of4);
+        p1->DefineFun( _T("f4of4"), f4of4);
+        p1->DefineFun( _T("f1of5"), f1of5);  // five parameter
+        p1->DefineFun( _T("f2of5"), f2of5);
+        p1->DefineFun( _T("f3of5"), f3of5);
+        p1->DefineFun( _T("f4of5"), f4of5);
+        p1->DefineFun( _T("f5of5"), f5of5);
+        // sample functions
+        p1->DefineFun( _T("min"), Min);
+        p1->DefineFun( _T("max"), Max);
+        p1->DefineFun( _T("sum"), Sum);
+        p1->DefineFun( _T("valueof"), ValueOf);
+        p1->DefineFun( _T("atof"), StrToFloat);
+        p1->DefineFun( _T("strfun1"), StrFun1);
+        p1->DefineFun( _T("strfun2"), StrFun2);
+        p1->DefineFun( _T("strfun3"), StrFun3);
+
+        // infix / postfix operator
+        // (identifiers used here do not have any meaning or make any sense at all)
+        p1->DefineInfixOprt( _T("$"), sign, prPOW+1);  // sign with high priority
+        p1->DefineInfixOprt( _T("~"), plus2);          // high priority
+        p1->DefinePostfixOprt( _T("m"), Milli);
+        p1->DefinePostfixOprt( _T("#"), times3);
+        p1->DefinePostfixOprt( _T("?"), sqr);  //
+        p1->SetExpr(a_str);
+
+        // Test bytecode integrity
+        // String parsing and bytecode parsing must yield the same result
+        value_type fVal[4] = {-999, -998, -997, -996}; // initially should be different
+        fVal[0] = p1->Eval(); // result from stringparsing
+        fVal[1] = p1->Eval(); // result from bytecode
+        if (fVal[0]!=fVal[1])
+          throw Parser::exception_type( _T("Bytecode corrupt.") );
+
+        // Test copy and assignement operators
+        try
+        {
+          // Test copy constructor
+          std::vector<mu::Parser> vParser;
+          vParser.push_back(*p1);
+          mu::Parser p2 = vParser[0];   // take parser from vector
+        
+          // destroy the originals from p2
+          vParser.clear();              // delete the vector
+          delete p1;                    // delete the original
+          p1 = 0;
+
+          fVal[2] = p2.Eval();
+
+          // Test assignement operator
+          // additionally  disable Optimizer this time
+          mu::Parser p3;
+          p3 = p2;
+          p3.EnableOptimizer(false);
+          fVal[3] = p3.Eval();
+        }
+        catch(std::exception &e)
+        {
+          mu::console() << _T("\n  ") << e.what() << _T("\n");
+        }
+
+        // limited floating point accuracy requires the following test
+        bool bCloseEnough(true);
+        for (int i=0; i<4; ++i)
+        {
+          bCloseEnough &= (fabs(a_fRes-fVal[i]) <= fabs(fVal[i]*0.0001));
+        }
+
+        iRet = ((bCloseEnough && a_fPass) || (!bCloseEnough && !a_fPass)) ? 0 : 1;
+        if (iRet==1)
+        {
+          mu::console() << "\n  fail: " << a_str.c_str() 
+                    << " (incorrect result; expected: " << a_fRes
+                    << " ;calculated: " << fVal[0]<< ").";
+        }
+      }
+      catch(Parser::exception_type &e)
+      {
+        if (a_fPass)
+        {
+         mu::console() << _T("\n  fail: ") << a_str.c_str() << _T(" (") << e.GetMsg() << _T(")");
+          return 1;
+        }
+      }
+      catch(std::exception &e)
+      {
+        mu::console() << _T("\n  fail: ") << a_str.c_str() << _T(" (") << e.what() << _T(")");
+         return 1;  // always return a failure since this exception is not expected
+      }
+      catch(...)
+      {
+       mu::console() << _T("\n  fail: ") << a_str.c_str() <<  _T(" (unexpected exception)");
+        return 1;  // exceptions other than ParserException are not allowed
+      }
+
+      return iRet;
+    }
+
+    //---------------------------------------------------------------------------
+    int ParserTester::EqnTestInt(const string_type &a_str, double a_fRes, bool a_fPass)
+    {
+      ParserTester::c_iCount++;
+
+      value_type vVarVal[] = {1, 2, 3};    // variable values
+      value_type fVal[2] = {-99, -999}; // results: initially should be different
+      int iRet(0);
+
+      try
+      {
+        ParserInt p;
+        p.DefineConst( _T("const1"), 1);
+        p.DefineConst( _T("const2"), 2);
+        p.DefineVar( _T("a"), &vVarVal[0]);
+        p.DefineVar( _T("b"), &vVarVal[1]);
+        p.DefineVar( _T("c"), &vVarVal[2]);
+
+        p.SetExpr(a_str);
+        fVal[0] = p.Eval(); // result from stringparsing
+        fVal[1] = p.Eval(); // result from bytecode
+
+        if (fVal[0]!=fVal[1])
+          throw Parser::exception_type( _T("Bytecode corrupt.") );
+
+        iRet =  ( (a_fRes==fVal[0] &&  a_fPass) || 
+                  (a_fRes!=fVal[0] && !a_fPass) ) ? 0 : 1;
+        if (iRet==1)
+        {
+          mu::console() << _T("\n  fail: ") << a_str.c_str() 
+                    << _T(" (incorrect result; expected: ") << a_fRes 
+                    << _T(" ;calculated: ") << fVal[0]<< _T(").");
+        }
+      }
+      catch(Parser::exception_type &e)
+      {
+        if (a_fPass)
+          mu::console() << _T("\n  ") << e.GetExpr() << _T(" : ") << e.GetMsg();
+      }
+      catch(...)
+      {
+       mu::console() << "\n  fail: " << a_str.c_str() <<  " (unexpected exception)";
+        return 1;  // exceptions other than ParserException are not allowed
+      }
+
+      return iRet;
+    }
+
+    //---------------------------------------------------------------------------
+    /** \brief Internal error in test class Test is going to be aborted. */
+    void ParserTester::Abort() const
+    {
+      mu::console() << _T("Test failed (internal error in test class)") << endl;
+      while (!getchar());
+      exit(-1);
+    }
+  } // namespace test
+} // namespace mu
+
+
+
diff --git a/muparser/muParserTest.h b/muparser/muParserTest.h
new file mode 100644
index 0000000..fe9bfdd
--- /dev/null
+++ b/muparser/muParserTest.h
@@ -0,0 +1,176 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_TEST_H
+#define MU_PARSER_TEST_H
+
+#include <string>
+#include <numeric> // for accumulate
+#include "muParser.h"
+#include "muParserInt.h"
+
+
+namespace mu
+{
+  /** \brief Namespace for test cases. */
+  namespace Test
+  {
+    //------------------------------------------------------------------------------
+    /** \brief Test cases for unit testing.
+
+      (C) 2004-2006 Ingo Berg
+    */
+    class ParserTester // final
+    {
+    private:
+        // Multiarg callbacks
+        static value_type f1of1(value_type v) { return v;};
+      	
+        static value_type f1of2(value_type v, value_type  ) {return v;};
+        static value_type f2of2(value_type  , value_type v) {return v;};
+
+        static value_type f1of3(value_type v, value_type  , value_type  ) {return v;};
+        static value_type f2of3(value_type  , value_type v, value_type  ) {return v;};
+        static value_type f3of3(value_type  , value_type  , value_type v) {return v;};
+      	
+        static value_type f1of4(value_type v, value_type,   value_type  , value_type  ) {return v;}
+        static value_type f2of4(value_type  , value_type v, value_type  , value_type  ) {return v;}
+        static value_type f3of4(value_type  , value_type,   value_type v, value_type  ) {return v;}
+        static value_type f4of4(value_type  , value_type,   value_type  , value_type v) {return v;}
+
+	      static value_type f1of5(value_type v, value_type,   value_type  , value_type  , value_type  ) { return v; }
+	      static value_type f2of5(value_type  , value_type v, value_type  , value_type  , value_type  ) { return v; }
+	      static value_type f3of5(value_type  , value_type,   value_type v, value_type  , value_type  ) { return v; }
+	      static value_type f4of5(value_type  , value_type,   value_type  , value_type v, value_type  ) { return v; }
+	      static value_type f5of5(value_type  , value_type,   value_type  , value_type  , value_type v) { return v; }
+
+        static value_type Min(value_type a_fVal1, value_type a_fVal2) { return (a_fVal1<a_fVal2) ? a_fVal1 : a_fVal2; }
+  	    static value_type Max(value_type a_fVal1, value_type a_fVal2) { return (a_fVal1>a_fVal2) ? a_fVal1 : a_fVal2; }
+
+        static value_type plus2(value_type v1) { return v1+2; }
+        static value_type times3(value_type v1) { return v1*3; }
+        static value_type sqr(value_type v1) { return v1*v1; }
+
+        static value_type sign(value_type v) { return -v; }
+
+        static value_type Sum(const value_type* a_afArg, int a_iArgc)
+        { 
+          if (!a_iArgc)	
+            throw mu::Parser::exception_type( _T("too few arguments for function sum.") );
+
+          value_type fRes=0;
+          for (int i=0; i<a_iArgc; ++i) fRes += a_afArg[i];
+          return fRes;
+        }
+
+        static value_type Rnd(value_type v)
+        {
+          return (value_type)(1+(v*std::rand()/(RAND_MAX+1.0)));
+        }
+
+        static value_type RndWithString(const char_type*)
+        {
+          return (value_type)( 1 + (1000.0f * std::rand() / (RAND_MAX + 1.0) ) );
+        }
+
+        static value_type ValueOf(const char_type*)      
+        { 
+          return 123; 
+        }
+
+        static value_type StrFun1(const char_type* v1)                               
+        { 
+          int val(0);
+          stringstream_type(v1) >> val;
+          return val;
+        }
+
+        static value_type StrFun2(const char_type* v1, value_type v2)                
+        { 
+          int val(0);
+          stringstream_type(v1) >> val;
+          return val + v2;
+        }
+        
+        static value_type StrFun3(const char_type* v1, value_type v2, value_type v3) 
+        { 
+          int val(0);
+          stringstream_type(v1) >> val;
+          return val + v2 + v3;
+        }
+
+        static value_type StrToFloat(const char_type* a_szMsg)
+        {
+          double val(0);
+          stringstream_type(a_szMsg) >> val;
+          return val;
+
+//          using namespace std; // atof is for some compilers in std for some not... 
+//          return atof(a_szMsg);
+        }
+
+        // postfix operator callback
+	      static value_type Milli(value_type v) { return v/(value_type)1e3; }
+        
+        static int c_iCount;
+
+	      int TestNames();
+	      int TestSyntax();
+	      int TestMultiArg();
+	      int TestVolatile();
+	      int TestPostFix();
+	      int TestFormula();
+	      int TestInfixOprt();
+	      int TestBinOprt();
+	      int TestVarConst();
+	      int TestInterface();
+	      int TestException();
+        int TestStrArg();
+
+        void Abort() const;
+
+    public:
+        typedef int (ParserTester::*testfun_type)();
+
+	      ParserTester();
+	      void Run();
+
+    private:
+        std::vector<testfun_type> m_vTestFun;
+	      void AddTest(testfun_type a_pFun);
+
+        // Test Double Parser
+        int EqnTest(const string_type& a_str, double a_fRes, bool a_fPass);
+        int ThrowTest(const string_type& a_str, int a_iErrc, bool a_bFail = true);
+
+        // Test Int Parser
+        int EqnTestInt(const string_type& a_str, double a_fRes, bool a_fPass);
+    };
+  } // namespace Test
+} // namespace mu
+
+#endif
+
+
diff --git a/muparser/muParserToken.h b/muparser/muParserToken.h
new file mode 100644
index 0000000..b4c7e54
--- /dev/null
+++ b/muparser/muParserToken.h
@@ -0,0 +1,464 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_TOKEN_H
+#define MU_PARSER_TOKEN_H
+
+#include <cassert>
+#include <string>
+#include <stack>
+#include <vector>
+#include <memory>
+
+#include "muParserError.h"
+#include "muParserCallback.h"
+
+
+namespace mu
+{
+
+/** \brief Encapsulation of the data for a single formula token. 
+
+  Formula token implementation. Part of the Math Parser Package.
+  Formula tokens can be either one of the following:
+  <ul>
+    <li>value</li>
+    <li>variable</li>
+    <li>function with numerical arguments</li>
+    <li>functions with a string as argument</li>
+    <li>prefix operators</li>
+    <li>infix operators</li>
+	  <li>binary operator</li>
+  </ul>
+
+ \author (C) 2004 Ingo Berg 
+*/
+template<typename TBase, typename TString>
+class ParserToken
+{
+public:
+    /** \brief Additional token flags. */
+    enum ETokFlags
+	  {
+	    flVOLATILE = 1    ///< Mark a token that depends on a variable or a function that is not conservative
+	  };
+
+private:
+    ECmdCode  m_iCode;  ///< Type of the token; The token type is a constant of type #ECmdCode.
+    ETypeCode m_iType;
+    void  *m_pTok;      ///< Stores Token pointer; not applicable for all tokens
+  	int  m_iFlags;      ///< Additional flags for the token.
+    int  m_iIdx;        ///< An otional index to an external buffer storing the token data
+    TString m_strTok;   ///< Token string
+    TString m_strVal;   ///< Value for string variables
+    value_type m_fVal;
+    std::auto_ptr<ParserCallback> m_pCallback;
+
+public:
+
+    //---------------------------------------------------------------------------
+    /** \brief Constructor (default).
+      
+        Sets token to an neutral state of type cmUNKNOWN.
+        \throw nothrow
+        \sa ECmdCode
+    */
+    ParserToken()
+      :m_iCode(cmUNKNOWN)
+      ,m_iType(tpVOID)
+      ,m_pTok(0)
+      ,m_iFlags(0)
+      ,m_iIdx(-1)
+      ,m_strTok()
+      ,m_pCallback()
+    {}
+
+    //------------------------------------------------------------------------------
+    /** \brief Create token from another one.
+    
+        Implemented by calling Assign(...)
+        \throw nothrow
+        \post m_iType==cmUNKNOWN
+        \sa #Assign
+    */
+    ParserToken(const ParserToken &a_Tok)
+    {
+      Assign(a_Tok);
+    }
+    
+    //------------------------------------------------------------------------------
+    /** \brief Assignement operator. 
+    
+        Copy token state from another token and return this.
+        Implemented by calling Assign(...).
+        \throw nothrow
+    */
+    ParserToken& operator=(const ParserToken &a_Tok)
+    {
+      Assign(a_Tok);
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Copy token information from argument.
+    
+        \throw nothrow
+    */
+    void Assign(const ParserToken &a_Tok)
+    {
+      m_iCode = a_Tok.m_iCode;
+      m_pTok = a_Tok.m_pTok;
+      m_iFlags = a_Tok.m_iFlags;
+      m_strTok = a_Tok.m_strTok;
+      m_iIdx = a_Tok.m_iIdx;
+      m_strVal = a_Tok.m_strVal;
+      m_iType = a_Tok.m_iType;
+      m_fVal = a_Tok.m_fVal;
+      // create new callback object if a_Tok has one 
+      m_pCallback.reset(a_Tok.m_pCallback.get() ? a_Tok.m_pCallback->Clone() : 0);
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Add additional flags to the token. 
+
+        Flags are currently used to mark volatile (non optimizeable) functions.
+        \sa m_iFlags, ETokFlags    
+    */
+    void AddFlags(int a_iFlags)
+    {
+      m_iFlags |= a_iFlags;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Check if a certain flag ist set. 
+
+        \throw nothrow
+    */
+    bool IsFlagSet(int a_iFlags) const
+    {
+        #if defined(_MSC_VER)
+          #pragma warning( disable : 4800 )
+        #endif
+        
+        return (bool)(m_iFlags & a_iFlags);
+
+        #if defined(_MSC_VER)
+          #pragma warning( default : 4800 ) // int: Variable set to boolean value (may degrade performance)
+        #endif
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Assign a token type. 
+
+      Token may not be of type value, variable or function. Those have seperate set functions. 
+
+      \pre [assert] a_iType!=cmVAR
+      \pre [assert] a_iType!=cmVAL
+      \pre [assert] a_iType!=cmFUNC
+      \post m_fVal = 0
+      \post m_pTok = 0
+    */
+    ParserToken& Set(ECmdCode a_iType, const TString &a_strTok=TString())
+    {
+      // The following types cant be set this way, they have special Set functions
+      assert(a_iType!=cmVAR);
+      assert(a_iType!=cmVAL);
+      assert(a_iType!=cmFUNC);
+
+      m_iCode = a_iType;
+      m_iType = tpVOID;
+      m_pTok = 0;
+      m_iFlags = 0;
+      m_strTok = a_strTok;
+      m_iIdx = -1;
+
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Set Callback type. */
+    ParserToken& Set(const ParserCallback &a_pCallback, const TString &a_sTok)
+    {
+      assert(a_pCallback.GetAddr());
+
+      m_iCode = a_pCallback.GetCode();
+      m_iType = tpVOID;
+      m_strTok = a_sTok;
+      m_pCallback.reset(new ParserCallback(a_pCallback));
+
+      m_pTok = 0;
+      m_iFlags = 0;
+      m_iIdx = -1;
+      
+      if (!m_pCallback->IsOptimizable())
+        AddFlags(flVOLATILE);
+
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Make this token a value token. 
+    
+        Member variables not necessary for value tokens will be invalidated.
+        \throw nothrow
+    */
+    ParserToken& SetVal(TBase a_fVal, const TString &a_strTok=TString())
+    {
+      m_iCode = cmVAL;
+      m_iType = tpDBL;
+      m_fVal = a_fVal;
+      m_iFlags = 0;
+      m_strTok = a_strTok;
+      m_iIdx = -1;
+      
+      m_pTok = 0;
+      m_pCallback.reset(0);
+
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief make this token a variable token. 
+    
+        Member variables not necessary for variable tokens will be invalidated.
+        \throw nothrow
+    */
+    ParserToken& SetVar(TBase *a_pVar, const TString &a_strTok)
+    {
+      m_iCode = cmVAR;
+      m_iType = tpDBL;
+      m_iFlags = 0;
+      m_strTok = a_strTok;
+      m_iIdx = -1;
+      m_pTok = (void*)a_pVar;
+      m_pCallback.reset(0);
+
+      AddFlags(ParserToken::flVOLATILE);
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Make this token a variable token. 
+    
+        Member variables not necessary for variable tokens will be invalidated.
+        \throw nothrow
+    */
+    ParserToken& SetString(const TString &a_strTok, std::size_t a_iSize)
+    {
+      m_iCode = cmSTRING; // cmSTRVAR;
+      m_iType = tpSTR;
+      m_iFlags = 0;
+      m_strTok = a_strTok;
+      m_iIdx = static_cast<int>(a_iSize);
+
+      m_pTok = 0;
+      m_pCallback.reset(0);
+
+      AddFlags(ParserToken::flVOLATILE);
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Make token a string token.
+
+        String tokens are used to store the value of string function arguments. 
+        \param a_strTok the string content.
+        \post #m_iType==cmSTRING, #m_strTok==a_strTok
+        \throw nothrow
+    */
+    ParserToken& SetString(const string_type &a_strTok)
+    {
+      m_iCode = cmSTRING;
+      m_iType = tpSTR;
+      m_iFlags = 0;
+      m_iIdx = -1;
+
+      m_pTok = 0;
+      m_pCallback.reset(0);
+        
+      m_strTok = a_strTok;
+
+      return *this;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Set an index associated with the token related data. 
+    
+        In cmSTRFUNC - This is the index to a string table in the main parser.
+        \param a_iIdx The index the string function result will take in the bytecode parser.
+        \throw exception_type if #a_iIdx<0 or #m_iType!=cmSTRING
+    */
+    void SetIdx(int a_iIdx)
+    {
+      if (m_iCode!=cmSTRING || a_iIdx<0)
+	      throw ParserError(ecINTERNAL_ERROR);
+      
+      m_iIdx = a_iIdx;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Return Index associated with the token related data. 
+    
+        In cmSTRFUNC - This is the index to a string table in the main parser.
+
+        \throw exception_type if #m_iIdx<0 or #m_iType!=cmSTRING
+        \return The index the result will take in the Bytecode calculatin array (#m_iIdx).
+    */
+    int GetIdx() const
+    {
+      if (m_iIdx<0 || m_iCode!=cmSTRING )
+        throw ParserError(ecINTERNAL_ERROR);
+
+      return m_iIdx;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Return the token type.
+    
+        \return #m_iType
+        \throw nothrow
+    */
+    ECmdCode GetCode() const
+    {
+      if (m_pCallback.get())
+      {
+        return m_pCallback->GetCode();
+      }
+      else
+      {
+        return m_iCode;
+      }
+    }
+
+    //------------------------------------------------------------------------------
+    ETypeCode GetType() const
+    {
+      if (m_pCallback.get())
+      {
+        return m_pCallback->GetType();
+      }
+      else
+      {
+        return m_iType;
+      }
+    }
+    
+    //------------------------------------------------------------------------------
+    int GetPri() const
+    {
+      if ( !m_pCallback.get())
+	      throw ParserError(ecINTERNAL_ERROR);
+          
+      if ( m_pCallback->GetCode()!=cmOPRT_BIN && m_pCallback->GetCode()!=cmOPRT_INFIX)
+	      throw ParserError(ecINTERNAL_ERROR);
+
+      return m_pCallback->GetPri();
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Return the address of the callback function assoziated with
+               function and operator tokens.
+
+        \return The pointer stored in #m_pTok.
+        \throw exception_type if token type is non of:
+               <ul>
+                 <li>cmFUNC</li>
+                 <li>cmSTRFUNC</li>
+                 <li>cmPOSTOP</li>
+                 <li>cmINFIXOP</li>
+                 <li>cmOPRT_BIN</li>
+               </ul>
+        \sa ECmdCode
+    */
+    void* GetFuncAddr() const
+    {
+      return (m_pCallback.get()) ? m_pCallback->GetAddr() : 0;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \biref Get value of the token.
+      
+        Only applicable to variable and value tokens.
+        \throw exception_type if token is no value/variable token.
+    */
+    TBase GetVal() const
+    {
+      switch (m_iCode)
+      {
+        case cmVAL:  return m_fVal;
+        case cmVAR:  return *((TBase*)m_pTok);
+        default:     throw ParserError(ecVAL_EXPECTED);
+      }
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Get address of a variable token.
+
+      Valid only if m_iType==CmdVar.
+      \throw exception_type if token is no variable token.
+    */
+    TBase* GetVar() const
+    {
+      if (m_iCode!=cmVAR)
+	      throw ParserError(ecINTERNAL_ERROR);
+
+      return (TBase*)m_pTok;
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Return the number of function arguments. 
+
+      Valid only if m_iType==CmdFUNC.
+    */
+    int GetArgCount() const
+    {
+      assert(m_pCallback.get());
+
+      if (!m_pCallback->GetAddr())
+	      throw ParserError(ecINTERNAL_ERROR);
+
+      return m_pCallback->GetArgc();
+    }
+
+    //------------------------------------------------------------------------------
+    /** \brief Return the token identifier. 
+        
+        If #m_iType is cmSTRING the token identifier is the value of the string argument
+        for a string function.
+        \return #m_strTok
+        \throw nothrow
+        \sa m_strTok
+    */
+    const TString& GetAsString() const
+    {
+      return m_strTok;
+    }
+};
+
+} // namespace mu
+
+#endif
+
+
diff --git a/muparser/muParserTokenReader.cpp b/muparser/muParserTokenReader.cpp
new file mode 100644
index 0000000..99c0a0a
--- /dev/null
+++ b/muparser/muParserTokenReader.cpp
@@ -0,0 +1,822 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <stack>
+#include <string>
+
+#include "muParserTokenReader.h"
+#include "muParserBase.h"
+
+
+namespace mu
+{
+
+  // Forward declaration
+  class ParserBase;
+
+  //---------------------------------------------------------------------------
+  /** \brief Copy constructor.
+
+      \sa Assign
+      \throw nothrow
+  */
+  ParserTokenReader::ParserTokenReader(const ParserTokenReader &a_Reader) 
+  { 
+    Assign(a_Reader);
+  }
+    
+  //---------------------------------------------------------------------------
+  /** \brief Assignement operator.
+
+      Self assignement will be suppressed otherwise #Assign is called.
+
+      \param a_Reader Object to copy to this token reader.
+      \throw nothrow
+  */
+  ParserTokenReader& ParserTokenReader::operator=(const ParserTokenReader &a_Reader) 
+  {
+    if (&a_Reader!=this)
+      Assign(a_Reader);
+
+    return *this;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Assign state of a token reader to this token reader. 
+      
+      \param a_Reader Object from which the state should be copied.
+      \throw nothrow
+  */
+  void ParserTokenReader::Assign(const ParserTokenReader &a_Reader)
+  {
+    m_pParser = a_Reader.m_pParser;
+    m_strFormula = a_Reader.m_strFormula;
+    m_iPos = a_Reader.m_iPos;
+    m_iSynFlags = a_Reader.m_iSynFlags;
+    
+    m_UsedVar = a_Reader.m_UsedVar;
+    m_pFunDef = a_Reader.m_pFunDef;
+    m_pConstDef = a_Reader.m_pConstDef;
+    m_pVarDef = a_Reader.m_pVarDef;
+    m_pStrVarDef = a_Reader.m_pStrVarDef;
+    m_pPostOprtDef = a_Reader.m_pPostOprtDef;
+    m_pInfixOprtDef = a_Reader.m_pInfixOprtDef;
+    m_pOprtDef = a_Reader.m_pOprtDef;
+    m_bIgnoreUndefVar = a_Reader.m_bIgnoreUndefVar;
+    m_vIdentFun = a_Reader.m_vIdentFun;
+    m_pFactory = a_Reader.m_pFactory;
+    m_pFactoryData = a_Reader.m_pFactoryData;
+    m_iBrackets = a_Reader.m_iBrackets;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Constructor. 
+      
+      Create a Token reader and bind it to a parser object. 
+
+      \pre [assert] a_pParser may not be NULL
+      \post #m_pParser==a_pParser
+      \param a_pParent Parent parser object of the token reader.
+  */
+  ParserTokenReader::ParserTokenReader(ParserBase *a_pParent)
+    :m_pParser(a_pParent)
+    ,m_strFormula()
+    ,m_iPos(0)
+    ,m_iSynFlags(0)
+    ,m_bIgnoreUndefVar(false)
+    ,m_pFunDef(NULL)
+    ,m_pPostOprtDef(NULL)
+    ,m_pInfixOprtDef(NULL)
+    ,m_pOprtDef(NULL)
+    ,m_pConstDef(NULL)
+    ,m_pStrVarDef(NULL)
+    ,m_pVarDef(NULL)
+    ,m_pFactory(NULL)
+    ,m_pFactoryData(NULL)
+    ,m_vIdentFun()
+    ,m_UsedVar()
+    ,m_fZero(0)
+    ,m_iBrackets(0)
+  {
+    assert(m_pParser);
+    SetParent(m_pParser);
+  }
+    
+  //---------------------------------------------------------------------------
+  /** \brief Destructor (trivial).
+  
+      \throw nothrow
+  */
+  ParserTokenReader::~ParserTokenReader()
+  {}
+
+  //---------------------------------------------------------------------------
+  /** \brief Create instance of a ParserTokenReader identical with this 
+              and return its pointer. 
+
+      This is a factory method the calling function must take care of the object destruction.
+
+      \return A new ParserTokenReader object.
+      \throw nothrow
+  */
+  ParserTokenReader* ParserTokenReader::Clone(ParserBase *a_pParent) const
+  {
+    std::auto_ptr<ParserTokenReader> ptr(new ParserTokenReader(*this));
+    ptr->SetParent(a_pParent);
+    return ptr.release();
+  }
+
+  //---------------------------------------------------------------------------
+  void ParserTokenReader::AddValIdent(identfun_type a_pCallback)
+  {
+    m_vIdentFun.push_back(a_pCallback);
+  }
+
+  //---------------------------------------------------------------------------
+  void ParserTokenReader::SetVarCreator(facfun_type a_pFactory, void *pUserData)
+  {
+    m_pFactory = a_pFactory;
+    m_pFactoryData = pUserData;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Return the current position of the token reader in the formula string. 
+
+      \return #m_iPos
+      \throw nothrow
+  */
+  int ParserTokenReader::GetPos() const
+  {
+    return m_iPos;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Return a reference to the formula. 
+
+      \return #m_strFormula
+      \throw nothrow
+  */
+  const string_type& ParserTokenReader::GetFormula() const
+  {
+    return m_strFormula;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Return a map containing the used variables only. */
+  const varmap_type& ParserTokenReader::GetUsedVar() const
+  {
+    return m_UsedVar;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Initialize the token Reader. 
+  
+      Sets the formula position index to zero and set Syntax flags to default for initial formula parsing.
+      \pre [assert] triggered if a_szFormula==0
+  */
+  void ParserTokenReader::SetFormula(const string_type &a_strFormula)
+  {
+    m_strFormula = a_strFormula;
+    ReInit();
+  }
+
+  //---------------------------------------------------------------------------
+  void ParserTokenReader::SetDefs( const funmap_type *a_pFunDef, 
+                                   const funmap_type *a_pOprtDef,
+                                   const funmap_type *a_pInfixOprtDef,
+                                   const funmap_type *a_pPostOprtDef,
+                                   varmap_type *a_pVarDef,
+                                   const strmap_type *a_pStrVarDef,
+                                   const valmap_type *a_pConstDef )
+  {
+    m_pFunDef = a_pFunDef;
+    m_pOprtDef = a_pOprtDef;
+    m_pInfixOprtDef = a_pInfixOprtDef;
+    m_pPostOprtDef = a_pPostOprtDef;
+    m_pVarDef = a_pVarDef;
+    m_pStrVarDef = a_pStrVarDef;
+    m_pConstDef = a_pConstDef;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Set Flag that contronls behaviour in case of undefined variables beeing found. 
+  
+    If true, the parser does not throw an exception if an undefined variable is found. 
+    otherwise it does. This variable is used internally only!
+    It supresses a "undefined variable" exception in GetUsedVar().  
+    Those function should return a complete list of variables including 
+    those the are not defined by the time of it's call.
+  */
+  void ParserTokenReader::IgnoreUndefVar(bool bIgnore)
+  {
+    m_bIgnoreUndefVar = bIgnore;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Reset the token reader to the start of the formula. 
+
+      The syntax flags will be reset to a value appropriate for the 
+      start of a formula.
+      \post #m_iPos==0, #m_iSynFlags = noOPT | noBC | noPOSTOP | noSTR
+      \throw nothrow
+      \sa ESynCodes
+  */
+  void ParserTokenReader::ReInit()
+  {
+    m_iPos = 0;
+    m_iSynFlags = noOPT | noBC | noPOSTOP | noASSIGN;
+    m_iBrackets = 0;
+    m_UsedVar.clear();
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Read the next token from the string. */ 
+  ParserTokenReader::token_type ParserTokenReader::ReadNextToken()
+  {
+    assert(m_pParser);
+
+    std::stack<int> FunArgs;
+    const char_type *szFormula = m_strFormula.c_str();
+    token_type tok;
+
+    while (szFormula[m_iPos]==' ') 
+      ++m_iPos;
+
+    if ( IsEOF(tok) ) return tok;        // Check for end of formula
+    if ( IsOprt(tok) )   return tok;     // Check for user defined binary operator
+    if ( IsBuiltIn(tok) ) return tok;    // Check built in operators / tokens
+    if ( IsFunTok(tok) ) return tok;     // Check for function token
+    if ( IsValTok(tok) ) return tok;     // Check for values / constant tokens
+    if ( IsVarTok(tok) ) return tok;     // Check for variable tokens
+    if ( IsStrVarTok(tok) ) return tok;  // Check for string variables
+    if ( IsString(tok) ) return tok;     // Check for String tokens
+    if ( IsInfixOpTok(tok) ) return tok; // Check for unary operators
+    if ( IsPostOpTok(tok) )  return tok; // Check for unary operators
+
+    // Check String for undefined variable token. Done only if a 
+    // flag is set indicating to ignore undefined variables.
+    // This is a way to conditionally avoid an error if 
+    // undefined variables occur. 
+    // The GetUsedVar function must supress the error for
+    // undefined variables in order to collect all variable 
+    // names including the undefined ones.
+    if ( (m_bIgnoreUndefVar || m_pFactory) && IsUndefVarTok(tok) )  return tok;
+
+    // Check for unknown token
+    // 
+    // !!! From this point on there is no exit without an exception possible...
+    // 
+    string_type strTok;
+    int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos);
+    if (iEnd!=m_iPos)
+      Error(ecUNASSIGNABLE_TOKEN, m_iPos, strTok);
+
+    Error(ecUNASSIGNABLE_TOKEN, m_iPos, m_strFormula.substr(m_iPos));
+    return token_type(); // never reached
+  }
+
+  //---------------------------------------------------------------------------
+  void ParserTokenReader::SetParent(ParserBase *a_pParent)
+  {
+    m_pParser  = a_pParent; 
+    m_pFunDef  = &a_pParent->m_FunDef;
+    m_pOprtDef = &a_pParent->m_OprtDef;
+    m_pInfixOprtDef = &a_pParent->m_InfixOprtDef;
+    m_pPostOprtDef  = &a_pParent->m_PostOprtDef;
+    m_pVarDef       = &a_pParent->m_VarDef;
+    m_pStrVarDef    = &a_pParent->m_StrVarDef;
+    m_pConstDef     = &a_pParent->m_ConstDef;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Extract all characters that belong to a certain charset.
+
+    \param a_szCharSet [in] Const char array of the characters allowed in the token. 
+    \param a_strTok [out]  The string that consists entirely of characters listed in a_szCharSet.
+    \param a_iPos [in] Position in the string from where to start reading.
+    \return The Position of the first character not listed in a_szCharSet.
+    \throw nothrow
+  */
+  int ParserTokenReader::ExtractToken( const char_type *a_szCharSet, 
+                                       string_type &a_sTok, int a_iPos ) const
+  {
+    int iEnd = (int)m_strFormula.find_first_not_of(a_szCharSet, a_iPos);
+
+    if (iEnd==(int)string_type::npos)
+        iEnd = (int)m_strFormula.length();
+
+    a_sTok = string_type( m_strFormula.begin()+a_iPos, m_strFormula.begin()+iEnd);
+    a_iPos = iEnd;
+    return iEnd;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check if a built in operator or other token can be found
+      \param a_Tok  [out] Operator token if one is found. This can either be a binary operator or an infix operator token.
+      \return true if an operator token has been found.
+  */
+  bool ParserTokenReader::IsBuiltIn(token_type &a_Tok)
+  {
+    const char_type **pOprtDef = m_pParser->GetOprtDef();
+    const char_type* szFormula = m_strFormula.c_str();
+
+    // Compare token with function and operator strings
+    // check string for operator/function
+    for (int i=0; pOprtDef[i]; i++)
+    {
+#if !defined _UNICODE
+      std::size_t len = std::strlen( pOprtDef[i] );
+      if ( !std::strncmp(&szFormula[m_iPos], pOprtDef[i], len) )
+#else
+      // this would work for both UNICODE and char but it's so god damn ugly!!
+      // apart from this this cant be fast
+      std::size_t len( std::char_traits<char_type>::length(pOprtDef[i]) );
+      if ( string_type(pOprtDef[i]) == string_type(szFormula + m_iPos, szFormula + m_iPos + len) )
+#endif
+      {
+	      switch(i)
+	      {
+        case cmAND:
+        case cmOR:
+        case cmXOR:
+        case cmLT:
+		    case cmGT:
+		    case cmLE:
+		    case cmGE:
+		    case cmNEQ:  
+		    case cmEQ:
+		    case cmADD:
+		    case cmSUB:
+		    case cmMUL:
+		    case cmDIV:
+		    case cmPOW:
+        case cmASSIGN:
+                      // The assignement operator need special treatment
+                      if (i==cmASSIGN && m_iSynFlags & noASSIGN)
+                        Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]);
+
+                      if (!m_pParser->HasBuiltInOprt()) continue;
+                      if (m_iSynFlags & noOPT) 
+                      {
+                        // Maybe its an infix operator not an operator
+                        // Both operator types can share characters in 
+                        // their identifiers
+                        if ( IsInfixOpTok(a_Tok) ) 
+                          return true;
+
+                        Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]);
+                      }
+
+                      m_iSynFlags  = noBC | noOPT | noCOMMA | noPOSTOP | noASSIGN;
+				              m_iSynFlags |= ( (i != cmEND) && ( i != cmBC) ) ? noEND : 0;
+				              break;
+
+		    case cmCOMMA:
+				              if (m_iSynFlags & noCOMMA)
+					              Error(ecUNEXPECTED_COMMA, m_iPos, pOprtDef[i]);
+        			
+				              m_iSynFlags  = noBC | noOPT | noEND | noCOMMA | noPOSTOP | noASSIGN;
+			                break;
+
+		    case cmBO:
+				              if (m_iSynFlags & noBO)
+					              Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]);
+
+				              m_iSynFlags = noBC | noOPT | noEND | noCOMMA | noPOSTOP | noASSIGN;
+                      ++m_iBrackets;
+				              break;
+
+		    case cmBC:
+				              if (m_iSynFlags & noBC)
+					              Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]);
+
+				              m_iSynFlags  = noBO | noVAR | noVAL | noFUN | noINFIXOP | noSTR | noASSIGN;
+
+                      if (--m_iBrackets<0)
+                        Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]);
+                      break;
+      	
+		    default:      // The operator is listed in c_DefaultOprt, but not here. This is a bad thing...
+                      Error(ecINTERNAL_ERROR);
+	      } // switch operator id
+
+        m_iPos += (int)len;
+        a_Tok.Set( (ECmdCode)i, pOprtDef[i] );
+        return true;
+	    } // if operator string found
+    } // end of for all operator strings
+  
+    return false;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check for End of Formula.
+
+      \return true if an end of formula is found false otherwise.
+      \param a_Tok [out] If an eof is found the corresponding token will be stored there.
+      \throw nothrow
+      \sa IsOprt, IsFunTok, IsStrFunTok, IsValTok, IsVarTok, IsString, IsInfixOpTok, IsPostOpTok
+  */
+  bool ParserTokenReader::IsEOF(token_type &a_Tok)
+  {
+    const char_type* szFormula = m_strFormula.c_str();
+
+    // check for EOF
+    if ( !szFormula[m_iPos] || szFormula[m_iPos] == '\n')
+    {
+      if ( m_iSynFlags & noEND )
+        Error(ecUNEXPECTED_EOF, m_iPos);
+
+      if (m_iBrackets>0)
+        Error(ecMISSING_PARENS, m_iPos, _T(")"));
+
+      m_iSynFlags = 0;
+      a_Tok.Set(cmEND);
+      return true;
+    }
+
+    return false;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check if a string position contains a unary infix operator. 
+      \return true if a function token has been found false otherwise.
+  */
+  bool ParserTokenReader::IsInfixOpTok(token_type &a_Tok)
+  {
+    string_type sTok;
+    int iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    funmap_type::const_iterator item = m_pInfixOprtDef->find(sTok);
+    if (item==m_pInfixOprtDef->end())
+      return false;
+
+    a_Tok.Set(item->second, sTok);
+    m_iPos = (int)iEnd;
+
+    if (m_iSynFlags & noINFIXOP) 
+      Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString());
+
+    m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN; 
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check whether the token at a given position is a function token.
+      \param a_Tok [out] If a value token is found it will be placed here.
+      \throw ParserException if Syntaxflags do not allow a function at a_iPos
+      \return true if a function token has been found false otherwise.
+      \pre [assert] m_pParser!=0
+  */
+  bool ParserTokenReader::IsFunTok(token_type &a_Tok)
+  {
+    string_type strTok;
+    int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    funmap_type::const_iterator item = m_pFunDef->find(strTok);
+    if (item==m_pFunDef->end())
+        return false;
+
+    a_Tok.Set(item->second, strTok);
+
+    m_iPos = (int)iEnd;
+    if (m_iSynFlags & noFUN)
+      Error(ecUNEXPECTED_FUN, m_iPos-(int)a_Tok.GetAsString().length(), a_Tok.GetAsString());
+
+    m_iSynFlags = noANY ^ noBO;
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check if a string position contains a binary operator.
+      \param a_Tok  [out] Operator token if one is found. This can either be a binary operator or an infix operator token.
+      \return true if an operator token has been found.
+  */
+  bool ParserTokenReader::IsOprt(token_type &a_Tok)
+  {
+    string_type strTok;
+    int iEnd = ExtractToken(m_pParser->ValidOprtChars(), strTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    funmap_type::const_iterator item = m_pOprtDef->find(strTok);
+    if (item==m_pOprtDef->end())
+      return false;
+
+    a_Tok.Set(item->second, strTok);
+
+    if (m_iSynFlags & noOPT) 
+    {
+      // An operator was found but is not expected to occur at
+      // this position of the formula, maybe it is an infix 
+      // operator, not a binary operator. Both operator types
+      // can share characters in their identifiers.
+      if ( IsInfixOpTok(a_Tok) ) return true;
+      // nope, no infix operator
+      Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); 
+    }
+
+    m_iPos = (int)iEnd;
+    m_iSynFlags  = noBC | noOPT | noCOMMA | noPOSTOP | noEND | noBC | noASSIGN;
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check if a string position contains a unary post value operator. */
+  bool ParserTokenReader::IsPostOpTok(token_type &a_Tok)
+  {
+    // Tricky problem with equations like "3m+5":
+    //     m is a postfix operator, + is a valid sign for postfix operators and 
+    //     for binary operators parser detects "m+" as operator string and 
+    //     finds no matching postfix operator.
+    // 
+    // This is a special case so this routine slightly differs from the other
+    // token readers.
+    
+    // Test if there could be a postfix operator
+    string_type sTok;
+    int iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    // iteraterate over all postfix operator strings
+    funmap_type::const_iterator item = m_pPostOprtDef->begin();
+    for (item=m_pPostOprtDef->begin(); item!=m_pPostOprtDef->end(); ++item)
+    {
+      if (sTok.find(item->first)!=0)
+        continue;
+
+      a_Tok.Set(item->second, sTok);
+  	  m_iPos += (int)item->first.length();
+
+      if (m_iSynFlags & noPOSTOP)
+        Error(ecUNEXPECTED_OPERATOR, m_iPos-(int)item->first.length(), item->first);
+
+      m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noSTR | noASSIGN;
+      return true;
+    }
+
+    return false;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check whether the token at a given position is a value token.
+
+    Value tokens are either values or constants.
+
+    \param a_Tok [out] If a value token is found it will be placed here.
+    \return true if a value token has been found.
+  */
+  bool ParserTokenReader::IsValTok(token_type &a_Tok)
+  {
+    assert(m_pConstDef);
+    assert(m_pParser);
+
+    #if defined(_MSC_VER)
+      #pragma warning( disable : 4244 )
+    #endif
+
+    string_type strTok;
+    value_type fVal(0);
+    int iEnd(0);
+    
+    // 2.) Check for user defined constant
+    // Read everything that could be a constant name
+    iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos);
+    if (iEnd!=m_iPos)
+    {
+      valmap_type::const_iterator item = m_pConstDef->find(strTok);
+      if (item!=m_pConstDef->end())
+      {
+        m_iPos = iEnd;
+        a_Tok.SetVal(item->second, strTok);
+
+        if (m_iSynFlags & noVAL)
+          Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok);
+
+        m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; 
+        return true;
+      }
+    }
+
+    // 3.call the value recognition functions provided by the user
+    // Call user defined value recognition functions
+    std::vector<identfun_type>::const_iterator item = m_vIdentFun.begin();
+    for (item = m_vIdentFun.begin(); item!=m_vIdentFun.end(); ++item)
+    {
+      int iStart = m_iPos;
+      if ( (*item)(m_strFormula.c_str() + m_iPos, m_iPos, fVal) )
+      {
+        strTok.assign(m_strFormula.c_str(), iStart, m_iPos);
+        if (m_iSynFlags & noVAL)
+          Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok);
+
+        a_Tok.SetVal(fVal, strTok);
+        m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN;
+        return true;
+      }
+    }
+
+    return false;
+
+    #if defined(_MSC_VER)
+      #pragma warning( default : 4244 )
+    #endif
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check wheter a token at a given position is a variable token. 
+      \param a_Tok [out] If a variable token has been found it will be placed here.
+	    \return true if a variable token has been found.
+  */
+  bool ParserTokenReader::IsVarTok(token_type &a_Tok)
+  {
+    if (!m_pVarDef->size())
+      return false;
+
+    string_type strTok;
+    int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    varmap_type::const_iterator item =  m_pVarDef->find(strTok);
+    if (item==m_pVarDef->end())
+      return false;
+
+    if (m_iSynFlags & noVAR)
+      Error(ecUNEXPECTED_VAR, m_iPos, strTok);
+
+    m_iPos = iEnd;
+    a_Tok.SetVar(item->second, strTok);
+    m_UsedVar[item->first] = item->second;  // Add variable to used-var-list
+
+    m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noINFIXOP | noSTR;
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  bool ParserTokenReader::IsStrVarTok(token_type &a_Tok)
+  {
+    if (!m_pStrVarDef || !m_pStrVarDef->size())
+      return false;
+
+    string_type strTok;
+    int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    strmap_type::const_iterator item =  m_pStrVarDef->find(strTok);
+    if (item==m_pStrVarDef->end())
+      return false;
+
+    if (m_iSynFlags & noSTR)
+      Error(ecUNEXPECTED_VAR, m_iPos, strTok);
+
+    m_iPos = iEnd;
+    if (!m_pParser->m_vStringVarBuf.size())
+      Error(ecINTERNAL_ERROR);
+
+    a_Tok.SetString(m_pParser->m_vStringVarBuf[item->second], m_pParser->m_vStringVarBuf.size() );
+
+    m_iSynFlags = m_iSynFlags = noANY ^ ( noBC | noOPT | noEND | noCOMMA);
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check wheter a token at a given position is an undefined variable. 
+
+      \param a_Tok [out] If a variable tom_pParser->m_vStringBufken has been found it will be placed here.
+	    \return true if a variable token has been found.
+      \throw nothrow
+  */
+  bool ParserTokenReader::IsUndefVarTok(token_type &a_Tok)
+  {
+    string_type strTok;
+    int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos);
+    if (iEnd==m_iPos)
+      return false;
+
+    if (m_iSynFlags & noVAR)
+    {
+      // <ibg/> 20061021 added token string strTok instead of a_Tok.GetAsString() as the 
+      //                token identifier.
+      Error(ecUNEXPECTED_VAR, m_iPos - (int)a_Tok.GetAsString().length(), strTok);
+    }
+
+    // If a factory is available implicitely create new variables
+    if (m_pFactory)
+    {
+      value_type *fVar = m_pFactory(strTok.c_str(), m_pFactoryData);
+      a_Tok.SetVar(fVar, strTok );
+
+      // Do not use m_pParser->DefineVar( strTok, fVar );
+      // in order to define the new variable, it will clear the
+      // m_UsedVar array which will kill previousely defined variables
+      // from the list
+      // This is safe because the new variable can never override an existing one
+      // because they are checked first!
+      (*m_pVarDef)[strTok] = fVar;
+      m_UsedVar[strTok] = fVar;  // Add variable to used-var-list
+    }
+    else
+    {
+      a_Tok.SetVar((value_type*)&m_fZero, strTok);
+      m_UsedVar[strTok] = 0;  // Add variable to used-var-list
+    }
+
+    m_iPos = iEnd;
+
+    // Call the variable factory in order to let it define a new parser variable
+    m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noINFIXOP | noSTR;
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Check wheter a token at a given position is a string.
+
+      \param a_Tok [out] If a variable token has been found it will be placed here.
+  	  \return true if a string token has been found.
+      \sa IsOprt, IsFunTok, IsStrFunTok, IsValTok, IsVarTok, IsEOF, IsInfixOpTok, IsPostOpTok
+      \throw nothrow
+  */
+  bool ParserTokenReader::IsString(token_type &a_Tok)
+  {
+    if (m_strFormula[m_iPos]!='"') 
+      return false;
+
+    string_type strBuf(&m_strFormula[m_iPos+1]);
+    std::size_t iEnd(0), iSkip(0);
+
+    // parser over escaped '\"' end replace them with '"'
+    for(iEnd=(int)strBuf.find( _T("\"") ); iEnd!=string_type::npos; iEnd=(int)strBuf.find( _T("\""), iEnd))
+    {
+      if (strBuf[iEnd-1]!='\\') break;
+      strBuf.replace(iEnd-1, 2, _T("\"") );
+      iSkip++;
+    }
+
+    if (iEnd==string_type::npos)
+      Error(ecUNTERMINATED_STRING, m_iPos, _T("\"") );
+
+    string_type strTok(strBuf.begin(), strBuf.begin()+iEnd);
+
+    if (m_iSynFlags & noSTR)
+      Error(ecUNEXPECTED_STR, m_iPos, strTok);
+
+		m_pParser->m_vStringBuf.push_back(strTok); // Store string in internal buffer
+    a_Tok.SetString(strTok, m_pParser->m_vStringBuf.size());
+
+    m_iPos += (int)strTok.length() + 2 + (int)iSkip;  // +2 wg Anf�hrungszeichen; +iSkip f�r entfernte escape zeichen
+    m_iSynFlags = m_iSynFlags = noANY ^ ( noCOMMA | noBC | noOPT | noEND );
+
+    return true;
+  }
+
+  //---------------------------------------------------------------------------
+  /** \brief Create an error containing the parse error position.
+
+    This function will create an Parser Exception object containing the error text and its position.
+
+    \param a_iErrc [in] The error code of type #EErrorCodes.
+    \param a_iPos [in] The position where the error was detected.
+    \param a_strTok [in] The token string representation associated with the error.
+    \throw ParserException always throws thats the only purpose of this function.
+  */
+  void  ParserTokenReader::Error( EErrorCodes a_iErrc, 
+                                  int a_iPos, 
+                                  const string_type &a_sTok) const
+  {
+    m_pParser->Error(a_iErrc, a_iPos, a_sTok);
+  }
+} // namespace mu
+
diff --git a/muparser/muParserTokenReader.h b/muparser/muParserTokenReader.h
new file mode 100644
index 0000000..122586e
--- /dev/null
+++ b/muparser/muParserTokenReader.h
@@ -0,0 +1,156 @@
+/*
+                 __________                                      
+    _____   __ __\______   \_____  _______  ______  ____ _______ 
+   /     \ |  |  \|     ___/\__  \ \_  __ \/  ___/_/ __ \\_  __ \
+  |  Y Y  \|  |  /|    |     / __ \_|  | \/\___ \ \  ___/ |  | \/
+  |__|_|  /|____/ |____|    (____  /|__|  /____  > \___  >|__|   
+        \/                       \/            \/      \/        
+  Copyright (C) 2004-2006 Ingo Berg
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+  software and associated documentation files (the "Software"), to deal in the Software
+  without restriction, including without limitation the rights to use, copy, modify, 
+  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to 
+  permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all copies or 
+  substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+  NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
+*/
+
+#ifndef MU_PARSER_TOKEN_READER_H
+#define MU_PARSER_TOKEN_READER_H
+
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <memory>
+#include <stack>
+#include <string>
+
+#include "muParserDef.h"
+#include "muParserToken.h"
+
+
+namespace mu
+{
+
+  // Forward declaration
+  class ParserBase;
+
+  /** \brief Token reader for the ParserBase class.
+
+  */
+  class ParserTokenReader 
+  {
+  private:
+      typedef ParserToken<value_type, string_type> token_type;
+      
+  private:
+      ParserBase *m_pParser;
+      string_type m_strFormula;
+      int  m_iPos;
+      int  m_iSynFlags;
+      bool m_bIgnoreUndefVar;
+
+      const funmap_type *m_pFunDef;
+      const funmap_type *m_pPostOprtDef;
+      const funmap_type *m_pInfixOprtDef;
+      const funmap_type *m_pOprtDef;
+      const valmap_type *m_pConstDef;
+      const strmap_type *m_pStrVarDef;
+      varmap_type *m_pVarDef;  ///< The only non const pointer to parser internals
+      facfun_type m_pFactory;
+      void *m_pFactoryData;
+      std::vector<identfun_type> m_vIdentFun; ///< Value token identification function
+      varmap_type m_UsedVar;
+      value_type m_fZero;      ///< Dummy value of zero, referenced by undefined variables
+      int m_iBrackets;
+
+  //
+  // private Functions
+  //
+  private:
+
+      /** \brief Syntax codes. 
+  	
+	        The syntax codes control the syntax check done during the first time parsing of 
+          the expression string. They are flags that indicate which tokens are allowed next
+          if certain tokens are identified.
+  	  */
+      enum ESynCodes
+      {
+        noBO      = 1 << 0,  ///< to avoid i.e. "cos(7)(" 
+        noBC      = 1 << 1,  ///< to avoid i.e. "sin)" or "()"
+        noVAL     = 1 << 2,  ///< to avoid i.e. "tan 2" or "sin(8)3.14"
+        noVAR     = 1 << 3,  ///< to avoid i.e. "sin a" or "sin(8)a"
+        noCOMMA   = 1 << 4,  ///< to avoid i.e. ",," or "+," ...
+        noFUN     = 1 << 5,  ///< to avoid i.e. "sqrt cos" or "(1)sin"	
+        noOPT     = 1 << 6,  ///< to avoid i.e. "(+)"
+        noPOSTOP  = 1 << 7,  ///< to avoid i.e. "(5!!)" "sin!"
+	      noINFIXOP = 1 << 8,  ///< to avoid i.e. "++4" "!!4"
+        noEND     = 1 << 9,  ///< to avoid unexpected end of formula
+        noSTR     = 1 << 10, ///< to block numeric arguments on string functions
+        noASSIGN  = 1 << 11, ///< to block assignement to constant i.e. "4=7"
+        noANY     = ~0       ///< All of he above flags set
+      };	
+
+      ParserTokenReader(const ParserTokenReader &a_Reader);
+      ParserTokenReader& operator=(const ParserTokenReader &a_Reader);
+      void Assign(const ParserTokenReader &a_Reader);
+
+  public:
+      ParserTokenReader(ParserBase *a_pParent);
+     ~ParserTokenReader();
+      ParserTokenReader* Clone(ParserBase *a_pParent) const;
+
+      void AddValIdent(identfun_type a_pCallback);
+      void SetVarCreator(facfun_type a_pFactory, void *pUserData);
+      int GetPos() const;
+      const string_type& GetFormula() const;
+      const varmap_type& GetUsedVar() const;
+      void SetFormula(const string_type &a_strFormula);
+      void SetDefs( const funmap_type *a_pFunDef, 
+                    const funmap_type *a_pOprtDef,
+                    const funmap_type *a_pInfixOprtDef,
+                    const funmap_type *a_pPostOprtDef,
+                    varmap_type *a_pVarDef,
+                    const strmap_type *a_pStrVarDef,
+                    const valmap_type *a_pConstDef );
+      void IgnoreUndefVar(bool bIgnore);
+      void ReInit();
+      token_type ReadNextToken();
+
+  //
+  // private functions
+  //
+  private:
+
+      void SetParent(ParserBase *a_pParent);
+      int ExtractToken( const char_type *a_szCharSet, 
+                        string_type &a_strTok, int a_iPos ) const;
+      bool IsBuiltIn(token_type &a_Tok);
+      bool IsEOF(token_type &a_Tok);
+      bool IsInfixOpTok(token_type &a_Tok);
+      bool IsFunTok(token_type &a_Tok);
+      bool IsPostOpTok(token_type &a_Tok);
+      bool IsOprt(token_type &a_Tok);
+      bool IsValTok(token_type &a_Tok);
+      bool IsVarTok(token_type &a_Tok);
+      bool IsStrVarTok(token_type &a_Tok);
+      bool IsUndefVarTok(token_type &a_Tok);
+      bool IsString(token_type &a_Tok);
+      void Error( EErrorCodes a_iErrc, int a_iPos = -1, 
+                  const string_type &a_sTok = string_type() ) const;
+  };
+} // namespace mu
+
+#endif
+
+
diff --git a/run_me b/run_me
new file mode 100755
index 0000000..a920e69
--- /dev/null
+++ b/run_me
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+echo "To run the program: type ./optcli"
+echo "To re-build the program, type: make clean;make"
+
diff --git a/samples/a b/samples/a
new file mode 100755
index 0000000..b8b8e8c
--- /dev/null
+++ b/samples/a
diff --git a/samples/a.cc b/samples/a.cc
new file mode 100644
index 0000000..1cf92df
--- /dev/null
+++ b/samples/a.cc
@@ -0,0 +1,36 @@
+#include <cmath>
+#include <fstream>
+#include <iostream>
+using namespace std;
+
+double powerlaw(double x)
+{
+  return 5*pow(x,-1.1);
+}
+
+double bpl(double x)
+{
+  double x_b=5;
+  double f_b=10;
+  double gamma1=-0.8;
+  double gamma2=-1.5;
+  if(x<x_b)
+    {
+      return f_b*pow(x,gamma1)/pow(x_b,gamma1);
+    }
+  else
+    {
+      return f_b*pow(x,gamma2)/pow(x_b,gamma2);
+    }
+}
+
+
+
+int main()
+{
+  double x,y,x1,x2,y1,y2;
+  while(cin>>x>>x1>>x2>>y>>y1>>y2)
+    {
+      cout<<x<<"\t"<<y<<"\t"<<y-y1<<"\t"<<y+y2<<endl;
+    }
+}
diff --git a/samples/a.dat b/samples/a.dat
new file mode 100644
index 0000000..8ca360f
--- /dev/null
+++ b/samples/a.dat
@@ -0,0 +1,4 @@
+0	4	3	5
+1	7	6	8
+2	10	9	11
+3	13	12	14
diff --git a/samples/bpl.dat b/samples/bpl.dat
new file mode 100644
index 0000000..f7e9490
--- /dev/null
+++ b/samples/bpl.dat
@@ -0,0 +1,901 @@
+1 0 0 36.239 .01 .01
+1.01 0 0 35.9517 .01 .01
+1.02 0 0 35.6694 .01 .01
+1.03 0 0 35.3921 .01 .01
+1.04 0 0 35.1196 .01 .01
+1.05 0 0 34.8517 .01 .01
+1.06 0 0 34.5885 .01 .01
+1.07 0 0 34.3296 .01 .01
+1.08 0 0 34.0751 .01 .01
+1.09 0 0 33.8248 .01 .01
+1.1 0 0 33.5785 .01 .01
+1.11 0 0 33.3363 .01 .01
+1.12 0 0 33.098 .01 .01
+1.13 0 0 32.8635 .01 .01
+1.14 0 0 32.6326 .01 .01
+1.15 0 0 32.4054 .01 .01
+1.16 0 0 32.1817 .01 .01
+1.17 0 0 31.9615 .01 .01
+1.18 0 0 31.7446 .01 .01
+1.19 0 0 31.5311 .01 .01
+1.2 0 0 31.3207 .01 .01
+1.21 0 0 31.1134 .01 .01
+1.22 0 0 30.9092 .01 .01
+1.23 0 0 30.708 .01 .01
+1.24 0 0 30.5098 .01 .01
+1.25 0 0 30.3143 .01 .01
+1.26 0 0 30.1217 .01 .01
+1.27 0 0 29.9318 .01 .01
+1.28 0 0 29.7446 .01 .01
+1.29 0 0 29.56 .01 .01
+1.3 0 0 29.3779 .01 .01
+1.31 0 0 29.1984 .01 .01
+1.32 0 0 29.0213 .01 .01
+1.33 0 0 28.8466 .01 .01
+1.34 0 0 28.6743 .01 .01
+1.35 0 0 28.5042 .01 .01
+1.36 0 0 28.3364 .01 .01
+1.37 0 0 28.1708 .01 .01
+1.38 0 0 28.0074 .01 .01
+1.39 0 0 27.8461 .01 .01
+1.4 0 0 27.6869 .01 .01
+1.41 0 0 27.5297 .01 .01
+1.42 0 0 27.3744 .01 .01
+1.43 0 0 27.2212 .01 .01
+1.44 0 0 27.0699 .01 .01
+1.45 0 0 26.9204 .01 .01
+1.46 0 0 26.7728 .01 .01
+1.47 0 0 26.627 .01 .01
+1.48 0 0 26.483 .01 .01
+1.49 0 0 26.3407 .01 .01
+1.5 0 0 26.2001 .01 .01
+1.51 0 0 26.0612 .01 .01
+1.52 0 0 25.9239 .01 .01
+1.53 0 0 25.7883 .01 .01
+1.54 0 0 25.6543 .01 .01
+1.55 0 0 25.5218 .01 .01
+1.56 0 0 25.3908 .01 .01
+1.57 0 0 25.2613 .01 .01
+1.58 0 0 25.1333 .01 .01
+1.59 0 0 25.0068 .01 .01
+1.6 0 0 24.8817 .01 .01
+1.61 0 0 24.758 .01 .01
+1.62 0 0 24.6356 .01 .01
+1.63 0 0 24.5147 .01 .01
+1.64 0 0 24.395 .01 .01
+1.65 0 0 24.2767 .01 .01
+1.66 0 0 24.1596 .01 .01
+1.67 0 0 24.0438 .01 .01
+1.68 0 0 23.9292 .01 .01
+1.69 0 0 23.8159 .01 .01
+1.7 0 0 23.7037 .01 .01
+1.71 0 0 23.5928 .01 .01
+1.72 0 0 23.483 .01 .01
+1.73 0 0 23.3743 .01 .01
+1.74 0 0 23.2668 .01 .01
+1.75 0 0 23.1604 .01 .01
+1.76 0 0 23.055 .01 .01
+1.77 0 0 22.9508 .01 .01
+1.78 0 0 22.8476 .01 .01
+1.79 0 0 22.7454 .01 .01
+1.8 0 0 22.6443 .01 .01
+1.81 0 0 22.5441 .01 .01
+1.82 0 0 22.445 .01 .01
+1.83 0 0 22.3468 .01 .01
+1.84 0 0 22.2496 .01 .01
+1.85 0 0 22.1533 .01 .01
+1.86 0 0 22.058 .01 .01
+1.87 0 0 21.9636 .01 .01
+1.88 0 0 21.87 .01 .01
+1.89 0 0 21.7774 .01 .01
+1.9 0 0 21.6857 .01 .01
+1.91 0 0 21.5948 .01 .01
+1.92 0 0 21.5048 .01 .01
+1.93 0 0 21.4156 .01 .01
+1.94 0 0 21.3272 .01 .01
+1.95 0 0 21.2397 .01 .01
+1.96 0 0 21.153 .01 .01
+1.97 0 0 21.067 .01 .01
+1.98 0 0 20.9819 .01 .01
+1.99 0 0 20.8975 .01 .01
+2 0 0 20.8138 .01 .01
+2.01 0 0 20.7309 .01 .01
+2.02 0 0 20.6488 .01 .01
+2.03 0 0 20.5674 .01 .01
+2.04 0 0 20.4867 .01 .01
+2.05 0 0 20.4067 .01 .01
+2.06 0 0 20.3274 .01 .01
+2.07 0 0 20.2488 .01 .01
+2.08 0 0 20.1709 .01 .01
+2.09 0 0 20.0937 .01 .01
+2.1 0 0 20.0171 .01 .01
+2.11 0 0 19.9411 .01 .01
+2.12 0 0 19.8659 .01 .01
+2.13 0 0 19.7912 .01 .01
+2.14 0 0 19.7172 .01 .01
+2.15 0 0 19.6438 .01 .01
+2.16 0 0 19.571 .01 .01
+2.17 0 0 19.4988 .01 .01
+2.18 0 0 19.4272 .01 .01
+2.19 0 0 19.3562 .01 .01
+2.2 0 0 19.2858 .01 .01
+2.21 0 0 19.216 .01 .01
+2.22 0 0 19.1467 .01 .01
+2.23 0 0 19.078 .01 .01
+2.24 0 0 19.0098 .01 .01
+2.25 0 0 18.9422 .01 .01
+2.26 0 0 18.8751 .01 .01
+2.27 0 0 18.8086 .01 .01
+2.28 0 0 18.7425 .01 .01
+2.29 0 0 18.677 .01 .01
+2.3 0 0 18.612 .01 .01
+2.31 0 0 18.5475 .01 .01
+2.32 0 0 18.4836 .01 .01
+2.33 0 0 18.4201 .01 .01
+2.34 0 0 18.3571 .01 .01
+2.35 0 0 18.2945 .01 .01
+2.36 0 0 18.2325 .01 .01
+2.37 0 0 18.1709 .01 .01
+2.38 0 0 18.1098 .01 .01
+2.39 0 0 18.0492 .01 .01
+2.4 0 0 17.989 .01 .01
+2.41 0 0 17.9293 .01 .01
+2.42 0 0 17.87 .01 .01
+2.43 0 0 17.8111 .01 .01
+2.44 0 0 17.7527 .01 .01
+2.45 0 0 17.6947 .01 .01
+2.46 0 0 17.6371 .01 .01
+2.47 0 0 17.58 .01 .01
+2.48 0 0 17.5233 .01 .01
+2.49 0 0 17.4669 .01 .01
+2.5 0 0 17.411 .01 .01
+2.51 0 0 17.3555 .01 .01
+2.52 0 0 17.3004 .01 .01
+2.53 0 0 17.2457 .01 .01
+2.54 0 0 17.1913 .01 .01
+2.55 0 0 17.1374 .01 .01
+2.56 0 0 17.0838 .01 .01
+2.57 0 0 17.0306 .01 .01
+2.58 0 0 16.9778 .01 .01
+2.59 0 0 16.9253 .01 .01
+2.6 0 0 16.8732 .01 .01
+2.61 0 0 16.8215 .01 .01
+2.62 0 0 16.7701 .01 .01
+2.63 0 0 16.719 .01 .01
+2.64 0 0 16.6684 .01 .01
+2.65 0 0 16.618 .01 .01
+2.66 0 0 16.568 .01 .01
+2.67 0 0 16.5184 .01 .01
+2.68 0 0 16.469 .01 .01
+2.69 0 0 16.42 .01 .01
+2.7 0 0 16.3714 .01 .01
+2.71 0 0 16.323 .01 .01
+2.72 0 0 16.275 .01 .01
+2.73 0 0 16.2273 .01 .01
+2.74 0 0 16.1799 .01 .01
+2.75 0 0 16.1328 .01 .01
+2.76 0 0 16.086 .01 .01
+2.77 0 0 16.0396 .01 .01
+2.78 0 0 15.9934 .01 .01
+2.79 0 0 15.9475 .01 .01
+2.8 0 0 15.9019 .01 .01
+2.81 0 0 15.8566 .01 .01
+2.82 0 0 15.8116 .01 .01
+2.83 0 0 15.7669 .01 .01
+2.84 0 0 15.7225 .01 .01
+2.85 0 0 15.6783 .01 .01
+2.86 0 0 15.6345 .01 .01
+2.87 0 0 15.5909 .01 .01
+2.88 0 0 15.5476 .01 .01
+2.89 0 0 15.5045 .01 .01
+2.9 0 0 15.4617 .01 .01
+2.91 0 0 15.4192 .01 .01
+2.92 0 0 15.3769 .01 .01
+2.93 0 0 15.3349 .01 .01
+2.94 0 0 15.2932 .01 .01
+2.95 0 0 15.2517 .01 .01
+2.96 0 0 15.2105 .01 .01
+2.97 0 0 15.1695 .01 .01
+2.98 0 0 15.1287 .01 .01
+2.99 0 0 15.0883 .01 .01
+3 0 0 15.048 .01 .01
+3.01 0 0 15.008 .01 .01
+3.02 0 0 14.9682 .01 .01
+3.03 0 0 14.9287 .01 .01
+3.04 0 0 14.8894 .01 .01
+3.05 0 0 14.8503 .01 .01
+3.06 0 0 14.8115 .01 .01
+3.07 0 0 14.7729 .01 .01
+3.08 0 0 14.7345 .01 .01
+3.09 0 0 14.6963 .01 .01
+3.1 0 0 14.6584 .01 .01
+3.11 0 0 14.6207 .01 .01
+3.12 0 0 14.5832 .01 .01
+3.13 0 0 14.5459 .01 .01
+3.14 0 0 14.5088 .01 .01
+3.15 0 0 14.472 .01 .01
+3.16 0 0 14.4353 .01 .01
+3.17 0 0 14.3989 .01 .01
+3.18 0 0 14.3626 .01 .01
+3.19 0 0 14.3266 .01 .01
+3.2 0 0 14.2908 .01 .01
+3.21 0 0 14.2552 .01 .01
+3.22 0 0 14.2197 .01 .01
+3.23 0 0 14.1845 .01 .01
+3.24 0 0 14.1495 .01 .01
+3.25 0 0 14.1146 .01 .01
+3.26 0 0 14.08 .01 .01
+3.27 0 0 14.0455 .01 .01
+3.28 0 0 14.0113 .01 .01
+3.29 0 0 13.9772 .01 .01
+3.3 0 0 13.9433 .01 .01
+3.31 0 0 13.9096 .01 .01
+3.32 0 0 13.876 .01 .01
+3.33 0 0 13.8427 .01 .01
+3.34 0 0 13.8095 .01 .01
+3.35 0 0 13.7765 .01 .01
+3.36 0 0 13.7437 .01 .01
+3.37 0 0 13.7111 .01 .01
+3.38 0 0 13.6786 .01 .01
+3.39 0 0 13.6463 .01 .01
+3.4 0 0 13.6142 .01 .01
+3.41 0 0 13.5823 .01 .01
+3.42 0 0 13.5505 .01 .01
+3.43 0 0 13.5189 .01 .01
+3.44 0 0 13.4874 .01 .01
+3.45 0 0 13.4561 .01 .01
+3.46 0 0 13.425 .01 .01
+3.47 0 0 13.3941 .01 .01
+3.48 0 0 13.3633 .01 .01
+3.49 0 0 13.3326 .01 .01
+3.5 0 0 13.3021 .01 .01
+3.51 0 0 13.2718 .01 .01
+3.52 0 0 13.2416 .01 .01
+3.53 0 0 13.2116 .01 .01
+3.54 0 0 13.1818 .01 .01
+3.55 0 0 13.152 .01 .01
+3.56 0 0 13.1225 .01 .01
+3.57 0 0 13.0931 .01 .01
+3.58 0 0 13.0638 .01 .01
+3.59 0 0 13.0347 .01 .01
+3.6 0 0 13.0057 .01 .01
+3.61 0 0 12.9769 .01 .01
+3.62 0 0 12.9482 .01 .01
+3.63 0 0 12.9196 .01 .01
+3.64 0 0 12.8912 .01 .01
+3.65 0 0 12.863 .01 .01
+3.66 0 0 12.8349 .01 .01
+3.67 0 0 12.8069 .01 .01
+3.68 0 0 12.779 .01 .01
+3.69 0 0 12.7513 .01 .01
+3.7 0 0 12.7237 .01 .01
+3.71 0 0 12.6963 .01 .01
+3.72 0 0 12.669 .01 .01
+3.73 0 0 12.6418 .01 .01
+3.74 0 0 12.6148 .01 .01
+3.75 0 0 12.5878 .01 .01
+3.76 0 0 12.561 .01 .01
+3.77 0 0 12.5344 .01 .01
+3.78 0 0 12.5078 .01 .01
+3.79 0 0 12.4814 .01 .01
+3.8 0 0 12.4552 .01 .01
+3.81 0 0 12.429 .01 .01
+3.82 0 0 12.403 .01 .01
+3.83 0 0 12.377 .01 .01
+3.84 0 0 12.3513 .01 .01
+3.85 0 0 12.3256 .01 .01
+3.86 0 0 12.3 .01 .01
+3.87 0 0 12.2746 .01 .01
+3.88 0 0 12.2493 .01 .01
+3.89 0 0 12.2241 .01 .01
+3.9 0 0 12.199 .01 .01
+3.91 0 0 12.174 .01 .01
+3.92 0 0 12.1492 .01 .01
+3.93 0 0 12.1244 .01 .01
+3.94 0 0 12.0998 .01 .01
+3.95 0 0 12.0753 .01 .01
+3.96 0 0 12.0509 .01 .01
+3.97 0 0 12.0266 .01 .01
+3.98 0 0 12.0024 .01 .01
+3.99 0 0 11.9784 .01 .01
+4 0 0 11.9544 .01 .01
+4.01 0 0 11.9306 .01 .01
+4.02 0 0 11.9068 .01 .01
+4.03 0 0 11.8832 .01 .01
+4.04 0 0 11.8596 .01 .01
+4.05 0 0 11.8362 .01 .01
+4.06 0 0 11.8129 .01 .01
+4.07 0 0 11.7896 .01 .01
+4.08 0 0 11.7665 .01 .01
+4.09 0 0 11.7435 .01 .01
+4.1 0 0 11.7206 .01 .01
+4.11 0 0 11.6978 .01 .01
+4.12 0 0 11.675 .01 .01
+4.13 0 0 11.6524 .01 .01
+4.14 0 0 11.6299 .01 .01
+4.15 0 0 11.6075 .01 .01
+4.16 0 0 11.5851 .01 .01
+4.17 0 0 11.5629 .01 .01
+4.18 0 0 11.5408 .01 .01
+4.19 0 0 11.5187 .01 .01
+4.2 0 0 11.4968 .01 .01
+4.21 0 0 11.4749 .01 .01
+4.22 0 0 11.4532 .01 .01
+4.23 0 0 11.4315 .01 .01
+4.24 0 0 11.4099 .01 .01
+4.25 0 0 11.3885 .01 .01
+4.26 0 0 11.3671 .01 .01
+4.27 0 0 11.3458 .01 .01
+4.28 0 0 11.3246 .01 .01
+4.29 0 0 11.3034 .01 .01
+4.3 0 0 11.2824 .01 .01
+4.31 0 0 11.2614 .01 .01
+4.32 0 0 11.2406 .01 .01
+4.33 0 0 11.2198 .01 .01
+4.34 0 0 11.1991 .01 .01
+4.35 0 0 11.1785 .01 .01
+4.36 0 0 11.158 .01 .01
+4.37 0 0 11.1376 .01 .01
+4.38 0 0 11.1172 .01 .01
+4.39 0 0 11.097 .01 .01
+4.4 0 0 11.0768 .01 .01
+4.41 0 0 11.0567 .01 .01
+4.42 0 0 11.0367 .01 .01
+4.43 0 0 11.0167 .01 .01
+4.44 0 0 10.9969 .01 .01
+4.45 0 0 10.9771 .01 .01
+4.46 0 0 10.9574 .01 .01
+4.47 0 0 10.9378 .01 .01
+4.48 0 0 10.9183 .01 .01
+4.49 0 0 10.8988 .01 .01
+4.5 0 0 10.8794 .01 .01
+4.51 0 0 10.8601 .01 .01
+4.52 0 0 10.8409 .01 .01
+4.53 0 0 10.8217 .01 .01
+4.54 0 0 10.8027 .01 .01
+4.55 0 0 10.7837 .01 .01
+4.56 0 0 10.7648 .01 .01
+4.57 0 0 10.7459 .01 .01
+4.58 0 0 10.7271 .01 .01
+4.59 0 0 10.7084 .01 .01
+4.6 0 0 10.6898 .01 .01
+4.61 0 0 10.6712 .01 .01
+4.62 0 0 10.6528 .01 .01
+4.63 0 0 10.6344 .01 .01
+4.64 0 0 10.616 .01 .01
+4.65 0 0 10.5977 .01 .01
+4.66 0 0 10.5796 .01 .01
+4.67 0 0 10.5614 .01 .01
+4.68 0 0 10.5434 .01 .01
+4.69 0 0 10.5254 .01 .01
+4.7 0 0 10.5075 .01 .01
+4.71 0 0 10.4896 .01 .01
+4.72 0 0 10.4718 .01 .01
+4.73 0 0 10.4541 .01 .01
+4.74 0 0 10.4365 .01 .01
+4.75 0 0 10.4189 .01 .01
+4.76 0 0 10.4014 .01 .01
+4.77 0 0 10.3839 .01 .01
+4.78 0 0 10.3665 .01 .01
+4.79 0 0 10.3492 .01 .01
+4.8 0 0 10.332 .01 .01
+4.81 0 0 10.3148 .01 .01
+4.82 0 0 10.2977 .01 .01
+4.83 0 0 10.2806 .01 .01
+4.84 0 0 10.2636 .01 .01
+4.85 0 0 10.2467 .01 .01
+4.86 0 0 10.2298 .01 .01
+4.87 0 0 10.213 .01 .01
+4.88 0 0 10.1962 .01 .01
+4.89 0 0 10.1796 .01 .01
+4.9 0 0 10.1629 .01 .01
+4.91 0 0 10.1464 .01 .01
+4.92 0 0 10.1299 .01 .01
+4.93 0 0 10.1134 .01 .01
+4.94 0 0 10.097 .01 .01
+4.95 0 0 10.0807 .01 .01
+4.96 0 0 10.0645 .01 .01
+4.97 0 0 10.0483 .01 .01
+4.98 0 0 10.0321 .01 .01
+4.99 0 0 10.016 .01 .01
+5 0 0 10 .01 .01
+5.01 0 0 9.97007 .01 .01
+5.02 0 0 9.9403 .01 .01
+5.03 0 0 9.91067 .01 .01
+5.04 0 0 9.88119 .01 .01
+5.05 0 0 9.85185 .01 .01
+5.06 0 0 9.82266 .01 .01
+5.07 0 0 9.79362 .01 .01
+5.08 0 0 9.76471 .01 .01
+5.09 0 0 9.73595 .01 .01
+5.1 0 0 9.70733 .01 .01
+5.11 0 0 9.67885 .01 .01
+5.12 0 0 9.65051 .01 .01
+5.13 0 0 9.6223 .01 .01
+5.14 0 0 9.59423 .01 .01
+5.15 0 0 9.5663 .01 .01
+5.16 0 0 9.53851 .01 .01
+5.17 0 0 9.51085 .01 .01
+5.18 0 0 9.48332 .01 .01
+5.19 0 0 9.45592 .01 .01
+5.2 0 0 9.42866 .01 .01
+5.21 0 0 9.40153 .01 .01
+5.22 0 0 9.37452 .01 .01
+5.23 0 0 9.34765 .01 .01
+5.24 0 0 9.3209 .01 .01
+5.25 0 0 9.29429 .01 .01
+5.26 0 0 9.26779 .01 .01
+5.27 0 0 9.24143 .01 .01
+5.28 0 0 9.21519 .01 .01
+5.29 0 0 9.18907 .01 .01
+5.3 0 0 9.16307 .01 .01
+5.31 0 0 9.1372 .01 .01
+5.32 0 0 9.11145 .01 .01
+5.33 0 0 9.08582 .01 .01
+5.34 0 0 9.06031 .01 .01
+5.35 0 0 9.03492 .01 .01
+5.36 0 0 9.00965 .01 .01
+5.37 0 0 8.98449 .01 .01
+5.38 0 0 8.95946 .01 .01
+5.39 0 0 8.93453 .01 .01
+5.4 0 0 8.90973 .01 .01
+5.41 0 0 8.88503 .01 .01
+5.42 0 0 8.86046 .01 .01
+5.43 0 0 8.83599 .01 .01
+5.44 0 0 8.81164 .01 .01
+5.45 0 0 8.7874 .01 .01
+5.46 0 0 8.76327 .01 .01
+5.47 0 0 8.73925 .01 .01
+5.48 0 0 8.71534 .01 .01
+5.49 0 0 8.69154 .01 .01
+5.5 0 0 8.66784 .01 .01
+5.51 0 0 8.64426 .01 .01
+5.52 0 0 8.62078 .01 .01
+5.53 0 0 8.5974 .01 .01
+5.54 0 0 8.57414 .01 .01
+5.55 0 0 8.55097 .01 .01
+5.56 0 0 8.52791 .01 .01
+5.57 0 0 8.50496 .01 .01
+5.58 0 0 8.48211 .01 .01
+5.59 0 0 8.45936 .01 .01
+5.6 0 0 8.43671 .01 .01
+5.61 0 0 8.41416 .01 .01
+5.62 0 0 8.39171 .01 .01
+5.63 0 0 8.36936 .01 .01
+5.64 0 0 8.34711 .01 .01
+5.65 0 0 8.32496 .01 .01
+5.66 0 0 8.30291 .01 .01
+5.67 0 0 8.28095 .01 .01
+5.68 0 0 8.2591 .01 .01
+5.69 0 0 8.23733 .01 .01
+5.7 0 0 8.21567 .01 .01
+5.71 0 0 8.19409 .01 .01
+5.72 0 0 8.17261 .01 .01
+5.73 0 0 8.15123 .01 .01
+5.74 0 0 8.12994 .01 .01
+5.75 0 0 8.10874 .01 .01
+5.76 0 0 8.08763 .01 .01
+5.77 0 0 8.06661 .01 .01
+5.78 0 0 8.04569 .01 .01
+5.79 0 0 8.02485 .01 .01
+5.8 0 0 8.00411 .01 .01
+5.81 0 0 7.98345 .01 .01
+5.82 0 0 7.96289 .01 .01
+5.83 0 0 7.94241 .01 .01
+5.84 0 0 7.92202 .01 .01
+5.85 0 0 7.90171 .01 .01
+5.86 0 0 7.88149 .01 .01
+5.87 0 0 7.86136 .01 .01
+5.88 0 0 7.84132 .01 .01
+5.89 0 0 7.82136 .01 .01
+5.9 0 0 7.80148 .01 .01
+5.91 0 0 7.78169 .01 .01
+5.92 0 0 7.76198 .01 .01
+5.93 0 0 7.74235 .01 .01
+5.94 0 0 7.72281 .01 .01
+5.95 0 0 7.70335 .01 .01
+5.96 0 0 7.68397 .01 .01
+5.97 0 0 7.66467 .01 .01
+5.98 0 0 7.64545 .01 .01
+5.99 0 0 7.62632 .01 .01
+6 0 0 7.60726 .01 .01
+6.01 0 0 7.58828 .01 .01
+6.02 0 0 7.56938 .01 .01
+6.03 0 0 7.55056 .01 .01
+6.04 0 0 7.53181 .01 .01
+6.05 0 0 7.51315 .01 .01
+6.06 0 0 7.49456 .01 .01
+6.07 0 0 7.47605 .01 .01
+6.08 0 0 7.45761 .01 .01
+6.09 0 0 7.43925 .01 .01
+6.1 0 0 7.42096 .01 .01
+6.11 0 0 7.40275 .01 .01
+6.12 0 0 7.38462 .01 .01
+6.13 0 0 7.36655 .01 .01
+6.14 0 0 7.34856 .01 .01
+6.15 0 0 7.33065 .01 .01
+6.16 0 0 7.3128 .01 .01
+6.17 0 0 7.29503 .01 .01
+6.18 0 0 7.27733 .01 .01
+6.19 0 0 7.25971 .01 .01
+6.2 0 0 7.24215 .01 .01
+6.21 0 0 7.22466 .01 .01
+6.22 0 0 7.20725 .01 .01
+6.23 0 0 7.1899 .01 .01
+6.24 0 0 7.17262 .01 .01
+6.25 0 0 7.15542 .01 .01
+6.26 0 0 7.13828 .01 .01
+6.27 0 0 7.12121 .01 .01
+6.28 0 0 7.10421 .01 .01
+6.29 0 0 7.08727 .01 .01
+6.3 0 0 7.0704 .01 .01
+6.31 0 0 7.0536 .01 .01
+6.32 0 0 7.03687 .01 .01
+6.33 0 0 7.0202 .01 .01
+6.34 0 0 7.0036 .01 .01
+6.35 0 0 6.98706 .01 .01
+6.36 0 0 6.97059 .01 .01
+6.37 0 0 6.95418 .01 .01
+6.38 0 0 6.93784 .01 .01
+6.39 0 0 6.92156 .01 .01
+6.4 0 0 6.90534 .01 .01
+6.41 0 0 6.88919 .01 .01
+6.42 0 0 6.8731 .01 .01
+6.43 0 0 6.85707 .01 .01
+6.44 0 0 6.8411 .01 .01
+6.45 0 0 6.8252 .01 .01
+6.46 0 0 6.80936 .01 .01
+6.47 0 0 6.79358 .01 .01
+6.48 0 0 6.77786 .01 .01
+6.49 0 0 6.7622 .01 .01
+6.5 0 0 6.7466 .01 .01
+6.51 0 0 6.73106 .01 .01
+6.52 0 0 6.71558 .01 .01
+6.53 0 0 6.70016 .01 .01
+6.54 0 0 6.6848 .01 .01
+6.55 0 0 6.6695 .01 .01
+6.56 0 0 6.65425 .01 .01
+6.57 0 0 6.63907 .01 .01
+6.58 0 0 6.62394 .01 .01
+6.59 0 0 6.60887 .01 .01
+6.6 0 0 6.59385 .01 .01
+6.61 0 0 6.57889 .01 .01
+6.62 0 0 6.56399 .01 .01
+6.63 0 0 6.54915 .01 .01
+6.64 0 0 6.53436 .01 .01
+6.65 0 0 6.51962 .01 .01
+6.66 0 0 6.50495 .01 .01
+6.67 0 0 6.49032 .01 .01
+6.68 0 0 6.47575 .01 .01
+6.69 0 0 6.46124 .01 .01
+6.7 0 0 6.44678 .01 .01
+6.71 0 0 6.43237 .01 .01
+6.72 0 0 6.41802 .01 .01
+6.73 0 0 6.40372 .01 .01
+6.74 0 0 6.38947 .01 .01
+6.75 0 0 6.37528 .01 .01
+6.76 0 0 6.36114 .01 .01
+6.77 0 0 6.34705 .01 .01
+6.78 0 0 6.33301 .01 .01
+6.79 0 0 6.31903 .01 .01
+6.8 0 0 6.3051 .01 .01
+6.81 0 0 6.29121 .01 .01
+6.82 0 0 6.27738 .01 .01
+6.83 0 0 6.2636 .01 .01
+6.84 0 0 6.24987 .01 .01
+6.85 0 0 6.23619 .01 .01
+6.86 0 0 6.22256 .01 .01
+6.87 0 0 6.20897 .01 .01
+6.88 0 0 6.19544 .01 .01
+6.89 0 0 6.18196 .01 .01
+6.9 0 0 6.16853 .01 .01
+6.91 0 0 6.15514 .01 .01
+6.92 0 0 6.1418 .01 .01
+6.93 0 0 6.12851 .01 .01
+6.94 0 0 6.11527 .01 .01
+6.95 0 0 6.10208 .01 .01
+6.96 0 0 6.08893 .01 .01
+6.97 0 0 6.07583 .01 .01
+6.98 0 0 6.06278 .01 .01
+6.99 0 0 6.04978 .01 .01
+7 0 0 6.03682 .01 .01
+7.01 0 0 6.0239 .01 .01
+7.02 0 0 6.01104 .01 .01
+7.03 0 0 5.99821 .01 .01
+7.04 0 0 5.98544 .01 .01
+7.05 0 0 5.97271 .01 .01
+7.06 0 0 5.96002 .01 .01
+7.07 0 0 5.94738 .01 .01
+7.08 0 0 5.93479 .01 .01
+7.09 0 0 5.92224 .01 .01
+7.1 0 0 5.90973 .01 .01
+7.11 0 0 5.89726 .01 .01
+7.12 0 0 5.88484 .01 .01
+7.13 0 0 5.87247 .01 .01
+7.14 0 0 5.86014 .01 .01
+7.15 0 0 5.84785 .01 .01
+7.16 0 0 5.8356 .01 .01
+7.17 0 0 5.8234 .01 .01
+7.18 0 0 5.81123 .01 .01
+7.19 0 0 5.79911 .01 .01
+7.2 0 0 5.78704 .01 .01
+7.21 0 0 5.775 .01 .01
+7.22 0 0 5.76301 .01 .01
+7.23 0 0 5.75106 .01 .01
+7.24 0 0 5.73914 .01 .01
+7.25 0 0 5.72727 .01 .01
+7.26 0 0 5.71545 .01 .01
+7.27 0 0 5.70366 .01 .01
+7.28 0 0 5.69191 .01 .01
+7.29 0 0 5.6802 .01 .01
+7.3 0 0 5.66853 .01 .01
+7.31 0 0 5.65691 .01 .01
+7.32 0 0 5.64532 .01 .01
+7.33 0 0 5.63377 .01 .01
+7.34 0 0 5.62226 .01 .01
+7.35 0 0 5.61079 .01 .01
+7.36 0 0 5.59936 .01 .01
+7.37 0 0 5.58797 .01 .01
+7.38 0 0 5.57661 .01 .01
+7.39 0 0 5.5653 .01 .01
+7.4 0 0 5.55402 .01 .01
+7.41 0 0 5.54278 .01 .01
+7.42 0 0 5.53158 .01 .01
+7.43 0 0 5.52042 .01 .01
+7.44 0 0 5.50929 .01 .01
+7.45 0 0 5.4982 .01 .01
+7.46 0 0 5.48715 .01 .01
+7.47 0 0 5.47613 .01 .01
+7.48 0 0 5.46516 .01 .01
+7.49 0 0 5.45422 .01 .01
+7.5 0 0 5.44331 .01 .01
+7.51 0 0 5.43244 .01 .01
+7.52 0 0 5.42161 .01 .01
+7.53 0 0 5.41081 .01 .01
+7.54 0 0 5.40005 .01 .01
+7.55 0 0 5.38933 .01 .01
+7.56 0 0 5.37864 .01 .01
+7.57 0 0 5.36798 .01 .01
+7.58 0 0 5.35736 .01 .01
+7.59 0 0 5.34678 .01 .01
+7.6 0 0 5.33623 .01 .01
+7.61 0 0 5.32572 .01 .01
+7.62 0 0 5.31524 .01 .01
+7.63 0 0 5.30479 .01 .01
+7.64 0 0 5.29438 .01 .01
+7.65 0 0 5.284 .01 .01
+7.66 0 0 5.27366 .01 .01
+7.67 0 0 5.26335 .01 .01
+7.68 0 0 5.25307 .01 .01
+7.69 0 0 5.24283 .01 .01
+7.7 0 0 5.23262 .01 .01
+7.71 0 0 5.22244 .01 .01
+7.72 0 0 5.2123 .01 .01
+7.73 0 0 5.20218 .01 .01
+7.74 0 0 5.19211 .01 .01
+7.75 0 0 5.18206 .01 .01
+7.76 0 0 5.17205 .01 .01
+7.77 0 0 5.16207 .01 .01
+7.78 0 0 5.15212 .01 .01
+7.79 0 0 5.1422 .01 .01
+7.8 0 0 5.13231 .01 .01
+7.81 0 0 5.12246 .01 .01
+7.82 0 0 5.11264 .01 .01
+7.83 0 0 5.10284 .01 .01
+7.84 0 0 5.09308 .01 .01
+7.85 0 0 5.08336 .01 .01
+7.86 0 0 5.07366 .01 .01
+7.87 0 0 5.06399 .01 .01
+7.88 0 0 5.05435 .01 .01
+7.89 0 0 5.04475 .01 .01
+7.9 0 0 5.03517 .01 .01
+7.91 0 0 5.02563 .01 .01
+7.92 0 0 5.01611 .01 .01
+7.93 0 0 5.00663 .01 .01
+7.94 0 0 4.99717 .01 .01
+7.95 0 0 4.98775 .01 .01
+7.96 0 0 4.97835 .01 .01
+7.97 0 0 4.96898 .01 .01
+7.98 0 0 4.95965 .01 .01
+7.99 0 0 4.95034 .01 .01
+8 0 0 4.94106 .01 .01
+8.01 0 0 4.93181 .01 .01
+8.02 0 0 4.92259 .01 .01
+8.03 0 0 4.9134 .01 .01
+8.04 0 0 4.90423 .01 .01
+8.05 0 0 4.8951 .01 .01
+8.06 0 0 4.88599 .01 .01
+8.07 0 0 4.87691 .01 .01
+8.08 0 0 4.86786 .01 .01
+8.09 0 0 4.85884 .01 .01
+8.1 0 0 4.84984 .01 .01
+8.11 0 0 4.84087 .01 .01
+8.12 0 0 4.83193 .01 .01
+8.13 0 0 4.82302 .01 .01
+8.14 0 0 4.81414 .01 .01
+8.15 0 0 4.80528 .01 .01
+8.16 0 0 4.79645 .01 .01
+8.17 0 0 4.78764 .01 .01
+8.18 0 0 4.77887 .01 .01
+8.19 0 0 4.77012 .01 .01
+8.2 0 0 4.7614 .01 .01
+8.21 0 0 4.7527 .01 .01
+8.22 0 0 4.74403 .01 .01
+8.23 0 0 4.73538 .01 .01
+8.24 0 0 4.72677 .01 .01
+8.25 0 0 4.71818 .01 .01
+8.26 0 0 4.70961 .01 .01
+8.27 0 0 4.70107 .01 .01
+8.28 0 0 4.69256 .01 .01
+8.29 0 0 4.68407 .01 .01
+8.3 0 0 4.67561 .01 .01
+8.31 0 0 4.66717 .01 .01
+8.32 0 0 4.65876 .01 .01
+8.33 0 0 4.65037 .01 .01
+8.34 0 0 4.64201 .01 .01
+8.35 0 0 4.63367 .01 .01
+8.36 0 0 4.62536 .01 .01
+8.37 0 0 4.61707 .01 .01
+8.38 0 0 4.60881 .01 .01
+8.39 0 0 4.60057 .01 .01
+8.4 0 0 4.59236 .01 .01
+8.41 0 0 4.58417 .01 .01
+8.42 0 0 4.57601 .01 .01
+8.43 0 0 4.56787 .01 .01
+8.44 0 0 4.55975 .01 .01
+8.45 0 0 4.55166 .01 .01
+8.46 0 0 4.54359 .01 .01
+8.47 0 0 4.53555 .01 .01
+8.48 0 0 4.52753 .01 .01
+8.49 0 0 4.51953 .01 .01
+8.5 0 0 4.51156 .01 .01
+8.51 0 0 4.50361 .01 .01
+8.52 0 0 4.49568 .01 .01
+8.53 0 0 4.48778 .01 .01
+8.54 0 0 4.4799 .01 .01
+8.55 0 0 4.47204 .01 .01
+8.56 0 0 4.46421 .01 .01
+8.57 0 0 4.4564 .01 .01
+8.58 0 0 4.44861 .01 .01
+8.59 0 0 4.44084 .01 .01
+8.6 0 0 4.4331 .01 .01
+8.61 0 0 4.42538 .01 .01
+8.62 0 0 4.41768 .01 .01
+8.63 0 0 4.41 .01 .01
+8.64 0 0 4.40235 .01 .01
+8.65 0 0 4.39472 .01 .01
+8.66 0 0 4.38711 .01 .01
+8.67 0 0 4.37952 .01 .01
+8.68 0 0 4.37195 .01 .01
+8.69 0 0 4.36441 .01 .01
+8.7 0 0 4.35689 .01 .01
+8.71 0 0 4.34938 .01 .01
+8.72 0 0 4.3419 .01 .01
+8.73 0 0 4.33445 .01 .01
+8.74 0 0 4.32701 .01 .01
+8.75 0 0 4.31959 .01 .01
+8.76 0 0 4.3122 .01 .01
+8.77 0 0 4.30483 .01 .01
+8.78 0 0 4.29747 .01 .01
+8.79 0 0 4.29014 .01 .01
+8.8 0 0 4.28283 .01 .01
+8.81 0 0 4.27554 .01 .01
+8.82 0 0 4.26827 .01 .01
+8.83 0 0 4.26102 .01 .01
+8.84 0 0 4.2538 .01 .01
+8.85 0 0 4.24659 .01 .01
+8.86 0 0 4.2394 .01 .01
+8.87 0 0 4.23223 .01 .01
+8.88 0 0 4.22509 .01 .01
+8.89 0 0 4.21796 .01 .01
+8.9 0 0 4.21085 .01 .01
+8.91 0 0 4.20377 .01 .01
+8.92 0 0 4.1967 .01 .01
+8.93 0 0 4.18965 .01 .01
+8.94 0 0 4.18262 .01 .01
+8.95 0 0 4.17562 .01 .01
+8.96 0 0 4.16863 .01 .01
+8.97 0 0 4.16166 .01 .01
+8.98 0 0 4.15471 .01 .01
+8.99 0 0 4.14778 .01 .01
+9 0 0 4.14087 .01 .01
+9.01 0 0 4.13397 .01 .01
+9.02 0 0 4.1271 .01 .01
+9.03 0 0 4.12025 .01 .01
+9.04 0 0 4.11341 .01 .01
+9.05 0 0 4.1066 .01 .01
+9.06 0 0 4.0998 .01 .01
+9.07 0 0 4.09302 .01 .01
+9.08 0 0 4.08626 .01 .01
+9.09 0 0 4.07952 .01 .01
+9.1 0 0 4.0728 .01 .01
+9.11 0 0 4.06609 .01 .01
+9.12 0 0 4.05941 .01 .01
+9.13 0 0 4.05274 .01 .01
+9.14 0 0 4.04609 .01 .01
+9.15 0 0 4.03946 .01 .01
+9.16 0 0 4.03285 .01 .01
+9.17 0 0 4.02625 .01 .01
+9.18 0 0 4.01968 .01 .01
+9.19 0 0 4.01312 .01 .01
+9.2 0 0 4.00657 .01 .01
+9.21 0 0 4.00005 .01 .01
+9.22 0 0 3.99355 .01 .01
+9.23 0 0 3.98706 .01 .01
+9.24 0 0 3.98059 .01 .01
+9.25 0 0 3.97413 .01 .01
+9.26 0 0 3.9677 .01 .01
+9.27 0 0 3.96128 .01 .01
+9.28 0 0 3.95488 .01 .01
+9.29 0 0 3.94849 .01 .01
+9.3 0 0 3.94213 .01 .01
+9.31 0 0 3.93578 .01 .01
+9.32 0 0 3.92944 .01 .01
+9.33 0 0 3.92313 .01 .01
+9.34 0 0 3.91683 .01 .01
+9.35 0 0 3.91055 .01 .01
+9.36 0 0 3.90428 .01 .01
+9.37 0 0 3.89803 .01 .01
+9.38 0 0 3.8918 .01 .01
+9.39 0 0 3.88559 .01 .01
+9.4 0 0 3.87939 .01 .01
+9.41 0 0 3.87321 .01 .01
+9.42 0 0 3.86704 .01 .01
+9.43 0 0 3.86089 .01 .01
+9.44 0 0 3.85476 .01 .01
+9.45 0 0 3.84864 .01 .01
+9.46 0 0 3.84254 .01 .01
+9.47 0 0 3.83645 .01 .01
+9.48 0 0 3.83039 .01 .01
+9.49 0 0 3.82433 .01 .01
+9.5 0 0 3.8183 .01 .01
+9.51 0 0 3.81228 .01 .01
+9.52 0 0 3.80627 .01 .01
+9.53 0 0 3.80028 .01 .01
+9.54 0 0 3.79431 .01 .01
+9.55 0 0 3.78835 .01 .01
+9.56 0 0 3.78241 .01 .01
+9.57 0 0 3.77648 .01 .01
+9.58 0 0 3.77057 .01 .01
+9.59 0 0 3.76467 .01 .01
+9.6 0 0 3.75879 .01 .01
+9.61 0 0 3.75293 .01 .01
+9.62 0 0 3.74708 .01 .01
+9.63 0 0 3.74124 .01 .01
+9.64 0 0 3.73542 .01 .01
+9.65 0 0 3.72962 .01 .01
+9.66 0 0 3.72383 .01 .01
+9.67 0 0 3.71805 .01 .01
+9.68 0 0 3.71229 .01 .01
+9.69 0 0 3.70655 .01 .01
+9.7 0 0 3.70082 .01 .01
+9.71 0 0 3.6951 .01 .01
+9.72 0 0 3.6894 .01 .01
+9.73 0 0 3.68371 .01 .01
+9.74 0 0 3.67804 .01 .01
+9.75 0 0 3.67238 .01 .01
+9.76 0 0 3.66674 .01 .01
+9.77 0 0 3.66111 .01 .01
+9.78 0 0 3.6555 .01 .01
+9.79 0 0 3.6499 .01 .01
+9.8 0 0 3.64431 .01 .01
+9.81 0 0 3.63874 .01 .01
+9.82 0 0 3.63319 .01 .01
+9.83 0 0 3.62764 .01 .01
+9.84 0 0 3.62212 .01 .01
+9.85 0 0 3.6166 .01 .01
+9.86 0 0 3.6111 .01 .01
+9.87 0 0 3.60561 .01 .01
+9.88 0 0 3.60014 .01 .01
+9.89 0 0 3.59468 .01 .01
+9.9 0 0 3.58924 .01 .01
+9.91 0 0 3.58381 .01 .01
+9.92 0 0 3.57839 .01 .01
+9.93 0 0 3.57298 .01 .01
+9.94 0 0 3.56759 .01 .01
+9.95 0 0 3.56222 .01 .01
+9.96 0 0 3.55685 .01 .01
+9.97 0 0 3.5515 .01 .01
+9.98 0 0 3.54617 .01 .01
+9.99 0 0 3.54084 .01 .01
+10 0 0 3.53553 .01 .01
diff --git a/samples/gauss.dat b/samples/gauss.dat
new file mode 100644
index 0000000..4130e1b
--- /dev/null
+++ b/samples/gauss.dat
@@ -0,0 +1,901 @@
+1 0 0 0.338027 .01 .01
+1.01 0 0 0.341041 .01 .01
+1.02 0 0 0.344074 .01 .01
+1.03 0 0 0.347127 .01 .01
+1.04 0 0 0.350199 .01 .01
+1.05 0 0 0.353291 .01 .01
+1.06 0 0 0.356402 .01 .01
+1.07 0 0 0.359532 .01 .01
+1.08 0 0 0.362681 .01 .01
+1.09 0 0 0.36585 .01 .01
+1.1 0 0 0.369039 .01 .01
+1.11 0 0 0.372247 .01 .01
+1.12 0 0 0.375475 .01 .01
+1.13 0 0 0.378722 .01 .01
+1.14 0 0 0.381989 .01 .01
+1.15 0 0 0.385275 .01 .01
+1.16 0 0 0.388581 .01 .01
+1.17 0 0 0.391907 .01 .01
+1.18 0 0 0.395252 .01 .01
+1.19 0 0 0.398618 .01 .01
+1.2 0 0 0.402002 .01 .01
+1.21 0 0 0.405407 .01 .01
+1.22 0 0 0.408831 .01 .01
+1.23 0 0 0.412275 .01 .01
+1.24 0 0 0.415739 .01 .01
+1.25 0 0 0.419223 .01 .01
+1.26 0 0 0.422726 .01 .01
+1.27 0 0 0.426249 .01 .01
+1.28 0 0 0.429792 .01 .01
+1.29 0 0 0.433355 .01 .01
+1.3 0 0 0.436938 .01 .01
+1.31 0 0 0.440541 .01 .01
+1.32 0 0 0.444163 .01 .01
+1.33 0 0 0.447805 .01 .01
+1.34 0 0 0.451467 .01 .01
+1.35 0 0 0.455149 .01 .01
+1.36 0 0 0.458851 .01 .01
+1.37 0 0 0.462572 .01 .01
+1.38 0 0 0.466313 .01 .01
+1.39 0 0 0.470075 .01 .01
+1.4 0 0 0.473856 .01 .01
+1.41 0 0 0.477656 .01 .01
+1.42 0 0 0.481477 .01 .01
+1.43 0 0 0.485317 .01 .01
+1.44 0 0 0.489177 .01 .01
+1.45 0 0 0.493057 .01 .01
+1.46 0 0 0.496956 .01 .01
+1.47 0 0 0.500876 .01 .01
+1.48 0 0 0.504815 .01 .01
+1.49 0 0 0.508773 .01 .01
+1.5 0 0 0.512752 .01 .01
+1.51 0 0 0.516749 .01 .01
+1.52 0 0 0.520767 .01 .01
+1.53 0 0 0.524804 .01 .01
+1.54 0 0 0.52886 .01 .01
+1.55 0 0 0.532937 .01 .01
+1.56 0 0 0.537032 .01 .01
+1.57 0 0 0.541147 .01 .01
+1.58 0 0 0.545282 .01 .01
+1.59 0 0 0.549435 .01 .01
+1.6 0 0 0.553609 .01 .01
+1.61 0 0 0.557801 .01 .01
+1.62 0 0 0.562013 .01 .01
+1.63 0 0 0.566244 .01 .01
+1.64 0 0 0.570494 .01 .01
+1.65 0 0 0.574763 .01 .01
+1.66 0 0 0.579051 .01 .01
+1.67 0 0 0.583359 .01 .01
+1.68 0 0 0.587685 .01 .01
+1.69 0 0 0.59203 .01 .01
+1.7 0 0 0.596395 .01 .01
+1.71 0 0 0.600778 .01 .01
+1.72 0 0 0.605179 .01 .01
+1.73 0 0 0.6096 .01 .01
+1.74 0 0 0.614039 .01 .01
+1.75 0 0 0.618496 .01 .01
+1.76 0 0 0.622973 .01 .01
+1.77 0 0 0.627467 .01 .01
+1.78 0 0 0.63198 .01 .01
+1.79 0 0 0.636511 .01 .01
+1.8 0 0 0.641061 .01 .01
+1.81 0 0 0.645629 .01 .01
+1.82 0 0 0.650215 .01 .01
+1.83 0 0 0.654818 .01 .01
+1.84 0 0 0.65944 .01 .01
+1.85 0 0 0.66408 .01 .01
+1.86 0 0 0.668737 .01 .01
+1.87 0 0 0.673412 .01 .01
+1.88 0 0 0.678105 .01 .01
+1.89 0 0 0.682815 .01 .01
+1.9 0 0 0.687543 .01 .01
+1.91 0 0 0.692288 .01 .01
+1.92 0 0 0.697051 .01 .01
+1.93 0 0 0.70183 .01 .01
+1.94 0 0 0.706627 .01 .01
+1.95 0 0 0.71144 .01 .01
+1.96 0 0 0.716271 .01 .01
+1.97 0 0 0.721118 .01 .01
+1.98 0 0 0.725982 .01 .01
+1.99 0 0 0.730862 .01 .01
+2 0 0 0.735759 .01 .01
+2.01 0 0 0.740672 .01 .01
+2.02 0 0 0.745602 .01 .01
+2.03 0 0 0.750547 .01 .01
+2.04 0 0 0.755509 .01 .01
+2.05 0 0 0.760486 .01 .01
+2.06 0 0 0.76548 .01 .01
+2.07 0 0 0.770488 .01 .01
+2.08 0 0 0.775513 .01 .01
+2.09 0 0 0.780553 .01 .01
+2.1 0 0 0.785608 .01 .01
+2.11 0 0 0.790678 .01 .01
+2.12 0 0 0.795764 .01 .01
+2.13 0 0 0.800864 .01 .01
+2.14 0 0 0.805979 .01 .01
+2.15 0 0 0.811109 .01 .01
+2.16 0 0 0.816253 .01 .01
+2.17 0 0 0.821412 .01 .01
+2.18 0 0 0.826585 .01 .01
+2.19 0 0 0.831772 .01 .01
+2.2 0 0 0.836973 .01 .01
+2.21 0 0 0.842187 .01 .01
+2.22 0 0 0.847416 .01 .01
+2.23 0 0 0.852658 .01 .01
+2.24 0 0 0.857913 .01 .01
+2.25 0 0 0.863181 .01 .01
+2.26 0 0 0.868463 .01 .01
+2.27 0 0 0.873757 .01 .01
+2.28 0 0 0.879064 .01 .01
+2.29 0 0 0.884384 .01 .01
+2.3 0 0 0.889716 .01 .01
+2.31 0 0 0.895061 .01 .01
+2.32 0 0 0.900417 .01 .01
+2.33 0 0 0.905785 .01 .01
+2.34 0 0 0.911166 .01 .01
+2.35 0 0 0.916557 .01 .01
+2.36 0 0 0.921961 .01 .01
+2.37 0 0 0.927375 .01 .01
+2.38 0 0 0.9328 .01 .01
+2.39 0 0 0.938237 .01 .01
+2.4 0 0 0.943684 .01 .01
+2.41 0 0 0.949142 .01 .01
+2.42 0 0 0.95461 .01 .01
+2.43 0 0 0.960088 .01 .01
+2.44 0 0 0.965576 .01 .01
+2.45 0 0 0.971074 .01 .01
+2.46 0 0 0.976581 .01 .01
+2.47 0 0 0.982098 .01 .01
+2.48 0 0 0.987624 .01 .01
+2.49 0 0 0.99316 .01 .01
+2.5 0 0 0.998704 .01 .01
+2.51 0 0 1.00426 .01 .01
+2.52 0 0 1.00982 .01 .01
+2.53 0 0 1.01539 .01 .01
+2.54 0 0 1.02096 .01 .01
+2.55 0 0 1.02655 .01 .01
+2.56 0 0 1.03214 .01 .01
+2.57 0 0 1.03774 .01 .01
+2.58 0 0 1.04335 .01 .01
+2.59 0 0 1.04896 .01 .01
+2.6 0 0 1.05458 .01 .01
+2.61 0 0 1.06021 .01 .01
+2.62 0 0 1.06585 .01 .01
+2.63 0 0 1.07149 .01 .01
+2.64 0 0 1.07713 .01 .01
+2.65 0 0 1.08278 .01 .01
+2.66 0 0 1.08844 .01 .01
+2.67 0 0 1.0941 .01 .01
+2.68 0 0 1.09977 .01 .01
+2.69 0 0 1.10544 .01 .01
+2.7 0 0 1.11112 .01 .01
+2.71 0 0 1.1168 .01 .01
+2.72 0 0 1.12249 .01 .01
+2.73 0 0 1.12818 .01 .01
+2.74 0 0 1.13387 .01 .01
+2.75 0 0 1.13957 .01 .01
+2.76 0 0 1.14527 .01 .01
+2.77 0 0 1.15097 .01 .01
+2.78 0 0 1.15667 .01 .01
+2.79 0 0 1.16238 .01 .01
+2.8 0 0 1.16809 .01 .01
+2.81 0 0 1.1738 .01 .01
+2.82 0 0 1.17951 .01 .01
+2.83 0 0 1.18523 .01 .01
+2.84 0 0 1.19095 .01 .01
+2.85 0 0 1.19666 .01 .01
+2.86 0 0 1.20238 .01 .01
+2.87 0 0 1.2081 .01 .01
+2.88 0 0 1.21382 .01 .01
+2.89 0 0 1.21953 .01 .01
+2.9 0 0 1.22525 .01 .01
+2.91 0 0 1.23097 .01 .01
+2.92 0 0 1.23669 .01 .01
+2.93 0 0 1.2424 .01 .01
+2.94 0 0 1.24812 .01 .01
+2.95 0 0 1.25383 .01 .01
+2.96 0 0 1.25954 .01 .01
+2.97 0 0 1.26525 .01 .01
+2.98 0 0 1.27096 .01 .01
+2.99 0 0 1.27666 .01 .01
+3 0 0 1.28236 .01 .01
+3.01 0 0 1.28806 .01 .01
+3.02 0 0 1.29375 .01 .01
+3.03 0 0 1.29944 .01 .01
+3.04 0 0 1.30513 .01 .01
+3.05 0 0 1.31081 .01 .01
+3.06 0 0 1.31649 .01 .01
+3.07 0 0 1.32216 .01 .01
+3.08 0 0 1.32783 .01 .01
+3.09 0 0 1.33349 .01 .01
+3.1 0 0 1.33915 .01 .01
+3.11 0 0 1.3448 .01 .01
+3.12 0 0 1.35045 .01 .01
+3.13 0 0 1.35609 .01 .01
+3.14 0 0 1.36172 .01 .01
+3.15 0 0 1.36734 .01 .01
+3.16 0 0 1.37296 .01 .01
+3.17 0 0 1.37857 .01 .01
+3.18 0 0 1.38417 .01 .01
+3.19 0 0 1.38977 .01 .01
+3.2 0 0 1.39535 .01 .01
+3.21 0 0 1.40093 .01 .01
+3.22 0 0 1.4065 .01 .01
+3.23 0 0 1.41206 .01 .01
+3.24 0 0 1.41761 .01 .01
+3.25 0 0 1.42315 .01 .01
+3.26 0 0 1.42867 .01 .01
+3.27 0 0 1.43419 .01 .01
+3.28 0 0 1.4397 .01 .01
+3.29 0 0 1.4452 .01 .01
+3.3 0 0 1.45069 .01 .01
+3.31 0 0 1.45616 .01 .01
+3.32 0 0 1.46162 .01 .01
+3.33 0 0 1.46707 .01 .01
+3.34 0 0 1.47251 .01 .01
+3.35 0 0 1.47794 .01 .01
+3.36 0 0 1.48335 .01 .01
+3.37 0 0 1.48875 .01 .01
+3.38 0 0 1.49413 .01 .01
+3.39 0 0 1.49951 .01 .01
+3.4 0 0 1.50486 .01 .01
+3.41 0 0 1.51021 .01 .01
+3.42 0 0 1.51554 .01 .01
+3.43 0 0 1.52085 .01 .01
+3.44 0 0 1.52615 .01 .01
+3.45 0 0 1.53143 .01 .01
+3.46 0 0 1.5367 .01 .01
+3.47 0 0 1.54195 .01 .01
+3.48 0 0 1.54718 .01 .01
+3.49 0 0 1.5524 .01 .01
+3.5 0 0 1.5576 .01 .01
+3.51 0 0 1.56278 .01 .01
+3.52 0 0 1.56795 .01 .01
+3.53 0 0 1.5731 .01 .01
+3.54 0 0 1.57823 .01 .01
+3.55 0 0 1.58334 .01 .01
+3.56 0 0 1.58843 .01 .01
+3.57 0 0 1.59351 .01 .01
+3.58 0 0 1.59856 .01 .01
+3.59 0 0 1.60359 .01 .01
+3.6 0 0 1.60861 .01 .01
+3.61 0 0 1.6136 .01 .01
+3.62 0 0 1.61858 .01 .01
+3.63 0 0 1.62353 .01 .01
+3.64 0 0 1.62846 .01 .01
+3.65 0 0 1.63337 .01 .01
+3.66 0 0 1.63826 .01 .01
+3.67 0 0 1.64313 .01 .01
+3.68 0 0 1.64797 .01 .01
+3.69 0 0 1.6528 .01 .01
+3.7 0 0 1.6576 .01 .01
+3.71 0 0 1.66237 .01 .01
+3.72 0 0 1.66713 .01 .01
+3.73 0 0 1.67186 .01 .01
+3.74 0 0 1.67657 .01 .01
+3.75 0 0 1.68125 .01 .01
+3.76 0 0 1.68591 .01 .01
+3.77 0 0 1.69054 .01 .01
+3.78 0 0 1.69515 .01 .01
+3.79 0 0 1.69973 .01 .01
+3.8 0 0 1.70429 .01 .01
+3.81 0 0 1.70882 .01 .01
+3.82 0 0 1.71333 .01 .01
+3.83 0 0 1.7178 .01 .01
+3.84 0 0 1.72226 .01 .01
+3.85 0 0 1.72668 .01 .01
+3.86 0 0 1.73108 .01 .01
+3.87 0 0 1.73545 .01 .01
+3.88 0 0 1.7398 .01 .01
+3.89 0 0 1.74411 .01 .01
+3.9 0 0 1.7484 .01 .01
+3.91 0 0 1.75266 .01 .01
+3.92 0 0 1.75689 .01 .01
+3.93 0 0 1.7611 .01 .01
+3.94 0 0 1.76527 .01 .01
+3.95 0 0 1.76941 .01 .01
+3.96 0 0 1.77353 .01 .01
+3.97 0 0 1.77761 .01 .01
+3.98 0 0 1.78166 .01 .01
+3.99 0 0 1.78569 .01 .01
+4 0 0 1.78968 .01 .01
+4.01 0 0 1.79364 .01 .01
+4.02 0 0 1.79757 .01 .01
+4.03 0 0 1.80147 .01 .01
+4.04 0 0 1.80534 .01 .01
+4.05 0 0 1.80917 .01 .01
+4.06 0 0 1.81298 .01 .01
+4.07 0 0 1.81675 .01 .01
+4.08 0 0 1.82048 .01 .01
+4.09 0 0 1.82419 .01 .01
+4.1 0 0 1.82786 .01 .01
+4.11 0 0 1.8315 .01 .01
+4.12 0 0 1.83511 .01 .01
+4.13 0 0 1.83868 .01 .01
+4.14 0 0 1.84222 .01 .01
+4.15 0 0 1.84572 .01 .01
+4.16 0 0 1.84919 .01 .01
+4.17 0 0 1.85262 .01 .01
+4.18 0 0 1.85602 .01 .01
+4.19 0 0 1.85939 .01 .01
+4.2 0 0 1.86272 .01 .01
+4.21 0 0 1.86601 .01 .01
+4.22 0 0 1.86927 .01 .01
+4.23 0 0 1.87249 .01 .01
+4.24 0 0 1.87568 .01 .01
+4.25 0 0 1.87883 .01 .01
+4.26 0 0 1.88194 .01 .01
+4.27 0 0 1.88502 .01 .01
+4.28 0 0 1.88805 .01 .01
+4.29 0 0 1.89106 .01 .01
+4.3 0 0 1.89402 .01 .01
+4.31 0 0 1.89695 .01 .01
+4.32 0 0 1.89984 .01 .01
+4.33 0 0 1.90269 .01 .01
+4.34 0 0 1.90551 .01 .01
+4.35 0 0 1.90828 .01 .01
+4.36 0 0 1.91102 .01 .01
+4.37 0 0 1.91372 .01 .01
+4.38 0 0 1.91638 .01 .01
+4.39 0 0 1.919 .01 .01
+4.4 0 0 1.92158 .01 .01
+4.41 0 0 1.92412 .01 .01
+4.42 0 0 1.92662 .01 .01
+4.43 0 0 1.92909 .01 .01
+4.44 0 0 1.93151 .01 .01
+4.45 0 0 1.93389 .01 .01
+4.46 0 0 1.93624 .01 .01
+4.47 0 0 1.93854 .01 .01
+4.48 0 0 1.9408 .01 .01
+4.49 0 0 1.94303 .01 .01
+4.5 0 0 1.94521 .01 .01
+4.51 0 0 1.94735 .01 .01
+4.52 0 0 1.94945 .01 .01
+4.53 0 0 1.95151 .01 .01
+4.54 0 0 1.95353 .01 .01
+4.55 0 0 1.9555 .01 .01
+4.56 0 0 1.95744 .01 .01
+4.57 0 0 1.95933 .01 .01
+4.58 0 0 1.96118 .01 .01
+4.59 0 0 1.96299 .01 .01
+4.6 0 0 1.96476 .01 .01
+4.61 0 0 1.96648 .01 .01
+4.62 0 0 1.96817 .01 .01
+4.63 0 0 1.96981 .01 .01
+4.64 0 0 1.97141 .01 .01
+4.65 0 0 1.97296 .01 .01
+4.66 0 0 1.97448 .01 .01
+4.67 0 0 1.97595 .01 .01
+4.68 0 0 1.97737 .01 .01
+4.69 0 0 1.97876 .01 .01
+4.7 0 0 1.9801 .01 .01
+4.71 0 0 1.9814 .01 .01
+4.72 0 0 1.98265 .01 .01
+4.73 0 0 1.98387 .01 .01
+4.74 0 0 1.98503 .01 .01
+4.75 0 0 1.98616 .01 .01
+4.76 0 0 1.98724 .01 .01
+4.77 0 0 1.98828 .01 .01
+4.78 0 0 1.98927 .01 .01
+4.79 0 0 1.99022 .01 .01
+4.8 0 0 1.99113 .01 .01
+4.81 0 0 1.99199 .01 .01
+4.82 0 0 1.99281 .01 .01
+4.83 0 0 1.99359 .01 .01
+4.84 0 0 1.99432 .01 .01
+4.85 0 0 1.99501 .01 .01
+4.86 0 0 1.99565 .01 .01
+4.87 0 0 1.99625 .01 .01
+4.88 0 0 1.9968 .01 .01
+4.89 0 0 1.99731 .01 .01
+4.9 0 0 1.99778 .01 .01
+4.91 0 0 1.9982 .01 .01
+4.92 0 0 1.99858 .01 .01
+4.93 0 0 1.99891 .01 .01
+4.94 0 0 1.9992 .01 .01
+4.95 0 0 1.99944 .01 .01
+4.96 0 0 1.99964 .01 .01
+4.97 0 0 1.9998 .01 .01
+4.98 0 0 1.99991 .01 .01
+4.99 0 0 1.99998 .01 .01
+5 0 0 2 .01 .01
+5.01 0 0 1.99998 .01 .01
+5.02 0 0 1.99991 .01 .01
+5.03 0 0 1.9998 .01 .01
+5.04 0 0 1.99964 .01 .01
+5.05 0 0 1.99944 .01 .01
+5.06 0 0 1.9992 .01 .01
+5.07 0 0 1.99891 .01 .01
+5.08 0 0 1.99858 .01 .01
+5.09 0 0 1.9982 .01 .01
+5.1 0 0 1.99778 .01 .01
+5.11 0 0 1.99731 .01 .01
+5.12 0 0 1.9968 .01 .01
+5.13 0 0 1.99625 .01 .01
+5.14 0 0 1.99565 .01 .01
+5.15 0 0 1.99501 .01 .01
+5.16 0 0 1.99432 .01 .01
+5.17 0 0 1.99359 .01 .01
+5.18 0 0 1.99281 .01 .01
+5.19 0 0 1.99199 .01 .01
+5.2 0 0 1.99113 .01 .01
+5.21 0 0 1.99022 .01 .01
+5.22 0 0 1.98927 .01 .01
+5.23 0 0 1.98828 .01 .01
+5.24 0 0 1.98724 .01 .01
+5.25 0 0 1.98616 .01 .01
+5.26 0 0 1.98503 .01 .01
+5.27 0 0 1.98387 .01 .01
+5.28 0 0 1.98265 .01 .01
+5.29 0 0 1.9814 .01 .01
+5.3 0 0 1.9801 .01 .01
+5.31 0 0 1.97876 .01 .01
+5.32 0 0 1.97737 .01 .01
+5.33 0 0 1.97595 .01 .01
+5.34 0 0 1.97448 .01 .01
+5.35 0 0 1.97296 .01 .01
+5.36 0 0 1.97141 .01 .01
+5.37 0 0 1.96981 .01 .01
+5.38 0 0 1.96817 .01 .01
+5.39 0 0 1.96648 .01 .01
+5.4 0 0 1.96476 .01 .01
+5.41 0 0 1.96299 .01 .01
+5.42 0 0 1.96118 .01 .01
+5.43 0 0 1.95933 .01 .01
+5.44 0 0 1.95744 .01 .01
+5.45 0 0 1.9555 .01 .01
+5.46 0 0 1.95353 .01 .01
+5.47 0 0 1.95151 .01 .01
+5.48 0 0 1.94945 .01 .01
+5.49 0 0 1.94735 .01 .01
+5.5 0 0 1.94521 .01 .01
+5.51 0 0 1.94303 .01 .01
+5.52 0 0 1.9408 .01 .01
+5.53 0 0 1.93854 .01 .01
+5.54 0 0 1.93624 .01 .01
+5.55 0 0 1.93389 .01 .01
+5.56 0 0 1.93151 .01 .01
+5.57 0 0 1.92909 .01 .01
+5.58 0 0 1.92662 .01 .01
+5.59 0 0 1.92412 .01 .01
+5.6 0 0 1.92158 .01 .01
+5.61 0 0 1.919 .01 .01
+5.62 0 0 1.91638 .01 .01
+5.63 0 0 1.91372 .01 .01
+5.64 0 0 1.91102 .01 .01
+5.65 0 0 1.90828 .01 .01
+5.66 0 0 1.90551 .01 .01
+5.67 0 0 1.90269 .01 .01
+5.68 0 0 1.89984 .01 .01
+5.69 0 0 1.89695 .01 .01
+5.7 0 0 1.89402 .01 .01
+5.71 0 0 1.89106 .01 .01
+5.72 0 0 1.88805 .01 .01
+5.73 0 0 1.88502 .01 .01
+5.74 0 0 1.88194 .01 .01
+5.75 0 0 1.87883 .01 .01
+5.76 0 0 1.87568 .01 .01
+5.77 0 0 1.87249 .01 .01
+5.78 0 0 1.86927 .01 .01
+5.79 0 0 1.86601 .01 .01
+5.8 0 0 1.86272 .01 .01
+5.81 0 0 1.85939 .01 .01
+5.82 0 0 1.85602 .01 .01
+5.83 0 0 1.85262 .01 .01
+5.84 0 0 1.84919 .01 .01
+5.85 0 0 1.84572 .01 .01
+5.86 0 0 1.84222 .01 .01
+5.87 0 0 1.83868 .01 .01
+5.88 0 0 1.83511 .01 .01
+5.89 0 0 1.8315 .01 .01
+5.9 0 0 1.82786 .01 .01
+5.91 0 0 1.82419 .01 .01
+5.92 0 0 1.82048 .01 .01
+5.93 0 0 1.81675 .01 .01
+5.94 0 0 1.81298 .01 .01
+5.95 0 0 1.80917 .01 .01
+5.96 0 0 1.80534 .01 .01
+5.97 0 0 1.80147 .01 .01
+5.98 0 0 1.79757 .01 .01
+5.99 0 0 1.79364 .01 .01
+6 0 0 1.78968 .01 .01
+6.01 0 0 1.78569 .01 .01
+6.02 0 0 1.78166 .01 .01
+6.03 0 0 1.77761 .01 .01
+6.04 0 0 1.77353 .01 .01
+6.05 0 0 1.76941 .01 .01
+6.06 0 0 1.76527 .01 .01
+6.07 0 0 1.7611 .01 .01
+6.08 0 0 1.75689 .01 .01
+6.09 0 0 1.75266 .01 .01
+6.1 0 0 1.7484 .01 .01
+6.11 0 0 1.74411 .01 .01
+6.12 0 0 1.7398 .01 .01
+6.13 0 0 1.73545 .01 .01
+6.14 0 0 1.73108 .01 .01
+6.15 0 0 1.72668 .01 .01
+6.16 0 0 1.72226 .01 .01
+6.17 0 0 1.7178 .01 .01
+6.18 0 0 1.71333 .01 .01
+6.19 0 0 1.70882 .01 .01
+6.2 0 0 1.70429 .01 .01
+6.21 0 0 1.69973 .01 .01
+6.22 0 0 1.69515 .01 .01
+6.23 0 0 1.69054 .01 .01
+6.24 0 0 1.68591 .01 .01
+6.25 0 0 1.68125 .01 .01
+6.26 0 0 1.67657 .01 .01
+6.27 0 0 1.67186 .01 .01
+6.28 0 0 1.66713 .01 .01
+6.29 0 0 1.66237 .01 .01
+6.3 0 0 1.6576 .01 .01
+6.31 0 0 1.6528 .01 .01
+6.32 0 0 1.64797 .01 .01
+6.33 0 0 1.64313 .01 .01
+6.34 0 0 1.63826 .01 .01
+6.35 0 0 1.63337 .01 .01
+6.36 0 0 1.62846 .01 .01
+6.37 0 0 1.62353 .01 .01
+6.38 0 0 1.61858 .01 .01
+6.39 0 0 1.6136 .01 .01
+6.4 0 0 1.60861 .01 .01
+6.41 0 0 1.60359 .01 .01
+6.42 0 0 1.59856 .01 .01
+6.43 0 0 1.59351 .01 .01
+6.44 0 0 1.58843 .01 .01
+6.45 0 0 1.58334 .01 .01
+6.46 0 0 1.57823 .01 .01
+6.47 0 0 1.5731 .01 .01
+6.48 0 0 1.56795 .01 .01
+6.49 0 0 1.56278 .01 .01
+6.5 0 0 1.5576 .01 .01
+6.51 0 0 1.5524 .01 .01
+6.52 0 0 1.54718 .01 .01
+6.53 0 0 1.54195 .01 .01
+6.54 0 0 1.5367 .01 .01
+6.55 0 0 1.53143 .01 .01
+6.56 0 0 1.52615 .01 .01
+6.57 0 0 1.52085 .01 .01
+6.58 0 0 1.51554 .01 .01
+6.59 0 0 1.51021 .01 .01
+6.6 0 0 1.50486 .01 .01
+6.61 0 0 1.49951 .01 .01
+6.62 0 0 1.49413 .01 .01
+6.63 0 0 1.48875 .01 .01
+6.64 0 0 1.48335 .01 .01
+6.65 0 0 1.47794 .01 .01
+6.66 0 0 1.47251 .01 .01
+6.67 0 0 1.46707 .01 .01
+6.68 0 0 1.46162 .01 .01
+6.69 0 0 1.45616 .01 .01
+6.7 0 0 1.45069 .01 .01
+6.71 0 0 1.4452 .01 .01
+6.72 0 0 1.4397 .01 .01
+6.73 0 0 1.43419 .01 .01
+6.74 0 0 1.42867 .01 .01
+6.75 0 0 1.42315 .01 .01
+6.76 0 0 1.41761 .01 .01
+6.77 0 0 1.41206 .01 .01
+6.78 0 0 1.4065 .01 .01
+6.79 0 0 1.40093 .01 .01
+6.8 0 0 1.39535 .01 .01
+6.81 0 0 1.38977 .01 .01
+6.82 0 0 1.38417 .01 .01
+6.83 0 0 1.37857 .01 .01
+6.84 0 0 1.37296 .01 .01
+6.85 0 0 1.36734 .01 .01
+6.86 0 0 1.36172 .01 .01
+6.87 0 0 1.35609 .01 .01
+6.88 0 0 1.35045 .01 .01
+6.89 0 0 1.3448 .01 .01
+6.9 0 0 1.33915 .01 .01
+6.91 0 0 1.33349 .01 .01
+6.92 0 0 1.32783 .01 .01
+6.93 0 0 1.32216 .01 .01
+6.94 0 0 1.31649 .01 .01
+6.95 0 0 1.31081 .01 .01
+6.96 0 0 1.30513 .01 .01
+6.97 0 0 1.29944 .01 .01
+6.98 0 0 1.29375 .01 .01
+6.99 0 0 1.28806 .01 .01
+7 0 0 1.28236 .01 .01
+7.01 0 0 1.27666 .01 .01
+7.02 0 0 1.27096 .01 .01
+7.03 0 0 1.26525 .01 .01
+7.04 0 0 1.25954 .01 .01
+7.05 0 0 1.25383 .01 .01
+7.06 0 0 1.24812 .01 .01
+7.07 0 0 1.2424 .01 .01
+7.08 0 0 1.23669 .01 .01
+7.09 0 0 1.23097 .01 .01
+7.1 0 0 1.22525 .01 .01
+7.11 0 0 1.21953 .01 .01
+7.12 0 0 1.21382 .01 .01
+7.13 0 0 1.2081 .01 .01
+7.14 0 0 1.20238 .01 .01
+7.15 0 0 1.19666 .01 .01
+7.16 0 0 1.19095 .01 .01
+7.17 0 0 1.18523 .01 .01
+7.18 0 0 1.17951 .01 .01
+7.19 0 0 1.1738 .01 .01
+7.2 0 0 1.16809 .01 .01
+7.21 0 0 1.16238 .01 .01
+7.22 0 0 1.15667 .01 .01
+7.23 0 0 1.15097 .01 .01
+7.24 0 0 1.14527 .01 .01
+7.25 0 0 1.13957 .01 .01
+7.26 0 0 1.13387 .01 .01
+7.27 0 0 1.12818 .01 .01
+7.28 0 0 1.12249 .01 .01
+7.29 0 0 1.1168 .01 .01
+7.3 0 0 1.11112 .01 .01
+7.31 0 0 1.10544 .01 .01
+7.32 0 0 1.09977 .01 .01
+7.33 0 0 1.0941 .01 .01
+7.34 0 0 1.08844 .01 .01
+7.35 0 0 1.08278 .01 .01
+7.36 0 0 1.07713 .01 .01
+7.37 0 0 1.07149 .01 .01
+7.38 0 0 1.06585 .01 .01
+7.39 0 0 1.06021 .01 .01
+7.4 0 0 1.05458 .01 .01
+7.41 0 0 1.04896 .01 .01
+7.42 0 0 1.04335 .01 .01
+7.43 0 0 1.03774 .01 .01
+7.44 0 0 1.03214 .01 .01
+7.45 0 0 1.02655 .01 .01
+7.46 0 0 1.02096 .01 .01
+7.47 0 0 1.01539 .01 .01
+7.48 0 0 1.00982 .01 .01
+7.49 0 0 1.00426 .01 .01
+7.5 0 0 0.998704 .01 .01
+7.51 0 0 0.99316 .01 .01
+7.52 0 0 0.987624 .01 .01
+7.53 0 0 0.982098 .01 .01
+7.54 0 0 0.976581 .01 .01
+7.55 0 0 0.971074 .01 .01
+7.56 0 0 0.965576 .01 .01
+7.57 0 0 0.960088 .01 .01
+7.58 0 0 0.95461 .01 .01
+7.59 0 0 0.949142 .01 .01
+7.6 0 0 0.943684 .01 .01
+7.61 0 0 0.938237 .01 .01
+7.62 0 0 0.9328 .01 .01
+7.63 0 0 0.927375 .01 .01
+7.64 0 0 0.921961 .01 .01
+7.65 0 0 0.916557 .01 .01
+7.66 0 0 0.911166 .01 .01
+7.67 0 0 0.905785 .01 .01
+7.68 0 0 0.900417 .01 .01
+7.69 0 0 0.895061 .01 .01
+7.7 0 0 0.889716 .01 .01
+7.71 0 0 0.884384 .01 .01
+7.72 0 0 0.879064 .01 .01
+7.73 0 0 0.873757 .01 .01
+7.74 0 0 0.868463 .01 .01
+7.75 0 0 0.863181 .01 .01
+7.76 0 0 0.857913 .01 .01
+7.77 0 0 0.852658 .01 .01
+7.78 0 0 0.847416 .01 .01
+7.79 0 0 0.842187 .01 .01
+7.8 0 0 0.836973 .01 .01
+7.81 0 0 0.831772 .01 .01
+7.82 0 0 0.826585 .01 .01
+7.83 0 0 0.821412 .01 .01
+7.84 0 0 0.816253 .01 .01
+7.85 0 0 0.811109 .01 .01
+7.86 0 0 0.805979 .01 .01
+7.87 0 0 0.800864 .01 .01
+7.88 0 0 0.795764 .01 .01
+7.89 0 0 0.790678 .01 .01
+7.9 0 0 0.785608 .01 .01
+7.91 0 0 0.780553 .01 .01
+7.92 0 0 0.775513 .01 .01
+7.93 0 0 0.770488 .01 .01
+7.94 0 0 0.76548 .01 .01
+7.95 0 0 0.760486 .01 .01
+7.96 0 0 0.755509 .01 .01
+7.97 0 0 0.750547 .01 .01
+7.98 0 0 0.745602 .01 .01
+7.99 0 0 0.740672 .01 .01
+8 0 0 0.735759 .01 .01
+8.01 0 0 0.730862 .01 .01
+8.02 0 0 0.725982 .01 .01
+8.03 0 0 0.721118 .01 .01
+8.04 0 0 0.716271 .01 .01
+8.05 0 0 0.71144 .01 .01
+8.06 0 0 0.706627 .01 .01
+8.07 0 0 0.70183 .01 .01
+8.08 0 0 0.697051 .01 .01
+8.09 0 0 0.692288 .01 .01
+8.1 0 0 0.687543 .01 .01
+8.11 0 0 0.682815 .01 .01
+8.12 0 0 0.678105 .01 .01
+8.13 0 0 0.673412 .01 .01
+8.14 0 0 0.668737 .01 .01
+8.15 0 0 0.66408 .01 .01
+8.16 0 0 0.65944 .01 .01
+8.17 0 0 0.654818 .01 .01
+8.18 0 0 0.650215 .01 .01
+8.19 0 0 0.645629 .01 .01
+8.2 0 0 0.641061 .01 .01
+8.21 0 0 0.636511 .01 .01
+8.22 0 0 0.63198 .01 .01
+8.23 0 0 0.627467 .01 .01
+8.24 0 0 0.622973 .01 .01
+8.25 0 0 0.618496 .01 .01
+8.26 0 0 0.614039 .01 .01
+8.27 0 0 0.6096 .01 .01
+8.28 0 0 0.605179 .01 .01
+8.29 0 0 0.600778 .01 .01
+8.3 0 0 0.596395 .01 .01
+8.31 0 0 0.59203 .01 .01
+8.32 0 0 0.587685 .01 .01
+8.33 0 0 0.583359 .01 .01
+8.34 0 0 0.579051 .01 .01
+8.35 0 0 0.574763 .01 .01
+8.36 0 0 0.570494 .01 .01
+8.37 0 0 0.566244 .01 .01
+8.38 0 0 0.562013 .01 .01
+8.39 0 0 0.557801 .01 .01
+8.4 0 0 0.553609 .01 .01
+8.41 0 0 0.549435 .01 .01
+8.42 0 0 0.545282 .01 .01
+8.43 0 0 0.541147 .01 .01
+8.44 0 0 0.537032 .01 .01
+8.45 0 0 0.532937 .01 .01
+8.46 0 0 0.52886 .01 .01
+8.47 0 0 0.524804 .01 .01
+8.48 0 0 0.520767 .01 .01
+8.49 0 0 0.516749 .01 .01
+8.5 0 0 0.512752 .01 .01
+8.51 0 0 0.508773 .01 .01
+8.52 0 0 0.504815 .01 .01
+8.53 0 0 0.500876 .01 .01
+8.54 0 0 0.496956 .01 .01
+8.55 0 0 0.493057 .01 .01
+8.56 0 0 0.489177 .01 .01
+8.57 0 0 0.485317 .01 .01
+8.58 0 0 0.481477 .01 .01
+8.59 0 0 0.477656 .01 .01
+8.6 0 0 0.473856 .01 .01
+8.61 0 0 0.470075 .01 .01
+8.62 0 0 0.466313 .01 .01
+8.63 0 0 0.462572 .01 .01
+8.64 0 0 0.458851 .01 .01
+8.65 0 0 0.455149 .01 .01
+8.66 0 0 0.451467 .01 .01
+8.67 0 0 0.447805 .01 .01
+8.68 0 0 0.444163 .01 .01
+8.69 0 0 0.440541 .01 .01
+8.7 0 0 0.436938 .01 .01
+8.71 0 0 0.433355 .01 .01
+8.72 0 0 0.429792 .01 .01
+8.73 0 0 0.426249 .01 .01
+8.74 0 0 0.422726 .01 .01
+8.75 0 0 0.419223 .01 .01
+8.76 0 0 0.415739 .01 .01
+8.77 0 0 0.412275 .01 .01
+8.78 0 0 0.408831 .01 .01
+8.79 0 0 0.405407 .01 .01
+8.8 0 0 0.402002 .01 .01
+8.81 0 0 0.398618 .01 .01
+8.82 0 0 0.395252 .01 .01
+8.83 0 0 0.391907 .01 .01
+8.84 0 0 0.388581 .01 .01
+8.85 0 0 0.385275 .01 .01
+8.86 0 0 0.381989 .01 .01
+8.87 0 0 0.378722 .01 .01
+8.88 0 0 0.375475 .01 .01
+8.89 0 0 0.372247 .01 .01
+8.9 0 0 0.369039 .01 .01
+8.91 0 0 0.36585 .01 .01
+8.92 0 0 0.362681 .01 .01
+8.93 0 0 0.359532 .01 .01
+8.94 0 0 0.356402 .01 .01
+8.95 0 0 0.353291 .01 .01
+8.96 0 0 0.350199 .01 .01
+8.97 0 0 0.347127 .01 .01
+8.98 0 0 0.344074 .01 .01
+8.99 0 0 0.341041 .01 .01
+9 0 0 0.338027 .01 .01
+9.01 0 0 0.335032 .01 .01
+9.02 0 0 0.332056 .01 .01
+9.03 0 0 0.329099 .01 .01
+9.04 0 0 0.326161 .01 .01
+9.05 0 0 0.323242 .01 .01
+9.06 0 0 0.320343 .01 .01
+9.07 0 0 0.317462 .01 .01
+9.08 0 0 0.3146 .01 .01
+9.09 0 0 0.311757 .01 .01
+9.1 0 0 0.308933 .01 .01
+9.11 0 0 0.306128 .01 .01
+9.12 0 0 0.303341 .01 .01
+9.13 0 0 0.300573 .01 .01
+9.14 0 0 0.297824 .01 .01
+9.15 0 0 0.295093 .01 .01
+9.16 0 0 0.292381 .01 .01
+9.17 0 0 0.289687 .01 .01
+9.18 0 0 0.287012 .01 .01
+9.19 0 0 0.284355 .01 .01
+9.2 0 0 0.281717 .01 .01
+9.21 0 0 0.279097 .01 .01
+9.22 0 0 0.276495 .01 .01
+9.23 0 0 0.273911 .01 .01
+9.24 0 0 0.271345 .01 .01
+9.25 0 0 0.268797 .01 .01
+9.26 0 0 0.266268 .01 .01
+9.27 0 0 0.263756 .01 .01
+9.28 0 0 0.261262 .01 .01
+9.29 0 0 0.258786 .01 .01
+9.3 0 0 0.256328 .01 .01
+9.31 0 0 0.253888 .01 .01
+9.32 0 0 0.251465 .01 .01
+9.33 0 0 0.249059 .01 .01
+9.34 0 0 0.246672 .01 .01
+9.35 0 0 0.244301 .01 .01
+9.36 0 0 0.241948 .01 .01
+9.37 0 0 0.239613 .01 .01
+9.38 0 0 0.237295 .01 .01
+9.39 0 0 0.234994 .01 .01
+9.4 0 0 0.23271 .01 .01
+9.41 0 0 0.230443 .01 .01
+9.42 0 0 0.228193 .01 .01
+9.43 0 0 0.22596 .01 .01
+9.44 0 0 0.223744 .01 .01
+9.45 0 0 0.221545 .01 .01
+9.46 0 0 0.219362 .01 .01
+9.47 0 0 0.217196 .01 .01
+9.48 0 0 0.215047 .01 .01
+9.49 0 0 0.212915 .01 .01
+9.5 0 0 0.210798 .01 .01
+9.51 0 0 0.208699 .01 .01
+9.52 0 0 0.206615 .01 .01
+9.53 0 0 0.204548 .01 .01
+9.54 0 0 0.202497 .01 .01
+9.55 0 0 0.200462 .01 .01
+9.56 0 0 0.198443 .01 .01
+9.57 0 0 0.19644 .01 .01
+9.58 0 0 0.194453 .01 .01
+9.59 0 0 0.192482 .01 .01
+9.6 0 0 0.190527 .01 .01
+9.61 0 0 0.188587 .01 .01
+9.62 0 0 0.186663 .01 .01
+9.63 0 0 0.184754 .01 .01
+9.64 0 0 0.182861 .01 .01
+9.65 0 0 0.180983 .01 .01
+9.66 0 0 0.17912 .01 .01
+9.67 0 0 0.177273 .01 .01
+9.68 0 0 0.175441 .01 .01
+9.69 0 0 0.173624 .01 .01
+9.7 0 0 0.171822 .01 .01
+9.71 0 0 0.170035 .01 .01
+9.72 0 0 0.168262 .01 .01
+9.73 0 0 0.166505 .01 .01
+9.74 0 0 0.164762 .01 .01
+9.75 0 0 0.163034 .01 .01
+9.76 0 0 0.16132 .01 .01
+9.77 0 0 0.159621 .01 .01
+9.78 0 0 0.157936 .01 .01
+9.79 0 0 0.156266 .01 .01
+9.8 0 0 0.154609 .01 .01
+9.81 0 0 0.152967 .01 .01
+9.82 0 0 0.151339 .01 .01
+9.83 0 0 0.149725 .01 .01
+9.84 0 0 0.148125 .01 .01
+9.85 0 0 0.146539 .01 .01
+9.86 0 0 0.144966 .01 .01
+9.87 0 0 0.143408 .01 .01
+9.88 0 0 0.141862 .01 .01
+9.89 0 0 0.140331 .01 .01
+9.9 0 0 0.138813 .01 .01
+9.91 0 0 0.137308 .01 .01
+9.92 0 0 0.135816 .01 .01
+9.93 0 0 0.134338 .01 .01
+9.94 0 0 0.132873 .01 .01
+9.95 0 0 0.131421 .01 .01
+9.96 0 0 0.129981 .01 .01
+9.97 0 0 0.128555 .01 .01
+9.98 0 0 0.127142 .01 .01
+9.99 0 0 0.125741 .01 .01
+10 0 0 0.124353 .01 .01
diff --git a/samples/linear.dat b/samples/linear.dat
new file mode 100644
index 0000000..03849b6
--- /dev/null
+++ b/samples/linear.dat
@@ -0,0 +1,4 @@
+0	0	0	4	1	1
+1	0	0	7	1	1
+2	0	0	10	1	1
+3	0	0	13	1	1
diff --git a/samples/powerlaw.dat b/samples/powerlaw.dat
new file mode 100644
index 0000000..ef67d32
--- /dev/null
+++ b/samples/powerlaw.dat
@@ -0,0 +1,901 @@
+1 0 0 5 .01 .01
+1.01 0 0 4.94557 .01 .01
+1.02 0 0 4.89226 .01 .01
+1.03 0 0 4.84004 .01 .01
+1.04 0 0 4.78887 .01 .01
+1.05 0 0 4.73873 .01 .01
+1.06 0 0 4.68958 .01 .01
+1.07 0 0 4.64139 .01 .01
+1.08 0 0 4.59414 .01 .01
+1.09 0 0 4.54779 .01 .01
+1.1 0 0 4.50234 .01 .01
+1.11 0 0 4.45774 .01 .01
+1.12 0 0 4.41398 .01 .01
+1.13 0 0 4.37103 .01 .01
+1.14 0 0 4.32887 .01 .01
+1.15 0 0 4.28748 .01 .01
+1.16 0 0 4.24684 .01 .01
+1.17 0 0 4.20693 .01 .01
+1.18 0 0 4.16773 .01 .01
+1.19 0 0 4.12922 .01 .01
+1.2 0 0 4.09139 .01 .01
+1.21 0 0 4.05421 .01 .01
+1.22 0 0 4.01767 .01 .01
+1.23 0 0 3.98175 .01 .01
+1.24 0 0 3.94645 .01 .01
+1.25 0 0 3.91173 .01 .01
+1.26 0 0 3.87759 .01 .01
+1.27 0 0 3.84402 .01 .01
+1.28 0 0 3.811 .01 .01
+1.29 0 0 3.77852 .01 .01
+1.3 0 0 3.74656 .01 .01
+1.31 0 0 3.71511 .01 .01
+1.32 0 0 3.68416 .01 .01
+1.33 0 0 3.6537 .01 .01
+1.34 0 0 3.62372 .01 .01
+1.35 0 0 3.59421 .01 .01
+1.36 0 0 3.56515 .01 .01
+1.37 0 0 3.53653 .01 .01
+1.38 0 0 3.50835 .01 .01
+1.39 0 0 3.4806 .01 .01
+1.4 0 0 3.45326 .01 .01
+1.41 0 0 3.42633 .01 .01
+1.42 0 0 3.3998 .01 .01
+1.43 0 0 3.37365 .01 .01
+1.44 0 0 3.34789 .01 .01
+1.45 0 0 3.3225 .01 .01
+1.46 0 0 3.29748 .01 .01
+1.47 0 0 3.27281 .01 .01
+1.48 0 0 3.24849 .01 .01
+1.49 0 0 3.22452 .01 .01
+1.5 0 0 3.20088 .01 .01
+1.51 0 0 3.17757 .01 .01
+1.52 0 0 3.15458 .01 .01
+1.53 0 0 3.13191 .01 .01
+1.54 0 0 3.10955 .01 .01
+1.55 0 0 3.08749 .01 .01
+1.56 0 0 3.06572 .01 .01
+1.57 0 0 3.04425 .01 .01
+1.58 0 0 3.02306 .01 .01
+1.59 0 0 3.00216 .01 .01
+1.6 0 0 2.98152 .01 .01
+1.61 0 0 2.96116 .01 .01
+1.62 0 0 2.94106 .01 .01
+1.63 0 0 2.92122 .01 .01
+1.64 0 0 2.90163 .01 .01
+1.65 0 0 2.88229 .01 .01
+1.66 0 0 2.8632 .01 .01
+1.67 0 0 2.84434 .01 .01
+1.68 0 0 2.82572 .01 .01
+1.69 0 0 2.80734 .01 .01
+1.7 0 0 2.78918 .01 .01
+1.71 0 0 2.77124 .01 .01
+1.72 0 0 2.75352 .01 .01
+1.73 0 0 2.73602 .01 .01
+1.74 0 0 2.71873 .01 .01
+1.75 0 0 2.70164 .01 .01
+1.76 0 0 2.68476 .01 .01
+1.77 0 0 2.66808 .01 .01
+1.78 0 0 2.6516 .01 .01
+1.79 0 0 2.63531 .01 .01
+1.8 0 0 2.61921 .01 .01
+1.81 0 0 2.6033 .01 .01
+1.82 0 0 2.58757 .01 .01
+1.83 0 0 2.57202 .01 .01
+1.84 0 0 2.55664 .01 .01
+1.85 0 0 2.54145 .01 .01
+1.86 0 0 2.52642 .01 .01
+1.87 0 0 2.51156 .01 .01
+1.88 0 0 2.49687 .01 .01
+1.89 0 0 2.48234 .01 .01
+1.9 0 0 2.46798 .01 .01
+1.91 0 0 2.45377 .01 .01
+1.92 0 0 2.43971 .01 .01
+1.93 0 0 2.42581 .01 .01
+1.94 0 0 2.41206 .01 .01
+1.95 0 0 2.39846 .01 .01
+1.96 0 0 2.385 .01 .01
+1.97 0 0 2.37169 .01 .01
+1.98 0 0 2.35851 .01 .01
+1.99 0 0 2.34548 .01 .01
+2 0 0 2.33258 .01 .01
+2.01 0 0 2.31982 .01 .01
+2.02 0 0 2.30719 .01 .01
+2.03 0 0 2.29469 .01 .01
+2.04 0 0 2.28232 .01 .01
+2.05 0 0 2.27008 .01 .01
+2.06 0 0 2.25796 .01 .01
+2.07 0 0 2.24596 .01 .01
+2.08 0 0 2.23409 .01 .01
+2.09 0 0 2.22233 .01 .01
+2.1 0 0 2.21069 .01 .01
+2.11 0 0 2.19917 .01 .01
+2.12 0 0 2.18776 .01 .01
+2.13 0 0 2.17647 .01 .01
+2.14 0 0 2.16528 .01 .01
+2.15 0 0 2.15421 .01 .01
+2.16 0 0 2.14324 .01 .01
+2.17 0 0 2.13238 .01 .01
+2.18 0 0 2.12162 .01 .01
+2.19 0 0 2.11097 .01 .01
+2.2 0 0 2.10041 .01 .01
+2.21 0 0 2.08996 .01 .01
+2.22 0 0 2.07961 .01 .01
+2.23 0 0 2.06935 .01 .01
+2.24 0 0 2.05919 .01 .01
+2.25 0 0 2.04913 .01 .01
+2.26 0 0 2.03916 .01 .01
+2.27 0 0 2.02928 .01 .01
+2.28 0 0 2.01949 .01 .01
+2.29 0 0 2.00979 .01 .01
+2.3 0 0 2.00018 .01 .01
+2.31 0 0 1.99066 .01 .01
+2.32 0 0 1.98122 .01 .01
+2.33 0 0 1.97187 .01 .01
+2.34 0 0 1.9626 .01 .01
+2.35 0 0 1.95342 .01 .01
+2.36 0 0 1.94432 .01 .01
+2.37 0 0 1.93529 .01 .01
+2.38 0 0 1.92635 .01 .01
+2.39 0 0 1.91749 .01 .01
+2.4 0 0 1.9087 .01 .01
+2.41 0 0 1.89999 .01 .01
+2.42 0 0 1.89136 .01 .01
+2.43 0 0 1.8828 .01 .01
+2.44 0 0 1.87431 .01 .01
+2.45 0 0 1.8659 .01 .01
+2.46 0 0 1.85755 .01 .01
+2.47 0 0 1.84928 .01 .01
+2.48 0 0 1.84108 .01 .01
+2.49 0 0 1.83295 .01 .01
+2.5 0 0 1.82489 .01 .01
+2.51 0 0 1.81689 .01 .01
+2.52 0 0 1.80896 .01 .01
+2.53 0 0 1.8011 .01 .01
+2.54 0 0 1.7933 .01 .01
+2.55 0 0 1.78557 .01 .01
+2.56 0 0 1.77789 .01 .01
+2.57 0 0 1.77029 .01 .01
+2.58 0 0 1.76274 .01 .01
+2.59 0 0 1.75526 .01 .01
+2.6 0 0 1.74783 .01 .01
+2.61 0 0 1.74047 .01 .01
+2.62 0 0 1.73316 .01 .01
+2.63 0 0 1.72591 .01 .01
+2.64 0 0 1.71872 .01 .01
+2.65 0 0 1.71159 .01 .01
+2.66 0 0 1.70451 .01 .01
+2.67 0 0 1.69749 .01 .01
+2.68 0 0 1.69053 .01 .01
+2.69 0 0 1.68361 .01 .01
+2.7 0 0 1.67676 .01 .01
+2.71 0 0 1.66995 .01 .01
+2.72 0 0 1.6632 .01 .01
+2.73 0 0 1.6565 .01 .01
+2.74 0 0 1.64985 .01 .01
+2.75 0 0 1.64325 .01 .01
+2.76 0 0 1.6367 .01 .01
+2.77 0 0 1.63021 .01 .01
+2.78 0 0 1.62376 .01 .01
+2.79 0 0 1.61736 .01 .01
+2.8 0 0 1.611 .01 .01
+2.81 0 0 1.6047 .01 .01
+2.82 0 0 1.59844 .01 .01
+2.83 0 0 1.59223 .01 .01
+2.84 0 0 1.58606 .01 .01
+2.85 0 0 1.57994 .01 .01
+2.86 0 0 1.57386 .01 .01
+2.87 0 0 1.56783 .01 .01
+2.88 0 0 1.56185 .01 .01
+2.89 0 0 1.5559 .01 .01
+2.9 0 0 1.55 .01 .01
+2.91 0 0 1.54414 .01 .01
+2.92 0 0 1.53833 .01 .01
+2.93 0 0 1.53255 .01 .01
+2.94 0 0 1.52682 .01 .01
+2.95 0 0 1.52113 .01 .01
+2.96 0 0 1.51548 .01 .01
+2.97 0 0 1.50986 .01 .01
+2.98 0 0 1.50429 .01 .01
+2.99 0 0 1.49876 .01 .01
+3 0 0 1.49326 .01 .01
+3.01 0 0 1.48781 .01 .01
+3.02 0 0 1.48239 .01 .01
+3.03 0 0 1.47701 .01 .01
+3.04 0 0 1.47167 .01 .01
+3.05 0 0 1.46636 .01 .01
+3.06 0 0 1.46109 .01 .01
+3.07 0 0 1.45585 .01 .01
+3.08 0 0 1.45066 .01 .01
+3.09 0 0 1.44549 .01 .01
+3.1 0 0 1.44036 .01 .01
+3.11 0 0 1.43527 .01 .01
+3.12 0 0 1.43021 .01 .01
+3.13 0 0 1.42518 .01 .01
+3.14 0 0 1.42019 .01 .01
+3.15 0 0 1.41523 .01 .01
+3.16 0 0 1.41031 .01 .01
+3.17 0 0 1.40542 .01 .01
+3.18 0 0 1.40056 .01 .01
+3.19 0 0 1.39573 .01 .01
+3.2 0 0 1.39093 .01 .01
+3.21 0 0 1.38616 .01 .01
+3.22 0 0 1.38143 .01 .01
+3.23 0 0 1.37673 .01 .01
+3.24 0 0 1.37205 .01 .01
+3.25 0 0 1.36741 .01 .01
+3.26 0 0 1.3628 .01 .01
+3.27 0 0 1.35821 .01 .01
+3.28 0 0 1.35366 .01 .01
+3.29 0 0 1.34913 .01 .01
+3.3 0 0 1.34464 .01 .01
+3.31 0 0 1.34017 .01 .01
+3.32 0 0 1.33573 .01 .01
+3.33 0 0 1.33132 .01 .01
+3.34 0 0 1.32693 .01 .01
+3.35 0 0 1.32258 .01 .01
+3.36 0 0 1.31825 .01 .01
+3.37 0 0 1.31394 .01 .01
+3.38 0 0 1.30967 .01 .01
+3.39 0 0 1.30542 .01 .01
+3.4 0 0 1.3012 .01 .01
+3.41 0 0 1.297 .01 .01
+3.42 0 0 1.29283 .01 .01
+3.43 0 0 1.28868 .01 .01
+3.44 0 0 1.28456 .01 .01
+3.45 0 0 1.28047 .01 .01
+3.46 0 0 1.2764 .01 .01
+3.47 0 0 1.27235 .01 .01
+3.48 0 0 1.26833 .01 .01
+3.49 0 0 1.26433 .01 .01
+3.5 0 0 1.26036 .01 .01
+3.51 0 0 1.25641 .01 .01
+3.52 0 0 1.25249 .01 .01
+3.53 0 0 1.24858 .01 .01
+3.54 0 0 1.2447 .01 .01
+3.55 0 0 1.24085 .01 .01
+3.56 0 0 1.23702 .01 .01
+3.57 0 0 1.2332 .01 .01
+3.58 0 0 1.22942 .01 .01
+3.59 0 0 1.22565 .01 .01
+3.6 0 0 1.2219 .01 .01
+3.61 0 0 1.21818 .01 .01
+3.62 0 0 1.21448 .01 .01
+3.63 0 0 1.2108 .01 .01
+3.64 0 0 1.20714 .01 .01
+3.65 0 0 1.2035 .01 .01
+3.66 0 0 1.19989 .01 .01
+3.67 0 0 1.19629 .01 .01
+3.68 0 0 1.19272 .01 .01
+3.69 0 0 1.18916 .01 .01
+3.7 0 0 1.18563 .01 .01
+3.71 0 0 1.18211 .01 .01
+3.72 0 0 1.17862 .01 .01
+3.73 0 0 1.17514 .01 .01
+3.74 0 0 1.17169 .01 .01
+3.75 0 0 1.16825 .01 .01
+3.76 0 0 1.16483 .01 .01
+3.77 0 0 1.16143 .01 .01
+3.78 0 0 1.15805 .01 .01
+3.79 0 0 1.15469 .01 .01
+3.8 0 0 1.15135 .01 .01
+3.81 0 0 1.14803 .01 .01
+3.82 0 0 1.14472 .01 .01
+3.83 0 0 1.14144 .01 .01
+3.84 0 0 1.13817 .01 .01
+3.85 0 0 1.13491 .01 .01
+3.86 0 0 1.13168 .01 .01
+3.87 0 0 1.12846 .01 .01
+3.88 0 0 1.12527 .01 .01
+3.89 0 0 1.12208 .01 .01
+3.9 0 0 1.11892 .01 .01
+3.91 0 0 1.11577 .01 .01
+3.92 0 0 1.11264 .01 .01
+3.93 0 0 1.10953 .01 .01
+3.94 0 0 1.10643 .01 .01
+3.95 0 0 1.10335 .01 .01
+3.96 0 0 1.10029 .01 .01
+3.97 0 0 1.09724 .01 .01
+3.98 0 0 1.0942 .01 .01
+3.99 0 0 1.09119 .01 .01
+4 0 0 1.08819 .01 .01
+4.01 0 0 1.0852 .01 .01
+4.02 0 0 1.08223 .01 .01
+4.03 0 0 1.07928 .01 .01
+4.04 0 0 1.07634 .01 .01
+4.05 0 0 1.07342 .01 .01
+4.06 0 0 1.07051 .01 .01
+4.07 0 0 1.06762 .01 .01
+4.08 0 0 1.06474 .01 .01
+4.09 0 0 1.06188 .01 .01
+4.1 0 0 1.05903 .01 .01
+4.11 0 0 1.05619 .01 .01
+4.12 0 0 1.05338 .01 .01
+4.13 0 0 1.05057 .01 .01
+4.14 0 0 1.04778 .01 .01
+4.15 0 0 1.045 .01 .01
+4.16 0 0 1.04224 .01 .01
+4.17 0 0 1.03949 .01 .01
+4.18 0 0 1.03675 .01 .01
+4.19 0 0 1.03403 .01 .01
+4.2 0 0 1.03133 .01 .01
+4.21 0 0 1.02863 .01 .01
+4.22 0 0 1.02595 .01 .01
+4.23 0 0 1.02328 .01 .01
+4.24 0 0 1.02063 .01 .01
+4.25 0 0 1.01799 .01 .01
+4.26 0 0 1.01536 .01 .01
+4.27 0 0 1.01274 .01 .01
+4.28 0 0 1.01014 .01 .01
+4.29 0 0 1.00755 .01 .01
+4.3 0 0 1.00497 .01 .01
+4.31 0 0 1.00241 .01 .01
+4.32 0 0 0.999857 .01 .01
+4.33 0 0 0.997317 .01 .01
+4.34 0 0 0.99479 .01 .01
+4.35 0 0 0.992274 .01 .01
+4.36 0 0 0.989771 .01 .01
+4.37 0 0 0.98728 .01 .01
+4.38 0 0 0.984801 .01 .01
+4.39 0 0 0.982334 .01 .01
+4.4 0 0 0.979878 .01 .01
+4.41 0 0 0.977434 .01 .01
+4.42 0 0 0.975002 .01 .01
+4.43 0 0 0.972581 .01 .01
+4.44 0 0 0.970172 .01 .01
+4.45 0 0 0.967774 .01 .01
+4.46 0 0 0.965387 .01 .01
+4.47 0 0 0.963012 .01 .01
+4.48 0 0 0.960648 .01 .01
+4.49 0 0 0.958295 .01 .01
+4.5 0 0 0.955952 .01 .01
+4.51 0 0 0.953621 .01 .01
+4.52 0 0 0.951301 .01 .01
+4.53 0 0 0.948991 .01 .01
+4.54 0 0 0.946692 .01 .01
+4.55 0 0 0.944403 .01 .01
+4.56 0 0 0.942125 .01 .01
+4.57 0 0 0.939858 .01 .01
+4.58 0 0 0.937601 .01 .01
+4.59 0 0 0.935354 .01 .01
+4.6 0 0 0.933118 .01 .01
+4.61 0 0 0.930891 .01 .01
+4.62 0 0 0.928675 .01 .01
+4.63 0 0 0.926469 .01 .01
+4.64 0 0 0.924273 .01 .01
+4.65 0 0 0.922087 .01 .01
+4.66 0 0 0.91991 .01 .01
+4.67 0 0 0.917744 .01 .01
+4.68 0 0 0.915587 .01 .01
+4.69 0 0 0.91344 .01 .01
+4.7 0 0 0.911302 .01 .01
+4.71 0 0 0.909174 .01 .01
+4.72 0 0 0.907055 .01 .01
+4.73 0 0 0.904946 .01 .01
+4.74 0 0 0.902846 .01 .01
+4.75 0 0 0.900756 .01 .01
+4.76 0 0 0.898674 .01 .01
+4.77 0 0 0.896602 .01 .01
+4.78 0 0 0.894539 .01 .01
+4.79 0 0 0.892485 .01 .01
+4.8 0 0 0.89044 .01 .01
+4.81 0 0 0.888404 .01 .01
+4.82 0 0 0.886377 .01 .01
+4.83 0 0 0.884358 .01 .01
+4.84 0 0 0.882348 .01 .01
+4.85 0 0 0.880347 .01 .01
+4.86 0 0 0.878355 .01 .01
+4.87 0 0 0.876371 .01 .01
+4.88 0 0 0.874396 .01 .01
+4.89 0 0 0.872429 .01 .01
+4.9 0 0 0.870471 .01 .01
+4.91 0 0 0.868521 .01 .01
+4.92 0 0 0.866579 .01 .01
+4.93 0 0 0.864646 .01 .01
+4.94 0 0 0.862721 .01 .01
+4.95 0 0 0.860804 .01 .01
+4.96 0 0 0.858895 .01 .01
+4.97 0 0 0.856994 .01 .01
+4.98 0 0 0.855102 .01 .01
+4.99 0 0 0.853217 .01 .01
+5 0 0 0.85134 .01 .01
+5.01 0 0 0.849471 .01 .01
+5.02 0 0 0.84761 .01 .01
+5.03 0 0 0.845756 .01 .01
+5.04 0 0 0.843911 .01 .01
+5.05 0 0 0.842073 .01 .01
+5.06 0 0 0.840242 .01 .01
+5.07 0 0 0.838419 .01 .01
+5.08 0 0 0.836604 .01 .01
+5.09 0 0 0.834796 .01 .01
+5.1 0 0 0.832996 .01 .01
+5.11 0 0 0.831203 .01 .01
+5.12 0 0 0.829417 .01 .01
+5.13 0 0 0.827639 .01 .01
+5.14 0 0 0.825868 .01 .01
+5.15 0 0 0.824104 .01 .01
+5.16 0 0 0.822347 .01 .01
+5.17 0 0 0.820598 .01 .01
+5.18 0 0 0.818855 .01 .01
+5.19 0 0 0.81712 .01 .01
+5.2 0 0 0.815392 .01 .01
+5.21 0 0 0.81367 .01 .01
+5.22 0 0 0.811956 .01 .01
+5.23 0 0 0.810248 .01 .01
+5.24 0 0 0.808548 .01 .01
+5.25 0 0 0.806854 .01 .01
+5.26 0 0 0.805166 .01 .01
+5.27 0 0 0.803486 .01 .01
+5.28 0 0 0.801812 .01 .01
+5.29 0 0 0.800145 .01 .01
+5.3 0 0 0.798485 .01 .01
+5.31 0 0 0.796831 .01 .01
+5.32 0 0 0.795183 .01 .01
+5.33 0 0 0.793542 .01 .01
+5.34 0 0 0.791908 .01 .01
+5.35 0 0 0.79028 .01 .01
+5.36 0 0 0.788658 .01 .01
+5.37 0 0 0.787043 .01 .01
+5.38 0 0 0.785434 .01 .01
+5.39 0 0 0.783831 .01 .01
+5.4 0 0 0.782234 .01 .01
+5.41 0 0 0.780644 .01 .01
+5.42 0 0 0.77906 .01 .01
+5.43 0 0 0.777482 .01 .01
+5.44 0 0 0.77591 .01 .01
+5.45 0 0 0.774344 .01 .01
+5.46 0 0 0.772784 .01 .01
+5.47 0 0 0.77123 .01 .01
+5.48 0 0 0.769682 .01 .01
+5.49 0 0 0.76814 .01 .01
+5.5 0 0 0.766604 .01 .01
+5.51 0 0 0.765074 .01 .01
+5.52 0 0 0.763549 .01 .01
+5.53 0 0 0.762031 .01 .01
+5.54 0 0 0.760518 .01 .01
+5.55 0 0 0.75901 .01 .01
+5.56 0 0 0.757509 .01 .01
+5.57 0 0 0.756013 .01 .01
+5.58 0 0 0.754523 .01 .01
+5.59 0 0 0.753038 .01 .01
+5.6 0 0 0.751559 .01 .01
+5.61 0 0 0.750086 .01 .01
+5.62 0 0 0.748618 .01 .01
+5.63 0 0 0.747155 .01 .01
+5.64 0 0 0.745698 .01 .01
+5.65 0 0 0.744246 .01 .01
+5.66 0 0 0.7428 .01 .01
+5.67 0 0 0.741359 .01 .01
+5.68 0 0 0.739924 .01 .01
+5.69 0 0 0.738493 .01 .01
+5.7 0 0 0.737068 .01 .01
+5.71 0 0 0.735648 .01 .01
+5.72 0 0 0.734234 .01 .01
+5.73 0 0 0.732824 .01 .01
+5.74 0 0 0.73142 .01 .01
+5.75 0 0 0.730021 .01 .01
+5.76 0 0 0.728627 .01 .01
+5.77 0 0 0.727238 .01 .01
+5.78 0 0 0.725854 .01 .01
+5.79 0 0 0.724475 .01 .01
+5.8 0 0 0.723101 .01 .01
+5.81 0 0 0.721732 .01 .01
+5.82 0 0 0.720369 .01 .01
+5.83 0 0 0.719009 .01 .01
+5.84 0 0 0.717655 .01 .01
+5.85 0 0 0.716306 .01 .01
+5.86 0 0 0.714961 .01 .01
+5.87 0 0 0.713622 .01 .01
+5.88 0 0 0.712287 .01 .01
+5.89 0 0 0.710957 .01 .01
+5.9 0 0 0.709631 .01 .01
+5.91 0 0 0.708311 .01 .01
+5.92 0 0 0.706995 .01 .01
+5.93 0 0 0.705683 .01 .01
+5.94 0 0 0.704377 .01 .01
+5.95 0 0 0.703074 .01 .01
+5.96 0 0 0.701777 .01 .01
+5.97 0 0 0.700484 .01 .01
+5.98 0 0 0.699196 .01 .01
+5.99 0 0 0.697912 .01 .01
+6 0 0 0.696632 .01 .01
+6.01 0 0 0.695357 .01 .01
+6.02 0 0 0.694087 .01 .01
+6.03 0 0 0.692821 .01 .01
+6.04 0 0 0.691559 .01 .01
+6.05 0 0 0.690302 .01 .01
+6.06 0 0 0.689049 .01 .01
+6.07 0 0 0.6878 .01 .01
+6.08 0 0 0.686556 .01 .01
+6.09 0 0 0.685316 .01 .01
+6.1 0 0 0.68408 .01 .01
+6.11 0 0 0.682849 .01 .01
+6.12 0 0 0.681622 .01 .01
+6.13 0 0 0.680399 .01 .01
+6.14 0 0 0.67918 .01 .01
+6.15 0 0 0.677965 .01 .01
+6.16 0 0 0.676755 .01 .01
+6.17 0 0 0.675548 .01 .01
+6.18 0 0 0.674346 .01 .01
+6.19 0 0 0.673148 .01 .01
+6.2 0 0 0.671953 .01 .01
+6.21 0 0 0.670763 .01 .01
+6.22 0 0 0.669577 .01 .01
+6.23 0 0 0.668395 .01 .01
+6.24 0 0 0.667217 .01 .01
+6.25 0 0 0.666043 .01 .01
+6.26 0 0 0.664872 .01 .01
+6.27 0 0 0.663706 .01 .01
+6.28 0 0 0.662543 .01 .01
+6.29 0 0 0.661385 .01 .01
+6.3 0 0 0.66023 .01 .01
+6.31 0 0 0.659079 .01 .01
+6.32 0 0 0.657932 .01 .01
+6.33 0 0 0.656789 .01 .01
+6.34 0 0 0.65565 .01 .01
+6.35 0 0 0.654514 .01 .01
+6.36 0 0 0.653382 .01 .01
+6.37 0 0 0.652254 .01 .01
+6.38 0 0 0.651129 .01 .01
+6.39 0 0 0.650009 .01 .01
+6.4 0 0 0.648891 .01 .01
+6.41 0 0 0.647778 .01 .01
+6.42 0 0 0.646668 .01 .01
+6.43 0 0 0.645562 .01 .01
+6.44 0 0 0.644459 .01 .01
+6.45 0 0 0.64336 .01 .01
+6.46 0 0 0.642265 .01 .01
+6.47 0 0 0.641173 .01 .01
+6.48 0 0 0.640085 .01 .01
+6.49 0 0 0.639 .01 .01
+6.5 0 0 0.637919 .01 .01
+6.51 0 0 0.636841 .01 .01
+6.52 0 0 0.635767 .01 .01
+6.53 0 0 0.634696 .01 .01
+6.54 0 0 0.633628 .01 .01
+6.55 0 0 0.632564 .01 .01
+6.56 0 0 0.631504 .01 .01
+6.57 0 0 0.630446 .01 .01
+6.58 0 0 0.629392 .01 .01
+6.59 0 0 0.628342 .01 .01
+6.6 0 0 0.627295 .01 .01
+6.61 0 0 0.626251 .01 .01
+6.62 0 0 0.62521 .01 .01
+6.63 0 0 0.624173 .01 .01
+6.64 0 0 0.623139 .01 .01
+6.65 0 0 0.622109 .01 .01
+6.66 0 0 0.621081 .01 .01
+6.67 0 0 0.620057 .01 .01
+6.68 0 0 0.619036 .01 .01
+6.69 0 0 0.618018 .01 .01
+6.7 0 0 0.617004 .01 .01
+6.71 0 0 0.615992 .01 .01
+6.72 0 0 0.614984 .01 .01
+6.73 0 0 0.613979 .01 .01
+6.74 0 0 0.612977 .01 .01
+6.75 0 0 0.611978 .01 .01
+6.76 0 0 0.610982 .01 .01
+6.77 0 0 0.60999 .01 .01
+6.78 0 0 0.609 .01 .01
+6.79 0 0 0.608014 .01 .01
+6.8 0 0 0.60703 .01 .01
+6.81 0 0 0.60605 .01 .01
+6.82 0 0 0.605072 .01 .01
+6.83 0 0 0.604098 .01 .01
+6.84 0 0 0.603126 .01 .01
+6.85 0 0 0.602158 .01 .01
+6.86 0 0 0.601192 .01 .01
+6.87 0 0 0.60023 .01 .01
+6.88 0 0 0.59927 .01 .01
+6.89 0 0 0.598314 .01 .01
+6.9 0 0 0.59736 .01 .01
+6.91 0 0 0.596409 .01 .01
+6.92 0 0 0.595461 .01 .01
+6.93 0 0 0.594516 .01 .01
+6.94 0 0 0.593574 .01 .01
+6.95 0 0 0.592634 .01 .01
+6.96 0 0 0.591698 .01 .01
+6.97 0 0 0.590764 .01 .01
+6.98 0 0 0.589833 .01 .01
+6.99 0 0 0.588905 .01 .01
+7 0 0 0.587979 .01 .01
+7.01 0 0 0.587057 .01 .01
+7.02 0 0 0.586137 .01 .01
+7.03 0 0 0.58522 .01 .01
+7.04 0 0 0.584306 .01 .01
+7.05 0 0 0.583394 .01 .01
+7.06 0 0 0.582485 .01 .01
+7.07 0 0 0.581579 .01 .01
+7.08 0 0 0.580675 .01 .01
+7.09 0 0 0.579775 .01 .01
+7.1 0 0 0.578876 .01 .01
+7.11 0 0 0.577981 .01 .01
+7.12 0 0 0.577088 .01 .01
+7.13 0 0 0.576198 .01 .01
+7.14 0 0 0.57531 .01 .01
+7.15 0 0 0.574425 .01 .01
+7.16 0 0 0.573543 .01 .01
+7.17 0 0 0.572663 .01 .01
+7.18 0 0 0.571785 .01 .01
+7.19 0 0 0.570911 .01 .01
+7.2 0 0 0.570039 .01 .01
+7.21 0 0 0.569169 .01 .01
+7.22 0 0 0.568302 .01 .01
+7.23 0 0 0.567437 .01 .01
+7.24 0 0 0.566575 .01 .01
+7.25 0 0 0.565716 .01 .01
+7.26 0 0 0.564859 .01 .01
+7.27 0 0 0.564004 .01 .01
+7.28 0 0 0.563152 .01 .01
+7.29 0 0 0.562302 .01 .01
+7.3 0 0 0.561455 .01 .01
+7.31 0 0 0.56061 .01 .01
+7.32 0 0 0.559768 .01 .01
+7.33 0 0 0.558928 .01 .01
+7.34 0 0 0.55809 .01 .01
+7.35 0 0 0.557255 .01 .01
+7.36 0 0 0.556422 .01 .01
+7.37 0 0 0.555592 .01 .01
+7.38 0 0 0.554764 .01 .01
+7.39 0 0 0.553938 .01 .01
+7.4 0 0 0.553115 .01 .01
+7.41 0 0 0.552294 .01 .01
+7.42 0 0 0.551475 .01 .01
+7.43 0 0 0.550658 .01 .01
+7.44 0 0 0.549844 .01 .01
+7.45 0 0 0.549033 .01 .01
+7.46 0 0 0.548223 .01 .01
+7.47 0 0 0.547416 .01 .01
+7.48 0 0 0.546611 .01 .01
+7.49 0 0 0.545808 .01 .01
+7.5 0 0 0.545008 .01 .01
+7.51 0 0 0.544209 .01 .01
+7.52 0 0 0.543413 .01 .01
+7.53 0 0 0.54262 .01 .01
+7.54 0 0 0.541828 .01 .01
+7.55 0 0 0.541039 .01 .01
+7.56 0 0 0.540252 .01 .01
+7.57 0 0 0.539467 .01 .01
+7.58 0 0 0.538684 .01 .01
+7.59 0 0 0.537903 .01 .01
+7.6 0 0 0.537125 .01 .01
+7.61 0 0 0.536348 .01 .01
+7.62 0 0 0.535574 .01 .01
+7.63 0 0 0.534802 .01 .01
+7.64 0 0 0.534032 .01 .01
+7.65 0 0 0.533264 .01 .01
+7.66 0 0 0.532498 .01 .01
+7.67 0 0 0.531735 .01 .01
+7.68 0 0 0.530973 .01 .01
+7.69 0 0 0.530214 .01 .01
+7.7 0 0 0.529456 .01 .01
+7.71 0 0 0.528701 .01 .01
+7.72 0 0 0.527948 .01 .01
+7.73 0 0 0.527197 .01 .01
+7.74 0 0 0.526447 .01 .01
+7.75 0 0 0.5257 .01 .01
+7.76 0 0 0.524955 .01 .01
+7.77 0 0 0.524212 .01 .01
+7.78 0 0 0.523471 .01 .01
+7.79 0 0 0.522732 .01 .01
+7.8 0 0 0.521995 .01 .01
+7.81 0 0 0.521259 .01 .01
+7.82 0 0 0.520526 .01 .01
+7.83 0 0 0.519795 .01 .01
+7.84 0 0 0.519066 .01 .01
+7.85 0 0 0.518338 .01 .01
+7.86 0 0 0.517613 .01 .01
+7.87 0 0 0.51689 .01 .01
+7.88 0 0 0.516168 .01 .01
+7.89 0 0 0.515449 .01 .01
+7.9 0 0 0.514731 .01 .01
+7.91 0 0 0.514015 .01 .01
+7.92 0 0 0.513301 .01 .01
+7.93 0 0 0.512589 .01 .01
+7.94 0 0 0.511879 .01 .01
+7.95 0 0 0.511171 .01 .01
+7.96 0 0 0.510465 .01 .01
+7.97 0 0 0.50976 .01 .01
+7.98 0 0 0.509057 .01 .01
+7.99 0 0 0.508357 .01 .01
+8 0 0 0.507658 .01 .01
+8.01 0 0 0.506961 .01 .01
+8.02 0 0 0.506265 .01 .01
+8.03 0 0 0.505572 .01 .01
+8.04 0 0 0.50488 .01 .01
+8.05 0 0 0.50419 .01 .01
+8.06 0 0 0.503502 .01 .01
+8.07 0 0 0.502816 .01 .01
+8.08 0 0 0.502132 .01 .01
+8.09 0 0 0.501449 .01 .01
+8.1 0 0 0.500768 .01 .01
+8.11 0 0 0.500089 .01 .01
+8.12 0 0 0.499411 .01 .01
+8.13 0 0 0.498736 .01 .01
+8.14 0 0 0.498062 .01 .01
+8.15 0 0 0.49739 .01 .01
+8.16 0 0 0.496719 .01 .01
+8.17 0 0 0.49605 .01 .01
+8.18 0 0 0.495383 .01 .01
+8.19 0 0 0.494718 .01 .01
+8.2 0 0 0.494054 .01 .01
+8.21 0 0 0.493392 .01 .01
+8.22 0 0 0.492732 .01 .01
+8.23 0 0 0.492074 .01 .01
+8.24 0 0 0.491417 .01 .01
+8.25 0 0 0.490762 .01 .01
+8.26 0 0 0.490108 .01 .01
+8.27 0 0 0.489456 .01 .01
+8.28 0 0 0.488806 .01 .01
+8.29 0 0 0.488158 .01 .01
+8.3 0 0 0.487511 .01 .01
+8.31 0 0 0.486865 .01 .01
+8.32 0 0 0.486222 .01 .01
+8.33 0 0 0.48558 .01 .01
+8.34 0 0 0.484939 .01 .01
+8.35 0 0 0.4843 .01 .01
+8.36 0 0 0.483663 .01 .01
+8.37 0 0 0.483028 .01 .01
+8.38 0 0 0.482394 .01 .01
+8.39 0 0 0.481761 .01 .01
+8.4 0 0 0.48113 .01 .01
+8.41 0 0 0.480501 .01 .01
+8.42 0 0 0.479873 .01 .01
+8.43 0 0 0.479247 .01 .01
+8.44 0 0 0.478623 .01 .01
+8.45 0 0 0.478 .01 .01
+8.46 0 0 0.477378 .01 .01
+8.47 0 0 0.476758 .01 .01
+8.48 0 0 0.47614 .01 .01
+8.49 0 0 0.475523 .01 .01
+8.5 0 0 0.474908 .01 .01
+8.51 0 0 0.474294 .01 .01
+8.52 0 0 0.473682 .01 .01
+8.53 0 0 0.473071 .01 .01
+8.54 0 0 0.472461 .01 .01
+8.55 0 0 0.471854 .01 .01
+8.56 0 0 0.471247 .01 .01
+8.57 0 0 0.470642 .01 .01
+8.58 0 0 0.470039 .01 .01
+8.59 0 0 0.469437 .01 .01
+8.6 0 0 0.468837 .01 .01
+8.61 0 0 0.468238 .01 .01
+8.62 0 0 0.46764 .01 .01
+8.63 0 0 0.467044 .01 .01
+8.64 0 0 0.46645 .01 .01
+8.65 0 0 0.465857 .01 .01
+8.66 0 0 0.465265 .01 .01
+8.67 0 0 0.464675 .01 .01
+8.68 0 0 0.464086 .01 .01
+8.69 0 0 0.463498 .01 .01
+8.7 0 0 0.462912 .01 .01
+8.71 0 0 0.462328 .01 .01
+8.72 0 0 0.461745 .01 .01
+8.73 0 0 0.461163 .01 .01
+8.74 0 0 0.460582 .01 .01
+8.75 0 0 0.460004 .01 .01
+8.76 0 0 0.459426 .01 .01
+8.77 0 0 0.45885 .01 .01
+8.78 0 0 0.458275 .01 .01
+8.79 0 0 0.457701 .01 .01
+8.8 0 0 0.457129 .01 .01
+8.81 0 0 0.456559 .01 .01
+8.82 0 0 0.455989 .01 .01
+8.83 0 0 0.455421 .01 .01
+8.84 0 0 0.454855 .01 .01
+8.85 0 0 0.454289 .01 .01
+8.86 0 0 0.453725 .01 .01
+8.87 0 0 0.453163 .01 .01
+8.88 0 0 0.452601 .01 .01
+8.89 0 0 0.452041 .01 .01
+8.9 0 0 0.451483 .01 .01
+8.91 0 0 0.450925 .01 .01
+8.92 0 0 0.450369 .01 .01
+8.93 0 0 0.449814 .01 .01
+8.94 0 0 0.449261 .01 .01
+8.95 0 0 0.448709 .01 .01
+8.96 0 0 0.448158 .01 .01
+8.97 0 0 0.447608 .01 .01
+8.98 0 0 0.44706 .01 .01
+8.99 0 0 0.446513 .01 .01
+9 0 0 0.445968 .01 .01
+9.01 0 0 0.445423 .01 .01
+9.02 0 0 0.44488 .01 .01
+9.03 0 0 0.444338 .01 .01
+9.04 0 0 0.443797 .01 .01
+9.05 0 0 0.443258 .01 .01
+9.06 0 0 0.44272 .01 .01
+9.07 0 0 0.442183 .01 .01
+9.08 0 0 0.441647 .01 .01
+9.09 0 0 0.441113 .01 .01
+9.1 0 0 0.44058 .01 .01
+9.11 0 0 0.440048 .01 .01
+9.12 0 0 0.439517 .01 .01
+9.13 0 0 0.438987 .01 .01
+9.14 0 0 0.438459 .01 .01
+9.15 0 0 0.437932 .01 .01
+9.16 0 0 0.437406 .01 .01
+9.17 0 0 0.436882 .01 .01
+9.18 0 0 0.436358 .01 .01
+9.19 0 0 0.435836 .01 .01
+9.2 0 0 0.435315 .01 .01
+9.21 0 0 0.434795 .01 .01
+9.22 0 0 0.434276 .01 .01
+9.23 0 0 0.433759 .01 .01
+9.24 0 0 0.433242 .01 .01
+9.25 0 0 0.432727 .01 .01
+9.26 0 0 0.432213 .01 .01
+9.27 0 0 0.4317 .01 .01
+9.28 0 0 0.431189 .01 .01
+9.29 0 0 0.430678 .01 .01
+9.3 0 0 0.430169 .01 .01
+9.31 0 0 0.42966 .01 .01
+9.32 0 0 0.429153 .01 .01
+9.33 0 0 0.428647 .01 .01
+9.34 0 0 0.428143 .01 .01
+9.35 0 0 0.427639 .01 .01
+9.36 0 0 0.427136 .01 .01
+9.37 0 0 0.426635 .01 .01
+9.38 0 0 0.426135 .01 .01
+9.39 0 0 0.425636 .01 .01
+9.4 0 0 0.425137 .01 .01
+9.41 0 0 0.424641 .01 .01
+9.42 0 0 0.424145 .01 .01
+9.43 0 0 0.42365 .01 .01
+9.44 0 0 0.423156 .01 .01
+9.45 0 0 0.422664 .01 .01
+9.46 0 0 0.422172 .01 .01
+9.47 0 0 0.421682 .01 .01
+9.48 0 0 0.421193 .01 .01
+9.49 0 0 0.420705 .01 .01
+9.5 0 0 0.420217 .01 .01
+9.51 0 0 0.419731 .01 .01
+9.52 0 0 0.419246 .01 .01
+9.53 0 0 0.418763 .01 .01
+9.54 0 0 0.41828 .01 .01
+9.55 0 0 0.417798 .01 .01
+9.56 0 0 0.417317 .01 .01
+9.57 0 0 0.416838 .01 .01
+9.58 0 0 0.416359 .01 .01
+9.59 0 0 0.415881 .01 .01
+9.6 0 0 0.415405 .01 .01
+9.61 0 0 0.414929 .01 .01
+9.62 0 0 0.414455 .01 .01
+9.63 0 0 0.413982 .01 .01
+9.64 0 0 0.413509 .01 .01
+9.65 0 0 0.413038 .01 .01
+9.66 0 0 0.412568 .01 .01
+9.67 0 0 0.412098 .01 .01
+9.68 0 0 0.41163 .01 .01
+9.69 0 0 0.411163 .01 .01
+9.7 0 0 0.410697 .01 .01
+9.71 0 0 0.410231 .01 .01
+9.72 0 0 0.409767 .01 .01
+9.73 0 0 0.409304 .01 .01
+9.74 0 0 0.408842 .01 .01
+9.75 0 0 0.40838 .01 .01
+9.76 0 0 0.40792 .01 .01
+9.77 0 0 0.407461 .01 .01
+9.78 0 0 0.407003 .01 .01
+9.79 0 0 0.406545 .01 .01
+9.8 0 0 0.406089 .01 .01
+9.81 0 0 0.405634 .01 .01
+9.82 0 0 0.405179 .01 .01
+9.83 0 0 0.404726 .01 .01
+9.84 0 0 0.404274 .01 .01
+9.85 0 0 0.403822 .01 .01
+9.86 0 0 0.403372 .01 .01
+9.87 0 0 0.402922 .01 .01
+9.88 0 0 0.402474 .01 .01
+9.89 0 0 0.402026 .01 .01
+9.9 0 0 0.401579 .01 .01
+9.91 0 0 0.401134 .01 .01
+9.92 0 0 0.400689 .01 .01
+9.93 0 0 0.400245 .01 .01
+9.94 0 0 0.399802 .01 .01
+9.95 0 0 0.39936 .01 .01
+9.96 0 0 0.398919 .01 .01
+9.97 0 0 0.398479 .01 .01
+9.98 0 0 0.39804 .01 .01
+9.99 0 0 0.397601 .01 .01
+10 0 0 0.397164 .01 .01
diff --git a/statistics/chisq.hpp b/statistics/chisq.hpp
new file mode 100644
index 0000000..15b3d33
--- /dev/null
+++ b/statistics/chisq.hpp
@@ -0,0 +1,163 @@
+#ifndef CHI_SQ_HPP
+#define CHI_SQ_HPP
+#include <core/fitter.hpp>
+#include <iostream>
+#include <vector>
+#include <cmath>
+using std::cerr;using std::endl;
+
+namespace opt_utilities
+{
+  template<typename Ty,typename Tx,typename Tp,typename Ts,typename Tstr>
+  class chisq
+    :public statistic<Ty,Tx,Tp,Ts,Tstr>
+  {
+  private:
+    bool verb;
+    int n;
+    
+    
+    statistic<Ty,Tx,Tp,Ts,Tstr>* do_clone()const
+    {
+      // return const_cast<statistic<Ty,Tx,Tp>*>(this);
+      return new chisq<Ty,Tx,Tp,Ts,Tstr>(*this);
+    }
+  public:
+    void verbose(bool v)
+    {
+      verb=v;
+    }
+  public:
+    chisq()
+      :verb(false)
+    {}
+    
+    
+
+    Ts do_eval(const Tp& p)
+    {
+      Ts result(0);
+      for(int i=(this->datas()).size()-1;i>=0;--i)
+	{
+	  Ty chi=(this->datas().get_data(i).get_y()-eval_model(this->datas().get_data(i).get_x(),p))/this->datas().get_data(i).get_y_upper_err();
+	  result+=chi*chi;
+
+	}
+      if(verb)
+	{
+	  n++;
+	  if(n%10==0)
+	    {
+
+	      cerr<<result<<"\t";
+	      for(size_t i=0;i<get_size(p);++i)
+		{
+		  cerr<<get_element(p,i)<<",";
+		}
+	      cerr<<endl;
+	    }
+
+	}
+      
+      return result;
+    }
+  };
+
+#if 1
+
+  template<>
+  class chisq<double,double,std::vector<double>,double,std::string>
+    :public statistic<double,double,std::vector<double> ,double,std::string>
+  {
+  public:
+    typedef double Ty;
+    typedef double Tx;
+    typedef std::vector<double> Tp;
+    typedef double Ts;
+    typedef std::string Tstr;
+  private:
+    bool verb;
+    int n;
+    
+    statistic<Ty,Tx,Tp,Ts,Tstr>* do_clone()const
+    {
+      // return const_cast<statistic<Ty,Tx,Tp>*>(this);
+      return new chisq<Ty,Tx,Tp,Ts,Tstr>(*this);
+    }
+
+
+  public:
+    void verbose(bool v)
+    {
+      verb=v;
+    }
+  public:
+    chisq()
+      :verb(false)
+    {}
+    
+    
+
+    Ty do_eval(const Tp& p)
+    {
+      Ty result(0);
+      for(int i=(this->datas()).size()-1;i>=0;--i)
+	{
+
+#ifdef HAVE_X_ERROR
+	  Tx x1=this->datas().get_data(i).get_x()-this->datas().get_data(i).get_x_lower_err();
+	  Tx x2=this->datas().get_data(i).get_x()+this->datas().get_data(i).get_x_upper_err();
+	  Ty errx=(eval_model(x1,p)-eval_model(x2,p))/2;
+	  //Ty errx=0;
+#else
+	  Ty errx=0;
+#endif
+
+	  Ty y_model=eval_model(this->datas().get_data(i).get_x(),p);
+	  Ty y_obs=this->datas().get_data(i).get_y();
+	  Ty y_err;
+
+	  if(y_model>y_obs)
+	    {
+	      y_err=this->datas().get_data(i).get_y_upper_err();
+	    }
+	  else
+	    {
+	      y_err=this->datas().get_data(i).get_y_lower_err();
+	    }
+
+	  Ty chi=(y_obs-y_model)/std::sqrt(y_err*y_err+errx*errx);
+
+	  //	  Ty chi=(this->datas().get_data(i).get_y()-eval_model(this->datas().get_data(i).get_x(),p));
+	  //	  cerr<<chi<<"\n";
+	  result+=chi*chi;
+	  //std::cerr<<chi<<std::endl;
+	  //cerr<<eval_model(this->datas()[i].x,p)<<endl;
+	  //cerr<<this->datas()[i].y_upper_err<<endl;
+	  //	  cerr<<this->datas()[i].x<<"\t"<<this->datas()[i].y<<"\t"<<eval_model(this->datas()[i].x,p)<<endl;
+	}
+      if(verb)
+	{
+	  n++;
+	  if(n%10==0)
+	    {
+	      cerr<<result<<"\t";
+	      for(int i=0;i<(int)get_size(p);++i)
+		{
+		  cerr<<get_element(p,i)<<",";
+		}
+	      cerr<<endl;
+	    }
+
+	}
+      
+      return result;
+    }
+  };
+#endif  
+}
+
+#endif
+//EOF
+
+
diff --git a/statistics/cstat.hpp b/statistics/cstat.hpp
new file mode 100644
index 0000000..b6b401d
--- /dev/null
+++ b/statistics/cstat.hpp
@@ -0,0 +1,66 @@
+#ifndef CSTAT_HPP
+#define CSTAT_HPP
+#include <core/fitter.hpp>
+#include <iostream>
+
+using std::cout;using std::endl;
+namespace opt_utilities
+{
+  template<typename Ty,typename Tx,typename Tp,typename Ts,typename Tstr>
+  class cstat_poisson
+    :public statistic<Ty,Tx,Tp,Ts,Tstr>
+  {
+  private:
+    bool verb;
+    int n;
+
+    Ty lnfrac(Ty y)const
+    {
+      return y*log(y)-y;
+    }
+    
+  public:
+    void verbose(bool v)
+    {
+      verb=v;
+    }
+  public:
+
+    statistic<Ty,Tx,Tp,Ts,Tstr>* do_clone()const
+    {
+      // return const_cast<statistic<Ty,Tx,Tp>*>(this);
+      return new cstat_poisson<Ty,Tx,Tp,Ts,Tstr>(*this);
+    }
+
+    Ts do_eval(const Tp& p)
+    {
+      Ts result(0);
+      for(int i=(this->datas()).size()-1;i>=0;--i)
+	{
+	  Ty model_y=eval_model(this->datas().get_data(i).get_x(),p);
+	  result+=model_y-this->datas().get_data(i).get_y()*log(model_y)+lnfrac(this->datas().get_data(i).get_y());
+	}
+
+      if(verb)
+	{
+	  n++;
+	  if(n%10==0)
+	    {
+	      cout<<result/this->p_fitter->get_dof()<<"\t";
+	      for(int i=0;i<get_size(p);++i)
+		{
+		  cout<<get_element(p,i)<<",";
+		}
+	      cout<<endl;
+	    }
+	  
+	}
+      return result;
+    }
+  };
+}
+
+#endif
+//EOF
+
+
diff --git a/test.cc b/test.cc
new file mode 100644
index 0000000..a69186c
--- /dev/null
+++ b/test.cc
@@ -0,0 +1,142 @@
+#include <blitz/array.h>
+
+using namespace blitz;
+
+#include <core/opt_traits.hpp>
+
+namespace opt_utilities
+{
+  template <typename TX>
+  void set_element(blitz::Array<double,1>& x,size_t i,TX v)
+  {
+    x(i)=v;
+  }
+
+  
+  inline const double& get_element(const blitz::Array<double,1>& x,size_t i)
+  {
+    return x(i);
+  }
+  
+  inline size_t get_size(const Array<double,1>& x)
+  {
+    return x.extent(0);
+  }
+
+  inline void resize(Array<double,1>& x,size_t s)
+  {
+    x.resize(s);
+  }
+
+  inline Array<double,1>& opt_eq(Array<double,1>& lhs, const Array<double,1>& rhs)
+  {
+    lhs.resize(rhs.extent(0));
+    lhs=rhs.copy();
+    return lhs;
+  }
+
+  template <>
+  class value_type_trait<Array<double,1> >
+  {
+  public:
+    typedef double value_type;
+  };
+
+  template <>
+  class value_type_trait<const Array<double,1> >
+  {
+  public:
+    typedef double value_type;
+  };
+}
+
+#include <statistics/chisq.hpp>
+#include <core/optimizer.hpp>
+#include <core/default_data_set.hpp>
+#include <methods/powell/powell_method.hpp>
+#include <methods/gsl_simplex/gsl_simplex.hpp>
+#include <core/fitter.hpp>
+using namespace std;
+#include <fstream>
+#include <vector>
+#include <blitz/array.h>
+//#include "gmpxx.h"
+using namespace std;
+//using namespace opt_utilities;
+using namespace blitz;
+
+class foo
+  :public opt_utilities::func_obj<double,blitz::Array<double,1> >
+{
+  typedef blitz::Array<double,1> pT;
+  double do_eval(const pT& x)
+  {
+    return x(0)*x(0)+x(1)*x(1);
+  }
+  
+  foo* do_clone()const
+  {
+    return new foo(*this);
+  }
+};
+
+class lin1d
+  :public opt_utilities::model<double,double,blitz::Array<double,1> >
+{
+private:
+  opt_utilities::model<double,double,Array<double,1> >* do_clone()const
+  {
+    return new lin1d(*this);
+  }
+public:
+  lin1d()
+  {
+    this->push_param_info(opt_utilities::param_info<Array<double,1> >("k",1));
+    this->push_param_info(opt_utilities::param_info<Array<double,1> >("b",0));
+  }
+  
+public:
+  double do_eval(const double& x,const Array<double,1>& param)
+  {
+    return x*opt_utilities::get_element(param,(size_t)0)+opt_utilities::get_element(param,(size_t)1);
+  }
+  
+private:
+  std::string do_to_string()const
+  {
+    return "linear model\n"
+      "y=k*x+b\n";
+  }
+};
+
+
+
+int main()
+{
+  opt_utilities::fitter<double,double,Array<double,1>,double> f;
+  //opt_utilities::optimizer<double,Array<double,1> > opt;
+  opt_utilities::powell_method<double,Array<double,1> > pm;
+  f.set_method(pm);
+  
+  Array<double,1> a(2);
+  a=2,4;
+
+  opt_utilities::default_data_set<double,double> ds;
+
+  for(double x=0;x<10;x+=.1)
+    {
+      opt_utilities::data<double,double> d;
+      d.set_x(x);
+      d.set_x_lower_err(0);
+      d.set_x_upper_err(0);
+      d.set_y(x*3+4);
+      d.set_y_lower_err(.1);
+      d.set_y_upper_err(.1);
+      ds.push_back(d);
+    }
+  f.load_data(ds);
+  f.set_model(lin1d());
+  f.set_statistic(opt_utilities::chisq<double,double,blitz::Array<double,1>,double>());
+  cout<<f.fit();
+}
+
diff --git a/test1.cc b/test1.cc
new file mode 100644
index 0000000..0e456fd
--- /dev/null
+++ b/test1.cc
@@ -0,0 +1,149 @@
+#include "optimizer.hpp"
+#include "powell_method.hpp"
+#include "add_model.hpp"
+#include "lin1d.hpp"
+#include "poly1d.hpp"
+#include "data_loaders.hpp"
+#include "chisq.hpp"
+#include "freeze_param.hpp"
+#include "add_model.hpp"
+#include "mul_model.hpp"
+#include "pow_model.hpp"
+#include "gsl_simplex.hpp"
+#include "pl1d.hpp"
+using namespace std;
+#include "dl_model.hpp"
+#include <fstream>
+#include <vector>
+//#include "gmpxx.h"
+#include "strmodel1d.hpp"
+using namespace std;
+using namespace opt_utilities;
+
+class foo
+  :public func_obj<double,vector<double> >
+{
+public:
+  double do_eval(const vector<double>& p)
+  {
+    //   cout<<"p0="<<p[0]<<endl;
+    return p[0]*p[0]+p[1]*p[1];
+  }
+
+  foo* do_clone()const
+  {
+    return new foo(*this);
+  }
+};
+
+
+double my_f (const gsl_vector *v, void *params)
+{
+  double x, y;
+  double *p = (double *)params;
+  //  cout<<p[1]<<endl;
+  x = gsl_vector_get(v, 0);
+  y = gsl_vector_get(v, 1);
+  
+  return x*x+y*y;
+}
+
+
+
+
+
+int main()
+{
+  
+  optimizer<double,vector<double> > op;
+  powell_method<double,vector<double> > pw;
+  gsl_simplex<double,vector<double> > gs;
+
+  op.set_func_obj(foo());
+  op.set_opt_method(gs);
+  vector<double> p1(2);
+  p1[0]=1;
+  p1[1]=1;
+  op.set_start_point(p1);
+  
+  vector<double> p=op.optimize();
+  cout<<p[0]<<"\t"<<p[1]<<endl;
+  
+  return 0;
+
+
+  
+  const gsl_multimin_fminimizer_type *T = 
+    gsl_multimin_fminimizer_nmsimplex;
+  gsl_multimin_fminimizer *s = NULL;
+  gsl_vector *ss, *x;
+  gsl_multimin_function minex_func;
+  
+  size_t iter = 0;
+  int status;
+  double size;
+     
+  /* Starting point */
+  x = gsl_vector_alloc (2);
+  gsl_vector_set (x, 0, 5.0);
+  gsl_vector_set (x, 1, 7.0);
+     
+  /* Set initial step sizes to 1 */
+  ss = gsl_vector_alloc (2);
+  gsl_vector_set_all (ss, 1.0);
+  foo f;
+  /* Initialize method and iterate */
+  minex_func.n = 2;
+  minex_func.f = &gsl_func_adapter<double,vector<double> >;
+  minex_func.params = (void *)&f;
+     
+  s = gsl_multimin_fminimizer_alloc (T, 2);
+  gsl_multimin_fminimizer_set (s, &minex_func, x, ss);
+  
+  do
+    {
+      iter++;
+      status = gsl_multimin_fminimizer_iterate(s);
+           
+      if (status) 
+	break;
+     
+      size = gsl_multimin_fminimizer_size (s);
+      status = gsl_multimin_test_size (size, 1e-2);
+     
+      if (status == GSL_SUCCESS)
+	{
+	  printf ("converged to minimum at\n");
+	}
+     
+      printf ("%5d %10.3e %10.3ef f() = %7.3f size = %.3f\n", 
+	      iter,
+	      gsl_vector_get (s->x, 0), 
+	      gsl_vector_get (s->x, 1), 
+	      s->fval, size);
+    }
+  while (status == GSL_CONTINUE && iter < 100);
+  
+  /*
+  foo f;
+  gsl_vector_set (x, 0, 0.0);
+  gsl_vector_set (x, 1, 0.0);
+  cout<<"fdsa ";
+  cout<<gsl_func_adapter<double,vector<double> >(x,(void*)&f)<<endl;;
+
+  */
+
+  gsl_vector_free(x);
+  gsl_vector_free(ss);
+  gsl_multimin_fminimizer_free (s);
+     
+  
+
+
+
+  return status;
+
+
+  
+}
+
diff --git a/utilities/opt_types.hpp b/utilities/opt_types.hpp
new file mode 100644
index 0000000..ebe56c7
--- /dev/null
+++ b/utilities/opt_types.hpp
@@ -0,0 +1,29 @@
+#ifndef OPT_TYPES_HPP
+#define OPT_TYPES_HPP
+#include <core/fitter.hpp>
+#include <core/default_data_set.hpp>
+#include <methods/powell/powell_method.hpp>
+#include <statistics/chisq.hpp>
+#include <vector>
+
+namespace opt_utilities
+{
+  template <typename Ty,typename Tx,typename Tp,typename Ts,typename Tstr>
+  class opt_types
+  {
+  public:
+    typedef fitter<Ty,Tx,Tp,Ts,Tstr> fitter;
+    typedef chisq<Ty,Tx,Tp,Ts,Tstr> chisq;
+    typedef powell_method<Ty,Tp> powell_method;
+    typedef model<Ty,Tx,Tp,Tstr> model;
+    typedef default_data_set<Ty,Ty> data_set;
+  };
+
+  typedef opt_types<double,double,std::vector<double>,double,std::string> dopt;
+}
+
+
+
+
+#endif
+//EOF
diff --git a/version_ctrl.cc b/version_ctrl.cc
new file mode 100644
index 0000000..97781ad
--- /dev/null
+++ b/version_ctrl.cc
@@ -0,0 +1,18 @@
+#include <iostream>
+using namespace std;
+class cprt
+{
+public:
+	cprt()
+	{
+	  cerr<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
+	  cerr<<"% Flexible model fitting package      %"<<endl;
+	  cerr<<"% version 2.18                        %"<<endl;
+	  cerr<<"% by Gu Junhua 2007.                  %"<<endl;
+	  cerr<<"% tompkins@sjtu.edu.cn                %"<<endl;
+	  cerr<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;;
+	    
+	}
+
+	~cprt(){}
+}_licence;
author	astrojhgu <astrojhgu@ed2142bd-67ad-457f-ba7c-d818d4011675>	2008-12-15 07:26:12 +0000
committer	astrojhgu <astrojhgu@ed2142bd-67ad-457f-ba7c-d818d4011675>	2008-12-15 07:26:12 +0000
commit	1f4a944064bc42284c33e6b755353d191cf288e8 (patch)
tree	c8cb2253dea5f395e0f867aa6976433bd3eb00de
download	opt-utilities-1f4a944064bc42284c33e6b755353d191cf288e8.tar.bz2