box_floating_point.hpp

Go to the documentation of this file.

#pragma once
#include "box.hpp"
#include "decimal.hpp"
#include "real.hpp"
#include <cmath>

namespace xtd {
  template<typename type_t>
  requires xtd::real<type_t>
  class box_floating_point : public xtd::box<type_t> {
  public:
    box_floating_point() = default;
    box_floating_point(const type_t& value) : xtd::box<type_t>(value) {}
    box_floating_point(const box_floating_point&) = default;
    box_floating_point(box_floating_point&&) = default;
    box_floating_point& operator =(const box_floating_point&) = default;
    
    
    static constexpr type_t epsilon = std::numeric_limits<type_t>::denorm_min();
    static constexpr type_t max_value = std::numeric_limits<type_t>::max();
    static constexpr type_t min_value = std::numeric_limits<type_t>::lowest();
    static constexpr type_t NaN = std::numeric_limits<type_t>::quiet_NaN();
    static constexpr type_t negative_infinity = -std::numeric_limits<type_t>::infinity();
    static constexpr type_t positive_infinity = +std::numeric_limits<type_t>::infinity();
    
    
    [[nodiscard]] static auto is_finite(type_t value) noexcept -> bool {return !is_infinity(value) && !is_NaN(value);}
    [[nodiscard]] static auto is_infinity(type_t value) noexcept -> bool {return is_negative_infinity(value) || is_positive_infinity(value);}
    
    [[nodiscard]] static auto is_NaN(type_t value) noexcept -> bool {return std::fpclassify(value) == FP_NAN;}

    [[nodiscard]] static auto is_negative_infinity(type_t value) noexcept -> bool {return value == negative_infinity;}

    [[nodiscard]] static auto is_normal(type_t value) noexcept -> bool {return std::fpclassify(value) == FP_NORMAL;}

    [[nodiscard]] static auto is_positive_infinity(type_t value) noexcept -> bool {return value == positive_infinity;}

    [[nodiscard]] static auto is_subnormal(type_t value) noexcept -> bool {return std::fpclassify(value) == FP_SUBNORMAL;}

    [[nodiscard]] static auto is_valid(type_t value) noexcept -> bool {return !is_NaN(value) && !is_infinity(value) && value >= static_cast<xtd::decimal>(min_value) && value <= static_cast<xtd::decimal>(max_value);}

    [[nodiscard]] static auto is_zero(type_t value) noexcept -> bool {return std::fpclassify(value) == FP_ZERO;}
 
    using box<type_t>::parse;
    [[nodiscard]] static auto parse(const xtd::string& value, xtd::number_styles styles) -> type_t {return xtd::parse<type_t>(value, styles);}
    
    using box<type_t>::try_parse;
    [[nodiscard]] static auto try_parse(const xtd::string& value, type_t& result, xtd::number_styles styles) noexcept -> bool {return xtd::try_parse<type_t>(value, result, styles);}
  };
}