histogram2d.hpp

Go to the documentation of this file.

/*
 * $Id: histogram2d.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_HISTOGRAM2D_HPP
#define CCGSL_HISTOGRAM2D_HPP
 
#include<new>
#include<gsl/gsl_histogram2d.h>
#include"exception.hpp"
 
namespace gsl {
  class histogram2d {
  public:
    histogram2d(){
      ccgsl_pointer = 0;
      count = 0; // initially nullptr will do
    }
    // Refines random access container
    // Refines assignable
    explicit histogram2d( size_t const nx, size_t const ny ){
      ccgsl_pointer = gsl_histogram2d_alloc( nx, ny );
      // just plausibly we could allocate histogram2d but not count
      try { count = new size_t; } catch( std::bad_alloc& e ){
    // try to tidy up before rethrowing
    gsl_histogram2d_free( ccgsl_pointer );
    throw e;
      }
      *count = 1; // initially there is just one reference to ccgsl_pointer
    }
    explicit histogram2d( gsl_histogram2d* 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
    histogram2d( histogram2d const& v ){ ccgsl_pointer = v.ccgsl_pointer;
      count = v.count; if( count != 0 ) ++*count; }
    // assignment operator
    histogram2d& operator=( histogram2d const& v ){
      // first, possibly delete anything pointed to by this
      if( count == 0 or --*count == 0 ){
    if( ccgsl_pointer != 0 ) gsl_histogram2d_free( ccgsl_pointer );
    delete count;
      } // Then copy
      ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
    }
    // destructor
    ~histogram2d(){
      if( count == 0 or --*count == 0 ){
    // could have allocated null pointer
    if( ccgsl_pointer != 0 ) gsl_histogram2d_free( ccgsl_pointer );
    delete count;
      }
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    histogram2d( histogram2d&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    histogram2d& operator=( histogram2d&& v ){
      histogram2d( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
    // Refines equality comparable
    // == operator
    bool operator==( histogram2d const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
    // != operator
    bool operator!=( histogram2d const& v ) const { return not operator==( v ); }
    // Refines forward container
    // Refines less than comparable
    // operator<
    bool operator<( histogram2d const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
    // operator>
    bool operator>( histogram2d const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
    // operator<=
    bool operator<=( histogram2d const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
    // operator>=
    bool operator>=( histogram2d 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( histogram2d& v ){
      std::swap( ccgsl_pointer, v.ccgsl_pointer );
      std::swap( count, v.count );
    }
  private:
    gsl_histogram2d* ccgsl_pointer;
    size_t* count;
  public:
    // shared reference functions
    gsl_histogram2d* 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; }
 
    inline static histogram2d calloc( size_t const nx, size_t const ny ){
      return histogram2d( gsl_histogram2d_calloc( nx, ny ) ); }
 
#ifndef DOXYGEN_SKIP 
    inline static histogram2d calloc_uniform( size_t const nx, size_t const ny,
                          double const xmin, double const xmax,
                          double const ymin, double const ymax ){
      return histogram2d( gsl_histogram2d_calloc_uniform( nx, ny, xmin, xmax, ymin, ymax ) ); }
#endif /* DOXYGEN_SKIP */
 
    int increment( double x, double y ){ return gsl_histogram2d_increment( get(), x, y ); }
 
    int accumulate( double x, double y, double weight ){
      return gsl_histogram2d_accumulate( get(), x, y, weight ); } 
 
#ifndef DOXYGEN_SKIP 
    int find( double const x, double const y, size_t* i, size_t* j ) const {
      return gsl_histogram2d_find( get(), x, y, i, j ); }
#endif /* DOXYGEN_SKIP */
    int find( double const x, double const y, size_t& i, size_t& j ) const {
      return gsl_histogram2d_find( get(), x, y, &i, &j ); }
 
    double get( size_t const i, size_t const j ) const {
      return gsl_histogram2d_get( get(), i, j ); }
 
#ifndef DOXYGEN_SKIP 
    int get_xrange( size_t const i, double* xlower, double* xupper ) const {
      return gsl_histogram2d_get_xrange( get(), i, xlower, xupper ); }
#endif /* DOXYGEN_SKIP */
    int get_xrange( size_t const i, double& xlower, double& xupper ) const {
      return gsl_histogram2d_get_xrange( get(), i, &xlower, &xupper ); }
 
#ifndef DOXYGEN_SKIP 
    int get_yrange( size_t const i, double* ylower, double* yupper ) const {
      return gsl_histogram2d_get_yrange( get(), i, ylower, yupper ); }
#endif /* DOXYGEN_SKIP */
    int get_yrange( size_t const j, double& ylower, double& yupper ) const {
      return gsl_histogram2d_get_yrange( get(), j, &ylower, &yupper ); }
 
    double xmax() const { return gsl_histogram2d_xmax( get() ); }
 
    double xmin() const { return gsl_histogram2d_xmin( get() ); }
 
    size_t nx() const { return gsl_histogram2d_nx( get() ); }
 
    double ymax() const { return gsl_histogram2d_ymax( get() ); }
 
    double ymin() const { return gsl_histogram2d_ymin( get() ); }
 
    size_t ny() const { return gsl_histogram2d_ny( get() ); }
 
    void reset(){ gsl_histogram2d_reset( get() ); }
 
