integration_table_algebraic.cpp

浏览该文件的文档.

#include "internal/expression_transform.hpp"
#include "internal/integration_table_rules.hpp"
 
namespace LMCAS::integration_table_detail {
 
void load_algebraic_elementary_rules(std::vector<detail::IntegrationEntry>& table) {
    {
        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));
    }
}
 
void load_algebraic_radicals_rules(std::vector<detail::IntegrationEntry>& table) {
    {
        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));
    }
}
 
void load_algebraic_reciprocals_rules(std::vector<detail::IntegrationEntry>& table) {
    {
        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));
    }
}
 
void load_polynomial_rules(std::vector<detail::IntegrationEntry>& table) {
    {
        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));
    }
}
 
}