fixed.hpp

Go to the documentation of this file.

#ifndef FIXED_HPP_
#define FIXED_HPP_

#include <cassert>
#include <cmath>
#include <iomanip>
#include <ios>
#include <istream>
#include <locale>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <string>

#include "ioflags.hpp"
#include "power10.hpp"

template<class T, int N>
class fixed
{
public:
    typedef T value_type;                    

    static value_type const places = N;      
    static value_type const places10 = power10<N>::value;       

    fixed() : value_() {}

    fixed(value_type integer, value_type fraction);

    fixed(value_type integer);

    fixed(double value)
    : value_(static_cast<value_type>(value * places10 + (value < 0 ? -0.5 : 0.5)))
    {}

    std::string as_string() const;
    template<class Char, class Traits>
    bool read(std::basic_istream<Char, Traits>& strm);
    double as_long_double() const { return static_cast<long double>(value()) / places10; }
    double as_double() const { return static_cast<double>(value()) / places10; }
    float as_float() const { return static_cast<float>(value()) / places10; }
    value_type round() const;

    value_type integer() const { return value() / places10; }
    value_type fraction() const;

    fixed& operator+=(fixed f);
    fixed& operator-=(fixed f);
    fixed& operator*=(fixed f);
    fixed& operator*=(value_type v);
    fixed& operator/=(fixed f);
    fixed& operator/=(value_type v);

    void negate();

    fixed& operator++();
    fixed operator++(int);
    fixed& operator--();
    fixed operator--(int);

    value_type value()    const { return value_; }
private:
    value_type reduce(value_type frac);
    value_type value_;
};

// Construct a fixed value from an integer part and a fraction part
template<class T, int N>
fixed<T,N>::fixed(value_type integer, value_type fraction)
{
  if (fraction < T())
    throw std::invalid_argument("negative fraction not allowed");
  fraction = reduce(fraction);
  if (integer < T())
    value_ = integer * places10 - fraction;
  else
    value_ = integer * places10 + fraction;
}

// Construct a fixed value from an integer part with no fraction
template<class T, int N>
fixed<T,N>::fixed(value_type integer)
: value_(integer * places10)
{}

// Get the fraction part
template<class T, int N>
typename fixed<T,N>::value_type fixed<T,N>::fraction()
const
{
  return std::abs(value()) % places10;
}

template<class T, int N>
typename fixed<T,N>::value_type fixed<T,N>::reduce(value_type frac)
{
  // First scan for zero digits on the right.
  value_type f(frac);
  while (f >= places10*10 and f % 10 == 0)
  {
    f /= 10;
  }

  if (f >= places10*10)
  {
    int x(0);
    // Loop ended because a non-zero digit was seen so Y* > 0.
    // Discard the remaining digits, but keep track of the last
    // digit to be processed (X).
    while (f >= places10)
    {
      x = f % 10;
      f /= 10;
    }
    // Round up if the last digit (X) is 5 or more
    if (x >= 5)
      ++f;
    return f;
  }
  // Else all digits so far are zero. Check how many digits there were,
  // that is, check whether G, and X at least are present.
  else if (f >= places10)
  {
    // Yes, G and X are present. If X == 5, implement banker's rounding.
    // Otherwise, round to nearest.
    int x(f % 10);
    f /= 10;
    assert(f < places10);
    if (x == 5)
    {
      // Yes, so implement banker's rounding.
      if (f % 2 != 0)
        ++f;
      return f;
    }
    else if (x < 5)
    {
      // Round down.
      return f;
    }
    else
    {
      // Round up.
      return f + 1;
    }
  }
  // Not enough digits, so nothing to round.
  assert(frac < places10);
  return frac;
}

// Round off to nearest integer.
template<class T, int N>
typename fixed<T,N>::value_type fixed<T,N>::round()
const
{
  const value_type frac(fraction());
  int adjust(value() < 0 ? -1 : +1);
  if (frac > places10/2)
    return integer()+adjust;
  else if (frac < places10/2)
    return integer();
  else if (integer() % 2 == 0)
    return integer();
  else
    return integer()+adjust;
}

