LMCAS::Irrational::EnclosureRound结构体 参考

LMCAS::Irrational::EnclosureRound 的协作图:

Public 类型
using	Bounds = detail::ExactConstantInterval

Public 成员函数
	EnclosureRound (ComputationContext &context, std::size_t precision)
const Bounds &	constant (bool use_pi)
Bounds	multiply_positive (const Bounds &a, const Bounds &b)
Bounds	power (Bounds base, const BigInt &exponent)
const Bounds &	radical (const BigInt &radicand)

静态 Public 成员函数
static Result< Sign >	refine_sign (const Terms &numerator, const Terms &denominator, bool numerator_zero, bool transcendental, ComputationContext &context, detail::ExactBoundArithmetic &arithmetic, const char *operation)
static int	separated_sign (const Bounds &bounds)
static bool	validate_terms (const Terms &terms, detail::ExactBoundArithmetic &arithmetic, bool &transcendental)

Public 属性
detail::ExactBoundArithmetic	arithmetic
ComputationContext &	context
std::optional< Bounds >	e
std::optional< Bounds >	pi
std::size_t	precision
std::map< BigInt, Bounds >	radicals

详细描述

在文件 irrational_arithmetic.cpp 第 137 行定义.

成员类型定义说明

Bounds

using LMCAS::Irrational::EnclosureRound::Bounds = detail::ExactConstantInterval

在文件 irrational_arithmetic.cpp 第 138 行定义.

构造及析构函数说明

EnclosureRound()

LMCAS::Irrational::EnclosureRound::EnclosureRound ( ComputationContext & context, std::size_t precision )

inline

在文件 irrational_arithmetic.cpp 第 146 行定义.

        : context(context), precision(precision),
          arithmetic(context, "Irrational::sign_checked") {}

引用了 arithmetic, context , 以及 precision.

被这些函数引用 refine_sign().

这是这个函数的调用关系图:

成员函数说明

constant()

const Bounds & LMCAS::Irrational::EnclosureRound::constant ( bool use_pi )

inline

在文件 irrational_arithmetic.cpp 第 176 行定义.

                                        {
        auto& cached = use_pi ? pi : e;
        if (!cached) {
            auto bounds = use_pi ? detail::exact_pi_bounds(precision, context)
                                 : detail::exact_e_bounds(precision, context);
            if (!bounds) throw bounds.error();
            cached = std::move(bounds.value());
        }
        return *cached;
    }

引用了 context, e, LMCAS::detail::exact_e_bounds(), LMCAS::detail::exact_pi_bounds(), pi , 以及 precision.

函数调用图:

multiply_positive()

Bounds LMCAS::Irrational::EnclosureRound::multiply_positive ( const Bounds & a, const Bounds & b )

inline

在文件 irrational_arithmetic.cpp 第 187 行定义.

                                                               {
        return {arithmetic.mul(a.first, b.first), arithmetic.mul(a.second, b.second)};
    }

引用了 LMCAS::a, arithmetic, LMCAS::b , 以及 LMCAS::detail::ExactBoundArithmetic::mul().

被这些函数引用 power().

函数调用图:

这是这个函数的调用关系图:

power()

Bounds LMCAS::Irrational::EnclosureRound::power ( Bounds base, const BigInt & exponent )

inline

在文件 irrational_arithmetic.cpp 第 191 行定义.

                                                      {
        arithmetic.bits(exponent.bit_length());
        BigInt remaining = exponent.abs();
        Bounds result{Rational(1), Rational(1)};
        while (!remaining.is_zero()) {
            arithmetic.step();
            if (remaining.is_odd()) result = multiply_positive(result, base);
            remaining >>= 1;
            if (!remaining.is_zero()) base = multiply_positive(base, base);
        }
        if (exponent.is_negative())
            return {arithmetic.div(Rational(1), result.second),
                    arithmetic.div(Rational(1), result.first)};
        return result;
    }

引用了 arithmetic, LMCAS::detail::ExactBoundArithmetic::bits(), LMCAS::detail::ExactBoundArithmetic::div(), LMCAS::exponent, multiply_positive() , 以及 LMCAS::detail::ExactBoundArithmetic::step().

函数调用图:

radical()

const Bounds & LMCAS::Irrational::EnclosureRound::radical ( const BigInt & radicand )

inline

在文件 irrational_arithmetic.cpp 第 150 行定义.

                                                  {
        auto found = radicals.find(radicand);
        if (found != radicals.end()) return found->second;
        arithmetic.step();
        if (radicand.is_negative() || radicand.is_zero())
            throw CasError{CasErrc::InternalInvariant,
                           "nonpositive normalized radicand", "Irrational::sign_checked"};
        if (radicand == BigInt(1))
            return radicals.emplace(radicand, Bounds{Rational(1), Rational(1)}).first->second;
        const BigInt scale = arithmetic.dyadic_scale(precision);
        const auto shift = arithmetic.growth(precision, precision);
        arithmetic.growth(radicand.bit_length(), shift);
        if (shift > std::numeric_limits<mp_size_t>::max())
            throw CasError{CasErrc::ResourceLimit,
                           "radical shift size exceeded", "Irrational::sign_checked"};
        const BigInt scaled = radicand << static_cast<mp_size_t>(shift);
        arithmetic.step();
        const BigInt lower = scaled.sqrt();
        arithmetic.growth(lower.bit_length(), lower.bit_length());
        const bool exact = lower * lower == scaled;
        arithmetic.growth(lower.bit_length(), 1);
        const BigInt upper = exact ? lower : lower + BigInt(1);
        return radicals.emplace(radicand, Bounds{Rational(lower, scale),
                                                  Rational(upper, scale)}).first->second;
    }

