datatypes/int/sc_nbcommon.inc

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

  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
  more contributor license agreements.  See the NOTICE file distributed
  with this work for additional information regarding copyright ownership.
  Accellera licenses this file to you under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with the
  License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  implied.  See the License for the specific language governing
  permissions and limitations under the License.

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

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

  sc_nbcommon.cpp -- Functions common to both sc_signed and sc_unsigned.
                     This file is included in sc_signed.cpp and
                     sc_unsigned.cpp after the macros are defined accordingly.
                     For example, sc_signed.cpp will first define CLASS_TYPE
                     as sc_signed before including this file. This file like
                     sc_nbfriends.cpp and sc_nbexterns.cpp is created in order
                     to ensure only one version of each function, regardless
                     of the class that they interface to.

  Original Author: Ali Dasdan, Synopsys, Inc.

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

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

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

      Name, Affiliation, Date:
  Description of Modification:

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


// ----------------------------------------------------------------------------
//  SECTION : Public members
// ----------------------------------------------------------------------------

// Create a CLASS_TYPE number with nb bits.
CLASS_TYPE::CLASS_TYPE( int nb ) :
    sc_value_base(), sgn(), nbits(), ndigits(), digit()
{
    sgn = default_sign();
    if( nb > 0 ) {
	nbits = num_bits( nb );
    } else {
        invalid_init( "int nb", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#ifdef SC_MAX_NBITS
    test_bound(nb);
#else
    digit = new sc_digit[ndigits];
#endif
    makezero();
}


// Create a copy of v with sgn s. v is of the same type.
CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE& v) :
    sc_value_base(v), sgn(v.sgn), nbits(v.nbits), ndigits(v.ndigits), digit()
{
#ifndef SC_MAX_NBITS
  digit = new sc_digit[ndigits];
#endif

  vec_copy(ndigits, digit, v.digit);
}


// Create a copy of v where v is of the different type.
CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE& v) :
    sc_value_base(v), sgn(v.sgn), nbits(num_bits(v.nbits)), ndigits(), digit()
{
#if (IF_SC_SIGNED == 1)
  ndigits = v.ndigits;
#else
  ndigits = DIV_CEIL(nbits);
#endif

#ifndef SC_MAX_NBITS
  digit = new sc_digit[ndigits];
#endif

  copy_digits(v.nbits, v.ndigits, v.digit);
}

