histogram.hpp

Go to the documentation of this file.

/*
 * $Id: histogram.hpp 293 2012-12-17 20:27:36Z jdl3 $
 * Copyright (C) 2012, 2020 John D Lamb
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
#ifndef CCGSL_HISTOGRAM_HPP
#define CCGSL_HISTOGRAM_HPP
 
#include<new>
#include<gsl/gsl_histogram.h>
#include"exception.hpp"
 
namespace gsl {
  class histogram {
  public:
    histogram(){
      ccgsl_pointer = 0;
      count = 0; // initially nullptr will do
    }
    // Refines random access container
    // Refines assignable
    explicit histogram( size_t const n ){
      ccgsl_pointer = gsl_histogram_alloc( n );
      // just plausibly we could allocate histogram but not count
      try { count = new size_t; } catch( std::bad_alloc& e ){
    // try to tidy up before rethrowing
    gsl_histogram_free( ccgsl_pointer );
    throw e;
      }
      *count = 1; // initially there is just one reference to ccgsl_pointer
    }
    explicit histogram( gsl_histogram* v ){
      ccgsl_pointer = v;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to ccgsl_pointer
    }
    // copy constructor
    histogram( histogram const& v ){ ccgsl_pointer = v.ccgsl_pointer;
      count = v.count; if( count != 0 ) ++*count; }
    // assignment operator
    histogram& operator=( histogram const& v ){
      // first, possibly delete anything pointed to by this
      if( count == 0 or --*count == 0 ){
    if( ccgsl_pointer != 0 ) gsl_histogram_free( ccgsl_pointer );
    delete count;
      } // Then copy
      ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
    }
    // destructor
    ~histogram(){
      if( count == 0 or --*count == 0 ){
    // could have allocated null pointer
    if( ccgsl_pointer != 0 ) gsl_histogram_free( ccgsl_pointer );
    delete count;
      }
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    histogram( histogram&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    histogram& operator=( histogram&& v ){
      histogram( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
    // Refines equality comparable
    // == operator
    bool operator==( histogram const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
    // != operator
    bool operator!=( histogram const& v ) const { return not operator==( v ); }
    // Refines forward container
    // Refines less than comparable
    // operator<
    bool operator<( histogram const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
    // operator>
    bool operator>( histogram const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
    // operator<=
    bool operator<=( histogram const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
    // operator>=
    bool operator>=( histogram const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
    bool empty() const { return ccgsl_pointer == 0; }
    // swap() --- should work even if sizes don't match
    void swap( histogram& v ){
      std::swap( ccgsl_pointer, v.ccgsl_pointer );
      std::swap( count, v.count );
    }
  private:
    gsl_histogram* ccgsl_pointer;
    size_t* count;
  public:
    // shared reference functions
    gsl_histogram* get() const { return ccgsl_pointer; }
    bool unique() const { return count != 0 and *count == 1; }
    size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    explicit
#endif
    operator bool() const { return ccgsl_pointer != 0; }
 
#ifndef DOXYGEN_SKIP
    inline static histogram calloc( size_t n ){ return histogram( gsl_histogram_calloc( n ) ); }
 
    inline static histogram calloc_uniform( size_t const n, double const xmin, double const xmax ){
      return histogram( gsl_histogram_calloc_uniform( n, xmin, xmax ) ); }
#endif /* DOXYGEN_SKIP */ 
    
    int increment( double x ){ return gsl_histogram_increment( get(), x ); }
 
    int accumulate( double x, double weight ){
      return gsl_histogram_accumulate( get(), x, weight ); }
 
#ifndef DOXYGEN_SKIP
    int find( double const x, size_t* i ) const {
      return gsl_histogram_find( get(), x, i ); }
#endif /* DOXYGEN_SKIP */ 
    int find( double const x, size_t& i ) const {
      return gsl_histogram_find( get(), x, &i ); }
 
    double get( size_t i ) const { return gsl_histogram_get( get(), i ); }
 
    double operator[]( size_t i ) const { return gsl_histogram_get( get(), i ); }
 
    int get_range( size_t i, double* lower, double* upper ) const {
      return gsl_histogram_get_range( get(), i, lower, upper ); }
    int get_range( size_t i, double& lower, double& upper ) const {
      return gsl_histogram_get_range( get(), i, &lower, &upper ); }
 
    double max() const { return gsl_histogram_max( get() ); }
 
    double min() const { return gsl_histogram_min( get() ); }
 
    size_t bins() const { return gsl_histogram_bins( get() ); }
 
    void reset(){ gsl_histogram_reset( get() ); }
 
#ifndef DOXYGEN_SKIP
    inline static histogram calloc_range( size_t n, double* range ){
      return histogram( gsl_histogram_calloc_range( n, range ) ); }
    template<typename RANGE>
    inline static histogram calloc_range( RANGE& range ){
      return histogram( gsl_histogram_calloc_range( range.size(), range.data() ) ); }
