BCPrior.h

#ifndef __BCPRIOR__H
#define __BCPRIOR__H

/*
 * Copyright (C) 2007-2018, the BAT core developer team
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 * For documentation see http://mpp.mpg.de/bat
 */

// ---------------------------------------------------------


#include "BCH1D.h"
#include "BCH2D.h"

#include <TF1.h>

#include <cstddef>
#include <cmath>
#include <limits>

class TH1;
class TH2;
class TRandom;

// ---------------------------------------------------------

class BCPrior
{

public:

    BCPrior();

    BCPrior(const BCPrior& other);

    virtual ~BCPrior();

    friend void swap(BCPrior& A, BCPrior& B);

    virtual double GetLogPrior(double x) = 0;

    virtual BCPrior* Clone() const = 0;
    // { return new [Derived Class](*this); }

    virtual bool IsValid() const = 0;

    virtual double GetLogNormalizedPrior(double x)
    { return GetLogPrior(x) - fLogIntegral;}

    virtual double GetPrior(double x, bool normalize = false);

    virtual TF1& GetFunction()
    { return fPriorFunction; }

    virtual const TF1& GetFunction() const
    { return fPriorFunction; }

    virtual void SetFunctionRange(double xmin, double xmax);

    virtual double GetMode(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity());

    virtual double GetRawMoment(unsigned n, double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity());

    virtual double GetIntegral(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity());

    virtual double GetCentralMoment(unsigned n, double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity());

    virtual double GetStandardizedMoment(unsigned n, double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity());

    virtual double GetMean(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return GetRawMoment(1, xmin, xmax); }

    virtual double GetVariance(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return GetCentralMoment(2, xmin, xmax); }

    virtual double GetStandardDeviation(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return sqrt(fabs(GetVariance(xmin, xmax))); }

    virtual double GetSkewness(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return GetStandardizedMoment(3, xmin, xmax); }

    virtual double GetKurtosis(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return GetStandardizedMoment(4, xmin, xmax); }

    virtual double GetRandomValue(double xmin, double xmax, TRandom* const R = NULL);

    virtual double GetPriorForROOT(double* x, double* /*p*/)
    { return GetPrior(x[0]); }

    virtual double GetNormalizedPriorForROOT(double* x, double* /*p*/)
    { return GetPrior(x[0]); }

    virtual double GetLogPriorForROOT(double* x, double* /*p*/)
    { return GetLogPrior(x[0]); }

    virtual double GetNormalizedLogPriorForROOT(double* x, double* /*p*/)
    { return GetLogPrior(x[0]) - fLogIntegral; }

    virtual double CalculateAndStoreIntegral(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { fLogIntegral = log(GetIntegral(xmin, xmax)); return fLogIntegral;}

    virtual void StoreIntegral(double I)
    { fLogIntegral = log(I); }

    virtual void StoreLogIntegral(double logI)
    { fLogIntegral = logI; }

    virtual double GetStoredIntegral() const
    { return exp(fLogIntegral); }

    virtual double GetStoredLogIntegral() const
    { return fLogIntegral; }

    virtual void FillHistogramByCenterValue(TH1* h);

    virtual void FillHistogramByIntegral(TH1* h);

    virtual BCH1D GetBCH1D(TH1* bins, const std::string& name = "prior");

    virtual BCH2D GetBCH2D(BCPrior* ordinate, TH2* bins, const std::string& name = "prior");

protected:
    TF1 fPriorFunction; 

    double fLogIntegral; 
};

#endif