Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic > Struct Template Reference

BinomialAccumulator. More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/Gaudi/Accumulators.h>

Inheritance diagram for Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >:

Collaboration diagram for Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >:

Classes
struct	binomial_t

Public Member Functions
unsigned long	nEntries () const
template<typename Result = fp_result_type<Arithmetic>>
auto	efficiency () const
auto	eff () const
template<typename Result = fp_result_type<Arithmetic>>
auto	efficiencyErr () const
auto	effErr () const
BinomialAccumulator &	operator+= (binomial_t b)
Public Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
constexpr	AccumulatorSet ()=default
AccumulatorSet &	operator+= (const InputType by)
OutputType	value () const
void	reset ()
void	mergeAndReset (AccumulatorSet< bool, Ato, InputType, TrueAccumulator... > &other)
void	operator+ (AccumulatorSet< bool, Ato, InputType, TrueAccumulator... > &&other)
void	operator++ ()=delete
Public Member Functions inherited from Gaudi::Accumulators::TrueAccumulator< Atomicity, bool >
unsigned long	nTrueEntries () const
Public Member Functions inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
GenericAccumulator	operator+= (const InputType by)
GenericAccumulator &	operator= (const GenericAccumulator &other)
OutputType	value () const
void	reset ()
void	mergeAndReset (GenericAccumulator< InputType, unsigned long, ato, TrueTo1, Identity, VH > &other)
void	operator+ (GenericAccumulator< InputType, unsigned long, ato, TrueTo1, Identity, VH > &&other)

Additional Inherited Members
Public Types inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
using	InputType
using	OutputType
using	InternalType
using	JSONStringEntriesType
Public Types inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
using	InputType
using	OutputType
using	InternalType
using	JSONStringEntriesType
Protected Member Functions inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
auto	rawValue () const
Static Protected Member Functions inherited from Gaudi::Accumulators::AccumulatorSet< bool, Atomicity, bool, TrueAccumulator, FalseAccumulator >
static InternalType	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)
Static Protected Member Functions inherited from Gaudi::Accumulators::GenericAccumulator< bool, unsigned long, Atomicity, TrueTo1 >
static unsigned long	extractJSONData (const nlohmann::json &j, const JSONStringEntriesType &entries)

Detailed Description

template<atomicity Atomicity, typename Arithmetic>
struct Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >

BinomialAccumulator.

A BinomialAccumulator is an Accumulator able to compute the efficiency of a process data

See also

Gaudi::Accumulators for detailed documentation

Definition at line 725 of file Accumulators.h.

Member Function Documentation

eff()

template<atomicity Atomicity, typename Arithmetic>

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::eff ( ) const

inline

Definition at line 735 of file Accumulators.h.

{ return efficiency(); }

effErr()

template<atomicity Atomicity, typename Arithmetic>

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::effErr ( ) const

inline

Definition at line 747 of file Accumulators.h.

{ return efficiencyErr(); }

efficiency()

template<atomicity Atomicity, typename Arithmetic>

template<typename Result = fp_result_type<Arithmetic>>

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::efficiency ( ) const

inline

Definition at line 730 of file Accumulators.h.

                            {
      auto nbEntries = nEntries();
      if ( 1 > nbEntries ) return Result{ -1 };
      return static_cast<Result>( this->nTrueEntries() ) / nbEntries;
    }

efficiencyErr()

template<atomicity Atomicity, typename Arithmetic>

template<typename Result = fp_result_type<Arithmetic>>

auto Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::efficiencyErr ( ) const

inline

Definition at line 738 of file Accumulators.h.

                               {
      // Note the usage of using, aiming at using the std version of sqrt by default, without preventing
      // more specialized versions to be used via ADL (see http://en.cppreference.com/w/cpp/language/adl)
      using Gaudi::Accumulators::sqrt;
      using std::sqrt;
      auto nbEntries = nEntries();
      if ( 1 > nbEntries ) return Result{ -1 };
      return sqrt( static_cast<Result>( this->nTrueEntries() * this->nFalseEntries() ) / nbEntries ) / nbEntries;
    }

nEntries()

template<atomicity Atomicity, typename Arithmetic>

unsigned long Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::nEntries ( ) const

inline

Definition at line 727 of file Accumulators.h.

{ return this->nTrueEntries() + this->nFalseEntries(); }

operator+=()

template<atomicity Atomicity, typename Arithmetic>

BinomialAccumulator & Gaudi::Accumulators::BinomialAccumulator< Atomicity, Arithmetic >::operator+= ( binomial_t b )

inline

Definition at line 753 of file Accumulators.h.

                                                  {
      assert( b.nPass <= b.nTotal );
      TrueAccumulator<atomicity::none, bool> t{ std::in_place, b.nPass };
      TrueAccumulator<Atomicity, bool>::mergeAndReset( t );
      FalseAccumulator<atomicity::none, bool> f{ std::in_place, b.nTotal - b.nPass };
      FalseAccumulator<Atomicity, bool>::mergeAndReset( f );
      return *this;
    }

---

The documentation for this struct was generated from the following file:

• GaudiKernel/include/Gaudi/Accumulators.h