Parameters.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/MEAL/MEAL/Parameters.h
 
#ifndef __Parameters_H
#define __Parameters_H
 
#include "MEAL/ParameterPolicy.h"
#include "Estimate.h"
#include "Error.h"
 
#include <vector>
 
namespace MEAL {
  
  class Parameters : public ParameterPolicy {
 
  public:

    Parameters (Function* context, unsigned nparam = 0);

    Parameters (const Parameters& np);

    Parameters& operator = (const Parameters& np);

    Parameters* clone (Function*) const;
 
    // ///////////////////////////////////////////////////////////////////
    //
    // Function implementation
    //
    // ///////////////////////////////////////////////////////////////////
 
    unsigned get_nparam () const
    {
      return params.size();
    }

    std::string get_name (unsigned index) const
    {
      range_check (index, "MEAL::Parameters::get_name");
      return names[index];
    }

    void set_name (unsigned index, const std::string& name)
    {
      range_check (index, "MEAL::Parameters::set_name");
      names[index] = name;
    }

    std::string get_description (unsigned index) const
    {
      range_check (index, "MEAL::Parameters::get_description");
      return descriptions[index];
    }

    void set_description (unsigned index, const std::string& description)
    {
      range_check (index, "MEAL::Parameters::set_description");
      descriptions[index] = description;
    }

    double get_param (unsigned index) const
    {
      range_check (index, "MEAL::Parameters::get_param");
      return params[index].val;
    }

    void set_param (unsigned index, double value);

    void swap_param (unsigned index, double& value);

    double get_variance (unsigned index) const
    {
      range_check (index, "MEAL::Parameters::get_variance");
      return params[index].var;
    }

    void set_variance (unsigned index, double value)
    {
      range_check (index, "MEAL::Parameters::set_variance");
      params[index].var = value;
    }

    bool get_infit (unsigned index) const
    {
      range_check (index, "MEAL::Parameters::get_infit");
      return fit[index];
    }

    void set_infit (unsigned index, bool flag)
    {
      range_check (index, "MEAL::Parameters::set_infit");
      fit[index] = flag;
    }

    void resize (unsigned nparam);

    void erase (unsigned iparam);
 
  protected:

    void range_check (unsigned index, const char* method) const
    {
      if (index >= params.size())
        throw Error (InvalidRange, method, "index=%d >= nparam=%d", 
                     index, params.size());
    }
 
  private:

    std::vector< Estimate<double> > params;

    std::vector<bool> fit;

    std::vector<std::string> names;

    std::vector<std::string> descriptions;
 
  };
 
}
 
#endif