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

类型定义
typedef std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > >	RatPair
	递归求值已执行 sin/cos->t 代换的表达式,生成关于 t 的多项式分子与分母; nullopt 表示当前节点位于有理函数支持域之外.

函数
bool	weier_has_trig_of_var (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
	是否至少包含一个 sin(var)/cos(var)/tan(var)... 形式(确保确实是三角有理函数)
bool	weier_is_rational_trig (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
	判断表达式是否仅由 var 通过 sin(var)/cos(var)/tan(var) 以及常数,四则,整数幂构成, 即关于 sin/cos 的有理函数.含有其它依赖 var 的函数(exp/ln/sqrt 等)时返回 false.
bool	weier_rational_function (const FunctionNode &fn, const std::string &var)
std::optional< RatPair >	weier_rational_power (const PowerNode &pw, const std::string &tvar, const std::shared_ptr< SymbolicExpr > &one, ComputationContext &context)
Result< std::shared_ptr< SymbolicExpr > >	weier_reduce_rational (const std::shared_ptr< SymbolicExpr > &num_poly, const std::shared_ptr< SymbolicExpr > &den_poly, const std::string &tvar, ComputationContext &context)
std::shared_ptr< const SymbolicNode >	weier_replace (const std::shared_ptr< const SymbolicNode > &node, const std::string &var, const std::string &tvar)
std::shared_ptr< const SymbolicNode >	weier_replace_function (const FunctionNode &fn, const std::string &var, const std::string &tvar)
std::optional< RatPair >	weier_to_rational (const std::shared_ptr< const SymbolicNode > &node, const std::string &tvar, ComputationContext &context)
bool	weier_trig_function (const FunctionNode &fn)
bool	weier_trig_of_variable (const FunctionNode &function, const std::string &var)

类型定义说明

RatPair

typedef std::pair<std::shared_ptr<SymbolicExpr>, std::shared_ptr<SymbolicExpr> > LMCAS::anonymous_namespace{integration_weierstrass.cpp}::RatPair

递归求值已执行 sin/cos->t 代换的表达式,生成关于 t 的多项式分子与分母; nullopt 表示当前节点位于有理函数支持域之外.

在文件 integration_weierstrass.cpp 第 162 行定义.

函数说明

weier_has_trig_of_var()

bool LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_has_trig_of_var	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	var )

是否至少包含一个 sin(var)/cos(var)/tan(var)... 形式(确保确实是三角有理函数)

在文件 integration_weierstrass.cpp 第 69 行定义.

                                                                                                {
    if (!node) { return false; }
    if (auto fn = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (weier_trig_of_variable(*fn, var)) {
            return true;
        }
        for (auto& a : fn->arguments()) if (weier_has_trig_of_var(a, var)) { return true; }
        return false;
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (auto& op : add->operands()) if (weier_has_trig_of_var(op, var)) { return true; }
        return false;
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (auto& op : mul->operands()) if (weier_has_trig_of_var(op, var)) { return true; }
        return false;
    }
    if (auto pw = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return weier_has_trig_of_var(pw->base(), var) || weier_has_trig_of_var(pw->exponent(), var);
    }
    return false;
}

引用了 LMCAS::a, LMCAS::add(), LMCAS::mul(), LMCAS::op, weier_has_trig_of_var() , 以及 weier_trig_of_variable().

被这些函数引用 weier_has_trig_of_var().

函数调用图:

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

weier_is_rational_trig()

bool LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_is_rational_trig	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	var )

判断表达式是否仅由 var 通过 sin(var)/cos(var)/tan(var) 以及常数,四则,整数幂构成, 即关于 sin/cos 的有理函数.含有其它依赖 var 的函数(exp/ln/sqrt 等)时返回 false.

裸 var 表示输入超出 sin/cos 有理函数域.

指数必须是不依赖 var 的整数常数

