BCPositiveDefinitePrior.h

#ifndef __BCPOSITIVEDEFINITEPRIOR__H
#define __BCPOSITIVEDEFINITEPRIOR__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 <algorithm>
#include <limits>

#include "BCPrior.h"

class TRandom;

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

class BCPositiveDefinitePrior : public BCPrior
{
public:

    BCPositiveDefinitePrior(BCPrior* prior);

    BCPositiveDefinitePrior(const BCPositiveDefinitePrior& other);

    virtual ~BCPositiveDefinitePrior();

    BCPositiveDefinitePrior& operator=(BCPositiveDefinitePrior other);

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

    BCPrior* Prior()
    { return fPrior; }

    const BCPrior* Prior() const
    { return fPrior; }

    virtual double GetLogPrior(double x)
    { return (x >= 0 and fPrior) ? fPrior->GetLogPrior(x) : -std::numeric_limits<double>::infinity(); }

    virtual double GetPrior(double x, bool normalize = false)
    { return (x >= 0 and fPrior) ? fPrior->GetPrior(x, normalize) : 0; }

    virtual BCPrior* Clone() const
    { return new BCPositiveDefinitePrior(*this); }

    virtual bool IsValid() const
    { return fPrior != NULL and fPrior->IsValid(); }

    virtual void SetFunctionRange(double xmin, double xmax)
    { BCPrior::SetFunctionRange(xmin, xmax); if (fPrior) fPrior->SetFunctionRange(xmin, xmax); }

    virtual double GetMode(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetMode(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetRawMoment(unsigned n, double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetRawMoment(n, std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetIntegral(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetIntegral(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetCentralMoment(unsigned n, double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetCentralMoment(n, std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetStandardizedMoment(unsigned n, double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetCentralMoment(n, std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetMean(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetMean(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetVariance(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetVariance(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetStandardDeviation(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetStandardDeviation(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetSkewness(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetSkewness(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

    virtual double GetKurtosis(double xmin = -std::numeric_limits<double>::infinity(), double xmax = std::numeric_limits<double>::infinity())
    { return (fPrior) ? fPrior->GetKurtosis(std::max<double>(xmin, 0), std::max<double>(xmax, 0)) : std::numeric_limits<double>::quiet_NaN(); }

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

protected:

    BCPrior* fPrior;

};

#endif