// Create a copy of v where v is an sign-less instance.
CLASS_TYPE::CLASS_TYPE(const sc_bv_base& v) :
    sc_value_base(), sgn(), nbits(), ndigits(), digit()
{
    int nb = v.length();
    sgn = default_sign();
    if( nb > 0 ) {
        nbits = num_bits( nb );
    } else {
        invalid_init( "sc_bv_base", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#   ifdef SC_MAX_NBITS
        test_bound(nb);
#    else
        digit = new sc_digit[ndigits];
#    endif
    makezero();
    *this = v;
}

CLASS_TYPE::CLASS_TYPE(const sc_lv_base& v) :
    sc_value_base(), sgn(), nbits(), ndigits(), digit()
{
    int nb = v.length();
    sgn = default_sign();
    if( nb > 0 ) {
        nbits = num_bits( nb );
    } else {
        invalid_init( "sc_lv_base", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#   ifdef SC_MAX_NBITS
        test_bound(nb);
#    else
        digit = new sc_digit[ndigits];
#    endif
    makezero();
    *this = v;
}

CLASS_TYPE::CLASS_TYPE(const sc_int_subref_r& v) :
    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
{
    int nb = v.length();
    sgn = default_sign();
    if( nb > 0 ) {
        nbits = num_bits( nb );
    } else {
        invalid_init( "sc_int_subref", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#   ifdef SC_MAX_NBITS
        test_bound(nb);
#    else
        digit = new sc_digit[ndigits];
#    endif
    makezero();
    *this = v.to_uint64();
}

CLASS_TYPE::CLASS_TYPE(const sc_uint_subref_r& v) :
    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
{
    int nb = v.length();
    sgn = default_sign();
    if( nb > 0 ) {
        nbits = num_bits( nb );
    } else {
        invalid_init( "sc_uint_subref", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#   ifdef SC_MAX_NBITS
        test_bound(nb);
#    else
        digit = new sc_digit[ndigits];
#    endif
    makezero();
    *this = v.to_uint64();
}

CLASS_TYPE::CLASS_TYPE(const sc_signed_subref_r& v) :
    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
{
    int nb = v.length();
    sgn = default_sign();
    if( nb > 0 ) {
        nbits = num_bits( nb );
    } else {
        invalid_init( "sc_signed_subref", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#   ifdef SC_MAX_NBITS
        test_bound(nb);
#    else
        digit = new sc_digit[ndigits];
#    endif
    makezero();
    *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
}

CLASS_TYPE::CLASS_TYPE(const sc_unsigned_subref_r& v) :
    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
{
    int nb = v.length();
    sgn = default_sign();
    if( nb > 0 ) {
        nbits = num_bits( nb );
    } else {
        invalid_init( "sc_unsigned_subref", nb );
        sc_core::sc_abort(); // can't recover from here
    }
    ndigits = DIV_CEIL(nbits);
#   ifdef SC_MAX_NBITS
        test_bound(nb);
#    else
        digit = new sc_digit[ndigits];
#    endif
    makezero();
    *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
}

// ----------------------------------------------------------------------------
//  SECTION: Public members - Concatenation support.
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
//  SECTION: Public members - Assignment operators.
// ----------------------------------------------------------------------------

// Assignment from v of the same type.
const CLASS_TYPE&
CLASS_TYPE::operator=(const CLASS_TYPE& v)
{
  if (this != &v) {

    sgn = v.sgn;

    if (sgn == SC_ZERO)
      vec_zero(ndigits, digit);

    else
      copy_digits(v.nbits, v.ndigits, v.digit);

  }

  return *this;
}


// Assignment from v of the different type.
const CLASS_TYPE&
CLASS_TYPE::operator=(const OTHER_CLASS_TYPE& v)
{
  sgn = v.sgn;

  if (sgn == SC_ZERO)
    vec_zero(ndigits, digit);

  else
    copy_digits(v.nbits, v.ndigits, v.digit);

  return *this;
}


// Assignment from an sc_unsigned_subref_r
const CLASS_TYPE&
CLASS_TYPE::operator=(const sc_unsigned_subref_r& v)
{
  return operator=(sc_unsigned(v));
}


// Assignment from an sc_signed_subref_r
const CLASS_TYPE&
CLASS_TYPE::operator=(const sc_signed_subref_r& v)
{
  return operator=(sc_unsigned(v));
}


// ----------------------------------------------------------------------------
//  SECTION: Input and output operators
// ----------------------------------------------------------------------------

void
CLASS_TYPE::scan( ::std::istream& is )
{
    std::string s;
    is >> s;
    *this = s.c_str();
}


// ----------------------------------------------------------------------------
//  SECTION: PLUS operators: +, +=, ++
// ----------------------------------------------------------------------------

// Cases to consider when computing u + v:
// 1. 0 + v = v
// 2. u + 0 = u
// 3. if sgn(u) == sgn(v)
//    3.1 u + v = +(u + v) = sgn(u) * (u + v)
//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
// 4. if sgn(u) != sgn(v)
//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
//
// Specialization of above cases for computing ++u or u++:
// 1. 0 + 1 = 1
// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)

const CLASS_TYPE&
CLASS_TYPE::operator+=(const CLASS_TYPE& v)
{
  // u = *this

  if (sgn == SC_ZERO) // case 1
    return (*this = v);

  if (v.sgn == SC_ZERO) // case 2
    return *this;

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              v.sgn, v.nbits, v.ndigits, v.digit);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator+=(const OTHER_CLASS_TYPE& v)
{
  // u = *this

  if (sgn == SC_ZERO) // case 1
    return (*this = v);

  if (v.sgn == SC_ZERO) // case 2
    return *this;

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              v.sgn, v.nbits, v.ndigits, v.digit);

  convert_SM_to_2C_to_SM();

  return *this;
}


CLASS_TYPE&
CLASS_TYPE::operator++() // prefix
{
    *this = *this + 1;
    return *this;
}


const CLASS_TYPE
CLASS_TYPE::operator++(int) // postfix
{
  // Copy digit into d.

#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[ndigits];
#endif

  small_type s = sgn;

  vec_copy(ndigits, d, digit);

  *this = *this + 1;

  return CLASS_TYPE(s, nbits, ndigits, d);
}


const CLASS_TYPE&
CLASS_TYPE::operator+=(int64 v)
{
  // u = *this

  if (sgn == SC_ZERO)  // case 1
    return (*this = v);

  if (v == 0) // case 2
    return *this;

  CONVERT_INT64(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator+=(uint64 v)
{
  // u = *this

  if (sgn == SC_ZERO)  // case 1
    return (*this = v);

  if (v == 0)  // case 2
    return *this;

  CONVERT_INT64(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator+=(long v)
{
  // u = *this

  if (sgn == SC_ZERO)  // case 1
    return (*this = v);

  if (v == 0) // case 2
    return *this;

  CONVERT_LONG(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator+=(unsigned long v)
{
  // u = *this

  if (sgn == SC_ZERO)  // case 1
    return (*this = v);

  if (v == 0)  // case 2
    return *this;

  CONVERT_LONG(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: MINUS operators: -, -=, --
// ----------------------------------------------------------------------------

// Cases to consider when computing u + v:
// 1. u - 0 = u
// 2. 0 - v = -v
// 3. if sgn(u) != sgn(v)
//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
// 4. if sgn(u) == sgn(v)
//    4.1 u - v = +(u - v) = sgn(u) * (u - v)
//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
//
// Specialization of above cases for computing --u or u--:
// 1. 0 - 1 = -1
// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
// 4. u - 1 = u - 1 = sgn(u) * (u - 1)

const CLASS_TYPE&
CLASS_TYPE::operator-=(const CLASS_TYPE& v)
{
  // u = *this

  if (v.sgn == SC_ZERO)  // case 1
    return *this;

  if (sgn == SC_ZERO) { // case 2

    sgn = -v.sgn;
    copy_digits(v.nbits, v.ndigits, v.digit);

  }
  else {

    // cases 3 and 4
    add_on_help(sgn, nbits, ndigits, digit,
                -v.sgn, v.nbits, v.ndigits, v.digit);

    convert_SM_to_2C_to_SM();

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator-=(const OTHER_CLASS_TYPE& v)
{
  // u = *this

  if (v.sgn == SC_ZERO)  // case 1
    return *this;

  if (sgn == SC_ZERO) { // case 2

    sgn = -v.sgn;
    copy_digits(v.nbits, v.ndigits, v.digit);

  }
  else {

    // cases 3 and 4
    add_on_help(sgn, nbits, ndigits, digit,
                -v.sgn, v.nbits, v.ndigits, v.digit);

    convert_SM_to_2C_to_SM();

  }

  return *this;
}


CLASS_TYPE&
CLASS_TYPE::operator--() // prefix
{
    *this = *this - 1;
    return *this;
}


const CLASS_TYPE
CLASS_TYPE::operator--(int) // postfix
{
  // Copy digit into d.

#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[ndigits];
#endif

  small_type s = sgn;

  vec_copy(ndigits, d, digit);

  *this = *this - 1;

  return CLASS_TYPE(s, nbits, ndigits, d);
}


const CLASS_TYPE&
CLASS_TYPE::operator-=(int64 v)
{
  // u = *this

  if (v == 0) // case 1
    return *this;

  if (sgn == SC_ZERO) // case 2
    return (*this = -v);

  CONVERT_INT64(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator-=(uint64 v)
{
  // u = *this

  if (v == 0) // case 1
    return *this;

  int64 v2 = (int64) v;

  if (sgn == SC_ZERO) // case 2
    return (*this = -v2);

  CONVERT_INT64(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator-=(long v)
{
  // u = *this

  if (v == 0) // case 1
    return *this;

  if (sgn == SC_ZERO) // case 2
    return (*this = -v);

  CONVERT_LONG(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator-=(unsigned long v)
{
  // u = *this

  if (v == 0) // case 1
    return *this;

  long v2 = (long) v;

  if (sgn == SC_ZERO) // case 2
    return (*this = -v2);

  CONVERT_LONG(v);

  // cases 3 and 4
  add_on_help(sgn, nbits, ndigits, digit,
              -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_SM_to_2C_to_SM();

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: MULTIPLICATION operators: *, *=
// ----------------------------------------------------------------------------

// Cases to consider when computing u * v:
// 1. u * 0 = 0 * v = 0
// 2. 1 * v = v and -1 * v = -v
// 3. u * 1 = u and u * -1 = -u
// 4. u * v = u * v

const CLASS_TYPE&
CLASS_TYPE::operator*=(const CLASS_TYPE& v)
{
  // u = *this

  sgn = mul_signs(sgn, v.sgn);

  if (sgn == SC_ZERO) // case 1
    vec_zero(ndigits, digit);

  else
    // cases 2-4
    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
                  v.nbits, v.ndigits, v.digit);

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator*=(const OTHER_CLASS_TYPE& v)
{
  // u = *this

  sgn = mul_signs(sgn, v.sgn);

  if (sgn == SC_ZERO) // case 1
    vec_zero(ndigits, digit);

  else
    // cases 2-4
    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
                  v.nbits, v.ndigits, v.digit);

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator*=(int64 v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) // case 1
    vec_zero(ndigits, digit);

  else {  // cases 2-4

    CONVERT_INT64_2(v);

    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator*=(uint64 v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) // case 1
    vec_zero(ndigits, digit);

  else { // cases 2-4

    CONVERT_INT64_2(v);

    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator*=(long v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) // case 1
    vec_zero(ndigits, digit);

  else {   // cases 2-4

    CONVERT_LONG_2(v);

    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator*=(unsigned long v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) // case 1
    vec_zero(ndigits, digit);

  else {  // cases 2-4

    CONVERT_LONG_2(v);

    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  }

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: DIVISION operators: /, /=
// ----------------------------------------------------------------------------

// Cases to consider when finding the quotient q = floor(u/v):
// Note that u = q * v + r for r < q.
// 1. 0 / 0 or u / 0 => error
// 2. 0 / v => 0 = 0 * v + 0
// 3. u / v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
// 4. u / v && u < v => u = 0 * v + u  - u can be 1 or -1
// 5. u / v && u > v => u = q * v + r  - v can be 1 or -1

const CLASS_TYPE&
CLASS_TYPE::operator/=(const CLASS_TYPE& v)
{
  sgn = mul_signs(sgn, v.sgn);

  if (sgn == SC_ZERO) {

    div_by_zero(v.sgn); // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else  // other cases
    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
                  v.nbits, v.ndigits, v.digit);

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator/=(const OTHER_CLASS_TYPE& v)
{
  sgn = mul_signs(sgn, v.sgn);

  if (sgn == SC_ZERO) {

    div_by_zero(v.sgn); // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else  // other cases
    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
                  v.nbits, v.ndigits, v.digit);

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator/=(int64 v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit); // case 2

  }
  else {

    CONVERT_INT64_2(v);

    // other cases
    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator/=(uint64 v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else {

    CONVERT_INT64_2(v);

    // other cases
    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator/=(long v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit); // case 2

  }
  else {

    CONVERT_LONG_2(v);

    // other cases
    DIV_ON_HELPER(sgn,  nbits, ndigits, digit,
                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator/=(unsigned long v)
{
  // u = *this

  sgn = mul_signs(sgn, get_sign(v));

  if (sgn == SC_ZERO) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else {

    CONVERT_LONG_2(v);

    // other cases
    DIV_ON_HELPER(sgn,  nbits, ndigits, digit,
                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  }

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: MOD operators: %, %=.
// ----------------------------------------------------------------------------

// Cases to consider when finding the remainder r = u % v:
// Note that u = q * v + r for r < q.
// 1. 0 % 0 or u % 0 => error
// 2. 0 % v => 0 = 0 * v + 0
// 3. u % v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
// 4. u % v && u < v => u = 0 * v + u  - u can be 1 or -1
// 5. u % v && u > v => u = q * v + r  - v can be 1 or -1

const CLASS_TYPE&
CLASS_TYPE::operator%=(const CLASS_TYPE& v)
{
  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {

    div_by_zero(v.sgn);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else // other cases
    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
                  v.nbits, v.ndigits, v.digit);

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator%=(const OTHER_CLASS_TYPE& v)
{
  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {

    div_by_zero(v.sgn);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else  // other cases
    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
                  v.nbits, v.ndigits, v.digit);

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator%=(int64 v)
{
  small_type vs = get_sign(v);

  if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else {

    CONVERT_INT64_2(v);

    // other cases
    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator%=(uint64 v)
{
  if ((sgn == SC_ZERO) || (v == 0)) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else {

    CONVERT_INT64_2(v);

    // other cases
    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator%=(long v)
{
  small_type vs = get_sign(v);

  if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else {

    CONVERT_LONG_2(v);

    // other cases
    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator%=(unsigned long v)
{
  if ((sgn == SC_ZERO) || (v == 0)) {

    div_by_zero(v);  // case 1
    vec_zero(ndigits, digit);  // case 2

  }
  else {

    CONVERT_LONG_2(v);

    // other cases
    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  }

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: Bitwise AND operators: &, &=
// ----------------------------------------------------------------------------

// Cases to consider when computing u & v:
// 1. u & 0 = 0 & v = 0
// 2. u & v => sgn = +
// 3. (-u) & (-v) => sgn = -
// 4. u & (-v) => sgn = +
// 5. (-u) & v => sgn = +

const CLASS_TYPE&
CLASS_TYPE::operator&=(const CLASS_TYPE& v)
{
  // u = *this

  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
    makezero();

  else  {  // other cases

    and_on_help(sgn, nbits, ndigits, digit,
                v.sgn, v.nbits, v.ndigits, v.digit);

    convert_2C_to_SM();

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator&=(const OTHER_CLASS_TYPE& v)
{
  // u = *this

  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
    makezero();

  else {  // other cases

    and_on_help(sgn, nbits, ndigits, digit,
                v.sgn, v.nbits, v.ndigits, v.digit);

    convert_2C_to_SM();

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator&=(int64 v)
{
  // u = *this

  if ((sgn == SC_ZERO) || (v == 0)) // case 1
    makezero();

  else {    // other cases

    CONVERT_INT64(v);

    and_on_help(sgn, nbits, ndigits, digit,
                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

    convert_2C_to_SM();

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator&=(uint64 v)
{
  // u = *this

  if ((sgn == SC_ZERO) || (v == 0))  // case 1
    makezero();

  else {  // other cases

    CONVERT_INT64(v);

    and_on_help(sgn, nbits, ndigits, digit,
                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

    convert_2C_to_SM();

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator&=(long v)
{
  // u = *this

  if ((sgn == SC_ZERO) || (v == 0))  // case 1
    makezero();

  else {      // other cases

    CONVERT_LONG(v);

    and_on_help(sgn, nbits, ndigits, digit,
                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

    convert_2C_to_SM();

  }

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator&=(unsigned long v)
{
  // u = *this

  if ((sgn == SC_ZERO) || (v == 0))  // case 1
    makezero();

  else {  // other cases

    CONVERT_LONG(v);

    and_on_help(sgn, nbits, ndigits, digit,
                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

    convert_2C_to_SM();

  }

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: Bitwise OR operators: |, |=
// ----------------------------------------------------------------------------

// Cases to consider when computing u | v:
// 1. u | 0 = u
// 2. 0 | v = v
// 3. u | v => sgn = +
// 4. (-u) | (-v) => sgn = -
// 5. u | (-v) => sgn = -
// 6. (-u) | v => sgn = -

const CLASS_TYPE&
CLASS_TYPE::operator|=(const CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases
  or_on_help(sgn, nbits, ndigits, digit,
             v.sgn, v.nbits, v.ndigits, v.digit);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator|=(const OTHER_CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases
  or_on_help(sgn, nbits, ndigits, digit,
             v.sgn, v.nbits, v.ndigits, v.digit);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator|=(int64 v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_INT64(v);

  or_on_help(sgn, nbits, ndigits, digit,
             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator|=(uint64 v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_INT64(v);

  or_on_help(sgn, nbits, ndigits, digit,
             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator|=(long v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_LONG(v);

  or_on_help(sgn, nbits, ndigits, digit,
             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator|=(unsigned long v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_LONG(v);

  or_on_help(sgn, nbits, ndigits, digit,
             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_2C_to_SM();

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: Bitwise XOR operators: ^, ^=
// ----------------------------------------------------------------------------

// Cases to consider when computing u ^ v:
// Note that  u ^ v = (~u & v) | (u & ~v).
// 1. u ^ 0 = u
// 2. 0 ^ v = v
// 3. u ^ v => sgn = +
// 4. (-u) ^ (-v) => sgn = -
// 5. u ^ (-v) => sgn = -
// 6. (-u) ^ v => sgn = +

const CLASS_TYPE&
CLASS_TYPE::operator^=(const CLASS_TYPE& v)
{
  // u = *this

  if (v.sgn == SC_ZERO)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases
  xor_on_help(sgn, nbits, ndigits, digit,
              v.sgn, v.nbits, v.ndigits, v.digit);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator^=(const OTHER_CLASS_TYPE& v)
{
  // u = *this

  if (v.sgn == SC_ZERO)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases
  xor_on_help(sgn, nbits, ndigits, digit,
              v.sgn, v.nbits, v.ndigits, v.digit);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator^=(int64 v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_INT64(v);

  xor_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator^=(uint64 v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_INT64(v);

  xor_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator^=(long v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_LONG(v);

  xor_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_2C_to_SM();

  return *this;
}


const CLASS_TYPE&
CLASS_TYPE::operator^=(unsigned long v)
{
  if (v == 0)  // case 1
    return *this;

  if (sgn == SC_ZERO)  // case 2
    return (*this = v);

  // other cases

  CONVERT_LONG(v);

  xor_on_help(sgn, nbits, ndigits, digit,
              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);

  convert_2C_to_SM();

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: Bitwise NOT operator: ~
// ----------------------------------------------------------------------------

CLASS_TYPE
operator~(const CLASS_TYPE& u)
{
  small_type s = u.sgn;

  if (s == SC_ZERO) {

    sc_digit d = 1;
    return CLASS_TYPE(SC_NEG, u.nbits, 1, &d, false);

  }

  int nd = u.ndigits;

#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[nd];
#endif

  vec_copy(nd, d, u.digit);

  if (s == SC_POS) {

    s = SC_NEG;
    vec_add_small_on(nd, d, 1);

  }
  else {

    s = SC_POS;
    vec_sub_small_on(nd, d, 1);

    if (check_for_zero(nd, d))
      s = SC_ZERO;

  }

  return CLASS_TYPE(s, u.nbits, nd, d);
}


// ----------------------------------------------------------------------------
//  SECTION: LEFT SHIFT operators: <<, <<=
// ----------------------------------------------------------------------------

CLASS_TYPE
operator<<(const CLASS_TYPE& u, const CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)
    return CLASS_TYPE(u);

#ifdef SC_SIGNED
  if (v.sgn == SC_NEG)
    return CLASS_TYPE(u);
#endif

  return operator<<(u, v.to_ulong());
}


const CLASS_TYPE&
CLASS_TYPE::operator<<=(const CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)
    return *this;

#ifdef SC_SIGNED
  if (v.sgn == SC_NEG)
    return *this;
#endif

  return operator<<=(v.to_ulong());
}


const CLASS_TYPE&
CLASS_TYPE::operator<<=(const OTHER_CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)
    return *this;

#ifdef SC_UNSIGNED
  if (v.sgn == SC_NEG)
    return *this;
#endif

  return operator<<=(v.to_ulong());
}


CLASS_TYPE
operator<<(const CLASS_TYPE& u, int64 v)
{
  if (v <= 0)
    return CLASS_TYPE(u);

  return operator<<(u, (unsigned long) v);
}


CLASS_TYPE
operator<<(const CLASS_TYPE& u, uint64 v)
{
  if (v == 0)
    return CLASS_TYPE(u);

  return operator<<(u, (unsigned long) v);
}


const CLASS_TYPE&
CLASS_TYPE::operator<<=(int64 v)
{
  if (v <= 0)
    return *this;

  return operator<<=((unsigned long) v);
}


const CLASS_TYPE&
CLASS_TYPE::operator<<=(uint64 v)
{
  if (v == 0)
    return *this;

  return operator<<=((unsigned long) v);
}


CLASS_TYPE
operator<<(const CLASS_TYPE& u, long v)
{
  if (v <= 0)
    return CLASS_TYPE(u);

  return operator<<(u, (unsigned long) v);
}

CLASS_TYPE
operator<<(const CLASS_TYPE& u, unsigned long v)
{
  if (v == 0)
    return CLASS_TYPE(u);

  if (u.sgn == SC_ZERO)
    return CLASS_TYPE(u);

  int nb = u.nbits + v;
  int nd = DIV_CEIL(nb);

#ifdef SC_MAX_NBITS
  test_bound(nb);
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[nd];
#endif

  vec_copy_and_zero(nd, d, u.ndigits, u.digit);

  convert_SM_to_2C(u.sgn, nd, d);

  vec_shift_left(nd, d, v);

  small_type s = convert_signed_2C_to_SM(nb, nd, d);

  return CLASS_TYPE(s, nb, nd, d);
}


const CLASS_TYPE&
CLASS_TYPE::operator<<=(long v)
{
  if (v <= 0)
    return *this;

  return operator<<=((unsigned long) v);
}


const CLASS_TYPE&
CLASS_TYPE::operator<<=(unsigned long v)
{
  if (v == 0)
    return *this;

  if (sgn == SC_ZERO)
    return *this;

  convert_SM_to_2C();

  vec_shift_left(ndigits, digit, v);

  convert_2C_to_SM();

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: RIGHT SHIFT operators: >>, >>=
// ----------------------------------------------------------------------------

CLASS_TYPE
operator>>(const CLASS_TYPE& u, const CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)
    return CLASS_TYPE(u);

#ifdef SC_SIGNED
  if (v.sgn == SC_NEG)
    return CLASS_TYPE(u);
#endif

  return operator>>(u, v.to_long());
}


const CLASS_TYPE&
CLASS_TYPE::operator>>=(const CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)
    return *this;

#ifdef SC_SIGNED
  if (v.sgn == SC_NEG)
    return *this;
#endif

  return operator>>=(v.to_long());
}


const CLASS_TYPE&
CLASS_TYPE::operator>>=(const OTHER_CLASS_TYPE& v)
{
  if (v.sgn == SC_ZERO)
    return *this;

#ifdef SC_UNSIGNED
  if (v.sgn == SC_NEG)
    return *this;
#endif

  return operator>>=(v.to_ulong());
}


CLASS_TYPE
operator>>(const CLASS_TYPE& u, int64 v)
{
  if (v <= 0)
    return CLASS_TYPE(u);

  return operator>>(u, (unsigned long) v);
}


CLASS_TYPE
operator>>(const CLASS_TYPE& u, uint64 v)
{
  if (v == 0)
    return CLASS_TYPE(u);

  return operator>>(u, (unsigned long) v);
}

const CLASS_TYPE&
CLASS_TYPE::operator>>=(int64 v)
{
  if (v <= 0)
    return *this;

  return operator>>=((unsigned long) v);
}


const CLASS_TYPE&
CLASS_TYPE::operator>>=(uint64 v)
{
  if (v == 0)
    return *this;

  return operator>>=((unsigned long) v);
}


CLASS_TYPE
operator>>(const CLASS_TYPE& u, long v)
{
  if (v <= 0)
    return CLASS_TYPE(u);

  return operator>>(u, (unsigned long) v);
}


CLASS_TYPE
operator>>(const CLASS_TYPE& u, unsigned long v)
{
  if (v == 0)
    return CLASS_TYPE(u);

  if (u.sgn == SC_ZERO)
    return CLASS_TYPE(u);

  int nb = u.nbits;
  int nd = u.ndigits;

#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[nd];
#endif

  vec_copy(nd, d, u.digit);

  convert_SM_to_2C(u.sgn, nd, d);

  if (u.sgn == SC_NEG)
    vec_shift_right(nd, d, v, DIGIT_MASK);
  else
    vec_shift_right(nd, d, v, 0);

  small_type s = convert_signed_2C_to_SM(nb, nd, d);

  return CLASS_TYPE(s, nb, nd, d);
}


const CLASS_TYPE&
CLASS_TYPE::operator>>=(long v)
{
  if (v <= 0)
    return *this;

  return operator>>=((unsigned long) v);
}


const CLASS_TYPE&
CLASS_TYPE::operator>>=(unsigned long v)
{
  if (v == 0)
    return *this;

  if (sgn == SC_ZERO)
    return *this;

  convert_SM_to_2C();

  if (sgn == SC_NEG)
    vec_shift_right(ndigits, digit, v, DIGIT_MASK);
  else
    vec_shift_right(ndigits, digit, v, 0);

  convert_2C_to_SM();

  return *this;
}


// ----------------------------------------------------------------------------
//  SECTION: EQUAL TO operator: ==
// ----------------------------------------------------------------------------

// Defined in the sc_signed.cpp and sc_unsigned.cpp.


// ----------------------------------------------------------------------------
//  SECTION: NOT_EQUAL operator: !=
// ----------------------------------------------------------------------------

bool
operator!=(const CLASS_TYPE& u, const CLASS_TYPE& v)
{
  return (! operator==(u, v));
}


bool
operator!=(const CLASS_TYPE& u, int64 v)
{
  return (! operator==(u, v));
}


bool
operator!=(int64 u, const CLASS_TYPE& v)
{
  return (! operator==(u, v));
}


bool
operator!=(const CLASS_TYPE& u, uint64 v)
{
  return (! operator==(u, v));
}


bool
operator!=(uint64 u, const CLASS_TYPE& v)
{
  return (! operator==(u, v));
}


bool
operator!=(const CLASS_TYPE& u, long v)
{
  return (! operator==(u, v));
}


bool
operator!=(long u, const CLASS_TYPE& v)
{
  return (! operator==(u, v));
}


bool
operator!=(const CLASS_TYPE& u, unsigned long v)
{
  return (! operator==(u, v));
}


bool
operator!=(unsigned long u, const CLASS_TYPE& v)
{
  return (! operator==(u, v));
}


// ----------------------------------------------------------------------------
//  SECTION: LESS THAN operator: <
// ----------------------------------------------------------------------------

// Defined in the sc_signed.cpp and sc_unsigned.cpp.


// ----------------------------------------------------------------------------
//  SECTION: LESS THAN or EQUAL operator: <=
// ----------------------------------------------------------------------------

bool
operator<=(const CLASS_TYPE& u, const CLASS_TYPE& v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(const CLASS_TYPE& u, int64 v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(int64 u, const CLASS_TYPE& v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(const CLASS_TYPE& u, uint64 v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(uint64 u, const CLASS_TYPE& v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(const CLASS_TYPE& u, long v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(long u, const CLASS_TYPE& v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(const CLASS_TYPE& u, unsigned long v)
{
  return (operator<(u, v) || operator==(u, v));
}


bool
operator<=(unsigned long u, const CLASS_TYPE& v)
{
  return (operator<(u, v) || operator==(u, v));
}


// ----------------------------------------------------------------------------
//  SECTION: GREATER THAN operator: >
// ----------------------------------------------------------------------------

bool
operator>(const CLASS_TYPE& u, const CLASS_TYPE& v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(const CLASS_TYPE& u, int64 v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(int64 u, const CLASS_TYPE& v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(const CLASS_TYPE& u, uint64 v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(uint64 u, const CLASS_TYPE& v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(const CLASS_TYPE& u, long v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(long u, const CLASS_TYPE& v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(const CLASS_TYPE& u, unsigned long v)
{
  return (! (operator<=(u, v)));
}


bool
operator>(unsigned long u, const CLASS_TYPE& v)
{
  return (! (operator<=(u, v)));
}


// ----------------------------------------------------------------------------
//  SECTION: GREATER THAN or EQUAL operator: >=
// ----------------------------------------------------------------------------

bool
operator>=(const CLASS_TYPE& u, const CLASS_TYPE& v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(const CLASS_TYPE& u, int64 v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(int64 u, const CLASS_TYPE& v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(const CLASS_TYPE& u, uint64 v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(uint64 u, const CLASS_TYPE& v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(const CLASS_TYPE& u, long v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(long u, const CLASS_TYPE& v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(const CLASS_TYPE& u, unsigned long v)
{
  return (! (operator<(u, v)));
}


bool
operator>=(unsigned long u, const CLASS_TYPE& v)
{
  return (! (operator<(u, v)));
}


// ----------------------------------------------------------------------------
//  SECTION: Public members - Other utils.
// ----------------------------------------------------------------------------

// Convert to int64, long, or int.
#define TO_INTX(RET_TYPE, UP_RET_TYPE)   \
                                                             \
if (sgn == SC_ZERO)                                          \
return 0;                                                    \
                                                             \
int vnd = sc_min((int)DIGITS_PER_ ## UP_RET_TYPE, ndigits); \
                                                             \
RET_TYPE v = 0;                                              \
while (--vnd >= 0)                                           \
v = (v << BITS_PER_DIGIT) + digit[vnd];                      \
                                                             \
if (sgn == SC_NEG)                                           \
return -v;                                                   \
else                                                         \
return v;


int64
CLASS_TYPE::to_int64() const
{
  TO_INTX(int64, INT64);
}


long
CLASS_TYPE::to_long() const
{
  TO_INTX(long, LONG);
}


int
CLASS_TYPE::to_int() const
{
  TO_INTX(int, INT);
}


// Convert to unsigned int64, unsigned long or unsigned
// int. to_uint64, to_ulong, and to_uint have the same body except for
// the type of v defined inside.
uint64
CLASS_TYPE::to_uint64() const
{
  if (sgn == SC_ZERO)
    return 0;

  int vnd = sc_min((int)DIGITS_PER_INT64, ndigits);

  uint64 v = 0;

  if (sgn == SC_NEG) {

#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[ndigits];
#endif

    vec_copy(ndigits, d, digit);

    convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);

    while (--vnd >= 0)
      v = (v << BITS_PER_DIGIT) + d[vnd];

#ifndef SC_MAX_NBITS
    delete [] d;
#endif

  }
  else {

    while (--vnd >= 0)
      v = (v << BITS_PER_DIGIT) + digit[vnd];

  }

  return v;
}


unsigned long
CLASS_TYPE::to_ulong() const
{
  if (sgn == SC_ZERO)
    return 0;

  int vnd = sc_min((int)DIGITS_PER_LONG, ndigits);

  unsigned long v = 0;

  if (sgn == SC_NEG) {

#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[ndigits];
#endif

    vec_copy(ndigits, d, digit);

    convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);

    while (--vnd >= 0)
      v = (v << BITS_PER_DIGIT) + d[vnd];

#ifndef SC_MAX_NBITS
    delete [] d;
#endif

  }
  else {

    while (--vnd >= 0)
      v = (v << BITS_PER_DIGIT) + digit[vnd];

  }

  return v;
}


unsigned int
CLASS_TYPE::to_uint() const
{
  if (sgn == SC_ZERO)
    return 0;

  int vnd = sc_min((int)DIGITS_PER_INT, ndigits);

  unsigned int v = 0;

  if (sgn == SC_NEG) {

#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[ndigits];
#endif

    vec_copy(ndigits, d, digit);

    convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);

    while (--vnd >= 0)
      v = (v << BITS_PER_DIGIT) + d[vnd];

#ifndef SC_MAX_NBITS
    delete [] d;
#endif

  }
  else {

    while (--vnd >= 0)
      v = (v << BITS_PER_DIGIT) + digit[vnd];

  }

  return v;
}


// Convert to double.
double
CLASS_TYPE::to_double() const
{
  if (sgn == SC_ZERO)
    return (double) 0.0;

  int vnd = ndigits;

  double v = 0.0;
  while (--vnd >= 0)
    v = v * DIGIT_RADIX + digit[vnd];

  if (sgn == SC_NEG)
    return -v;
  else
    return v;
}


// Return true if the bit i is 1, false otherwise. If i is outside the
// bounds, return 1/0 according to the sign of the number by assuming
// that the number has infinite length.

bool
CLASS_TYPE::test(int i) const
{
#ifdef SC_SIGNED
  if (check_if_outside(i)) {
    if (sgn == SC_NEG)
      return 1;
    else
      return 0;
  }
#else
  if (check_if_outside(i))
    return 0;
#endif

  int bit_num = bit_ord(i);
  int digit_num = digit_ord(i);

  if (sgn == SC_NEG) {

#ifdef SC_MAX_NBITS
    sc_digit d[MAX_NDIGITS];
#else
    sc_digit *d = new sc_digit[ndigits];
#endif

    vec_copy(ndigits, d, digit);
    vec_complement(ndigits, d);
    bool val = ((d[digit_num] & one_and_zeros(bit_num)) != 0);

#ifndef SC_MAX_NBITS
    delete [] d;
#endif

    return val;

  }
  else
    return ((digit[digit_num] & one_and_zeros(bit_num)) != 0);
}


// Set the ith bit with 1.
void
CLASS_TYPE::set(int i)
{
  if (check_if_outside(i))
    return;

  int bit_num = bit_ord(i);
  int digit_num = digit_ord(i);

  convert_SM_to_2C();
  digit[digit_num] |= one_and_zeros(bit_num);
  digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
  convert_2C_to_SM();
}


// Set the ith bit with 0, i.e., clear the ith bit.
void
CLASS_TYPE::clear(int i)
{
  if (check_if_outside(i))
    return;

  int bit_num = bit_ord(i);
  int digit_num = digit_ord(i);

  convert_SM_to_2C();
  digit[digit_num] &= ~(one_and_zeros(bit_num));
  digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
  convert_2C_to_SM();
}


// Create a mirror image of the number.
void
CLASS_TYPE::reverse()
{
  convert_SM_to_2C();
  vec_reverse(length(), ndigits, digit, length() - 1);
  convert_2C_to_SM();
}


// Get a packed bit representation of the number.
void
CLASS_TYPE::get_packed_rep(sc_digit *buf) const
{
  int buf_ndigits = (length() - 1) / BITS_PER_DIGIT_TYPE + 1;

  // Initialize buf to zero.
  vec_zero(buf_ndigits, buf);

  if (sgn == SC_ZERO)
    return;

  const sc_digit *digit_or_d;
#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  sc_digit *d = new sc_digit[ndigits];
#endif

  if (sgn == SC_POS)
    digit_or_d = digit;

  else
  {
    // If sgn is negative, we have to convert digit to its 2's
    // complement. Since this function is const, we can not do it on
    // digit. Since buf doesn't have overflow bits, we cannot also do
    // it on buf. Thus, we have to do the complementation on a copy of
    // digit, i.e., on d.

    vec_copy(ndigits, d, digit);
    vec_complement(ndigits, d);

    buf[buf_ndigits - 1] = ~((sc_digit) 0);

    digit_or_d = d;

  }

  // Copy the bits from digit to buf. The division and mod operations
  // below can be converted to addition/subtraction and comparison
  // operations at the expense of complicating the code. We can do it
  // if we see any performance problems.

  for (int i = length() - 1; i >= 0; --i) {

    if ((digit_or_d[digit_ord(i)] & one_and_zeros(bit_ord(i))) != 0) // Test.

      buf[i / BITS_PER_DIGIT_TYPE] |=
        one_and_zeros(i % BITS_PER_DIGIT_TYPE); // Set.

    else

      buf[i / BITS_PER_DIGIT_TYPE] &=
        ~(one_and_zeros(i % BITS_PER_DIGIT_TYPE));  // Clear.

  }

#ifndef SC_MAX_NBITS
    delete[] d;
#endif
}


// Set a packed bit representation of the number.
void
CLASS_TYPE::set_packed_rep(sc_digit *buf)
{
  // Initialize digit to zero.
  vec_zero(ndigits, digit);

  // Copy the bits from buf to digit.
  for (int i = length() - 1; i >= 0; --i) {

    if ((buf[i / BITS_PER_DIGIT_TYPE] &
         one_and_zeros(i % BITS_PER_DIGIT_TYPE)) != 0) // Test.

      digit[digit_ord(i)] |= one_and_zeros(bit_ord(i));     // Set.

    else

      digit[digit_ord(i)] &= ~(one_and_zeros(bit_ord(i)));  // Clear

  }

  convert_2C_to_SM();
}


// ----------------------------------------------------------------------------
//  SECTION: Private members.
// ----------------------------------------------------------------------------

// Create a copy of v with sgn s.
CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE& v, small_type s) :
    sc_value_base(v), sgn(s), nbits(v.nbits), ndigits(v.ndigits), digit()
{
#ifndef SC_MAX_NBITS
  digit = new sc_digit[ndigits];
#endif

  vec_copy(ndigits, digit, v.digit);
}


// Create a copy of v where v is of the different type.
CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE& v, small_type s) :
    sc_value_base(v), sgn(s), nbits(num_bits(v.nbits)), ndigits(), digit()
{
#if (IF_SC_SIGNED == 1)
  ndigits = v.ndigits;
#else
  ndigits = DIV_CEIL(nbits);
#endif

#ifndef SC_MAX_NBITS
  digit = new sc_digit[ndigits];
#endif

  copy_digits(v.nbits, v.ndigits, v.digit);
}


// Create a signed number with (s, nb, nd, d) as its attributes (as
// defined in class CLASS_TYPE). If alloc is set, delete d.
CLASS_TYPE::CLASS_TYPE(small_type s, int nb,
                       int nd, sc_digit *d,
                       bool alloc) :
    sc_value_base(), sgn(s), nbits(num_bits(nb)), ndigits(), digit()
{
  ndigits = DIV_CEIL(nbits);

#ifndef SC_MAX_NBITS
  digit = new sc_digit[ndigits];
#endif

  if (ndigits <= nd)
    vec_copy(ndigits, digit, d);
  else
    vec_copy_and_zero(ndigits, digit, nd, d);

#ifndef SC_MAX_NBITS
  if (alloc)
    delete [] d;
#endif
}

// This constructor is mainly used in finding a "range" of bits from a
// number of type CLASS_TYPE. The function range(l, r) can have
// arbitrary precedence between l and r. If l is smaller than r, then
// the output is the reverse of range(r, l).
CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE* u, int l, int r) :
    sc_value_base(), sgn(), nbits(), ndigits(), digit()
{
  bool reversed = false;

  if( l < r ) {
    reversed = true;
    int tmp = l;
    l = r;
    r = tmp;
  }

  // at this point, l >= r

  // make sure that l and r point to the bits of u
  r = sc_max( r, 0 );
  l = sc_min( l, u->nbits - 1 );

  nbits = num_bits( l - r + 1 );

  // nbits can still be <= 0 because l and r have just been updated
  // with the bounds of u.

  // if u == 0 or the range is out of bounds, return 0
  if( u->sgn == SC_ZERO || nbits <= num_bits( 0 ) ) {
    sgn = SC_ZERO;
    if( nbits <= num_bits( 0 ) ) {
      nbits = 1;
    }
    ndigits = DIV_CEIL( nbits );
#ifndef SC_MAX_NBITS
    digit = new sc_digit[ndigits];
#endif
    vec_zero( ndigits, digit );
    return;
  }

  // The rest will be executed if u is not zero.

  ndigits = DIV_CEIL(nbits);

  // The number of bits up to and including l and r, respectively.
  int nl = l + 1;
  int nr = r + 1;

  // The indices of the digits that have lth and rth bits, respectively.
  int left_digit = DIV_CEIL(nl) - 1;
  int right_digit = DIV_CEIL(nr) - 1;

  int nd;

  // The range is performed on the 2's complement representation, so
  // first get the indices for that.
  if (u->sgn == SC_NEG)
    nd = left_digit + 1;
  else
    nd = left_digit - right_digit + 1;

  // Allocate memory for the range.
#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  digit = new sc_digit[ndigits];
  sc_digit *d = new sc_digit[nd];
#endif

  // Getting the range on the 2's complement representation.
  if (u->sgn == SC_NEG) {

    vec_copy(nd, d, u->digit);
    vec_complement(nd, d);  // d = -d;
    vec_shift_right(nd, d, r, DIGIT_MASK);

  }
  else {

    for (int i = right_digit; i <= left_digit; ++i)
      d[i - right_digit] = u->digit[i];

    vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);

  }

  vec_zero(ndigits, digit);

  if (! reversed)
    vec_copy(sc_min(nd, ndigits), digit, d);

  else {

    // If l < r, i.e., reversed is set, reverse the bits of digit.  d
    // will be used as a temporary store. The following code tries to
    // minimize the use of bit_ord and digit_ord, which use mod and
    // div operators. Since these operators are function calls to
    // standard library routines, they are slow. The main idea in
    // reversing is "read bits out of d from left to right and push
    // them into digit using right shifting."

    // Take care of the last digit.
    int nd_less_1 = nd - 1;

    // Deletions will start from the left end and move one position
    // after each deletion.
    sc_digit del_mask = one_and_zeros(bit_ord(l - r));

    while (del_mask) {
      vec_shift_right(ndigits, digit, 1, ((d[nd_less_1] & del_mask) != 0));
      del_mask >>= 1;
    }

    // Take care of the other digits if any.

    // Insertion to digit will always occur at the left end.
    sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);

    for (int j = nd - 2; j >= 0; --j) { // j = nd - 2

      // Deletions will start from the left end and move one position
      // after each deletion.
      del_mask = ins_mask;

      while (del_mask) {
        vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
        del_mask >>= 1;
      }
    }

    if (u->sgn == SC_NEG)
      vec_shift_right(ndigits, digit,
                      ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
    else
      vec_shift_right(ndigits, digit,
                      ndigits * BITS_PER_DIGIT - length(), 0);


  }  // if reversed.

  convert_2C_to_SM();

#ifndef SC_MAX_NBITS
  delete [] d;
#endif
}

// This constructor is mainly used in finding a "range" of bits from a
// number of type OTHER_CLASS_TYPE. The function range(l, r) can have
// arbitrary precedence between l and r. If l is smaller than r, then
// the output is the reverse of range(r, l).
CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE* u, int l, int r) :
    sc_value_base(), sgn(), nbits(), ndigits(), digit()
{
  bool reversed = false;

  if( l < r ) {
    reversed = true;
    int tmp = l;
    l = r;
    r = tmp;
  }

  // at this point, l >= r

  // make sure that l and r point to the bits of u
  r = sc_max( r, 0 );
  l = sc_min( l, u->nbits - 1 );

  nbits = num_bits( l - r + 1 );

  // nbits can still be <= 0 because l and r have just been updated
  // with the bounds of u.

  // if u == 0 or the range is out of bounds, return 0
  if( u->sgn == SC_ZERO || nbits <= num_bits( 0 ) ) {
    sgn = SC_ZERO;
    if( nbits <= num_bits( 0 ) ) {
      nbits = 1;
    }
    ndigits = DIV_CEIL( nbits );
#ifndef SC_MAX_NBITS
    digit = new sc_digit[ndigits];
#endif
    vec_zero( ndigits, digit );
    return;
  }

  // The rest will be executed if u is not zero.

  ndigits = DIV_CEIL(nbits);

  // The number of bits up to and including l and r, respectively.
  int nl = l + 1;
  int nr = r + 1;

  // The indices of the digits that have lth and rth bits, respectively.
  int left_digit = DIV_CEIL(nl) - 1;
  int right_digit = DIV_CEIL(nr) - 1;

  int nd;

  // The range is performed on the 2's complement representation, so
  // first get the indices for that.
  if (u->sgn == SC_NEG)
    nd = left_digit + 1;
  else
    nd = left_digit - right_digit + 1;

  // Allocate memory for the range.
#ifdef SC_MAX_NBITS
  sc_digit d[MAX_NDIGITS];
#else
  digit = new sc_digit[ndigits];
  sc_digit *d = new sc_digit[nd];
#endif

  // Getting the range on the 2's complement representation.
  if (u->sgn == SC_NEG) {

    vec_copy(nd, d, u->digit);
    vec_complement(nd, d);  // d = -d;
    vec_shift_right(nd, d, r, DIGIT_MASK);

  }
  else {

    for (int i = right_digit; i <= left_digit; ++i)
      d[i - right_digit] = u->digit[i];

    vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);

  }

  vec_zero(ndigits, digit);

  if (! reversed)
    vec_copy(sc_min(nd, ndigits), digit, d);

  else {

    // If l < r, i.e., reversed is set, reverse the bits of digit.  d
    // will be used as a temporary store. The following code tries to
    // minimize the use of bit_ord and digit_ord, which use mod and
    // div operators. Since these operators are function calls to
    // standard library routines, they are slow. The main idea in
    // reversing is "read bits out of d from left to right and push
    // them into digit using right shifting."

    // Take care of the last digit.
    int nd_less_1 = nd - 1;

    // Deletions will start from the left end and move one position
    // after each deletion.
    sc_digit del_mask = one_and_zeros(bit_ord(l - r));

    while (del_mask) {
      vec_shift_right(ndigits, digit, 1, ((d[nd_less_1] & del_mask) != 0));
      del_mask >>= 1;
    }

    // Take care of the other digits if any.

    // Insertion to digit will always occur at the left end.
    sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);

    for (int j = nd - 2; j >= 0; --j) { // j = nd - 2

      // Deletions will start from the left end and move one position
      // after each deletion.
      del_mask = ins_mask;

      while (del_mask) {
        vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
        del_mask >>= 1;
      }
    }

    if (u->sgn == SC_NEG)
      vec_shift_right(ndigits, digit,
                      ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
    else
      vec_shift_right(ndigits, digit,
                      ndigits * BITS_PER_DIGIT - length(), 0);


  }  // if reversed.

  convert_2C_to_SM();

#ifndef SC_MAX_NBITS
  delete [] d;
#endif
}


// Print out all the physical attributes.
void
CLASS_TYPE::dump(::std::ostream& os) const
{
  // Save the current setting, and set the base to decimal.
  ::std::ios::fmtflags old_flags = os.setf(::std::ios::dec, ::std::ios::basefield);

  os << "width = " << length() << ::std::endl;
  os << "value = " << *this << ::std::endl;
  os << "bits  = ";

  int len = length();

  for (int i = len - 1; i >= 0; --i) {

    os << "01"[test(i)];
    if (--len % 4 == 0)
      os << " ";

  }

  os << ::std::endl;

  // Restore old_flags.
  os.setf(old_flags, ::std::ios::basefield);
}


// Checks to see if bit_num is out of bounds.
bool
CLASS_TYPE::check_if_outside(int bit_num) const
{
  if ((bit_num < 0) || (num_bits(bit_num) >= nbits)) {

#ifdef DEBUG_SYSTEMC
      if( bit_num < 0 || bit_num >= nbits ) {
          std::stringstream msg;
          msg << CLASS_TYPE_STR "::check_if_outside( int bit_num ) : "
                 "bit_num = " << bit_num << " is out of bounds";
          SC_REPORT_WARNING( sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str() );
      }
#endif

    return true;
  }

  return false;
}

// End of file.