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

函数
Polynomial< SymbolicPolyCoeff >	add_checked_coefficients (const Polynomial< SymbolicPolyCoeff > &left, const Polynomial< SymbolicPolyCoeff > &right, detail::RewriteBudget &budget)
Result< void >	check_power_coefficient_count (std::size_t base_count, int exponent, detail::RewriteBudget *budget)
Result< void >	check_zero_power_base (const detail::SymbolicNodePtr &base, ComputationContext &context)
void	checked_coefficient_count (std::size_t count, detail::RewriteBudget &budget)
std::size_t	checked_product_count (std::size_t left, std::size_t right, detail::RewriteBudget &budget)
template<typename Node>
detail::SymbolicNodePtr	coefficient_arithmetic (const detail::SymbolicNodePtr &left, const detail::SymbolicNodePtr &right, detail::RewriteBudget &budget)
template<typename T>
Result< Polynomial< T > >	constant_to_poly (const detail::SymbolicNodePtr &node, const std::string &variable, detail::RewriteBudget *budget)
Polynomial< SymbolicPolyCoeff >	multiply_checked_coefficients (const Polynomial< SymbolicPolyCoeff > &left, const Polynomial< SymbolicPolyCoeff > &right, detail::RewriteBudget &budget)
detail::SymbolicNodePtr	normalize_coefficient (const detail::SymbolicNodePtr &node, detail::RewriteBudget &budget)
void	trim_checked_coefficients (Polynomial< SymbolicPolyCoeff > &polynomial, detail::RewriteBudget &budget)

函数说明

add_checked_coefficients()

Polynomial< SymbolicPolyCoeff > LMCAS::anonymous_namespace{poly_utils.cpp}::add_checked_coefficients	(	const Polynomial< SymbolicPolyCoeff > &	left,
		const Polynomial< SymbolicPolyCoeff > &	right,
		detail::RewriteBudget &	budget )

在文件 poly_utils.cpp 第 174 行定义.

                                 {
    const auto count = std::max(left.coeffs.size(), right.coeffs.size());
    checked_coefficient_count(count, budget);
    Polynomial<SymbolicPolyCoeff> result(left.variable_name);
    result.coeffs.reserve(count);
    std::size_t nodes = 0;
    for (std::size_t index = 0; index < count; ++index) {
        detail::SymbolicNodePtr coefficient;
        if (index < left.coeffs.size() && index < right.coeffs.size()) {
            coefficient = coefficient_arithmetic<AddNode>(
                detail::node(left.coeffs[index].val), detail::node(right.coeffs[index].val), budget);
        } else {
            const auto& source = index < left.coeffs.size() ? left : right;
            coefficient = detail::node(source.coeffs[index].val);
        }
        nodes = budget.append_size(nodes, budget.measure(coefficient));
        result.coeffs.emplace_back(detail::make_expression_ptr(std::move(coefficient)));
    }
    trim_checked_coefficients(result, budget);
    return result;
}

