decimal.h

 
#ifndef _aspose_system_decimal_h_
#define _aspose_system_decimal_h_
 
#include <system/object.h>
#include <system/string.h>
#include <system/midpoint_rounding.h>
#include <system/globalization/number_styles.h>
#include <system/globalization/culture_info.h>
#include <system/boxable_traits.h>
#include <system/type_code.h>
 
#include <string>
#include <limits>
#include <cmath>
#include <memory>
#include <array>
 
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
 
 
namespace boost { namespace multiprecision {
    namespace backends {
        template <unsigned, class, class> class cpp_dec_float;
    }
    using backends::cpp_dec_float;
    ASPOSECPP_3RD_PARTY_ENUM(expression_template_option);
    template <class, expression_template_option> class number;
} }
 
 
namespace System {
 
#ifndef ASPOSE_CPP_DECIMAL_DIGITS
    #define ASPOSE_CPP_DECIMAL_DIGITS 28
#endif
 
#define DECIMAL_FROM_DOUBLE_SIGNIFICANT_DIGITS 15
 
#define DECIMAL_FROM_FLOAT_SIGNIFICANT_DIGITS 7
 
class IFormatProvider;
 
namespace Detail {
    template <typename I> class DecimalConverter;
 
    typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<ASPOSE_CPP_DECIMAL_DIGITS + 1, std::int32_t, void>, (boost::multiprecision::expression_template_option)1> decimal_number_type;
    struct decimal_size_equivalent {
        std::array<std::uint32_t, (ASPOSE_CPP_DECIMAL_DIGITS + 8) / 8 + 3> m_data;
        std::int32_t m_exponent;
        bool m_neg;
        enum { e1, e2, e3 } m_class;
        std::int32_t m_precision;
    };
 
    ASPOSECPP_3RD_PARTY_TYPE_HOLDER(decimal_number_type, number, sizeof(decimal_size_equivalent), std::uint32_t, DecimalHolder);
}
 
struct DecimalDotNetImpl;
 
class ASPOSECPP_SHARED_CLASS Decimal
{
public:
    template<typename I> friend class Detail::DecimalConverter;
 
    typedef Detail::decimal_number_type number_type;    
 
    static const Decimal ASPOSECPP_SHARED_API MaxValue;
    static const Decimal ASPOSECPP_SHARED_API MinValue;
    static const Decimal ASPOSECPP_SHARED_API MinusOne;
    static const Decimal ASPOSECPP_SHARED_API One;
    static const Decimal ASPOSECPP_SHARED_API Zero;
 
    // ctors
    ASPOSECPP_SHARED_API Decimal();
    ASPOSECPP_SHARED_API Decimal(std::int8_t i);
    ASPOSECPP_SHARED_API Decimal(std::int16_t i);
    ASPOSECPP_SHARED_API Decimal(std::int32_t i);
    ASPOSECPP_SHARED_API Decimal(std::int64_t i);
    ASPOSECPP_SHARED_API Decimal(std::uint8_t i);
    ASPOSECPP_SHARED_API Decimal(std::uint16_t i);
    ASPOSECPP_SHARED_API Decimal(std::uint32_t i);
    ASPOSECPP_SHARED_API Decimal(std::uint64_t i);
 
    ASPOSECPP_SHARED_API Decimal(float f);
    ASPOSECPP_SHARED_API Decimal(double d);
 
    ASPOSECPP_SHARED_API explicit Decimal(const std::string& str);
    ASPOSECPP_SHARED_API Decimal(int32_t lo, int32_t mid, int32_t hi, bool isNegative, uint8_t scale);
    ASPOSECPP_SHARED_API Decimal(const Decimal &d);
    ASPOSECPP_SHARED_API Decimal(const ArrayPtr<int32_t>& bits);
    ASPOSECPP_SHARED_API Decimal(std::nullptr_t bits);
    ASPOSECPP_SHARED_API ~Decimal();
 
    // operators
    ASPOSECPP_SHARED_API Decimal& operator = (const Decimal &d);
 
    ASPOSECPP_SHARED_API explicit operator std::int8_t() const;
    ASPOSECPP_SHARED_API explicit operator std::int16_t() const;
    ASPOSECPP_SHARED_API explicit operator std::int32_t() const;
    ASPOSECPP_SHARED_API explicit operator std::int64_t() const;
    ASPOSECPP_SHARED_API explicit operator std::uint8_t() const;
    ASPOSECPP_SHARED_API explicit operator std::uint16_t() const;
    ASPOSECPP_SHARED_API explicit operator std::uint32_t() const;
    ASPOSECPP_SHARED_API explicit operator std::uint64_t() const;
    ASPOSECPP_SHARED_API explicit operator float() const;
    ASPOSECPP_SHARED_API explicit operator double() const;
    