在文件 integration_weierstrass.cpp 第 33 行定义.

                                                                                                 {
    if (!node) { return true; }
    if (auto vn = std::dynamic_pointer_cast<const VariableNode>(node)) {
        /// 裸 var 表示输入超出 sin/cos 有理函数域.
        return vn->is_constant() || vn->name() != var;
    }
    if (std::dynamic_pointer_cast<const NumberNode>(node)) { return true; }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (auto& op : add->operands()) if (!weier_is_rational_trig(op, var)) { return false; }
        return true;
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (auto& op : mul->operands()) if (!weier_is_rational_trig(op, var)) { return false; }
        return true;
    }
    if (auto pw = std::dynamic_pointer_cast<const PowerNode>(node)) {
        /// 指数必须是不依赖 var 的整数常数
        auto en = std::dynamic_pointer_cast<const NumberNode>(pw->exponent());
        if (!en) { return false; }
        return weier_is_rational_trig(pw->base(), var);
    }
    if (auto fn = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return weier_rational_function(*fn, var);
    }
    return false;
}

引用了 LMCAS::add(), LMCAS::mul(), LMCAS::op, weier_is_rational_trig() , 以及 weier_rational_function().

被这些函数引用 weier_is_rational_trig().

函数调用图:

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

weier_rational_function()

bool LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_function	(	const FunctionNode &	fn,
		const std::string &	var )

在文件 integration_weierstrass.cpp 第 19 行定义.

                                                                           {
    if (weier_trig_function(fn)) {
        auto variable = std::dynamic_pointer_cast<const VariableNode>(fn.arguments()[0]);
        if (variable && !variable->is_constant() && variable->name() == var) { return true; }
        return !expression_depends_on_variable(fn.arguments()[0], var);
    }
    for (const auto& argument : fn.arguments()) {
        if (expression_depends_on_variable(argument, var)) { return false; }
    }
    return true;
}

引用了 LMCAS::FunctionNode::arguments(), LMCAS::expression_depends_on_variable(), LMCAS::variable, weier_rational_function() , 以及 weier_trig_function().

被这些函数引用 weier_is_rational_trig() , 以及 weier_rational_function().

函数调用图:

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

weier_rational_power()

std::optional< RatPair > LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power	(	const PowerNode &	pw,
		const std::string &	tvar,
		const std::shared_ptr< SymbolicExpr > &	one,
		ComputationContext &	context )

在文件 integration_weierstrass.cpp 第 166 行定义.

                                                                         {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
        auto en = std::dynamic_pointer_cast<const NumberNode>(pw.exponent());
        if (!en) { return std::nullopt; }
        const auto bounded_exponent = integration_bounded_exponent(*en, -32, 32);
        if (!bounded_exponent) { return std::nullopt; }
 
        auto base = weier_to_rational(pw.base(), tvar, context);
        if (!base) { return std::nullopt; }
        auto [bn, bd] = *base;
        const bool neg = *bounded_exponent < 0;
        const int power_count = neg ? -*bounded_exponent : *bounded_exponent;
        std::shared_ptr<SymbolicExpr> num = one, den = one;
        for (int i = 0; i < power_count; ++i) {
            num = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(num, bn)), transform_budget));
            den = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(den, bd)), transform_budget));
        }
        if (neg) std::swap(num, den);
        return RatPair{num, den};
}

引用了 LMCAS::PowerNode::base(), LMCAS::context, LMCAS::PowerNode::exponent(), LMCAS::integration_bounded_exponent(), LMCAS::detail::make_expression_ptr(), LMCAS::neg(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::polynomial_solver_detail::num(), weier_rational_power() , 以及 weier_to_rational().

被这些函数引用 weier_rational_power() , 以及 weier_to_rational().

函数调用图:

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

weier_reduce_rational()

Result< std::shared_ptr< SymbolicExpr > > LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_reduce_rational	(	const std::shared_ptr< SymbolicExpr > &	num_poly,
		const std::shared_ptr< SymbolicExpr > &	den_poly,
		const std::string &	tvar,
		ComputationContext &	context )

在文件 integration_weierstrass.cpp 第 236 行定义.

                                                                                                         {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto numerator = symbolic_to_poly<Rational>(detail::make_expression_ptr(detail::expand_node(detail::node(num_poly), transform_budget)), tvar);
    if (!numerator && numerator.error().code != CasErrc::UnsupportedExpression) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(numerator.error());
    }
    auto denominator = symbolic_to_poly<Rational>(detail::make_expression_ptr(detail::expand_node(detail::node(den_poly), transform_budget)), tvar);
    if (!denominator && denominator.error().code != CasErrc::UnsupportedExpression) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(denominator.error());
    }
    if (!numerator || !denominator) { return SymbolicExpr::divide(num_poly, den_poly); }
    auto Np = std::move(numerator.value());
    auto Dp = std::move(denominator.value());
    if (Dp.is_zero()) { return SymbolicExpr::divide(num_poly, den_poly); }
    auto g = Polynomial<Rational>::gcd(Np, Dp);
    if (g.degree() >= 1) {
        auto [q1, r1] = Np.div_mod(g);
        auto [q2, r2] = Dp.div_mod(g);
        if (r1.is_zero() && r2.is_zero()) { Np = q1; Dp = q2; }
    }
    auto np_expr = poly_to_symbolic(Np);
    auto dp_expr = poly_to_symbolic(Dp);
    return SymbolicExpr::divide(np_expr, dp_expr);
} catch (const CasError& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(error);
}

