Cached.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2005 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/MEAL/MEAL/Cached.h
 
#ifndef __Cached_H
#define __Cached_H
 
#include "MEAL/CalculatePolicy.h"
#include <iostream>
 
namespace MEAL {
  

 
  template<class T>
  class Cached : public CalculatePolicy<T>
  {
  public:
 
    typedef typename T::Result Result;

    Cached (T* context) : CalculatePolicy<T> (context)
    { gradient_is_cached = false; }

    Result evaluate (std::vector<Result>* gradient = 0) const try
    {
      if (this->get_context()->get_verbose())
        std::cerr << class_name() + "evaluate" << std::endl;
 
      update (gradient != 0);
  
      if (gradient)
      {
        gradient->resize (cached_gradient.size());
        for (unsigned i=0; i<cached_gradient.size(); i++)
          (*gradient)[i] = cached_gradient[i];
      }
 
      return cached_result;
    }
    catch (Error& error)
      {
        throw error += class_name() + "evaluate";
      }

    std::string class_name() const
    { return "MEAL::Cached[" + this->get_context()->get_name() + "]::"; }
 
  protected:

    void update (bool need_gradient) const
    {
      const_cast<Cached*>(this)->update (need_gradient);
    }
 
    void update (bool need_gradient)
    {
      if (! (this->get_context()->get_evaluation_changed()
             || (need_gradient && !gradient_is_cached)))
      {
        if (this->get_context()->get_verbose()) 
          std::cerr << class_name() + "update no change" << std::endl;
        return;
      }
 
      std::vector<Result>* grad_ptr = 0;
 
      if (need_gradient)
      {
        cached_gradient.resize (this->get_context()->get_nparam());
        grad_ptr = &cached_gradient;
        gradient_is_cached = true;
      }
 
      this->calculate (cached_result, grad_ptr);
 
      this->get_context()->set_evaluation_changed (false);
    }

    Result cached_result;

    std::vector<Result> cached_gradient;
 
  private:

    bool gradient_is_cached;
 
  };
 
}
 
#endif