Numeric.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
// and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable OnixS Software
// Services Agreement (the Agreement) and Customer end user license agreements granting
// a non-assignable, non-transferable and non-exclusive license to use the software
// for it's own data processing purposes under the terms defined in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or reproduction of any
// part of this source code or associated reference material to any other location for further
// reproduction or redistribution, and any amendments to this copyright notice, are expressly
// prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in accordance with
// the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include "OnixS/CME/DropCopy/Export.h"
 
#include <cassert>
#include <cmath>
#include <ostream>
#include <stdexcept>
#include <string>
 
namespace OnixS { namespace CME { namespace DropCopy {
 
typedef int Int32;
typedef unsigned int UInt32;
 
typedef long long Int64;
typedef unsigned long long UInt64;
 
typedef double Double;
 
typedef Int64 DecimalMantissa;
typedef Int32 DecimalExponent;

class ONIXS_CME_DROP_COPY_EXPORT Decimal
{
public:
    Decimal(DecimalMantissa mantissa = 0, DecimalExponent exponent = 0);

    Decimal(Double value, size_t precision);

    Decimal(const Decimal& other);

    DecimalMantissa mantissa() const;

    void mantissa(DecimalMantissa);

    DecimalExponent exponent() const;

    void exponent(DecimalExponent);

    bool operator==(const Decimal&) const;

    bool operator!=(const Decimal&) const;

    bool operator<(const Decimal&) const;

    bool operator>(const Decimal&) const;

    operator Int32() const;

    operator UInt32() const;

    operator Int64() const;

    operator UInt64() const;

    operator Double() const;

    bool toNumber(Int32&) const;

    bool toNumber(UInt32&) const;

    bool toNumber(Int64&) const;

    bool toNumber(UInt64&) const;

    bool toNumber(Double&) const;

    Double toDoubleUnchecked() const;

    static Decimal fromDoubleUnchecked(Double value, size_t precision);

    void toString(std::string&) const;

    std::string toString() const;

    Decimal& operator=(const Decimal& other);

    static bool tryParse(const char* buffer, size_t bufferSize, Decimal&);

    static Decimal parse(const char* buffer, size_t bufferSize);
 
private:
    DecimalMantissa mantissa_;

    DecimalExponent exponent_;
};
 
inline Decimal::Decimal(DecimalMantissa mantissa, DecimalExponent exponent)
  : mantissa_(mantissa)
  , exponent_(exponent)
{
}
 
inline Decimal::Decimal(const Decimal& other)
  : mantissa_(other.mantissa_)
  , exponent_(other.exponent_)
{
}
 
inline DecimalMantissa Decimal::mantissa() const
{
    return mantissa_;
}
 
inline void Decimal::mantissa(DecimalMantissa value)
{
    mantissa_ = value;
}
 
inline DecimalExponent Decimal::exponent() const
{
    return exponent_;
}
 
inline void Decimal::exponent(DecimalExponent value)
{
    exponent_ = value;
}
 
inline Decimal& Decimal::operator=(const Decimal& other)
{
    mantissa_ = other.mantissa_;
    exponent_ = other.exponent_;
 
    return *this;
}
 
inline Decimal::operator Int32() const
{
    Int32 number;
 
    if (toNumber(number))
    {
        return number;
    }
 
    throw std::domain_error("Cannot cast value to target type. ");
}
 
inline Decimal::operator UInt32() const
{
    UInt32 number;
 
    if (toNumber(number))
    {
        return number;
    }
 
    throw std::domain_error("Cannot cast value to target type. ");
}
 
inline Decimal::operator Int64() const
{
    Int64 number;
 
    if (toNumber(number))
    {
        return number;
    }
 
    throw std::domain_error("Cannot cast value to target type. ");
}
 
inline Decimal::operator UInt64() const
{
    UInt64 number;
 
    if (toNumber(number))
    {
        return number;
    }
 
    throw std::domain_error("Cannot cast value to target type. ");
}
 
inline Decimal::operator Double() const
{
    Double number;
 
    if (toNumber(number))
    {
        return number;
    }
 
    throw std::domain_error("Cannot cast value to target type. ");
}
 
inline std::string Decimal::toString() const
{
    std::string presentation;
    toString(presentation);
    return presentation;
}
 
namespace NumericDetails {
static const int maxAbsPower10 = 20;
static const int powers10Size = maxAbsPower10 * 2 + 1; // Negative, positive and zero powers
 
static const double powers10[] = {1E-20, 1E-19, 1E-18, 1E-17, 1E-16, 1E-15, 1E-14, 1E-13, 1E-12,
                                  1E-11, 1E-10, 1E-9,  1E-8,  1E-7,  1E-6,  1E-5,  1E-4,  1E-3,
                                  1E-2,  1E-1,  1E0,   1E1,   1E2,   1E3,   1E4,   1E5,   1E6,
                                  1E7,   1E8,   1E9,   1E10,  1E11,  1E12,  1E13,  1E14,  1E15,
                                  1E16,  1E17,  1E18,  1E19,  1E20};
 
inline OnixS::CME::DropCopy::Double fastPower10(int power)
{
    const int offset = power + maxAbsPower10;
    if (offset >= 0 && offset < powers10Size)
    {
        return powers10[offset];
    }
 
    throw std::invalid_argument("Invalid power argument, must be in range [-20, 20]");
}
}
 
inline Double Decimal::toDoubleUnchecked() const
{
    using namespace NumericDetails;
    return mantissa_ * fastPower10(exponent_);
}
 
inline Decimal Decimal::fromDoubleUnchecked(Double value, size_t precision)
{
    using namespace NumericDetails;
    DecimalExponent convertedExponent = 0;
 
    Double dummy;
    if (fabs(modf(value, &dummy)) != 0.0)
    {
        const DecimalExponent exp = static_cast<DecimalExponent>(precision);
 
        // Apply last digit rounding
        const Double rounding = 0.5 * fastPower10(-exp);
        value += (value > 0) ? rounding : -rounding;
 
        value *= fastPower10(exp);
        convertedExponent = -exp;
    }
 
    return Decimal(static_cast<DecimalMantissa>(value), convertedExponent);
}

struct ONIXS_CME_DROP_COPY_EXPORT Number
{
    static bool tryParse(const char* buffer, size_t bufferSize, Int32& number);
    static bool tryParse(const char* buffer, size_t bufferSize, UInt32& number);
    static bool tryParse(const char* buffer, size_t bufferSize, Int64& number);
    static bool tryParse(const char* buffer, size_t bufferSize, UInt64& number);
    static bool tryParse(const char* buffer, size_t bufferSize, Double& number);
    static bool tryParse(const char* buffer, size_t bufferSize, Decimal& number);
};

struct ONIXS_CME_DROP_COPY_EXPORT DecimalComparator
{
    typedef bool (*CompareFunction)(const Decimal&, const Decimal&);

