---

scfx_rep.cpp

Go to the documentation of this file.

/*****************************************************************************

  The following code is derived, directly or indirectly, from the SystemC
  source code Copyright (c) 1996-2004 by all Contributors.
  All Rights reserved.

  The contents of this file are subject to the restrictions and limitations
  set forth in the SystemC Open Source License Version 2.3 (the "License");
  You may not use this file except in compliance with such restrictions and
  limitations. You may obtain instructions on how to receive a copy of the
  License at http://www.systemc.org/. Software distributed by Contributors
  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
  ANY KIND, either express or implied. See the License for the specific
  language governing rights and limitations under the License.

 *****************************************************************************/

/*****************************************************************************

  scfx_rep.cpp - 

  Original Author: Robert Graulich, Synopsys, Inc.
                   Martin Janssen,  Synopsys, Inc.

 *****************************************************************************/

/*****************************************************************************

  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
  changes you are making here.

      Name, Affiliation, Date:
  Description of Modification:

 *****************************************************************************/


#include "systemc/datatypes/fx/scfx_rep.h"

#include "systemc/datatypes/fx/scfx_ieee.h"
#include "systemc/datatypes/fx/scfx_pow10.h"
#include "systemc/datatypes/fx/scfx_utils.h"

#include "systemc/datatypes/bit/sc_bv_base.h"

#include <ctype.h>
#include <math.h>


namespace sc_dt
{

// ----------------------------------------------------------------------------
//  some utilities
// ----------------------------------------------------------------------------

static scfx_pow10 pow10_fx;

static const int mantissa0_size = SCFX_IEEE_DOUBLE_M_SIZE - bits_in_int;

static inline
int
n_word( int x )
{
    return ( x + bits_in_word - 1 ) / bits_in_word;
}


// ----------------------------------------------------------------------------
//  CONSTRUCTORS
// ----------------------------------------------------------------------------

scfx_rep::scfx_rep()
: m_mant( min_mant ), m_r_flag( false )
{
    set_zero();
}

scfx_rep::scfx_rep( int a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a != 0 )
    {
        m_mant.clear();
  m_wp = m_msw = m_lsw = 2;
  m_state = normal;
  if( a > 0 )
  {
      m_mant[2] = a;
      m_sign = 1;
  }
  else
  {
      m_mant[2] = -a;
      m_sign = -1;
  }
    }
    else
        set_zero();
}

scfx_rep::scfx_rep( unsigned int a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a != 0 )
    {
        m_mant.clear();
  m_wp = m_msw = m_lsw = 2;
  m_state = normal;
  m_mant[2] = a;
  m_sign = 1;
    }
    else
        set_zero();
}

scfx_rep::scfx_rep( long a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a != 0 )
    {
        m_mant.clear();
  m_wp = m_msw = m_lsw = 2;
  m_state = normal;
  if( a > 0 )
  {
      m_mant[2] = a;
      m_sign = 1;
  }
  else
  {
      m_mant[2] = -a;
      m_sign = -1;
  }
    }
    else
        set_zero();
}

scfx_rep::scfx_rep( unsigned long a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a != 0 )
    {
        m_mant.clear();
  m_wp = m_msw = m_lsw = 2;
  m_state = normal;
  m_mant[2] = a;
  m_sign = 1;
    }
    else
        set_zero();
}

scfx_rep::scfx_rep( double a )
: m_mant( min_mant ), m_wp( 0 ), m_state( normal ), m_msw( 0 ), m_lsw( 0 ),
  m_r_flag( false )
{
    m_mant.clear();

    scfx_ieee_double id( a );

    m_sign = id.negative() ? -1 : 1;

    if( id.is_nan() )
        m_state = not_a_number;
    else if( id.is_inf() )
        m_state = infinity;
    else if( id.is_subnormal() )
    {
  m_mant[0] = id.mantissa1();
  m_mant[1] = id.mantissa0();
  normalize( id.exponent() + 1 - SCFX_IEEE_DOUBLE_M_SIZE );
    }
    else if( id.is_normal() )
    {
  m_mant[0] = id.mantissa1();
  m_mant[1] = id.mantissa0() | ( 1 << mantissa0_size );
  normalize( id.exponent() - SCFX_IEEE_DOUBLE_M_SIZE );
    }
}

scfx_rep::scfx_rep( int64 a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a != 0 )
    {
        m_mant.clear();
  m_wp = 1;
  m_state = normal;
  if( a > 0 )
  {
      m_mant[1] = static_cast<word>( a );
      m_mant[2] = static_cast<word>( a >> bits_in_word );
      m_sign = 1;
  }
  else
  {
      m_mant[1] = static_cast<word>( -a );
      m_mant[2] = static_cast<word>( (-a) >> bits_in_word );
      m_sign = -1;
  }
  find_sw();
    }
    else
        set_zero();
}

scfx_rep::scfx_rep( uint64 a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a != 0 )
    {
        m_mant.clear();
  m_wp = 1;
  m_state = normal;
  m_mant[1] = static_cast<word>( a );
  m_mant[2] = static_cast<word>( a >> bits_in_word );
  m_sign = 1;
  find_sw();
    }
    else
        set_zero();
}

scfx_rep::scfx_rep( const sc_signed& a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a.iszero() )
  set_zero();
    else
    {
  int words = n_word( a.length() );
  if( words > size() )
      resize_to( words );
  m_mant.clear();
  m_wp = 0;
  m_state = normal;
  if( a.sign() )
  {
      sc_signed a2 = -a;
      for( int i = 0; i < a2.length(); ++ i )
      {
    if( a2[i] )
    {
        scfx_index x = calc_indices( i );
        m_mant[x.wi()] |= 1 << x.bi();
    }
      }
      m_sign = -1;
  }
  else
  {
      for( int i = 0; i < a.length(); ++ i )
      {
    if( a[i] )
    {
        scfx_index x = calc_indices( i );
        m_mant[x.wi()] |= 1 << x.bi();
    }
      }
      m_sign = 1;
  }
  find_sw();
    }
}

