binners.hpp

Go to the documentation of this file.

 
#ifndef H_BINNERS
#define H_BINNERS
 
#include <type_traits>
#include <cassert>
#include <stdexcept>
 
 
namespace pottu {
 
    template <class V> 
    class BinnerFloat {
    public:
    typedef V value_type;
 
    BinnerFloat( value_type low_, value_type high_, unsigned int binc )
        : _low(low_), _high(high_), _binc(binc),
          _step( (_high-_low)/binc ) {
        static_assert( std::is_floating_point<V>::value, "Template argument for BinnerFloat must be floating point type." );
        if( binc < 1 )
        throw std::runtime_error( "Bincount must be larger than one!" );
    }
    BinnerFloat( const BinnerFloat &o ) = default;
    BinnerFloat( BinnerFloat &&o ) = default;
    BinnerFloat &operator=( const BinnerFloat &o ) = default;
    BinnerFloat &operator=( BinnerFloat &&o ) = default;
 
    value_type low() const { return( _low ); }
    value_type high() const { return( _high ); }
    unsigned int binCount() const { return( _binc ); }
 
    int operator()( value_type v ) const { return( (v-_low)/_step ); }
    
    bool isUnderflow( value_type v ) const { return( v < _low ); }
    bool isOverflow( value_type v ) const { return( v >= _high ); }
 
    value_type binWidth() const { return( _step ); }
    value_type binLow( unsigned int i ) const { return( i * binWidth() ); }
    value_type binHigh( unsigned int i ) const { return( (i+1)*binWidth() ); }
    double     binCenter( unsigned int i ) const { return(  _low + i*_step + 0.5*_step ); }
 
    
    value_type _low;
    value_type _high;
    unsigned int _binc;
    value_type _step;
    };
 
 
 
    template <class V> 
    class BinnerInteger {
    public:
    typedef V value_type;
 
    BinnerInteger( value_type low, value_type high, unsigned int binc )
        : _low(low), _high(high), _binc(binc),
          _step( (high-low)/binc )
    {
        static_assert( std::is_integral<V>::value, "Template parameter for BinnerInteger must be integer type." );
        assert( _step != 0 && _high == _low + binc*_step );
    }
 
    BinnerInteger( const BinnerInteger &o ) = default;
    BinnerInteger( BinnerInteger &&o ) = default;
    BinnerInteger &operator=( const BinnerInteger &o ) = default;
    BinnerInteger &operator=( BinnerInteger &&o ) = default;
    
    value_type low() const { return( _low ); }
    value_type high() const { return( _high ); }
    unsigned int binCount() const { return( _binc ); }
 
    int operator()( value_type v ) const { return( (v-_low)/_step ); }
    
    bool isUnderflow( value_type v ) const { return( v < _low ); }
    bool isOverflow( value_type v ) const { return( v >= _high ); }
 
    value_type binWidth() const { return( _step ); }
    value_type binLow( unsigned int i ) const { return( i * binWidth() ); }
    value_type binHigh( unsigned int i ) const { return( (i+1)*binWidth() ); }
    double     binCenter( unsigned int i ) const { return(  _low + i*_step + 0.5*_step ); }
    
    
    value_type   _low;
    value_type   _high;
    unsigned int _binc;
    value_type   _step;
    };
 
 
 
    template <class V> 
    class BinnerPow2 {
    public:
    typedef V value_type;
 
    BinnerPow2( value_type high_bits, value_type bins_bits )
        : _high_bits(high_bits),
          _bins_bits(bins_bits),
          _div_bits( _high_bits-bins_bits )
    {
        static_assert( std::is_integral<V>::value && std::is_unsigned<V>::value,
               "Template parameter for BinnerPow2 must be unsigned integer type." );
        assert( _high_bits >= 0 && _bins_bits >= 0 );
        assert( _high_bits >= _bins_bits );
        // Setting some upper limit for memory usage. 31 bits for bins
        // is already 2 gigabins!
        assert( _bins_bits < 32 );
    }
 
    BinnerPow2( const BinnerPow2 &o ) = default;
    BinnerPow2( BinnerPow2 &&o ) = default;
    BinnerPow2 &operator=( const BinnerPow2 &o ) = default;
    BinnerPow2 &operator=( BinnerPow2 &&o ) = default;
    
    value_type low() const { return( 0 ); }
    value_type high() const { return( V(1) << _high_bits ); }
    unsigned int binCount() const { return( V(1) << _bins_bits ); }
 
    int operator()( value_type v ) const noexcept { return( v >> _div_bits ); }
    
    bool isUnderflow( value_type v ) const noexcept { return( v < 0 ); }
    bool isOverflow( value_type v ) const noexcept { return( v >= ( V(1) << _high_bits ) ); }
 
    value_type binWidth() const { return( V(1) << _div_bits ); }
    value_type binLow( unsigned int i ) const { return( i * binWidth() ); }
    value_type binHigh( unsigned int i ) const { return( (i+1)*binWidth() ); }
    double     binCenter( unsigned int i ) const { return(  i*binWidth() + 0.5*binWidth() ); }
    
    
    value_type _high_bits;
    value_type _bins_bits;
    value_type _div_bits;
    };
 
}
 
 
#endif