类型定义
using	FT = FunctionNode::FuncType

函数
void	load_algebraic_elementary_rules (std::vector< detail::IntegrationEntry > &table)
void	load_algebraic_radicals_rules (std::vector< detail::IntegrationEntry > &table)
void	load_algebraic_reciprocals_rules (std::vector< detail::IntegrationEntry > &table)
void	load_exponential_base_rules (std::vector< detail::IntegrationEntry > &table)
void	load_exponential_rules (std::vector< detail::IntegrationEntry > &table)
void	load_exponential_trig_rules (std::vector< detail::IntegrationEntry > &table)
void	load_hyperbolic_rules (std::vector< detail::IntegrationEntry > &table)
void	load_inverse_trig_rules (std::vector< detail::IntegrationEntry > &table)
void	load_logarithmic_rules (std::vector< detail::IntegrationEntry > &table)
void	load_polynomial_rules (std::vector< detail::IntegrationEntry > &table)
void	load_scaled_radical_rules (std::vector< detail::IntegrationEntry > &table)
void	load_scaled_trig_rules (std::vector< detail::IntegrationEntry > &table)
void	load_trig_derivatives_rules (std::vector< detail::IntegrationEntry > &table)
void	load_trig_primitives_rules (std::vector< detail::IntegrationEntry > &table)
void	load_trig_squares_rules (std::vector< detail::IntegrationEntry > &table)
auto	u_is_real_var (const std::string &wc)
auto	u_is_var (const std::string &wc)
auto	u_is_var_a_indep (const std::string &u_wc, const std::string &a_wc)
auto	u_is_var_a_nonzero (const std::string &u_wc, const std::string &a_wc, bool real_scale=false)

类型定义说明

◆ FT

using LMCAS::integration_table_detail::FT = FunctionNode::FuncType

在文件 integration_table_rules.hpp 第 6 行定义.

函数说明

◆ load_algebraic_elementary_rules()

void LMCAS::integration_table_detail::load_algebraic_elementary_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_algebraic.cpp 第 6 行定义.

                                                                               {
    {
        auto u = wildcard("_u");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto neg_u_sq = SymbolicExpr::multiply(SymbolicExpr::number(-1), u_sq);
        auto one_minus_u_sq = SymbolicExpr::add(SymbolicExpr::number(1), neg_u_sq);
        auto pat = *SymbolicExpr::power(SymbolicExpr::sqrt(one_minus_u_sq), SymbolicExpr::number(-1));
        auto res = *make_unary_function(FT::ArcSin, detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("1/sqrt(1-x^2)", pat, res, {"_u"}, u_is_var("_u"), 40));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Abs, detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::multiply(
            SymbolicExpr::number(Rational(1, 2)),
            SymbolicExpr::multiply(detail::make_expression_ptr(u), make_unary_function(FT::Abs, detail::make_expression_ptr(u))));
        table.push_back(detail::IntegrationEntry("|x|", pat, res, {"_u"}, u_is_real_var("_u"), 40));
        auto square = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto root = *SymbolicExpr::sqrt(square);
        table.push_back(detail::IntegrationEntry("sqrt(x^2)", root, res, {"_u"}, u_is_real_var("_u"), 40));
    }
    {
        auto u = wildcard("_u");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto one_plus_u_sq = SymbolicExpr::add(SymbolicExpr::number(1), u_sq);
        auto pat = *SymbolicExpr::power(one_plus_u_sq, SymbolicExpr::number(-1));
        auto res = *make_unary_function(FT::ArcTan, detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("1/(1+x^2)", pat, res, {"_u"}, u_is_var("_u"), 40));
    }
}

引用了 load_algebraic_elementary_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::u, u_is_real_var(), u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_algebraic_elementary_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_algebraic_radicals_rules()

