csd.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stdexcept>  // for invalid_argument
#include <string>     // for basic_string, operator==, operator<<
 
#if __cpp_constexpr >= 201304
#    define CONSTEXPR14 constexpr
#else
#    define CONSTEXPR14 inline
#endif
 
namespace csd {
 
 
    constexpr int MAX_DECIMAL_PLACES = 20;
 
    constexpr unsigned int MIN_NONZERO_DIGITS = 1;
 
    class invalid_csd_format : public std::invalid_argument {
      public:
        explicit invalid_csd_format(const std::string& message) : std::invalid_argument(message) {}
    };
 
    extern auto to_csd(double decimal_value, int places) -> std::string;
 
    extern auto to_csd_i(int decimal_value) -> std::string;
 
    extern auto to_csdnnz(double decimal_value, unsigned int nnz) -> std::string;
 
    extern auto to_csdnnz_i(int decimal_value, unsigned int nnz) -> std::string;
 
    CONSTEXPR14 auto to_decimal_using_switch(const char* csd) -> double {
        // Handle integral part using int (bit shifts are faster than FP ops)
        auto integral = 0;
        for (; *csd != '.' && *csd != '\0'; ++csd) {
            switch (*csd) {
                case '0':
                    integral *= 2;
                    break;
                case '+':
                    integral = integral * 2 + 1;
                    break;
                case '-':
                    integral = integral * 2 - 1;
                    break;
                default:
                    throw std::invalid_argument("Work with 0, +, -, and . only");
            }
        }
        if (*csd == '\0') {
            return double(integral);
        }
        // Handle fractional part
        auto decimal_value = double(integral);
        auto scale = 0.5;
        for (++csd; *csd != '\0'; ++csd) {
            switch (*csd) {
                case '0':
                    break;
                case '+':
                    decimal_value += scale;
                    break;
                case '-':
                    decimal_value -= scale;
                    break;
                default:
                    throw std::invalid_argument("Fractional part work with 0, +, and - only");
            }
            scale /= 2;
        }
        return decimal_value;
    }
 
    CONSTEXPR14 auto to_decimal_integral(const char*& csd) -> int {
        auto decimal_value = 0;
 
        for (;; ++csd) {
            auto digit = *csd;
            if (digit == '0') {
                decimal_value <<= 1;
            } else if (digit == '+') {
                decimal_value = (decimal_value << 1) + 1;
            } else if (digit == '-') {
                decimal_value = (decimal_value << 1) - 1;
            } else if (digit == '.' || digit == '\0') {
                break;
            } else {
                throw std::invalid_argument("Work with 0, +, -, and . only");
            }
        }
 
        return decimal_value;
    }
 
    CONSTEXPR14 auto to_decimal_fractional(const char* csd) -> double {
        auto decimal_value = 0.0;
        auto scale = 0.5;
 
        for (++csd;; ++csd) {
            auto digit = *csd;
            if (digit == '0') {
            } else if (digit == '+') {
                decimal_value += scale;
            } else if (digit == '-') {
                decimal_value -= scale;
            } else if (digit == '\0') {
                break;
            } else {
                throw std::invalid_argument("Fractional part work with 0, +, and - only");
            }
            scale /= 2.0;
        }
 
        return decimal_value;
    }
 
    CONSTEXPR14 auto to_decimal(const char* csd) -> double {
        auto integral = to_decimal_integral(csd);
 
        if (*csd == '\0') {
            return double(integral);
        }
 
        auto fractional = to_decimal_fractional(csd);
        return double(integral) + fractional;
    }
 
    CONSTEXPR14 auto to_decimal_i(const char* csd) -> int { return to_decimal_integral(csd); }
 
}  // namespace csd