#endif /* DOXYGEN_SKIP */ 
 
    template<typename RANGE>
    int set_ranges( RANGE const& range ){
      return gsl_histogram_set_ranges( get(), range.data(), range.size() ); }
 
    int set_ranges_uniform( double xmin, double xmax ){
      return gsl_histogram_set_ranges_uniform( get(), xmin, xmax ); }
 
    int memcpy( histogram const& source ){ return gsl_histogram_memcpy( get(), source.get() ); }
 
    histogram clone() const { return histogram( gsl_histogram_clone( get() ) ); }
 
    double max_val() const { return gsl_histogram_max_val( get() ); }
 
    size_t max_bin() const { return gsl_histogram_max_bin( get() ); }
 
    double min_val() const { return gsl_histogram_min_val( get() ); }
 
    size_t min_bin() const { return gsl_histogram_min_bin( get() ); }
 
    bool equal_bins_p( histogram const& h2 ) const {
      return gsl_histogram_equal_bins_p( get(), h2.get() ) != 0; }
 
    int add( histogram const& h2 ){ return gsl_histogram_add( get(), h2.get() ); }
 
    int sub( histogram const& h2 ){ return gsl_histogram_sub( get(), h2.get() ); }
 
    int mul( histogram const& h2 ){ return gsl_histogram_mul( get(), h2.get() ); }
 
    int div( histogram const& h2 ){ return gsl_histogram_div( get(), h2.get() ); }
 
    int scale( double const scale ){ return gsl_histogram_scale( get(), scale ); }
 
    int shift( double const shift ){ return gsl_histogram_shift( get(), shift ); }
 
    double sigma() const { return gsl_histogram_sigma( get() ); }
 
    double mean() const { return gsl_histogram_mean( get() ); }
 
    double sum() const { return gsl_histogram_sum( get() ); }
 
    int fwrite( FILE* stream ) const { return gsl_histogram_fwrite( stream, get() ); }
 
    int fread( FILE* stream ){ return gsl_histogram_fread( stream, get() ); }
 
    int fprintf( FILE* stream, char const* range_format, char const* bin_format ) const {
      return gsl_histogram_fprintf( stream, get(), range_format, bin_format ); }
 
    int fscanf( FILE* stream ){ return gsl_histogram_fscanf( stream, get() ); }
 
    //PDF functions
    class pdf {
    public:
      pdf(){
    ccgsl_pointer = 0;
    count = 0; // initially nullptr will do
      }
      // Refines random access container
      // Refines assignable
      explicit pdf( size_t const n ){
    ccgsl_pointer = gsl_histogram_pdf_alloc( n );
    // just plausibly we could allocate pdf but not count
    try { count = new size_t; } catch( std::bad_alloc& e ){
      // try to tidy up before rethrowing
      gsl_histogram_pdf_free( ccgsl_pointer );
      throw e;
    }
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      explicit pdf( gsl_histogram_pdf* v ){
    ccgsl_pointer = v;
    // just plausibly we could fail to allocate count: no further action needed.
    count = new size_t;
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      // copy constructor
      pdf( pdf const& v ){ ccgsl_pointer = v.ccgsl_pointer;
    count = v.count; if( count != 0 ) ++*count; }
      // assignment operator
      pdf& operator=( pdf const& v ){
    // first, possibly delete anything pointed to by this
    if( count == 0 or --*count == 0 ){
      if( ccgsl_pointer != 0 ) gsl_histogram_pdf_free( ccgsl_pointer );
      delete count;
    } // Then copy
    ccgsl_pointer = v.ccgsl_pointer; count = v.count;
    if( count != 0 ){ ++*count; }
    return *this;
      }
      // destructor
      ~pdf(){
    if( count == 0 or --*count == 0 ){
      // could have allocated null pointer
      if( ccgsl_pointer != 0 ) gsl_histogram_pdf_free( ccgsl_pointer );
      delete count;
    }
      }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      pdf( pdf&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
    std::swap( count, v.count );
    v.ccgsl_pointer = nullptr;
      }
      pdf& operator=( pdf&& v ){
    pdf( std::move( v ) ).swap( *this );
    return *this;
      }
#endif
      // Refines equality comparable
      // == operator
      bool operator==( pdf const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
      // != operator
      bool operator!=( pdf const& v ) const { return not operator==( v ); }
      // Refines forward container
      // Refines less than comparable
      // operator<
      bool operator<( pdf const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
      // operator>
      bool operator>( pdf const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
      // operator<=
      bool operator<=( pdf const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
      // operator>=
      bool operator>=( pdf const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
      bool empty() const { return ccgsl_pointer == 0; }
      // swap() --- should work even if sizes don't match
      void swap( pdf& v ){
    std::swap( ccgsl_pointer, v.ccgsl_pointer );
    std::swap( count, v.count );
      }
    private:
      gsl_histogram_pdf* ccgsl_pointer;
      size_t* count;
    public:
      // shared reference functions
      gsl_histogram_pdf* get() const { return ccgsl_pointer; }
      bool unique() const { return count != 0 and *count == 1; }
      size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
#endif
      operator bool() const { return ccgsl_pointer != 0; }
 
      int init( histogram const& h ){ return gsl_histogram_pdf_init( get(), h.get() ); }
 
      double sample( double r ){ return gsl_histogram_pdf_sample( get(), r ); }
    };
  };
}
#endif