c:/Users/efeyhl/devs/math2/siv.h

#ifndef __SIV_H__
#define __SIV_H__

#include "number.h"

//#include <limits.h> //LLONG_MIN, ...
//#include <string.h> //strlen
//#include <stdlib.h> //abs, _atoi64
//#include <math.h> //fabs
//#include <float.h> //DBL_EPSILON, DBL_MAX, ...
//#include <stdio.h> //printf
//#include <errno.h> //errno, ERANGE
//#include "math_const.h" //DBL_MAX_VALUE, ...
//#include "dataTypes.h" //uint64


class siv : public number<__int64>
{
public: //implementation of pure virtual methods of number


  virtual __int64 stringToValue( const char* stringValue )
  {
    return stringToInt64( stringValue, (char**)0, &bms );
  };

public: //methods


  siv(const __int64 val)
  {
    value = val;
    bms.status = 0;
    bms.undef = 1;
  };
  

  siv(const siv& val)
  {
    value = val.value;
    bms.status = val.bms.status;
  };


  inline void printBitpat( FILE* file=0 ) const
  {
    char* fmt = "%I64x";
    if (file == 0)
    {
      file = stdout;
    }
    fprintf( file, fmt, value );
  };


  inline siv& assignCopy(const double val)
  {
    if ( val < (double)LLONG_MIN )
    { //the rounding value of 0.5 is not significant
      //this means that LLONG_MIN has more significant digits then the data type double 
      value = LLONG_MIN;
      bms.overflow = 1;
      bms.negative = 1;
      return *this;
    }
    if ( val < 0.0 )
    {
      value = (__int64)(val - 0.5);
      return *this;
    }
    if ( val <= (double)LLONG_MAX )
    {
      value = (__int64)(val + 0.5);
      return *this;
    }
    //else: val is out of range
    value = LLONG_MAX;
    bms.overflow = 1;
    return *this;
  };


  inline siv& assignCopy(const char* strVal)
  {
    if (strVal == NULL)
    {
      bms.strErr = 1;
      return *this;
    }
    size_t sLen = strlen( strVal );
    size_t idx = 0;
    for ( idx = 0; idx < sLen; idx++ )
    {
      if ( ('0' <= strVal[idx]) && (strVal[idx] <= '9') )
      {
        break; //first number found
      }
      if ( strVal[idx] == '\r' )
      {
        continue; //check next character
      }
      if ( strVal[idx] == '\n' )
      {
        continue; //check next character
      }
      if ( strVal[idx] == '\t' )
      {
        continue; //check next character
      }
      if ( strVal[idx] == ' ' )
      {
        continue; //check next character
      }
      if ( strVal[idx] == '+' )
      {
        continue; //check next character
      }
      if ( strVal[idx] == '-' )
      {
        continue; //check next character
      }
      //all other characters are not allowed
      bms.strErr = 1;
      return *this;
    }
    
    //here: idx points to the first numerical character
    if ( idx > 0 )
    { //check for a sign character
      if ( (strVal[idx-1] == '+') || (strVal[idx-1] == '-') )
      {
        idx--;
      }
    }
    value = _atoi64( &strVal[idx] );
    bms.status = 0;
    return *this;
  };


  inline siv& operator = (const double val)
  {
    return assignCopy( val );
  };

// basic operations


  inline siv operator + (const __int64 addend) const
  {
    siv res(*this);
    res.assignAdd( addend );
    return res;
  };


  inline siv operator + (const siv& addend) const
  {
    siv res(*this);
    res.assignAdd( addend );
    return res;
  };


  inline siv operator - (const __int64& subtrahend) const
  {
    siv res(*this);
    res.assignSub( subtrahend );
    return res;
  };


  inline siv operator - (const siv& subtrahend) const
  {
    siv res(*this);
    res.assignSub( subtrahend );
    return res;
  };


  inline siv operator * (const __int64 multiplicand) const
  {
    siv res(*this);
    res.assignMul( multiplicand );
    return res;
  };


  inline siv operator * (const siv& multiplicand) const
  {
    siv res(*this);
    res.assignMul( multiplicand );
    return res;
  };


  inline siv& assignReciproc()
  { // value = 1 / value
    if ((-2 <= value) && (value < 0))
    { //value = -2   ||   value = -1
      value = -1;
      return *this;
    }
    if ((0 < value) && (value <= 2))
    { //value = 1   ||   value = 2
      value = 1;
      return *this;
    }
    value = 0;
    return *this;
  };


  inline siv reciproc() const
  {
    siv res( *this );
    res.assignReciproc();
    return res;
  };


  inline siv operator / (const __int64 denominator) const
  {
    siv res(*this);
    res.assignDiv( denominator );
    return res;
  };


  inline siv operator / (const siv& denominator) const
  {
    siv res(*this);
    res.assignDiv( denominator );
    return res;
  };


