LMCAS::detail::transcendental 命名空间参考

命名空间
namespace	anonymous_namespace{transcendental_inversion.cpp}
namespace	anonymous_namespace{transcendental_patterns.cpp}

类
struct	ExpBasePattern
struct	InversePattern
struct	LambertWPattern

函数
SolutionSet	conditional_preimage (const ExprPtr &original, const std::string &var)
std::optional< ExpBasePattern >	decompose_exp_base_pattern (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context)
std::optional< LambertWPattern >	decompose_lambert_w_pattern (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context)
std::optional< InversePattern >	decompose_trig_exp_pattern (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
std::vector< std::shared_ptr< SymbolicExpr > >	invert_exp_base (const std::shared_ptr< SymbolicExpr > &base, const std::shared_ptr< SymbolicExpr > &c, ComputationContext &context)
SolveResult	invert_function (const InversePattern &pattern, const ExprPtr &original, const std::string &var, ComputationContext &context, const SolveOptions &options)
std::vector< std::shared_ptr< SymbolicExpr > >	invert_lambert_w (const std::shared_ptr< SymbolicExpr > &c, ComputationContext &context)
bool	try_evaluate_numeric (const std::shared_ptr< SymbolicExpr > &expr, lmmc_real_t &out, ComputationContext &context)

---

类说明

LMCAS::detail::transcendental::ExpBasePattern

struct LMCAS::detail::transcendental::ExpBasePattern

在文件 transcendental_solver_support.hpp 第 31 行定义.

LMCAS::detail::transcendental::ExpBasePattern 的协作图:

类成员
shared_ptr< SymbolicExpr >	base
shared_ptr< SymbolicExpr >	inner
shared_ptr< SymbolicExpr >	rhs

LMCAS::detail::transcendental::InversePattern

struct LMCAS::detail::transcendental::InversePattern

在文件 transcendental_solver_support.hpp 第 19 行定义.

LMCAS::detail::transcendental::InversePattern 的协作图:

类成员
shared_ptr< SymbolicExpr >	coefficient
FuncType	func_type
shared_ptr< SymbolicExpr >	inner
shared_ptr< SymbolicExpr >	rhs

LMCAS::detail::transcendental::LambertWPattern

struct LMCAS::detail::transcendental::LambertWPattern

在文件 transcendental_solver_support.hpp 第 26 行定义.

LMCAS::detail::transcendental::LambertWPattern 的协作图:

类成员
shared_ptr< SymbolicExpr >	inner
shared_ptr< SymbolicExpr >	rhs

函数说明

conditional_preimage()

SolutionSet LMCAS::detail::transcendental::conditional_preimage	(	const ExprPtr &	original,
		const std::string &	var )

在文件 transcendental_inversion.cpp 第 65 行定义.

                                                                                {
    auto relation = std::dynamic_pointer_cast<const RelationalNode>(detail::node(original));
    auto predicate = relation ? original : SymbolicExpr::eq(original, SymbolicExpr::number(0));
    return SolutionSet{ConditionalSolutions{ConditionSet{var, std::move(predicate), {}}}};
}

引用了 conditional_preimage(), LMCAS::detail::node() , 以及 LMCAS::relation().

被这些函数引用 LMCAS::anonymous_namespace{solve_transcendental.cpp}::append_solutions(), conditional_preimage(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), invert_function(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_function_pattern(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant() , 以及 LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range().

函数调用图:

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

decompose_exp_base_pattern()

std::optional< ExpBasePattern > LMCAS::detail::transcendental::decompose_exp_base_pattern	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context )

在文件 transcendental_patterns.cpp 第 287 行定义.

                                 {
    if (!expr || !node(expr)) {
        return std::nullopt;
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node(expr))) {
        auto pattern = power_pattern(*power, var, context);
        if (pattern) {
            pattern->rhs = SymbolicExpr::number(0);
            return pattern;
        }
    }
    if (auto sum = std::dynamic_pointer_cast<const AddNode>(node(expr))) {
        return additive_power_pattern(*sum, var, context);
    }
    return std::nullopt;
}

引用了 LMCAS::detail::context, decompose_exp_base_pattern() , 以及 LMCAS::detail::node().

被这些函数引用 decompose_exp_base_pattern() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl().

函数调用图:

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

decompose_lambert_w_pattern()

std::optional< LambertWPattern > LMCAS::detail::transcendental::decompose_lambert_w_pattern	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context )

在文件 transcendental_patterns.cpp 第 270 行定义.

                                                                                                {
    if (!expr || !node(expr)) {
        return std::nullopt;
    }
    if (auto product = std::dynamic_pointer_cast<const MultiplyNode>(node(expr))) {
        auto inner = lambert_inner(*product, var);
        if (inner) {
            return LambertWPattern{*inner, SymbolicExpr::number(0)};
        }
    }
    if (auto sum = std::dynamic_pointer_cast<const AddNode>(node(expr))) {
        return additive_lambert_pattern(*sum, var, context);
    }
    return std::nullopt;
}

引用了 LMCAS::detail::context, decompose_lambert_w_pattern() , 以及 LMCAS::detail::node().

被这些函数引用 decompose_lambert_w_pattern() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl().

函数调用图:

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

decompose_trig_exp_pattern()

