RhoDoubleErr.h

Go to the documentation of this file.

#ifndef RHODOUBLEERR_H
#define RHODOUBLEERR_H
//                                                                      //
// RhoDoubleErr                                                         //
//                                                                      //
// Double w/ error                                                      //
//                                                                      //
// Author: Marcel Kunze, RUB, Nov. 99                                   //
// Copyright (C) 1999-2001, Ruhr-University Bochum.                     //
// Ralf Kliemt, HIM/GSI Feb.2013 (Cleanup & Restructuring)              //
//                                                                      //

// Description:
// Class TDoubleErr holds a Double_t and its error squared,
// the equivalent of a TVectorErr with one dimension.
//
// determineChisq(Double_t ref) returns (ref-value())^2 / covariance().
// If the covariance() <= 0 then returns TError::chisqUndef.
//
// The mathematical operators can be used to correctly take into account
// error propagation through simple mathematical operations. Beware of
// operations whose covariance may not be the same as the one which
// results from a sequence of simple operations. For example, a*a will give
// the wrong covariance, since the algorithm assumes that the two arguments
// of the operator* are independent.

#include "TBuffer.h"
#include "TObject.h"
#include "RhoError.h"       // for chisqUndef only

class RhoDoubleErr : public TObject
{
  public:

    // Constructors: The fCovariance and the fValue are 0.0 unless specified:
    RhoDoubleErr() :                       fValue ( 0.0 ), fCovariance ( 0.0 ) {};
    RhoDoubleErr ( Double_t val ) :             fValue ( val ), fCovariance ( 0.0 ) {};
    RhoDoubleErr ( Double_t val, Double_t cov ) : fValue ( val ), fCovariance ( cov ) {};

    // Copy Constructor
    RhoDoubleErr ( const RhoDoubleErr& );

    // Destructor
    virtual ~RhoDoubleErr() {}

    // Assignment operator:
    RhoDoubleErr& operator = ( const RhoDoubleErr& );

    // Accessors (const)
    Double_t Value()                    const {
      return fValue;
    }
    Double_t Covariance()               const {
      return fCovariance;
    }
    Double_t DetermineChisq ( Double_t ref ) const;

    RhoDoubleErr operator-();   // value() -> -value(), covariance() unaffected
    RhoDoubleErr operator - ( const RhoDoubleErr& );
    RhoDoubleErr operator + ( const RhoDoubleErr& );

    // NOTE: (a * b).covariance() is
    // b^2 * a.covariance() + a^2 * b.covariance()
    RhoDoubleErr operator * ( const RhoDoubleErr& );

    // NOTE: (a / b).covariance() is
    // a.covariance() / b^2 + b.covariance() * a^2 / b^4
    RhoDoubleErr operator / ( const RhoDoubleErr& );

    // modifiers:
    void SetValue ( Double_t val )      {
      fValue = val;
    }
    void SetCovariance ( Double_t cov ) {
      fCovariance = cov;
    }

    RhoDoubleErr& operator += ( const RhoDoubleErr& );
    RhoDoubleErr& operator -= ( const RhoDoubleErr& );
    RhoDoubleErr& operator *= ( const RhoDoubleErr& );
    RhoDoubleErr& operator /= ( const RhoDoubleErr& );

    // needed for RWTValOrderedVector
    Bool_t           operator == ( const RhoDoubleErr& other ) const {
      return ( fValue == other.fValue && fCovariance == other.fCovariance );
    }
    Bool_t           operator < ( const RhoDoubleErr& other ) const {
      return ( fValue < other.fValue );
    }


  private:
    // Data members
    Double_t fValue;
    Double_t fCovariance;

  public:
    ClassDef ( RhoDoubleErr,1 ) // holds a Double_t and its error squared
};

std::ostream& operator<< ( std::ostream& stream, const RhoDoubleErr& bde );

#endif