LMCAS::detail::NumericEvaluator类 参考

#include </home/runner/work/docs/docs/LMCAS/src/internal/numeric_evaluation_support.hpp>

LMCAS::detail::NumericEvaluator 的协作图:

Public 成员函数
	NumericEvaluator (const NumericBindings &bindings, ComputationContext &context)
Result< ApproxReal >	evaluate (const std::shared_ptr< const SymbolicNode > &node)

Private 成员函数
Result< ApproxReal >	atan2 (const FunctionNode &node)
Result< ApproxReal >	extremum (const FunctionNode &node)
Result< ApproxReal >	function (const FunctionNode &node)
Result< ApproxReal >	norm (const std::array< const PowerNode *, 2 > &squares)
Result< ApproxReal >	number (const NumberNode &node)
Result< ApproxReal >	power (const PowerNode &node)
Result< ApproxReal >	product (const MultiplyNode &node)
Result< ApproxReal >	root (const std::shared_ptr< const SymbolicNode > &node)
Result< ApproxReal >	square_root (const NumberNode &node)
Result< ApproxReal >	sum (const AddNode &node)
Result< ApproxReal >	variable (const VariableNode &node)

Private 属性
const NumericBindings &	bindings_
ComputationContext &	context_

详细描述

在文件 numeric_evaluation_support.hpp 第 13 行定义.

构造及析构函数说明

NumericEvaluator()

LMCAS::detail::NumericEvaluator::NumericEvaluator ( const NumericBindings & bindings, ComputationContext & context )

inline

在文件 numeric_evaluation_support.hpp 第 15 行定义.

        : bindings_(bindings), context_(context) {}

引用了 LMCAS::bindings, bindings_, LMCAS::detail::context , 以及 context_.

成员函数说明

atan2()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::atan2 ( const FunctionNode & node )

private

在文件 numeric_evaluation_nodes.cpp 第 131 行定义.

                                                                   {
        if (node.arguments().size() != 2) {
            return numeric_failure(CasErrc::InvalidArgument, "atan2 requires two arguments");
        }
        auto y = evaluate(node.arguments()[0]);
        if (!y) return y;
        auto x = evaluate(node.arguments()[1]);
        if (!x) return x;
        return numeric_approximation(std::atan2(y.value().value, x.value().value));
}

