elastic_scaled_integer.h

Go to the documentation of this file.

 
//          Copyright John McFarlane 2015 - 2017.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file ../LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
 
 
#if !defined(CNL_ELASTIC_SCALED_INTEGER_H)
#define CNL_ELASTIC_SCALED_INTEGER_H
 
#include "_impl/charconv/descale.h"
#include "_impl/numbers/adopt_signedness.h"
#include "_impl/scaled/is_scaled_tag.h"
#include "_impl/scaled/power.h"
#include "elastic_integer.h"
#include "scaled_integer.h"
 
#include <algorithm>
#include <limits>
#include <type_traits>
 
namespace cnl {
    // cnl-specific definitions
 
 
    template<int Digits, scaled_tag Scale = power<>, class Narrowest = signed>
    using elastic_scaled_integer =
            scaled_integer<elastic_integer<Digits, Narrowest>, Scale>;
 
    // cnl::make_elastic_scaled_integer
 
 
    template<typename Narrowest = int, CNL_IMPL_CONSTANT_VALUE_TYPE Value = 0>
    [[nodiscard]] constexpr auto make_elastic_scaled_integer(constant<Value>)
            -> elastic_scaled_integer<
                    std::max(digits_v<constant<Value>> - trailing_bits(Value), 1),
                    power<trailing_bits(Value)>, Narrowest>
    {
        return Value;
    }
 
    // cnl::make_elastic_scaled_integer
 
    template<typename Narrowest = void, typename Integral = int>
    [[nodiscard]] constexpr auto make_elastic_scaled_integer(Integral const& value)
            -> elastic_scaled_integer<
                    std::numeric_limits<Integral>::digits, power<>,
                    typename std::conditional<
                            std::is_same<void, Narrowest>::value,
                            _impl::adopt_signedness_t<int, Integral>, Narrowest>::type>
    {
        return {value};
    }
 
    template<typename Narrowest = void, typename Rep = int, scaled_tag Scale = power<>>
    [[nodiscard]] constexpr auto make_elastic_scaled_integer(scaled_integer<Rep, Scale> const& value)
            -> elastic_scaled_integer<
                    std::numeric_limits<Rep>::digits, Scale,
                    typename std::conditional<
                            std::is_same<void, Narrowest>::value,
                            _impl::adopt_signedness_t<int, Rep>, Narrowest>::type>
    {
        return {value};
    }
 
    namespace _impl {
        template<integer auto ParsedSignificand, integer auto ParsedExponent, int ParsedRadix, int UdlRadix>
        [[nodiscard]] constexpr auto make_from_udl()
        {
            constexpr auto descaled{
                    descale<decltype(ParsedSignificand), UdlRadix, true>(
                            ParsedSignificand,
                            power<ParsedExponent, ParsedRadix>{})};
            constexpr auto rep{make_elastic_integer(constant<descaled.significand>{})};
            return from_rep<scaled_integer<
                    decltype(rep),
                    power<descaled.exponent, descaled.radix>>>(rep);
        }
    }
 
    namespace literals {
        // cnl::literals::operator "" _cnl
 
 
        template<char... Chars>
        [[nodiscard]] constexpr auto operator"" _cnl()
        {
            constexpr auto parsed{_impl::parse_real<intmax_t, Chars...>()};
            return _impl::make_from_udl<parsed.significand, parsed.exponent, parsed.radix, parsed.radix>();
        }
 
 
        template<char... Chars>
        [[nodiscard]] constexpr auto operator"" _cnl2()
        {
            constexpr auto parsed{_impl::parse_real<intmax_t, Chars...>()};
            return _impl::make_from_udl<parsed.significand, parsed.exponent, parsed.radix, 2>();
        }
    }
}
 
#endif  // CNL_ELASTIC_SCALED_INTEGER_H