scfx_rep::scfx_rep( const sc_unsigned& a )
: m_mant( min_mant ), m_r_flag( false )
{
    if( a.iszero() )
  set_zero();
    else
    {
  int words = n_word( a.length() );
  if( words > size() )
      resize_to( words );
  m_mant.clear();
  m_wp = 0;
  m_state = normal;
  for( int i = 0; i < a.length(); ++ i )
  {
      if( a[i] )
      {
    scfx_index x = calc_indices( i );
    m_mant[x.wi()] |= 1 << x.bi();
      }
  }
  m_sign = 1;
  find_sw();
    }
}


// copy constructor

scfx_rep::scfx_rep( const scfx_rep& a )
: m_mant( a.m_mant ), m_wp( a.m_wp ), m_sign( a.m_sign ), m_state( a.m_state ),
  m_msw( a.m_msw ), m_lsw( a.m_lsw ), m_r_flag( false )
{}


// ----------------------------------------------------------------------------
//  OPERATORS : new, delete
//
//  Memory management for class scfx_rep.
// ----------------------------------------------------------------------------

union scfx_rep_node
{
    char           data[sizeof( scfx_rep )];
    scfx_rep_node* next;
};


static scfx_rep_node* list = 0;


void*
scfx_rep::operator new( size_t size )
{
    const int ALLOC_SIZE = 1024;

    if( size != sizeof( scfx_rep ) )
  return ::operator new( size );

    if( ! list )
    {
  list = new scfx_rep_node[ALLOC_SIZE];
  for( int i = 0; i < ALLOC_SIZE - 1; i ++ )
      list[i].next = list + i + 1;
  list[ALLOC_SIZE - 1].next = 0;
    }

    scfx_rep* ptr = reinterpret_cast<scfx_rep*>( list->data );
    list = list->next;

    return ptr;
}


void scfx_rep::operator delete( void* ptr, size_t size )
{
    if( size != sizeof( scfx_rep ) )
    {
  ::operator delete( ptr );
  return;
    }

    scfx_rep_node* node = static_cast<scfx_rep_node*>( ptr );
    node->next = list;
    list = node;
}


// ----------------------------------------------------------------------------
//  METHOD : from_string
//
//  Convert from character string to sc_fxrep.
// ----------------------------------------------------------------------------

#define SCFX_FAIL_IF_(cnd)                                                    \
{                                                                             \
    if( ( cnd ) )                                                             \
    {                                                                         \
        m_state = not_a_number;                                               \
  m_mant.clear(); /* to avoid Purify UMRs during assignment */          \
        return;                                                               \
    }                                                                         \
}


