Function.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004-2009 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/MEAL/MEAL/Function.h

 
#ifndef __MEAL_Function_H
#define __MEAL_Function_H
 
#include "MEAL/Argument.h"
#include "MEAL/ArgumentPolicy.h"
#include "MEAL/ParameterPolicy.h"
#include "Callback.h"
#include "Estimate.h"
 
#include <string>
 
// forward declaration of text interface
namespace TextInterface { class Parser; };


namespace MEAL {


  class Function : public Reference::Able {
 
  public:

    static bool verbose;

    static bool very_verbose;

    static bool check_zero;

    static bool check_variance;

    static bool cache_results;

    template<class Model>
    static Model* load (const std::string& filename);

    static Function* load_Function (const std::string& filename);

    static Function* factory (const std::string& text);

    Function ();

    Function (const Function& model);

    Function& operator = (const Function& model);

    virtual ~Function ();

    virtual Function* clone () const;

    virtual void copy (const Function* model);

    template<class T> class Interface;

    virtual TextInterface::Parser* get_interface ();

    virtual void parse (const std::string& text);

    virtual void print (std::string& text) const;

    virtual std::string get_name () const = 0;

    virtual std::string get_description () const { return ""; }

    unsigned get_nparam () const
    { if (parameter_policy) return parameter_policy->get_nparam (); return 0; }

    std::string get_param_name (unsigned index) const
    { return parameter_policy->get_name (index); }

    std::string get_param_description (unsigned index) const
    { return parameter_policy->get_description (index); }

    double get_param (unsigned index) const
    { return parameter_policy->get_param (index); }

    void set_param (unsigned index, double value)
    { parameter_policy->set_param (index,value); }

    double get_variance (unsigned index) const
    { return parameter_policy->get_variance (index); }

    void set_variance (unsigned index, double value)
    { parameter_policy->set_variance (index,value); }

    bool get_infit (unsigned index) const
    { return parameter_policy->get_infit (index); }
    
    void set_infit (unsigned index, bool flag)
    { parameter_policy->set_infit (index,flag); }
    
    void set_argument (unsigned dimension, Argument* axis)
    { if (argument_policy) argument_policy->set_argument (dimension, axis); }

    Estimate<double> get_Estimate (unsigned index) const;

    void set_Estimate (unsigned index, const Estimate<double>& param);

    void set_verbose (bool);

    bool get_verbose () const;

    enum Attribute {
      ParameterCount,
      Evaluation
    };

    Callback<Attribute> changed;

    void set_evaluation_changed (bool _changed = true);

    bool get_evaluation_changed () const { return evaluation_changed; }

    const ParameterPolicy* get_parameter_policy () const
    { return parameter_policy; }

    ParameterPolicy* get_parameter_policy ()
    { return parameter_policy; }

    bool has_parameter_policy () const { return parameter_policy; }

    virtual void print_parameters (std::string& text,
                                   const std::string& separator) const;
 
   protected:
 
    friend class ParameterPolicy;

    Reference::To< ParameterPolicy > parameter_policy;
 
    friend class ArgumentPolicy;

    Reference::To< ArgumentPolicy > argument_policy;

    void copy_evaluation_changed (const Function& model) 
    { set_evaluation_changed (model.get_evaluation_changed()); }

    void copy_parameter_policy (const Function*);

    void set_parameter_policy (ParameterPolicy* policy);

    bool set_parameter_policy_context;

    bool this_verbose;
 
  private:

    bool evaluation_changed;

    void init ();
 
  };
 
}
 
template<class Model>
Model* MEAL::Function::load (const std::string& filename)
{
  Function* function = load_Function (filename);
 
  Model* model = dynamic_cast<Model*> (function);
  if (!model)
    throw Error (InvalidState, "MEAL::Function::load",
                 "function is not a %s", Model::Name);
 
  return model;
}
 
#endif