    ASPOSECPP_SHARED_API explicit operator bool() const;
 
    ASPOSECPP_SHARED_API Decimal operator+(const Decimal& d) const;
    ASPOSECPP_SHARED_API Decimal operator-(const Decimal& d) const;
    ASPOSECPP_SHARED_API Decimal operator*(const Decimal& d) const;
    ASPOSECPP_SHARED_API Decimal operator/(const Decimal& d) const;
    ASPOSECPP_SHARED_API Decimal operator%(const Decimal& d) const;
    ASPOSECPP_SHARED_API Decimal operator-() const;
 
    ASPOSECPP_SHARED_API bool operator==(const Decimal& d) const;
    ASPOSECPP_SHARED_API bool operator!=(const Decimal& d) const;
    ASPOSECPP_SHARED_API bool operator==(std::nullptr_t) const;
    ASPOSECPP_SHARED_API bool operator!=(std::nullptr_t) const;
    ASPOSECPP_SHARED_API bool operator<(const Decimal& d) const;
    ASPOSECPP_SHARED_API bool operator<=(const Decimal& d) const;
    ASPOSECPP_SHARED_API bool operator>(const Decimal& d) const;
    ASPOSECPP_SHARED_API bool operator>=(const Decimal& d) const;
    
    ASPOSECPP_SHARED_API Decimal& operator++();
    ASPOSECPP_SHARED_API Decimal& operator--();
 
    ASPOSECPP_SHARED_API Decimal& operator+=(const Decimal& d);
    ASPOSECPP_SHARED_API Decimal& operator-=(const Decimal& d);
    ASPOSECPP_SHARED_API Decimal& operator*=(const Decimal& d);
    ASPOSECPP_SHARED_API Decimal& operator/=(const Decimal& d);
    ASPOSECPP_SHARED_API Decimal& operator%=(const Decimal& d);
 
    ASPOSECPP_SHARED_API friend std::ostream& operator<<(std::ostream& os, const Decimal& d);
    ASPOSECPP_SHARED_API friend std::wostream& operator<<(std::wostream& os, const Decimal& d);
 
    // methods
    ASPOSECPP_SHARED_API bool Equals(const Decimal& d) const;
    ASPOSECPP_SHARED_API bool Equals(const SharedPtr<Object>& obj) const;
    ASPOSECPP_SHARED_API int CompareTo(const Decimal& d) const;
    ASPOSECPP_SHARED_API int GetHashCode() const;
    ASPOSECPP_SHARED_API String ToString() const;
 
    ASPOSECPP_SHARED_API String ToString(const SharedPtr<IFormatProvider>& provider) const;
    // Optimized function overloads
    ASPOSECPP_SHARED_API String ToString(const SharedPtr<Globalization::CultureInfo>& culture) const;
    ASPOSECPP_SHARED_API String ToString(const SharedPtr<Globalization::NumberFormatInfo>& nfi) const;
    String ToString(const Decimal& value, std::nullptr_t) const { ASPOSE_UNUSED(value); return ToString(); }
 
    ASPOSECPP_SHARED_API String ToString(const String& format, const SharedPtr<IFormatProvider>& provider) const;
    // Optimized function overloads
    ASPOSECPP_SHARED_API String ToString(const String& format, const SharedPtr<Globalization::CultureInfo>& culture) const;
    ASPOSECPP_SHARED_API String ToString(const String& format, const SharedPtr<Globalization::NumberFormatInfo>& nfi) const;
    ASPOSECPP_SHARED_API String ToString(const String& format, std::nullptr_t = nullptr) const;
 
    // static methods
    static ASPOSECPP_SHARED_API Decimal Round(const Decimal& d, MidpointRounding mode = MidpointRounding::ToEven);
    static ASPOSECPP_SHARED_API Decimal Round(const Decimal& d, int digits, MidpointRounding mode = MidpointRounding::ToEven);
    static ASPOSECPP_SHARED_API Decimal Truncate(const Decimal& d);
    static ASPOSECPP_SHARED_API Decimal Ceiling(const Decimal& d);
    static ASPOSECPP_SHARED_API Decimal Floor(const Decimal& d);
 
    static bool Equals(const Decimal& d1, const Decimal& d2) { return d1 == d2; }
    static int Compare(const Decimal& d1, const Decimal& d2) { return d1.CompareTo(d2); }
    static ASPOSECPP_SHARED_API Decimal Parse(const String& s);
    static ASPOSECPP_SHARED_API Decimal Parse(const String& s, Globalization::NumberStyles styles);
    static ASPOSECPP_SHARED_API Decimal Parse(const String& s, const SharedPtr<IFormatProvider>& provider);
    static ASPOSECPP_SHARED_API Decimal Parse(const String& s, Globalization::NumberStyles styles, const SharedPtr<IFormatProvider>& provider);
    static ASPOSECPP_SHARED_API bool TryParse(const String& value, Decimal& result);
    static ASPOSECPP_SHARED_API bool TryParse(const String& value, Globalization::NumberStyles styles, const SharedPtr<IFormatProvider>& provider, Decimal& result);
 
