JGauss.hh

Go to the documentation of this file.

#ifndef __JMATH__JGAUSS__
#define __JMATH__JGAUSS__

#include <limits>
#include <cmath>
#include <istream>
#include <ostream>
#include <iomanip>

#include "JLang/JEquals.hh"
#include "Jeep/JPrint.hh"
#include "JMath/JMath.hh"

/**
 * \author mdejong
 */

namespace JMATH {}
namespace JPP { using namespace JMATH; }

namespace JMATH {

  using JLANG::JEquals;

  /**
   * Data structure for Gaussian function on top of a flat background.
   *
   * This class implements the JMATH::JMath interface.
   */
  class JGauss :
    public JMATH::JMath<JGauss>
  {
  public:

    /**
     * Type definition of fit parameter.
     */
    typedef double JGauss::*parameter_type;


    /**
     * Default constructor.
     */
    JGauss() :
      mean      (0.0),
      sigma     (0.0),
      signal    (0.0),
      background(0.0)
    {}


    /**
     * Constructor.
     *
     * \param  mean          mean
     * \param  sigma         sigma
     * \param  signal        signal
     * \param  background    background
     */
    JGauss(const double mean,
           const double sigma,
           const double signal,
           const double background) :
      mean      (mean),
      sigma     (sigma),
      signal    (signal),
      background(background)
    {}


    /**
     * Add gauss.
     *
     * \param  gauss         gauss
     * \return               this gauss
     */
    JGauss& add(const JGauss& gauss)
    {
      mean       += gauss.mean;
      sigma      += gauss.sigma;
      signal     += gauss.signal;
      background += gauss.background;

      return *this;
    }


    /**
     * Subtract gauss.
     *
     * \param  gauss         gauss
     * \return               this gauss
     */
    JGauss& sub(const JGauss& gauss)
    {
      mean       -= gauss.mean;
      sigma      -= gauss.sigma;
      signal     -= gauss.signal;
      background -= gauss.background;

      return *this;
    }


    /**
     * Scale gauss.
     *
     * \param  factor        multiplication factor
     * \return               this gauss
     */
    JGauss& mul(const double factor)
    {
      mean       *= factor;
      sigma      *= factor;
      signal     *= factor;
      background *= factor;

      return *this;
    }


    /**
     * Equality.
     *
     * \param  gauss    gauss
     * \param  eps      numerical precision
     * \return          true if gauss's identical; else false
     */
    bool equals(const JGauss& gauss,
                const double  eps = std::numeric_limits<double>::min()) const
    {
      return (fabs(mean       - gauss.mean)       <=  eps  &&
              fabs(sigma      - gauss.sigma)      <=  eps  &&
              fabs(signal     - gauss.signal)     <=  eps  &&
              fabs(background - gauss.background) <=  eps);
    }


    /**
     * Write Gauss to input stream.
     *
     * \param  in            input stream
     * \param  gauss         gauss
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JGauss& gauss) 
    {
      return in >> gauss.mean >> gauss.sigma >> gauss.signal >> gauss.background;
    }


    /**
     * Write Gauss to output stream.
     *
     * \param  out           output stream
     * \param  gauss         gauss
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JGauss& gauss) 
    {
      using namespace std;

      return out << FIXED(7,3) << gauss.mean   << ' '
                 << FIXED(7,3) << gauss.sigma  << ' '
                 << FIXED(9,3) << gauss.signal << ' '
                 << FIXED(9,3) << gauss.background;
    }

    double mean;
    double sigma;
    double signal;
    double background;
  };
}

#endif