Compiler Explorer

Source code

#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cmath>
#include <iostream>
#include <map>
#include <optional>
#include <regex>
#include <string>
#include <string_view>
#include <utility>

enum class BaseTy {
    BIN = 2,
    OCT = 8,
    DEC = 10,
    HEX = 16
};

static const std::regex bin_regex(R"(*\-?[01]*\.?[01]*)");
static const std::regex oct_regex(R"(*\-?[0-7]*\.?[0-7]*)");
static const std::regex dec_regex(R"(*\-?[0-9]*\.?[0-9]*)");
static const std::regex hex_regex(R"(*\-?[0-9a-fA-F)*\.?[0-9a-fA-F]*)");

static const std::regex bin_exp_regex(R"(*\-?[01]*)");
static const std::regex oct_exp_regex(R"(*\-?[0-7]*)");
static const std::regex dec_exp_regex(R"(*\-?[0-9]*)");
static const std::regex hex_exp_regex(R"(*\-?[0-9a-fA-F)*)");

static const std::map<BaseTy, std::regex> ValidDigitSets = {
    {BaseTy::BIN, bin_regex},
    {BaseTy::OCT, oct_regex},
    {BaseTy::DEC, dec_regex},
    {BaseTy::HEX, hex_regex}
};

static const std::map<BaseTy, std::regex> ValidExponentSets = {
    {BaseTy::BIN, bin_exp_regex},
    {BaseTy::OCT, oct_exp_regex},
    {BaseTy::DEC, dec_exp_regex},
    {BaseTy::HEX, hex_exp_regex}
};

static const auto match = [&](const std::string& digits, const std::regex& regex) -> bool {
    std::smatch base_match;
    return std::regex_match(digits, base_match, regex);
};

// Check to see if the sequence evaluates to 0, ignore both '-' and '.' characters.
static const auto isZero = [](const std::string_view& sv) -> bool {
    if (sv.empty()) { return true; }

uint16_t zeros = 0;
    uint16_t non_zeros = 0;
    for (auto& c : sv) {
        if (c == '-' || c == '.') {
            non_zeros++;
        }
        else {
            zeros++;
        }
    }
    return (zeros == (sv.size() - non_zeros));
};
    
template<BaseTy BASE = BaseTy::DEC>
class Fpn {
public:
    const uint16_t Base = static_cast<uint16_t>(BASE);

public:
    std::string digits_{ "0" };
    int64_t integral_value_{ 0 };
    uint64_t decimal_value_{ 0 };
    int64_t exponent_{1};
    size_t decimal_location_{1};

Fpn() = default;
    Fpn(const std::string_view digit_sequence, const std::string_view exponent = "") {
        // Assert to make sure that the input has the correct character sets
        assert(
            (match(digit_sequence.data(), ValidDigitSets.at(BASE)) ||
                match(exponent.data(), ValidExponentSets.at(BASE))) &&
                "invalid character sequence entered"
            );

// If the input sequence is empty default everything, early return
        if (digit_sequence.empty() || isZero(digit_sequence.data())) {
            digits_ = { "0.0" };
            integral_value_ = 0;
            decimal_value_ = 0;
            decimal_location_ = 1;
            exponent_ = 1;
            return;
        }

// if exponent is empty we can treat this as a value raised to the 1st power
        exponent_ = exponent.empty() ? 1 : std::stoi(exponent.data());
        if (exponent_ == 0) {
            digits_ = { "1" };
            integral_value_ = 1;
            decimal_value_ = 0;
            decimal_location_ = 1;
            return;
        }

// Set the digits_ member value... 
        digits_ = digit_sequence.data();

// Determine the location of the decimal point,
        // if it's not found, then assign it to the size of the sequence
        // We have to take into account if a `-` sign is present.

bool negative = (digits_[0] == '-');
        decimal_location_ = digits_.find_first_of('.');

if (!negative) {
            if (decimal_location_ == std::string::npos) {
                decimal_location_ = digits_.size();
            }
        }
        else {
            if (decimal_location_ == std::string::npos) {
                decimal_location_ = digits_.size() - 1;
            }
        }

integral_value_ = std::stoi(digits_.substr(0, decimal_location_));
        decimal_value_ = std::stoi(digits_.substr(decimal_location_ + 1, digits_.size()));
    }

};

int main() {
    Fpn large("314195.2");
    Fpn small("1.24");
    Fpn sample("420");

std::cout << "large:\n\t" 
                << "digits{" << large.digits_ << "}\n\t"
                << "integral = " << large.integral_value_ << "\n\t"
                << "decimal = " << large.decimal_value_ << "\n\t"
                << "dec loc = " << large.decimal_location_ << "\n\t"
                << "exponent = " << large.exponent_ << "\n\n";

std::cout << "small:\n\t" 
        << "digits{" << small.digits_ << "}\n\t"
        << "integral = " << small.integral_value_ << "\n\t"
        << "decimal = " << small.decimal_value_ << "\n\t"
        << "dec loc = " << small.decimal_location_ << "\n\t"
        << "exponent = " << small.exponent_ << "\n\n";

std::cout << "sample:\n\t" 
        << "digits{" << sample.digits_ << "}\n\t"
        << "integral = " << sample.integral_value_ << "\n\t"
        << "decimal = " << sample.decimal_value_ << "\n\t"
        << "dec loc = " << sample.decimal_location_ << "\n\t"
        << "exponent = " << sample.exponent_ << "\n\n";

return 0;
}