void
scfx_rep::from_string( const char* s, int cte_wl )
{
    SCFX_FAIL_IF_( s == 0 || *s == 0 );

    scfx_string s2;
    s2 += s;
    s2 += '\0';

    bool sign_char;
    m_sign = scfx_parse_sign( s, sign_char );

    sc_numrep numrep = scfx_parse_prefix( s );

    int base = 0;

    switch( numrep )
    {
  case SC_DEC:
  {
      base = 10;
      if( scfx_is_nan( s ) )
      {   // special case: NaN
    m_state = not_a_number;
    m_mant.clear(); /* to avoid Purify UMRs during assignment */
    return;
      }
      if( scfx_is_inf( s ) )
      {   // special case: Infinity
    m_state = infinity;
    m_mant.clear(); /* to avoid Purify UMRs during assignment */
    return;
      }
      break;
  }
  case SC_BIN:
  case SC_BIN_US:
  {
      SCFX_FAIL_IF_( sign_char );
      base = 2;
      break;
  }
  
  case SC_BIN_SM:
  {
      base = 2;
      break;
  }
  case SC_OCT:
  case SC_OCT_US:
  {
      SCFX_FAIL_IF_( sign_char );
      base = 8;
      break;
  }
  case SC_OCT_SM:
  {
      base = 8;
      break;
  }
  case SC_HEX:
  case SC_HEX_US:
  {
      SCFX_FAIL_IF_( sign_char );
      base = 16;
      break;
  }
  case SC_HEX_SM:
  {
      base = 16;
      break;
  }
  case SC_CSD:
  {
      SCFX_FAIL_IF_( sign_char );
      base = 2;
      scfx_csd2tc( s2 );
      s = (const char*) s2 + 4;
      numrep = SC_BIN;
      break;
  }
        default:;
    }

    //
    // find end of mantissa and count the digits and points
    //

    const char *end = s;
    bool based_point = false;
    int int_digits = 0;
    int frac_digits = 0;

    while( *end )
    {
  if( scfx_exp_start( end ) )
      break;
  
  if( *end == '.' )
  {
      SCFX_FAIL_IF_( based_point );
      based_point = true;
  }
  else
  {
      SCFX_FAIL_IF_( ! scfx_is_digit( *end, numrep ) );
      if( based_point )
    frac_digits ++;
      else
    int_digits ++;
  }

  ++ end;
    }

    SCFX_FAIL_IF_( int_digits == 0 && frac_digits == 0 );

    // [ exponent ]
    
    int exponent = 0;

    if( *end )
    {
  for( const char *e = end + 2; *e; ++ e )
      SCFX_FAIL_IF_( ! scfx_is_digit( *e, SC_DEC ) );
  exponent = atoi( end + 1 );
    }

    //
    // check if the mantissa is negative
    //

    bool mant_is_neg = false;

    switch( numrep )
    {
  case SC_BIN:
  case SC_OCT:
  case SC_HEX:
  {
      const char* p = s;
      if( *p == '.' )
    ++ p;

      mant_is_neg = ( scfx_to_digit( *p, numrep ) >= ( base >> 1 ) );

      break;
  }
  default:
      ;
    }

    //
    // convert the mantissa
    //

    switch( base )
    {
        case 2:
  {
      int bit_offset = exponent % bits_in_word;
      int word_offset = exponent / bits_in_word;

      int_digits += bit_offset;
      frac_digits -= bit_offset;

      int words = n_word( int_digits ) + n_word( frac_digits );
      if( words > size() )
    resize_to( words );
      m_mant.clear();

      int j = n_word( frac_digits ) * bits_in_word + int_digits - 1;
      
      for( ; s < end; s ++ )
      {
    switch( *s )
    {
        case '1':
            set_bin( j );
        case '0':
      j --;
        case '.':
      break;
        default:
      SCFX_FAIL_IF_( true );  // should not happen
    }
      }

      m_wp = n_word( frac_digits ) - word_offset;
      break;
  }
        case 8:
  {
      exponent *= 3;
      int_digits *= 3;
      frac_digits *= 3;

      int bit_offset = exponent % bits_in_word;
      int word_offset = exponent / bits_in_word;

      int_digits += bit_offset;
      frac_digits -= bit_offset;

      int words = n_word( int_digits ) + n_word( frac_digits );
      if( words > size() )
    resize_to( words );
      m_mant.clear();

      int j = n_word( frac_digits ) * bits_in_word + int_digits - 3;
      
      for( ; s < end; s ++ )
      {
    switch( *s )
    {
        case '7': case '6': case '5': case '4':
        case '3': case '2': case '1':
            set_oct( j, *s - '0' );
        case '0':
      j -= 3;
        case '.':
      break;
        default:
      SCFX_FAIL_IF_( true );  // should not happen
    }
      }

      m_wp = n_word( frac_digits ) - word_offset;
      break;
  }
        case 10:
  {
      unsigned long carry, temp;
      int length = int_digits + frac_digits;
      resize_to( sc_max( min_mant, n_word( 4 * length ) ) );

      m_mant.clear();
      m_msw = m_lsw = 0;
      
      for( ; s < end; s ++ )
      {
    switch( *s )
    {
        case '9': case '8': case '7': case '6': case '5':
        case '4': case '3': case '2': case '1': case '0':
            multiply_by_ten();
      carry = *s - '0';
      for ( int i = 0; carry && i < m_mant.size(); i++ )
      {
          temp = m_mant[i];
                            temp += carry;          
          carry = temp < m_mant[i];
          m_mant[i] = temp;
      }
        case '.':
      break;
        default:
      SCFX_FAIL_IF_( true );  // should not happen
    }
      }
      
      m_wp = 0;
      find_sw();

      int denominator = frac_digits - exponent;
      
      if( denominator )
      {
    scfx_rep frac_num = pow10_fx( denominator );
    scfx_rep* temp_num =
        div_scfx_rep( const_cast<const scfx_rep&>( *this ),
           frac_num, cte_wl );
    *this = *temp_num;
    delete temp_num;
      }

      break;
  }
        case 16:
  {
      exponent *= 4;
      int_digits *= 4;
      frac_digits *= 4;

      int bit_offset = exponent % bits_in_word;
      int word_offset = exponent / bits_in_word;

      int_digits += bit_offset;
      frac_digits -= bit_offset;

      int words = n_word( int_digits ) + n_word( frac_digits );
      if( words > size() )
    resize_to( words );
      m_mant.clear();

      int j = n_word( frac_digits ) * bits_in_word + int_digits - 4;
      
      for( ; s < end; s ++ )
      {
    switch( *s )
    {
        case 'f': case 'e': case 'd': case 'c': case 'b': case 'a':
           set_hex( j, *s - 'a' + 10 );
           j -= 4;
           break;
        case 'F': case 'E': case 'D': case 'C': case 'B': case 'A':
           set_hex( j, *s - 'A' + 10 );
           j -= 4;
           break;
        case '9': case '8': case '7': case '6': case '5':
        case '4': case '3': case '2': case '1':
           set_hex( j, *s - '0' );
        case '0':
           j -= 4;
        case '.':
           break;
       default:
           SCFX_FAIL_IF_( true );  // should not happen
    }
      }

      m_wp = n_word( frac_digits ) - word_offset;
      break;
  }
    }

    m_state = normal;
    find_sw();

    //
    // two's complement of mantissa if it is negative
    //

    if( mant_is_neg )
    {
  m_mant[m_msw] |=  -1 << scfx_find_msb( m_mant[m_msw] );
  for( int i = m_msw + 1; i < m_mant.size(); ++ i )
      m_mant[i] = static_cast<word>( -1 );
  complement( m_mant, m_mant, m_mant.size() );
  inc( m_mant );
  m_sign *= -1;
  find_sw();
    }
}


#undef SCFX_FAIL_IF_


// ----------------------------------------------------------------------------
//  METHOD : to_double
//
//  Convert from scfx_rep to double.
// ----------------------------------------------------------------------------