std::optional< InversePattern > LMCAS::detail::transcendental::decompose_trig_exp_pattern	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var )

在文件 transcendental_patterns.cpp 第 253 行定义.

                                                                   {
    if (!expr || !node(expr)) {
        return std::nullopt;
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node(expr))) {
        if (invertible_function(*function, var)) {
            return InversePattern{function->type(),
                make_expression_ptr(function->arguments()[0]), SymbolicExpr::number(0), nullptr};
        }
    }
    if (auto sum = std::dynamic_pointer_cast<const AddNode>(node(expr))) {
        return additive_function_pattern(*sum, var);
    }
    return std::nullopt;
}

引用了 decompose_trig_exp_pattern(), LMCAS::function(), LMCAS::detail::make_expression_ptr() , 以及 LMCAS::detail::node().

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

函数调用图:

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

invert_exp_base()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::detail::transcendental::invert_exp_base	(	const std::shared_ptr< SymbolicExpr > &	base,
		const std::shared_ptr< SymbolicExpr > &	c,
		ComputationContext &	context )

在文件 transcendental_inversion.cpp 第 45 行定义.

                                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    lmmc_real_t c_val;
    if (try_evaluate_numeric(c, c_val, context)) {
        if (c_val <= 0.0) {
            return {};
        }
    }
 
    auto ln_c = SymbolicExpr::ln(c);
    auto ln_a = SymbolicExpr::ln(base);
    auto sol = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(ln_c, ln_a)), transform_budget));
    return {sol};
}

引用了 LMCAS::c, LMCAS::detail::context, invert_exp_base(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 try_evaluate_numeric().

被这些函数引用 invert_exp_base() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl().

函数调用图:

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

invert_function()

SolveResult LMCAS::detail::transcendental::invert_function	(	const InversePattern &	pattern,
		const ExprPtr &	original,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 transcendental_inversion.cpp 第 316 行定义.

                                                          {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto step = context.consume_steps(1, "solve.inverse");
    if (!step) { return SolveResult::failure(step.error()); }
    std::optional<detail::AssumptionFacts> assumption_facts;
    if (context.assumptions()) { assumption_facts.emplace(*context.assumptions()); }
    const FactsQuery& facts = assumption_facts ? static_cast<const FactsQuery&>(*assumption_facts) :
        detail::no_facts();
    auto rhs = pattern.rhs;
    if (pattern.coefficient) {
        auto nonzero = detail::query_nonzero_value(detail::node(pattern.coefficient), facts, Domain::Real, context);
        if (!nonzero) { return SolveResult::failure(nonzero.error()); }
        if (nonzero.value() != Tribool::True) { return conditional_preimage(original, var); }
        rhs = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(rhs, pattern.coefficient)), transform_budget));
    }
    switch (pattern.func_type) {
    case FunctionNode::FuncType::Sin:
    case FunctionNode::FuncType::Cos:
    case FunctionNode::FuncType::Tan:
        return invert_trigonometric(pattern, rhs, original, var, facts, context);
    case FunctionNode::FuncType::Exp:
        return invert_exponential(rhs, original, var, facts, context);
    case FunctionNode::FuncType::Ln:
        return invert_logarithm(rhs, original, var, facts, context);
    default:
        return SolveResult::failure(CasErrc::Inconclusive,
            "Inverse requires a complete solution-set representation", "solve.inverse");
    }
} catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit, "allocation failed", "invert_function");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "invert_function");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "invert_function");
}

引用了 LMCAS::detail::transcendental::InversePattern::coefficient, conditional_preimage(), LMCAS::detail::context, LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, LMCAS::detail::facts, LMCAS::Result< SolutionSet >::failure(), LMCAS::detail::transcendental::InversePattern::func_type, LMCAS::Inconclusive, invert_function(), LMCAS::FunctionNode::Ln, LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, LMCAS::detail::rhs, LMCAS::detail::transcendental::InversePattern::rhs, LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Tan , 以及 LMCAS::True.

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

函数调用图:

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

invert_lambert_w()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::detail::transcendental::invert_lambert_w	(	const std::shared_ptr< SymbolicExpr > &	c,
		ComputationContext &	context )

在文件 transcendental_inversion.cpp 第 32 行定义.

                                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    auto sol = SymbolicExpr::lambertw(c);
    if (!sol) {
        return {};
    }
    return {detail::make_expression_ptr(detail::normalize_node(detail::node(sol), transform_budget))};
}

引用了 LMCAS::c, LMCAS::detail::context, invert_lambert_w(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 invert_lambert_w() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl().

函数调用图:

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

try_evaluate_numeric()

bool LMCAS::detail::transcendental::try_evaluate_numeric	(	const std::shared_ptr< SymbolicExpr > &	expr,
		lmmc_real_t &	out,
		ComputationContext &	context )

在文件 transcendental_inversion.cpp 第 20 行定义.

                                                   {
    if (!expr) return false;
    auto numeric = detail::try_finite_numeric(*expr, context);
    if (!numeric) {
        return false;
    }
    out = static_cast<lmmc_real_t>(*numeric);
    return true;
}

引用了 LMCAS::detail::context, try_evaluate_numeric() , 以及 LMCAS::detail::try_finite_numeric().

被这些函数引用 invert_exp_base(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::power_pattern() , 以及 try_evaluate_numeric().

函数调用图:

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