void LMCAS::integration_table_detail::load_algebraic_radicals_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_algebraic.cpp 第 37 行定义.

                                                                             {
    {
        auto u = wildcard("_u");
        auto a = wildcard("_a");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto a_sq = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto sum = SymbolicExpr::add(u_sq, a_sq);
        auto pat = *SymbolicExpr::power(SymbolicExpr::sqrt(sum), SymbolicExpr::number(-1));
 
        auto u_sq_r = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto a_sq_r = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto sum_r = SymbolicExpr::add(u_sq_r, a_sq_r);
        auto inner = SymbolicExpr::add(detail::make_expression_ptr(u), SymbolicExpr::sqrt(sum_r));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs, inner));
        table.push_back(detail::IntegrationEntry("1/sqrt(x^2+a^2)", pat, res, {"_u", "_a"},
            u_is_var_a_nonzero("_u", "_a", true), 50));
    }
    {
        auto u = wildcard("_u");
        auto a = wildcard("_a");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto a_sq = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto neg_a_sq = SymbolicExpr::multiply(SymbolicExpr::number(-1), a_sq);
        auto diff = SymbolicExpr::add(u_sq, neg_a_sq);
        auto pat = *SymbolicExpr::power(SymbolicExpr::sqrt(diff), SymbolicExpr::number(-1));
 
        auto u_sq_r = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto a_sq_r = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto neg_a_sq_r = SymbolicExpr::multiply(SymbolicExpr::number(-1), a_sq_r);
        auto diff_r = SymbolicExpr::add(u_sq_r, neg_a_sq_r);
        auto inner = SymbolicExpr::add(detail::make_expression_ptr(u), SymbolicExpr::sqrt(diff_r));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs, inner));
        table.push_back(detail::IntegrationEntry("1/sqrt(x^2-a^2)", pat, res, {"_u", "_a"},
            u_is_var_a_nonzero("_u", "_a", true), 50));
    }
}

引用了 LMCAS::a, load_algebraic_radicals_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::u, u_is_var_a_nonzero() , 以及 LMCAS::wildcard().

被这些函数引用 load_algebraic_radicals_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_algebraic_reciprocals_rules()

void LMCAS::integration_table_detail::load_algebraic_reciprocals_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_algebraic.cpp 第 74 行定义.

                                                                                {
    {
        auto u = wildcard("_u");
        auto a = wildcard("_a");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto a_sq = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto sum = SymbolicExpr::add(u_sq, a_sq);
        auto pat = *SymbolicExpr::power(sum, SymbolicExpr::number(-1));
 
        auto inv_a = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(-1));
        auto u_over_a = SymbolicExpr::multiply(detail::make_expression_ptr(u), SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(-1)));
        auto res = *SymbolicExpr::multiply(inv_a, make_unary_function(FT::ArcTan, u_over_a));
        table.push_back(detail::IntegrationEntry("1/(x^2+a^2)", pat, res, {"_u", "_a"},
            u_is_var_a_nonzero("_u", "_a"), 50));
    }
    {
        auto u = wildcard("_u");
        auto a = wildcard("_a");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto a_sq = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto neg_a_sq = SymbolicExpr::multiply(SymbolicExpr::number(-1), a_sq);
        auto diff = SymbolicExpr::add(u_sq, neg_a_sq);
        auto pat = *SymbolicExpr::power(diff, SymbolicExpr::number(-1));
 
        auto two_a = SymbolicExpr::multiply(SymbolicExpr::number(2), detail::make_expression_ptr(a));
        auto inv_2a = SymbolicExpr::power(two_a, SymbolicExpr::number(-1));
        auto neg_a = SymbolicExpr::multiply(SymbolicExpr::number(-1), detail::make_expression_ptr(a));
        auto u_minus_a = SymbolicExpr::add(detail::make_expression_ptr(u), neg_a);
        auto u_plus_a = SymbolicExpr::add(detail::make_expression_ptr(u), detail::make_expression_ptr(a));
        auto frac = SymbolicExpr::divide(u_minus_a, u_plus_a);
        auto res = *SymbolicExpr::multiply(inv_2a, SymbolicExpr::ln(make_unary_function(FT::Abs, frac)));
        table.push_back(detail::IntegrationEntry("1/(x^2-a^2)", pat, res, {"_u", "_a"},
            u_is_var_a_nonzero("_u", "_a", true), 50));
    }
}

引用了 LMCAS::a, load_algebraic_reciprocals_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::u, u_is_var_a_nonzero() , 以及 LMCAS::wildcard().

被这些函数引用 load_algebraic_reciprocals_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_exponential_base_rules()

