decimalfloat.h

Go to the documentation of this file.

/**********************************************************//**
 **
 ** @file base/decimalfloat.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/

#ifndef XPACE_DECIMAL_FLOAT_H
#define XPACE_DECIMAL_FLOAT_H

#ifdef _WIN32
#undef min
#undef max
#endif

#include <limits>
#include <cstdio>
#include <wchar.h>
#include <cstring>

#include "base/types.h"

namespace Xpace
{
  // ================================ FLOAT ===================

  /// A floatimg-point number with explicit mantissa and decimals
  /// TODO: normalize 
  class DecimalFloat
  {
  public:
    DecimalFloat
      (const String8& str,
       uint precision = ~0);
    DecimalFloat
      (const String16& str,
       uint precision = ~0);
    DecimalFloat
      (const String& str,
       uint precision = ~0);

    DecimalFloat
      (int64 mantissa = 0,
       int decimals = 0);

    DecimalFloat
      (double val);

    operator double
      ()
      const;

    int64 getMantissa
      ()
      const
    {
      return mantissa;
    }

    int getDecimals
      ()
      const
    {
      return decimals;
    }

    int compare
      (const DecimalFloat& rhs)
      const;
    bool operator==
      (const DecimalFloat& rhs)
      const;
    bool operator!=
      (const DecimalFloat& rhs)
      const;
    bool operator<
      (const DecimalFloat& rhs)
      const
    {
      return compare(rhs) < 0; 
    }
    bool operator<=
      (const DecimalFloat& rhs)
      const;
    bool operator>
      (const DecimalFloat& rhs)
      const;
    bool operator>=
      (const DecimalFloat& rhs)
      const;

    template <typename STR>
    bool toRawString
      (STR* str,
       typename STR::charType decimalChar = '.')
      const;

    String toString
      (utf16_t decimalChar = '.')
      const;

  private:
    int64 mantissa;
    int decimals;

    template <typename STR>
    bool from_raw_string
      (const STR& str,
       uint precision = ~0);

    static
    bool itoafn
      (int64 val,
       utf8_t* dest,
       size_t size,
       size_t* len = 0)
    {
      if (_i64toa_s(val, reinterpret_cast<char*>(dest), size, 10))
        return false;
      if (len)
        *len = strlen(reinterpret_cast<char*>(dest));
      return true;
    }

    static
    bool itoafn
      (int64 val,
       utf16_t* dest,
       size_t size,
       size_t* len = 0)
    {
      if (_i64tow_s(val, reinterpret_cast<wchar_t*>(dest), size, 10))
        return false;
      if (len)
        *len = wcslen(reinterpret_cast<wchar_t*>(dest));
      return true;
    }
  };
  
  /// =========================================================
  /// =========================================================
  /// =========================================================

  inline
  DecimalFloat::DecimalFloat
    (int64 m,
     int e) :
      mantissa(m),
      decimals(e)
  {
  }

  inline 
  DecimalFloat::DecimalFloat
    (const String8& str,
     uint precision) :
      mantissa(0),
      decimals(0)
  {
    from_raw_string(str, precision);
  }

  inline 
  DecimalFloat::DecimalFloat
    (const String16& str,
     uint precision) :
      mantissa(0),
      decimals(0)
  {
    from_raw_string(str, precision);
  }

  inline 
  DecimalFloat::DecimalFloat
    (const String& str,
     uint precision)
  {
    String16 s16(const_cast<utf16_t*>(str.toUtf16()), str.getLength());
    new (this) DecimalFloat(s16, precision);
  }

  template <typename STR>
  inline
  bool DecimalFloat::toRawString
    (STR* str,
     typename STR::charType decimalChar)
    const
  {
    size_t len;

    if (decimals > 0)
    {
      if (!itoafn(mantissa, str->data + 1, str->length - 1, &len))
        return false;
      typename STR::charType* ch(str->data);
      for (; ch < str->data + len - decimals; ++ch)
        *ch = *(ch + 1);
      *ch = decimalChar;
      str->length = len + 1;
      return true;
    }
      
    if (decimals < 0)
    {
      if (!itoafn(mantissa, str->data, str->length + decimals, &len))
        return false;
      typename STR::charType* ch(str->data + len);
      for (; ch < str->data + len - decimals; ++ch)
        *ch = 0;
      return true;
    }

    if (!itoafn(mantissa, str->data, str->length, &len))
      return false;

    str->length = len;

    return true;
  }

  inline
  String DecimalFloat::toString
    (utf16_t decimalChar)
    const
  {
    utf16_t buf[32];
    String16 str(buf, 32);
    return (toRawString(&str, decimalChar)) ? String(str.data, str.length) : String();
  }

  template <typename STR>
  inline
  bool DecimalFloat::from_raw_string
    (const STR& str,
     uint precision) 
  {
    typename STR::charType buf[256];
    typename STR::charType* b(buf);
    const typename STR::charType* d(str.data);
    uint len(narrow_to<uint>(str.length));
    bool minus(false);
    for (uint i(0); i < len; ++i, ++d)
    {
      if (*d == '.')
      {
        if (INVALID(precision))
          decimals = len - i - 1;
        else
        {
          decimals = std::min(precision, len - i - 1);
          len = std::min(len, i + precision + 1);
        }
      }
      else if (*d == ',')
        continue;
      else if ((*d >= '0') && (*d <= '9'))
        *b++ = *d;
      else if (*d == '-')
        minus = true;
      else
        return false;
    }
    *b = 0;

    while ((decimals > 0) && (b > buf) && (*--b == '0'))
    {
      --decimals;
      *b = 0;
    }

    mantissa = (sizeof(typename STR::charType) == 1) ? _atoi64(reinterpret_cast<const char*>(buf)) : _wtoi64(reinterpret_cast<const wchar_t*>(buf));

    if (mantissa == std::numeric_limits<int64>::max())
    {
      mantissa = 0;
      return false;
    }

    if (minus)
      mantissa = -mantissa;

    if ((len < str.length) && (*d >= '5') && (*d <= '9'))
    {
      if (mantissa < 0)
        --mantissa;
      else
        ++mantissa;
    }
    return true;
  }

  inline
  DecimalFloat::DecimalFloat
    (double d)
  {
    // TODO: optimize this
    byte buf[128];
    int len(sprintf_s((char*)buf, sizeof(buf), "%f", d));
    new (this) DecimalFloat(String8(buf, len));
  }

  inline
  DecimalFloat::operator double
    ()
    const
  {
    return double(mantissa) / pow10_64(decimals);
  }

  inline 
  int DecimalFloat::compare
    (const DecimalFloat& rhs)
    const
  {
    if (decimals == rhs.decimals)
    {
      if (mantissa == rhs.mantissa)
        return 0;
      return (mantissa < rhs.mantissa) ? -1 : 1;
    }
    
    if (decimals > rhs.decimals)
    {
      int64 rm(rhs.mantissa * pow10_64(decimals - rhs.decimals));
      return (mantissa == rm) ? 0 : ((mantissa < rm) ? -1 : 1);
      // TODO: worry about comparing 430 to 430.000
    }
    
    int64 lm(mantissa * pow10_64(rhs.decimals - decimals));
    return (lm == rhs.mantissa) ? 0 : ((lm < rhs.mantissa) ? -1 : 1);
  }

  inline 
  bool DecimalFloat::operator==
    (const DecimalFloat& rhs)
    const
  {
    if (decimals == rhs.decimals)
      return mantissa == rhs.mantissa;
    if (decimals < rhs.decimals)
      return int64(mantissa * pow10_64(rhs.decimals - decimals)) == rhs.mantissa;
    return mantissa == int64(rhs.mantissa * pow10_64(decimals - rhs.decimals));
  }

  inline 
  bool DecimalFloat::operator!=
    (const DecimalFloat& rhs)
    const
  {
    return !(*this == rhs);
  }
}

#endif