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

函数
std::shared_ptr< SymbolicExpr >	rd_fraction_term (const Polynomial< Rational > &numerator, const Polynomial< Rational > &factor, int power)
std::shared_ptr< SymbolicExpr >	rd_integrate_linear_term (const Polynomial< Rational > &numerator, const Polynomial< Rational > &factor, int power, const std::string &var)
std::shared_ptr< SymbolicExpr >	rd_integrate_negative_discriminant (const std::shared_ptr< SymbolicExpr > &result, const std::shared_ptr< SymbolicExpr > &shifted, const Rational &residual, const Rational &discriminant)
std::shared_ptr< SymbolicExpr >	rd_integrate_positive_discriminant (const std::shared_ptr< SymbolicExpr > &result, const std::shared_ptr< SymbolicExpr > &shifted, const Rational &residual, const Rational &discriminant)
std::shared_ptr< SymbolicExpr >	rd_integrate_quadratic_term (const Polynomial< Rational > &numerator, const Polynomial< Rational > &factor, const std::string &var)
std::shared_ptr< SymbolicExpr >	rd_integrate_repeated_quadratic (const Polynomial< Rational > &numerator, const Polynomial< Rational > &factor, const Rational &p, const Rational &B, const Rational &residual, const std::string &var)
std::shared_ptr< SymbolicExpr >	rd_quadratic_logarithm (const Polynomial< Rational > &factor, const Rational &B)
std::shared_ptr< SymbolicExpr >	rd_shifted_double_variable (const Rational &p, const std::string &var)
std::shared_ptr< SymbolicExpr >	rd_var_minus (const std::string &var, const Rational &r)

函数说明

rd_fraction_term()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_fraction_term	(	const Polynomial< Rational > &	numerator,
		const Polynomial< Rational > &	factor,
		int	power )

在文件 integration_rational_terms.cpp 第 31 行定义.

               {
    auto numerator_expr = poly_to_symbolic(numerator);
    auto denominator = poly_to_symbolic(factor);
    auto denominator_power = SymbolicExpr::power(
        denominator, SymbolicExpr::number(BigInt(power)));
    auto inverse = SymbolicExpr::power(
        denominator_power, SymbolicExpr::number(BigInt(-1)));
    return SymbolicExpr::multiply(numerator_expr, inverse);
}

引用了 LMCAS::denominator , 以及 rd_fraction_term().

被这些函数引用 rd_fraction_term().

函数调用图:

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

rd_integrate_linear_term()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_linear_term	(	const Polynomial< Rational > &	numerator,
		const Polynomial< Rational > &	factor,
		int	power,
		const std::string &	var )