void LMCAS::integration_table_detail::load_exponential_base_rules ( std::vector< detail::IntegrationEntry > & table )

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

                                                                           {
    {
        auto a = wildcard("_a");
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(detail::make_expression_ptr(a), detail::make_expression_ptr(u));
        auto inv_ln_a = SymbolicExpr::power(SymbolicExpr::ln(detail::make_expression_ptr(a)), SymbolicExpr::number(-1));
        auto a_pow_u = SymbolicExpr::power(detail::make_expression_ptr(a), detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::multiply(a_pow_u, inv_ln_a);
        table.push_back(detail::IntegrationEntry("a^x", pat, res, {"_a", "_u"},
            [](const MatchMap& m, const std::string& var, ComputationContext& context) {
                if (!u_is_var_a_indep("_u", "_a")(m, var, context)) { return false; }
                std::optional<detail::AssumptionFacts> assumptions;
                if (context.assumptions()) { assumptions.emplace(*context.assumptions()); }
                const FactsQuery& facts = assumptions ?
                    static_cast<const FactsQuery&>(*assumptions) : detail::no_facts();
                auto logarithm = SymbolicExpr::ln(detail::make_expression_ptr(m.at("_a")));
                return normalization_proved(detail::query_definedness(
                    detail::node(logarithm), facts, Domain::Real, context)) &&
                    normalization_proved(detail::query_nonzero_value(
                        detail::node(logarithm), facts, Domain::Real, context));
            }, 70));
    }
}

引用了 LMCAS::a, LMCAS::context, load_exponential_base_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::normalization_proved(), LMCAS::detail::query_definedness(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, LMCAS::u, u_is_var_a_indep() , 以及 LMCAS::wildcard().

被这些函数引用 load_exponential_base_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_exponential_rules()

void LMCAS::integration_table_detail::load_exponential_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_elementary.cpp 第 5 行定义.

                                                                      {
    {
        auto a = wildcard("_a");
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::exp(SymbolicExpr::multiply(detail::make_expression_ptr(a), detail::make_expression_ptr(u)));
        auto res = *SymbolicExpr::multiply(
            SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(-1)),
            SymbolicExpr::exp(SymbolicExpr::multiply(detail::make_expression_ptr(a), detail::make_expression_ptr(u))));
        table.push_back(detail::IntegrationEntry("exp(a*x)", pat, res, {"_a", "_u"},
            u_is_var_a_nonzero("_u", "_a"), 50));
    }
    {
        auto u = wildcard("_u");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto pat = *SymbolicExpr::multiply(u_sq, SymbolicExpr::exp(detail::make_expression_ptr(u)));
 
        auto u_sq_r = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto two_u = SymbolicExpr::multiply(SymbolicExpr::number(-2), detail::make_expression_ptr(u));
        auto poly = SymbolicExpr::add(SymbolicExpr::add(u_sq_r, two_u), SymbolicExpr::number(2));
        auto res = *SymbolicExpr::multiply(poly, SymbolicExpr::exp(detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("x^2*exp(x)", pat, res, {"_u"}, u_is_var("_u"), 40));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::multiply(detail::make_expression_ptr(u), SymbolicExpr::exp(detail::make_expression_ptr(u)));
 
        auto u_minus_1 = SymbolicExpr::add(detail::make_expression_ptr(u), SymbolicExpr::number(-1));
        auto res = *SymbolicExpr::multiply(u_minus_1, SymbolicExpr::exp(detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("x*exp(x)", pat, res, {"_u"}, u_is_var("_u"), 50));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::exp(detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::exp(detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("exp(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
}

引用了 LMCAS::a, load_exponential_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::u, u_is_var(), u_is_var_a_nonzero() , 以及 LMCAS::wildcard().

被这些函数引用 load_exponential_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_exponential_trig_rules()

void LMCAS::integration_table_detail::load_exponential_trig_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_composite.cpp 第 99 行定义.

                                                                           {
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::multiply(
            SymbolicExpr::exp(detail::make_expression_ptr(u)),
            SymbolicExpr::sin(detail::make_expression_ptr(u)));
 
        auto sin_u = SymbolicExpr::sin(detail::make_expression_ptr(u));
        auto neg_cos_u = SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::cos(detail::make_expression_ptr(u)));
        auto sin_minus_cos = SymbolicExpr::add(sin_u, neg_cos_u);
        auto exp_u = SymbolicExpr::exp(detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::multiply(
            sym_rational(1, 2),
            SymbolicExpr::multiply(exp_u, sin_minus_cos));
        table.push_back(detail::IntegrationEntry("exp(x)*sin(x)", pat, res, {"_u"}, u_is_var("_u"), 35));
    }
}

引用了 load_exponential_trig_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::sym_rational(), LMCAS::u, u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_exponential_trig_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_hyperbolic_rules()

void LMCAS::integration_table_detail::load_hyperbolic_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_elementary.cpp 第 199 行定义.

                                                                     {
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Sinh, detail::make_expression_ptr(u));
        auto res = *make_unary_function(FT::Cosh, detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("sinh(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Cosh, detail::make_expression_ptr(u));
        auto res = *make_unary_function(FT::Sinh, detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("cosh(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Tanh, detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Cosh, detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("tanh(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto sinh_inv = SymbolicExpr::power(make_unary_function(FT::Sinh, detail::make_expression_ptr(u)), SymbolicExpr::number(-1));
        auto pat = *SymbolicExpr::multiply(make_unary_function(FT::Cosh, detail::make_expression_ptr(u)), sinh_inv);
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs,
            make_unary_function(FT::Sinh, detail::make_expression_ptr(u))));
        table.push_back(detail::IntegrationEntry("coth(x)", pat, res, {"_u"}, u_is_real_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(make_unary_function(FT::Cosh, detail::make_expression_ptr(u)), SymbolicExpr::number(-1));
        auto res = *make_unary_function(FT::ArcTan, make_unary_function(FT::Sinh, detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("sech(x)", pat, res, {"_u"}, u_is_var("_u"), 50));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(make_unary_function(FT::Sinh, detail::make_expression_ptr(u)), SymbolicExpr::number(-1));
        auto u_half = SymbolicExpr::multiply(detail::make_expression_ptr(u), sym_rational(1, 2));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs, make_unary_function(FT::Tanh, u_half)));
        table.push_back(detail::IntegrationEntry("csch(x)", pat, res, {"_u"}, u_is_real_var("_u"), 50));
    }
}

引用了 load_hyperbolic_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::sym_rational(), LMCAS::u, u_is_real_var(), u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_hyperbolic_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_inverse_trig_rules()

void LMCAS::integration_table_detail::load_inverse_trig_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_elementary.cpp 第 164 行定义.

                                                                       {
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::ArcSin, detail::make_expression_ptr(u));
        auto x_asin = SymbolicExpr::multiply(detail::make_expression_ptr(u), make_unary_function(FT::ArcSin, detail::make_expression_ptr(u)));
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto neg_u_sq = SymbolicExpr::multiply(SymbolicExpr::number(-1), u_sq);
        auto one_minus_u_sq = SymbolicExpr::add(SymbolicExpr::number(1), neg_u_sq);
        auto root = SymbolicExpr::sqrt(one_minus_u_sq);
        auto res = *SymbolicExpr::add(x_asin, root);
        table.push_back(detail::IntegrationEntry("arcsin(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::ArcCos, detail::make_expression_ptr(u));
        auto x_acos = SymbolicExpr::multiply(detail::make_expression_ptr(u), make_unary_function(FT::ArcCos, detail::make_expression_ptr(u)));
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto neg_u_sq = SymbolicExpr::multiply(SymbolicExpr::number(-1), u_sq);
        auto one_minus_u_sq = SymbolicExpr::add(SymbolicExpr::number(1), neg_u_sq);
        auto neg_root = SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::sqrt(one_minus_u_sq));
        auto res = *SymbolicExpr::add(x_acos, neg_root);
        table.push_back(detail::IntegrationEntry("arccos(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::ArcTan, detail::make_expression_ptr(u));
        auto x_atan = SymbolicExpr::multiply(detail::make_expression_ptr(u), make_unary_function(FT::ArcTan, detail::make_expression_ptr(u)));
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto one_plus_u_sq = SymbolicExpr::add(SymbolicExpr::number(1), u_sq);
        auto half_ln = SymbolicExpr::multiply(SymbolicExpr::ln(one_plus_u_sq), sym_rational(-1, 2));
        auto res = *SymbolicExpr::add(x_atan, half_ln);
        table.push_back(detail::IntegrationEntry("arctan(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
}

引用了 load_inverse_trig_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::sym_rational(), LMCAS::u, u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_inverse_trig_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_logarithmic_rules()

void LMCAS::integration_table_detail::load_logarithmic_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_composite.cpp 第 5 行定义.

                                                                      {
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::ln(detail::make_expression_ptr(u));
        auto x_ln_x = SymbolicExpr::multiply(detail::make_expression_ptr(u), SymbolicExpr::ln(detail::make_expression_ptr(u)));
        auto res = *sym_sub(*x_ln_x, u);
        table.push_back(detail::IntegrationEntry("ln(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto inv_u = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(-1));
        auto pat = *SymbolicExpr::multiply(SymbolicExpr::ln(detail::make_expression_ptr(u)), inv_u);
        auto ln_sq = SymbolicExpr::power(SymbolicExpr::ln(detail::make_expression_ptr(u)), SymbolicExpr::number(2));
        auto res = *SymbolicExpr::multiply(ln_sq, sym_rational(1, 2));
        table.push_back(detail::IntegrationEntry("ln(x)/x", pat, res, {"_u"}, u_is_var("_u"), 50));
    }
}

引用了 load_logarithmic_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::sym_rational(), LMCAS::sym_sub(), LMCAS::u, u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_logarithmic_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_polynomial_rules()

void LMCAS::integration_table_detail::load_polynomial_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_algebraic.cpp 第 110 行定义.

                                                                     {
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(-1));
        auto res = *SymbolicExpr::ln(detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("1/x", pat, res, {"_u"}, u_is_var("_u"), 50));
    }
    {
        auto u = wildcard("_u");
        auto n = wildcard("_n");
        auto pat = *SymbolicExpr::power(detail::make_expression_ptr(u), detail::make_expression_ptr(n));
        auto n_plus_1 = SymbolicExpr::add(detail::make_expression_ptr(n), SymbolicExpr::number(1));
        auto res = *SymbolicExpr::divide(
            SymbolicExpr::power(detail::make_expression_ptr(u), n_plus_1),
            n_plus_1);
        table.push_back(detail::IntegrationEntry("x^n", pat, res, {"_u", "_n"},
        [](const MatchMap& m, const std::string& var, ComputationContext& context) {
            auto it_u = m.find("_u");
            if (it_u == m.end()) { return false; }
            auto v = std::dynamic_pointer_cast<const VariableNode>(LMCAS::detail::node(it_u->second));
            if (!v || v->is_constant() || v->name() != var) { return false; }
            auto it_n = m.find("_n");
            if (it_n == m.end()) { return false; }
            if (expression_depends_on_variable(LMCAS::detail::node(it_n->second), var)) { return false; }
            const auto exponent = detail::exact_rational_value(detail::node(it_n->second));
            if (exponent) { return *exponent + Rational(1) != Rational(0); }
            detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                context.limits().max_ast_nodes, "integrate.power");
            auto next = detail::normalize_node(detail::node(SymbolicExpr::add(
                detail::make_expression_ptr(it_n->second), SymbolicExpr::number(1))), budget);
            std::optional<detail::AssumptionFacts> assumptions;
            if (context.assumptions()) { assumptions.emplace(*context.assumptions()); }
            return normalization_proved(detail::query_nonzero_value(next,
                assumptions ? static_cast<const FactsQuery&>(*assumptions) : detail::no_facts(),
                Domain::Real, context));
        }, 80));
    }
    {
        auto u = wildcard("_u");
        auto pat = LMCAS::detail::expression_from_node(LMCAS::detail::node(u));
        auto res = *SymbolicExpr::multiply(
            SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2)),
            sym_rational(1, 2));
        table.push_back(detail::IntegrationEntry("x", pat, res, {"_u"}, u_is_var("_u"), 90));
    }
}

引用了 LMCAS::context, LMCAS::detail::exact_rational_value(), LMCAS::exponent, LMCAS::expression_depends_on_variable(), LMCAS::detail::expression_from_node(), load_polynomial_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::normalization_proved(), LMCAS::detail::normalize_node(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, LMCAS::sym_rational(), LMCAS::u, u_is_var(), LMCAS::v , 以及 LMCAS::wildcard().

被这些函数引用 load_polynomial_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_scaled_radical_rules()

void LMCAS::integration_table_detail::load_scaled_radical_rules ( std::vector< detail::IntegrationEntry > & table )

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

                                                                         {
    {
        auto u = wildcard("_u");
        auto a = wildcard("_a");
        auto a_sq = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(2));
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto neg_u_sq = SymbolicExpr::multiply(SymbolicExpr::number(-1), u_sq);
        auto a_sq_minus_u_sq = SymbolicExpr::add(a_sq, neg_u_sq);
        auto pat = *SymbolicExpr::power(SymbolicExpr::sqrt(a_sq_minus_u_sq), SymbolicExpr::number(-1));
 
        auto u_over_a = SymbolicExpr::multiply(detail::make_expression_ptr(u),
            SymbolicExpr::power(make_unary_function(FT::Abs, detail::make_expression_ptr(a)),
                SymbolicExpr::number(-1)));
        auto res = *make_unary_function(FT::ArcSin, u_over_a);
        table.push_back(detail::IntegrationEntry("1/sqrt(a^2-x^2)", pat, res, {"_u", "_a"},
            u_is_var_a_nonzero("_u", "_a", true), 50));
    }
}

引用了 LMCAS::a, load_scaled_radical_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::u, u_is_var_a_nonzero() , 以及 LMCAS::wildcard().

被这些函数引用 load_scaled_radical_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_scaled_trig_rules()

void LMCAS::integration_table_detail::load_scaled_trig_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_composite.cpp 第 66 行定义.

                                                                      {
    {
        auto a = wildcard("_a");
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::sin(SymbolicExpr::multiply(detail::make_expression_ptr(a), detail::make_expression_ptr(u)));
        auto inv_a = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(-1));
        auto neg_inv_a = SymbolicExpr::multiply(SymbolicExpr::number(-1), inv_a);
        auto cos_ax = SymbolicExpr::cos(SymbolicExpr::multiply(detail::make_expression_ptr(a), detail::make_expression_ptr(u)));
        auto res = *SymbolicExpr::multiply(neg_inv_a, cos_ax);
        table.push_back(detail::IntegrationEntry("sin(a*x)", pat, res, {"_a", "_u"},
            u_is_var_a_nonzero("_u", "_a"), 55));
    }
    {
        auto a = wildcard("_a");
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::cos(SymbolicExpr::multiply(detail::make_expression_ptr(a), detail::make_expression_ptr(u)));
        auto inv_a = SymbolicExpr::power(detail::make_expression_ptr(a), SymbolicExpr::number(-1));
        auto sin_ax = SymbolicExpr::sin(SymbolicExpr::multiply(detail::make_expression_ptr(a), detail::make_expression_ptr(u)));
        auto res = *SymbolicExpr::multiply(inv_a, sin_ax);
        table.push_back(detail::IntegrationEntry("cos(a*x)", pat, res, {"_a", "_u"},
            u_is_var_a_nonzero("_u", "_a"), 55));
    }
    {
        auto u = wildcard("_u");
        auto u_sq = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto pat = *SymbolicExpr::multiply(detail::make_expression_ptr(u), SymbolicExpr::cos(u_sq));
 
        auto u_sq_r = SymbolicExpr::power(detail::make_expression_ptr(u), SymbolicExpr::number(2));
        auto res = *SymbolicExpr::multiply(sym_rational(1, 2), SymbolicExpr::sin(u_sq_r));
        table.push_back(detail::IntegrationEntry("x*cos(x^2)", pat, res, {"_u"}, u_is_var("_u"), 35));
    }
}

引用了 LMCAS::a, load_scaled_trig_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::sym_rational(), LMCAS::u, u_is_var(), u_is_var_a_nonzero() , 以及 LMCAS::wildcard().

被这些函数引用 load_scaled_trig_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_trig_derivatives_rules()

void LMCAS::integration_table_detail::load_trig_derivatives_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_elementary.cpp 第 43 行定义.

                                                                           {
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(make_unary_function(FT::Sec, detail::make_expression_ptr(u)), SymbolicExpr::number(2));
        auto res = *make_unary_function(FT::Tan, detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("sec(x)^2", pat, res, {"_u"}, u_is_var("_u"), 30));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(make_unary_function(FT::Csc, detail::make_expression_ptr(u)), SymbolicExpr::number(2));
        auto res = *SymbolicExpr::multiply(SymbolicExpr::number(-1), make_unary_function(FT::Cot, detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("csc(x)^2", pat, res, {"_u"}, u_is_var("_u"), 30));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::multiply(make_unary_function(FT::Sec, detail::make_expression_ptr(u)), make_unary_function(FT::Tan, detail::make_expression_ptr(u)));
        auto res = *make_unary_function(FT::Sec, detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("sec(x)*tan(x)", pat, res, {"_u"}, u_is_var("_u"), 30));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::multiply(make_unary_function(FT::Csc, detail::make_expression_ptr(u)), make_unary_function(FT::Cot, detail::make_expression_ptr(u)));
        auto res = *SymbolicExpr::multiply(SymbolicExpr::number(-1), make_unary_function(FT::Csc, detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("csc(x)*cot(x)", pat, res, {"_u"}, u_is_var("_u"), 30));
    }
}

引用了 load_trig_derivatives_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::u, u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_trig_derivatives_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_trig_primitives_rules()

void LMCAS::integration_table_detail::load_trig_primitives_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_elementary.cpp 第 100 行定义.

                                                                          {
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::sin(detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::cos(detail::make_expression_ptr(u)));
        table.push_back(detail::IntegrationEntry("sin(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::cos(detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::sin(detail::make_expression_ptr(u));
        table.push_back(detail::IntegrationEntry("cos(x)", pat, res, {"_u"}, u_is_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::tan(detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::multiply(SymbolicExpr::number(-1),
            SymbolicExpr::ln(make_unary_function(FT::Abs, SymbolicExpr::cos(detail::make_expression_ptr(u)))));
        table.push_back(detail::IntegrationEntry("tan(x)", pat, res, {"_u"}, u_is_real_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto sin_u = SymbolicExpr::sin(detail::make_expression_ptr(u));
        auto cos_u = SymbolicExpr::cos(detail::make_expression_ptr(u));
        auto pat = *SymbolicExpr::multiply(
            sin_u,
            SymbolicExpr::power(cos_u, SymbolicExpr::number(-1)));
        auto res = *SymbolicExpr::multiply(
            SymbolicExpr::number(-1), SymbolicExpr::ln(make_unary_function(FT::Abs, cos_u)));
        table.push_back(detail::IntegrationEntry("sin(x)/cos(x)", pat, res, {"_u"}, u_is_real_var("_u"), 61));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Cot, detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs, SymbolicExpr::sin(detail::make_expression_ptr(u))));
        table.push_back(detail::IntegrationEntry("cot(x)", pat, res, {"_u"}, u_is_real_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto sin_u = SymbolicExpr::sin(detail::make_expression_ptr(u));
        auto cos_u = SymbolicExpr::cos(detail::make_expression_ptr(u));
        auto pat = *SymbolicExpr::multiply(
            cos_u,
            SymbolicExpr::power(sin_u, SymbolicExpr::number(-1)));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs, sin_u));
        table.push_back(detail::IntegrationEntry("cos(x)/sin(x)", pat, res, {"_u"}, u_is_real_var("_u"), 61));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Sec, detail::make_expression_ptr(u));
        auto inner = SymbolicExpr::add(make_unary_function(FT::Sec, detail::make_expression_ptr(u)), make_unary_function(FT::Tan, detail::make_expression_ptr(u)));
        auto res = *SymbolicExpr::ln(make_unary_function(FT::Abs, inner));
        table.push_back(detail::IntegrationEntry("sec(x)", pat, res, {"_u"}, u_is_real_var("_u"), 60));
    }
    {
        auto u = wildcard("_u");
        auto pat = *make_unary_function(FT::Csc, detail::make_expression_ptr(u));
        auto inner = SymbolicExpr::add(make_unary_function(FT::Csc, detail::make_expression_ptr(u)), make_unary_function(FT::Cot, detail::make_expression_ptr(u)));
        auto res = *SymbolicExpr::multiply(SymbolicExpr::number(-1),
            SymbolicExpr::ln(make_unary_function(FT::Abs, inner)));
        table.push_back(detail::IntegrationEntry("csc(x)", pat, res, {"_u"}, u_is_real_var("_u"), 60));
    }
}

引用了 load_trig_primitives_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::make_unary_function(), LMCAS::u, u_is_real_var(), u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_trig_primitives_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ load_trig_squares_rules()

void LMCAS::integration_table_detail::load_trig_squares_rules ( std::vector< detail::IntegrationEntry > & table )

在文件 integration_table_elementary.cpp 第 70 行定义.

                                                                       {
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(SymbolicExpr::sin(detail::make_expression_ptr(u)), SymbolicExpr::number(2));
 
        auto u_half = SymbolicExpr::multiply(detail::make_expression_ptr(u), sym_rational(1, 2));
        auto two_u = SymbolicExpr::multiply(SymbolicExpr::number(2), detail::make_expression_ptr(u));
        auto sin_2u_over_4 = SymbolicExpr::multiply(SymbolicExpr::sin(two_u), sym_rational(-1, 4));
        auto res = *SymbolicExpr::add(u_half, sin_2u_over_4);
        table.push_back(detail::IntegrationEntry("sin(x)^2", pat, res, {"_u"}, u_is_var("_u"), 35));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(SymbolicExpr::cos(detail::make_expression_ptr(u)), SymbolicExpr::number(2));
 
        auto u_half = SymbolicExpr::multiply(detail::make_expression_ptr(u), sym_rational(1, 2));
        auto two_u = SymbolicExpr::multiply(SymbolicExpr::number(2), detail::make_expression_ptr(u));
        auto sin_2u_over_4 = SymbolicExpr::multiply(SymbolicExpr::sin(two_u), sym_rational(1, 4));
        auto res = *SymbolicExpr::add(u_half, sin_2u_over_4);
        table.push_back(detail::IntegrationEntry("cos(x)^2", pat, res, {"_u"}, u_is_var("_u"), 35));
    }
    {
        auto u = wildcard("_u");
        auto pat = *SymbolicExpr::power(SymbolicExpr::tan(detail::make_expression_ptr(u)), SymbolicExpr::number(2));
        auto neg_u = SymbolicExpr::multiply(SymbolicExpr::number(-1), detail::make_expression_ptr(u));
        auto res = *SymbolicExpr::add(SymbolicExpr::tan(detail::make_expression_ptr(u)), neg_u);
        table.push_back(detail::IntegrationEntry("tan(x)^2", pat, res, {"_u"}, u_is_var("_u"), 35));
    }
}

引用了 load_trig_squares_rules(), LMCAS::detail::make_expression_ptr(), LMCAS::sym_rational(), LMCAS::u, u_is_var() , 以及 LMCAS::wildcard().

被这些函数引用 load_trig_squares_rules() , 以及 LMCAS::detail::make_integration_entries().

函数调用图:

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

◆ u_is_real_var()

auto LMCAS::integration_table_detail::u_is_real_var ( const std::string & wc )

inline

在文件 integration_table_rules.hpp 第 42 行定义.

                                               {
    return [u_matches = u_is_var(wc), wc](
        const MatchMap& m, const std::string& var, ComputationContext& context) {
        if (!u_matches(m, var, context)) { return false; }
        std::optional<detail::AssumptionFacts> assumptions;
        if (context.assumptions()) { assumptions.emplace(*context.assumptions()); }
        return normalization_proved(detail::query_real_value(detail::node(m.at(wc)),
            assumptions ? static_cast<const FactsQuery&>(*assumptions) : detail::no_facts(), context));
    };
}

引用了 LMCAS::context, LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::normalization_proved(), LMCAS::detail::query_real_value(), u_is_real_var() , 以及 u_is_var().

被这些函数引用 load_algebraic_elementary_rules(), load_hyperbolic_rules(), load_trig_primitives_rules() , 以及 u_is_real_var().

函数调用图:

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

◆ u_is_var()

auto LMCAS::integration_table_detail::u_is_var ( const std::string & wc )

inline

在文件 integration_table_rules.hpp 第 8 行定义.

                                          {
    return [wc](const MatchMap& m, const std::string& var, ComputationContext&) {
        auto it = m.find(wc);
        if (it == m.end()) { return false; }
        auto value = std::dynamic_pointer_cast<const VariableNode>(detail::node(it->second));
        return value && !value->is_constant() && value->name() == var;
    };
}

引用了 LMCAS::detail::node(), u_is_var() , 以及 LMCAS::value.

被这些函数引用 load_algebraic_elementary_rules(), load_exponential_rules(), load_exponential_trig_rules(), load_hyperbolic_rules(), load_inverse_trig_rules(), load_logarithmic_rules(), load_polynomial_rules(), load_scaled_trig_rules(), load_trig_derivatives_rules(), load_trig_primitives_rules(), load_trig_squares_rules(), u_is_real_var(), u_is_var() , 以及 u_is_var_a_indep().

函数调用图:

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

◆ u_is_var_a_indep()

auto LMCAS::integration_table_detail::u_is_var_a_indep	(	const std::string &	u_wc,
		const std::string &	a_wc )

inline

在文件 integration_table_rules.hpp 第 17 行定义.

                                                                           {
    return [u_matches = u_is_var(u_wc), a_wc](
        const MatchMap& m, const std::string& var, ComputationContext& context) {
        if (!u_matches(m, var, context)) { return false; }
        auto a = m.find(a_wc);
        return a != m.end() && !expression_depends_on_variable(detail::node(a->second), var);
    };
}

引用了 LMCAS::a, LMCAS::context, LMCAS::expression_depends_on_variable(), LMCAS::detail::node(), u_is_var() , 以及 u_is_var_a_indep().

被这些函数引用 load_exponential_base_rules(), u_is_var_a_indep() , 以及 u_is_var_a_nonzero().

函数调用图:

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

◆ u_is_var_a_nonzero()

auto LMCAS::integration_table_detail::u_is_var_a_nonzero	(	const std::string &	u_wc,
		const std::string &	a_wc,
		bool	real_scale = false )

inline

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

                                                      {
    return [independent = u_is_var_a_indep(u_wc, a_wc), u_wc, a_wc, real_scale](
        const MatchMap& m, const std::string& var, ComputationContext& context) {
        if (!independent(m, var, context)) { return false; }
        std::optional<detail::AssumptionFacts> assumptions;
        if (context.assumptions()) { assumptions.emplace(*context.assumptions()); }
        const FactsQuery& facts = assumptions ? static_cast<const FactsQuery&>(*assumptions) : detail::no_facts();
        auto a = detail::node(m.at(a_wc));
        return (!real_scale ||
                (normalization_proved(detail::query_real_value(detail::node(m.at(u_wc)), facts, context)) &&
                 normalization_proved(detail::query_real_value(a, facts, context)))) &&
            normalization_proved(detail::query_nonzero_value(a, facts, Domain::Real, context));
    };
}

引用了 LMCAS::a, LMCAS::context, LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::normalization_proved(), LMCAS::detail::query_nonzero_value(), LMCAS::detail::query_real_value(), LMCAS::Real, u_is_var_a_indep() , 以及 u_is_var_a_nonzero().

被这些函数引用 load_algebraic_radicals_rules(), load_algebraic_reciprocals_rules(), load_exponential_rules(), load_scaled_radical_rules(), load_scaled_trig_rules() , 以及 u_is_var_a_nonzero().

函数调用图:

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