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

函数
detail::IntegralParts	rd_add_fraction_primitives (const std::string &var, const std::vector< std::pair< Polynomial< Rational >, int > > &factors, const std::vector< Polynomial< Rational > > &numerators, detail::IntegralParts result, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	rd_integrate_polynomial (const Polynomial< Rational > &quot, const std::string &var)
Result< detail::IntegralParts >	rd_integrate_proper_fraction (const std::string &var, const Polynomial< Rational > &P, const Polynomial< Rational > &Q, const SymbolicExpr &zero, ComputationContext &computation)
void	rd_reduce_reciprocal (Polynomial< Rational > &P, Polynomial< Rational > &Q)

函数说明

rd_add_fraction_primitives()

detail::IntegralParts LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives	(	const std::string &	var,
		const std::vector< std::pair< Polynomial< Rational >, int > > &	factors,
		const std::vector< Polynomial< Rational > > &	numerators,
		detail::IntegralParts	result,
		ComputationContext &	context )

在文件 integration_rational.cpp 第 41 行定义.

                                                             {
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                            context.limits().max_ast_nodes, "transform");
    size_t idx = 0;
    for (const auto& [factor, mult] : factors) {
        for (int power = 1; power <= mult; ++power, ++idx) {
            auto term = detail::integrate_rational_term(numerators[idx], factor, power, var);
            result.primitive = *SymbolicExpr::add(
                detail::make_expression_ptr(result.primitive),
                detail::make_expression_ptr(term.primitive));
            result.remainder = *SymbolicExpr::add(
                detail::make_expression_ptr(result.remainder),
                detail::make_expression_ptr(term.remainder));
        }
    }
    result.primitive = detail::expression_from_node(
        detail::normalize_node(detail::node(result.primitive), transform_budget));
    result.remainder = detail::expression_from_node(
        detail::normalize_node(detail::node(result.remainder), transform_budget));
    return result;
}

引用了 LMCAS::context, LMCAS::detail::expression_from_node(), LMCAS::detail::integrate_rational_term(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::IntegralParts::primitive, rd_add_fraction_primitives() , 以及 LMCAS::detail::IntegralParts::remainder.

被这些函数引用 rd_add_fraction_primitives() , 以及 rd_integrate_proper_fraction().

函数调用图:

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

rd_integrate_polynomial()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational.cpp}::rd_integrate_polynomial	(	const Polynomial< Rational > &	quot,
		const std::string &	var )

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

                                                            {
    auto result = SymbolicExpr::number(0);
        if (!quot.is_zero()) {
            for (size_t k = 0; k < quot.coeffs.size(); ++k) {
                if (quot.coeffs[k] == Rational(0)) { continue; }
                const BigInt integrated_power = BigInt(k) + BigInt(1);
                Rational coeff = quot.coeffs[k] / Rational(integrated_power);
                std::shared_ptr<SymbolicExpr> term;
                auto v = SymbolicExpr::variable(var);
                auto pw = SymbolicExpr::power(v, SymbolicExpr::number(integrated_power));
                if (coeff == Rational(1)) {
                    term = pw;
                } else {
                    term = SymbolicExpr::multiply(SymbolicExpr::number(coeff), pw);
                }
                result = SymbolicExpr::add(result, term);
            }
        }
    return result;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::is_zero(), rd_integrate_polynomial() , 以及 LMCAS::v.

被这些函数引用 rd_integrate_polynomial() , 以及 rd_integrate_proper_fraction().

函数调用图:

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

rd_integrate_proper_fraction()

Result< detail::IntegralParts > LMCAS::anonymous_namespace{integration_rational.cpp}::rd_integrate_proper_fraction	(	const std::string &	var,
		const Polynomial< Rational > &	P,
		const Polynomial< Rational > &	Q,
		const SymbolicExpr &	zero,
		ComputationContext &	computation )

在文件 integration_rational.cpp 第 67 行定义.

                                                               {
    Polynomial<Rational> quot(Q.variable_name), rem = P;
    if (P.degree() >= Q.degree()) {
        auto divided = P.div_mod(Q);
        quot = std::move(divided.first);
        rem = std::move(divided.second);
    }
 
    detail::IntegralParts result{*rd_integrate_polynomial(quot, var), zero};
    if (rem.is_zero()) { return result; }
 
    std::vector<std::pair<Polynomial<Rational>, int>> factors;
    if (!detail::factor_denominator(Q, factors)) {
        result.remainder = *SymbolicExpr::divide(poly_to_symbolic(rem), poly_to_symbolic(Q));
        return result;
    }
 
    std::vector<Polynomial<Rational>> numerators;
    auto coefficients = detail::solve_coefficients(rem, Q, factors, numerators, computation);
    if (!coefficients) {
        return Result<detail::IntegralParts>::failure(coefficients.error());
    }
    if (!coefficients.value()) {
        result.remainder = *SymbolicExpr::divide(poly_to_symbolic(rem), poly_to_symbolic(Q));
        return result;
    }
    return rd_add_fraction_primitives(var, factors, numerators, std::move(result), computation);
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::detail::factor_denominator(), LMCAS::Result< T >::failure(), LMCAS::Polynomial< CoeffType >::is_zero(), rd_add_fraction_primitives(), rd_integrate_polynomial(), rd_integrate_proper_fraction(), LMCAS::detail::IntegralParts::remainder, LMCAS::detail::solve_coefficients() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 rd_integrate_proper_fraction().

函数调用图:

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

rd_reduce_reciprocal()

void LMCAS::anonymous_namespace{integration_rational.cpp}::rd_reduce_reciprocal	(	Polynomial< Rational > &	P,
		Polynomial< Rational > &	Q )

在文件 integration_rational.cpp 第 8 行定义.

                                                                            {
    if (!P.is_zero() && P.degree() > 0 && P.degree() < Q.degree()) {
        auto [reduced_denominator, remainder] = Q.div_mod(P);
        if (remainder.is_zero()) {
            P = Polynomial<Rational>(
                std::vector<Rational>{Rational(1)}, P.variable_name);
            Q = std::move(reduced_denominator);
        }
    }
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::is_zero(), rd_reduce_reciprocal() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 rd_reduce_reciprocal().

函数调用图:

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