// @(#)root/minuit2:$Id: MnUserParameters.h 21185 2007-12-04 14:56:12Z moneta $
// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005  

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
 *                                                                    *
 **********************************************************************/

#ifndef ROOT_Minuit2_MnUserParameters
#define ROOT_Minuit2_MnUserParameters

#include "Minuit2/MnUserTransformation.h"


#include <vector>

namespace ROOT {

   namespace Minuit2 {


class MnMachinePrecision;

/** API class for the user interaction with the parameters;
    serves as input to the minimizer as well as output from it;
    users can interact: Fix/release parameters, set values and errors, etc.;
    parameters can be accessed via their Parameter number (determined 
    internally by Minuit and followed the order how the parameters are created) 
    or via their user-specified Name (10 character string). 
    Minuit has also an internal parameter number which is used during the minimization
    (the fix parameter are skipped). The parameter number used in this class is the external 
    one. The class ROOT::Minuit2::MnUserTransformation is used to keep the 
    internal <-> external transformation
 */

class MnUserParameters {

public:

  MnUserParameters() : fTransformation(MnUserTransformation()) {}

  MnUserParameters(const std::vector<double>&, const std::vector<double>&);

  ~MnUserParameters() {}

  MnUserParameters(const MnUserParameters& par) : 
    fTransformation(par.fTransformation) {}

  MnUserParameters& operator=(const MnUserParameters& par) {
    fTransformation = par.fTransformation;
    return *this;
  }

  const MnUserTransformation& Trafo() const {return fTransformation;}

  unsigned int VariableParameters() const {
    return fTransformation.VariableParameters();
  }

  /// access to parameters (row-wise)
   const std::vector<ROOT::Minuit2::MinuitParameter>& Parameters() const;

  /// access to parameters and errors in column-wise representation 
  std::vector<double> Params() const;
  std::vector<double> Errors() const;

  /// access to single Parameter
  const MinuitParameter& Parameter(unsigned int) const;

  /// Add free Parameter Name, Value, Error
  bool Add(const char*, double, double);
  /// Add limited Parameter Name, Value, Lower bound, Upper bound
  bool Add(const char*, double, double, double, double);
  /// Add const Parameter Name, vale
  bool Add(const char*, double);

  /// interaction via external number of Parameter
  void Fix(unsigned int);
  void Release(unsigned int);
  void SetValue(unsigned int, double);
  void SetError(unsigned int, double);
  void SetLimits(unsigned int, double, double);
  void SetUpperLimit(unsigned int, double);
  void SetLowerLimit(unsigned int, double);
  void RemoveLimits(unsigned int);

  double Value(unsigned int) const;
  double Error(unsigned int) const;
  
  /// interaction via Name of Parameter
  void Fix(const char*);
  void Release(const char*);
  void SetValue(const char*, double);
  void SetError(const char*, double);
  void SetLimits(const char*, double, double);
  void SetUpperLimit(const char*, double);
  void SetLowerLimit(const char*, double);
  void RemoveLimits(const char*);

  double Value(const char*) const;
  double Error(const char*) const;
  
  //convert Name into external number of Parameter
  unsigned int Index(const char*) const;
  //convert external number into Name of Parameter
  const char* Name(unsigned int) const;

  const MnMachinePrecision& Precision() const;
  void SetPrecision(double eps) {fTransformation.SetPrecision(eps);}

private:

  MnUserTransformation fTransformation;
};

  }  // namespace Minuit2

}  // namespace ROOT

#endif  // ROOT_Minuit2_MnUserParameters