  inline siv operator % (const __int64 denominator) const
  {
    siv remainder(*this);
    remainder.assignMod( denominator );
    return remainder;
  }


  inline siv operator % (const siv& denominator) const
  {
    siv remainder(*this);
    remainder.assignMod( denominator );
    return remainder;
  }


  inline siv positive() const
  {
    siv absVal( *this );
    absVal.assignPositive();
    return absVal;
  };


  inline siv negative() const
  {
    siv negVal( *this );
    negVal.assignNegative();
    return negVal;
  };


  inline siv absMin( const siv& val ) const //returns the object which value is 
  { //absolute lower. The object itself remains the sign!!!
    //returns |val| < |this| ? val : this
    if ( positive() <= val.positive() )
    {
      return *this;
    }
    return val;
  };


  inline siv invertSign() const
  {
    siv invVal( *this );
    invVal.assignInvertSign();
    return invVal;
  };

// power and root with integers


  inline siv pow(const int exp)
  {
    siv res( *this );
    res.assignPow( exp );
    return res;
  };


  inline siv sqrt() const //returns the square-root
  { 
    siv res( *this );
    res.assignSqrt();
    return res;
  };

// bitwise operations (AND OR XOR NOT SHIFT ROT ...)


  inline siv& assignAnd(const __int64 val)
  {
    value &= val;
    return *this;
  };


  inline siv& operator &= (const __int64 val)
  {
    return assignAnd( val );
  };


  inline siv and(const __int64 val) const
  {
    siv res( *this );
    res.assignAnd( val );
    return res;
  };


  inline siv operator & (const __int64 val) const
  {
    return and( val );
  };


  inline siv& assignOr(const __int64 val)
  {
    value |= val;
    return *this;
  };


  inline siv& operator |= (const __int64 val)
  {
    return assignOr( val );
  };


  inline siv or(const __int64 val) const
  {
    siv res( *this );
    res.assignOr( val );
    return res;
  };


  inline siv operator | (const __int64 val) const
  {
    return or( val );
  };


  inline siv& assignBitwiseNot()
  {
    value = ~value;
    return *this;
  };


  inline siv bitwiseNot()
  {
    siv res( ~value );
    return res;
  };


  inline siv& operator ~ ()
  {
    return assignBitwiseNot();
  };


  inline siv& assignXor(const __int64 val)
  {
    value ^= val;
    return *this;
  };


  inline siv& operator ^= (const __int64 val)
  {
    return assignXor( val );
  };


  inline siv xor(const __int64 val) const
  {
    siv res( *this );
    res.assignXor( val );
    return res;
  };


  inline siv operator ^ (const __int64 val) const
  {
    return xor( val );
  };


  inline siv& assignShiftLeft(const int cnt)
  {
    value <<= cnt;
    return *this;
  };


  inline siv& operator <<= (const int cnt)
  {
    return assignShiftLeft( cnt );
  };


  inline siv shiftLeft(const int cnt) const
  {
    siv res( *this );
    res.assignShiftLeft( cnt );
    return res;
  };


  inline siv operator << (const int cnt)
  {
    return shiftLeft( cnt );
  };


  inline siv& assignShiftRight(const int cnt)
  {
    value >>= cnt;
    return *this;
  };


  inline siv& operator >>= (const int cnt)
  {
    return assignShiftRight( cnt );
  };


  inline siv shiftRight(const int cnt) const
  {
    siv res( *this );
    res.assignShiftRight( cnt );
    return res;
  };


  inline siv operator >> (const int cnt)
  {
    return shiftRight( cnt );
  };


  inline siv& assignRotLeft(const int cnt)
  {
    if ( cnt < 0 )
    {
      return assignRotRight( -cnt );
    }
    __int64 hiBit;
    for ( int bitPos = 0; bitPos < cnt; bitPos++ )
    {
      hiBit = value & 0x8000000000000000L;
      value <<= 1;
      if (hiBit != 0L)
      {
        value |= 1L;
      }
    }
    return *this;
  };


  inline siv rotLeft(const int cnt) const
  {
    siv res( *this );
    res.assignRotLeft( cnt );
    return res;
  };


  inline siv& assignRotRight(const int cnt)
  {
    if ( cnt < 0 )
    {
      return assignRotLeft( -cnt );
    }
    __int64 loBit;
    for ( int bitPos = 0; bitPos < cnt; bitPos++ )
    {
      loBit = value & 1L;
      value >>= 1;
      if (loBit != 0L)
      {
        value |= 0x8000000000000000L;
      }
    }
    return *this;
  };


  inline siv rotRight(const int cnt) const
  {
    siv res( *this );
    res.assignRotRight( cnt );
    return res;
  };

};

#endif //__SIV_H__

---