double
scfx_rep::to_double() const 
{
    scfx_ieee_double id;

    // handle special cases

    if( is_nan() )
    {
        id.set_nan();
  return id;
    }

    if( is_inf() )
    {
        id.set_inf();
  id.negative( m_sign < 0 );
  return id;
    }

    if( is_zero() )
    {
  id = 0.;
  id.negative( m_sign < 0 );
  return id;
    }

    int msb = scfx_find_msb( m_mant[m_msw] );

    int exp = (m_msw - m_wp) * bits_in_word + msb;

    if( exp > SCFX_IEEE_DOUBLE_E_MAX )
    {
  id.set_inf();
  id.negative( m_sign < 0 );
  return id;
    }

    if( exp < SCFX_IEEE_DOUBLE_E_MIN
  - static_cast<int>( SCFX_IEEE_DOUBLE_M_SIZE ) )
    {
  id = 0.;
  return id;
    }
 
    int shift = mantissa0_size - msb;

    unsigned int m0;
    unsigned int m1 = 0;
    unsigned int guard = 0;

    if( shift == 0 )
    {
        m0 = m_mant[m_msw] & ~( 1 << mantissa0_size );
  if( m_msw > m_lsw )
  {
      m1 = m_mant[m_msw - 1];
      if( m_msw - 1 > m_lsw )
          guard = m_mant[m_msw - 2] >> ( bits_in_word - 1 );
  }
    }
    else if( shift < 0 )
    {
  m0 = ( m_mant[m_msw] >> -shift ) & ~( 1 << mantissa0_size );
  m1 = m_mant[m_msw] << ( bits_in_word + shift );
  if( m_msw > m_lsw )
  {
      m1 |= m_mant[m_msw - 1] >> -shift;
      guard = ( m_mant[m_msw - 1] >> ( -shift - 1 ) ) & 1;
  }
    }
    else
    {
  m0 = ( m_mant[m_msw] << shift ) & ~( 1 << mantissa0_size );
  if( m_msw > m_lsw )
  {
      m0 |= m_mant[m_msw - 1] >> ( bits_in_word - shift );
      m1 = m_mant[m_msw - 1] << shift;
      if( m_msw - 1 > m_lsw )
      {
          m1 |= m_mant[m_msw - 2] >> ( bits_in_word - shift );
    guard = ( m_mant[m_msw - 2] >> (bits_in_word - shift - 1) )
                      & 1;
      }      
  }
    }

    if( exp < SCFX_IEEE_DOUBLE_E_MIN )
    {
  m0 |= ( 1 << mantissa0_size );

  int subnormal_shift = SCFX_IEEE_DOUBLE_E_MIN - exp;

  if( subnormal_shift < bits_in_word )
  {
      m1 = m1 >> subnormal_shift
         | m0 << ( bits_in_word - subnormal_shift );
      m0 = m0 >> subnormal_shift;
  }
  else
  {
      m1 = m0 >> ( subnormal_shift - bits_in_word );
      m0 = 0;
  }

  guard = 0;

  exp = SCFX_IEEE_DOUBLE_E_MIN - 1;
    }

    id.mantissa0( m0 );
    id.mantissa1( m1 );
    id.exponent( exp );
    id.negative( m_sign < 0 );

    double result = id;

    if( guard != 0 )
        result += m_sign * scfx_pow2( exp - SCFX_IEEE_DOUBLE_M_SIZE );

    return result;
}


// ----------------------------------------------------------------------------
//  METHOD : to_string
//
//  Convert from scfx_rep to character string.
// ----------------------------------------------------------------------------

void
print_dec( scfx_string& s, const scfx_rep& num, int w_prefix, sc_fmt fmt )
{
    if( num.is_neg() )
  s += '-';

    if( w_prefix == 1 ) {
  scfx_print_prefix( s, SC_DEC );
    }

    if( num.is_zero() )
    {
  s += '0';
  return;
    }

    // split 'num' into its integer and fractional part

    scfx_rep int_part  = num;
    scfx_rep frac_part = num;

    int i;
    
    for( i = int_part.m_lsw; i <= int_part.m_msw && i < int_part.m_wp; i ++ )
  int_part.m_mant[i] = 0;
    int_part.find_sw();
    if( int_part.m_wp < int_part.m_lsw )
  int_part.resize_to( int_part.size() - int_part.m_wp, -1 );
    
    for( i = frac_part.m_msw;
   i >= frac_part.m_lsw && i >= frac_part.m_wp;
   i -- )
  frac_part.m_mant[i] = 0;
    frac_part.find_sw();
    if( frac_part.m_msw == frac_part.size() - 1 )
  frac_part.resize_to( frac_part.size() + 1, 1 );

    // print integer part

    int int_digits = 0;
    int int_zeros  = 0;
    
    if( ! int_part.is_zero() )
    {
  double int_wl = ( int_part.m_msw - int_part.m_wp ) * bits_in_word
                + scfx_find_msb( int_part.m_mant[int_part.m_msw] ) + 1;
  int_digits = (int) ceil( int_wl * log10( 2. ) );

  int len = s.length();
  s.append( int_digits );

  bool zero_digits = ( frac_part.is_zero() && fmt != SC_F );

  for( i = int_digits + len - 1; i >= len; i-- )
  {
      unsigned int remainder = int_part.divide_by_ten();
      s[i] = static_cast<char>( '0' + remainder );
      
      if( zero_digits )
      {
    if( remainder == 0 )
        int_zeros ++;
    else
        zero_digits = false;
      }
  }

  // discard trailing zeros from int_part
  s.discard( int_zeros );

  if( s[len] == '0' )
  {
      // int_digits was overestimated by one
      s.remove( len );
      -- int_digits;
  }
    }

    // print fractional part

    int frac_digits = 0;
    int frac_zeros  = 0;

    if( ! frac_part.is_zero() )
    {
  s += '.';

  bool zero_digits = ( int_digits == 0 && fmt != SC_F );

  double frac_wl = ( frac_part.m_wp - frac_part.m_msw ) * bits_in_word
                 - scfx_find_msb( frac_part.m_mant[frac_part.m_msw] )
                       - 1;
  frac_zeros = (int) floor( frac_wl * log10( 2. ) );

  scfx_rep temp;
  sc_dt::multiply( temp, frac_part, pow10_fx( frac_zeros ) );
  frac_part = temp;
  if( frac_part.m_msw == frac_part.size() - 1 )
      frac_part.resize_to( frac_part.size() + 1, 1 );
  
  frac_digits = frac_zeros;
  if( ! zero_digits )
  {
      for( i = 0; i < frac_zeros; i ++ )
    s += '0';
      frac_zeros = 0;
  }

  while( ! frac_part.is_zero() )
  {
      frac_part.multiply_by_ten();
      int n = frac_part.m_mant[frac_part.m_msw + 1];
  
      if( zero_digits )
      {
    if( n == 0 )
        frac_zeros ++;
    else
        zero_digits = false;
      }
  
      if( ! zero_digits )
    s += static_cast<char>( '0' + n );

      frac_part.m_mant[frac_part.m_msw + 1] = 0;
      frac_digits ++;
  }
    }

    // print exponent
    
    if( fmt != SC_F )
    {
        if( frac_digits == 0 )
      scfx_print_exp( s, int_zeros );
  else if( int_digits == 0 )
      scfx_print_exp( s, - frac_zeros );
    }
}