引用了 LMCAS::context, LMCAS::denominator, LMCAS::detail::expand_node(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::UnsupportedExpression , 以及 weier_reduce_rational().

被这些函数引用 weier_reduce_rational().

函数调用图:

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

weier_replace()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	var,
		const std::string &	tvar )

其它函数:递归替换参数

在文件 integration_weierstrass.cpp 第 132 行定义.

                                                                                         {
    if (!node) { return node; }
    if (auto fn = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        auto replaced = weier_replace_function(*fn, var, tvar);
        if (replaced) { return replaced; }
        /// 其它函数:递归替换参数
        std::vector<std::shared_ptr<const SymbolicNode>> new_args;
        for (auto& a : fn->arguments()) new_args.push_back(weier_replace(a, var, tvar));
        return LMCAS::detail::make_node<FunctionNode>(fn->type(), new_args);
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> ops;
        for (auto& op : add->operands()) ops.push_back(weier_replace(op, var, tvar));
        return LMCAS::detail::make_node<AddNode>(ops);
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> ops;
        for (auto& op : mul->operands()) ops.push_back(weier_replace(op, var, tvar));
        return LMCAS::detail::make_node<MultiplyNode>(ops);
    }
    if (auto pw = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return LMCAS::detail::make_node<PowerNode>(weier_replace(pw->base(), var, tvar),
                                           weier_replace(pw->exponent(), var, tvar));
    }
    return node->clone();
}

引用了 LMCAS::a, LMCAS::add(), LMCAS::SymbolicNode::clone(), LMCAS::detail::make_node(), LMCAS::mul(), LMCAS::op, weier_replace() , 以及 weier_replace_function().

被这些函数引用 weier_replace().

函数调用图:

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

weier_replace_function()

std::shared_ptr< const SymbolicNode > LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace_function	(	const FunctionNode &	fn,
		const std::string &	var,
		const std::string &	tvar )

< 多项式 1+t^2。

< 多项式 1-t^2。

在文件 integration_weierstrass.cpp 第 92 行定义.

                                                                         {
    using FT = FunctionNode::FuncType;
    if (fn.arguments().size() != 1) {
        return nullptr;
    }
    auto av = std::dynamic_pointer_cast<const VariableNode>(fn.arguments()[0]);
    if (!av || av->is_constant() || av->name() != var) {
        return nullptr;
    }
    auto t = SymbolicExpr::variable(tvar);
    auto one = SymbolicExpr::number(1);
    auto t2 = SymbolicExpr::power(t, SymbolicExpr::number(2));
    auto onep = SymbolicExpr::add(one, t2);                          /**< 多项式 1+t^2。 */
    auto onem = SymbolicExpr::add(one, SymbolicExpr::multiply(SymbolicExpr::number(-1), t2)); /**< 多项式 1-t^2。 */
    auto two_t = SymbolicExpr::multiply(SymbolicExpr::number(2), t);
    switch (fn.type()) {
        case FT::Sin: {
            return LMCAS::detail::node(SymbolicExpr::divide(two_t, onep));
        }
        case FT::Cos: {
            return LMCAS::detail::node(SymbolicExpr::divide(onem, onep));
        }
        case FT::Tan: {
            return LMCAS::detail::node(SymbolicExpr::divide(two_t, onem));
        }
        case FT::Csc: {
            return LMCAS::detail::node(SymbolicExpr::divide(onep, two_t));
        }
        case FT::Sec: {
            return LMCAS::detail::node(SymbolicExpr::divide(onep, onem));
        }
        case FT::Cot: {
            return LMCAS::detail::node(SymbolicExpr::divide(onem, two_t));
        }
        default: break;
    }
    return nullptr;
}