引用了 arithmetic, LMCAS::detail::ExactBoundArithmetic::dyadic_scale(), LMCAS::detail::ExactBoundArithmetic::growth(), LMCAS::InternalInvariant, LMCAS::lower, precision, radicals, LMCAS::ResourceLimit, LMCAS::detail::ExactBoundArithmetic::step() , 以及 LMCAS::upper.

函数调用图:

refine_sign()

Result< Sign > LMCAS::Irrational::EnclosureRound::refine_sign ( const Terms & numerator, const Terms & denominator, bool numerator_zero, bool transcendental, ComputationContext & context, detail::ExactBoundArithmetic & arithmetic, const char * operation )

inlinestatic

不同规范无平方因子根式在 Q 上线性无关，故非空纯根式和非零，细化过程在数学上终止； 实际执行仍受调用方资源预算限制。

在文件 irrational_arithmetic.cpp 第 232 行定义.

                                                                       {
        /**
         * @brief 不同规范无平方因子根式在 Q 上线性无关，故非空纯根式和非零，细化过程在数学上终止；
         * 实际执行仍受调用方资源预算限制。
         */
        for (std::size_t precision = 32;;) {
            arithmetic.step();
            EnclosureRound round(context, precision);
            const auto denominator_bounds = terms_bounds(denominator, round);
            const int denominator_sign = separated_sign(denominator_bounds);
            if (denominator_sign != 0) {
                if (numerator_zero) { return Sign::Zero; }
                const auto numerator_bounds = terms_bounds(numerator, round);
                const int numerator_sign = separated_sign(numerator_bounds);
                if (numerator_sign != 0) {
                    return numerator_sign == denominator_sign ? Sign::Positive : Sign::Negative;
                }
            }
            if (transcendental && precision == 4096) {
                return Result<Sign>::failure(CasErrc::Inconclusive,
                    "pi/e enclosure did not separate zero at 4096 bits", operation);
            }
            if (precision > std::numeric_limits<std::size_t>::max() / 2) {
                return Result<Sign>::failure(CasErrc::ResourceLimit,
                                             "refinement size exceeded", operation);
            }
            precision *= 2;
        }
    }

引用了 EnclosureRound(), arithmetic, context, LMCAS::denominator, LMCAS::Result< T >::failure(), LMCAS::Inconclusive, LMCAS::Negative, LMCAS::Positive, precision, LMCAS::ResourceLimit, LMCAS::round(), separated_sign(), LMCAS::detail::ExactBoundArithmetic::step() , 以及 LMCAS::Zero.

函数调用图:

separated_sign()

int LMCAS::Irrational::EnclosureRound::separated_sign ( const Bounds & bounds )

inlinestatic

在文件 irrational_arithmetic.cpp 第 225 行定义.

                                                    {
        const auto lower = bounds.first.get_numerator();
        if (!lower.is_zero() && !lower.is_negative()) { return 1; }
        if (bounds.second.get_numerator().is_negative()) { return -1; }
        return 0;
    }

引用了 LMCAS::lower.

被这些函数引用 refine_sign().

这是这个函数的调用关系图:

validate_terms()

bool LMCAS::Irrational::EnclosureRound::validate_terms ( const Terms & terms, detail::ExactBoundArithmetic & arithmetic, bool & transcendental )

inlinestatic

在文件 irrational_arithmetic.cpp 第 207 行定义.

                                                                      {
        bool zero = true;
        for (const auto& term : terms) {
            arithmetic.step();
            arithmetic.bits(term.second.get_numerator().bit_length());
            arithmetic.bits(term.second.get_denominator().bit_length());
            arithmetic.bits(term.first.radicand.bit_length());
            arithmetic.bits(term.first.pi_power.bit_length());
            arithmetic.bits(term.first.e_power.bit_length());
            if (term.second.is_zero()) { continue; }
            zero = false;
            transcendental |= !term.first.pi_power.is_zero() ||
                              !term.first.e_power.is_zero();
        }
        return zero;
    }

引用了 arithmetic, LMCAS::detail::ExactBoundArithmetic::bits() , 以及 LMCAS::detail::ExactBoundArithmetic::step().

函数调用图:

类成员变量说明

arithmetic

detail::ExactBoundArithmetic LMCAS::Irrational::EnclosureRound::arithmetic

在文件 irrational_arithmetic.cpp 第 141 行定义.

被这些函数引用 EnclosureRound(), multiply_positive(), power(), radical(), refine_sign() , 以及 validate_terms().

context

ComputationContext& LMCAS::Irrational::EnclosureRound::context

在文件 irrational_arithmetic.cpp 第 139 行定义.

被这些函数引用 EnclosureRound(), constant() , 以及 refine_sign().

e

std::optional<Bounds> LMCAS::Irrational::EnclosureRound::e

在文件 irrational_arithmetic.cpp 第 144 行定义.

被这些函数引用 constant().

pi

std::optional<Bounds> LMCAS::Irrational::EnclosureRound::pi

在文件 irrational_arithmetic.cpp 第 143 行定义.

被这些函数引用 constant().

precision

std::size_t LMCAS::Irrational::EnclosureRound::precision

在文件 irrational_arithmetic.cpp 第 140 行定义.

被这些函数引用 EnclosureRound(), constant(), radical() , 以及 refine_sign().

radicals

std::map<BigInt, Bounds> LMCAS::Irrational::EnclosureRound::radicals

在文件 irrational_arithmetic.cpp 第 142 行定义.

被这些函数引用 radical().

---

该结构体的文档由以下文件生成:

• src/irrational_arithmetic.cpp