void
print_other( scfx_string& s, const scfx_rep& a, sc_numrep numrep, int w_prefix,
       sc_fmt fmt, const scfx_params* params )
{
    scfx_rep b = a;

    sc_numrep numrep2 = numrep;

    bool numrep_is_sm = ( numrep == SC_BIN_SM ||
        numrep == SC_OCT_SM ||
        numrep == SC_HEX_SM );

    if( numrep_is_sm )
    {
  if( b.is_neg() )
  {
      s += '-';
      b = *neg_scfx_rep( a );
  }
  switch( numrep )
  {
      case SC_BIN_SM:
    numrep2 = SC_BIN_US;
    break;
      case SC_OCT_SM:
    numrep2 = SC_OCT_US;
    break;
      case SC_HEX_SM:
    numrep2 = SC_HEX_US;
    break;
      default:
    ;
  }
    }
    
    if( w_prefix != 0 ) {
  scfx_print_prefix( s, numrep );
    }

    numrep = numrep2;

    int msb, lsb;

    if( params != 0 )
    {
  msb = params->iwl() - 1;
  lsb = params->iwl() - params->wl();

  if( params->enc() == SC_TC_ &&
      ( numrep == SC_BIN_US ||
        numrep == SC_OCT_US ||
        numrep == SC_HEX_US ) &&
      ! numrep_is_sm &&
      params->wl() > 1 )
      -- msb;
  else if( params->enc() == SC_US_ &&
      ( numrep == SC_BIN ||
        numrep == SC_OCT ||
        numrep == SC_HEX ||
        numrep == SC_CSD ) )
      ++ msb;
    }
    else
    {
  if( b.is_zero() )
  {
      msb = 0;
      lsb = 0;
  }
  else
  {
      msb = ( b.m_msw - b.m_wp ) * bits_in_word
    + scfx_find_msb( b.m_mant[ b.m_msw ] ) + 1;
      while( b.get_bit( msb ) == b.get_bit( msb - 1 ) )
    -- msb;

      if( numrep == SC_BIN_US ||
    numrep == SC_OCT_US ||
    numrep == SC_HEX_US )
    -- msb;

      lsb = ( b.m_lsw - b.m_wp ) * bits_in_word
    + scfx_find_lsb( b.m_mant[ b.m_lsw ] );
  }
    }

    int step;

    switch( numrep )
    {
  case SC_BIN:
  case SC_BIN_US:
  case SC_CSD:
      step = 1;
     break;
  case SC_OCT:
  case SC_OCT_US:
      step = 3;
      break;
  case SC_HEX:
  case SC_HEX_US:
      step = 4;
      break;
  default:
      step = 0;
    }

    msb = (int) ceil( double( msb + 1 ) / step ) * step - 1;

    lsb = (int) floor( double( lsb ) / step ) * step;

    if( msb < 0 )
    {
  s += '.';
  if( fmt == SC_F )
  {
      int sign = ( b.is_neg() ) ? ( 1 << step ) - 1 : 0;
      for( int i = ( msb + 1 ) / step; i < 0; i ++ )
      {
    if( sign < 10 )
        s += static_cast<char>( sign + '0' );
    else
        s += static_cast<char>( sign + 'a' - 10 );
      }
  }
    }

    int i = msb;
    while( i >= lsb )
    {
        int value = 0;
        for( int j = step - 1; j >= 0; -- j )
  {
            value += static_cast<int>( b.get_bit( i ) ) << j;
            -- i;
        }
        if( value < 10 )
            s += static_cast<char>( value + '0' );
  else
            s += static_cast<char>( value + 'a' - 10 );
  if( i == -1 )
      s += '.';
    }

    if( lsb > 0 && fmt == SC_F )
    {
  for( int i = lsb / step; i > 0; i -- )
      s += '0';
    }

    if( s[s.length() - 1] == '.' )
  s.discard( 1 );

    if( fmt != SC_F )
    {
  if( msb < 0 )
      scfx_print_exp( s, ( msb + 1 ) / step );
  else if( lsb > 0 )
      scfx_print_exp( s, lsb / step );
    }

    if( numrep == SC_CSD )
  scfx_tc2csd( s, w_prefix );
}

const char*
scfx_rep::to_string( sc_numrep numrep, int w_prefix,
         sc_fmt fmt, const scfx_params* params ) const
{
    static scfx_string s;

    s.clear();

    if( is_nan() )
        scfx_print_nan( s );
    else if( is_inf() )
        scfx_print_inf( s, is_neg() );
    else if( is_neg() && ! is_zero() &&
       ( numrep == SC_BIN_US ||
         numrep == SC_OCT_US ||
         numrep == SC_HEX_US ) )
        s += "negative";
    else if( numrep == SC_DEC )
        sc_dt::print_dec( s, *this, w_prefix, fmt );
    else
        sc_dt::print_other( s, *this, numrep, w_prefix, fmt, params );

    return s;
}


// ----------------------------------------------------------------------------
//  ADD
//
//  add two mantissas of the same size
//  result has the same size
//  returns carry of operation
// ----------------------------------------------------------------------------

static inline
int
add_mants( int size, scfx_mant& result,
     const scfx_mant& a, const scfx_mant& b )
{
    unsigned int carry = 0;

    int index = 0;

    do
    {
        word x = a[index];
  word y = b[index];

  y += carry;
  carry = y < carry;
  y += x;
  carry += y < x;
  result[index] = y;
    }
    while( ++ index < size );

    return ( carry ? 1 : 0 );
}


static inline
int
sub_mants( int size, scfx_mant& result,
     const scfx_mant& a, const scfx_mant& b )
{
    unsigned carry = 0;

    int index = 0;

    do
    {
  word x = a[index];
  word y = b[index];

  y += carry;
  carry = y < carry;
  y = x - y;
  carry += y > x;
  result[index] = y;
    }
    while( ++ index < size );

    return ( carry ? 1 : 0 );
}


