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);
 
    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; }
 
    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