    const CompareFunction equal;
    const CompareFunction nonEqual;
    const CompareFunction less;
    const CompareFunction greater;

    DecimalComparator(
        const CompareFunction equalFunc,
        const CompareFunction nonEqualFunc,
        const CompareFunction lessFunc,
        const CompareFunction greaterFunc
    )
      : equal(equalFunc)
      , nonEqual(nonEqualFunc)
      , less(lessFunc)
      , greater(greaterFunc)
    {
    }
 
    // Assignment operator: not defined.
    DecimalComparator& operator=(const DecimalComparator&);

    bool fixedPoint() const;

    bool genericDecimal() const;
};

namespace GenericDecimal {
inline bool equal(const Decimal& lhs, const Decimal& rhs)
{
    return lhs == rhs;
}
 
inline bool nonEqual(const Decimal& lhs, const Decimal& rhs)
{
    return lhs != rhs;
}
 
inline bool less(const Decimal& lhs, const Decimal& rhs)
{
    return lhs < rhs;
}
 
inline bool greater(const Decimal& lhs, const Decimal& rhs)
{
    return lhs > rhs;
}
 
ONIXS_CME_DROP_COPY_EXPORT extern const DecimalComparator Comparator;
}

namespace FixedPointDecimal {
inline bool equal(const Decimal& lhs, const Decimal& rhs)
{
    assert(lhs.exponent() == rhs.exponent());
    return lhs.mantissa() == rhs.mantissa();
}
 
inline bool nonEqual(const Decimal& lhs, const Decimal& rhs)
{
    assert(lhs.exponent() == rhs.exponent());
    return lhs.mantissa() != rhs.mantissa();
}
 
inline bool less(const Decimal& lhs, const Decimal& rhs)
{
    assert(lhs.exponent() == rhs.exponent());
    return lhs.mantissa() < rhs.mantissa();
}
 
inline bool greater(const Decimal& lhs, const Decimal& rhs)
{
    assert(lhs.exponent() == rhs.exponent());
    return lhs.mantissa() > rhs.mantissa();
}
 
ONIXS_CME_DROP_COPY_EXPORT extern const DecimalComparator Comparator;
}
 
inline bool DecimalComparator::fixedPoint() const
{
    return this == &FixedPointDecimal::Comparator;
}
 
inline bool DecimalComparator::genericDecimal() const
{
    return this == &GenericDecimal::Comparator;
}
 
static const DecimalComparator& defaultDecimalComparator = GenericDecimal::Comparator;
 
}}}
 
namespace std {
 
// Outputs decimal into standard stream.
ONIXS_CME_DROP_COPY_EXPORT std::ostream&
operator<<(std::ostream&, const OnixS::CME::DropCopy::Decimal&);
 
}