在文件 integration_rational_terms.cpp 第 12 行定义.

                                     {
        Rational r = Rational(0) - factor.coeffs[0];
        Rational A = (numerator.coeffs.size() > 0) ? numerator.coeffs[0] : Rational(0);
        if (A == Rational(0)) { return SymbolicExpr::number(0); }
 
        if (power == 1) {
            auto inner = rd_var_minus(var, r);
            return SymbolicExpr::multiply(SymbolicExpr::number(A), SymbolicExpr::ln(inner));
        }
        Rational coeff = Rational(0) - A / Rational(BigInt(power - 1));
        auto base = rd_var_minus(var, r);
        auto exp = SymbolicExpr::number(BigInt(power - 1));
        auto pw = SymbolicExpr::power(base, exp);
        auto inv_pw = SymbolicExpr::power(pw, SymbolicExpr::number(BigInt(-1)));
        return SymbolicExpr::multiply(SymbolicExpr::number(coeff), inv_pw);
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::exp(), LMCAS::r, rd_integrate_linear_term() , 以及 rd_var_minus().

被这些函数引用 rd_integrate_linear_term() , 以及 rd_integrate_repeated_quadratic().

函数调用图:

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

rd_integrate_negative_discriminant()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_negative_discriminant	(	const std::shared_ptr< SymbolicExpr > &	result,
		const std::shared_ptr< SymbolicExpr > &	shifted,
		const Rational &	residual,
		const Rational &	discriminant )

在文件 integration_rational_terms.cpp 第 85 行定义.

                                                            {
    auto square_root = SymbolicExpr::sqrt(
        SymbolicExpr::number(Rational(0) - discriminant));
    auto inverse_root = SymbolicExpr::power(
        square_root, SymbolicExpr::number(BigInt(-1)));
    auto arctangent = make_arctan(
        SymbolicExpr::multiply(shifted, inverse_root));
    auto coefficient = SymbolicExpr::multiply(
        SymbolicExpr::multiply(
            SymbolicExpr::number(residual),
            SymbolicExpr::number(BigInt(2))),
        inverse_root);
    return SymbolicExpr::add(
        result, SymbolicExpr::multiply(coefficient, arctangent));
}

引用了 LMCAS::make_arctan() , 以及 rd_integrate_negative_discriminant().

被这些函数引用 rd_integrate_negative_discriminant() , 以及 rd_integrate_quadratic_term().

函数调用图:

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

rd_integrate_positive_discriminant()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_positive_discriminant	(	const std::shared_ptr< SymbolicExpr > &	result,
		const std::shared_ptr< SymbolicExpr > &	shifted,
		const Rational &	residual,
		const Rational &	discriminant )

在文件 integration_rational_terms.cpp 第 104 行定义.

                                                            {
    auto square_root =
        SymbolicExpr::sqrt(SymbolicExpr::number(discriminant));
    auto negative_root = SymbolicExpr::multiply(
        SymbolicExpr::number(BigInt(-1)), square_root);
    auto ratio = SymbolicExpr::divide(
        SymbolicExpr::add(shifted, negative_root),
        SymbolicExpr::add(shifted, square_root));
    auto inverse_root = SymbolicExpr::power(
        square_root, SymbolicExpr::number(BigInt(-1)));
    auto coefficient = SymbolicExpr::multiply(
        SymbolicExpr::number(residual), inverse_root);
    return SymbolicExpr::add(
        result,
        SymbolicExpr::multiply(coefficient, SymbolicExpr::ln(ratio)));
}

引用了 rd_integrate_positive_discriminant().

被这些函数引用 rd_integrate_positive_discriminant() , 以及 rd_integrate_quadratic_term().

函数调用图:

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

rd_integrate_quadratic_term()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_quadratic_term	(	const Polynomial< Rational > &	numerator,
		const Polynomial< Rational > &	factor,
		const std::string &	var )

在文件 integration_rational_terms.cpp 第 124 行定义.

                          {
    const Rational q = factor.coeffs.empty()
        ? Rational(0) : factor.coeffs[0];
    const Rational p = factor.coeffs.size() > 1
        ? factor.coeffs[1] : Rational(0);
    const Rational discriminant = p * p - Rational(4) * q;
    const Rational B = numerator.coeffs.size() > 1
        ? numerator.coeffs[1] : Rational(0);
    const Rational C = numerator.coeffs.empty()
        ? Rational(0) : numerator.coeffs[0];
    const Rational residual = C - (B * p) / Rational(2);
 
    if (discriminant == Rational(0)) {
        return rd_integrate_repeated_quadratic(
            numerator, factor, p, B, residual, var);
    }
 
    auto result = rd_quadratic_logarithm(factor, B);
    if (residual == Rational(0)) {
        return result;
    }
    auto shifted = rd_shifted_double_variable(p, var);
    if (discriminant.get_numerator().is_negative()) {
        return rd_integrate_negative_discriminant(
            result, shifted, residual, discriminant);
    }
    return rd_integrate_positive_discriminant(
        result, shifted, residual, discriminant);
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, rd_integrate_negative_discriminant(), rd_integrate_positive_discriminant(), rd_integrate_quadratic_term(), rd_integrate_repeated_quadratic(), rd_quadratic_logarithm() , 以及 rd_shifted_double_variable().

被这些函数引用 rd_integrate_quadratic_term().

函数调用图:

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

rd_integrate_repeated_quadratic()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_repeated_quadratic	(	const Polynomial< Rational > &	numerator,
		const Polynomial< Rational > &	factor,
		const Rational &	p,
		const Rational &	B,
		const Rational &	residual,
		const std::string &	var )

在文件 integration_rational_terms.cpp 第 44 行定义.

                                                    {
    Polynomial<Rational> linear(
        std::vector<Rational>{p / Rational(2), Rational(1)},
        factor.variable_name);
    Polynomial<Rational> linear_numerator(
        std::vector<Rational>{B}, numerator.variable_name);
    Polynomial<Rational> repeated_numerator(
        std::vector<Rational>{residual}, numerator.variable_name);
    auto logarithmic = rd_integrate_linear_term(
        linear_numerator, linear, 1, var);
    auto repeated = rd_integrate_linear_term(
        repeated_numerator, linear, 2, var);
    return SymbolicExpr::add(logarithmic, repeated);
}

引用了 rd_integrate_linear_term(), rd_integrate_repeated_quadratic() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 rd_integrate_quadratic_term() , 以及 rd_integrate_repeated_quadratic().

函数调用图:

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

rd_quadratic_logarithm()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_quadratic_logarithm	(	const Polynomial< Rational > &	factor,
		const Rational &	B )

在文件 integration_rational_terms.cpp 第 63 行定义.

                                                           {
    const Rational half = B / Rational(2);
    auto result = SymbolicExpr::number(0);
    if (half == Rational(0)) {
        return result;
    }
    auto denominator = poly_to_symbolic(factor);
    auto logarithm = SymbolicExpr::multiply(
        SymbolicExpr::number(half), SymbolicExpr::ln(denominator));
    return SymbolicExpr::add(result, logarithm);
}

引用了 LMCAS::denominator , 以及 rd_quadratic_logarithm().

被这些函数引用 rd_integrate_quadratic_term() , 以及 rd_quadratic_logarithm().

函数调用图:

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

rd_shifted_double_variable()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_shifted_double_variable	(	const Rational &	p,
		const std::string &	var )

在文件 integration_rational_terms.cpp 第 76 行定义.

                                             {
    auto two_x = SymbolicExpr::multiply(
        SymbolicExpr::number(BigInt(2)), SymbolicExpr::variable(var));
    return p == Rational(0)
        ? two_x
        : SymbolicExpr::add(two_x, SymbolicExpr::number(p));
}

引用了 rd_shifted_double_variable().

被这些函数引用 rd_integrate_quadratic_term() , 以及 rd_shifted_double_variable().

函数调用图:

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

rd_var_minus()

std::shared_ptr< SymbolicExpr > LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_var_minus	(	const std::string &	var,
		const Rational &	r )

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

                                                                                  {
    auto v = SymbolicExpr::variable(var);
    if (r == Rational(0)) { return v; }
    return SymbolicExpr::add(v, SymbolicExpr::number(Rational(0) - r));
}

引用了 LMCAS::r, rd_var_minus() , 以及 LMCAS::v.

被这些函数引用 rd_integrate_linear_term() , 以及 rd_var_minus().

函数调用图:

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