scfx_rep*
add_scfx_rep( const scfx_rep& lhs, const scfx_rep& rhs, int max_wl )
{
    scfx_rep& result = *new scfx_rep;

    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan()
    ||  ( lhs.is_inf() && rhs.is_inf() && lhs.m_sign != rhs.m_sign ) )
    {
  result.set_nan();
  return &result;
    }

    if( lhs.is_inf() )
    {
  result.set_inf( lhs.m_sign );
  return &result;
    }

    if( rhs.is_inf() )
    {
  result.set_inf( rhs.m_sign );
  return &result;
    }

    //
    // align operands if needed
    //

    scfx_mant_ref lhs_mant;
    scfx_mant_ref rhs_mant;

    int len_mant = lhs.size();
    int new_wp = lhs.m_wp;

    align( lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant );

    //
    // size the result mantissa
    //

    result.resize_to( len_mant );
    result.m_wp = new_wp;

    //
    // do it
    //

    if( lhs.m_sign == rhs.m_sign )
    {
  add_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
  result.m_sign = lhs.m_sign;
    }
    else
    {
  int cmp = compare_abs( lhs, rhs );

  if( cmp == 1 )
  {
      sub_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
      result.m_sign = lhs.m_sign;
  }
  else if ( cmp == -1 )
  {
      sub_mants( len_mant, result.m_mant, rhs_mant, lhs_mant );
      result.m_sign = rhs.m_sign;
  }
  else
  {
      result.m_mant.clear();
      result.m_sign = 1;
  }
    }

    result.find_sw();
    result.round( max_wl );

    return &result;
}


// ----------------------------------------------------------------------------
//  SUB
//
//  sub two word's of the same size
//  result has the same size
//  returns carry of operation
// ----------------------------------------------------------------------------

static inline
int
sub_with_index(       scfx_mant& a, int a_msw, int a_lsw,
    const scfx_mant& b, int b_msw, int b_lsw )
{
    unsigned carry = 0;

    int size    = b_msw - b_lsw;
    int a_index = a_msw - size;
    int b_index = b_msw - size;

    do
    {
  word x = a[a_index];
  word y = b[b_index];

  y += carry;
  carry = y < carry;
  y = x - y;
  carry += y > x;
  a[a_index] = y;

  a_index ++;
  b_index ++;
    }
    while( size -- );

    if( carry )
    {
        // special case: a[a_msw + 1 ] == 1
        a[a_msw + 1] = 0;
    }

    return ( carry ? 1 : 0 );
}


scfx_rep*
sub_scfx_rep( const scfx_rep& lhs, const scfx_rep& rhs, int max_wl )
{
    scfx_rep& result = *new scfx_rep;

    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan()
    ||  ( lhs.is_inf() && rhs.is_inf() && lhs.m_sign == rhs.m_sign ) )
    {
  result.set_nan();
  return &result;
    }

    if( lhs.is_inf() )
    {
  result.set_inf( lhs.m_sign );
  return &result;
    }

    if( rhs.is_inf() )
    {
  result.set_inf( -1 * rhs.m_sign );
  return &result;
    }

    //
    // align operands if needed
    //

    scfx_mant_ref lhs_mant;
    scfx_mant_ref rhs_mant;

    int len_mant = lhs.size();
    int new_wp = lhs.m_wp;

    align( lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant );

    //
    // size the result mantissa
    //

    result.resize_to( len_mant );
    result.m_wp = new_wp;

    //
    // do it
    //

    if( lhs.m_sign != rhs.m_sign )
    {
  add_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
  result.m_sign = lhs.m_sign;
    }
    else
    {
  int cmp = compare_abs( lhs, rhs );

  if( cmp == 1 )
  {
      sub_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
      result.m_sign = lhs.m_sign;
  }
  else if ( cmp == -1 )
  {
      sub_mants( len_mant, result.m_mant, rhs_mant, lhs_mant );
      result.m_sign = -rhs.m_sign;
  } else {
      result.m_mant.clear();
      result.m_sign = 1;
  }
    }

    result.find_sw();
    result.round( max_wl );

    return &result;
}


// ----------------------------------------------------------------------------
//  MUL
// ----------------------------------------------------------------------------

union long_short
{
    word l;
    struct
    {
#if defined( SCFX_BIG_ENDIAN )
        half_word u;
        half_word l;
#elif defined( SCFX_LITTLE_ENDIAN )
        half_word l;
        half_word u;
#endif
    } s;
};


#if defined( SCFX_BIG_ENDIAN )
static const int half_word_incr = -1;
#elif defined( SCFX_LITTLE_ENDIAN )
static const int half_word_incr = 1;
#endif


void
multiply( scfx_rep& result, const scfx_rep& lhs, const scfx_rep& rhs,
    int max_wl )
{
    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan()
    ||  lhs.is_inf() && rhs.is_zero()
    ||  lhs.is_zero() && rhs.is_inf() )
    {
  result.set_nan();
  return;
    }

    if( lhs.is_inf() || rhs.is_inf() )
    {
  result.set_inf( lhs.m_sign * rhs.m_sign );
  return;
    }
    
    if( lhs.is_zero() || rhs.is_zero() ) {
  result.set_zero( lhs.m_sign * rhs.m_sign );
  return;
    }

    //
    // do it
    //

    int len_lhs = lhs.m_msw - lhs.m_lsw + 1;
    int len_rhs = rhs.m_msw - rhs.m_lsw + 1;

    int new_size = sc_max( min_mant, len_lhs + len_rhs );
    int new_wp   = ( lhs.m_wp - lhs.m_lsw ) + ( rhs.m_wp - rhs.m_lsw );
    int new_sign = lhs.m_sign * rhs.m_sign;

    result.resize_to( new_size );
    result.m_mant.clear();
    result.m_wp    = new_wp;
    result.m_sign  = new_sign;
    result.m_state = scfx_rep::normal;

    half_word *s1 = lhs.m_mant.half_addr( lhs.m_lsw );
    half_word *s2 = rhs.m_mant.half_addr( rhs.m_lsw );

    half_word *t = result.m_mant.half_addr();

    len_lhs <<= 1;
    len_rhs <<= 1;

    int i1, i2;

    for( i1 = 0; i1 * half_word_incr < len_lhs; i1 += half_word_incr )
    {
  register long_short ls;
  ls.l = 0;

  half_word v1 = s1[i1];

  for( i2  = 0; i2 * half_word_incr < len_rhs; i2 += half_word_incr )
  {
      ls.l  += v1 * s2[i2];
      ls.s.l = ls.s.u + ( ( t[i2] += ls.s.l ) < ls.s.l );
      ls.s.u = 0;
  }

  t[i2] = ls.s.l;
  t += half_word_incr;
    }

    result.find_sw();
    result.round( max_wl );
}