引用了 LMCAS::FunctionNode::arguments(), LMCAS::detail::node(), LMCAS::t, LMCAS::FunctionNode::type() , 以及 weier_replace_function().

被这些函数引用 weier_replace() , 以及 weier_replace_function().

函数调用图:

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

weier_to_rational()

std::optional< RatPair > LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	tvar,
		ComputationContext &	context )

累加:a/b + c/d = (a*d + c*b)/(b*d)

其他节点结构由 nullopt 标记为 t 有理函数域之外.

在文件 integration_weierstrass.cpp 第 190 行定义.

                                                                                             {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto one = SymbolicExpr::number(1);
    if (!node) { return RatPair{SymbolicExpr::number(0), one}; }
 
    if (std::dynamic_pointer_cast<const NumberNode>(node) ||
        std::dynamic_pointer_cast<const VariableNode>(node)) {
        return RatPair{LMCAS::detail::make_expression_ptr(node->clone()), one};
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        /// 累加:a/b + c/d = (a*d + c*b)/(b*d)
        std::shared_ptr<SymbolicExpr> num = SymbolicExpr::number(0);
        std::shared_ptr<SymbolicExpr> den = one;
        for (auto& op : add->operands()) {
            auto r = weier_to_rational(op, tvar, context);
            if (!r) { return std::nullopt; }
            auto [n2, d2] = *r;
            auto new_num = SymbolicExpr::add(
                SymbolicExpr::multiply(num, d2), SymbolicExpr::multiply(n2, den));
            den = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(den, d2)), transform_budget));
            num = detail::make_expression_ptr(detail::normalize_node(detail::node(new_num), transform_budget));
        }
        return RatPair{num, den};
    }
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        std::shared_ptr<SymbolicExpr> num = one;
        std::shared_ptr<SymbolicExpr> den = one;
        for (auto& op : mul->operands()) {
            auto r = weier_to_rational(op, tvar, context);
            if (!r) { return std::nullopt; }
            auto [n2, d2] = *r;
            num = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(num, n2)), transform_budget));
            den = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(den, d2)), transform_budget));
        }
        return RatPair{num, den};
    }
    if (auto pw = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return weier_rational_power(*pw, tvar, one, context);
    }
    /// 其他节点结构由 nullopt 标记为 t 有理函数域之外.
    return std::nullopt;
}

引用了 LMCAS::add(), LMCAS::SymbolicNode::clone(), LMCAS::context, LMCAS::detail::make_expression_ptr(), LMCAS::mul(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::polynomial_solver_detail::num(), LMCAS::op, LMCAS::r, weier_rational_power() , 以及 weier_to_rational().

被这些函数引用 weier_rational_power() , 以及 weier_to_rational().

函数调用图:

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

weier_trig_function()

bool LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_trig_function

(

const FunctionNode &

fn

)

在文件 integration_weierstrass.cpp 第 9 行定义.

                                                 {
    using FT = FunctionNode::FuncType;
    if (fn.arguments().size() != 1) {
        return false;
    }
    return fn.type() == FT::Sin || fn.type() == FT::Cos ||
           fn.type() == FT::Tan || fn.type() == FT::Sec ||
           fn.type() == FT::Csc || fn.type() == FT::Cot;
}

引用了 LMCAS::FunctionNode::arguments(), LMCAS::FunctionNode::type() , 以及 weier_trig_function().

被这些函数引用 weier_rational_function(), weier_trig_function() , 以及 weier_trig_of_variable().

函数调用图:

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

weier_trig_of_variable()

bool LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_trig_of_variable	(	const FunctionNode &	function,
		const std::string &	var )

在文件 integration_weierstrass.cpp 第 60 行定义.

                                                                                {
    if (!weier_trig_function(function)) {
        return false;
    }
    auto argument = std::dynamic_pointer_cast<const VariableNode>(function.arguments()[0]);
    return argument && !argument->is_constant() && argument->name() == var;
}

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

被这些函数引用 weier_has_trig_of_var() , 以及 weier_trig_of_variable().

函数调用图:

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