Numeric Type Implementation

[bigerl]

Implemented Types:

• xsd:decimal -> 128 bit decimal double
  • xsd:integer -> int128_t
    • xsd:long -> int64_t
      • xsd:int -> int32_t
        • xsd:short -> int16_t
          • xsd:byte -> int8_t
    • xsd:nonNegativeInteger -> uint128_t
      • xsd:positiveInteger -> -> uint128_t (or wrapper)
      • xsd:unisngedLong -> uint64_t
        • xsd:unsigendInt -> uint32_t
          • xsd:unsignedShort -> uint16_t
            • xsd:unsignedByte -> uint8_t
    • xsd:nonPostiveInteger -> int128_t (or wrapper)
      • xsd:negativeInteger -> int128_t (or wrapper)
• xsd:float -> float
• xsd:double -> double
• owl:rational -> ?
• owl:real -> ?

Ideal would be a library with:

• runtime arbitrary precision
• support for basic operations +-*/...
• support for Integers and Decimals
• support for nonNegative = unsigned integer
• explicit support for positiveInteger, nonPostiveInteger, negativeInteger is not required (use Integer or write wrapper)
• support for fancy pointers and custom allocators

Options for arbitrary precision types:

• use multi-precision library, e.g.:
  • https://github.com/Xilinx/HLS_arbitrary_Precision_Types / https://docs.xilinx.com/r/2020.2-English/ug1399-vitis-hls/Arbitrary-Precision-Data-Types-Library
    • +: sound implementation, also support for fixed-point typed
    • - compile time precision
• 128 bit decimal double (IEEE-754 2008) https://bloomberg.github.io/bde/knowledge_base/feature_index.html#decimal-floating-point / https://bloomberg.github.io/bde-resources/doxygen/bde_api_prod/namespacebdldfp.html#a09749072ea49a21ac8b190a712f99dd5 / https://github.com/bloomberg/bde/tree/master/groups/bdl/bdldfp
• https://github.com/Kronuz/uinteger_t
• (u)int128_t https://github.com/cpsusie/cjm-numerics

Options for arbitrary precision floating decimals:

• mpdecimal/2.5.1

Starting Points for own implementations could be:

• https://github.com/michaeljclark/bignum
• https://github.com/python/cpython/blob/main/Objects/longobject.c

signature could be something like:

template<class Allocator = std::allocator<uint32_t>>
class Integer {
    using ptr_type = typename std::allocator_traits<Allocator>::pointer;
    std::size_t count_;
    union {
        size_t small;
        ptr_type big;
    };
   Allocator allocator_;

public:
    consteval Integer() : count_(0), small(0) {}

    Integer(std::string_view str_repr, Allocator const &alloc = Allocator()), allocator_(alloc) {
        std::vector<uint32_t> x{alloc};
        uint32_t buffer[32] = {};
        count_ = parse(str_repr, buffer);
        switch (count_) {
            case 0UL:
                small = {};
                break;
            case 1UL:
                small = buffer[0];
                break;
            case 2UL:
                small = buffer[0] | (uint64_t(buffer[1]) << 32);
                break;
            default: {
                big = std::allocator_traits<Allocator>::allocate(allocator_, count_);
                std::memcpy(std::to_address(big), buffer, sizeof(uint32_t) * count_);
            }
        }
    }
}

This needs more research

[Clueliss]

Implementation takes place in branch feature/numeric-types.

I am currently using boost::multiprecision for xsd:decimal, xsd:integer, xsd:nonNegativeInteger (rational can also be implemented using it). This is by no means a final decision; it was just really easy to integrate into cmake and covers all our needs. But if there is anything wrong with the library then I will obviously change it to something different.

[Clueliss]

#64 needs to be fixed first
alternatively: actually rely on 128bit integers instead of ap ones; and accept the standard violation by utilizing modular arithmetic, and incorrectly implementing xsd:positiveInteger and xsd:negativeInteger by allowing 0 values.

[Clueliss]

#82