combination.hpp

Go to the documentation of this file.

/*
 * $Id: combination.hpp 316 2014-02-22 14:32:31Z jdl3 $
 * Copyright (C) 2012, 2014, 2024 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_COMBINATION_HPP
#define CCGSL_COMBINATION_HPP
 
#include<cstddef>
#include<new>
#include<algorithm>
#include<gsl/gsl_combination.h>
#include"exception.hpp"
 
namespace gsl {
  class combination {
  public:
    combination(){
      ccgsl_pointer = 0;
      count = 0; // initially nullptr will do
    }
    explicit combination( size_t const n, size_t const k, bool init = false ){
      ccgsl_pointer = gsl_combination_alloc( n, k );
      // just plausibly we could allocate combination but not count
      try { count = new size_t; } catch( std::bad_alloc& e ){
    // try to tidy up before rethrowing
    gsl_combination_free( ccgsl_pointer );
    throw e;
      }
      *count = 1; // initially there is just one reference to ccgsl_pointer
      if( init ) this->init_first();
    }
    explicit combination( gsl_combination* 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
    combination( combination const& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( v.count ){
      if( count != 0 ) ++*count; // combination is now shared.
    }
    // assignment operator
    combination& operator=( combination const& v ){
      // first, possibly delete anything pointed to by this
      if( count == 0 or --*count == 0 ){
    if( ccgsl_pointer != 0 ) gsl_combination_free( ccgsl_pointer );
    delete count;
      }
      // Then copy
      ccgsl_pointer = v.ccgsl_pointer;
      count = v.count;
      if( count != 0 ) ++*count; // combination is now shared.
      return *this;
    }
    // clone()
    combination clone() const {
      combination copy( get()->n, get()->k );
      // Now copy
      gsl_combination_memcpy( copy.get(), get() );
      // return new object
      return copy;
    }
    // destructor
    ~combination(){
      if( count == 0 or --*count == 0 ){
    // could have allocated null pointer
    if( ccgsl_pointer != 0 ) gsl_combination_free( ccgsl_pointer );
    delete count;
      }
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    combination( combination&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    combination& operator=( combination&& v ){
      std::swap( ccgsl_pointer, v.ccgsl_pointer );
      std::swap( count, v.count );
      return *this;
    }
#endif
  private:
    gsl_combination* ccgsl_pointer;
    size_t* count;
  public:
    // shared reference functions
    gsl_combination* get(){ return ccgsl_pointer; }
    gsl_combination const* 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; }
  public:
    // GSL functions
    static combination calloc( size_t const n, size_t const k ){
      return combination( gsl_combination_calloc( n, k ) ); }
    void init_first(){ gsl_combination_init_first( get() ); }
    void init_last(){ gsl_combination_init_last( get() ); }
    int memcpy( combination const& src ){ return gsl_combination_memcpy( get(), src.get() ); }
    int fread( FILE* stream ){ return gsl_combination_fread( stream, get() ); }
    int fwrite( FILE* stream ) const { return gsl_combination_fwrite( stream, get() ); }
    int fscanf( FILE* stream ){ return gsl_combination_fscanf( stream, get() ); }
    int fprintf( FILE* stream, char const* format ) const {
      return gsl_combination_fprintf( stream, get(), format ); }
    size_t n() const { return get()->n; }
    size_t k() const { return get()->k; }
    size_t* data() { return get()->data; }
    int valid() { return gsl_combination_valid( get() ); }
    int next(){ return gsl_combination_next( get() ); }
    int prev(){ return gsl_combination_prev( get() ); }
    size_t get( size_t const i ) const { return gsl_combination_get( get(), i ); }
    size_t operator[]( size_t const i ) const { return gsl_combination_get( get(), i ); }
      private:
    template<typename container, typename content, bool reverse> class iterator_base {
      friend class combination;
    public:
      typedef std::random_access_iterator_tag iterator_category;
      typedef size_t value_type;
      typedef value_type* pointer;
      typedef value_type& reference;
      // // type iterator_traits<combination>::difference_type
      typedef ptrdiff_t difference_type;
    public:
      // // operator*
      reference operator*() const {
    // Always try to return something
    static content something = 0;
    // First check that iterator is initialised.
    if( v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAULT );
      return something;
    } else if( v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAULT );
      return something;
    }
    // Check that position make sense
    if( position >= static_cast<difference_type>( v->k() ) ){
      gsl_error( "trying to dereference beyond rbegin()", __FILE__, __LINE__, exception::GSL_EFAILED );
      return something;
    }
    if( position <= -1 ){
      gsl_error( "trying to dereference beyond begin()", __FILE__, __LINE__, exception::GSL_EFAILED );
      return something;
    }
    // position and v are valid: return data
    return *(v->ccgsl_pointer->data + position);
      }
      // // operator->
      pointer operator->() const {
    // First check that iterator is initialised.
    if( v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return 0;
    } else if( v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return 0;
    }
    // Check that position make sense
    if( position >= static_cast<difference_type>( v->k() ) ){
      gsl_error( "trying to dereference end()", __FILE__, __LINE__, exception::GSL_EFAILED );
      return 0;
    }
    if( position <= -1 ){
      gsl_error( "trying to dereference rend()", __FILE__, __LINE__, exception::GSL_EFAILED );
      return 0;
    }
    // position and v are valid: return data
    return *(v->ccgsl_pointer->data + position);
      }
      // // operator[]
      reference operator[]( difference_type const n ) const {
    // Always try to return something
    static content something = 0;
    // First check that iterator is initialised.
    if( v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return something;
    } else if( v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return something;
    }
    // Check that position make sense
    difference_type const p = reverse ? position - n : position + n;
    if( p >= static_cast<difference_type>( v->k() ) ){
      gsl_error( "trying to dereference beyond rbegin()", __FILE__, __LINE__, exception::GSL_EFAILED );
      return something;
    }
    if( p <= -1 ){
      gsl_error( "trying to dereference beyond begin()", __FILE__, __LINE__, exception::GSL_EFAILED );
      return something;
    }
    // p is a valid position
    return *(v->ccgsl_pointer->data + p );
      }
      // // operator-: find distance between two iterators
      difference_type operator-( iterator_base<container,content,reverse> const& i ) const {
    // Warn if either iterator undefined
    if( v == 0 or i.v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return 0;
    } else if( v->ccgsl_pointer == 0 or i.v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return 0;
    }
    // Warn if iterators do not point to same combination
    if( v->ccgsl_pointer != i.v->ccgsl_pointer ){
      gsl_error( "trying to take difference of iterators for different combinations", __FILE__, __LINE__,
             exception::GSL_EFAILED );
      return 0;
    }
    return reverse ? i.position - position : position - i.position;
      }
      // // operator!=
      // // operator<
      bool operator==( iterator_base<container,content,reverse> const& i ) const {
    return this->v == i.v and this->position == i.position;
      }
      bool operator!=( iterator_base<container,content,reverse> const& i ) const {
    return not this->operator==( i );
      }
      bool operator<( iterator_base<container,content,reverse> const& i ) const {
    // Warn if either iterator undefined
    if( v == 0 or i.v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return false;
    }
    // Warn if iterators do not point to same combination
    if( v->ccgsl_pointer != i.v->ccgsl_pointer ){
      gsl_error( "trying to take difference of iterators for different combinations", __FILE__, __LINE__,
             exception::GSL_EFAILED );
      return false;
    }
    return reverse ? i.position < position : position < i.position;
      }
    protected:
      void increment(){
    // Only makes sense if v points to a combination
    if( v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return;
    } else if( v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return;
    }
    // increment position and check against size
    if( reverse ){ if( position >= 0 ) --position; }
    else { if( position < static_cast<difference_type>( v->k() ) ) ++position; }
      }
      void decrement(){
    // Only makes sense if v points to a combination
    if( v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return;
    } else if( v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return;
    }
    // decrement position and check against size
    if( reverse ){ if( position < static_cast<difference_type>( v->k() ) ) ++position; }
    else { if( position >= 0 ) --position; }
      }
      void shift( difference_type const n ){
    // Warn if iterator undefined
    if( v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return;
    } else if( v->ccgsl_pointer == 0 ){
      gsl_error( "combination not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return;
    }
    position += reverse ? -n : n;
      }
      iterator_base(){ v = 0; }
      iterator_base( container* v, difference_type position )
    : v( v ), position( position ){}
      container* v;
      difference_type position;
    };
    template<bool reverse> class const_iterator_t
      : public iterator_base<combination const,unsigned long,reverse>{
    public:
      // // Refines output iterator
      // // operator=
      const_iterator_t<reverse>& operator=( const_iterator_t<reverse> const& i ){
    iterator_base<combination const,unsigned long,reverse>::v = i.v;
    iterator_base<combination const,unsigned long,reverse>::position = i.position;
    return *this;
      }
      // // Refines forward iterator
      // // operator++ (both)
      const_iterator_t<reverse>& operator++(){
    iterator_base<combination const,unsigned long,reverse>::increment();
    return *this;
      }
      const_iterator_t<reverse> operator++( int ){
    // return value
    const_iterator_t<reverse> result( *this );
    iterator_base<combination const,unsigned long,reverse>::increment();
    return result;
      }
      // // Refines bidirectional iterator
      // // operator-- (both)
      const_iterator_t<reverse>& operator--(){
    iterator_base<combination const,unsigned long,reverse>::decrement();
    return *this;
      }
      const_iterator_t<reverse> operator--( int ){
    // return value
    const_iterator_t<reverse> result( *this );
    iterator_base<combination const,unsigned long,reverse>::decrement();
    return result;
      }
      typedef typename iterator_base<combination const,unsigned long,reverse>::difference_type
    difference_type;
      // // operator+=
      const_iterator_t<reverse>& operator+=( difference_type const n ){
    this->shift( n );
    return *this;
      }
      // // operator-=
      const_iterator_t<reverse>& operator-=( difference_type const n ){
    this->shift( -n );
    return *this;
      }
      // // operator+ (n+i)(i+n)
      const_iterator_t<reverse> operator+( difference_type const n ) const {
    const_iterator_t<reverse> result( *this );
    result += n;
    return result;
      }
      // // operator- (n-i)(i-n)(i-j)
      const_iterator_t<reverse> operator-( difference_type const n ) const {
    const_iterator_t<reverse> result( *this );
    result -= n;
    return result;
      }
      difference_type operator-( const_iterator_t<reverse> const& i ) const {
    return iterator_base<combination const,unsigned long,reverse>::operator-( i );
      }
      const_iterator_t() : iterator_base<combination,unsigned long,reverse>(){}
      const_iterator_t( const_iterator_t<reverse> const&i ){
    const_iterator_t<reverse>::v = i.v;
    const_iterator_t<reverse>::position = i.position;
      }
      bool operator==( const_iterator_t<reverse> const& i ) const {
        return this->v == i.v and this->position == i.position;
      }
      bool operator!=( const_iterator_t<reverse> const& i ) const {
        return not this->operator==( i );
      }
      bool operator<( const_iterator_t<reverse> const& i ) const {
    // Warn if either iterator undefined
    if( this->v == 0 or i.v == 0 ){
      gsl_error( "iterator not initialised", __FILE__, __LINE__, exception::GSL_EFAILED );
      return false;
    }
    // Warn if iterators do not point to same combination
    if( this->v->ccgsl_pointer != i.v->ccgsl_pointer ){
      gsl_error( "trying to take difference of iterators for different combinations", __FILE__, __LINE__,
             exception::GSL_EFAILED );
      return false;
    }
    return reverse ? i.position < this->position : this->position < i.position;
      }
    protected:
      // We need a constructor for combination
      friend class combination;
      const_iterator_t( combination const* v, difference_type position )
      : iterator_base<combination const,unsigned long,reverse>( v, position ){}
    };
  public:
    typedef const_iterator_t<false> const_iterator;
    typedef const_iterator_t<true> const_reverse_iterator;
    // type difference_type
    typedef const_iterator::difference_type difference_type;
    // type size_type
    typedef size_t size_type;
    // begin()
    const_iterator begin() const {
      return const_iterator( this, 0 );
    }
    // end()
    const_iterator end() const {
      if( ccgsl_pointer == 0 ) return const_iterator( this, 0 );
      return const_iterator( this, k() );
    }
 
  };
 
}
#endif