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

类
struct	LinearWrapper

枚举
enum class	LinearWrapperKind { None , Function , PowerOfFunction , PowerOfLinear }

函数
LinearWrapper	classify_linear_wrapper (const SymbolicExpr &expr, const std::string &var)
std::shared_ptr< SymbolicExpr >	linear_reduced_expression (const LinearWrapper &wrapper, const std::shared_ptr< SymbolicExpr > &variable)
bool	linear_substitutable_function (const FunctionNode &function)
Result< std::shared_ptr< SymbolicExpr > >	substitute_candidate (const SymbolicExpr &expr, const SymbolicExpr &candidate_term, const std::string &var, ComputationContext &computation)
std::optional< SymbolicExpr >	substitution_argument (const SymbolicExpr &term)
Result< std::shared_ptr< SymbolicExpr > >	substitution_primitive (const SymbolicExpr &candidate_term, const SymbolicExpr &u, const std::string &var, ComputationContext &context)

---

类说明

LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper

struct LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper

在文件 integration_substitution.cpp 第 102 行定义.

LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper 的协作图:

类成员
optional< SymbolicExpr >	argument
shared_ptr< const FunctionNode >	function
LinearWrapperKind	kind = LinearWrapperKind::None
shared_ptr< const PowerNode >	power

枚举类型说明

LinearWrapperKind

enum class LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapperKind

strong

枚举值
None
Function
PowerOfFunction
PowerOfLinear

在文件 integration_substitution.cpp 第 101 行定义.

{ None, Function, PowerOfFunction, PowerOfLinear };

函数说明

classify_linear_wrapper()

LinearWrapper LMCAS::anonymous_namespace{integration_substitution.cpp}::classify_linear_wrapper	(	const SymbolicExpr &	expr,
		const std::string &	var )

在文件 integration_substitution.cpp 第 119 行定义.

                                                                                      {
    LinearWrapper wrapper;
    wrapper.function = std::dynamic_pointer_cast<const FunctionNode>(detail::node(expr));
    if (wrapper.function) {
        if (!linear_substitutable_function(*wrapper.function)) { return wrapper; }
        wrapper.argument = detail::expression_from_node(wrapper.function->arguments()[0]);
        wrapper.kind = LinearWrapperKind::Function;
        return wrapper;
    }
    wrapper.power = std::dynamic_pointer_cast<const PowerNode>(detail::node(expr));
    if (!wrapper.power) { return wrapper; }
    if (expression_depends_on_variable(wrapper.power->exponent(), var)) { return wrapper; }
    wrapper.function = std::dynamic_pointer_cast<const FunctionNode>(wrapper.power->base());
    if (wrapper.function) {
        if (!linear_substitutable_function(*wrapper.function)) { return wrapper; }
        wrapper.argument = detail::expression_from_node(wrapper.function->arguments()[0]);
        wrapper.kind = LinearWrapperKind::PowerOfFunction;
    } else {
        wrapper.argument = detail::expression_from_node(wrapper.power->base());
        wrapper.kind = LinearWrapperKind::PowerOfLinear;
    }
    return wrapper;
}

引用了 LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::argument, classify_linear_wrapper(), LMCAS::expression_depends_on_variable(), LMCAS::detail::expression_from_node(), Function, LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::function, LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::kind, linear_substitutable_function(), LMCAS::detail::node(), LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::power, PowerOfFunction , 以及 PowerOfLinear.

被这些函数引用 classify_linear_wrapper().

函数调用图:

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

linear_reduced_expression()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_reduced_expression	(	const LinearWrapper &	wrapper,
		const std::shared_ptr< SymbolicExpr > &	variable )

在文件 integration_substitution.cpp 第 143 行定义.

                                                                               {
    if (wrapper.kind == LinearWrapperKind::PowerOfLinear) {
        return detail::make_expression_ptr(detail::make_node<PowerNode>(
            detail::node(variable), wrapper.power->exponent()));
    }
    std::vector<std::shared_ptr<const SymbolicNode>> args{detail::node(variable)};
    auto function = detail::make_node<FunctionNode>(wrapper.function->type(), args);
    if (wrapper.kind == LinearWrapperKind::Function) {
        return detail::make_expression_ptr(function);
    }
    return detail::make_expression_ptr(
        detail::make_node<PowerNode>(function, wrapper.power->exponent()));
}