// ----------------------------------------------------------------------------
//  DIV
// ----------------------------------------------------------------------------

scfx_rep*
div_scfx_rep( const scfx_rep& lhs, const scfx_rep& rhs, int div_wl )
{
    scfx_rep& result = *new scfx_rep;

    //
    // check for special cases
    //

    if( lhs.is_nan() || rhs.is_nan() || lhs.is_inf() && rhs.is_inf() ||
  lhs.is_zero() && rhs.is_zero() )
    {
  result.set_nan();
  return &result;
    }

    if( lhs.is_inf() || rhs.is_zero() )
    {
  result.set_inf( lhs.m_sign * rhs.m_sign );
  return &result;
    }

    if( lhs.is_zero() || rhs.is_inf() )
    {
  result.set_zero( lhs.m_sign * rhs.m_sign );
  return &result;
    }

    //
    // do it
    //

    // compute one bit more for rounding
    div_wl ++;

    result.resize_to( sc_max( n_word( div_wl ) + 1, min_mant ) );
    result.m_mant.clear();
    result.m_sign = lhs.m_sign * rhs.m_sign;

    int msb_lhs = scfx_find_msb( lhs.m_mant[lhs.m_msw] )
          + ( lhs.m_msw - lhs.m_wp ) * bits_in_word;
    int msb_rhs = scfx_find_msb( rhs.m_mant[rhs.m_msw] )
          + ( rhs.m_msw - rhs.m_wp ) * bits_in_word;

    int msb_res = msb_lhs - msb_rhs;
    int to_shift = -msb_res % bits_in_word;
    int result_index;

    int c = ( msb_res % bits_in_word >= 0 ) ? 1 : 0;

    result_index = (result.size() - c) * bits_in_word + msb_res % bits_in_word;
    result.m_wp   = (result.size() - c) - msb_res / bits_in_word;

    scfx_rep remainder = lhs;

    // align msb from remainder to msb from rhs
    remainder.lshift( to_shift );

    // make sure msw( remainder ) < size - 1
    if( remainder.m_msw == remainder.size() - 1 )
  remainder.resize_to( remainder.size() + 1, 1 );

    // make sure msw( remainder ) >= msw( rhs )!
    int msw_diff = rhs.m_msw - remainder.m_msw;
    if (msw_diff > 0)
  remainder.resize_to( remainder.size() + msw_diff, -1 );

    int counter;

    for( counter = div_wl; counter && ! remainder.is_zero(); counter -- )
    {
  if( compare_msw_ff( rhs, remainder ) <= 0 )
  {
      result.set_bin( result_index );
      sub_with_index( remainder.m_mant, remainder.m_msw, remainder.m_lsw,
          rhs.m_mant, rhs.m_msw, rhs.m_lsw );
  }
  result_index --;
  remainder.shift_left( 1 );
        remainder.m_lsw = remainder.find_lsw();
    }

    // perform convergent rounding, if needed
    if( counter == 0 )
    {
  int index = result_index + 1 - result.m_wp * bits_in_word;

  scfx_index x = result.calc_indices( index );
  scfx_index x1 = result.calc_indices( index + 1 );

  if( result.o_bit_at( x ) && result.o_bit_at( x1 ) )
      result.q_incr( x );

  result.m_r_flag = true;
    }

    result.find_sw();

    return &result;
}


// ----------------------------------------------------------------------------
//  destructive shift mantissa to the left
// ----------------------------------------------------------------------------

void
scfx_rep::lshift( int n )
{
    if( n == 0 )
        return;

    if( n < 0 )
    {
        rshift( -n );
  return;
    }

    if( is_normal() )
    {
        int shift_bits  = n % bits_in_word;
  int shift_words = n / bits_in_word;

  // resize if needed
  if( m_msw == size() - 1 &&
      scfx_find_msb( m_mant[m_msw] ) >= bits_in_word - shift_bits )
      resize_to( size() + 1, 1 );

  // do it
  m_wp -= shift_words;
  shift_left( shift_bits );
  find_sw();
    }
}


// ----------------------------------------------------------------------------
//  destructive shift mantissa to the right
// ----------------------------------------------------------------------------

void
scfx_rep::rshift( int n )
{
    if( n == 0 )
        return;

    if( n < 0 )
    {
        lshift( -n );
  return;
    }

    if( is_normal() )
    {
        int shift_bits  = n % bits_in_word;
  int shift_words = n / bits_in_word;

  // resize if needed
  if( m_lsw == 0 && scfx_find_lsb( m_mant[m_lsw] ) < shift_bits )
      resize_to( size() + 1, -1 );

  // do it
  m_wp += shift_words;
  shift_right( shift_bits );
  find_sw();
    }
}


// ----------------------------------------------------------------------------
//  FRIEND FUNCTION : compare_abs
//
//  Compares the absolute values of two scfx_reps, excluding the special cases.
// ----------------------------------------------------------------------------

int
compare_abs( const scfx_rep& a, const scfx_rep& b )
{
    // check for zero

    word a_word = a.m_mant[a.m_msw];
    word b_word = b.m_mant[b.m_msw];
  
    if( a_word == 0 || b_word == 0 )
    {
  if( a_word != 0 )
      return 1;
  if( b_word != 0 )
      return -1;
  return 0;
    }

    // compare msw index

    int a_msw = a.m_msw - a.m_wp;
    int b_msw = b.m_msw - b.m_wp;

    if( a_msw > b_msw )
  return 1;

    if( a_msw < b_msw )
  return -1;

    // compare content

    int a_i = a.m_msw;
    int b_i = b.m_msw;

    while( a_i >= a.m_lsw && b_i >= b.m_lsw )
    {
  a_word = a.m_mant[a_i];
  b_word = b.m_mant[b_i];
  if( a_word > b_word )
      return 1;
  if( a_word < b_word )
      return -1;
  -- a_i;
  -- b_i;
    }

    bool a_zero = true;
    while( a_i >= a.m_lsw )
    {
  a_zero = a_zero && ( a.m_mant[a_i] == 0 );
  -- a_i;
    }
  
    bool b_zero = true;
    while( b_i >= b.m_lsw )
    {
  b_zero = b_zero && ( b.m_mant[b_i] == 0 );
  -- b_i;
    }

    // assertion: a_zero || b_zero == true

    if( ! a_zero && b_zero )
  return 1;

    if( a_zero && ! b_zero )
  return -1;

    return 0;
}


