synaps/arithm/hdwi.h

#ifndef SYNAPS_NUMERICS_HDWI_H
#define SYNAPS_NUMERICS_HDWI_H

#include <synaps/init.h> 

__BEGIN_NAMESPACE_SYNAPS

namespace numerics
{
  template< class T >
  struct is_rounded              { static const bool result = false; typedef Type::false_t result_t; };
  template< >
  struct is_rounded<float>       { static const bool result = true;  typedef Type::true_t  result_t; };
  template< > 
  struct is_rounded<double>      { static const bool result = true;  typedef Type::true_t  result_t; };
  template< >
  struct is_rounded<long double> { static const bool result = true;  typedef Type::true_t  result_t; };
  
  template< class T >
  struct bit_resolution
  { static const int nbit = sizeof(unsigned)*8*3; };
  template<>
  struct bit_resolution<double>
  { static const int nbit = sizeof(double)*8;     };
  template<>
  struct bit_resolution<long double> { static const int nbit = sizeof(long double); };
  
  template< class T >
  unsigned bitprec( const T& e, const T& l = T(1.0) )
  {
    T tmp(l);
    unsigned b = 2;
    while ( tmp > e ) { tmp/=2; b++; };
    return b;
  };
  
  template<typename hdwi, unsigned n>
  struct hdwimax    { static const hdwi result; };
  template<typename T,unsigned n>
  const T hdwimax<T,n>::result((hdwimax<T,n-1>::result<<1)|1);
  template<typename hdwi>
  struct hdwimax<hdwi,0> { static const hdwi result; }; 
  template<typename T> const T hdwimax<T,0>::result(0);
  template< class T >
  struct hdwintp { static const bool result = false; };
  template< class hardware_int >
  struct hdwi
  {

    typedef hardware_int hdw_int;
    enum { nbit = sizeof(hardware_int)*8 };
    //    static const unsigned     nbit  = sizeof(hardware_int)*8;
    static const hardware_int nmax;
    static hdw_int reverse( hdw_int a )
    {
      hdw_int res = 0;
      for ( unsigned i = 0; i < nbit; i ++ )
        {
          res <<= 1;
          res  |= a & 1;
          a   >>= 1;
        };
      return res;
    };
    static void reverse( unsigned h, hdw_int& a)
    {
      unsigned i;
      hdw_int c;
      c = 0;
      for ( i = 0; i < h; i ++ )
        {
          c <<= 1;
          c |= a&1;
          a >>= 1;
        };
      a = c;
    };
  };
  template<class T> const T hdwi<T>::nmax( hdwimax<T,sizeof(T)*8>::result );
  
  template<class unsigned_t> // a faire = sar
  void sal( unsigned_t& a, unsigned n )
  {
    assert(n<=hdwi<unsigned_t>::nbit);
    if ( a & 1 )
      {
        unsigned_t msk(hdwi<unsigned_t>::nmax);
        msk >>= (hdwi<unsigned_t>::nbit-n);
        a <<= n;
        a |= msk;
      }
    else 
      {
        //      std::cout << "SAL( " << n << ") \n";
        //      std::cout << a << std::endl;
        a <<= n;
        //      std::cout << a << std::endl;
      };
          
  };
  
  
  /* met (ha,a) et (hb,b) dans la meme representation 
   * par un shift arithmetique (SAL), c'est a dire en repetant
   * le bit de poids faible. 
   */
  template<typename unsigned_t>
  void hsal( unsigned& ha, unsigned_t& a, unsigned& hb, unsigned_t& b )
  {
    if ( ha == hb ) return; // 
    if ( ha > hb )
      {
        sal(b,ha-hb);
        hb = ha;
      }
    else hsal(hb,b,ha,a);
  };
  
};

__END_NAMESPACE_SYNAPS

#endif