引用了 Function, LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::function, LMCAS::function(), LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::kind, linear_reduced_expression(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::anonymous_namespace{integration_substitution.cpp}::LinearWrapper::power, PowerOfLinear , 以及 LMCAS::variable.

被这些函数引用 linear_reduced_expression().

函数调用图:

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

linear_substitutable_function()

bool LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_substitutable_function

(

const FunctionNode &

function

)

在文件 integration_substitution.cpp 第 109 行定义.

                                                                 {
    using FT = FunctionNode::FuncType;
    switch (function.type()) {
        case FT::Infinity:
        case FT::Atan2:
        case FT::Log: return false;
        default: return function.arguments().size() == 1;
    }
}

引用了 LMCAS::function() , 以及 linear_substitutable_function().

被这些函数引用 classify_linear_wrapper() , 以及 linear_substitutable_function().

函数调用图:

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

substitute_candidate()

Result< std::shared_ptr< SymbolicExpr > > LMCAS::anonymous_namespace{integration_substitution.cpp}::substitute_candidate	(	const SymbolicExpr &	expr,
		const SymbolicExpr &	candidate_term,
		const std::string &	var,
		ComputationContext &	computation )

在文件 integration_substitution.cpp 第 47 行定义.

                                                               {
    detail::RewriteBudget transform_budget(computation, (computation).limits().max_recursion_depth,
                                            (computation).limits().max_ast_nodes, "transform");
    auto u = substitution_argument(candidate_term);
    if (!u || !depends_on_integration_variable(*u, var)) { return nullptr; }
            auto d_ptr = detail::make_expression_ptr(detail::differentiate_node(detail::node(*u), var, transform_budget));
            if (!d_ptr) { return nullptr; }
            auto du = detail::make_expression_ptr(detail::normalize_node(detail::node(d_ptr), transform_budget));
            if (du->is_zero()) { return nullptr; }
 
            auto f_u = candidate_term;
            auto term_times_du = SymbolicExpr::multiply(detail::make_expression_ptr(f_u), detail::make_expression_ptr(*du));
            auto ratio = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(detail::make_expression_ptr(expr), term_times_du)), transform_budget));
    if (depends_on_integration_variable(*ratio, var)) { return nullptr; }
    auto primitive = substitution_primitive(candidate_term, *u, var, computation);
    if (!primitive) { return primitive; }
    if (!primitive.value()) { return nullptr; }
    return SymbolicExpr::multiply(ratio, primitive.value());
} catch (const CasError& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(CasErrc::ResourceLimit, "allocation failed", "substitute_candidate");
} catch (const std::length_error& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(CasErrc::ResourceLimit, error.what(), "substitute_candidate");
} catch (const std::exception& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(CasErrc::InternalInvariant, error.what(), "substitute_candidate");
}

引用了 LMCAS::depends_on_integration_variable(), LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), substitute_candidate(), substitution_argument(), substitution_primitive() , 以及 LMCAS::u.

被这些函数引用 substitute_candidate().

函数调用图:

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

substitution_argument()

std::optional< SymbolicExpr > LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_argument

(

const SymbolicExpr &

term

)

在文件 integration_substitution.cpp 第 10 行定义.

                                                                          {
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(detail::node(term))) {
        return detail::expression_from_node(power->base());
    }
    auto function = std::dynamic_pointer_cast<const FunctionNode>(detail::node(term));
    if (function && !function->arguments().empty()) {
        return detail::expression_from_node(function->arguments()[0]);
    }
    return std::nullopt;
}

引用了 LMCAS::detail::expression_from_node(), LMCAS::function(), LMCAS::detail::node() , 以及 substitution_argument().

被这些函数引用 substitute_candidate() , 以及 substitution_argument().

函数调用图:

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

substitution_primitive()

Result< std::shared_ptr< SymbolicExpr > > LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive	(	const SymbolicExpr &	candidate_term,
		const SymbolicExpr &	u,
		const std::string &	var,
		ComputationContext &	context )

在文件 integration_substitution.cpp 第 21 行定义.

                                                       {
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(detail::node(candidate_term))) {
        auto primitive = detail::integrate_power_primitive(u,
            detail::expression_from_node(power->exponent()), var, context);
        if (!primitive) {
            return Result<std::shared_ptr<SymbolicExpr>>::failure(primitive.error());
        }
        return primitive.value() ? detail::make_expression_ptr(*primitive.value()) : nullptr;
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(detail::node(candidate_term))) {
        if (function->type() == FunctionNode::FuncType::Cos) {
            return SymbolicExpr::sin(detail::make_expression_ptr(u));
        }
        if (function->type() == FunctionNode::FuncType::Sin) {
            return SymbolicExpr::multiply(SymbolicExpr::number(-1),
                SymbolicExpr::cos(detail::make_expression_ptr(u)));
        }
        if (function->type() == FunctionNode::FuncType::Exp) {
            return SymbolicExpr::exp(detail::make_expression_ptr(u));
        }
    }
    return nullptr;
}

引用了 LMCAS::context, LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, LMCAS::detail::expression_from_node(), LMCAS::function(), LMCAS::detail::integrate_power_primitive(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::FunctionNode::Sin, substitution_primitive() , 以及 LMCAS::u.

被这些函数引用 substitute_candidate() , 以及 substitution_primitive().

函数调用图:

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