引用了 add_checked_coefficients(), LMCAS::detail::RewriteBudget::append_size(), checked_coefficient_count(), coefficient_arithmetic(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::right, trim_checked_coefficients() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 add_checked_coefficients().

函数调用图:

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

check_power_coefficient_count()

Result< void > LMCAS::anonymous_namespace{poly_utils.cpp}::check_power_coefficient_count	(	std::size_t	base_count,
		int	exponent,
		detail::RewriteBudget *	budget )

在文件 poly_utils.cpp 第 246 行定义.

                                                                     {
    if (!budget || base_count == 0) { return Result<void>::success(); }
    const auto degree = base_count - 1;
    const auto maximum = static_cast<std::size_t>(std::numeric_limits<int>::max());
    const auto count = static_cast<std::size_t>(exponent);
    if (degree > (maximum - 1) / count) {
        return Result<void>::failure(CasErrc::ResourceLimit,
            "Polynomial coefficient storage limit exceeded", "polynomial.convert");
    }
    checked_coefficient_count(degree * count + 1, *budget);
    return Result<void>::success();
}

引用了 check_power_coefficient_count(), checked_coefficient_count(), LMCAS::exponent, LMCAS::Result< T >::failure(), LMCAS::ResourceLimit , 以及 LMCAS::Result< T >::success().

被这些函数引用 check_power_coefficient_count().

函数调用图:

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

check_zero_power_base()

Result< void > LMCAS::anonymous_namespace{poly_utils.cpp}::check_zero_power_base	(	const detail::SymbolicNodePtr &	base,
		ComputationContext &	context )

在文件 poly_utils.cpp 第 229 行定义.

                                                                    {
    const auto& facts = detail::no_facts();
    auto real_defined = detail::query_definedness(base, facts, Domain::Real, context);
    if (!real_defined) { return Result<void>::failure(real_defined.error()); }
    auto complex_defined = detail::query_definedness(base, facts, Domain::Complex, context);
    if (!complex_defined) { return Result<void>::failure(complex_defined.error()); }
    auto nonzero = detail::query_nonzero_value(base, facts, Domain::Real, context);
    if (!nonzero) { return Result<void>::failure(nonzero.error()); }
    if (real_defined.value() != Tribool::True ||
        complex_defined.value() != Tribool::True || nonzero.value() != Tribool::True) {
        return Result<void>::failure(CasErrc::UnsupportedExpression,
            "Zero power requires a defined nonzero base", "polynomial.convert");
    }
    return Result<void>::success();
}

引用了 check_zero_power_base(), LMCAS::Complex, LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::detail::no_facts(), LMCAS::detail::query_definedness(), LMCAS::detail::query_nonzero_value(), LMCAS::Real, LMCAS::Result< T >::success(), LMCAS::True , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 check_zero_power_base().

函数调用图:

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

checked_coefficient_count()

void LMCAS::anonymous_namespace{poly_utils.cpp}::checked_coefficient_count	(	std::size_t	count,
		detail::RewriteBudget &	budget )

在文件 poly_utils.cpp 第 125 行定义.

                                                                             {
    if (count > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
        throw CasError{CasErrc::ResourceLimit,
            "Polynomial coefficient storage limit exceeded", "polynomial.convert"};
    }
    auto terms = budget.context().require_expansion_terms(count, "polynomial.convert");
    if (!terms) { throw terms.error(); }
    budget.require_nodes(count);
}

引用了 checked_coefficient_count(), LMCAS::detail::RewriteBudget::context(), LMCAS::ComputationContext::require_expansion_terms(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 LMCAS::ResourceLimit.

被这些函数引用 add_checked_coefficients(), check_power_coefficient_count(), checked_coefficient_count(), checked_product_count() , 以及 constant_to_poly().

函数调用图:

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

checked_product_count()

std::size_t LMCAS::anonymous_namespace{poly_utils.cpp}::checked_product_count	(	std::size_t	left,
		std::size_t	right,
		detail::RewriteBudget &	budget )

在文件 poly_utils.cpp 第 135 行定义.

                                                              {
    if (left == 0 || right == 0) return 0;
    const auto maximum = static_cast<std::size_t>(std::numeric_limits<int>::max());
    if (left > maximum || right - 1 > maximum - left) {
        throw CasError{CasErrc::ResourceLimit,
            "Polynomial coefficient storage limit exceeded", "polynomial.convert"};
    }
    const auto count = left + right - 1;
    checked_coefficient_count(count, budget);
    return count;
}

引用了 checked_coefficient_count(), checked_product_count(), LMCAS::ResourceLimit , 以及 LMCAS::right.

被这些函数引用 checked_product_count() , 以及 multiply_checked_coefficients().

函数调用图:

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

coefficient_arithmetic()

template<typename Node>

detail::SymbolicNodePtr LMCAS::anonymous_namespace{poly_utils.cpp}::coefficient_arithmetic	(	const detail::SymbolicNodePtr &	left,
		const detail::SymbolicNodePtr &	right,
		detail::RewriteBudget &	budget )

在文件 poly_utils.cpp 第 156 行定义.

                                 {
    normalization_check_arithmetic<Node>(&budget, 0, left, right);
    return normalize_coefficient(detail::make_node<Node>(
        std::vector<detail::SymbolicNodePtr>{left, right}), budget);
}

引用了 coefficient_arithmetic(), LMCAS::detail::make_node(), LMCAS::normalization_check_arithmetic(), normalize_coefficient() , 以及 LMCAS::right.

被这些函数引用 add_checked_coefficients(), coefficient_arithmetic() , 以及 multiply_checked_coefficients().

函数调用图:

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

constant_to_poly()

template<typename T>

Result< Polynomial< T > > LMCAS::anonymous_namespace{poly_utils.cpp}::constant_to_poly	(	const detail::SymbolicNodePtr &	node,
		const std::string &	variable,
		detail::RewriteBudget *	budget )

在文件 poly_utils.cpp 第 261 行定义.

                                 {
    if constexpr (std::is_same_v<T, SymbolicPolyCoeff>) {
        if (budget) {
            checked_coefficient_count(1, *budget);
            auto coefficient = normalize_coefficient(node, *budget);
            budget->append_size(0, budget->measure(coefficient));
            Polynomial<T> result(variable);
            result.coeffs.emplace_back(detail::make_expression_ptr(std::move(coefficient)));
            trim_checked_coefficients(result, *budget);
            return result;
        }
    }
    auto coefficient = extract_coeff_value<T>(detail::make_expression_ptr(node));
    if (!coefficient) { return Result<Polynomial<T>>::failure(coefficient.error()); }
    return Polynomial<T>({std::move(coefficient.value())}, variable);
}

引用了 LMCAS::Polynomial< CoeffType >::Polynomial(), LMCAS::detail::RewriteBudget::append_size(), checked_coefficient_count(), LMCAS::Polynomial< CoeffType >::coeffs, constant_to_poly(), LMCAS::extract_coeff_value(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), normalize_coefficient(), trim_checked_coefficients() , 以及 LMCAS::variable.

被这些函数引用 constant_to_poly().

函数调用图:

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

multiply_checked_coefficients()

Polynomial< SymbolicPolyCoeff > LMCAS::anonymous_namespace{poly_utils.cpp}::multiply_checked_coefficients	(	const Polynomial< SymbolicPolyCoeff > &	left,
		const Polynomial< SymbolicPolyCoeff > &	right,
		detail::RewriteBudget &	budget )

在文件 poly_utils.cpp 第 198 行定义.

                                 {
    const auto count = checked_product_count(left.coeffs.size(), right.coeffs.size(), budget);
    Polynomial<SymbolicPolyCoeff> result(left.variable_name);
    result.coeffs.reserve(count);
    std::size_t nodes = 0;
    for (std::size_t degree = 0; degree < count; ++degree) {
        detail::SymbolicNodePtr coefficient;
        std::size_t coefficient_nodes = 0;
        const auto first = degree < right.coeffs.size() ? 0 : degree - right.coeffs.size() + 1;
        const auto last = std::min(degree, left.coeffs.size() - 1);
        for (std::size_t index = first; index <= last; ++index) {
            auto product = coefficient_arithmetic<MultiplyNode>(
                detail::node(left.coeffs[index].val),
                detail::node(right.coeffs[degree - index].val), budget);
            if (coefficient) {
                coefficient = coefficient_arithmetic<AddNode>(coefficient, product, budget);
            } else {
                coefficient.swap(product);
            }
            coefficient_nodes = budget.measure(coefficient);
            budget.append_size(nodes, coefficient_nodes);
        }
        nodes = budget.append_size(nodes, coefficient_nodes);
        result.coeffs.emplace_back(detail::make_expression_ptr(std::move(coefficient)));
    }
    trim_checked_coefficients(result, budget);
    return result;
}

引用了 LMCAS::detail::RewriteBudget::append_size(), checked_product_count(), coefficient_arithmetic(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), multiply_checked_coefficients(), LMCAS::detail::node(), LMCAS::right, trim_checked_coefficients() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 multiply_checked_coefficients().

函数调用图:

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

normalize_coefficient()

detail::SymbolicNodePtr LMCAS::anonymous_namespace{poly_utils.cpp}::normalize_coefficient	(	const detail::SymbolicNodePtr &	node,
		detail::RewriteBudget &	budget )

在文件 poly_utils.cpp 第 148 行定义.

                                                                    {
    auto step = budget.context().consume_steps(1, "polynomial.coefficient");
    if (!step) { throw step.error(); }
    return detail::normalize_node(node, budget);
}

引用了 LMCAS::ComputationContext::consume_steps(), LMCAS::detail::RewriteBudget::context(), normalize_coefficient() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 coefficient_arithmetic(), constant_to_poly() , 以及 normalize_coefficient().

函数调用图:

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

trim_checked_coefficients()

void LMCAS::anonymous_namespace{poly_utils.cpp}::trim_checked_coefficients	(	Polynomial< SymbolicPolyCoeff > &	polynomial,
		detail::RewriteBudget &	budget )

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

                                                            {
    while (!polynomial.coeffs.empty()) {
        auto step = budget.context().consume_steps(1, "polynomial.coefficient");
        if (!step) { throw step.error(); }
        if (!detail::node(polynomial.coeffs.back().val)->is_zero()) break;
        polynomial.coeffs.pop_back();
    }
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::ComputationContext::consume_steps(), LMCAS::detail::RewriteBudget::context(), LMCAS::detail::node() , 以及 trim_checked_coefficients().

被这些函数引用 add_checked_coefficients(), constant_to_poly(), multiply_checked_coefficients() , 以及 trim_checked_coefficients().

函数调用图:

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