引用了 evaluate(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::detail::numeric_approximation() , 以及 LMCAS::detail::numeric_failure().

被这些函数引用 function().

函数调用图:

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

evaluate()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::evaluate

(

const std::shared_ptr< const SymbolicNode > &

node

)

在文件 numeric_evaluation.cpp 第 36 行定义.

                                                                                           {
    auto entered = context_.enter_recursion(kOperation);
    if (!entered) {
        return Result<ApproxReal>::failure(entered.error());
    }
    RecursionScope scope(context_);
    if (!node) {
        return numeric_failure(CasErrc::InvalidArgument, "expression contains a null node");
    }
    if (const auto* value = dynamic_cast<const NumberNode*>(node.get())) {
        return number(*value);
    }
    if (const auto* value = dynamic_cast<const VariableNode*>(node.get())) {
        return variable(*value);
    }
    if (const auto* value = dynamic_cast<const AddNode*>(node.get())) {
        return sum(*value);
    }
    if (const auto* value = dynamic_cast<const MultiplyNode*>(node.get())) {
        return product(*value);
    }
    const auto squares = squared_norm_terms(*node);
    if (squares[0]) {
        return norm(squares);
    }
    if (const auto* value = dynamic_cast<const PowerNode*>(node.get())) {
        return power(*value);
    }
    if (dynamic_cast<const RootOfNode*>(node.get())) {
        return root(node);
    }
    if (const auto* value = dynamic_cast<const FunctionNode*>(node.get())) {
        return function(*value);
    }
    return numeric_failure(CasErrc::UnsupportedExpression,
                           "expression node is not real-numerically evaluable");
}

引用了 context_, LMCAS::ComputationContext::enter_recursion(), LMCAS::Result< T >::failure(), function(), LMCAS::InvalidArgument, LMCAS::detail::node(), norm(), number(), LMCAS::detail::numeric_failure(), power(), product(), root(), LMCAS::detail::squared_norm_terms(), sum(), LMCAS::UnsupportedExpression, LMCAS::value , 以及 variable().

被这些函数引用 atan2(), LMCAS::evaluate_numeric(), extremum(), function(), norm(), power(), product() , 以及 sum().

函数调用图:

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

extremum()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::extremum ( const FunctionNode & node )

private

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

                                                                      {
        if (node.arguments().empty()) {
            return numeric_failure(CasErrc::InvalidArgument, "min/max requires an argument");
        }
        auto first = evaluate(node.arguments().front());
        if (!first) return first;
        double value = first.value().value;
        for (std::size_t i = 1; i < node.arguments().size(); ++i) {
            auto next = evaluate(node.arguments()[i]);
            if (!next) return next;
            value = node.type() == FunctionNode::FuncType::Max
                        ? std::max(value, next.value().value)
                        : std::min(value, next.value().value);
        }
        return numeric_approximation(value);
}

引用了 evaluate(), LMCAS::InvalidArgument, LMCAS::FunctionNode::Max, LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure() , 以及 LMCAS::value.

被这些函数引用 function().

函数调用图:

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

function()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::function ( const FunctionNode & node )

private

在文件 numeric_evaluation.cpp 第 74 行定义.

                                                                      {
    if (node.type() == FunctionNode::FuncType::Infinity && node.arguments().empty()) {
        return Result<ApproxReal>::success(ApproxReal{
            std::numeric_limits<double>::infinity(), 0.0, NumericStatus::PositiveInfinity});
    }
    if (node.type() == FunctionNode::FuncType::Atan2) {
        return atan2(node);
    }
    if (node.type() == FunctionNode::FuncType::Max || node.type() == FunctionNode::FuncType::Min) {
        return extremum(node);
    }
    if (node.type() == FunctionNode::FuncType::Log &&
        node.arguments().size() == 2) {
        auto value = evaluate(node.arguments()[0]);
        if (!value) {
            return value;
        }
        auto base = evaluate(node.arguments()[1]);
        if (!base) {
            return base;
        }
        const double numeric_value = value.value().value;
        const double numeric_base = base.value().value;
        if (!(numeric_value > 0.0)) {
            return numeric_failure(
                CasErrc::DomainError,
                "logarithm requires a positive real argument");
        }
        if (!(numeric_base > 0.0) || numeric_base == 1.0) {
            return numeric_failure(
                CasErrc::DomainError,
                "logarithm base must be positive and not equal to one");
        }
        return numeric_approximation(
            std::log(numeric_value) / std::log(numeric_base));
    }
    if (node.arguments().size() != 1) {
        return numeric_failure(CasErrc::UnsupportedExpression,
                               "function is not supported by real numeric evaluation");
    }
    if (node.type() == FunctionNode::FuncType::Sqrt) {
        if (const auto* value = dynamic_cast<const NumberNode*>(node.arguments()[0].get())) {
            return square_root(*value);
        }
    }
    auto argument = evaluate(node.arguments()[0]);
    if (!argument) {
        return argument;
    }
    return evaluate_unary_numeric(node.type(), argument.value().value);
}

引用了 LMCAS::FunctionNode::Atan2, atan2(), LMCAS::DomainError, evaluate(), LMCAS::detail::evaluate_unary_numeric(), extremum(), LMCAS::FunctionNode::Infinity, LMCAS::FunctionNode::Log, LMCAS::FunctionNode::Max, LMCAS::FunctionNode::Min, LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::PositiveInfinity, LMCAS::FunctionNode::Sqrt, square_root(), LMCAS::Result< T >::success(), LMCAS::UnsupportedExpression , 以及 LMCAS::value.

被这些函数引用 evaluate().

函数调用图:

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

norm()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::norm ( const std::array< const PowerNode *, 2 > & squares )

private

在文件 numeric_evaluation_nodes.cpp 第 159 行定义.

                                                                                      {
    auto first = evaluate(squares[0]->base());
    if (!first) return first;
    if (!squares[1]) return numeric_approximation(std::abs(first.value().value));
    auto second = evaluate(squares[1]->base());
    if (!second) return second;
    return numeric_approximation(std::hypot(first.value().value, second.value().value));
}

引用了 evaluate() , 以及 LMCAS::detail::numeric_approximation().

被这些函数引用 evaluate().

函数调用图:

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

number()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::number ( const NumberNode & node )

private

在文件 numeric_evaluation_nodes.cpp 第 8 行定义.

                                                                  {
    double value = 0.0;
    try {
        if (std::holds_alternative<BigInt>(node.value())) {
            value = std::get<BigInt>(node.value()).to_double();
        } else {
            value = std::get<Rational>(node.value()).to_double();
        }
    } catch (const std::exception& error) {
        return numeric_failure(CasErrc::NumericFailure, error.what());
    }
    if (!std::isfinite(value)) {
        return numeric_failure(CasErrc::NumericFailure,
                       "exact number cannot be represented as a finite double");
    }
    return numeric_approximation(value);
}

引用了 LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::NumericFailure , 以及 LMCAS::value.

被这些函数引用 evaluate() , 以及 product().

函数调用图:

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

power()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::power ( const PowerNode & node )

private

在文件 numeric_evaluation_power.cpp 第 71 行定义.

                                                                {
    const auto* base_number = dynamic_cast<const NumberNode*>(node.base().get());
    const auto* exponent_number = dynamic_cast<const NumberNode*>(node.exponent().get());
    if (base_number && exponent_number) {
        const auto* exponent = std::get_if<Rational>(&exponent_number->value());
        if (exponent && *exponent == Rational(1, 2)) {
            auto step = context_.consume_steps(1, "evaluate_numeric");
            if (!step) return Result<ApproxReal>::failure(step.error());
            return square_root(*base_number);
        }
        if (exponent_number->is_negative_one()) {
            auto step = context_.consume_steps(2, "evaluate_numeric");
            if (!step) return Result<ApproxReal>::failure(step.error());
            if (base_number->is_zero()) {
                return numeric_failure(CasErrc::DomainError, "zero cannot be raised to a non-positive power");
            }
            try {
                if (const auto* integer = std::get_if<BigInt>(&base_number->value())) {
                    return numeric_approximation(Rational(BigInt(1), *integer).to_double());
                }
                const auto& rational = std::get<Rational>(base_number->value());
                return numeric_approximation(
                    Rational(rational.get_denominator(), rational.get_numerator()).to_double());
            } catch (const std::range_error& error) {
                return numeric_failure(CasErrc::NumericFailure, error.what());
            } catch (const std::overflow_error& error) {
                return numeric_failure(CasErrc::NumericFailure, error.what());
            } catch (const std::underflow_error& error) {
                return numeric_failure(CasErrc::NumericFailure, error.what());
            }
        }
    }
    auto base = evaluate(node.base());
    if (!base) {
        return base;
    }
    auto exponent = evaluate(node.exponent());
    if (!exponent) {
        return exponent;
    }
    const double base_value = base.value().value;
    const double exponent_value = exponent.value().value;
    if (base_value == 0.0 && exponent_value <= 0.0) {
        return numeric_failure(CasErrc::DomainError, "zero cannot be raised to a non-positive power");
    }
    if (std::signbit(base_value) && std::isfinite(exponent_value)) {
        const auto parity = exponent_parity(node, exponent_value);
        if (base_value < 0.0 && std::isfinite(base_value) && !parity.integral) {
            return numeric_failure(CasErrc::DomainError,
                                   "a negative real base requires an integer exponent");
        }
        if (parity.integral) {
            const double magnitude = std::pow(std::abs(base_value), exponent_value);
            if (magnitude == 0.0 && base_value != 0.0) {
                return numeric_failure(CasErrc::NumericFailure, "numeric power underflow");
            }
            return numeric_approximation(parity.odd ? -magnitude : magnitude);
        }
    }
    const double value = std::pow(base_value, exponent_value);
    if (value == 0.0 && base_value != 0.0) {
        return numeric_failure(CasErrc::NumericFailure, "numeric power underflow");
    }
    return numeric_approximation(value);
}

引用了 LMCAS::ComputationContext::consume_steps(), context_, LMCAS::DomainError, evaluate(), LMCAS::exponent, LMCAS::Result< T >::failure(), LMCAS::integer, LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::NumericFailure, LMCAS::rational(), square_root() , 以及 LMCAS::value.

被这些函数引用 evaluate() , 以及 product().

函数调用图:

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

product()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::product ( const MultiplyNode & node )

private

在文件 numeric_evaluation_nodes.cpp 第 67 行定义.

                                                                     {
    const bool exact_constants = std::all_of(node.operands().begin(), node.operands().end(),
        [](const auto& operand) {
            if (dynamic_cast<const NumberNode*>(operand.get())) return true;
            const auto* power = dynamic_cast<const PowerNode*>(operand.get());
            const auto* exponent = power
                ? dynamic_cast<const NumberNode*>(power->exponent().get()) : nullptr;
            return exponent && exponent->is_negative_one() &&
                   dynamic_cast<const NumberNode*>(power->base().get());
        });
    if (exact_constants) {
        Rational value(1);
        for (const auto& operand : node.operands()) {
            const auto* power = dynamic_cast<const PowerNode*>(operand.get());
            const auto* number = dynamic_cast<const NumberNode*>(
                power ? power->base().get() : operand.get());
            auto step = context_.consume_steps(power ? 3 : 1, "evaluate_numeric");
            if (!step) return Result<ApproxReal>::failure(step.error());
            Rational factor = std::holds_alternative<BigInt>(number->value())
                ? Rational(std::get<BigInt>(number->value()))
                : std::get<Rational>(number->value());
            if (power) {
                if (factor.is_zero()) {
                    return numeric_failure(CasErrc::DomainError, "zero cannot be raised to a non-positive power");
                }
                factor = Rational(factor.get_denominator(), factor.get_numerator());
            }
            value = value * factor;
            auto numerator_bits = context_.require_integer_bits(
                value.get_numerator().bit_length(), "evaluate_numeric");
            if (!numerator_bits) return Result<ApproxReal>::failure(numerator_bits.error());
            auto denominator_bits = context_.require_integer_bits(
                value.get_denominator().bit_length(), "evaluate_numeric");
            if (!denominator_bits) return Result<ApproxReal>::failure(denominator_bits.error());
        }
        try {
            return numeric_approximation(value.to_double());
        } catch (const std::exception& error) {
            return numeric_failure(CasErrc::NumericFailure, error.what());
        }
    }
    double value = 1.0;
    bool infinite = false;
    for (const auto& operand : node.operands()) {
        auto evaluated = evaluate(operand);
        if (!evaluated) return evaluated;
        const double factor = evaluated.value().value;
        const double multiplied = value * factor;
        if (multiplied == 0.0 && value != 0.0 && factor != 0.0) {
            return numeric_failure(CasErrc::NumericFailure, "numeric multiplication underflow");
        }
        value = multiplied;
        infinite = infinite || !evaluated.value().is_finite();
        if (std::isinf(value) && !infinite) {
            return numeric_failure(CasErrc::NumericFailure, "numeric evaluation produced a nonfinite result");
        }
    }
    if (std::isinf(value) && infinite) {
        return Result<ApproxReal>::success(ApproxReal{
            value, 0.0, value > 0 ? NumericStatus::PositiveInfinity : NumericStatus::NegativeInfinity});
    }
    return numeric_approximation(value);
}

引用了 LMCAS::ComputationContext::consume_steps(), context_, LMCAS::DomainError, evaluate(), LMCAS::Result< T >::failure(), LMCAS::NegativeInfinity, LMCAS::detail::node(), number(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::NumericFailure, LMCAS::PositiveInfinity, power(), LMCAS::ComputationContext::require_integer_bits(), LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 evaluate().

函数调用图:

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

root()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::root ( const std::shared_ptr< const SymbolicNode > & node )

private

在文件 numeric_evaluation_nodes.cpp 第 168 行定义.

                                                                                       {
    auto root_expression = LMCAS::detail::make_expression_ptr(node);
    auto root = rootof_evaluate_checked(root_expression, context_);
    if (!root) return Result<ApproxReal>::failure(root.error());
    return numeric_approximation(root.value());
}

引用了 context_, LMCAS::Result< T >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), root() , 以及 LMCAS::rootof_evaluate_checked().

被这些函数引用 evaluate() , 以及 root().

函数调用图:

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

square_root()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::square_root ( const NumberNode & node )

private

在文件 numeric_evaluation_power.cpp 第 31 行定义.

                                                                       {
    auto step = context_.consume_steps(1, "evaluate_numeric");
    if (!step) return Result<ApproxReal>::failure(step.error());
    if (node.is_zero()) return numeric_approximation(0.0);
    BigInt numerator;
    BigInt denominator(1);
    if (const auto* integer = std::get_if<BigInt>(&node.value())) {
        numerator = *integer;
    } else {
        const auto& rational = std::get<Rational>(node.value());
        numerator = rational.get_numerator();
        denominator = rational.get_denominator();
    }
    if (numerator.is_negative()) {
        return numeric_failure(CasErrc::DomainError,
                               "real square root requires a non-negative argument");
    }
    const auto num_bits = numerator.bit_length();
    const auto den_bits = denominator.bit_length();
    auto bits = context_.require_integer_bits(std::max(num_bits, den_bits), "evaluate_numeric");
    if (!bits) return Result<ApproxReal>::failure(bits.error());
    const bool reciprocal_scale = num_bits < den_bits;
    const auto difference = reciprocal_scale ? den_bits - num_bits : num_bits - den_bits;
    constexpr int max_scale = 2 * std::numeric_limits<double>::max_exponent;
    constexpr int min_scale = 2 * (std::numeric_limits<double>::digits -
                                   std::numeric_limits<double>::min_exponent + 1);
    if (difference > static_cast<std::size_t>(reciprocal_scale ? min_scale : max_scale)) {
        return numeric_failure(CasErrc::NumericFailure, "numeric square root is outside the floating-point range");
    }
    const auto shift = difference - difference % 2;
    if (reciprocal_scale) numerator <<= shift;
    else denominator <<= shift;
    const int scale = static_cast<int>(shift / 2) * (reciprocal_scale ? -1 : 1);
    const double value = std::ldexp(std::sqrt(Rational(numerator, denominator).to_double()), scale);
    if (value == 0.0) {
        return numeric_failure(CasErrc::NumericFailure, "numeric square root underflow");
    }
    return numeric_approximation(value);
}

引用了 LMCAS::ComputationContext::consume_steps(), context_, LMCAS::denominator, LMCAS::DomainError, LMCAS::Result< T >::failure(), LMCAS::integer, LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::NumericFailure, LMCAS::rational(), LMCAS::ComputationContext::require_integer_bits() , 以及 LMCAS::value.

被这些函数引用 function() , 以及 power().

函数调用图:

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

sum()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::sum ( const AddNode & node )

private

在文件 numeric_evaluation_nodes.cpp 第 48 行定义.

                                                            {
    double value = 0.0;
    bool infinite = false;
    for (const auto& operand : node.operands()) {
        auto evaluated = evaluate(operand);
        if (!evaluated) return evaluated;
        value += evaluated.value().value;
        infinite = infinite || !evaluated.value().is_finite();
        if (std::isinf(value) && !infinite) {
            return numeric_failure(CasErrc::NumericFailure, "numeric evaluation produced a nonfinite result");
        }
    }
    if (std::isinf(value) && infinite) {
        return Result<ApproxReal>::success(ApproxReal{
            value, 0.0, value > 0 ? NumericStatus::PositiveInfinity : NumericStatus::NegativeInfinity});
    }
    return numeric_approximation(value);
}

引用了 evaluate(), LMCAS::NegativeInfinity, LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::NumericFailure, LMCAS::PositiveInfinity, LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 evaluate().

函数调用图:

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

variable()

Result< ApproxReal > LMCAS::detail::NumericEvaluator::variable ( const VariableNode & node )

private

在文件 numeric_evaluation_nodes.cpp 第 26 行定义.

                                                                      {
    if (node.is_constant() && (node.name() == "pi" || node.name() == "π")) {
        return numeric_approximation(static_cast<double>(LMMC_CONST_PI));
    }
    if (node.is_constant() && node.name() == "e") {
        return numeric_approximation(std::exp(1.0));
    }
    if (node.is_constant() && node.name() == "phi") {
        return numeric_approximation((1.0 + std::sqrt(5.0)) / 2.0);
    }
    auto it = bindings_.find(node.name());
    if (it == bindings_.end()) {
        return numeric_failure(CasErrc::UnboundSymbol,
                       "no numeric binding for symbol '" + node.name() + "'");
    }
    if (!std::isfinite(it->second)) {
        return numeric_failure(CasErrc::NumericFailure, "numeric binding is not finite");
    }
    return Result<ApproxReal>::success(
        ApproxReal{it->second, 0.0, NumericStatus::Finite});
}

引用了 bindings_, LMCAS::Finite, LMCAS::detail::node(), LMCAS::detail::numeric_approximation(), LMCAS::detail::numeric_failure(), LMCAS::NumericFailure, LMCAS::Result< T >::success() , 以及 LMCAS::UnboundSymbol.

被这些函数引用 evaluate().

函数调用图:

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

类成员变量说明

bindings_

const NumericBindings& LMCAS::detail::NumericEvaluator::bindings_

private

在文件 numeric_evaluation_support.hpp 第 21 行定义.

被这些函数引用 NumericEvaluator() , 以及 variable().

context_

ComputationContext& LMCAS::detail::NumericEvaluator::context_

private

在文件 numeric_evaluation_support.hpp 第 22 行定义.

被这些函数引用 NumericEvaluator(), evaluate(), power(), product(), root() , 以及 square_root().

---

该类的文档由以下文件生成:

• src/internal/numeric_evaluation_support.hpp
• src/numeric_evaluation.cpp
• src/numeric_evaluation_nodes.cpp
• src/numeric_evaluation_power.cpp