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

类
class	MixedRootCollection

函数
MixedTranscendentalResult	classify_constant_equation (const std::shared_ptr< SymbolicExpr > &expr, bool unresolved_parameters, const SolveOptions &opts, ComputationContext &context)
bool	is_mixed_terminal_error (CasErrc code)
MixedTranscendentalResult	solve_mixed_equation (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts, ComputationContext &context)
std::optional< CasError >	validate_mixed_input (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts)

变量
constexpr const char *	mixed_operation = "solve_mixed_transcendental_checked"

函数说明

classify_constant_equation()

MixedTranscendentalResult LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::classify_constant_equation	(	const std::shared_ptr< SymbolicExpr > &	expr,
		bool	unresolved_parameters,
		const SolveOptions &	opts,
		ComputationContext &	context )

在文件 solve_mixed_transcendental.cpp 第 57 行定义.

                                                                                       {
    using Roots = MathResult<std::vector<std::shared_ptr<SymbolicExpr>>>;
    if (unresolved_parameters) {
        return MixedTranscendentalResult::success(Roots{
            {}, Completeness::Inconclusive,
            "equation depends on unresolved parameters but not the solve variable"});
    }
    auto evaluated = evaluate_numeric(*expr, {}, context);
    if (!evaluated && is_mixed_terminal_error(evaluated.error().code)) {
        return MixedTranscendentalResult::failure(evaluated.error());
    }
    if (!evaluated || !std::isfinite(evaluated.value().value)) {
        return MixedTranscendentalResult::success(Roots{
            {}, Completeness::Inconclusive,
            "constant equation could not be evaluated in the real domain"});
    }
    if (std::abs(evaluated.value().value) <= opts.tolerance) {
        return MixedTranscendentalResult::success(Roots{
            {}, Completeness::Inconclusive,
            "equation is identically zero; every real value satisfies it"});
    }
    return MixedTranscendentalResult::success(Roots{{}, Completeness::Complete, {}});
}

引用了 classify_constant_equation(), LMCAS::Complete, LMCAS::context, LMCAS::evaluate_numeric(), LMCAS::Result< MathResult< std::vector< std::shared_ptr< SymbolicExpr > > > >::failure(), LMCAS::Inconclusive, is_mixed_terminal_error(), LMCAS::Result< MathResult< std::vector< std::shared_ptr< SymbolicExpr > > > >::success() , 以及 LMCAS::SolveOptions::tolerance.

被这些函数引用 classify_constant_equation() , 以及 solve_mixed_equation().

函数调用图:

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

is_mixed_terminal_error()

bool LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::is_mixed_terminal_error

(

CasErrc

code

)

在文件 solve_mixed_transcendental.cpp 第 50 行定义.

                                           {
    return code != CasErrc::DomainError &&
        code != CasErrc::UnboundSymbol &&
        code != CasErrc::UnsupportedExpression &&
        code != CasErrc::Inconclusive;
}

引用了 LMCAS::DomainError, LMCAS::Inconclusive, is_mixed_terminal_error(), LMCAS::UnboundSymbol , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness(), classify_constant_equation(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::handle_symbolic_evaluation_error(), is_mixed_terminal_error() , 以及 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::polish_value().

函数调用图:

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

solve_mixed_equation()

MixedTranscendentalResult LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::solve_mixed_equation	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts,
		ComputationContext &	context )

在文件 solve_mixed_transcendental.cpp 第 463 行定义.

                                                           {
    auto step = context.consume_steps(1, mixed_operation);
    if (!step) {
        return MixedTranscendentalResult::failure(step.error());
    }
    const auto variables = free_variables(detail::node(expr));
    if (variables.find(var) == variables.end()) {
        return classify_constant_equation(expr, !variables.empty(), opts, context);
    }
    auto interval = determine_search_interval(expr, var, opts);
    if (!interval) {
        return MixedTranscendentalResult::failure(
            CasErrc::InvalidArgument, "无法确定有效搜索区间", mixed_operation);
    }
    if (!std::isfinite(interval->lo) || !std::isfinite(interval->hi) ||
        interval->lo >= interval->hi) {
        return MixedTranscendentalResult::failure(
            CasErrc::InvalidArgument, "搜索区间必须为有限递增区间", mixed_operation);
    }
    MixedRootCollection collection(expr, var, *interval, opts, context);
    auto failure = collection.solve(context);
    if (failure) {
        return MixedTranscendentalResult::failure(std::move(*failure));
    }
    return collection.finish();
}

引用了 classify_constant_equation(), LMCAS::context, LMCAS::determine_search_interval(), LMCAS::Result< MathResult< std::vector< std::shared_ptr< SymbolicExpr > > > >::failure(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::finish(), LMCAS::free_variables(), LMCAS::interval(), LMCAS::InvalidArgument, mixed_operation, LMCAS::detail::node(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve() , 以及 solve_mixed_equation().

被这些函数引用 solve_mixed_equation().

函数调用图:

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

validate_mixed_input()

std::optional< CasError > LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::validate_mixed_input	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts )

在文件 solve_mixed_transcendental.cpp 第 25 行定义.

                                                    {
    if (!expr || !detail::node(expr)) {
        return CasError{
            CasErrc::InvalidArgument, "待求解表达式不能为空", mixed_operation};
    }
    if (var.empty()) {
        return CasError{
            CasErrc::InvalidArgument, "求解变量不能为空", mixed_operation};
    }
    if (!std::isfinite(opts.tolerance) || opts.tolerance <= 0.0 ||
        opts.max_newton_iterations <= 0 || opts.max_roots == 0 || opts.max_roots < -1) {
        return CasError{
            CasErrc::InvalidArgument, "求解选项包含无效界限", mixed_operation};
    }
    if (opts.has_search_interval &&
        (!std::isfinite(opts.search_lo) || !std::isfinite(opts.search_hi) ||
         opts.search_lo >= opts.search_hi)) {
        return CasError{
            CasErrc::InvalidArgument, "搜索区间必须为有限递增区间", mixed_operation};
    }
    return std::nullopt;
}

引用了 LMCAS::SolveOptions::has_search_interval, LMCAS::InvalidArgument, LMCAS::SolveOptions::max_newton_iterations, LMCAS::SolveOptions::max_roots, mixed_operation, LMCAS::detail::node(), LMCAS::SolveOptions::search_hi, LMCAS::SolveOptions::search_lo, LMCAS::SolveOptions::tolerance , 以及 validate_mixed_input().

被这些函数引用 validate_mixed_input().

函数调用图:

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

变量说明

mixed_operation

const char* LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::mixed_operation = "solve_mixed_transcendental_checked"

constexpr

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

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::MixedRootCollection(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve(), solve_mixed_equation() , 以及 validate_mixed_input().