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

函数
Result< ApproxComplex >	add_complex (const ApproxComplex &lhs, const ApproxComplex &rhs)
ApproxComplex	approx_complex (double real, double imag)
ApproxReal	approx_part (double value, double error=0.0)
Result< ApproxComplex >	checked_complex (double real, double imag, const char *operation)
Result< ApproxComplex >	complex_failure (CasErrc code, std::string message, const char *operation)
Result< ApproxComplex >	divide_complex (const ApproxComplex &lhs, const ApproxComplex &rhs)
Result< ApproxComplex >	eval_complex_failure (const CasError &error)
Result< ApproxComplex >	evaluate_complex_components (const ComplexNode &node, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxComplex >	evaluate_complex_exponent (const std::shared_ptr< const SymbolicNode > &node, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxComplex >	evaluate_complex_node (const std::shared_ptr< const SymbolicNode > &node, const NumericBindings &bindings, ComputationContext &context)
template<typename Combine>
Result< ApproxComplex >	evaluate_complex_operands (const std::vector< std::shared_ptr< const SymbolicNode > > &operands, ApproxComplex identity, Combine combine, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxComplex >	evaluate_complex_power (const PowerNode &power, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxComplex >	integer_complex_power (Result< ApproxComplex > base, int integer)
Result< ApproxComplex >	multiply_complex (const ApproxComplex &lhs, const ApproxComplex &rhs)
Result< ApproxComplex >	real_to_complex (const Result< ApproxReal > &real)

变量
constexpr const char *	kEvalfOperation = "LMCAS.evalf"

函数说明

add_complex()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::add_complex	(	const ApproxComplex &	lhs,
		const ApproxComplex &	rhs )

在文件 expr_complex_evaluation.cpp 第 64 行定义.

                                                            {
    return checked_complex(lhs.real.value + rhs.real.value,
                           lhs.imag.value + rhs.imag.value,
                           kEvalComplexOperation);
}

引用了 add_complex(), checked_complex(), LMCAS::ApproxComplex::imag, LMCAS::kEvalComplexOperation, LMCAS::ApproxComplex::real, LMCAS::rhs , 以及 LMCAS::ApproxReal::value.

被这些函数引用 add_complex() , 以及 evaluate_complex_node().

函数调用图:

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

approx_complex()

ApproxComplex LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::approx_complex	(	double	real,
		double	imag )

在文件 expr_complex_evaluation.cpp 第 35 行定义.

                                                       {
    return ApproxComplex{approx_part(real), approx_part(imag)};
}

引用了 approx_complex(), approx_part(), LMCAS::imag , 以及 LMCAS::real().

被这些函数引用 approx_complex(), evaluate_complex_node() , 以及 integer_complex_power().

函数调用图:

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

approx_part()

ApproxReal LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::approx_part	(	double	value,
		double	error = 0.0 )

在文件 expr_complex_evaluation.cpp 第 27 行定义.

                                                       {
    ApproxReal part;
    part.value = value;
    part.absolute_error = error;
    part.status = NumericStatus::Finite;
    return part;
}

引用了 LMCAS::ApproxReal::absolute_error, approx_part(), LMCAS::Finite, LMCAS::ApproxReal::status, LMCAS::ApproxReal::value , 以及 LMCAS::value.

被这些函数引用 approx_complex(), approx_part(), checked_complex() , 以及 real_to_complex().

函数调用图:

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

checked_complex()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::checked_complex	(	double	real,
		double	imag,
		const char *	operation )

在文件 expr_complex_evaluation.cpp 第 39 行定义.

                                                             {
    if (!std::isfinite(real) || !std::isfinite(imag)) {
        return complex_failure(CasErrc::NumericFailure,
                               "complex evaluation produced a non-finite component",
                               operation);
    }
    const double unknown = std::numeric_limits<double>::infinity();
    return Result<ApproxComplex>::success(
        ApproxComplex{approx_part(real, unknown), approx_part(imag, unknown)});
}

引用了 approx_part(), checked_complex(), complex_failure(), LMCAS::imag, LMCAS::NumericFailure, LMCAS::real() , 以及 LMCAS::Result< T >::success().

被这些函数引用 add_complex(), checked_complex(), divide_complex(), evaluate_complex_power(), integer_complex_power() , 以及 multiply_complex().

函数调用图:

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

complex_failure()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::complex_failure	(	CasErrc	code,
		std::string	message,
		const char *	operation )

在文件 expr_complex_evaluation.cpp 第 18 行定义.

                                                             {
    return Result<ApproxComplex>::failure(code, std::move(message), operation);
}

引用了 complex_failure() , 以及 LMCAS::Result< T >::failure().

被这些函数引用 checked_complex(), complex_failure(), divide_complex(), eval_complex_failure(), evaluate_complex_components(), evaluate_complex_exponent(), evaluate_complex_node(), evaluate_complex_power(), multiply_complex() , 以及 real_to_complex().

函数调用图:

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

divide_complex()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex	(	const ApproxComplex &	lhs,
		const ApproxComplex &	rhs )

在文件 expr_complex_evaluation.cpp 第 88 行定义.

                                                               {
    const double a = lhs.real.value;
    const double b = lhs.imag.value;
    const double c = rhs.real.value;
    const double d = rhs.imag.value;
    if (c == 0.0 && d == 0.0) {
        return complex_failure(CasErrc::DomainError,
                               "complex division by zero",
                               kEvalComplexOperation);
    }
    const lmmc_complex_t left{a, b};
    const lmmc_complex_t right{c, d};
    lmmc_complex_t quotient;
    if (lmmc_complex_div(&left, &right, &quotient) != LMMC_STATUS_OK) {
        return complex_failure(CasErrc::NumericFailure,
                               "complex division requires finite components and result",
                               kEvalComplexOperation);
    }
    return checked_complex(quotient.real, quotient.imag, kEvalComplexOperation);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, checked_complex(), complex_failure(), divide_complex(), LMCAS::DomainError, LMCAS::ApproxComplex::imag, LMCAS::kEvalComplexOperation, LMCAS::NumericFailure, LMCAS::ApproxComplex::real, LMCAS::rhs, LMCAS::right , 以及 LMCAS::ApproxReal::value.

被这些函数引用 divide_complex() , 以及 integer_complex_power().

函数调用图:

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

eval_complex_failure()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::eval_complex_failure

(

const CasError &

error

)

在文件 expr_complex_evaluation.cpp 第 23 行定义.

                                                                  {
    return complex_failure(error.code, error.message, kEvalComplexOperation);
}

引用了 LMCAS::CasError::code, complex_failure(), eval_complex_failure(), LMCAS::kEvalComplexOperation , 以及 LMCAS::CasError::message.

被这些函数引用 eval_complex_failure(), evaluate_complex_components() , 以及 real_to_complex().

函数调用图:

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

evaluate_complex_components()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_components	(	const ComplexNode &	node,
		const NumericBindings &	bindings,
		ComputationContext &	context )

在文件 expr_complex_evaluation.cpp 第 115 行定义.

                                 {
    auto real = evaluate_numeric(
        *detail::make_expression_ptr(node.real()), bindings, context);
    if (!real) {
        return eval_complex_failure(real.error());
    }
    auto imag = evaluate_numeric(
        *detail::make_expression_ptr(node.imag()), bindings, context);
    if (!imag) {
        return eval_complex_failure(imag.error());
    }
    if (!real.value().is_finite() || !imag.value().is_finite() ||
        !std::isfinite(real.value().value) ||
        !std::isfinite(imag.value().value)) {
        return complex_failure(CasErrc::NumericFailure,
                               "complex components must be finite",
                               kEvalComplexOperation);
    }
    return Result<ApproxComplex>::success(
        ApproxComplex{real.value(), imag.value()});
}

引用了 LMCAS::bindings, complex_failure(), LMCAS::context, LMCAS::Result< T >::error(), eval_complex_failure(), evaluate_complex_components(), LMCAS::evaluate_numeric(), LMCAS::imag, LMCAS::kEvalComplexOperation, LMCAS::detail::make_expression_ptr(), LMCAS::NumericFailure, LMCAS::real(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 evaluate_complex_components() , 以及 evaluate_complex_node().

函数调用图:

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

evaluate_complex_exponent()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_exponent	(	const std::shared_ptr< const SymbolicNode > &	node,
		const NumericBindings &	bindings,
		ComputationContext &	context )

在文件 expr_complex_evaluation.cpp 第 158 行定义.

                                                                  {
    auto expression = simplify(detail::make_expression_ptr(node), context);
    if (!expression) {
        return complex_failure(expression.error().code,
                               std::move(expression.error().message),
                               kEvalComplexOperation);
    }
    const auto* number = dynamic_cast<const NumberNode*>(
        detail::node(expression.value()).get());
    const auto* rational = number ? std::get_if<Rational>(&number->value()) : nullptr;
    auto exponent = evaluate_complex_node(detail::node(expression.value()),
                                          bindings, context);
    if (!exponent) return exponent;
    if (rational && rational->get_denominator() != BigInt(1) &&
        std::trunc(exponent.value().real.value) == exponent.value().real.value) {
        return complex_failure(CasErrc::UnsupportedExpression,
                               "exact fractional exponent rounds to an integer",
                               kEvalComplexOperation);
    }
    return exponent;
}

引用了 LMCAS::bindings, complex_failure(), LMCAS::context, evaluate_complex_exponent(), evaluate_complex_node(), LMCAS::exponent, LMCAS::kEvalComplexOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::rational(), LMCAS::simplify() , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 evaluate_complex_exponent() , 以及 evaluate_complex_power().

函数调用图:

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

evaluate_complex_node()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_node	(	const std::shared_ptr< const SymbolicNode > &	node,
		const NumericBindings &	bindings,
		ComputationContext &	context )

在文件 expr_complex_evaluation.cpp 第 250 行定义.

                                 {
    auto entered = context.enter_recursion(kEvalComplexOperation);
    if (!entered) {
        return Result<ApproxComplex>::failure(entered.error());
    }
    struct RecursionExit {
        ComputationContext& context;
        ~RecursionExit() { context.leave_recursion(); }
    } recursion_exit{context};
    if (!node) {
        return complex_failure(CasErrc::InvalidArgument,
                               "expression contains a null node",
                               kEvalComplexOperation);
    }
 
    if (auto complex_node = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        return evaluate_complex_components(*complex_node, bindings, context);
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return evaluate_complex_operands(
            add->operands(), approx_complex(0.0, 0.0), add_complex, bindings, context);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return evaluate_complex_operands(
            multiply->operands(), approx_complex(1.0, 0.0), multiply_complex,
            bindings, context);
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return evaluate_complex_power(*power, bindings, context);
    }
 
    return real_to_complex(
        evaluate_numeric(*LMCAS::detail::make_expression_ptr(node),
                         bindings, context));
}

引用了 LMCAS::add(), add_complex(), approx_complex(), LMCAS::bindings, complex_failure(), LMCAS::context, evaluate_complex_components(), evaluate_complex_node(), evaluate_complex_operands(), evaluate_complex_power(), LMCAS::evaluate_numeric(), LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::kEvalComplexOperation, LMCAS::detail::make_expression_ptr(), multiply_complex() , 以及 real_to_complex().

被这些函数引用 evaluate_complex_exponent(), evaluate_complex_node(), evaluate_complex_operands() , 以及 evaluate_complex_power().

函数调用图:

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

evaluate_complex_operands()

template<typename Combine>

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_operands	(	const std::vector< std::shared_ptr< const SymbolicNode > > &	operands,
		ApproxComplex	identity,
		Combine	combine,
		const NumericBindings &	bindings,
		ComputationContext &	context )

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

                                 {
    auto result = Result<ApproxComplex>::success(identity);
    for (const auto& operand : operands) {
        auto value = evaluate_complex_node(operand, bindings, context);
        if (!value) {
            return value;
        }
        result = combine(result.value(), value.value());
        if (!result) {
            return result;
        }
    }
    return result;
}

引用了 LMCAS::bindings, LMCAS::context, evaluate_complex_node(), evaluate_complex_operands(), LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 evaluate_complex_node() , 以及 evaluate_complex_operands().

函数调用图:

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

evaluate_complex_power()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_power	(	const PowerNode &	power,
		const NumericBindings &	bindings,
		ComputationContext &	context )

在文件 expr_complex_evaluation.cpp 第 213 行定义.

                                 {
    auto base = evaluate_complex_node(power.base(), bindings, context);
    if (!base) {
        return base;
    }
    auto exponent = evaluate_complex_exponent(power.exponent(), bindings, context);
    if (!exponent) {
        return Result<ApproxComplex>::failure(std::move(exponent.error()));
    }
    if (exponent.value().imag.value != 0.0 ||
        std::trunc(exponent.value().real.value) != exponent.value().real.value) {
        const lmmc_complex_t value{base.value().real.value, base.value().imag.value};
        const lmmc_complex_t power{exponent.value().real.value,
                                   exponent.value().imag.value};
        lmmc_complex_t result;
        const auto status = lmmc_complex_pow(&value, &power, &result);
        if (status == LMMC_STATUS_OUT_OF_RANGE) {
            return complex_failure(CasErrc::DomainError, "complex power of zero",
                                   kEvalComplexOperation);
        }
        if (status != LMMC_STATUS_OK) {
            return complex_failure(CasErrc::NumericFailure,
                                   "complex power produced a non-finite result",
                                   kEvalComplexOperation);
        }
        return checked_complex(result.real, result.imag, kEvalComplexOperation);
    }
    if (std::abs(exponent.value().real.value) > 64.0) {
        return complex_failure(CasErrc::UnsupportedExpression,
                               "complex evaluation only supports integer powers with |n| <= 64",
                               kEvalComplexOperation);
    }
    return integer_complex_power(std::move(base), static_cast<int>(exponent.value().real.value));
}

引用了 LMCAS::PowerNode::base(), LMCAS::bindings, checked_complex(), complex_failure(), LMCAS::context, LMCAS::DomainError, evaluate_complex_exponent(), evaluate_complex_node(), evaluate_complex_power(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::Result< T >::failure(), integer_complex_power(), LMCAS::kEvalComplexOperation, LMCAS::NumericFailure, LMCAS::UnsupportedExpression , 以及 LMCAS::value.

被这些函数引用 evaluate_complex_node() , 以及 evaluate_complex_power().

函数调用图:

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

integer_complex_power()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::integer_complex_power	(	Result< ApproxComplex >	base,
		int	integer )

在文件 expr_complex_evaluation.cpp 第 182 行定义.

                                                                                     {
    unsigned magnitude = static_cast<unsigned>(std::abs(integer));
    auto factor = base;
    if (integer < 0) {
        factor = divide_complex(approx_complex(1.0, 0.0), base.value());
        if (!factor) {
            return factor;
        }
    }
    auto result = Result<ApproxComplex>::success(approx_complex(1.0, 0.0));
    if (magnitude == 0U) {
        return checked_complex(1.0, 0.0, kEvalComplexOperation);
    }
    while (magnitude != 0U) {
        if ((magnitude & 1U) != 0U) {
            result = multiply_complex(result.value(), factor.value());
            if (!result) {
                return result;
            }
        }
        magnitude >>= 1U;
        if (magnitude != 0U) {
            factor = multiply_complex(factor.value(), factor.value());
            if (!factor) {
                return factor;
            }
        }
    }
    return result;
}

引用了 approx_complex(), checked_complex(), divide_complex(), LMCAS::integer, integer_complex_power(), LMCAS::kEvalComplexOperation, multiply_complex(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 evaluate_complex_power() , 以及 integer_complex_power().

函数调用图:

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

multiply_complex()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex	(	const ApproxComplex &	lhs,
		const ApproxComplex &	rhs )

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

                                                                 {
    const double a = lhs.real.value;
    const double b = lhs.imag.value;
    const double c = rhs.real.value;
    const double d = rhs.imag.value;
    const lmmc_complex_t left{a, b};
    const lmmc_complex_t right{c, d};
    lmmc_complex_t product;
    if (lmmc_complex_mul(&left, &right, &product) != LMMC_STATUS_OK) {
        return complex_failure(CasErrc::NumericFailure,
                               "complex multiplication requires finite components and result",
                               kEvalComplexOperation);
    }
    return checked_complex(product.real, product.imag, kEvalComplexOperation);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, checked_complex(), complex_failure(), LMCAS::ApproxComplex::imag, LMCAS::kEvalComplexOperation, multiply_complex(), LMCAS::NumericFailure, LMCAS::ApproxComplex::real, LMCAS::rhs, LMCAS::right , 以及 LMCAS::ApproxReal::value.

被这些函数引用 evaluate_complex_node(), integer_complex_power() , 以及 multiply_complex().

函数调用图:

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

real_to_complex()

Result< ApproxComplex > LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::real_to_complex

(

const Result< ApproxReal > &

real

)

在文件 expr_complex_evaluation.cpp 第 51 行定义.

                                                                      {
    if (!real) {
        return eval_complex_failure(real.error());
    }
    if (!real.value().is_finite() || !std::isfinite(real.value().value)) {
        return complex_failure(CasErrc::NumericFailure,
                               "complex evaluation requires finite real components",
                               kEvalComplexOperation);
    }
    return Result<ApproxComplex>::success(
        ApproxComplex{real.value(), approx_part(0.0)});
}

引用了 approx_part(), complex_failure(), LMCAS::Result< T >::error(), eval_complex_failure(), LMCAS::kEvalComplexOperation, LMCAS::NumericFailure, LMCAS::real(), real_to_complex(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 evaluate_complex_node() , 以及 real_to_complex().

函数调用图:

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

变量说明

kEvalfOperation

const char* LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::kEvalfOperation = "LMCAS.evalf"

constexpr

在文件 expr_complex_evaluation.cpp 第 16 行定义.