    static const TypeInfo& Type()
    {
        return *static_holder<ThisTypeInfo>();
    }
 
    ASPOSECPP_SHARED_API std::string ToStdString() const;
    static ASPOSECPP_SHARED_API System::ArrayPtr<int> GetBits(const Decimal& d);
    static ASPOSECPP_SHARED_API void GetBytes(const Decimal& value, const System::ArrayPtr<uint8_t>& buffer);
    ASPOSECPP_SHARED_API Decimal(const number_type& value);
    static ASPOSECPP_SHARED_API int64_t ToOACurrency(const Decimal& value);
    static ASPOSECPP_SHARED_API Decimal FromOACurrency(int64_t currency);
    TypeCode GetTypeCode() const { return TypeCode::Decimal; }
    
    static Decimal Add(const Decimal& d1, const Decimal& d2) { return d1 + d2; }
    static Decimal Subtract(const Decimal& d1, const Decimal& d2) { return d1 - d2; }
    static Decimal Divide(const Decimal& d1, const Decimal& d2) { return d1 / d2; }
    static Decimal Remainder(const Decimal& d1, const Decimal& d2) { return d1 % d2; }
    static Decimal Multiply(const Decimal& d1, const Decimal& d2) { return d1 * d2; }
    static Decimal Negate(const Decimal& d) { return -d; }
 
    static uint8_t ToByte(Decimal value) { return static_cast<uint8_t>(value); }
    static int8_t ToSByte(Decimal value) { return static_cast<int8_t>(value); }
    static uint16_t ToUInt16(Decimal value) { return static_cast<uint16_t>(value); }
    static int16_t ToInt16(Decimal value) { return static_cast<int16_t>(value); }
    static uint32_t ToUInt32(Decimal value) { return static_cast<uint32_t>(value); }
    static int32_t ToInt32(Decimal value) { return static_cast<int32_t>(value); }
    static uint64_t ToUInt64(Decimal value) { return static_cast<uint64_t>(value); }
    static int64_t ToInt64(Decimal value) { return static_cast<int64_t>(value); }
    static float ToSingle(Decimal value) { return static_cast<float>(value); }
    static double ToDouble(Decimal value) { return static_cast<double>(value); }
 
    String ToStringInternal() const;
 
protected:
    static ASPOSECPP_SHARED_API void DecimalToDotNetImpl(const Decimal& value, DecimalDotNetImpl* impl);
    Detail::DecimalHolder m_value;
 
private:
    static Decimal Round_unchecked(const Decimal& d, int digits, MidpointRounding mode = MidpointRounding::ToEven);
 
    struct ThisTypeInfo : TypeInfoPtr
    {
        ThisTypeInfo()
            : TypeInfoPtr(u"System::Decimal")
        {}
    };
 
    template <class T>
    inline void EliminateRoundError()
    {
        // This intends to limit fractional error when converting from double or float to Decimal.
        // It is requires to put the behavior in line with original C# one which seems to consider only 15 digits for double when converting.
        typedef std::numeric_limits<T> limits;
        if (limits::is_integer)
            return;
 
        CutErroneousDigits(limits::digits10);
    }
 
    void CutErroneousDigits(int digits);
 
    void DecimalInternal(int32_t lo, int32_t mid, int32_t hi, bool isNegative, uint8_t scale);
};
 
template <typename T, typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator+(const T& x, const Decimal& d) { return Decimal(x) + d; }
 
template <typename T, typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator-(const T& x, const Decimal& d) { return Decimal(x) - d; }
 
template <typename T, typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator*(const T& x, const Decimal& d) { return Decimal(x) * d; }
 
template <typename T, typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator/(const T& x, const Decimal& d) { return Decimal(x) / d; }
 
ASPOSECPP_SHARED_API void PrintTo(const Decimal& d, ::std::ostream* os);
 
ASPOSECPP_SHARED_API std::ostream& operator<<(std::ostream& stream, const Decimal& decimal);
 
ASPOSECPP_SHARED_API std::wostream& operator<<(std::wostream& stream, const Decimal& decimal);
 
template<> struct IsBoxable<Decimal> : std::true_type {};
 
} // namespace System
 
namespace std
{
    template <>
    struct hash<System::Decimal>
    {
        std::size_t operator()(const System::Decimal& val) const
        {
            return static_cast<std::size_t>(val.GetHashCode());
        }
    };
}
 
 
#endif // _aspose_system_decimal_h_