LMCAS::detail::anonymous_namespace{exact_root.cpp} 命名空间参考

函数
ApproxReal	approximate_component (const Rational &lower, const Rational &upper)
Result< ApproxReal >	approximate_real_isolation (ExactRealAlgebraic isolation, const NumericEvaluationOptions &options, ComputationContext &context, const std::string &operation)
double	conversion_ulp (double value)
bool	valid_options (const NumericEvaluationOptions &options)

函数说明

approximate_component()

ApproxReal LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_component	(	const Rational &	lower,
		const Rational &	upper )

在文件 exact_root.cpp 第 79 行定义.

                           {
    const double lower_value = lower.to_double();
    const double upper_value = upper.to_double();
    const double value =
        lower_value + (upper_value - lower_value) * 0.5;
    const double error = std::abs(upper_value - lower_value) * 0.5 +
        conversion_ulp(lower_value) + conversion_ulp(upper_value) +
        conversion_ulp(value);
    return ApproxReal{value, error, NumericStatus::Finite};
}

引用了 approximate_component(), conversion_ulp(), LMCAS::Finite, LMCAS::lower, LMCAS::upper , 以及 LMCAS::value.

被这些函数引用 approximate_component().

函数调用图:

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

approximate_real_isolation()

Result< ApproxReal > LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation	(	ExactRealAlgebraic	isolation,
		const NumericEvaluationOptions &	options,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_root.cpp 第 37 行定义.

                                {
    while (isolation.lower != isolation.upper) {
        const bool positive = isolation.lower > Rational(0) &&
            isolation.upper <= Rational(2) * isolation.lower;
        const bool negative = isolation.upper < Rational(0) &&
            isolation.lower >= Rational(2) * isolation.upper;
        if (positive || negative) break;
        auto narrowed = refine_exact_real_algebraic(isolation, context, operation);
        if (!narrowed) return Result<ApproxReal>::failure(narrowed.error());
    }
    const double scale = std::min(
        std::abs(isolation.lower.to_double()), std::abs(isolation.upper.to_double()));
    const double absolute_tolerance = std::min(
        options.absolute_tolerance,
        std::max(std::numeric_limits<double>::denorm_min(),
                 options.relative_tolerance * scale));
    auto refined = refine_exact_real_algebraic_to_tolerance(
        isolation, absolute_tolerance, options.relative_tolerance,
        context, operation);
    if (!refined) return Result<ApproxReal>::failure(refined.error());
    const double lower = isolation.lower.to_double();
    const double upper = isolation.upper.to_double();
    const double value = lower + (upper - lower) * 0.5;
    const double error = std::abs(upper - lower) * 0.5 +
        conversion_ulp(lower) + conversion_ulp(upper) +
        conversion_ulp(value);
    if (!std::isfinite(value) || !std::isfinite(error) ||
        (value == 0.0 &&
         (isolation.lower > Rational(0) || isolation.upper < Rational(0)))) {
        return Result<ApproxReal>::failure(
            CasErrc::NumericFailure,
            "certified root enclosure could not be represented as finite double",
            operation);
    }
    return Result<ApproxReal>::success(
        ApproxReal{value, error, NumericStatus::Finite});
}

引用了 LMCAS::detail::absolute_tolerance, approximate_real_isolation(), LMCAS::detail::context, conversion_ulp(), LMCAS::Result< T >::failure(), LMCAS::Finite, LMCAS::detail::ExactRealAlgebraic::lower, LMCAS::lower, LMCAS::NumericFailure, LMCAS::detail::operation, LMCAS::options, LMCAS::detail::refine_exact_real_algebraic(), LMCAS::detail::refine_exact_real_algebraic_to_tolerance(), LMCAS::Result< T >::success(), LMCAS::detail::ExactRealAlgebraic::upper, LMCAS::upper , 以及 LMCAS::value.

被这些函数引用 approximate_real_isolation().

函数调用图:

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

conversion_ulp()

double LMCAS::detail::anonymous_namespace{exact_root.cpp}::conversion_ulp

(

double

value

)

在文件 exact_root.cpp 第 19 行定义.

                                    {
    if (!std::isfinite(value)) {
        return std::numeric_limits<double>::infinity();
    }
    const double upward = std::nextafter(
        value, std::numeric_limits<double>::infinity());
    const double downward = std::nextafter(
        value, -std::numeric_limits<double>::infinity());
    double spacing = 0.0;
    if (std::isfinite(upward)) {
        spacing = std::max(spacing, std::abs(upward - value));
    }
    if (std::isfinite(downward)) {
        spacing = std::max(spacing, std::abs(value - downward));
    }
    return spacing;
}

引用了 conversion_ulp() , 以及 LMCAS::value.

被这些函数引用 approximate_component(), approximate_real_isolation() , 以及 conversion_ulp().

函数调用图:

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

valid_options()

bool LMCAS::detail::anonymous_namespace{exact_root.cpp}::valid_options

(

const NumericEvaluationOptions &

options

)

在文件 exact_root.cpp 第 12 行定义.

                                                            {
    return options.absolute_tolerance > 0.0 &&
           options.relative_tolerance > 0.0 &&
           std::isfinite(options.absolute_tolerance) &&
           std::isfinite(options.relative_tolerance);
}

引用了 LMCAS::options , 以及 valid_options().

被这些函数引用 valid_options().

函数调用图:

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