// Convert to a string using fixed-point notation.
template<class T, int N>
std::string fixed<T,N>::as_string()
const
{
  std::ostringstream out;
  out << integer() << '.'
      << std::setfill('0') << std::setw(places) << fraction();
  return out.str();
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator+=(fixed f)
{
  value_ += f.value();
  return *this;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator-=(fixed f)
{
  value_ -= f.value();
  return *this;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator*=(fixed f)
{
  value_ = (value_ * f.value()) / places10;
  return *this;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator*=(value_type v)
{
  value_ *= v;
  return *this;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator/=(fixed f)
{
  value_ = (value_ * places10) / f.value();
  return *this;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator/=(value_type v)
{
  value_ /= v;
  return *this;
}

template<class T, int N>
void fixed<T,N>::negate()
{
  value_ = -value_;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator++()
{
  value_ += places10;
  return *this;
}

template<class T, int N>
fixed<T,N> fixed<T,N>::operator++(int)
{
  fixed result(*this);
  ++*this;
  return result;
}

template<class T, int N>
fixed<T,N>& fixed<T,N>::operator--()
{
  value_ -= places10;
  return *this;
}

template<class T, int N>
fixed<T,N> fixed<T,N>::operator--(int)
{
  fixed result(*this);
  --*this;
  return result;
}

template<class T, int N>
template<class Char, class Traits>
bool fixed<T,N>::read(std::basic_istream<Char, Traits>& strm)
{
  ioflags flags(strm);

  value_type integer;
  char decimal;
  if (not (strm >> integer))
    return false;
  strm.unsetf(std::ios_base::skipws);
  if (not (strm >> decimal) or decimal != '.')
  {
    // Just an integer is fine. Push back the non-decimal character,
    // if there is one, and reset the stream flags to show that
    // reading the fixed value succeeded.
    strm.unget();
    strm.clear(strm.rdstate() & ~strm.failbit);
    value_ = integer * places10;
    return true;
  }
  else
  {
    value_type fraction(0);
    char c;
    int p(0);
    // Read one extra place for round-off.
    for (;
          p != places+1 and strm >> c and std::isdigit(c, strm.getloc());
          ++p)
    {
      fraction = fraction * 10 + (c - '0');
    }
    // Pad out to the requisite number of decimal places.
    for (; p < places; ++p)
      fraction = fraction * 10;
    // If the loop terminated because the maximum number of decimal
    // places were read, keep reading the stream to discard excees digits.
    while (strm and std::isdigit(c, strm.getloc()))
      strm >> c;
    // Push back the last, non-digit character read from the stream.
    // If the stream reached EOF, unget() is harmless.
    strm.unget();
    // Clear failbit because even if reading a character or whatever
    // failed, reading the fixed value did not.
    strm.clear(strm.rdstate() & ~strm.failbit);
    fraction = reduce(fraction);
    if (integer < 0)
      value_ = integer * places10 - fraction;
    else
      value_ = integer * places10 + fraction;
  }
  return true;
}

template<class T, int N, class Char, class Traits>
std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& strm, fixed<T,N>& f)
{
  if (not f.read(strm))
    strm.setstate(strm.failbit);
  return strm;
}

template<class T, int N, class Char, class Traits>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& strm, fixed<T,N> f)
{
  strm << f.as_string();
  return strm;
}

template<class T, int N>
fixed<T,N> operator+(fixed<T,N> a, fixed<T,N> b)
{
  a += b;
  return a;
}

template<class T, int N>
fixed<T,N> operator+(fixed<T,N> a, T b)
{
  a += fixed<T,N>(b);
  return a;
}

template<class T, int N>
fixed<T,N> operator+(T a, fixed<T,N> b)
{
  b += a;
  return b;
}

template<class T, int N>
fixed<T,N> operator-(fixed<T,N> a, fixed<T,N> b)
{
  a -= b;
  return a;
}

template<class T, int N>
fixed<T,N> operator-(fixed<T,N> a, T b)
{
  a -= fixed<T,N>(b);
  return a;
}

template<class T, int N>
fixed<T,N> operator-(T a, fixed<T,N> b)
{
  b += -a;
  return -b;
}

template<class T, int N>
fixed<T,N> operator*(fixed<T,N> a, fixed<T,N> b)
{
  a *= b;
  return a;
}

template<class T, int N>
fixed<T,N> operator*(fixed<T,N> a, T b)
{
  a *= b;
  return a;
}

template<class T, int N>
fixed<T,N> operator*(T a, fixed<T,N> b)
{
  b *= a;
  return b;
}

template<class T, int N>
fixed<T,N> operator/(fixed<T,N> a, fixed<T,N> b)
{
  a /= b;
  return a;
}

template<class T, int N>
fixed<T,N> operator/(fixed<T,N> a, T b)
{
  a /= b;
  return a;
}

template<class T, int N>
fixed<T,N> operator/(T a, fixed<T,N> b)
{
  fixed<T,N> tmp(a);
  tmp /= b;
  return tmp;
}

template<class T, int N>
fixed<T,N> operator-(fixed<T,N> a)
{
  a.negate();
  return a;
}

template<class T, int N>
bool operator==(fixed<T,N> a, fixed<T,N> b)
{
  return a.value() == b.value();
}
template<class T, int N>
bool operator==(T a, fixed<T,N> b)
{
  return a == b.value();
}
template<class T, int N>
bool operator==(fixed<T,N> a, T b)
{
  return a.value() == b;
}

template<class T, int N>
bool operator!=(fixed<T,N> a, fixed<T,N> b)
{
  return not (a == b);
}
template<class T, int N>
bool operator!=(T a, fixed<T,N> b)
{
  return not (a == b);
}
template<class T, int N>
bool operator!=(fixed<T,N> a, T b)
{
  return not (a == b);
}

template<class T, int N>
bool operator<(fixed<T,N> a, fixed<T,N> b)
{
  return a.value() < b.value();
}
template<class T, int N>
bool operator<(T a, fixed<T,N> b)
{
  return a < b.value();
}
template<class T, int N>
bool operator<(fixed<T,N> a, T b)
{
  return a.value() < b;
}

template<class T, int N>
bool operator>(fixed<T,N> a, fixed<T,N> b)
{
  return b < a;
}
template<class T, int N>
bool operator>(T a, fixed<T,N> b)
{
  return b < a;
}
template<class T, int N>
bool operator>(fixed<T,N> a, T b)
{
  return b < a;
}

template<class T, int N>
bool operator<=(fixed<T,N> a, fixed<T,N> b)
{
  return not (b < a);
}
template<class T, int N>
bool operator<=(T a, fixed<T,N> b)
{
  return not (b < a);
}
template<class T, int N>
bool operator<=(fixed<T,N> a, T b)
{
  return not (b < a);
}

template<class T, int N>
bool operator>=(fixed<T,N> a, fixed<T,N> b)
{
  return not (a < b);
}
template<class T, int N>
bool operator>=(T a, fixed<T,N> b)
{
  return not (a < b);
}
template<class T, int N>
bool operator>=(fixed<T,N> a, T b)
{
  return not (a < b);
}

#endif

---