Univariate.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/MEAL/MEAL/Univariate.h
 
#ifndef __MEAL_Univariate_H
#define __MEAL_Univariate_H
 
#include "MEAL/UnivariatePolicy.h"
#include "MEAL/Nvariate.h"
#include "Reference.h"
 
namespace MEAL {

  template<class T>
  class Univariate : public Nvariate<T>
  {
 
  public:

    Univariate ()
    { set_univariate_policy ( new UnivariatePolicy (this) ); }

    Univariate (const Univariate& copy) : T (copy) { }

    Univariate& operator = (const Univariate& copy);

    Univariate<T>* clone () const
    { throw Error (InvalidState, "Univariate<T>::clone", "not implemented"); }

    virtual void set_abscissa (double value)
    { univariate_policy->set_abscissa(value); }

    double get_abscissa () const
    { return univariate_policy->get_abscissa (); }

    typename T::Result compute (double x)
    { set_abscissa (x); return this->evaluate (); }


    unsigned get_ndim () const { return 1; }

    void set_abscissa_value (unsigned idim, double value)
    { set_abscissa (value); }

    double get_abscissa_value (unsigned idim) const
    { return get_abscissa (); }

 
  protected:
 
    template <class U>
    friend class FunctionPolicyTraits;
    
    void set_univariate_policy (UnivariatePolicy* policy)
    { this->argument_policy = univariate_policy = policy; }
 
    UnivariatePolicy* get_univariate_policy () const
    { return univariate_policy; }

    void copy_univariate_policy (const Univariate* other)
    { set_univariate_policy (other->get_univariate_policy()); }
 
  private:

    Reference::To<UnivariatePolicy> univariate_policy;
 
  };
 
  template<class T>
  class FunctionPolicyTraits< Univariate<T> >
  {
  public:
    static void composite_component (Univariate<T>* composite,
                                     Univariate<T>* component)
    {
      component->copy_univariate_policy (composite);
    }
  };
}
 
template<class T>
MEAL::Univariate<T>& MEAL::Univariate<T>::operator = (const Univariate& copy)
{ 
  if (&copy == this)
    return *this;
 
  set_abscissa( copy.get_abscissa() ); 
  T::operator=( copy );
  return *this;
}
 
#endif