Dbn1D.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2021 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_Dbn1D_h
#define YODA_Dbn1D_h

#include "YODA/Dbn0D.h"
#include "YODA/Exceptions.h"
#include "YODA/Utils/MathUtils.h"
#include <cmath>

namespace YODA {


  class Dbn1D {
  public:


    Dbn1D() {
      reset();
    }


    Dbn1D(double numEntries, double sumW, double sumW2, double sumWX, double sumWX2)
      : _dbnW(numEntries, sumW, sumW2),
        _sumWX(sumWX),
        _sumWX2(sumWX2)
    { }


    Dbn1D(const Dbn1D& toCopy) {
      _dbnW = toCopy._dbnW;
      _sumWX = toCopy._sumWX;
      _sumWX2 = toCopy._sumWX2;
    }


    Dbn1D& operator=(const Dbn1D& toCopy) {
      _dbnW = toCopy._dbnW;
      _sumWX = toCopy._sumWX;
      _sumWX2 = toCopy._sumWX2;
      return *this;
    }




    void fill(double val, double weight=1.0, double fraction=1.0) {
      _dbnW.fill(weight, fraction);
      _sumWX += fraction*weight*val;
      _sumWX2 += fraction*weight*val*val;
    }


    void reset() {
      _dbnW.reset();
      _sumWX = 0;
      _sumWX2 = 0;
    }


    void scaleW(double scalefactor) {
      _dbnW.scaleW(scalefactor);
      _sumWX *= scalefactor;
      _sumWX2 *= scalefactor;
    }


    void scaleX(double factor) {
      _sumWX *= factor;
      _sumWX2 *= factor*factor;
    }


  public:



    double errW() const { return _dbnW.errW(); }

    double relErrW() const { return _dbnW.relErrW(); }

    double xMean() const;

    double xVariance() const;

    double xStdDev() const { return std::sqrt(xVariance()); }

    double xStdErr() const;

    double xRMS() const;




    double numEntries() const {
      return _dbnW.numEntries();
    }

    double effNumEntries() const {
      return _dbnW.effNumEntries();
    }

    double sumW() const {
      return _dbnW.sumW();
    }

    double sumW2() const {
      return _dbnW.sumW2();
    }

    double sumWX() const {
      return _sumWX;
    }

    double sumWX2() const {
      return _sumWX2;
    }




    Dbn1D& operator += (const Dbn1D& d) {
      return add(d);
    }

    Dbn1D& operator -= (const Dbn1D& d) {
      return subtract(d);
    }



  protected:

    Dbn1D& add(const Dbn1D& d);

    Dbn1D& subtract(const Dbn1D& d);


  private:


    Dbn0D _dbnW;

    double _sumWX;

    double _sumWX2;


  };


  inline Dbn1D operator + (const Dbn1D& a, const Dbn1D& b) {
    Dbn1D rtn = a;
    rtn += b;
    return rtn;
  }

  inline Dbn1D operator - (const Dbn1D& a, const Dbn1D& b) {
    Dbn1D rtn = a;
    rtn -= b;
    return rtn;
  }


}

#endif