// ----------------------------------------------------------------------------
//  FRIEND FUNCTION : cmp_scfx_rep
//
//  Compares the values of two scfx_reps, including the special cases.
// ----------------------------------------------------------------------------

int
cmp_scfx_rep( const scfx_rep& a, const scfx_rep& b )
{
    // handle special cases

    if( a.is_nan() || b.is_nan() )
    {
#if 0
  if( a.is_nan() && b.is_nan() )
  {
      return 0;
  }
#endif
  return 2;
    }

    if( a.is_inf() || b.is_inf() )
    {
  if( a.is_inf() )
  {
      if( ! a.is_neg() )
      {
    if( b.is_inf() && ! b.is_neg() )
    {
        return 0;
    }
    else
    {
        return 1;
    }
      }
      else
      {
    if( b.is_inf() && b.is_neg() )
    {
        return 0;
    }
    else
    {
        return -1;
    }
      }
  }
  if( b.is_inf() )
  {
      if( ! b.is_neg() )
      {
    return -1;
      }
      else
      {
    return 1;
      }
  }
    }
  
    if( a.is_zero() && b.is_zero() )
    {
  return 0;
    }

    // compare sign

    if( a.m_sign != b.m_sign )
    {
  return a.m_sign;
    }

    return ( a.m_sign * compare_abs( a, b ) );
}


// ----------------------------------------------------------------------------
//  PRIVATE METHOD : quantization
//
//  Performs destructive quantization.
// ----------------------------------------------------------------------------

void
scfx_rep::quantization( const scfx_params& params, bool& q_flag )
{
    scfx_index x = calc_indices( params.iwl() - params.wl() );

    if( x.wi() < 0 )
        return;

    if( x.wi() >= size() )
        resize_to( x.wi() + 1, 1 );

    bool qb = q_bit( x );
    bool qz = q_zero( x );

    q_flag = ( qb || ! qz );

    if( q_flag )
    {
        switch( params.q_mode() )
  {
            case SC_TRN:      // truncation
      {
          if( is_neg() )
        q_incr( x );
    break;
      }
            case SC_RND:      // rounding to plus infinity
      {
          if( ! is_neg() )
    {
        if( qb )
      q_incr( x );
    }
    else
    {
        if( qb && ! qz )
      q_incr( x );
    }
    break;
      }
            case SC_TRN_ZERO:     // truncation to zero
      {
          break;
      }
            case SC_RND_INF:      // rounding to infinity
      {
          if( qb )
        q_incr( x );
    break;
      }
            case SC_RND_CONV:     // convergent rounding
      {
    if( qb && ! qz || qb && qz && q_odd( x ) )
        q_incr( x );
    break;
      }
            case SC_RND_ZERO:     // rounding to zero
      {
    if( qb && ! qz )
        q_incr( x );
    break;
      }
            case SC_RND_MIN_INF:    // rounding to minus infinity
      {
    if( ! is_neg() )
    {
        if( qb && ! qz )
      q_incr( x );
    }
    else
    {
        if( qb )
      q_incr( x );
    }
    break;
      }
            default:
          ;
  }
  q_clear( x );
  
  find_sw();
    }
}


// ----------------------------------------------------------------------------
//  PRIVATE METHOD : overflow
//
//  Performs destructive overflow handling.
// ----------------------------------------------------------------------------

void
scfx_rep::overflow( const scfx_params& params, bool& o_flag )
{
    scfx_index x = calc_indices( params.iwl() - 1 );

    if( x.wi() >= size() )
        resize_to( x.wi() + 1, 1 );

    if( x.wi() < 0 )
    {
        resize_to( size() - x.wi(), -1 );
        x.wi( 0 );
    }

    bool zero_left = o_zero_left( x );
    bool bit_at = o_bit_at( x );
    bool zero_right = o_zero_right( x );

    bool under = false;
    bool over = false;

    sc_enc enc = params.enc();

    if( enc == SC_TC_ )
    {
  if( is_neg() )
  {
      if( params.o_mode() == SC_SAT_SYM )
    under = ( ! zero_left || bit_at );
      else
    under = ( ! zero_left || zero_left && bit_at && ! zero_right );
  }
  else
      over = ( ! zero_left || bit_at );
    }
    else
    {
  if( is_neg() )
      under = ( ! is_zero() );
        else
      over = ( ! zero_left );
    }

    o_flag = ( under || over );

    if( o_flag )
    {
  scfx_index x2 = calc_indices( params.iwl() - params.wl() );

  if( x2.wi() < 0 )
  {
      resize_to( size() - x2.wi(), -1 );
      x.wi( x.wi() - x2.wi() );
      x2.wi( 0 );
  }

  switch( params.o_mode() )
  {
            case SC_WRAP:     // wrap-around
      {
    int n_bits = params.n_bits();

    if( n_bits == 0 )
    {
        // wrap-around all 'wl' bits
        toggle_tc();
        o_extend( x, enc );
        toggle_tc();
    }
    else if( n_bits < params.wl() )
    {
        scfx_index x3 = calc_indices( params.iwl() - 1 - n_bits );

        // wrap-around least significant 'wl - n_bits' bits;
        // saturate most significant 'n_bits' bits
        toggle_tc();
        o_set( x, x3, enc, under );
        o_extend( x, enc );
        toggle_tc();
    }
    else
    {
        // saturate all 'wl' bits