#ifndef DOXYGEN_SKIP 
    inline static histogram2d calloc_range( size_t nx, size_t ny, double* xrange,
                        double* yrange ){
      return histogram2d( gsl_histogram2d_calloc_range( nx, ny, xrange, yrange ) ); }
    template<typename XRANGE,typename YRANGE> 
    inline static histogram2d calloc_range( XRANGE& xrange, YRANGE& yrange ){
      return histogram2d( gsl_histogram2d_calloc_range( xrange.size(), yrange.size(),
                            xrange.data(), yrange.data() ) ); }
#endif /* DOXYGEN_SKIP */
 
    int set_ranges_uniform( double xmin, double xmax, double ymin, double ymax ){
      return gsl_histogram2d_set_ranges_uniform( get(), xmin, xmax, ymin, ymax ); }
 
    int set_ranges( double const xrange[], size_t xsize, double const yrange[], size_t ysize ){
      return gsl_histogram2d_set_ranges( get(), xrange, xsize, yrange, ysize ); }
    template<typename XRANGE,typename YRANGE> 
    int set_ranges( XRANGE const& xrange, YRANGE const& yrange ){
      return gsl_histogram2d_set_ranges( get(), xrange.data(), xrange.size(),
                     yrange.data(), yrange.size() ); }
 
    int memcpy( histogram2d const& source ){
      return gsl_histogram2d_memcpy( get(), source.get() ); }
 
    histogram2d clone() const { return histogram2d( gsl_histogram2d_clone( get() ) ); }
 
    double max_val() const { return gsl_histogram2d_max_val( get() ); }
 
#ifndef DOXYGEN_SKIP 
    void max_bin( size_t* i, size_t* j ) const { gsl_histogram2d_max_bin( get(), i, j ); }
#endif /* DOXYGEN_SKIP */
    void max_bin( size_t& i, size_t& j ) const { gsl_histogram2d_max_bin( get(), &i, &j ); }
 
    double min_val() const { return gsl_histogram2d_min_val( get() ); }
 
#ifndef DOXYGEN_SKIP 
    void min_bin( size_t* i, size_t* j ) const { gsl_histogram2d_min_bin( get(), i, j ); }
#endif /* DOXYGEN_SKIP */
    void min_bin( size_t& i, size_t& j ) const { gsl_histogram2d_min_bin( get(), &i, &j ); }
 
    double xmean() const { return gsl_histogram2d_xmean( get() ); }
 
    double ymean() const { return gsl_histogram2d_ymean( get() ); }
 
    double xsigma() const { return gsl_histogram2d_xsigma( get() ); }
 
    double ysigma() const { return gsl_histogram2d_ysigma( get() ); }
 
    double cov() const { return gsl_histogram2d_cov( get() ); }
 
    double sum() const { return gsl_histogram2d_sum( get() ); }
 
    bool equal_bins_p( histogram2d const& h2 ) const {
      return gsl_histogram2d_equal_bins_p( get(), h2.get() ) != 0; }
 
    int add( histogram2d const& h2 ){ return gsl_histogram2d_add( get(), h2.get() ); }
 
    int sub( histogram2d const& h2 ){ return gsl_histogram2d_sub( get(), h2.get() ); }
 
    int mul( histogram2d const& h2 ){ return gsl_histogram2d_mul( get(), h2.get() ); }
 
    int div( histogram2d const& h2 ){ return gsl_histogram2d_div( get(), h2.get() ); }
 
    int scale( double scale ){ return gsl_histogram2d_scale( get(), scale ); }
 
    int shift( double shift ){ return gsl_histogram2d_shift( get(), shift ); }
 
    int fwrite( FILE* stream ) const { return gsl_histogram2d_fwrite( stream, get() ); }
 
    int fread( FILE* stream ){ return gsl_histogram2d_fread( stream, get() ); } 
 
    int fprintf( FILE* stream, char const* range_format, char const* bin_format ) const {
      return gsl_histogram2d_fprintf( stream, get(), range_format, bin_format ); }
 
    int fscanf( FILE* stream ){ return gsl_histogram2d_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 nx, size_t const ny ){
    ccgsl_pointer = gsl_histogram2d_pdf_alloc( nx, ny );
    // 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_histogram2d_pdf_free( ccgsl_pointer );
      throw e;
    }
    *count = 1; // initially there is just one reference to ccgsl_pointer
      }
      explicit pdf( gsl_histogram2d_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_histogram2d_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_histogram2d_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_histogram2d_pdf* ccgsl_pointer;
      size_t* count;
    public:
      // shared reference functions
      gsl_histogram2d_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( histogram2d const& h ) const {
    return gsl_histogram2d_pdf_init( get(), h.get() ); }
 
#ifndef DOXYGEN_SKIP 
      int sample( double r1, double r2, double* x, double* y ){
    return gsl_histogram2d_pdf_sample( get(), r1, r2, x, y ); }
#endif /* DOXYGEN_SKIP */
      int sample( double r1, double r2, double& x, double& y ){
    return gsl_histogram2d_pdf_sample( get(), r1, r2, &x, &y ); }
    
    };
  };
}
#endif