funcstate.h

Go to the documentation of this file.

#ifndef FUNCSTATE_H
#define FUNCSTATE_H

#include <cassert>
#include <deque>
using namespace std;

#include <typedefs.h>

template< typename X >
class funcstate
{
public:

  uint counter;

  uint dim;
  
  X* xi;

  funcstate()
    : counter(0), dim(0), xi(0), mem(false) {}

  funcstate(uintc dim_, boolc mem_=true);

  virtual X const operator()() = 0;
 
  virtual ~funcstate();

  bool mem;

  void set_position(X* xi_);
  void set_positionvalue(X* xi_);
  X const fnvalue()
    { return xi[dim]; }
};


template< typename X >
class funchistory
{
public:

  deque< X* > xik;

  funcstate<X> & fs;

  funchistory(funcstate<X> & fs_)
    : fs(fs_) {}
  ~funchistory();

  X* operator [] (uintc i)
    { assert(i<xik.size()); return xik[i]; }

  void push();

  void pop();

  void restore();

  void del_back();

};


// template wrappers to create inherited classes of funcstate.

//---------------------------------------------------------
//  Implementation

template< typename X >
funcstate<X>::funcstate(uintc dim_, boolc mem_)
  : counter(0), dim(dim_), mem(mem_)
{
  if (mem==true)
  {
    assert(dim!=0);
    xi = new X[dim+1];
  }
}

template< typename X >
void funcstate<X>::set_position(X* xi_)
{
  for (uint i=0; i<dim; ++i)
    xi[i] = xi_[i];
}

template< typename X >
void funcstate<X>::set_positionvalue(X* xi_)
{
  for (uint i=0; i<=dim; ++i)
    xi[i] = xi_[i];
}

template< typename X >
funcstate<X>::~funcstate()
{
  if (mem)
    delete[] xi;
  xi=0;  
}

template< typename X >
void funchistory<X>::push()
{
  X* x= new X[fs.dim+1];
  for (uint i=0; i<=fs.dim; ++i)
    x[i] = fs.xi[i];

  xik.push_front(x);
}
  
template< typename X >
void funchistory<X>::pop()
{
  assert( xik.empty()==false);
  if (xik.empty())
    return;

  X * z = xik[0];
  fs.set_positionvalue( z );
  delete[] z;
  xik.pop_front();
}

template< typename X >
void funchistory<X>::restore()
{
  assert( xik.empty()==false);
  if (xik.empty())
    return;

  X * z = xik[0];
  fs.set_positionvalue( z );
}

template< typename X >
void funchistory<X>::del_back()
{
  if (xik.empty())
    return;

  X * z = xik.back();
  xik.pop_back();
  delete[] z; 
}

template< typename X >
funchistory<X>::~funchistory()
{
  for (uint i=0; i<xik.size(); ++i)
    delete[] xik[i];
  xik.clear();
}

#endif