IntegerConverter.h

 
#pragma once
 
#if defined(IntegerConverter_RECURSES)
#error Recursive header files inclusion detected in IntegerConverter.h
#else // defined(IntegerConverter_RECURSES)
#define IntegerConverter_RECURSES
 
#if !defined IntegerConverter_h
#define IntegerConverter_h
 
// Inclusions
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/PointVector.h"
 
namespace DGtal
{
#ifdef WITH_BIGINTEGER
  namespace detail {
    
    static void mpz_set_sll(mpz_t n, long long sll)
    {
      mpz_set_si(n, (int)(sll >> 32));     /* n = (int)sll >> 32 */
      mpz_mul_2exp(n, n, 32 );             /* n <<= 32 */
      mpz_add_ui(n, n, (unsigned int)sll); /* n += (unsigned int)sll */
    }
    
    static void mpz_set_ull(mpz_t n, unsigned long long ull)
    {
      mpz_set_ui(n, (unsigned int)(ull >> 32)); /* n = (unsigned int)(ull >> 32) */
      mpz_mul_2exp(n, n, 32);                   /* n <<= 32 */
      mpz_add_ui(n, n, (unsigned int)ull);      /* n += (unsigned int)ull */
    }      
 
    static unsigned long long mpz_get_ull(mpz_t n)
    {
      unsigned int lo, hi;
      mpz_t tmp;
      mpz_init( tmp );
      mpz_mod_2exp( tmp, n, 64 );   /* tmp = (lower 64 bits of n) */
      lo = mpz_get_ui( tmp );       /* lo = tmp & 0xffffffff */ 
      mpz_div_2exp( tmp, tmp, 32 ); /* tmp >>= 32 */
      hi = mpz_get_ui( tmp );       /* hi = tmp & 0xffffffff */
      mpz_clear( tmp );
      return (((unsigned long long)hi) << 32) + lo;
    }
    
    static long long mpz_get_sll(mpz_t n)
    {
      return (long long)mpz_get_ull(n); /* just use unsigned version */
    }
  }
#endif
    
    
  template < DGtal::Dimension dim,
             typename TInteger >
  struct IntegerConverter {
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ));
    typedef TInteger Integer;
 
    static Integer cast( Integer i ) 
    {
      return i;
    }
 
    static
    PointVector< dim, Integer >
    cast( PointVector< dim, Integer > p )
    {
      return p;
    }
  };
 
  template < DGtal::Dimension dim >
  struct IntegerConverter< dim, DGtal::int32_t > {
    typedef DGtal::int32_t Integer;
 
    static DGtal::int32_t cast( DGtal::int32_t i ) 
    {
      return i;
    }
 
    static
    PointVector< dim, DGtal::int32_t >
    cast( PointVector< dim, DGtal::int32_t > p )
    {
      return p;
    }
 
    static DGtal::int32_t cast( DGtal::int64_t i ) 
    {
      DGtal::int32_t r = DGtal::int32_t( i );
      if ( DGtal::int64_t( r ) != i )
        trace.warning() << "Bad integer conversion: " << i << " -> " << r
                        << std::endl;
      return r;
    }
 
    static
    PointVector< dim, DGtal::int32_t >
    cast( PointVector< dim, DGtal::int64_t > p )
    {
      PointVector< dim, DGtal::int32_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
      
#ifdef WITH_BIGINTEGER
    static DGtal::int32_t cast( DGtal::BigInteger i ) 
    {
      DGtal::int32_t r = i.get_si();
      if ( DGtal::BigInteger( r ) != i )
        trace.warning() << "Bad integer conversion: " << i << " -> " << r
                        << std::endl;
      return r;
    }
 
    static
    PointVector< dim, DGtal::int32_t >
    cast( PointVector< dim, DGtal::BigInteger > p )
    {
      PointVector< dim, DGtal::int32_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
 
#endif
  };
    
 
  template < DGtal::Dimension dim >
  struct IntegerConverter< dim, DGtal::int64_t > {
    typedef DGtal::int64_t Integer;
 
    static DGtal::int64_t cast( DGtal::int32_t i ) 
    {
      return i;
    }
 
    static
    PointVector< dim, DGtal::int64_t >
    cast( PointVector< dim, DGtal::int32_t > p )
    {
      PointVector< dim, DGtal::int64_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
 
    static DGtal::int64_t cast( DGtal::int64_t i ) 
    {
      return i;
    }
 
    static
    PointVector< dim, DGtal::int64_t >
    cast( PointVector< dim, DGtal::int64_t > p )
    {
      return p;
    }
      
#ifdef WITH_BIGINTEGER
    static DGtal::int64_t cast( DGtal::BigInteger i ) 
    {
      DGtal::int64_t r = detail::mpz_get_sll( i.get_mpz_t() );
      DGtal::BigInteger tmp;
      detail::mpz_set_sll( tmp.get_mpz_t(), r );
      if ( tmp != i )
        trace.warning() << "Bad integer conversion: " << i << " -> " << r
                        << std::endl;
      return r;
    }
 
    static
    PointVector< dim, DGtal::int64_t >
    cast( PointVector< dim, DGtal::BigInteger > p )
    {
      PointVector< dim, DGtal::int64_t > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
      
#endif
  };
    
 
#ifdef WITH_BIGINTEGER
  template < DGtal::Dimension dim >
  struct IntegerConverter< dim, DGtal::BigInteger > {
    typedef DGtal::BigInteger Integer;
 
    static DGtal::BigInteger cast( DGtal::int32_t i ) 
    {
      return DGtal::BigInteger( i );
    }
 
    static
    PointVector< dim, DGtal::BigInteger >
    cast( PointVector< dim, DGtal::int32_t > p )
    {
      PointVector< dim, DGtal::BigInteger > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
 
    static DGtal::BigInteger cast( DGtal::int64_t i ) 
    {
      DGtal::BigInteger tmp;
      detail::mpz_set_sll( tmp.get_mpz_t(), i );
      return tmp;
    }
 
    static
    PointVector< dim, DGtal::BigInteger >
    cast( PointVector< dim, DGtal::int64_t > p )
    {
      PointVector< dim, DGtal::BigInteger > q;
      for ( DGtal::Dimension i = 0; i < dim; i++ )
        q[ i ] = cast( p[ i ] );
      return q;
    }
      
    static DGtal::BigInteger cast( DGtal::BigInteger i ) 
    {
      return i;
    }
 
    static
    PointVector< dim, DGtal::BigInteger >
    cast( PointVector< dim, DGtal::BigInteger > p )
    {
      return p;
    }
      
  };
#endif
 
      
} // namespace DGtal {
 
#endif // !defined IntegerConverter_h
 
#undef IntegerConverter_RECURSES
#endif // else defined(IntegerConverter_RECURSES)