LMCAS::detail 命名空间参考

多元 Hensel 提升（单变量步） 更多...

命名空间
namespace	anonymous_namespace{assumption_simplification.cpp}
namespace	anonymous_namespace{complex_quadratic.cpp}
namespace	anonymous_namespace{complex_root_isolation.cpp}
namespace	anonymous_namespace{exact_algebraic.cpp}
namespace	anonymous_namespace{exact_algebraic_refinement.cpp}
namespace	anonymous_namespace{exact_constant_bounds.cpp}
namespace	anonymous_namespace{exact_matrix.cpp}
namespace	anonymous_namespace{exact_matrix_determinant.cpp}
namespace	anonymous_namespace{exact_matrix_solve.cpp}
namespace	anonymous_namespace{exact_matrix_support.cpp}
namespace	anonymous_namespace{exact_rational_solve.cpp}
namespace	anonymous_namespace{exact_root.cpp}
namespace	anonymous_namespace{exact_sturm.cpp}
namespace	anonymous_namespace{facts_query.cpp}
namespace	anonymous_namespace{facts_query_adapters.cpp}
namespace	anonymous_namespace{facts_query_rational.cpp}
namespace	anonymous_namespace{interval_endpoint.cpp}
namespace	anonymous_namespace{interval_endpoint_order.cpp}
namespace	anonymous_namespace{lmmc_lifecycle.cpp}
namespace	anonymous_namespace{mixed_transcendental_isolation.cpp}
namespace	anonymous_namespace{mixed_transcendental_refinement.cpp}
namespace	anonymous_namespace{numeric_evaluation_functions.cpp}
namespace	anonymous_namespace{numeric_evaluation_power.cpp}
namespace	anonymous_namespace{rewrite_budget.cpp}
namespace	anonymous_namespace{squared_norm.cpp}
namespace	anonymous_namespace{symbolic_quadric_classification.cpp}
namespace	complex_root
namespace	definite
namespace	inequality_support
namespace	matrix_api
namespace	matrix_decomposition
namespace	matrix_kernel
namespace	series_support
namespace	transcendental

类
struct	AffineForm
class	AssumptionFacts
struct	BinderView
struct	CheckedInterval
struct	ComparableEndpoint
struct	ComplexIsolation
struct	EliminationResult
class	ExactBoundArithmetic
	常数及根式包围区间共用的内部算术策略。 保守界覆盖未约分 Rational 的交叉乘积及结果；受检入口统一捕获 CasError，仅返回完整结果。 更多...
struct	ExactMatrixData
struct	ExactRealAlgebraic
struct	ExactRootId
struct	InconsistentLinearSolution
struct	IntegralParts
struct	IntegrationEntry
class	NodeTypeDetector
struct	NumericEvaluationOptions
class	NumericEvaluator
struct	ParametricLinearSolution
struct	QuadraticCartesianRoot
struct	RealIsolation
class	RecursiveSymbolicVisitor
class	RewriteBudget
class	RewriteScope
class	ScopedFacts
	为绑定体提供词法作用域，隔离同名自由变量的外层事实。 无关表达式继续借用外层事实及其关系推论；栈上视图串联保留嵌套作用域。 更多...
struct	SymbolicExprAccess
class	SymbolicRewriter
class	SymbolicVisitor
struct	UniqueLinearSolution

类型定义
using	CartesianQuadraticRoots = std::array<QuadraticCartesianRoot, 2>
using	ExactConstantInterval = std::pair<Rational, Rational>
using	ExactLinearSolution
using	ExactRealAlgebraicResult = Result<ExactRealAlgebraic>
using	Node = std::shared_ptr<const SymbolicNode>
using	RationalInterval = std::pair<Rational, Rational>
using	RootIsolation = std::variant<RealIsolation, ComplexIsolation>
using	SymbolicNodePtr = std::shared_ptr<const SymbolicNode>

枚举
enum class	EliminationForm { Echelon , ReducedRowEchelon }
enum class	ZeroProof { Zero , NonZero , Unknown }

函数
	__attribute__ ((visibility("default"))) bool is_linear(const MultiPoly &poly
	检测是否为线性多项式
	__attribute__ ((visibility("default"))) ExactRealAlgebraicResult make_exact_real_algebraic(Polynomial< Rational > polynomial
static void	adjust_homogeneous_constant (const MultiPoly &poly, MultiFactorResult &result)
std::set< std::string >	all_variable_names (const SymbolicNodePtr &expression, RewriteBudget *budget=nullptr)
std::optional< BinderView >	binder_view (const SymbolicNode &node)
template<typename Transform>
ExpressionResult	checked_transform_expr (const ExprPtr &expression, ComputationContext &context, const char *operation, const char *transform_name, Transform &&transform)
Result< ZeroProof >	classify_exact_zero (const ExprPtr &expression, ComputationContext &context, const std::string &operation)
VectorStringResult	classify_quadric_impl (const SurfaceSymbolic &surf, ComputationContext &context, const std::string &operation)
std::optional< Rational >	closed_rational_value (const Node &node, Domain domain, ComputationContext &context)
std::optional< Rational >	closed_rational_value (const std::shared_ptr< const SymbolicNode > &node, Domain domain, ComputationContext &context)
Result< ComparableEndpoint >	comparable_endpoint (const Endpoint &endpoint, ComputationContext &context, const std::string &operation)
Result< int >	compare_comparable (const ComparableEndpoint &left, const ComparableEndpoint &right, ComputationContext &context)
Result< int >	compare_exact_real_algebraic (ExactRealAlgebraic lhs, ExactRealAlgebraic rhs, ComputationContext &context)
Result< Tribool >	compare_pointwise_values (const ExprPtr &left, const ExprPtr &right, ComputationContext &context, Domain domain)
	在给定假设的 Real 或 Complex 域内比较逐点值，并保留错误。 True/False 分别证明值处处有定义且相等/不等；定义性未证实也归为 Unknown， 仅有非恒等残差不足以判定 False。
ExpressionResult	constant_expression (const char *name)
bool	consume_decimal_digits (std::string_view token, std::size_t &pos) noexcept
bool	consume_decimal_exponent (std::string_view token, std::size_t &pos) noexcept
bool	consume_decimal_mantissa (std::string_view token, std::size_t &pos) noexcept
void	consume_decimal_sign (std::string_view token, std::size_t &pos) noexcept
bool	consume_mixed_step (ComputationContext &context, std::optional< CasError > *failure, bool *complete)
template<class Node>
bool	contains_node_type (const SymbolicNodePtr &root)
Result< std::size_t >	count_real_roots_exact (const Polynomial< Rational > &polynomial, const Rational &lower, const Rational &upper, ComputationContext &context, const std::string &operation)
std::optional< std::tuple< std::string, std::string, int > >	detect_binomial_power (const MultiPoly &poly)
	检测二项式幂模式 xⁿ - yⁿ
std::optional< std::pair< MultiPoly, MultiPoly > >	detect_difference_of_squares (const MultiPoly &poly)
	检测差平方模式 a^2 - b^2
Result< ExprPtr >	determinant_exact (const ExactMatrixData &input, ComputationContext &context, const std::string &operation)
ExpressionResult	differentiate_expression (const ExprPtr &expression, const std::string &variable, ComputationContext &context)
SymbolicNodePtr	differentiate_node (const SymbolicNodePtr &node, const std::string &variable, RewriteBudget &budget, const FactsQuery &facts, Domain domain)
Result< std::optional< std::vector< std::shared_ptr< SymbolicExpr > > > >	domain_constraints (const Node &node, const FactsQuery &facts, Domain domain, ComputationContext &context)
Result< std::optional< std::vector< std::shared_ptr< SymbolicExpr > > > >	domain_constraints (const std::shared_ptr< const SymbolicNode > &expression, const FactsQuery &facts, Domain domain, ComputationContext &context)
	返回完整定义域约束：空向量表示已证明，nullopt 表示无法完整表达。
Result< EliminationResult >	eliminate_exact (ExactMatrixData input, std::size_t coefficient_columns, EliminationForm form, ComputationContext &context, const std::string &operation)
void	ensure_lmmc_lifecycle () noexcept
Result< bool >	equal_exact_real_algebraic (ExactRealAlgebraic lhs, ExactRealAlgebraic rhs, ComputationContext &context)
ExprPtr	equation_predicate (const ExprPtr &expression)
Result< bool >	equivalent_impl (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context, const EqvOptions &options)
Result< ApproxComplex >	evaluate_root_complex (const ExactRootId &root, const NumericEvaluationOptions &options, ComputationContext &context)
Result< ApproxReal >	evaluate_root_real (const ExactRootId &root, const NumericEvaluationOptions &options, ComputationContext &context)
Result< ApproxReal >	evaluate_unary_numeric (FunctionNode::FuncType type, double value)
Result< ExactConstantInterval >	exact_atan_bounds (const Rational &value, std::size_t precision_bits, ComputationContext &context)
Result< Rational >	exact_double_rational (double value, ComputationContext &context, const std::string &operation)
Result< ExactConstantInterval >	exact_e_bounds (std::size_t precision_bits, ComputationContext &context)
Result< ExactConstantInterval >	exact_pi_bounds (std::size_t precision_bits, ComputationContext &context)
std::optional< Rational >	exact_rational_value (const NumberNode &number)
std::optional< Rational >	exact_rational_value (const SymbolicNodePtr &node)
ExpressionResult	expand_expression (const ExprPtr &expression, ComputationContext &context)
SymbolicNodePtr	expand_node (const SymbolicNodePtr &node, RewriteBudget &budget, const FactsQuery &facts, Domain domain)
inline ::LMCAS::SymbolicExpr	expression_from_node (SymbolicNodePtr root)
std::pair< Monomial, MultiPoly >	extract_common_monomial (const MultiPoly &poly)
	提取公因子单项式
Result< bool >	extract_rational (const SymbolicExpr &expr, const std::string &var, Polynomial< Rational > &numerator, Polynomial< Rational > &denominator)
bool	factor_denominator (const Polynomial< Rational > &denominator, std::vector< std::pair< Polynomial< Rational >, int > > &factors)
Result< std::optional< MultiFactorResult > >	factor_homogeneous_bivariate (const MultiPoly &poly, ComputationContext &context)
	齐次二元多项式分解
SolveResult	finalize_solution_set (const ExprPtr &original, const std::string &variable, SolutionSet solutions, ComputationContext &context, Domain domain, const SolveOptions &options)
static MultiPoly	homogenize_factor (const Polynomial< Rational > &uf, const std::vector< std::string > &vars)
Result< std::optional< SymbolicExpr > >	integrate_power_primitive (const SymbolicExpr &base, const SymbolicExpr &exponent, const std::string &variable, ComputationContext &)
IntegralParts	integrate_rational_term (const Polynomial< Rational > &numerator, const Polynomial< Rational > &factor, int power, const std::string &var)
bool	integration_depends_on_variable (const SymbolicNodePtr &expression, const std::string &variable, RewriteBudget *budget=nullptr)
Result< ExactMatrixData >	inverse_exact (const ExactMatrixData &input, ComputationContext &context, const std::string &operation)
bool	is_imaginary_unit_name (const std::string &name)
bool	is_linear (const MultiPoly &poly, const std::string &main_var)
	检测是否为线性多项式(主变量次数 <= 1)
bool	is_signed_decimal_token (std::string_view token) noexcept
Result< RootIsolation >	isolate_exact_root (const ExactRootId &root, ComputationContext &context, const std::string &operation)
Result< std::vector< RootIsolation > >	isolate_exact_roots (const Polynomial< Rational > &input, ComputationContext &context, const std::string &operation)
Result< std::vector< RationalInterval > >	isolate_real_roots_exact (const Polynomial< Rational > &polynomial, ComputationContext &context, const std::string &operation)
std::vector< IsolatedInterval >	isolate_roots_with_context (const std::shared_ptr< SymbolicExpr > &expr, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &var, const SearchInterval &interval, const SolveOptions &opts, RewriteBudget &budget, std::optional< CasError > *failure, bool *complete)
ExactRealAlgebraicResult	make_exact_real_algebraic (Polynomial< Rational > polynomial, std::size_t root_index, std::size_t multiplicity, ComputationContext &context)
Result< ExactRootId >	make_exact_root_id (Polynomial< Rational > polynomial, std::size_t index, ComputationContext &context, const std::string &operation)
std::shared_ptr<::LMCAS::SymbolicExpr >	make_expression_ptr (const ::LMCAS::SymbolicExpr &expression)
std::shared_ptr<::LMCAS::SymbolicExpr >	make_expression_ptr (SymbolicNodePtr root)
std::vector< IntegrationEntry >	make_integration_entries ()
template<typename Node, typename... Args>
std::shared_ptr< const Node >	make_node (Args &&... args)
std::vector< std::shared_ptr< SymbolicExpr > >	make_rootof_solutions_impl (const Polynomial< SymbolicPolyCoeff > &polynomial, const std::string &variable, ComputationContext &context)
SymbolicExpr	materialize_integral (const IntegralParts &parts, const std::string &variable, RewriteBudget &budget)
Result< std::vector< std::pair< ExprPtr, std::vector< std::vector< ExprPtr > > > > >	matrix_eigenspaces_checked (const ExprPtr &matrix, ComputationContext &context)
lmmc_real_t	mixed_evaluate_at (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, lmmc_real_t x, RewriteBudget &budget)
lmmc_real_t	mixed_evaluate_with_retry (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, lmmc_real_t x, lmmc_real_t half_width, RewriteBudget &budget, int max_retries=3)
Result< std::vector< NumericRoot > >	mixed_numerical_path (const std::shared_ptr< SymbolicExpr > &factor, const std::string &var, const SearchInterval &interval, const SolveOptions &opts, RewriteBudget &budget, bool &complete)
	隔离并精化单个因子的数值根。
std::shared_ptr< SymbolicExpr >	multiply_expression_factors (const std::vector< std::shared_ptr< SymbolicExpr > > &factors)
std::vector< std::shared_ptr< SymbolicExpr > >	multipoly_term_factors (const Monomial &monomial, const Rational &coefficient, const std::vector< std::string > &variables)
std::shared_ptr< SymbolicExpr >	multipoly_term_to_expression (const Monomial &monomial, const Rational &coefficient, const std::vector< std::string > &variables)
const FactsQuery &	no_facts () noexcept
const SymbolicNodePtr &	node (const ::LMCAS::SymbolicExpr &expression) noexcept
const SymbolicNodePtr &	node (const std::shared_ptr< const ::LMCAS::SymbolicExpr > &expression) noexcept
const SymbolicNodePtr &	node (const std::shared_ptr<::LMCAS::SymbolicExpr > &expression) noexcept
SymbolicNodePtr	normalize_node (const SymbolicNodePtr &node, RewriteBudget &budget, const FactsQuery &facts, Domain domain)
Result< std::vector< std::vector< ExprPtr > > >	nullspace_exact (ExactMatrixData coefficients, ComputationContext &context, const std::string &operation)
Result< ApproxReal >	numeric_approximation (double value)
Result< ApproxReal >	numeric_failure (CasErrc code, std::string message)
Result< double >	parse_finite_decimal (std::string_view token)
Result< Tribool >	query_definedness (const Node &node, const FactsQuery &facts, Domain domain, ComputationContext &context, bool *violated_real_restriction)
Result< Tribool >	query_definedness (const std::shared_ptr< const SymbolicNode > &node, const FactsQuery &facts, Domain domain, ComputationContext &context, bool *violated_real_restriction=nullptr)
Result< Tribool >	query_nonnegative_value (const Node &node, const FactsQuery &facts, ComputationContext &context)
Result< Tribool >	query_nonnegative_value (const std::shared_ptr< const SymbolicNode > &node, const FactsQuery &facts, ComputationContext &context)
Result< Tribool >	query_nonzero_value (const Node &node, const FactsQuery &facts, Domain domain, ComputationContext &context)
Result< Tribool >	query_nonzero_value (const std::shared_ptr< const SymbolicNode > &node, const FactsQuery &facts, Domain domain, ComputationContext &context)
Result< Tribool >	query_positive_value (const Node &node, const FactsQuery &facts, ComputationContext &context)
Result< Tribool >	query_positive_value (const std::shared_ptr< const SymbolicNode > &node, const FactsQuery &facts, ComputationContext &context)
Result< Tribool >	query_real_value (const Node &node, const FactsQuery &facts, ComputationContext &context)
Result< Tribool >	query_real_value (const std::shared_ptr< const SymbolicNode > &node, const FactsQuery &facts, ComputationContext &context)
Result< std::size_t >	rank_exact (ExactMatrixData input, std::size_t coefficient_columns, ComputationContext &context, const std::string &operation)
Result< Rational >	rational_determinant_exact (std::size_t dimension, std::vector< Rational > values, ComputationContext &context, const std::string &operation)
Result< Rational >	rational_determinant_value_impl (std::size_t dimension, std::vector< Rational > values, ComputationContext &context, const std::string &operation)
static std::optional< Rational >	rational_square_root (const Rational &coefficient)
bool	rational_system_inconsistent (std::size_t rows, std::size_t coefficient_columns, const std::vector< Rational > &matrix)
Result< CartesianQuadraticRoots >	real_quadratic_roots_checked (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, ComputationContext &context)
Result< std::optional< AffineForm > >	recognize_affine (const SymbolicExpr &expression, const std::string &variable, ComputationContext &context)
std::vector< std::optional< std::size_t > >	reduce_rational_rows (std::size_t rows, std::size_t coefficient_columns, std::vector< Rational > &matrix, bool start_at_pivot)
Result< void >	refine_complex_isolation (const Polynomial< Rational > &, ComplexIsolation &isolation, const NumericEvaluationOptions &options, ComputationContext &context, const std::string &operation)
Result< void >	refine_exact_real_algebraic (ExactRealAlgebraic &value, ComputationContext &context, const std::string &operation)
Result< void >	refine_exact_real_algebraic_to_tolerance (ExactRealAlgebraic &value, double absolute_tolerance, double relative_tolerance, ComputationContext &context, const std::string &operation)
std::optional< NumericRoot >	refine_root_with_context (const std::shared_ptr< SymbolicExpr > &expr, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &var, const IsolatedInterval &interval, const SolveOptions &opts, RewriteBudget &budget, std::optional< CasError > *failure, bool *complete)
constexpr RelationOp	reversed_relation (RelationOp op) noexcept
Result< ExactMatrixData >	rref_exact (ExactMatrixData input, std::size_t coefficient_columns, ComputationContext &context, const std::string &operation)
ExpressionResult	simplify_expression (const ExprPtr &expression, ComputationContext &context)
Result< bool >	solve_coefficients (const Polynomial< Rational > &numerator, const Polynomial< Rational > &denominator, const std::vector< std::pair< Polynomial< Rational >, int > > &factors, std::vector< Polynomial< Rational > > &numerators, ComputationContext &context)
Result< ExactLinearSolution >	solve_linear_exact (ExactMatrixData augmented, std::size_t coefficient_columns, ComputationContext &context, const std::string &operation)
Result< std::vector< Rational > >	solve_rational_unique (std::size_t rows, std::size_t coefficient_columns, std::vector< Rational > matrix, ComputationContext &context, const std::string &operation)
std::array< const PowerNode *, 2 >	squared_norm_terms (const SymbolicNode &root)
	Recognize real-numeric norm forms without evaluating their squares.
Rational	strict_cauchy_root_bound (const Polynomial< Rational > &polynomial)
ExpressionResult	substitute_expression (const ExprPtr &expression, const std::string &variable, const ExprPtr &replacement, ComputationContext &context)
ExpressionResult	substitute_expression (const ExprPtr &expression, const std::vector< Binding > &replacements, ComputationContext &context)
SymbolicNodePtr	substitute_node (const SymbolicNodePtr &node, const std::string &variable, const SymbolicNodePtr &replacement, RewriteBudget &budget, const FactsQuery &facts, Domain domain)
ExprPtr	substitute_raw (const ExprPtr &expression, const std::string &variable, const ExprPtr &value)
Result< Polynomial< SymbolicPolyCoeff > >	symbolic_to_poly_checked (const SymbolicExpr &expression, const std::string &variable, ComputationContext &context)
BigInt	symmetric_remainder (const BigInt &value, const BigInt &modulus)
std::optional< double >	try_finite_numeric (const SymbolicExpr &expression, ComputationContext &context)

变量
double	absolute_tolerance
RewriteBudget &	budget
std::size_t std::size_t ComputationContext &	context
RewriteBudget const FactsQuery Domain	domain = Domain::Real)
RewriteBudget const FactsQuery &	facts = no_facts()
const std::string &	main_var
std::size_t std::size_t	multiplicity
ComputationContext const std::string &	operation = "exact_algebraic.refine")
double double	relative_tolerance
const std::string const SymbolicNodePtr &	replacement
ExactRealAlgebraic	rhs
std::size_t	root_index
const std::string &	variable

详细描述

多元 Hensel 提升（单变量步）

将一元因子逐变量提升，从 f(x₁, a₂, ..., aₙ) 的因子恢复到包含 lift_var 的因子。 每次引入一个辅助变量，计算修正项直到达到次数上界。

参数

[in]	poly	原始多元多项式
[in]	univariate_factors	一元分解得到的因子列表
[in]	lift_var	当前提升的变量名
[in]	eval_point	该变量的求值点
[in]	degree_bound	提升次数上界

返回

提升后的多元因子列表

多元丢番图方程求解器

求解 s₁·f₁ + s₂·f₂ + ... + sᵣ·fᵣ ≡ target (mod ideal)， 其中 ideal 由 (var - eval_point)^degree_bound 生成。 用于 Hensel 提升过程中计算修正项。

参数

[in]	factors	互素因子列表
[in]	target	目标多项式
[in]	var	变量名
[in]	eval_point	求值点
[in]	degree_bound	次数上界

返回

解多项式列表 [s₁, s₂, ..., sᵣ] 快速路径检测（detail 命名空间）

---

类说明

LMCAS::detail::AffineForm

struct LMCAS::detail::AffineForm

在文件 expression_analysis.hpp 第 37 行定义.

LMCAS::detail::AffineForm 的协作图:

类成员
shared_ptr< SymbolicExpr >	offset
shared_ptr< SymbolicExpr >	slope

LMCAS::detail::BinderView

struct LMCAS::detail::BinderView

在文件 traversal.hpp 第 11 行定义.

LMCAS::detail::BinderView 的协作图:

类成员
string_view	bound_name
vector< SymbolicNodePtr >	outside_scope
SymbolicNodePtr	scoped_body

LMCAS::detail::CheckedInterval

struct LMCAS::detail::CheckedInterval

在文件 interval_endpoint.hpp 第 27 行定义.

LMCAS::detail::CheckedInterval 的协作图:

类成员
Interval	interval
ComparableEndpoint	lower
ComparableEndpoint	upper

LMCAS::detail::ComplexIsolation

struct LMCAS::detail::ComplexIsolation

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

LMCAS::detail::ComplexIsolation 的协作图:

类成员
Rational	imaginary_lower
ExactRealAlgebraic	imaginary_projection
Rational	imaginary_upper
Rational	real_lower
ExactRealAlgebraic	real_projection
Rational	real_upper

LMCAS::detail::EliminationResult

struct LMCAS::detail::EliminationResult

在文件 exact_matrix.hpp 第 44 行定义.

LMCAS::detail::EliminationResult 的协作图:

类成员
ExactMatrixData	matrix
vector< size_t >	pivot_columns
vector< ExprPtr >	pivot_values
size_t	rank = 0
size_t	row_swaps = 0

LMCAS::detail::InconsistentLinearSolution

struct LMCAS::detail::InconsistentLinearSolution

在文件 exact_matrix.hpp 第 93 行定义.

LMCAS::detail::InconsistentLinearSolution 的协作图:

LMCAS::detail::IntegralParts

struct LMCAS::detail::IntegralParts

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

LMCAS::detail::IntegralParts 的协作图:

类成员
SymbolicExpr	primitive
SymbolicExpr	remainder

LMCAS::detail::NumericEvaluationOptions

struct LMCAS::detail::NumericEvaluationOptions

在文件 exact_root.hpp 第 28 行定义.

LMCAS::detail::NumericEvaluationOptions 的协作图:

类成员
double	absolute_tolerance = 1e-12
double	relative_tolerance = 1e-12

LMCAS::detail::ParametricLinearSolution

struct LMCAS::detail::ParametricLinearSolution

在文件 exact_matrix.hpp 第 87 行定义.

LMCAS::detail::ParametricLinearSolution 的协作图:

类成员
vector< size_t >	free_columns
vector< vector< ExprPtr > >	nullspace_basis
vector< ExprPtr >	particular

LMCAS::detail::QuadraticCartesianRoot

struct LMCAS::detail::QuadraticCartesianRoot

在文件 complex_quadratic.hpp 第 10 行定义.

LMCAS::detail::QuadraticCartesianRoot 的协作图:

类成员
shared_ptr< SymbolicExpr >	imag
shared_ptr< SymbolicExpr >	real

LMCAS::detail::RealIsolation

struct LMCAS::detail::RealIsolation

在文件 exact_root.hpp 第 13 行定义.

LMCAS::detail::RealIsolation 的协作图:

类成员
ExactRealAlgebraic	value

LMCAS::detail::UniqueLinearSolution

struct LMCAS::detail::UniqueLinearSolution

在文件 exact_matrix.hpp 第 83 行定义.

LMCAS::detail::UniqueLinearSolution 的协作图:

类成员
vector< ExprPtr >	values

类型定义说明

CartesianQuadraticRoots

using LMCAS::detail::CartesianQuadraticRoots = std::array<QuadraticCartesianRoot, 2>

在文件 complex_quadratic.hpp 第 14 行定义.

ExactConstantInterval

using LMCAS::detail::ExactConstantInterval = std::pair<Rational, Rational>

在文件 exact_constant_bounds.hpp 第 11 行定义.

ExactLinearSolution

using LMCAS::detail::ExactLinearSolution

初始值:

std::variant<
   UniqueLinearSolution,
   ParametricLinearSolution,
   InconsistentLinearSolution>

在文件 exact_matrix.hpp 第 95 行定义.

ExactRealAlgebraicResult

using LMCAS::detail::ExactRealAlgebraicResult = Result<ExactRealAlgebraic>

在文件 exact_algebraic.hpp 第 21 行定义.

Node

using LMCAS::detail::Node = std::shared_ptr<const SymbolicNode>

在文件 facts_query_rational.cpp 第 10 行定义.

RationalInterval

using LMCAS::detail::RationalInterval = std::pair<Rational, Rational>

在文件 exact_sturm.hpp 第 13 行定义.

RootIsolation

using LMCAS::detail::RootIsolation = std::variant<RealIsolation, ComplexIsolation>

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

SymbolicNodePtr

using LMCAS::detail::SymbolicNodePtr = std::shared_ptr<const SymbolicNode>

在文件 base.hpp 第 73 行定义.

枚举类型说明

EliminationForm

enum class LMCAS::detail::EliminationForm

strong

枚举值
Echelon
ReducedRowEchelon

在文件 exact_matrix.hpp 第 39 行定义.

                           {
    Echelon,
    ReducedRowEchelon
};

ZeroProof

enum class LMCAS::detail::ZeroProof

strong

枚举值
Zero
NonZero
Unknown

在文件 exact_matrix.hpp 第 15 行定义.

                     {
    Zero,
    NonZero,
    Unknown
};

函数说明

__attribute__() [1/2]

LMCAS::detail::__attribute__

(

(visibility("default"))

)

const &

检测是否为线性多项式

判断多项式关于主变量的次数是否 ≤ 1，线性多项式直接视为不可约。

参数

[in]	poly	输入多项式
[in]	main_var	主变量名

返回

若关于 main_var 的次数 ≤ 1 则返回 true

引用了 context, detect_binomial_power(), detect_difference_of_squares(), extract_common_monomial(), factor_homogeneous_bivariate(), is_linear(), LMCAS_API , 以及 main_var.

函数调用图:

__attribute__() [2/2]

LMCAS::detail::__attribute__

(

(visibility("default"))

)

引用了 LMCAS_API , 以及 make_exact_real_algebraic().

函数调用图:

adjust_homogeneous_constant()

void LMCAS::detail::adjust_homogeneous_constant ( const MultiPoly & poly, MultiFactorResult & result )

static

在文件 multivariate_factor_patterns.cpp 第 45 行定义.

                                                                   {
    const auto& vars = poly.variables();
    MultiPoly product(Rational(1), vars);
    for (const auto& f : result.factors) {
        product = product * f;
    }
    if (!product.is_zero() && !poly.is_zero()) {
        try {
            MultiPoly ratio = poly.exact_div(product);
            if (ratio.is_constant()) {
                result.constant = ratio.numeric_content();
                if (!ratio.terms().empty() && ratio.terms()[0].second < Rational(0)) {
                    result.constant = -result.constant;
                }
            }
        } catch (const std::runtime_error&) {
            if (!product.terms().empty() && !poly.terms().empty()) {
                result.constant = poly.terms()[0].second / product.terms()[0].second;
            }
        }
    }
}

引用了 adjust_homogeneous_constant(), LMCAS::MultiFactorResult::constant, LMCAS::MultiFactorResult::factors , 以及 LMCAS::vars.

被这些函数引用 adjust_homogeneous_constant() , 以及 factor_homogeneous_bivariate().

函数调用图:

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

all_variable_names()

std::set< std::string > LMCAS::detail::all_variable_names	(	const SymbolicNodePtr &	expression,
		detail::RewriteBudget *	budget = nullptr )

在文件 expression_analysis.cpp 第 306 行定义.

                                                                          {
    if (budget) { budget->measure(expression); }
    return all_names(expression, budget);
}

引用了 budget , 以及 LMCAS::detail::RewriteBudget::measure().

被这些函数引用 LMCAS::append_product_families(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::capture_free_integer_parameter(), LMCAS::solve_product_set() , 以及 LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series().

函数调用图:

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

binder_view()

std::optional< BinderView > LMCAS::detail::binder_view ( const SymbolicNode & node )

inline

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

                                                                     {
    if (const auto* sum = dynamic_cast<const SummationNode*>(&node)) {
        return BinderView{sum->index_var(), sum->body(),
                          {sum->lower_bound(), sum->upper_bound()}};
    }
    if (const auto* product = dynamic_cast<const ProductNode*>(&node)) {
        return BinderView{product->index_var(), product->body(),
                          {product->lower_bound(), product->upper_bound()}};
    }
    if (const auto* integral = dynamic_cast<const IntegralNode*>(&node)) {
        std::vector<SymbolicNodePtr> bounds;
        if (integral->lower()) bounds.push_back(integral->lower());
        if (integral->upper()) bounds.push_back(integral->upper());
        return BinderView{integral->variable(), integral->body(), std::move(bounds)};
    }
    if (const auto* transform = dynamic_cast<const TransformNode*>(&node)) {
        return BinderView{transform->source_var(), transform->body(),
                          {transform->target()}};
    }
    if (const auto* quantifier = dynamic_cast<const QuantifierNode*>(&node)) {
        return BinderView{quantifier->bound_var(), quantifier->predicate(),
                          {quantifier->domain()}};
    }
    if (const auto* set_builder = dynamic_cast<const SetBuilderNode*>(&node)) {
        return BinderView{set_builder->element_var(), set_builder->predicate(),
                          {set_builder->domain()}};
    }
    if (const auto* limit = dynamic_cast<const LimitNode*>(&node)) {
        return BinderView{limit->variable(), limit->body(), {limit->point()}};
    }
    return std::nullopt;
}

引用了 binder_view() , 以及 node().

被这些函数引用 binder_view(), LMCAS::NormalizationVisitor::normalize_bound_body(), LMCAS::anonymous_namespace{complex_analysis.cpp}::FunctionDependencyFinder::visit_binder(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeVariableCollector::visit_binder() , 以及 LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeVariableFinder::visit_binder().

函数调用图:

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

checked_transform_expr()

template<typename Transform>

ExpressionResult LMCAS::detail::checked_transform_expr	(	const ExprPtr &	expression,
		ComputationContext &	context,
		const char *	operation,
		const char *	transform_name,
		Transform &&	transform )

在文件 expression_transform.hpp 第 30 行定义.

                                                               {
    auto step = context.consume_steps(1, operation);
    if (!step) return ExpressionResult::failure(step.error());
    if (!expression || !LMCAS::detail::node(expression)) {
        return ExpressionResult::failure(CasErrc::InvalidArgument,
                                         std::string(transform_name) +
                                             " argument cannot be null",
                                         operation);
    }
    try {
        auto result = std::forward<Transform>(transform)(*expression);
        if (!result || !LMCAS::detail::node(result)) {
            return ExpressionResult::failure(CasErrc::InternalInvariant,
                                             std::string(transform_name) +
                                                 " returned null",
                                             operation);
        }
        return ExpressionResult::success(std::move(result));
    } catch (const CasError& error) {
        return ExpressionResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                         std::string(transform_name) +
                                             " allocation failed",
                                         operation);
    } catch (const std::length_error& error) {
        return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(),
                                         operation);
    } catch (const std::exception& error) {
        return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(),
                                         operation);
    }
}

引用了 checked_transform_expr(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, node(), operation, LMCAS::ResourceLimit , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::checked_derivative() , 以及 checked_transform_expr().

函数调用图:

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

classify_exact_zero()

Result< ZeroProof > LMCAS::detail::classify_exact_zero	(	const ExprPtr &	expression,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix_support.cpp 第 168 行定义.

                                {
    auto access = context.consume_steps(1, operation);
    if (!access) {
        return Result<ZeroProof>::failure(access.error());
    }
    if (!expression || !node(expression)) {
        return Result<ZeroProof>::failure(
            CasErrc::InvalidArgument,
            "zero classification requires an expression", operation);
    }
    try {
        auto simplified = simplify_expr(expression, context);
        if (auto proof = classify_numeric_value(simplified)) {
            return Result<ZeroProof>::success(*proof);
        }
        if (!context.assumptions()) {
            return Result<ZeroProof>::success(ZeroProof::Unknown);
        }
        auto assumption = context.assumptions()->is_nonzero_checked(*simplified, context);
        if (!assumption) {
            return Result<ZeroProof>::failure(assumption.error());
        }
        if (assumption.value() == Tribool::True) {
            return Result<ZeroProof>::success(ZeroProof::NonZero);
        }
        if (assumption.value() == Tribool::False) {
            return Result<ZeroProof>::success(ZeroProof::Zero);
        }
        return Result<ZeroProof>::success(ZeroProof::Unknown);
    } catch (const CasError& error) {
        return Result<ZeroProof>::failure(error);
    } catch (const std::length_error& error) {
        return Result<ZeroProof>::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::bad_alloc&) {
        return Result<ZeroProof>::failure(
            CasErrc::ResourceLimit,
            "zero classification allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<ZeroProof>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 classify_exact_zero(), context, LMCAS::Result< T >::failure(), LMCAS::False, LMCAS::InternalInvariant, LMCAS::InvalidArgument, node(), NonZero, operation, LMCAS::ResourceLimit, LMCAS::detail::matrix_kernel::simplify_expr(), LMCAS::Result< T >::success(), LMCAS::True, Unknown , 以及 Zero.

被这些函数引用 LMCAS::detail::matrix_kernel::choose_pivot(), classify_exact_zero(), LMCAS::anonymous_namespace{residual_verification.cpp}::classify_residual(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_already_collected(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::eliminate_below(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::inconsistent_symbolic_system(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::reduce_above(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::symbolic_quadratic_sign() , 以及 LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_identity().

函数调用图:

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

classify_quadric_impl()

VectorStringResult LMCAS::detail::classify_quadric_impl	(	const SurfaceSymbolic &	surf,
		ComputationContext &	context,
		const std::string &	operation )

在文件 symbolic_quadric_classification.cpp 第 532 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const auto& vars = surf.vars;
    auto expanded = detail::make_expression_ptr(detail::expand_node(detail::node(surf.F), transform_budget));
    if (!expanded || !node(expanded)) expanded = surf.F;
 
    double quadratic_matrix[3][3] = {};
    double linear_coefficients[3];
    CasError error;
    if (!extract_axis_coefficients(
            expanded, vars, context, operation, quadratic_matrix,
            linear_coefficients, error)) {
        return VectorStringResult::failure(std::move(error));
    }
    if (!extract_mixed_coefficients(
            expanded, vars, context, operation, quadratic_matrix, error)) {
        return VectorStringResult::failure(std::move(error));
    }
 
    const SymmetricEigen3 principal =
        diagonalize_symmetric_3x3(quadratic_matrix);
    if (principal.coefficient_scale == 0.0) {
        return VectorStringResult::failure(
            CasErrc::Inconclusive,
            "quadric has no nonzero quadratic part",
            operation);
    }
    if (principal.unresolved_rank) {
        return VectorStringResult::failure(
            CasErrc::Inconclusive,
            "quadric rank is unresolved within the eigensolver error bound",
            operation);
    }
 
    double linear[3] = {0.0, 0.0, 0.0};
    double linear_tolerance[3];
    if (!project_linear_coefficients(
            principal, linear_coefficients, linear, linear_tolerance,
            operation, error)) {
        return VectorStringResult::failure(std::move(error));
    }
    const int rank =
        (principal.values[0] != 0.0) +
        (principal.values[1] != 0.0) +
        (principal.values[2] != 0.0);
 
    if (rank == 1) {
        if (has_null_axis_linear_term(principal, linear, linear_tolerance)) {
            return VectorStringResult::success("cylinder");
        }
        return VectorStringResult::failure(
            CasErrc::Inconclusive,
            "rank-one quadric is degenerate or has no real locus",
            operation);
    }
    if (rank == 2 &&
        has_null_axis_linear_term(principal, linear, linear_tolerance)) {
        return VectorStringResult::success("paraboloid");
    }
    return classify_translated_quadric(
        principal, rank, linear, expanded, vars, context, operation);
} catch (const CasError& error) {
    return VectorStringResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorStringResult::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return VectorStringResult::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return VectorStringResult::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 classify_quadric_impl(), context, expand_node(), LMCAS::SurfaceSymbolic::F, LMCAS::Result< std::string >::failure(), LMCAS::Inconclusive, make_expression_ptr(), node(), operation, LMCAS::Result< std::string >::success(), LMCAS::SurfaceSymbolic::vars , 以及 LMCAS::vars.

被这些函数引用 LMCAS::classify_quadric_checked() , 以及 classify_quadric_impl().

函数调用图:

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

closed_rational_value() [1/2]

std::optional< Rational > LMCAS::detail::closed_rational_value	(	const Node &	node,
		Domain	domain,
		ComputationContext &	context )

引用了 closed_rational_value(), context, domain , 以及 node().

函数调用图:

closed_rational_value() [2/2]

std::optional< Rational > LMCAS::detail::closed_rational_value	(	const std::shared_ptr< const SymbolicNode > &	node,
		Domain	domain,
		ComputationContext &	context )

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

                                                                                               {
    ExactBoundArithmetic arithmetic(context, "facts.constant_exponent");
    arithmetic.require(context.enter_recursion("facts.constant_exponent"));
    struct Leave {
        ComputationContext& context;
        ~Leave() { context.leave_recursion(); }
    } leave{context};
    if (const auto* number = dynamic_cast<const NumberNode*>(node.get())) {
        auto value = exact_number_as_rational(*number);
        arithmetic.bits(std::max(value.get_numerator().bit_length(),
                                 value.get_denominator().bit_length()));
        return value;
    }
    const auto* sum = dynamic_cast<const AddNode*>(node.get());
    const auto* product = dynamic_cast<const MultiplyNode*>(node.get());
    if (sum || product) {
        Rational value(product ? 1 : 0);
        for (const auto& operand : sum ? sum->operands() : product->operands()) {
            auto child = closed_rational_value(operand, domain, context);
            if (!child) { return std::nullopt; }
            value = product ? arithmetic.mul(value, *child) : arithmetic.add(value, *child);
        }
        return value;
    }
    const auto* power = dynamic_cast<const PowerNode*>(node.get());
    if (!power) { return std::nullopt; }
    return closed_rational_power(*power, domain, context, arithmetic);
}

引用了 LMCAS::detail::ExactBoundArithmetic::add(), LMCAS::detail::ExactBoundArithmetic::bits(), closed_rational_value(), context, domain, LMCAS::exact_number_as_rational(), LMCAS::detail::ExactBoundArithmetic::mul(), node(), LMCAS::detail::ExactBoundArithmetic::require() , 以及 LMCAS::value.

被这些函数引用 LMCAS::detail::anonymous_namespace{facts_query_rational.cpp}::closed_rational_power(), closed_rational_value(), closed_rational_value() , 以及 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::power().

函数调用图:

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

comparable_endpoint()

Result< ComparableEndpoint > LMCAS::detail::comparable_endpoint	(	const Endpoint &	endpoint,
		ComputationContext &	context,
		const std::string &	operation )

在文件 interval_endpoint.cpp 第 310 行定义.

                                {
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return Result<ComparableEndpoint>::failure(step.error());
    }
 
    if (endpoint.is_neg_infinity && endpoint.is_pos_infinity) {
        return Result<ComparableEndpoint>::failure(
            CasErrc::InvalidArgument,
            "an endpoint cannot be both negative and positive infinity",
            operation);
    }
    if (endpoint.is_neg_infinity || endpoint.is_pos_infinity) {
        if (endpoint.value) {
            return Result<ComparableEndpoint>::failure(
                CasErrc::InvalidArgument,
                "infinite endpoints cannot also contain a finite value",
                operation);
        }
        if (!endpoint.is_open) {
            return Result<ComparableEndpoint>::failure(
                CasErrc::InvalidArgument,
                "infinite interval endpoints must be open",
                operation);
        }
        return Result<ComparableEndpoint>::success(
            ComparableEndpoint{endpoint.is_neg_infinity ? -1 : 1,
                               Rational(0), Rational(0), Rational(0)});
    }
    return comparable_finite_endpoint(endpoint, context, operation);
}

引用了 comparable_endpoint(), context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, operation , 以及 LMCAS::Result< T >::success().

被这些函数引用 comparable_endpoint(), LMCAS::InferenceEngine::Impl::logarithm_monotonicity(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_endpoint_bound() , 以及 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds().

函数调用图:

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

compare_comparable()

Result< int > LMCAS::detail::compare_comparable	(	const ComparableEndpoint &	left,
		const ComparableEndpoint &	right,
		ComputationContext &	context )

在文件 interval_endpoint_order.cpp 第 71 行定义.

                                                            {
    if (left.infinity < right.infinity) {
        return Result<int>::success(-1);
    }
    if (left.infinity > right.infinity) {
        return Result<int>::success(1);
    }
    if (left.infinity != 0) {
        return Result<int>::success(0);
    }
 
    const bool left_radical =
        left.radical_coefficient != Rational(0) || left.algebraic.has_value();
    const bool right_radical =
        right.radical_coefficient != Rational(0) || right.algebraic.has_value();
    if (!left_radical && !right_radical) {
        return Result<int>::success(compare_rationals(left.rational, right.rational));
    }
    if (left.algebraic && !right_radical) {
        return Result<int>::success(
            compare_algebraic_to_rational(*left.algebraic, right.rational));
    }
    if (right.algebraic && !left_radical) {
        return Result<int>::success(
            -compare_algebraic_to_rational(*right.algebraic, left.rational));
    }
    auto left_algebraic = to_algebraic(left, context);
    if (!left_algebraic) {
        return Result<int>::failure(left_algebraic.error());
    }
    auto right_algebraic = to_algebraic(right, context);
    if (!right_algebraic) {
        return Result<int>::failure(right_algebraic.error());
    }
    return LMCAS::detail::compare_exact_real_algebraic(
        left_algebraic.value(), right_algebraic.value(), context);
}

引用了 LMCAS::detail::ComparableEndpoint::algebraic, compare_comparable(), compare_exact_real_algebraic(), context, LMCAS::Result< T >::failure(), LMCAS::detail::ComparableEndpoint::infinity, LMCAS::detail::ComparableEndpoint::radical_coefficient, LMCAS::detail::ComparableEndpoint::rational, LMCAS::right , 以及 LMCAS::Result< T >::success().

被这些函数引用 compare_comparable(), LMCAS::InferenceEngine::Impl::logarithm_monotonicity(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_endpoint_bound() , 以及 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds().

函数调用图:

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

compare_exact_real_algebraic()

Result< int > LMCAS::detail::compare_exact_real_algebraic	(	ExactRealAlgebraic	lhs,
		ExactRealAlgebraic	rhs,
		ComputationContext &	context )

在文件 exact_algebraic.cpp 第 206 行定义.

                                 {
    auto equal = equal_exact_real_algebraic(lhs, rhs, context);
    if (!equal) {
        return Result<int>::failure(equal.error());
    }
    if (equal.value()) {
        return Result<int>::success(0);
    }
 
    while (true) {
        if (lhs.upper < rhs.lower) {
            return Result<int>::success(-1);
        }
        if (rhs.upper < lhs.lower) {
            return Result<int>::success(1);
        }
        const double lhs_width = (lhs.upper - lhs.lower).to_double();
        const double rhs_width = (rhs.upper - rhs.lower).to_double();
        const double width = std::max(lhs_width, rhs_width);
        if (!(width > 0.0) || !std::isfinite(width)) {
            return Result<int>::failure(
                CasErrc::InternalInvariant,
                "distinct algebraic values retained an inseparable enclosure",
                "exact_algebraic.compare");
        }
        if (lhs_width > 0.0) {
            auto refined = refine_exact_real_algebraic_to_tolerance(
                lhs, width / 16.0, 1e-15, context,
                "exact_algebraic.compare");
            if (!refined) {
                return Result<int>::failure(refined.error());
            }
        }
        if (rhs_width > 0.0) {
            auto refined = refine_exact_real_algebraic_to_tolerance(
                rhs, width / 16.0, 1e-15, context,
                "exact_algebraic.compare");
            if (!refined) {
                return Result<int>::failure(refined.error());
            }
        }
    }
}

引用了 compare_exact_real_algebraic(), context, LMCAS::e(), equal_exact_real_algebraic(), LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::detail::ExactRealAlgebraic::lower, refine_exact_real_algebraic_to_tolerance(), rhs, LMCAS::Result< T >::success() , 以及 LMCAS::detail::ExactRealAlgebraic::upper.

被这些函数引用 LMCAS::detail::definite::compare_boundaries(), compare_comparable(), compare_exact_real_algebraic(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::compare_isolations() , 以及 LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::sort_exact_inequality_roots().

函数调用图:

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

compare_pointwise_values()

Result< Tribool > LMCAS::detail::compare_pointwise_values	(	const ExprPtr &	left,
		const ExprPtr &	right,
		ComputationContext &	context,
		Domain	domain )

在给定假设的 Real 或 Complex 域内比较逐点值，并保留错误。 True/False 分别证明值处处有定义且相等/不等；定义性未证实也归为 Unknown， 仅有非恒等残差不足以判定 False。

在文件 residual_comparison.cpp 第 126 行定义.

                                                {
    constexpr const char* operation = "residual.compare_values";
    auto access = context.consume_steps(1, operation);
    if (!access) {
        return Result<Tribool>::failure(access.error());
    }
    if (!left || !right || !detail::node(left) || !detail::node(right)) {
        return Result<Tribool>::failure(
            CasErrc::InvalidArgument,
            "value comparison requires two expressions", operation);
    }
    try {
        std::optional<detail::AssumptionFacts> assumed;
        if (context.assumptions()) {
            assumed.emplace(*context.assumptions());
        }
        const auto& facts = assumed
            ? static_cast<const FactsQuery&>(*assumed)
            : detail::no_facts();
        auto defined = pointwise_values_defined(
            left, right, facts, domain, context);
        if (!defined) {
            return Result<Tribool>::failure(defined.error());
        }
        if (!defined.value()) {
            return Tribool::Unknown;
        }
        return compare_defined_values(
            left, right, facts, context, domain);
    } catch (const CasError& error) {
        return Result<Tribool>::failure(error);
    } catch (const std::bad_alloc&) {
        return Result<Tribool>::failure(
            CasErrc::ResourceLimit,
            "value comparison allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<Tribool>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 context, domain, facts, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, no_facts(), node(), operation, LMCAS::ResourceLimit, LMCAS::right , 以及 LMCAS::Unknown.

被这些函数引用 LMCAS::anonymous_namespace{calculus_continuity.cpp}::classify_continuity_point_value(), LMCAS::anonymous_namespace{limit_result.cpp}::combine_one_sided_limits() , 以及 LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_from_limits().

函数调用图:

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

constant_expression()

ExpressionResult LMCAS::detail::constant_expression

(

const char *

name

)

在文件 symbolic_construction.cpp 第 30 行定义.

                                                             {
    constexpr const char* operation = "LMCAS.constant";
    try {
        auto expression = LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<VariableNode>(name, true));
        if (!expression || !LMCAS::detail::node(expression)) {
            return ExpressionResult::failure(CasErrc::InternalInvariant,
                                             "constant factory returned null",
                                             operation);
        }
        return ExpressionResult::success(std::move(expression));
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                         "constant allocation failed",
                                         operation);
    } catch (const std::exception& error) {
        return ExpressionResult::failure(CasErrc::InvalidArgument, error.what(),
                                         operation);
    }
}

引用了 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, make_expression_ptr(), make_node(), LMCAS::name, node(), operation, LMCAS::ResourceLimit , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 LMCAS::e(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::phi() , 以及 LMCAS::pi().

函数调用图:

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

consume_decimal_digits()

bool LMCAS::detail::consume_decimal_digits ( std::string_view token, std::size_t & pos )

inlinenoexcept

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

                                                                                  {
    const auto start = pos;
    while (pos < token.size() && token[pos] >= '0' && token[pos] <= '9') {
        ++pos;
    }
    return pos != start;
}

引用了 consume_decimal_digits().

被这些函数引用 consume_decimal_digits(), consume_decimal_exponent() , 以及 consume_decimal_mantissa().

函数调用图:

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

consume_decimal_exponent()

bool LMCAS::detail::consume_decimal_exponent ( std::string_view token, std::size_t & pos )

inlinenoexcept

在文件 numeric_literal.hpp 第 40 行定义.

                                                                                    {
    if (pos < token.size() && (token[pos] == 'e' || token[pos] == 'E')) {
        ++pos;
        consume_decimal_sign(token, pos);
        return consume_decimal_digits(token, pos);
    }
    return true;
}

引用了 consume_decimal_digits(), consume_decimal_exponent() , 以及 consume_decimal_sign().

被这些函数引用 consume_decimal_exponent() , 以及 is_signed_decimal_token().

函数调用图:

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

consume_decimal_mantissa()

bool LMCAS::detail::consume_decimal_mantissa ( std::string_view token, std::size_t & pos )

inlinenoexcept

在文件 numeric_literal.hpp 第 25 行定义.

                                                                                    {
    bool has_digits = consume_decimal_digits(token, pos);
    if (pos < token.size() && token[pos] == '.') {
        ++pos;
        has_digits = consume_decimal_digits(token, pos) || has_digits;
    }
    return has_digits;
}

引用了 consume_decimal_digits() , 以及 consume_decimal_mantissa().

被这些函数引用 consume_decimal_mantissa() , 以及 is_signed_decimal_token().

函数调用图:

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

consume_decimal_sign()

void LMCAS::detail::consume_decimal_sign ( std::string_view token, std::size_t & pos )

inlinenoexcept

在文件 numeric_literal.hpp 第 34 行定义.

                                                                                {
    if (pos < token.size() && (token[pos] == '+' || token[pos] == '-')) {
        ++pos;
    }
}

引用了 consume_decimal_sign().

被这些函数引用 consume_decimal_exponent(), consume_decimal_sign() , 以及 is_signed_decimal_token().

函数调用图:

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

consume_mixed_step()

bool LMCAS::detail::consume_mixed_step	(	ComputationContext &	context,
		std::optional< CasError > *	failure,
		bool *	complete )

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

                    {
    auto step = context.consume_steps(1, "solve_mixed_transcendental_checked");
    if (step) { return true; }
    if (failure) { *failure = step.error(); }
    if (complete) { *complete = false; }
    return false;
}

引用了 consume_mixed_step(), context , 以及 LMCAS::Result< T >::error().

被这些函数引用 LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::bisect(), consume_mixed_step(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::initialize(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::newton() , 以及 LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::run().

函数调用图:

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

contains_node_type()

template<class Node>

bool LMCAS::detail::contains_node_type

(

const SymbolicNodePtr &

root

)

在文件 traversal.hpp 第 159 行定义.

                                                     {
    if (!root) return false;
    NodeTypeDetector<Node> detector;
    root->accept(detector);
    return detector.found();
}

引用了 contains_node_type() , 以及 LMCAS::detail::NodeTypeDetector< Node >::found().

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::apply_root_representation_policy(), LMCAS::asymptote_candidates(), LMCAS::calculus_utils_extract_real_candidate(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_limit_result(), contains_node_type(), LMCAS::contains_unevaluated_integral() , 以及 LMCAS::transform_detail::te_contains_transform().

函数调用图:

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

count_real_roots_exact()

Result< std::size_t > LMCAS::detail::count_real_roots_exact	(	const Polynomial< Rational > &	polynomial,
		const Rational &	lower,
		const Rational &	upper,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_sturm.cpp 第 242 行定义.

                                {
    if (upper < lower) {
        return Result<std::size_t>::failure(
            CasErrc::InvalidArgument,
            "real-root interval bounds must be ordered",
            operation);
    }
    try {
        auto step = context.consume_steps(1, operation);
        if (!step) return Result<std::size_t>::failure(step.error());
        if (polynomial.degree() <= 0) {
            return Result<std::size_t>::success(0);
        }
        auto square_free = polynomial.square_free_part().make_monic();
        if (lower == upper) {
            return Result<std::size_t>::success(
                polynomial_sign_at(square_free, lower) == 0 ? 1U : 0U);
        }
        auto sequence = make_sturm_sequence(square_free, context, operation);
        if (!sequence) return Result<std::size_t>::failure(sequence.error());
        auto interior = count_open_roots(
            square_free, sequence.value(), lower, upper, context, operation);
        if (!interior) return interior;
        std::size_t count = interior.value();
        if (polynomial_sign_at(square_free, lower) == 0) ++count;
        if (polynomial_sign_at(square_free, upper) == 0) ++count;
        return Result<std::size_t>::success(count);
    } catch (const std::bad_alloc&) {
        return Result<std::size_t>::failure(
            CasErrc::ResourceLimit,
            "Sturm root counting allocation failed",
            operation);
    } catch (const std::exception& error) {
        return Result<std::size_t>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 context, count_real_roots_exact(), LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, LMCAS::lower, LMCAS::Polynomial< CoeffType >::make_monic(), operation, LMCAS::ResourceLimit, LMCAS::Polynomial< CoeffType >::square_free_part(), LMCAS::Result< T >::success() , 以及 LMCAS::upper.

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::certify_dyadic_candidate(), count_real_roots_exact(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::edge_is_clear(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::left_pole_sample(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::pole_interval_is_clear() , 以及 LMCAS::detail::definite::polynomial_at_root_sign().

函数调用图:

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

detect_binomial_power()

std::optional< std::tuple< std::string, std::string, int > > LMCAS::detail::detect_binomial_power

(

const MultiPoly &

poly

)

检测二项式幂模式 xⁿ - yⁿ

判断多项式是否为两个不同变量的纯幂之差,系数分别为 +1 和 -1, 且幂次相同.若匹配,返回 (变量1, 变量2, 幂次).

参数

[in]

poly

输入多项式

返回

若匹配则返回 (var1, var2, n),否则返回 nullopt

确定正项和负项

检查每项的单项式是否为单变量的纯幂(恰好一个非零指数)

幂次必须相同,变量必须不同

在文件 multivariate_factor_patterns.cpp 第 159 行定义.

{
    if (poly.num_terms() != 2) { return std::nullopt; }
 
    const auto& terms = poly.terms();
    const auto& vars = poly.variables();
 
    /// 确定正项和负项
    int pos_idx = -1, neg_idx = -1;
    if (terms[0].second == Rational(1) && terms[1].second == Rational(-1)) {
        pos_idx = 0; neg_idx = 1;
    } else if (terms[1].second == Rational(1) && terms[0].second == Rational(-1)) {
        pos_idx = 1; neg_idx = 0;
    } else {
        return std::nullopt;
    }
 
    /// 检查每项的单项式是否为单变量的纯幂(恰好一个非零指数)
    auto get_single_var_power = [&](const Monomial& mono)
        -> std::optional<std::pair<int, int>> {
        int nonzero_count = 0;
        int var_index = -1;
        int exponent = 0;
        for (size_t i = 0; i < mono.size(); ++i) {
            if (mono[i] != 0) {
                nonzero_count++;
                var_index = static_cast<int>(i);
                exponent = mono[i];
            }
        }
        if (nonzero_count != 1 || exponent <= 1) { return std::nullopt; }
        return std::make_pair(var_index, exponent);
    };
 
    auto pos_info = get_single_var_power(terms[pos_idx].first);
    if (!pos_info) { return std::nullopt; }
    auto neg_info = get_single_var_power(terms[neg_idx].first);
    if (!neg_info) { return std::nullopt; }
 
    auto [pos_var_idx, pos_exp] = *pos_info;
    auto [neg_var_idx, neg_exp] = *neg_info;
 
    /// 幂次必须相同,变量必须不同
    if (pos_exp != neg_exp) { return std::nullopt; }
    if (pos_var_idx == neg_var_idx) { return std::nullopt; }
 
    return std::make_tuple(vars[pos_var_idx], vars[neg_var_idx], pos_exp);
}

引用了 detect_binomial_power(), LMCAS::exponent , 以及 LMCAS::vars.

被这些函数引用 __attribute__(), detect_binomial_power() , 以及 LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl().

函数调用图:

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

detect_difference_of_squares()

std::optional< std::pair< MultiPoly, MultiPoly > > LMCAS::detail::detect_difference_of_squares

(

const MultiPoly &

poly

)

检测差平方模式 a^2 - b^2

判断多项式是否恰好有两项,一正一负,且两项的单项式各分量指数均为偶数. 若匹配,返回 (a, b),其中 a^2 为正项,b^2 为负项.

参数

[in]

poly

输入多项式

返回

若匹配则返回 (a, b),否则返回 nullopt

确定哪项为正,哪项为负

检查系数绝对值相等(都应为完全平方的系数) 对于差平方 a^2 - b^2,正项系数和负项系数的绝对值不必相等 但两项的系数本身必须是完全平方数

检查系数是否为完全平方有理数 分子和分母都必须是完全平方数

检查两项的单项式各分量指数均为偶数

构造 a:正项单项式指数减半,系数为 sqrt(pos_coeff)

构造 b:负项单项式指数减半,系数为 sqrt(neg_coeff)

在文件 multivariate_factor_patterns.cpp 第 87 行定义.

{
    if (poly.num_terms() != 2) { return std::nullopt; }
 
    const auto& terms = poly.terms();
    const auto& vars = poly.variables();
 
    /// 确定哪项为正,哪项为负
    int pos_idx = -1, neg_idx = -1;
    if (terms[0].second > Rational(0) && terms[1].second < Rational(0)) {
        pos_idx = 0; neg_idx = 1;
    } else if (terms[1].second > Rational(0) && terms[0].second < Rational(0)) {
        pos_idx = 1; neg_idx = 0;
    } else {
        return std::nullopt;
    }
 
    /// 检查系数绝对值相等(都应为完全平方的系数)
    /// 对于差平方 a^2 - b^2,正项系数和负项系数的绝对值不必相等
    /// 但两项的系数本身必须是完全平方数
    Rational pos_coeff = terms[pos_idx].second;
    Rational neg_coeff = -terms[neg_idx].second; // 取绝对值
 
    /// 检查系数是否为完全平方有理数
    /// 分子和分母都必须是完全平方数
    auto positive_root = rational_square_root(pos_coeff);
    if (!positive_root) { return std::nullopt; }
    auto negative_root = rational_square_root(neg_coeff);
    if (!negative_root) { return std::nullopt; }
 
    /// 检查两项的单项式各分量指数均为偶数
    const Monomial& pos_mono = terms[pos_idx].first;
    const Monomial& neg_mono = terms[neg_idx].first;
 
    for (size_t i = 0; i < pos_mono.size(); ++i) {
        if (pos_mono[i] % 2 != 0) { return std::nullopt; }
    }
    for (size_t i = 0; i < neg_mono.size(); ++i) {
        if (neg_mono[i] % 2 != 0) { return std::nullopt; }
    }
 
    /// 构造 a:正项单项式指数减半,系数为 sqrt(pos_coeff)
    Monomial a_mono(vars.size(), 0);
    for (size_t i = 0; i < pos_mono.size(); ++i) {
        a_mono[i] = pos_mono[i] / 2;
    }
    const Rational& a_coeff = *positive_root;
    std::vector<MultiPoly::Term> a_terms = {{a_mono, a_coeff}};
    MultiPoly a(std::move(a_terms), vars);
 
    /// 构造 b:负项单项式指数减半,系数为 sqrt(neg_coeff)
    Monomial b_mono(vars.size(), 0);
    for (size_t i = 0; i < neg_mono.size(); ++i) {
        b_mono[i] = neg_mono[i] / 2;
    }
    const Rational& b_coeff = *negative_root;
    std::vector<MultiPoly::Term> b_terms = {{b_mono, b_coeff}};
    MultiPoly b(std::move(b_terms), vars);
 
    return std::make_pair(a, b);
}

引用了 LMCAS::a, LMCAS::b, detect_difference_of_squares(), rational_square_root() , 以及 LMCAS::vars.

被这些函数引用 __attribute__(), detect_difference_of_squares() , 以及 LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl().

函数调用图:

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

determinant_exact()

Result< ExprPtr > LMCAS::detail::determinant_exact	(	const ExactMatrixData &	input,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix_determinant.cpp 第 115 行定义.

                                {
    auto valid = validate_matrix(input, operation);
    if (!valid) return Result<ExprPtr>::failure(valid.error());
    if (input.rows != input.cols) {
        return Result<ExprPtr>::failure(
            CasErrc::InvalidArgument,
            "determinant requires a square matrix", operation);
    }
    bool all_rational = true;
    for (const auto& entry : input.entries) {
        all_rational = all_rational && exact_rational(entry).has_value();
    }
    if (all_rational) return rational_determinant(input, context, operation);
 
    try {
        return symbolic_determinant_value(input, context, operation);
    } catch (const std::bad_alloc&) {
        return Result<ExprPtr>::failure(
            CasErrc::ResourceLimit,
            "exact determinant allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<ExprPtr>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 LMCAS::detail::ExactMatrixData::cols, context, determinant_exact(), LMCAS::detail::ExactMatrixData::entries, LMCAS::detail::matrix_kernel::exact_rational(), LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, operation, LMCAS::ResourceLimit, LMCAS::detail::ExactMatrixData::rows , 以及 LMCAS::detail::matrix_kernel::validate_matrix().

被这些函数引用 determinant_exact() , 以及 LMCAS::matrix_determinant_checked().

函数调用图:

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

differentiate_expression()

ExpressionResult LMCAS::detail::differentiate_expression	(	const ExprPtr &	expression,
		const std::string &	variable,
		ComputationContext &	context )

在文件 assumption_simplification.cpp 第 48 行定义.

                                                                       {
    return assumed_transform(expression, context, "LMCAS.differentiate", "differentiate",
        [&](const SymbolicNodePtr& value, RewriteBudget& budget, const FactsQuery& facts) {
            return differentiate_node(value, variable, budget, facts);
        });
}

引用了 budget, context, differentiate_expression(), differentiate_node(), facts, LMCAS::value , 以及 variable.

被这些函数引用 LMCAS::differentiate() , 以及 differentiate_expression().

函数调用图:

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

differentiate_node()

SymbolicNodePtr LMCAS::detail::differentiate_node	(	const SymbolicNodePtr &	node,
		const std::string &	variable,
		RewriteBudget &	budget,
		const FactsQuery &	facts,
		Domain	domain )

在文件 symbolic_core.cpp 第 233 行定义.

                                                                           {
    budget.consume();
    if (!node || variable.empty()) {
        throw CasError{CasErrc::InvalidArgument, "invalid differentiation argument",
                       "LMCAS.differentiate"};
    }
    budget.measure(node);
    DifferentiationVisitor visitor(variable, budget);
    node->accept(visitor);
    return normalize_node(visitor.get_result(), budget, facts, domain);
}

引用了 budget, LMCAS::detail::RewriteBudget::consume(), differentiate_node(), domain, facts, LMCAS::DifferentiationVisitor::get_result(), LMCAS::InvalidArgument, LMCAS::detail::RewriteBudget::measure(), node(), normalize_node() , 以及 variable.

被这些函数引用 LMCAS::calculate_residue_impl(), LMCAS::cauchy_integral_impl(), LMCAS::checked_derivative(), LMCAS::christoffel_first_kind_impl(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), LMCAS::vector_calculus_detail::curl_impl(), LMCAS::curve_integral_scalar(), LMCAS::curve_integral_vector(), LMCAS::differential(), differentiate_expression(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::differentiate_geometry_checked(), LMCAS::differentiate_if_dependent(), differentiate_node(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::differentiate_surface_checked(), LMCAS::vector_calculus_detail::divergence_impl(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_term(), LMCAS::extract_coefficient(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_mixed_coefficients(), LMCAS::find_extrema_impl(), LMCAS::find_integrating_factor_impl(), LMCAS::vector_calculus_detail::gradient_impl(), LMCAS::greens_theorem(), LMCAS::vector_calculus_detail::hessian_impl(), LMCAS::implicit_diff(), LMCAS::inverse_branch_derivative(), LMCAS::is_exact_ode(), LMCAS::is_linear_first_order(), LMCAS::isolate_linear_coeff(), LMCAS::vector_calculus_detail::jacobian_impl(), LMCAS::vector_calculus_detail::laplacian_impl(), LMCAS::laurent_series_full_impl(), LMCAS::lie_derivative_impl(), LMCAS::log_differentiate(), mixed_numerical_path(), LMCAS::ordinary_taylor_coefficients(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::quadratic_coefficients(), LMCAS::riemann_curvature_tensor_with_inverse(), LMCAS::singular_taylor_coefficients(), LMCAS::solve_exact_ode_impl(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_initial_guess(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial(), LMCAS::solve_variation_of_parameters_core(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitute_candidate(), LMCAS::surface_area_revolution_x_checked(), LMCAS::surface_area_revolution_y_checked(), LMCAS::total_differential(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict(), LMCAS::vector_calculus_single_dir_deriv() , 以及 LMCAS::zt_polynomial().

函数调用图:

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

domain_constraints() [1/2]

Result< std::optional< std::vector< std::shared_ptr< SymbolicExpr > > > > LMCAS::detail::domain_constraints	(	const Node &	node,
		const FactsQuery &	facts,
		Domain	domain,
		ComputationContext &	context )

在文件 facts_query.cpp 第 721 行定义.

                                                                                           {
    using Output = std::optional<std::vector<std::shared_ptr<SymbolicExpr>>>;
    if (domain != Domain::Real && domain != Domain::Complex) {
        return Result<Output>::failure(CasErrc::InvalidArgument,
            "value domain must be Real or Complex", "facts.domain");
    }
    try {
        DomainTraversal traversal(facts, domain, context, true);
        auto result = traversal.walk(node);
        if (traversal.error) return Result<Output>::failure(*traversal.error);
        if (result.defined == T::False) {
            if (domain == Domain::Real && !traversal.violated_real_restriction) {
                auto complex_defined = query_definedness(node, facts, Domain::Complex, context);
                if (!complex_defined) return Result<Output>::failure(complex_defined.error());
                if (complex_defined.value() != T::False) {
                    auto real_value = query_real_value(node, facts, context);
                    if (!real_value) return Result<Output>::failure(real_value.error());
                    if (real_value.value() == T::Unknown) return Output{};
                }
            }
            auto impossible = traversal.false_condition();
            if (traversal.error) return Result<Output>::failure(*traversal.error);
            traversal.conditions.clear();
            traversal.conditions.push_back(make_expression_ptr(std::move(impossible)));
        } else if (!traversal.expressible) {
            return Output{};
        }
        return Output{std::move(traversal.conditions)};
    } catch (const CasError& error) {
        return Result<Output>::failure(error);
    } catch (const std::bad_alloc&) {
        return Result<Output>::failure(CasErrc::ResourceLimit,
                                      "domain projection allocation failed", "facts.domain");
    }
}

引用了 LMCAS::Complex, context, domain, domain_constraints(), facts, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, make_expression_ptr(), node(), query_definedness(), query_real_value(), LMCAS::Real , 以及 LMCAS::ResourceLimit.

被这些函数引用 LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_domain(), LMCAS::detail::definite::defined_on_interval(), domain_constraints(), domain_constraints(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finish(), LMCAS::detail::definite::original_conditions_checked() , 以及 LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit().

函数调用图:

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

domain_constraints() [2/2]

Result< std::optional< std::vector< std::shared_ptr< SymbolicExpr > > > > LMCAS::detail::domain_constraints	(	const std::shared_ptr< const SymbolicNode > &	expression,
		const FactsQuery &	facts,
		Domain	domain,
		ComputationContext &	context )

返回完整定义域约束：空向量表示已证明，nullopt 表示无法完整表达。

注解

非空向量表示条件合取；空定义域用假谓词表示。

引用了 context, domain, domain_constraints() , 以及 facts.

函数调用图:

eliminate_exact()

Result< EliminationResult > LMCAS::detail::eliminate_exact	(	ExactMatrixData	input,
		std::size_t	coefficient_columns,
		EliminationForm	form,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix.cpp 第 87 行定义.

                                {
    auto valid = validate_matrix(input, operation);
    if (!valid) return Result<EliminationResult>::failure(valid.error());
    if (coefficient_columns == 0 || coefficient_columns > input.cols) {
        return Result<EliminationResult>::failure(
            CasErrc::InvalidArgument,
            "coefficient column count is outside matrix shape", operation);
    }
    try {
        EliminationResult result;
        result.matrix = std::move(input);
        auto forward = eliminate_forward(result, coefficient_columns, context, operation);
        if (!forward) return Result<EliminationResult>::failure(forward.error());
 
        if (form == EliminationForm::ReducedRowEchelon) {
            auto reduced = reduce_above(result, context, operation);
            if (!reduced) return Result<EliminationResult>::failure(reduced.error());
        }
        return Result<EliminationResult>::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return Result<EliminationResult>::failure(
            CasErrc::ResourceLimit,
            "exact elimination allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<EliminationResult>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 LMCAS::detail::ExactMatrixData::cols, context, eliminate_exact(), LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, LMCAS::detail::EliminationResult::matrix, operation, ReducedRowEchelon, LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::detail::matrix_kernel::validate_matrix().

被这些函数引用 eliminate_exact(), inverse_exact(), nullspace_exact(), rank_exact(), rref_exact() , 以及 solve_linear_exact().

函数调用图:

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

ensure_lmmc_lifecycle()

void LMCAS::detail::ensure_lmmc_lifecycle ( )

noexcept

在文件 lmmc_lifecycle.cpp 第 80 行定义.

                                      {
#ifdef _WIN32
    static LmmcLifecycleSlot slot;
    if (FlsGetValue(slot.index())) {
        return;
    }
    if (lmmc_init() != LMMC_STATUS_OK) {
        std::terminate();
    }
    void* owner = reinterpret_cast<void*>(static_cast<std::uintptr_t>(GetCurrentThreadId()));
    if (!FlsSetValue(slot.index(), owner)) {
        if (lmmc_deinit() != LMMC_STATUS_OK) {
            std::terminate();
        }
        std::terminate();
    }
#else
    static thread_local LmmcLifecycle lifecycle;
    (void)lifecycle;
#endif
}

引用了 ensure_lmmc_lifecycle().

被这些函数引用 LMCAS::adaptive_simpson_numeric(), LMCAS::anonymous_namespace{bigint_arithmetic.cpp}::bigint_div(), LMCAS::anonymous_namespace{bigint_arithmetic.cpp}::bigint_mul(), ensure_lmmc_lifecycle(), LMCAS::quadrature_gaussian_numeric(), LMCAS::quadrature_simpson_numeric(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend() , 以及 LMCAS::anonymous_namespace{newton_raphson.cpp}::run_newton_backend().

函数调用图:

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

equal_exact_real_algebraic()

Result< bool > LMCAS::detail::equal_exact_real_algebraic	(	ExactRealAlgebraic	lhs,
		ExactRealAlgebraic	rhs,
		ComputationContext &	context )

在文件 exact_algebraic.cpp 第 166 行定义.

                                 {
    auto step = context.consume_steps(1, "exact_algebraic.equal");
    if (!step) {
        return Result<bool>::failure(step.error());
    }
    if (!overlaps(lhs.lower, lhs.upper, rhs.lower, rhs.upper)) {
        return Result<bool>::success(false);
    }
    if (same_polynomial(lhs.polynomial, rhs.polynomial)) {
        return Result<bool>::success(lhs.root_index == rhs.root_index);
    }
 
    const Rational overlap_lower =
        lhs.lower < rhs.lower ? rhs.lower : lhs.lower;
    const Rational overlap_upper =
        lhs.upper < rhs.upper ? lhs.upper : rhs.upper;
    if (overlap_lower == overlap_upper &&
        (lhs.polynomial.eval(overlap_lower) != Rational(0) ||
         rhs.polynomial.eval(overlap_lower) != Rational(0))) {
        return Result<bool>::success(false);
    }
 
    try {
        return common_root_in_enclosures(lhs, rhs, context);
    } catch (const std::bad_alloc&) {
        return Result<bool>::failure(
            CasErrc::ResourceLimit,
            "algebraic equality allocation failed",
            "exact_algebraic.equal");
    } catch (const std::exception& error) {
        return Result<bool>::failure(
            CasErrc::InternalInvariant,
            error.what(),
            "exact_algebraic.equal");
    }
}

引用了 context, equal_exact_real_algebraic(), LMCAS::Polynomial< CoeffType >::eval(), LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::detail::ExactRealAlgebraic::lower, LMCAS::detail::ExactRealAlgebraic::polynomial, LMCAS::ResourceLimit, rhs, LMCAS::detail::ExactRealAlgebraic::root_index, LMCAS::Result< T >::success() , 以及 LMCAS::detail::ExactRealAlgebraic::upper.

被这些函数引用 LMCAS::detail::definite::compare_boundaries(), compare_exact_real_algebraic() , 以及 equal_exact_real_algebraic().

函数调用图:

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

equation_predicate()

ExprPtr LMCAS::detail::equation_predicate

(

const ExprPtr &

expression

)

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

                                                            {
    if (std::dynamic_pointer_cast<const RelationalNode>(detail::node(expression))) {
        return expression;
    }
    return detail::make_expression_ptr(detail::make_node<RelationalNode>(
        detail::node(expression), detail::node(SymbolicExpr::number(0)), RelationOp::EQ));
}

引用了 LMCAS::EQ, make_expression_ptr(), make_node() , 以及 node().

函数调用图:

equivalent_impl()

Result< bool > LMCAS::detail::equivalent_impl	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs,
		ComputationContext &	context,
		const EqvOptions &	options )

在文件 equivalence_engine.cpp 第 196 行定义.

                                                        {
    return equivalent_with_budget(lhs, rhs, context, options, nullptr);
}

引用了 context, LMCAS::options , 以及 rhs.

被这些函数引用 LMCAS::equivalent() , 以及 LMCAS::anonymous_namespace{residual_verification.cpp}::prove_with_profiles().

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

evaluate_root_complex()

Result< ApproxComplex > LMCAS::detail::evaluate_root_complex	(	const ExactRootId &	root,
		const NumericEvaluationOptions &	options,
		ComputationContext &	context )

在文件 exact_root.cpp 第 162 行定义.

                                 {
    constexpr const char* operation = "rootof.evaluate_complex";
    if (!valid_options(options)) {
        return Result<ApproxComplex>::failure(
            CasErrc::InvalidArgument,
            "root evaluation tolerances must be finite and positive",
            operation);
    }
    auto isolated = isolate_exact_root(root, context, operation);
    if (!isolated) return Result<ApproxComplex>::failure(isolated.error());
    if (auto* real = std::get_if<RealIsolation>(&isolated.value())) {
        auto approximation = approximate_real_isolation(
            std::move(real->value), options, context, operation);
        if (!approximation) {
            return Result<ApproxComplex>::failure(approximation.error());
        }
        return Result<ApproxComplex>::success(ApproxComplex{
            approximation.value(),
            ApproxReal{0.0, 0.0, NumericStatus::Finite}});
    }
    auto complex = std::get<ComplexIsolation>(std::move(isolated.value()));
    auto refined = refine_complex_isolation(
        root.polynomial, complex, options, context, operation);
    if (!refined) return Result<ApproxComplex>::failure(refined.error());
    auto real_part = approximate_component(
        complex.real_lower, complex.real_upper);
    auto imaginary_part = approximate_component(
        complex.imaginary_lower, complex.imaginary_upper);
    if (!std::isfinite(real_part.value) ||
        !std::isfinite(real_part.absolute_error) ||
        !std::isfinite(imaginary_part.value) ||
        !std::isfinite(imaginary_part.absolute_error)) {
        return Result<ApproxComplex>::failure(
            CasErrc::NumericFailure,
            "certified complex root enclosure could not be represented as finite double",
            operation);
    }
    return Result<ApproxComplex>::success(
        ApproxComplex{real_part, imaginary_part});
}

引用了 LMCAS::complex(), context, evaluate_root_complex(), LMCAS::Result< T >::failure(), LMCAS::Finite, LMCAS::InvalidArgument, isolate_exact_root(), LMCAS::NumericFailure, operation, LMCAS::options, LMCAS::detail::ExactRootId::polynomial, LMCAS::real(), refine_complex_isolation(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 evaluate_root_complex() , 以及 LMCAS::rootof_evaluate_complex_checked().

函数调用图:

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

evaluate_root_real()

Result< ApproxReal > LMCAS::detail::evaluate_root_real	(	const ExactRootId &	root,
		const NumericEvaluationOptions &	options,
		ComputationContext &	context )

在文件 exact_root.cpp 第 131 行定义.

                                 {
    constexpr const char* operation = "rootof.evaluate_real";
    if (!valid_options(options)) {
        return Result<ApproxReal>::failure(
            CasErrc::InvalidArgument,
            "root evaluation tolerances must be finite and positive",
            operation);
    }
    if (root.index >= static_cast<std::size_t>(root.polynomial.degree())) {
        return Result<ApproxReal>::failure(
            CasErrc::InvalidArgument,
            "RootOf index exceeds the number of distinct roots",
            operation);
    }
    auto real_roots = isolate_real_roots_exact(root.polynomial, context, operation);
    if (!real_roots) return Result<ApproxReal>::failure(real_roots.error());
    if (root.index >= real_roots.value().size()) {
        return Result<ApproxReal>::failure(
            CasErrc::DomainError,
            "selected RootOf is not real",
            operation);
    }
    const auto& interval = real_roots.value()[root.index];
    return approximate_real_isolation(
        ExactRealAlgebraic{root.polynomial, interval.first, interval.second, root.index, 1},
        options, context, operation);
}

引用了 context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::DomainError, evaluate_root_real(), LMCAS::Result< T >::failure(), LMCAS::detail::ExactRootId::index, LMCAS::interval(), LMCAS::InvalidArgument, isolate_real_roots_exact(), operation, LMCAS::options, LMCAS::detail::ExactRootId::polynomial , 以及 LMCAS::Result< T >::value().

被这些函数引用 evaluate_root_real() , 以及 LMCAS::rootof_evaluate_checked().

函数调用图:

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

evaluate_unary_numeric()

Result< ApproxReal > LMCAS::detail::evaluate_unary_numeric	(	FunctionNode::FuncType	type,
		double	value )

在文件 numeric_evaluation_functions.cpp 第 166 行定义.

                                                                               {
    auto evaluated = trigonometric(type, x);
    if (!evaluated) {
        evaluated = inverse_trigonometric(type, x);
    }
    if (!evaluated) {
        evaluated = hyperbolic(type, x);
    }
    if (!evaluated) {
        evaluated = elementary(type, x);
    }
    if (!evaluated) {
        evaluated = special(type, x);
    }
    if (!evaluated) {
        return numeric_failure(CasErrc::UnsupportedExpression,
                               "function is not supported by real numeric evaluation");
    }
    return std::move(*evaluated);
}

引用了 evaluate_unary_numeric(), numeric_failure() , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 evaluate_unary_numeric() , 以及 LMCAS::detail::NumericEvaluator::function().

函数调用图:

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

exact_atan_bounds()

Result< ExactConstantInterval > LMCAS::detail::exact_atan_bounds	(	const Rational &	value,
		std::size_t	precision_bits,
		ComputationContext &	context )

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

                                                                                  {
    return checked_bounds(context, "exact.atan.bounds", [&](const ExactBoundArithmetic& arithmetic) {
        return atan_bounds(value, precision_bits, arithmetic);
    });
}

引用了 context, exact_atan_bounds() , 以及 LMCAS::value.

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_endpoint() , 以及 exact_atan_bounds().

函数调用图:

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

exact_double_rational()

Result< Rational > LMCAS::detail::exact_double_rational	(	double	value,
		ComputationContext &	context,
		const std::string &	operation )

在文件 interval_endpoint.cpp 第 11 行定义.

                                                                   {
    if (!std::isfinite(value)) {
        return Result<Rational>::failure(
            CasErrc::NumericFailure,
            "finite interval endpoint evaluated to NaN or infinity",
            operation);
    }
    if (value == 0.0) {
        return Result<Rational>::success(Rational(0));
    }
 
    int exponent = 0;
    std::frexp(value, &exponent);
    const int binary_exponent = exponent - 53;
    const std::size_t required_bits = binary_exponent < 0
        ? static_cast<std::size_t>(-binary_exponent) + 1
        : static_cast<std::size_t>(binary_exponent) + 54;
    auto bit_budget = context.require_integer_bits(required_bits, operation);
    if (!bit_budget) {
        return Result<Rational>::failure(bit_budget.error());
    }
 
    return Result<Rational>::success(Rational::from_double(value));
}

引用了 context, exact_double_rational(), LMCAS::exponent, LMCAS::Result< T >::failure(), LMCAS::NumericFailure, operation, LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 exact_double_rational().

函数调用图:

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

exact_e_bounds()

Result< ExactConstantInterval > LMCAS::detail::exact_e_bounds	(	std::size_t	precision_bits,
		ComputationContext &	context )

< 级数项 1/n!。

< 含 k=0 项的部分和 S_n。

在文件 exact_constant_bounds.cpp 第 114 行定义.

                                                           {
    return checked_bounds(context, "exact.e.bounds", [&](const ExactBoundArithmetic& arithmetic) {
        const Rational target(BigInt(1), arithmetic.dyadic_scale(precision_bits));
        BigInt n(1);
        Rational term(1); /**< 级数项 1/n!。 */
        Rational sum(2); /**< 含 k=0 项的部分和 S_n。 */
        for (;;) {
            arithmetic.step();
            const Rational tail = arithmetic.div(term, Rational(n));
            if (!arithmetic.less(target, tail))
                return Bounds{sum, arithmetic.add(sum, tail)};
            arithmetic.growth(n.bit_length(), 1);
            n += BigInt(1);
            term = arithmetic.div(term, Rational(n));
            sum = arithmetic.add(sum, term);
        }
    });
}

引用了 LMCAS::detail::ExactBoundArithmetic::add(), context, LMCAS::detail::ExactBoundArithmetic::div(), LMCAS::detail::ExactBoundArithmetic::dyadic_scale(), exact_e_bounds(), LMCAS::detail::ExactBoundArithmetic::growth(), LMCAS::detail::ExactBoundArithmetic::less(), LMCAS::detail::ExactBoundArithmetic::step() , 以及 LMCAS::target.

被这些函数引用 LMCAS::Irrational::EnclosureRound::constant() , 以及 exact_e_bounds().

函数调用图:

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

exact_pi_bounds()

Result< ExactConstantInterval > LMCAS::detail::exact_pi_bounds	(	std::size_t	precision_bits,
		ComputationContext &	context )

在文件 exact_constant_bounds.cpp 第 107 行定义.

                                                           {
    return checked_bounds(context, "exact.pi.bounds", [&](const ExactBoundArithmetic& arithmetic) {
        return pi_bounds(precision_bits, arithmetic);
    });
}

引用了 context , 以及 exact_pi_bounds().

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_endpoint(), LMCAS::Irrational::EnclosureRound::constant() , 以及 exact_pi_bounds().

函数调用图:

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

exact_rational_value() [1/2]

std::optional< Rational > LMCAS::detail::exact_rational_value

(

const NumberNode &

number

)

在文件 expression_analysis.cpp 第 243 行定义.

                              {
    if (const auto* integer = std::get_if<BigInt>(&number.value())) {
        return Rational(*integer);
    }
    if (const auto* rational = std::get_if<Rational>(&number.value())) {
        return *rational;
    }
    return std::nullopt;
}

引用了 LMCAS::integer, LMCAS::rational() , 以及 LMCAS::NumberNode::value().

被这些函数引用 LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::coefficient(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::convert_number(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_fractional_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_function(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_power(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_polynomial_nodes(), LMCAS::detail::matrix_kernel::exact_rational(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), exact_rational_value(), integrate_power_primitive(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_by_parts_score(), LMCAS::anonymous_namespace{integrator.cpp}::is_zero(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::linear_interval(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::outside_real_function_domain(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_quadratic_surd(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_surd_power(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), LMCAS::equivalence_detail::prove_rational_polynomial_equivalence(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::radical_radicand(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::radical_square(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::register_new_atom(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_radical(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_inv_ln_var(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_inv_var(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_half_exponent() , 以及 LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_match_radical().

函数调用图:

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

exact_rational_value() [2/2]

std::optional< Rational > LMCAS::detail::exact_rational_value

(

const SymbolicNodePtr &

node

)

在文件 expression_analysis.cpp 第 254 行定义.

                                       {
    const auto number = std::dynamic_pointer_cast<const NumberNode>(node);
    return number ? exact_rational_value(*number) : std::nullopt;
}

引用了 exact_rational_value() , 以及 node().

函数调用图:

expand_expression()

ExpressionResult LMCAS::detail::expand_expression	(	const ExprPtr &	expression,
		ComputationContext &	context )

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

                                                                                           {
    return assumed_transform(expression, context, "LMCAS.expand", "expand",
        [](const SymbolicNodePtr& value, RewriteBudget& budget, const FactsQuery& facts) {
            return expand_node(value, budget, facts);
        });
}

引用了 budget, context, expand_expression(), expand_node(), facts , 以及 LMCAS::value.

被这些函数引用 LMCAS::expand() , 以及 expand_expression().

函数调用图:

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

expand_node()

SymbolicNodePtr LMCAS::detail::expand_node	(	const SymbolicNodePtr &	node,
		RewriteBudget &	budget,
		const FactsQuery &	facts,
		Domain	domain )

在文件 symbolic_core.cpp 第 220 行定义.

                                                                    {
    budget.consume();
    if (!node) {
        throw CasError{CasErrc::InvalidArgument, "expand argument cannot be null",
                       "LMCAS.expand"};
    }
    budget.measure(node);
    ExpandVisitor visitor(budget);
    node->accept(visitor);
    return normalize_node(visitor.get_result(), budget, facts, domain);
}

引用了 budget, LMCAS::detail::RewriteBudget::consume(), domain, expand_node(), facts, LMCAS::ExpandVisitor::get_result(), LMCAS::InvalidArgument, LMCAS::detail::RewriteBudget::measure(), node() , 以及 normalize_node().

被这些函数引用 LMCAS::calculus_utils_oblique_from_rational(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_variable(), classify_quadric_impl(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::equivalence_detail::expand_equivalence(), expand_expression(), expand_node(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_normalized_residual(), LMCAS::quadratic_form_matrix(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstructs_expression(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_radical(), LMCAS::solve_homogeneous_ode_impl(), LMCAS::tf_build_polynomial_impl() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_reduce_rational().

函数调用图:

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

expression_from_node()

inline ::LMCAS::SymbolicExpr LMCAS::detail::expression_from_node

(

SymbolicNodePtr

root

)

在文件 base.hpp 第 107 行定义.

                                                                    {
    return SymbolicExprAccess::expression_from_node(std::move(root));
}

引用了 expression_from_node() , 以及 LMCAS::detail::SymbolicExprAccess::expression_from_node().

被这些函数引用 LMCAS::InferenceEngine::Impl::accumulate_product_sign(), LMCAS::InferenceEngine::Impl::accumulate_sum_relation_sign(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::anonymous_namespace{integration_substitution.cpp}::classify_linear_wrapper(), LMCAS::detail::definite::collect_predicate_roots(), LMCAS::InferenceEngine::Impl::deduce_function_relation(), LMCAS::InferenceEngine::Impl::deduce_power_relations(), LMCAS::anonymous_namespace{query_conditions.cpp}::difference_conditions(), expression_from_node(), LMCAS::groebner_detail::from_poly_ext(), LMCAS::groebner_detail::PolyBuilder::get_or_create_aux_var(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_by_parts_choice(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_by_parts_score(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_differential_factor(), LMCAS::detail::AssumptionFacts::is_negative(), LMCAS::detail::AssumptionFacts::is_nonnegative(), LMCAS::detail::AssumptionFacts::is_nonzero(), LMCAS::detail::AssumptionFacts::is_positive(), LMCAS::detail::AssumptionFacts::is_real(), LMCAS::isolate_linear_coeff(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::InferenceEngine::Impl::logarithm_sign(), LMCAS::match_recursive(), materialize_integral(), LMCAS::InferenceEngine::Impl::multiply_domain(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::parse_conditional_relation(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_serialized_numeric_atom(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::InferenceEngine::Impl::product_relation_sign(), LMCAS::detail::definite::rational_checked(), LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives(), LMCAS::record_remainder(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::relational_predicate_truth(), LMCAS::detail::definite::segment_expression_checked(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::select_continuity_branch(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_match_exp_neg_quad(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_argument(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive(), LMCAS::InferenceEngine::Impl::sum_sign(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int(), LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_quadratic_coefficients(), LMCAS::RewriteVisitor::try_match(), LMCAS::anonymous_namespace{integration_definite.cpp}::unresolved_integral(), LMCAS::groebner_detail::PolyBuilder::use_numeric_function() , 以及 LMCAS::wildcard().

函数调用图:

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

extract_common_monomial()

std::pair< Monomial, MultiPoly > LMCAS::detail::extract_common_monomial

(

const MultiPoly &

poly

)

提取公因子单项式

计算所有项单项式的逐分量最小值(GCD 单项式),将其从每项中减去.

参数

[in]

poly

输入多项式

返回

pair(公因子单项式, 提取后的多项式)

计算逐分量最小值

检查是否为平凡(全零)

从每项中减去 GCD 单项式

在文件 multivariate_factor_patterns.cpp 第 217 行定义.

{
    const auto& vars = poly.variables();
    Monomial identity(vars.size(), 0);
 
    if (poly.is_zero() || poly.num_terms() == 0) {
        return {identity, poly};
    }
 
    const auto& terms = poly.terms();
 
    /// 计算逐分量最小值
    Monomial gcd_mono = terms[0].first;
    for (size_t t = 1; t < terms.size(); ++t) {
        const Monomial& mono = terms[t].first;
        for (size_t i = 0; i < gcd_mono.size(); ++i) {
            int val = (i < mono.size()) ? mono[i] : 0;
            if (val < gcd_mono[i]) { gcd_mono[i] = val; }
        }
    }
 
    /// 检查是否为平凡(全零)
    bool is_trivial = true;
    for (size_t i = 0; i < gcd_mono.size(); ++i) {
        if (gcd_mono[i] != 0) { is_trivial = false; break; }
    }
    if (is_trivial) { return {identity, poly}; }
 
    /// 从每项中减去 GCD 单项式
    std::vector<MultiPoly::Term> quotient_terms;
    quotient_terms.reserve(terms.size());
    for (const auto& term : terms) {
        Monomial new_mono(vars.size(), 0);
        for (size_t i = 0; i < vars.size(); ++i) {
            int orig = (i < term.first.size()) ? term.first[i] : 0;
            new_mono[i] = orig - gcd_mono[i];
        }
        quotient_terms.emplace_back(std::move(new_mono), term.second);
    }
 
    MultiPoly quotient(std::move(quotient_terms), vars);
    return {gcd_mono, quotient};
}

引用了 extract_common_monomial(), LMCAS::t , 以及 LMCAS::vars.

被这些函数引用 __attribute__(), extract_common_monomial() , 以及 LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl().

函数调用图:

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

extract_rational()

Result< bool > LMCAS::detail::extract_rational	(	const SymbolicExpr &	expr,
		const std::string &	var,
		Polynomial< Rational > &	numerator,
		Polynomial< Rational > &	denominator )

分母为零时返回 false。

在文件 integration_rational_collection.cpp 第 160 行定义.

                                                              {
 
    std::vector<Polynomial<Rational>> nums, dens;
    auto collected = rd_collect_rational(LMCAS::detail::node(expr), var, nums, dens);
    if (!collected || !collected.value()) { return collected; }
 
    Polynomial<Rational> P({Rational(1)}, var);
    for (const auto& p : nums) { P = P * p; }
    Polynomial<Rational> Q({Rational(1)}, var);
    for (const auto& p : dens) { Q = Q * p; }
 
    if (Q.is_zero()) { return false; } /** @brief 分母为零时返回 false。 */
 
    rd_normalize_fraction(P, Q, var);
 
    P_out = P;
    Q_out = Q;
    return true;
}

引用了 node().

被这些函数引用 LMCAS::extract_laurent_regular_part().

函数调用图:

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

factor_denominator()

bool LMCAS::detail::factor_denominator	(	const Polynomial< Rational > &	denominator,
		std::vector< std::pair< Polynomial< Rational >, int > > &	factors )

逐次提取各无平方因子的有理根。 剩余因子次数至多为 2 时匹配成功，否则返回未匹配。

在文件 integration_rational_factorization.cpp 第 64 行定义.

                                                                {
    factors_out.clear();
    if (Q.degree() <= 0) { return false; }
    auto sqfree = square_free_factorization(Q);
    if (sqfree.empty()) { return false; }
 
    /**
     * @brief 逐次提取各无平方因子的有理根。
     * 剩余因子次数至多为 2 时匹配成功，否则返回未匹配。
     */
    for (const auto& [piece, mult] : sqfree) {
        if (!rd_factor_piece(piece, mult, factors_out)) { return false; }
    }
    return true;
}

引用了 LMCAS::Polynomial< CoeffType >::degree() , 以及 LMCAS::square_free_factorization().

被这些函数引用 LMCAS::anonymous_namespace{integration_rational.cpp}::rd_integrate_proper_fraction().

函数调用图:

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

factor_homogeneous_bivariate()

Result< std::optional< MultiFactorResult > > LMCAS::detail::factor_homogeneous_bivariate	(	const MultiPoly &	poly,
		ComputationContext &	context )

齐次二元多项式分解

对齐次二元多项式 f(x, y),令 y=1 得到一元多项式 f(x, 1), 对其进行一元因式分解,然后将每个因子重新齐次化.

参数

[in]	poly	输入多项式（须为齐次二元）
[in,out]	context	调用方的计算预算和取消状态

返回

不适用时成功返回 nullopt；分解错误原样传播

去齐次化:令 y = 1,得到关于 x 的一元多项式

转换为一元多项式

一元因式分解

重新齐次化每个因子

在文件 multivariate_factor_patterns.cpp 第 272 行定义.

{
    if (!poly.is_homogeneous() || poly.num_vars() != 2) {
        return std::optional<MultiFactorResult>{};
    }
 
    const auto& vars = poly.variables();
    std::string var_x = vars[0];
    std::string var_y = vars[1];
 
    /// 去齐次化:令 y = 1,得到关于 x 的一元多项式
    MultiPoly dehomogenized = poly.eval(var_y, Rational(1));
 
    /// 转换为一元多项式
    Polynomial<Rational> uni_poly;
    try {
        uni_poly = dehomogenized.to_univariate();
    } catch (const std::invalid_argument&) {
        return std::optional<MultiFactorResult>{};
    }
 
    /// 一元因式分解
    auto checked_factors =
        factor_univariate_bridge_checked(uni_poly, context);
    if (!checked_factors) {
        return Result<std::optional<MultiFactorResult>>::failure(
            checked_factors.error());
    }
    if (checked_factors.value().completeness != Completeness::Complete) {
        return std::optional<MultiFactorResult>{};
    }
    std::vector<Polynomial<Rational>> uni_factors =
        std::move(checked_factors.value().value);
    if (uni_factors.size() <= 1) {
        return std::optional<MultiFactorResult>{};
    }
 
    /// 重新齐次化每个因子
    MultiFactorResult result;
    result.constant = poly.numeric_content();
 
    for (const auto& uf : uni_factors) {
        auto homo_factor = homogenize_factor(uf, vars);
        result.factors.push_back(std::move(homo_factor));
        result.multiplicities.push_back(1);
    }
 
    adjust_homogeneous_constant(poly, result);
 
    return std::optional<MultiFactorResult>(std::move(result));
}

引用了 adjust_homogeneous_constant(), LMCAS::Complete, LMCAS::MultiFactorResult::constant, context, factor_homogeneous_bivariate(), LMCAS::factor_univariate_bridge_checked(), LMCAS::MultiFactorResult::factors, homogenize_factor(), LMCAS::MultiFactorResult::multiplicities , 以及 LMCAS::vars.

被这些函数引用 __attribute__(), factor_homogeneous_bivariate() , 以及 LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl().

函数调用图:

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

finalize_solution_set()

SolveResult LMCAS::detail::finalize_solution_set	(	const ExprPtr &	original,
		const std::string &	variable,
		SolutionSet	solutions,
		ComputationContext &	context,
		Domain	domain,
		const SolveOptions &	options )

在文件 solve_solution_finalization.cpp 第 250 行定义.

                                                {
    if (std::holds_alternative<EmptySolutions>(solutions)) { return solutions; }
    AssumptionContext local_facts = context.assumptions() ?
        *context.assumptions() : AssumptionContext{};
    if (domain == Domain::Real) {
        auto declared = local_facts.assume_domain_checked(variable, Domain::Real);
        if (!declared) { return SolveResult::failure(declared.error()); }
    }
    if (const auto* families = std::get_if<ParametricSolutions>(&solutions)) {
        for (const auto& family : families->values) {
            for (const auto& parameter : family.integer_parameters) {
                auto declared = local_facts.assume_domain_checked(parameter, Domain::Integer);
                if (!declared) { return SolveResult::failure(declared.error()); }
            }
        }
    }
    detail::AssumptionFacts adapter(local_facts);
    return SolutionFinalizer(original, variable, adapter, context, domain, options).finish(std::move(solutions));
}

引用了 context, domain, LMCAS::Result< SolutionSet >::failure(), LMCAS::Integer, LMCAS::options, LMCAS::Real , 以及 variable.

被这些函数引用 LMCAS::dispatch_equation() , 以及 LMCAS::solve_transcendental().

函数调用图:

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

homogenize_factor()

MultiPoly LMCAS::detail::homogenize_factor ( const Polynomial< Rational > & uf, const std::vector< std::string > & vars )

static

在文件 multivariate_factor_patterns.cpp 第 27 行定义.

                                                                     {
    int d = uf.degree();
    // c*x^k becomes c*x^k*y^(d-k).
    std::vector<MultiPoly::Term> homo_terms;
    for (int k = 0; k <= d; ++k) {
        Rational coeff = (k < static_cast<int>(uf.coeffs.size())) ? uf.coeffs[k] : Rational(0);
        if (coeff.is_zero()) { continue; }
        Monomial mono(2, 0);
        mono[0] = k;
        mono[1] = d - k;
        homo_terms.emplace_back(std::move(mono), coeff);
    }
    MultiPoly homo_factor(std::move(homo_terms), vars);
    homo_factor = homo_factor.make_primitive();
    return homo_factor;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::degree(), homogenize_factor() , 以及 LMCAS::vars.

被这些函数引用 factor_homogeneous_bivariate() , 以及 homogenize_factor().

函数调用图:

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

integrate_power_primitive()

Result< std::optional< SymbolicExpr > > LMCAS::detail::integrate_power_primitive	(	const SymbolicExpr &	base,
		const SymbolicExpr &	exponent,
		const std::string &	variable,
		ComputationContext &	context )

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

                                                            {
    if (depends_on_integration_variable(exponent, variable)) {
        return std::optional<SymbolicExpr>{};
    }
    RewriteBudget budget(context, context.limits().max_recursion_depth,
                         context.limits().max_ast_nodes, "integrate.power");
    auto exact = exact_rational_value(node(exponent));
    if (exact && *exact == Rational(-1)) {
        return std::optional<SymbolicExpr>{*SymbolicExpr::ln(make_expression_ptr(base))};
    }
    auto next = exact ? SymbolicExpr::number(*exact + Rational(1)) :
        make_expression_ptr(normalize_node(node(SymbolicExpr::add(
            make_expression_ptr(exponent), SymbolicExpr::number(1))), budget));
    if (!exact) {
        std::optional<AssumptionFacts> facts;
        if (context.assumptions()) { facts.emplace(*context.assumptions()); }
        auto nonzero = query_nonzero_value(node(next),
            facts ? static_cast<const FactsQuery&>(*facts) : no_facts(), Domain::Real, context);
        if (!nonzero) {
            return Result<std::optional<SymbolicExpr>>::failure(nonzero.error());
        }
        if (nonzero.value() != Tribool::True) { return std::optional<SymbolicExpr>{}; }
    }
    return std::optional<SymbolicExpr>{*SymbolicExpr::divide(
        SymbolicExpr::power(make_expression_ptr(base), next), next)};
}

引用了 budget, context, LMCAS::depends_on_integration_variable(), exact_rational_value(), LMCAS::exponent, facts, make_expression_ptr(), no_facts(), node(), normalize_node(), query_nonzero_value(), LMCAS::Real, LMCAS::True , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive().

函数调用图:

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

integrate_rational_term()

detail::IntegralParts LMCAS::detail::integrate_rational_term	(	const Polynomial< Rational > &	numerator,
		const Polynomial< Rational > &	factor,
		int	power,
		const std::string &	var )

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

                                     {
    const SymbolicExpr zero = *SymbolicExpr::number(0);
    if (numerator.is_zero()) { return {zero, zero}; }
    if (factor.degree() == 1) {
        return {*rd_integrate_linear_term(numerator, factor, power, var), zero};
    }
    if (factor.degree() == 2 && power == 1) {
        return {*rd_integrate_quadratic_term(numerator, factor, var), zero};
    }
    return {zero, *rd_fraction_term(numerator, factor, power)};
}

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

被这些函数引用 LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives().

函数调用图:

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

integration_depends_on_variable()

bool LMCAS::detail::integration_depends_on_variable	(	const SymbolicNodePtr &	expression,
		const std::string &	variable,
		RewriteBudget *	budget = nullptr )

在文件 expression_analysis.cpp 第 328 行定义.

                                                                                         {
    if (!expression || variable.empty()) return false;
    FreeVariableFinder finder(variable, budget, true);
    expression->accept(finder);
    return finder.found;
}

引用了 LMCAS::SymbolicNode::accept(), budget , 以及 variable.

被这些函数引用 LMCAS::depends_on_integration_variable().

函数调用图:

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

inverse_exact()

Result< ExactMatrixData > LMCAS::detail::inverse_exact	(	const ExactMatrixData &	input,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix.cpp 第 146 行定义.

                                {
    auto valid = validate_matrix(input, operation);
    if (!valid) return Result<ExactMatrixData>::failure(valid.error());
    if (input.rows != input.cols) {
        return Result<ExactMatrixData>::failure(
            CasErrc::InvalidArgument,
            "inverse requires a square matrix", operation);
    }
    const std::size_t n = input.rows;
    ExactMatrixData augmented{n, 2 * n, {}};
    augmented.entries.reserve(n * 2 * n);
    for (std::size_t row = 0; row < n; ++row) {
        for (std::size_t column = 0; column < n; ++column) {
            augmented.entries.push_back(input.at(row, column));
        }
        for (std::size_t column = 0; column < n; ++column) {
            augmented.entries.push_back(
                SymbolicExpr::number(row == column ? 1 : 0));
        }
    }
    auto eliminated = eliminate_exact(
        std::move(augmented), n,
        EliminationForm::ReducedRowEchelon, context, operation);
    if (!eliminated) return Result<ExactMatrixData>::failure(eliminated.error());
    if (eliminated.value().rank != n) {
        return Result<ExactMatrixData>::failure(
            CasErrc::DomainError,
            "matrix is singular and has no inverse", operation);
    }
    ExactMatrixData inverse{n, n, {}};
    inverse.entries.reserve(n * n);
    for (std::size_t row = 0; row < n; ++row) {
        for (std::size_t column = 0; column < n; ++column) {
            inverse.entries.push_back(
                eliminated.value().matrix.at(row, n + column));
        }
    }
    return Result<ExactMatrixData>::success(std::move(inverse));
}

引用了 LMCAS::detail::ExactMatrixData::at(), LMCAS::detail::ExactMatrixData::cols, context, LMCAS::DomainError, eliminate_exact(), LMCAS::detail::ExactMatrixData::entries, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, inverse_exact(), operation, ReducedRowEchelon, LMCAS::detail::ExactMatrixData::rows, LMCAS::Result< T >::success() , 以及 LMCAS::detail::matrix_kernel::validate_matrix().

被这些函数引用 inverse_exact() , 以及 LMCAS::matrix_inverse_checked().

函数调用图:

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

is_imaginary_unit_name()

bool LMCAS::detail::is_imaginary_unit_name

(

const std::string &

name

)

在文件 expression_analysis.cpp 第 302 行定义.

                                                         {
    return name == "I";
}

引用了 LMCAS::name.

被这些函数引用 LMCAS::expr_detail::ExprParser::parse_identifier_or_call() , 以及 LMCAS::sym().

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

is_linear()

bool LMCAS::detail::is_linear	(	const MultiPoly &	poly,
		const std::string &	main_var )

检测是否为线性多项式(主变量次数 <= 1)

在文件 multivariate_factor_patterns.cpp 第 72 行定义.

{
    return poly.degree(main_var) <= 1;
}

引用了 is_linear() , 以及 main_var.

被这些函数引用 __attribute__() , 以及 is_linear().

函数调用图:

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

is_signed_decimal_token()

bool LMCAS::detail::is_signed_decimal_token ( std::string_view token )

inlinenoexcept

在文件 numeric_literal.hpp 第 49 行定义.

                                                                   {
    std::size_t pos = 0;
    consume_decimal_sign(token, pos);
    if (!consume_decimal_mantissa(token, pos)) { return false; }
    if (!consume_decimal_exponent(token, pos)) { return false; }
    return pos == token.size();
}

引用了 consume_decimal_exponent(), consume_decimal_mantissa(), consume_decimal_sign() , 以及 is_signed_decimal_token().

被这些函数引用 is_signed_decimal_token() , 以及 parse_finite_decimal().

函数调用图:

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

isolate_exact_root()

Result< RootIsolation > LMCAS::detail::isolate_exact_root	(	const ExactRootId &	root,
		ComputationContext &	context,
		const std::string &	operation )

在文件 complex_root_isolation.cpp 第 236 行定义.

                                {
    auto roots = isolate_exact_roots(root.polynomial, context, operation);
    if (!roots) return Result<RootIsolation>::failure(roots.error());
    if (root.index >= roots.value().size()) {
        return Result<RootIsolation>::failure(
            CasErrc::InvalidArgument,
            "RootOf index exceeds the number of distinct roots",
            operation);
    }
    return Result<RootIsolation>::success(
        std::move(roots.value()[root.index]));
}

引用了 context, LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), LMCAS::detail::ExactRootId::index, LMCAS::InvalidArgument, isolate_exact_root(), isolate_exact_roots(), operation, LMCAS::detail::ExactRootId::polynomial, LMCAS::roots(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_root(), evaluate_root_complex(), isolate_exact_root(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::root_facts() , 以及 LMCAS::solution_is_excluded().

函数调用图:

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

isolate_exact_roots()

Result< std::vector< RootIsolation > > LMCAS::detail::isolate_exact_roots	(	const Polynomial< Rational > &	input,
		ComputationContext &	context,
		const std::string &	operation )

在文件 complex_root_isolation.cpp 第 197 行定义.

                                {
    const std::size_t starting_steps = context.steps_used();
    try {
        auto step = context.consume_steps(1, operation);
        if (!step) return Result<std::vector<RootIsolation>>::failure(step.error());
        if (input.degree() <= 0) {
            return Result<std::vector<RootIsolation>>::failure(
                CasErrc::InvalidArgument,
                "exact root isolation requires a nonconstant polynomial", operation);
        }
        Poly polynomial = input.square_free_part().make_monic();
        polynomial.variable_name = "_root";
        for (const auto& entry : root_isolation_cache) {
            if (!same_polynomial(entry.polynomial, polynomial)) continue;
            const std::size_t remaining_cost = entry.step_cost > 0 ? entry.step_cost - 1 : 0;
            auto cached_step = context.consume_steps(remaining_cost, operation + ".cache");
            if (!cached_step) return Result<std::vector<RootIsolation>>::failure(cached_step.error());
            return Result<std::vector<RootIsolation>>::success(entry.roots);
        }
        auto factors = strict_factors(polynomial, context);
        if (!factors) return Result<std::vector<RootIsolation>>::failure(factors.error());
        auto roots = factors.value().empty()
            ? isolate_unfactored(polynomial, context, operation)
            : isolate_factors(factors.value(), static_cast<std::size_t>(polynomial.degree()),
                              context, operation);
        if (!roots) return roots;
        return remember_isolations(polynomial, std::move(roots.value()),
                                   context.steps_used() - starting_steps);
    } catch (const std::bad_alloc&) {
        return Result<std::vector<RootIsolation>>::failure(
            CasErrc::ResourceLimit, "complex root isolation allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<std::vector<RootIsolation>>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, isolate_exact_roots(), LMCAS::Polynomial< CoeffType >::make_monic(), operation, LMCAS::ResourceLimit, LMCAS::roots(), LMCAS::Polynomial< CoeffType >::square_free_part(), LMCAS::Result< T >::value() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 isolate_exact_root(), isolate_exact_roots() , 以及 LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::isolate_factors().

函数调用图:

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

isolate_real_roots_exact()

Result< std::vector< RationalInterval > > LMCAS::detail::isolate_real_roots_exact	(	const Polynomial< Rational > &	polynomial,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_sturm.cpp 第 285 行定义.

                                {
    try {
        auto step = context.consume_steps(1, operation);
        if (!step) return Result<std::vector<RationalInterval>>::failure(step.error());
        if (polynomial.degree() <= 0) {
            return Result<std::vector<RationalInterval>>::success({});
        }
        if (polynomial.degree() == 1) {
            const Rational root = -polynomial.coeffs[0] / polynomial.coeffs[1];
            return Result<std::vector<RationalInterval>>::success({{root, root}});
        }
        auto square_free = polynomial.square_free_part().make_monic();
        auto sequence = make_sturm_sequence(square_free, context, operation);
        if (!sequence) {
            return Result<std::vector<RationalInterval>>::failure(sequence.error());
        }
        return isolate_sturm_sequence(square_free, sequence.value(), context, operation);
    } catch (const std::bad_alloc&) {
        return Result<std::vector<RationalInterval>>::failure(
            CasErrc::ResourceLimit,
            "Sturm root isolation allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<std::vector<RationalInterval>>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::InternalInvariant, isolate_real_roots_exact(), LMCAS::Polynomial< CoeffType >::make_monic(), operation, LMCAS::ResourceLimit , 以及 LMCAS::Polynomial< CoeffType >::square_free_part().

被这些函数引用 LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), LMCAS::detail::anonymous_namespace{exact_algebraic.cpp}::common_root_in_enclosures(), evaluate_root_real(), LMCAS::isolate_real_roots_checked(), isolate_real_roots_exact(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::isolate_unfactored(), make_exact_real_algebraic(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::prepare_projection_grid() , 以及 LMCAS::detail::definite::roots_checked().

函数调用图:

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

isolate_roots_with_context()

std::vector< IsolatedInterval > LMCAS::detail::isolate_roots_with_context	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	var,
		const SearchInterval &	interval,
		const SolveOptions &	opts,
		RewriteBudget &	budget,
		std::optional< CasError > *	failure,
		bool *	complete )

在文件 mixed_transcendental_isolation.cpp 第 184 行定义.

                                                    {
    if (interval.lo >= interval.hi) {
        return {};
    }
    RootIsolation isolation(expr, derivative, var, budget);
    if (!isolation.initialize(interval, failure, complete)) {
        return {};
    }
    isolation.run(opts, failure, complete);
    return isolation.finish(opts.max_roots, complete);
}

引用了 budget, LMCAS::interval(), isolate_roots_with_context() , 以及 LMCAS::SolveOptions::max_roots.

被这些函数引用 LMCAS::isolate_roots(), isolate_roots_with_context() , 以及 mixed_numerical_path().

函数调用图:

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

make_exact_real_algebraic()

ExactRealAlgebraicResult LMCAS::detail::make_exact_real_algebraic	(	Polynomial< Rational >	polynomial,
		std::size_t	root_index,
		std::size_t	multiplicity,
		ComputationContext &	context )

在文件 exact_algebraic.cpp 第 65 行定义.

                                 {
    if (polynomial.degree() < 1) {
        return ExactRealAlgebraicResult::failure(
            CasErrc::InvalidArgument,
            "an algebraic value requires a non-constant polynomial",
            kOperation);
    }
    if (multiplicity == 0) {
        return ExactRealAlgebraicResult::failure(
            CasErrc::InvalidArgument,
            "algebraic root multiplicity must be positive",
            kOperation);
    }
    auto step = context.consume_steps(1, kOperation);
    if (!step) return ExactRealAlgebraicResult::failure(step.error());
 
    try {
        polynomial = monic(std::move(polynomial));
        auto rational_roots = find_rational_roots(polynomial);
        std::sort(rational_roots.begin(), rational_roots.end());
        rational_roots.erase(
            std::unique(rational_roots.begin(), rational_roots.end()),
            rational_roots.end());
        if (rational_roots.size() ==
            static_cast<std::size_t>(polynomial.degree())) {
            if (root_index >= rational_roots.size()) {
                return ExactRealAlgebraicResult::failure(
                    CasErrc::InvalidArgument,
                    "real algebraic root index is out of range",
                    kOperation);
            }
            return ExactRealAlgebraicResult::success(ExactRealAlgebraic{
                std::move(polynomial), rational_roots[root_index],
                rational_roots[root_index], root_index, multiplicity});
        }
        auto isolated = isolate_real_roots_exact(
            polynomial, context, kOperation);
        if (!isolated) {
            return ExactRealAlgebraicResult::failure(isolated.error());
        }
        const auto& intervals = isolated.value();
        if (root_index >= intervals.size()) {
            return ExactRealAlgebraicResult::failure(
                CasErrc::InvalidArgument,
                "real algebraic root index is out of range",
                kOperation);
        }
        return ExactRealAlgebraicResult::success(ExactRealAlgebraic{
            std::move(polynomial), intervals[root_index].first,
            intervals[root_index].second, root_index, multiplicity});
    } catch (const std::bad_alloc&) {
        return ExactRealAlgebraicResult::failure(
            CasErrc::ResourceLimit,
            "algebraic root isolation allocation failed",
            kOperation);
    } catch (const std::exception& error) {
        return ExactRealAlgebraicResult::failure(
            CasErrc::InternalInvariant, error.what(), kOperation);
    }
}

引用了 context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< ExactRealAlgebraic >::failure(), LMCAS::find_rational_roots(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, isolate_real_roots_exact(), make_exact_real_algebraic(), multiplicity, LMCAS::ResourceLimit, root_index , 以及 LMCAS::Result< ExactRealAlgebraic >::success().

被这些函数引用 __attribute__(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::append_exact_factor_roots(), LMCAS::detail::definite::boundary_checked(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_surd(), make_exact_real_algebraic() , 以及 LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::to_algebraic().

函数调用图:

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

make_exact_root_id()

Result< ExactRootId > LMCAS::detail::make_exact_root_id	(	Polynomial< Rational >	polynomial,
		std::size_t	index,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_root.cpp 第 95 行定义.

                                {
    auto access = context.consume_steps(1, operation);
    if (!access) return Result<ExactRootId>::failure(access.error());
    try {
        polynomial.trim();
        if (polynomial.degree() <= 0) {
            return Result<ExactRootId>::failure(
                CasErrc::InvalidArgument,
                "RootOf requires a nonconstant exact rational polynomial",
                operation);
        }
        polynomial = polynomial.square_free_part().make_monic();
        polynomial.variable_name = "_root";
        if (polynomial.degree() <= 0 ||
            index >= static_cast<std::size_t>(polynomial.degree())) {
            return Result<ExactRootId>::failure(
                CasErrc::InvalidArgument,
                "RootOf index exceeds the number of distinct roots",
                operation);
        }
        return Result<ExactRootId>::success(
            ExactRootId{std::move(polynomial), index});
    } catch (const std::bad_alloc&) {
        return Result<ExactRootId>::failure(
            CasErrc::ResourceLimit,
            "RootOf canonicalization allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<ExactRootId>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, make_exact_root_id(), LMCAS::Polynomial< CoeffType >::make_monic(), operation, LMCAS::ResourceLimit, LMCAS::Polynomial< CoeffType >::square_free_part(), LMCAS::Result< T >::success(), LMCAS::Polynomial< CoeffType >::trim() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 make_exact_root_id() , 以及 LMCAS::make_rootof_checked().

函数调用图:

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

make_expression_ptr() [1/2]

std::shared_ptr<::LMCAS::SymbolicExpr > LMCAS::detail::make_expression_ptr ( const ::LMCAS::SymbolicExpr & expression )

inline

在文件 base.hpp 第 115 行定义.

                                         {
    return std::make_shared<::LMCAS::SymbolicExpr>(expression);
}

引用了 make_expression_ptr().

函数调用图:

make_expression_ptr() [2/2]

std::shared_ptr<::LMCAS::SymbolicExpr > LMCAS::detail::make_expression_ptr ( SymbolicNodePtr root )

inline

在文件 base.hpp 第 111 行定义.

                                                                                  {
    return SymbolicExprAccess::make_expression_ptr(std::move(root));
}

引用了 make_expression_ptr() , 以及 LMCAS::detail::SymbolicExprAccess::make_expression_ptr().

被这些函数引用 LMCAS::abs(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::abs_expression(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::ComplexProduct::accumulate(), LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), LMCAS::anonymous_namespace{poly_utils.cpp}::add_checked_coefficients(), LMCAS::add_fourier_harmonic(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_function_pattern(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_lambert_pattern(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_power_pattern(), LMCAS::alternating_sequence_bound(), LMCAS::analytic_continuation(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append_mixed_product(), LMCAS::expr_detail::ExprParser::apply_integral(), LMCAS::expr_detail::ExprParser::apply_limit(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::asymptotic_expand(), LMCAS::detail::definite::boundary_value_checked(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::build_product(), LMCAS::calculate_residue_impl(), LMCAS::calculus_utils_extract_denominator(), LMCAS::calculus_utils_extract_real_candidate(), LMCAS::calculus_utils_detail::calculus_utils_make_abs(), LMCAS::calculus_utils_oblique_from_rational(), LMCAS::calculus_utils_product(), LMCAS::calculus_utils_try_symbolic_definite(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_polynomial_gcd(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_variable(), LMCAS::equivalence_detail::canonicalize_complex_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_sum(), LMCAS::cauchy_integral_impl(), LMCAS::checked_derivative(), LMCAS::geometry_detail::checked_nonzero_numeric_or_exact(), LMCAS::anonymous_namespace{matrix_decomposition_cholesky.cpp}::cholesky_decomposition_impl(), LMCAS::christoffel_first_kind_impl(), LMCAS::christoffel_second_kind_impl(), LMCAS::clamp(), LMCAS::classify_first_order_ode(), LMCAS::classify_hessian_eigenvalues(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_function(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_power(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_sum(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_limit_result(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_power(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_sqrt(), classify_quadric_impl(), LMCAS::classify_ratio_limit(), LMCAS::classify_singular_point_checked(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::detail::inequality_support::close_symbolic_endpoint(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_constant(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), LMCAS::coefficient_power_radius(), LMCAS::collect_bernoulli_coefficients(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::collect_fraction_terms(), LMCAS::collect_oblique_asymptote(), LMCAS::collect_power_denominators(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::collect_transcendental_subexprs(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_finite_endpoint(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), LMCAS::complex(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::conjugate_checked(), constant_expression(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::constant_sum(), LMCAS::anonymous_namespace{poly_utils.cpp}::constant_to_poly(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::expr_detail::anonymous_namespace{expr_parser_construction.cpp}::construct_expression(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_point_value(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::convert_basis_polynomial(), LMCAS::polynomial_solver_detail::convert_to_rational_poly(), LMCAS::cross_product_impl(), LMCAS::vector_calculus_detail::curl_impl(), LMCAS::curvature_checked(), LMCAS::curvature_parametric_checked(), LMCAS::curve_integral_scalar(), LMCAS::curve_integral_vector(), LMCAS::detail::transcendental::decompose_trig_exp_pattern(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::definite_integral_geometry_checked(), LMCAS::detect_parity(), LMCAS::detect_substitution(), LMCAS::detect_trans_substitutions(), LMCAS::detail::inequality_support::determine_leading_sign(), LMCAS::differential(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::differentiate_geometry_checked(), LMCAS::differentiate_if_dependent(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::differentiate_surface_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::distinct_denominator_product(), LMCAS::vector_calculus_detail::divergence_impl(), LMCAS::divergence_theorem(), domain_constraints(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root(), LMCAS::dot_product_impl(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace(), LMCAS::eliminate_parametric_column(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), equation_predicate(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equation_residual(), LMCAS::essential_exponent(), LMCAS::essential_laurent(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_components(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_exponent(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_node(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::detail::matrix_api::exact_matrix_data(), LMCAS::detail::matrix_api::exact_matrix_expression(), LMCAS::detail::matrix_decomposition::exact_number_expr(), LMCAS::detail::inequality_support::exact_numeric_sign(), LMCAS::equivalence_detail::expand_equivalence(), LMCAS::expr_match(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_component(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_term(), LMCAS::extract_bernoulli_factor(), LMCAS::extract_coefficient(), LMCAS::extract_constant_term(), LMCAS::extract_laurent_regular_part(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_mixed_coefficients(), LMCAS::factor_common_polynomial(), LMCAS::factor_numeric_content(), LMCAS::factor_rational_univariate(), LMCAS::factor_symbolic_quadratic(), LMCAS::factor_transcendental_expression(), LMCAS::find_extrema_impl(), LMCAS::find_integrating_factor_impl(), LMCAS::find_parametric_pivot(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::finish_cancellation(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::finite_numeric_coeff(), LMCAS::fourier_constant_coefficient(), LMCAS::fourier_series_checked(), LMCAS::anonymous_namespace{symbolic_set.cpp}::from_nodes(), LMCAS::function(), LMCAS::vector_calculus_detail::gradient_impl(), LMCAS::gram_schmidt(), LMCAS::greens_theorem(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), LMCAS::vector_calculus_detail::hessian_impl(), LMCAS::imag_part_checked(), LMCAS::implicit_diff(), LMCAS::inflection_curve_defined(), LMCAS::inflection_points_checked(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_even_case(), LMCAS::integrate_multiple_checked(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_odd_case(), integrate_power_primitive(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_sec_power(), LMCAS::integrating_factor_from_antiderivative(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_differential_factor(), LMCAS::inverse_branch_derivative(), LMCAS::inverse_fourier_transform_core(), LMCAS::inverse_laplace_core(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::inverse_trig(), LMCAS::detail::transcendental::invert_exp_base(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::invert_lambert_w(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::is_analytic_impl(), LMCAS::is_bernoulli_ode(), LMCAS::is_euler_equation(), LMCAS::is_exact_ode(), LMCAS::is_homogeneous_ode(), LMCAS::is_linear_first_order(), LMCAS::is_nonreal_sqrt(), LMCAS::isolate_linear_coeff(), LMCAS::vector_calculus_detail::jacobian_impl(), LMCAS::kronecker(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::lambert_inner(), LMCAS::transform_detail::laplace_transform_core(), LMCAS::vector_calculus_detail::laplacian_impl(), LMCAS::laurent_series_checked(), LMCAS::laurent_series_full_checked(), LMCAS::laurent_series_full_impl(), LMCAS::lie_derivative_impl(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::linear_interval(), LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_reduced_expression(), LMCAS::integration_table_detail::load_algebraic_elementary_rules(), LMCAS::integration_table_detail::load_algebraic_radicals_rules(), LMCAS::integration_table_detail::load_algebraic_reciprocals_rules(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_exponential_rules(), LMCAS::integration_table_detail::load_exponential_trig_rules(), LMCAS::integration_table_detail::load_hyperbolic_rules(), LMCAS::integration_table_detail::load_inverse_trig_rules(), LMCAS::integration_table_detail::load_logarithmic_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::integration_table_detail::load_scaled_radical_rules(), LMCAS::integration_table_detail::load_scaled_trig_rules(), LMCAS::integration_table_detail::load_trig_derivatives_rules(), LMCAS::integration_table_detail::load_trig_primitives_rules(), LMCAS::integration_table_detail::load_trig_squares_rules(), LMCAS::log_differentiate(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), LMCAS::anonymous_namespace{expr_facade.cpp}::logical_expression(), LMCAS::lookup_integral(), LMCAS::make_abs(), make_expression_ptr(), make_expression_ptr(), LMCAS::make_interval(), LMCAS::make_membership(), LMCAS::anonymous_namespace{quantity.cpp}::make_quantity(), LMCAS::make_rootof_checked(), make_rootof_solutions_impl(), LMCAS::make_unary_function(), LMCAS::expr_detail::expr_common::make_unary_function_expr(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::matrix_axis_sum(), LMCAS::matrix_characteristic_polynomial_checked(), matrix_eigenspaces_checked(), LMCAS::matrix_eigenvalues_checked(), LMCAS::matrix_exp(), LMCAS::matrix_log(), LMCAS::matrix_multiply_checked(), LMCAS::matrix_norm(), LMCAS::matrix_solve_linear_checked(), LMCAS::matrix_trace(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::maximum_axis_sum(), mixed_evaluate_at(), mixed_numerical_path(), LMCAS::anonymous_namespace{poly_utils.cpp}::multiply_checked_coefficients(), LMCAS::solver_detail::multiply_no_expand(), LMCAS::multipoly_to_symbolic(), LMCAS::multivariate_factor_expression(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), LMCAS::equivalence_detail::normalize_equivalence(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::opposite_exponential_lambert_pattern(), LMCAS::ordinary_frobenius_solution(), LMCAS::ordinary_taylor_coefficients(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_basis(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_input_polynomials(), LMCAS::parametric_linear_solution(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::polynomial_logic(), LMCAS::polynomial_relation(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::positive_log_argument(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::power_pattern(), LMCAS::power_series_add(), LMCAS::power_series_compose_checked(), LMCAS::power_series_multiply_checked(), LMCAS::prepare_fourier_period(), LMCAS::product_without_factor(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::propagate(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_exact_root_residual(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_normalized_residual(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_piecewise_residual(), LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::qr_decomposition_impl(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::quadratic_coefficients(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign(), LMCAS::quadratic_form_matrix(), LMCAS::ratio_convergence_test(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::rational_polynomial_expression(), LMCAS::rational_root_factors(), LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_rational(), LMCAS::real_part_checked(), LMCAS::recognize_regular_laurent(), LMCAS::reconstruct_rational_root_factors(), LMCAS::reconstruct_rational_roots(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstructs_expression(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::reduce_fraction(), LMCAS::relation(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::require(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_absolute(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_exp_log_function(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_negative_lambert_exponential(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_square_absolute(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_function(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_sum(), LMCAS::equivalence_detail::rewritten_complex(), LMCAS::riemann_curvature_tensor_with_inverse(), LMCAS::detail::NumericEvaluator::root(), LMCAS::detail::inequality_support::root_less_than(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_power_sign(), LMCAS::detail::inequality_support::roots_equal(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::run(), LMCAS::scalar_project_impl(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::separable_reciprocal(), LMCAS::sequence_extreme_limit(), LMCAS::series_abs(), LMCAS::series_negate(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_sqrt_pi(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::sign_condition(), LMCAS::geometry_detail::simplify_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::simplify_exact_rational_expr(), LMCAS::detail::matrix_kernel::simplify_expr(), LMCAS::simplify_finite_limit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::simplify_geometry_checked(), LMCAS::singular_frobenius_solution(), LMCAS::singular_taylor_coefficients(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::skew_distance_from_directions(), LMCAS::solve_bernoulli_ode_impl(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), LMCAS::solve_closed_form_from_poly(), LMCAS::solve_closed_form_poly(), LMCAS::solve_complex_nth_root_checked(), LMCAS::solve_constant_inequality(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), LMCAS::solve_degenerate_cubic(), LMCAS::solve_equation(), LMCAS::solve_euler_ode_checked(), LMCAS::solve_euler_ode_impl(), LMCAS::solve_exact_factor(), LMCAS::solve_exact_ode_impl(), LMCAS::solve_higher_order_ode_checked(), LMCAS::solve_higher_order_ode_impl(), LMCAS::solve_homogeneous_ode_impl(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_initial_guess(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial(), LMCAS::solve_lagrange_strict(), LMCAS::solve_linear2_homogeneous(), LMCAS::solver_detail::solve_linear_system_impl(), LMCAS::solve_product_factor(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), LMCAS::solve_separable_ode(), LMCAS::solve_set_core(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::solve_single_equation(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::solve_symbolic_polynomial_set(), LMCAS::solve_symbolic_quadratic(), LMCAS::solve_transcendental(), LMCAS::solve_variation_of_parameters_core(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::specialize_absolute(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::squared_profile(), LMCAS::stokes_theorem(), LMCAS::strip_unit(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitute_candidate(), LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series(), substitute_raw(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive(), LMCAS::surface_area_revolution_x_checked(), LMCAS::surface_area_revolution_y_checked(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_at_point_checked(), LMCAS::surface_integral_scalar(), LMCAS::surface_integral_vector(), LMCAS::sym_sub(), LMCAS::symbolic_cubic_roots(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), LMCAS::anonymous_namespace{irrational_symbolic.cpp}::symbolic_named_power(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_point_plane_distance(), LMCAS::symbolic_poly_to_expr(), LMCAS::symbolic_product(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::polynomial_solver_detail::symbolic_quartic_roots(), LMCAS::symbolic_sum(), LMCAS::te_abs_decay(), LMCAS::te_abs_fourier(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_atomic_gaussian_rate(), LMCAS::te_convolve_core(), LMCAS::te_convolve_sum(), LMCAS::te_decay_condition(), LMCAS::te_extract_exp(), LMCAS::te_fourier_sum(), LMCAS::te_fourier_unevaluated(), LMCAS::te_gaussian_fourier(), LMCAS::transform_detail::te_gt_condition(), LMCAS::te_inv_power(), LMCAS::te_inv_product(), LMCAS::te_inverse_pole_term(), LMCAS::te_laplace_sum(), LMCAS::transform_detail::te_linear_coefficient(), LMCAS::transform_detail::te_split_coeff(), LMCAS::te_unevaluated_inv_laplace(), LMCAS::te_unevaluated_laplace(), LMCAS::tf_back_substitute(), LMCAS::tf_build_polynomial_impl(), LMCAS::tf_detect_exponential_separation(), LMCAS::tf_detect_multiplicative_structure(), LMCAS::tf_simplify_pythagorean(), LMCAS::solver_detail::to_ptr(), LMCAS::total_differential(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::expr_detail::ExprParser::uninterpreted_function(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::unwrap_trig_negated_argument(), LMCAS::groebner_detail::PolyBuilder::use_numeric_function(), LMCAS::validate_frobenius_regular_singular_domain(), LMCAS::vector_angle_symbolic_impl(), LMCAS::vector_calculus_constant_integrand(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict(), LMCAS::vector_calculus_evaluate_hessian_at_point(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_magnitude_squared(), LMCAS::vector_calculus_multiple_integral_strict(), LMCAS::vector_calculus_numerical_definite(), LMCAS::vector_calculus_detail::vector_calculus_simplify_strict(), LMCAS::vector_calculus_single_dir_deriv(), LMCAS::vector_calculus_substitute_coords_strict(), LMCAS::vector_calculus_try_definite(), LMCAS::vector_dot_checked(), LMCAS::vector_project_impl(), LMCAS::verified_quadratic_boundaries(), LMCAS::verified_real_inverse_candidates(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_identity(), LMCAS::verify_lagrange_solutions(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::visit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_reduce_rational(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational(), LMCAS::z_transform_core(), LMCAS::zt_abs_expr(), LMCAS::zt_exponential(), LMCAS::zt_is_exp_seq(), LMCAS::zt_is_weighted_exp(), LMCAS::zt_polynomial(), LMCAS::zt_roc(), LMCAS::zt_sum(), LMCAS::zt_trigonometric() , 以及 LMCAS::zt_unevaluated().

函数调用图:

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

make_integration_entries()

std::vector< IntegrationEntry > LMCAS::detail::make_integration_entries

(

)

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

                                                       {
    std::vector<IntegrationEntry> entries;
    integration_table_detail::load_exponential_rules(entries);
    integration_table_detail::load_trig_derivatives_rules(entries);
    integration_table_detail::load_trig_squares_rules(entries);
    integration_table_detail::load_trig_primitives_rules(entries);
    integration_table_detail::load_inverse_trig_rules(entries);
    integration_table_detail::load_hyperbolic_rules(entries);
    integration_table_detail::load_algebraic_elementary_rules(entries);
    integration_table_detail::load_algebraic_radicals_rules(entries);
    integration_table_detail::load_algebraic_reciprocals_rules(entries);
    integration_table_detail::load_polynomial_rules(entries);
    integration_table_detail::load_logarithmic_rules(entries);
    integration_table_detail::load_exponential_base_rules(entries);
    integration_table_detail::load_scaled_radical_rules(entries);
    integration_table_detail::load_scaled_trig_rules(entries);
    integration_table_detail::load_exponential_trig_rules(entries);
    std::stable_sort(entries.begin(), entries.end(),
        [](const IntegrationEntry& a, const IntegrationEntry& b) {
            return a.priority < b.priority;
        });
    return entries;
}

引用了 LMCAS::a, LMCAS::b, LMCAS::integration_table_detail::load_algebraic_elementary_rules(), LMCAS::integration_table_detail::load_algebraic_radicals_rules(), LMCAS::integration_table_detail::load_algebraic_reciprocals_rules(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_exponential_rules(), LMCAS::integration_table_detail::load_exponential_trig_rules(), LMCAS::integration_table_detail::load_hyperbolic_rules(), LMCAS::integration_table_detail::load_inverse_trig_rules(), LMCAS::integration_table_detail::load_logarithmic_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::integration_table_detail::load_scaled_radical_rules(), LMCAS::integration_table_detail::load_scaled_trig_rules(), LMCAS::integration_table_detail::load_trig_derivatives_rules(), LMCAS::integration_table_detail::load_trig_primitives_rules(), LMCAS::integration_table_detail::load_trig_squares_rules() , 以及 make_integration_entries().

被这些函数引用 make_integration_entries().

函数调用图:

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

make_node()

template<typename Node, typename... Args>

std::shared_ptr< const Node > LMCAS::detail::make_node

(

Args &&...

args

)

在文件 base.hpp 第 123 行定义.

                                                    {
    static_assert(std::is_base_of<SymbolicNode, Node>::value,
                  "make_node only constructs SymbolicNode implementations");
    return std::shared_ptr<const Node>(
        new Node(std::forward<Args>(args)...));
}

引用了 make_node().

被这些函数引用 LMCAS::anonymous_namespace{matrix_decomposition.cpp}::abs_expression(), LMCAS::add_number_nodes(), LMCAS::add_numbers(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append_mixed_product(), LMCAS::expr_detail::ExprParser::apply_integral(), LMCAS::expr_detail::ExprParser::apply_limit(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::build_product(), LMCAS::calculus_utils_extract_denominator(), LMCAS::calculus_utils_detail::calculus_utils_make_abs(), LMCAS::calculus_utils_product(), LMCAS::cauchy_integral_impl(), LMCAS::clamp(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::classify_fraction_factor(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_function(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_sum(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::AddNode::clone(), LMCAS::ComplexNode::clone(), LMCAS::FiniteSetNode::clone(), LMCAS::FunctionNode::clone(), LMCAS::IntegralNode::clone(), LMCAS::IntervalNode::clone(), LMCAS::LimitNode::clone(), LMCAS::LogicalNode::clone(), LMCAS::MatrixNode::clone(), LMCAS::MembershipNode::clone(), LMCAS::MultiplyNode::clone(), LMCAS::NumberNode::clone(), LMCAS::PiecewiseNode::clone(), LMCAS::PowerNode::clone(), LMCAS::ProductNode::clone(), LMCAS::QuantifierNode::clone(), LMCAS::QuantityNode::clone(), LMCAS::RelationalNode::clone(), LMCAS::RootOfNode::clone(), LMCAS::SetBuilderNode::clone(), LMCAS::SummationNode::clone(), LMCAS::TransformNode::clone(), LMCAS::UninterpretedFunctionNode::clone(), LMCAS::VariableNode::clone(), LMCAS::anonymous_namespace{poly_utils.cpp}::coefficient_arithmetic(), LMCAS::coefficient_power_radius(), LMCAS::NormalizationVisitor::collect_sum(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::anonymous_namespace{integration_linearity.cpp}::combine_integration_exponentials(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::compound_node(), constant_expression(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::constant_sum(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_complex(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_power(), LMCAS::SymbolicFactory::create_variable(), LMCAS::InferenceEngine::Impl::deduce_function_relation(), LMCAS::InferenceEngine::Impl::deduce_power_relations(), LMCAS::denominator_factor(), LMCAS::DifferentiationVisitor::differentiate_atan2(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::elementary_outer(), equation_predicate(), LMCAS::detail::matrix_api::exact_matrix_expression(), LMCAS::detail::matrix_decomposition::exact_number_expr(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::extract_small_square_factor(), LMCAS::NormalizationVisitor::extract_term_coefficient(), LMCAS::factor_common_polynomial(), LMCAS::factor_numeric_content(), LMCAS::factor_rational_univariate(), LMCAS::factor_symbolic_quadratic(), LMCAS::factor_transcendental_expression(), LMCAS::NormalizationVisitor::finish_squared_norm(), LMCAS::expr_detail::ExprParser::finite_set(), LMCAS::anonymous_namespace{symbolic_set.cpp}::from_nodes(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::function(), LMCAS::function(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::function_at_zero(), LMCAS::expr_detail::ExprParser::function_node(), LMCAS::NormalizationVisitor::fuse_matrix_product(), LMCAS::MatrixNode::get(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::half_numeric_power(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::halves_pi(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::hyperbolic_outer(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::integer_numeric_power(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::integer_pi(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_even_case(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_odd_case(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_sec_power(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_differential_factor(), LMCAS::expr_detail::ExprParser::interval(), LMCAS::interval_to_expr(), LMCAS::inverse_fourier_transform_core(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::inverse_trig(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::inverse_trigonometric_outer(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked(), LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_reduced_expression(), LMCAS::InferenceEngine::Impl::logarithm_sign(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::logarithmic_outer(), LMCAS::expr_detail::ExprParser::logical(), LMCAS::anonymous_namespace{expr_facade.cpp}::logical_expression(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::make(), LMCAS::make_abs(), LMCAS::make_interval(), LMCAS::make_membership(), make_node(), LMCAS::make_normalized_multiply_node(), LMCAS::anonymous_namespace{quantity.cpp}::make_quantity(), LMCAS::make_rootof_checked(), make_rootof_solutions_impl(), LMCAS::make_unary_function(), LMCAS::expr_detail::expr_common::make_unary_function_expr(), materialize_integral(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::matrix(), LMCAS::anonymous_namespace{normalization_matrices.cpp}::matrix_element(), LMCAS::matrix_multiply_checked(), LMCAS::NormalizationVisitor::matrix_product_element(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::maximum_axis_sum(), LMCAS::expr_detail::ExprParser::membership(), LMCAS::solver_detail::multiply_no_expand(), LMCAS::multiply_number_nodes(), LMCAS::multiply_numbers(), LMCAS::multivariate_factor_expression(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::node(), LMCAS::normalization_exact_square_root(), LMCAS::normalization_imaginary_power(), LMCAS::normalization_numeric_function(), LMCAS::NormalizationVisitor::normalize_function_parity(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_matrix_product(), LMCAS::NormalizationVisitor::normalize_matrix_sum(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::NormalizationVisitor::normalize_nested_power(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::anonymous_namespace{normalization_norms.cpp}::normalized_norm_argument(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::numeric_absolute(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::numeric_lambert_w(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::numeric_square_root(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::parse_conditional_relation(), LMCAS::assumption_detail::parse_finite_number_node(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::piecewise(), LMCAS::polynomial_logic(), LMCAS::polynomial_relation(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::positive_denominator_exponent(), LMCAS::anonymous_namespace{normalization_signs.cpp}::positive_negative_number(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::power(), LMCAS::power_series_multiply_checked(), LMCAS::prepare_fourier_period(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::product_without(), LMCAS::product_without_factor(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::quantity(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::quarters_pi(), LMCAS::ratio_convergence_test(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::reciprocal_exact_number(), LMCAS::anonymous_namespace{symbolic_ode.cpp}::reciprocal_on_regular_region(), LMCAS::reconstruct_rational_root_factors(), LMCAS::reconstruct_rational_roots(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::register_new_atom(), LMCAS::relation(), LMCAS::expr_detail::ExprParser::relational(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::SubstNodeVisitor::replace(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::rewrite_exp_as_u_power(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_exp_log_function(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_negative_lambert_exponential(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_radical(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_function(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::root_of(), LMCAS::scale_integral_field(), LMCAS::NormalizationVisitor::scale_matrix(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::scaled_function(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::scaled_radical(), LMCAS::series_abs(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_sqrt_pi(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::sign_condition(), LMCAS::NormalizationVisitor::simplify_assumed_absolute(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::simplify_pythagorean_sum(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::sixths_pi(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::skew_distance_from_directions(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::small_exact_power(), LMCAS::solve_complex_nth_root_checked(), LMCAS::solve_separable_ode(), LMCAS::solve_symbolic_quadratic(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::special_outer(), LMCAS::substitute_negative_variable(), LMCAS::surface_area_revolution_x_checked(), LMCAS::surface_area_revolution_y_checked(), LMCAS::anonymous_namespace{irrational_symbolic.cpp}::symbolic_named_power(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_point_plane_distance(), LMCAS::symbolic_product(), LMCAS::symbolic_sum(), LMCAS::te_convolve_core(), LMCAS::te_fourier_unevaluated(), LMCAS::te_gaussian_fourier(), LMCAS::transform_detail::te_gt_condition(), LMCAS::te_inv_power(), LMCAS::te_inv_product(), LMCAS::transform_detail::te_split_coeff(), LMCAS::te_unevaluated_inv_laplace(), LMCAS::te_unevaluated_laplace(), LMCAS::tf_detect_exponential_separation(), LMCAS::tf_extract_coeff_trig_squared(), LMCAS::tf_remove_exp_factor(), LMCAS::tf_simplify_pythagorean_node(), LMCAS::tf_substitute_expr(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::thirds_pi(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::trig_square(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::trigonometric_outer(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::expr_detail::ExprParser::uninterpreted_function(), LMCAS::anonymous_namespace{integration_definite.cpp}::unresolved_integral(), LMCAS::groebner_detail::PolyBuilder::use_numeric_function(), LMCAS::vector_angle_symbolic_impl(), LMCAS::vector_dot_checked(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::visit(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace(), LMCAS::zt_abs_expr() , 以及 LMCAS::zt_unevaluated().

函数调用图:

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

make_rootof_solutions_impl()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::detail::make_rootof_solutions_impl	(	const Polynomial< SymbolicPolyCoeff > &	polynomial,
		const std::string &	variable,
		ComputationContext &	context )

在文件 root_of_identity.cpp 第 103 行定义.

                                                       {
    if (poly.degree() <= 0) return {};
    auto polynomial_expression = symbolic_poly_to_expr(poly, context);
    auto recognized = recognize_rational_polynomial(
        *polynomial_expression, var, context);
    if (!recognized) throw recognized.error();
    if (!recognized.value()) return {};
    auto canonical = recognized.value()->square_free_part().make_monic();
    canonical.variable_name = "_root";
    std::vector<std::shared_ptr<SymbolicExpr>> solutions;
    solutions.reserve(static_cast<std::size_t>(canonical.degree()));
    for (int index = 0; index < canonical.degree(); ++index) {
        solutions.push_back(LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<RootOfNode>(
                detail::ExactRootId{
                    canonical, static_cast<std::size_t>(index)},
                var)));
    }
    return solutions;
}

引用了 context, LMCAS::Polynomial< CoeffType >::degree(), make_expression_ptr(), make_node(), LMCAS::recognize_rational_polynomial() , 以及 LMCAS::symbolic_poly_to_expr().

被这些函数引用 LMCAS::append_factor_solutions(), LMCAS::make_rootof_solutions() , 以及 LMCAS::polynomial_solver_detail::solve_by_factoring_impl().

函数调用图:

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

materialize_integral()

SymbolicExpr LMCAS::detail::materialize_integral	(	const IntegralParts &	parts,
		const std::string &	variable,
		RewriteBudget &	budget )

在文件 integrator.cpp 第 13 行定义.

                                                                                  {
    const auto* primitive = dynamic_cast<const PiecewiseNode*>(node(parts.primitive).get());
    const auto* remainder = dynamic_cast<const PiecewiseNode*>(node(parts.remainder).get());
    if (primitive && remainder) {
        std::vector<PiecewiseNode::Branch> branches;
        branches.reserve(primitive->branches().size());
        for (std::size_t i = 0; i < primitive->branches().size(); ++i) {
            budget.consume();
            auto branch = materialize_integral({
                expression_from_node(primitive->branches()[i].expression),
                expression_from_node(remainder->branches()[i].expression)}, variable, budget);
            branches.push_back({node(branch), primitive->branches()[i].condition});
        }
        SymbolicNodePtr fallback;
        if (primitive->default_expr()) {
            fallback = node(materialize_integral({expression_from_node(primitive->default_expr()),
                expression_from_node(remainder->default_expr())}, variable, budget));
        }
        auto result = make_node<PiecewiseNode>(std::move(branches), fallback);
        budget.measure(result);
        return expression_from_node(result);
    }
    if (is_zero(parts.remainder)) { return parts.primitive; }
    auto integral = make_node<IntegralNode>(node(parts.remainder), variable);
    if (is_zero(parts.primitive)) { return expression_from_node(integral); }
    return expression_from_node(SymbolicFactory::create_add(
        {node(parts.primitive), integral}, &budget));
}

引用了 budget, LMCAS::detail::RewriteBudget::consume(), LMCAS::SymbolicFactory::create_add(), expression_from_node(), make_node(), materialize_integral(), LMCAS::detail::RewriteBudget::measure(), node(), LMCAS::detail::IntegralParts::primitive, LMCAS::detail::IntegralParts::remainder , 以及 variable.

被这些函数引用 materialize_integral().

函数调用图:

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

matrix_eigenspaces_checked()

Result< std::vector< std::pair< ExprPtr, std::vector< std::vector< ExprPtr > > > > > LMCAS::detail::matrix_eigenspaces_checked	(	const ExprPtr &	matrix,
		ComputationContext &	context )

在文件 symbolic_matrix_eigen.cpp 第 200 行定义.

                                                                                    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    using SpacesResult = Result<Eigenspaces>;
    constexpr const char* operation = "matrix_eigenspaces";
    auto matrix_result = require_square_matrix(A, context, operation);
    if (!matrix_result) { return SpacesResult::failure(matrix_result.error()); }
    auto eigenvalues = matrix_eigenvalues_checked(A, context);
    if (!eigenvalues) { return SpacesResult::failure(eigenvalues.error()); }
    const auto& matrix = *matrix_result.value();
    Eigenspaces spaces;
    AssumptionContext assumptions;
    detail::AssumptionFacts facts(context.assumptions() ? *context.assumptions() : assumptions);
    try {
        for (const auto& eigenvalue : eigenvalues.value()) {
            auto lambda = detail::make_expression_ptr(detail::normalize_node(detail::node(eigenvalue), transform_budget));
            auto duplicate = eigenvalue_already_collected(lambda, spaces, context, facts);
            if (!duplicate) { return SpacesResult::failure(duplicate.error()); }
            if (duplicate.value()) { continue; }
            auto nullspace = eigenvalue_nullspace(matrix, lambda, context);
            if (!nullspace) { return SpacesResult::failure(nullspace.error()); }
            spaces.emplace_back(std::move(lambda), std::move(nullspace.value()));
        }
        return SpacesResult::success(std::move(spaces));
    } catch (const std::bad_alloc&) {
        return SpacesResult::failure(CasErrc::ResourceLimit,
            "allocation failed while computing eigenspaces", operation);
    } catch (const std::length_error& error) { return Result<std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>>::failure(CasErrc::ResourceLimit, error.what(), "matrix_eigenspaces"); } catch (const std::exception& ex) {
        return SpacesResult::failure(CasErrc::InternalInvariant, ex.what(), operation);
    }
} catch (const CasError& error) {
    return Result<std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>>::failure(CasErrc::ResourceLimit, "allocation failed", "matrix_eigenspaces");
} catch (const std::length_error& error) {
    return Result<std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>>::failure(CasErrc::ResourceLimit, error.what(), "matrix_eigenspaces");
} catch (const std::exception& error) {
    return Result<std::vector<std::pair<ExprPtr, std::vector<std::vector<ExprPtr>>>>>::failure(CasErrc::InternalInvariant, error.what(), "matrix_eigenspaces");
}

引用了 context, facts, LMCAS::InternalInvariant, make_expression_ptr(), LMCAS::matrix_eigenvalues_checked(), node(), normalize_node(), operation, LMCAS::detail::matrix_api::require_square_matrix() , 以及 LMCAS::ResourceLimit.

被这些函数引用 LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::diagonalization_checked() , 以及 LMCAS::matrix_eigenvectors_checked().

函数调用图:

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

mixed_evaluate_at()

lmmc_real_t LMCAS::detail::mixed_evaluate_at	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		lmmc_real_t	x,
		RewriteBudget &	budget )

在文件 mixed_transcendental_evaluation.cpp 第 10 行定义.

                                                                {
    auto substituted = make_expression_ptr(substitute_node(
        node(expr), var, node(SymbolicExpr::number(static_cast<double>(x))), budget));
    auto value = try_finite_numeric(*substituted, budget.context());
    return value ? static_cast<lmmc_real_t>(*value)
                 : std::numeric_limits<lmmc_real_t>::quiet_NaN();
}

引用了 budget, LMCAS::detail::RewriteBudget::context(), make_expression_ptr(), mixed_evaluate_at(), node(), substitute_node(), try_finite_numeric() , 以及 LMCAS::value.

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_value(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::evaluate(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::initialize(), mixed_evaluate_at(), mixed_evaluate_with_retry(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::newton(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::polish_value(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::process() , 以及 LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::subdivide().

函数调用图:

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

mixed_evaluate_with_retry()

lmmc_real_t LMCAS::detail::mixed_evaluate_with_retry	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		lmmc_real_t	x,
		lmmc_real_t	half_width,
		RewriteBudget &	budget,
		int	max_retries = 3 )

在文件 mixed_transcendental_evaluation.cpp 第 20 行定义.

                                                                    {
    auto value = mixed_evaluate_at(expr, var, x, budget);
    if (!std::isnan(value)) { return value; }
    auto offset = half_width;
    for (int i = 0; i < max_retries; ++i) {
        offset *= 0.5;
        value = mixed_evaluate_at(expr, var, x + offset, budget);
        if (!std::isnan(value)) { return value; }
        value = mixed_evaluate_at(expr, var, x - offset, budget);
        if (!std::isnan(value)) { return value; }
    }
    return std::numeric_limits<lmmc_real_t>::quiet_NaN();
}

引用了 budget, mixed_evaluate_at(), mixed_evaluate_with_retry() , 以及 LMCAS::value.

被这些函数引用 mixed_evaluate_with_retry() , 以及 LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::sample().

函数调用图:

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

mixed_numerical_path()

Result< std::vector< NumericRoot > > LMCAS::detail::mixed_numerical_path	(	const std::shared_ptr< SymbolicExpr > &	factor,
		const std::string &	var,
		const SearchInterval &	interval,
		const SolveOptions &	opts,
		RewriteBudget &	budget,
		bool &	complete )

隔离并精化单个因子的数值根。

计算导数后用 isolate_roots 隔离根，再用 refine_root 逐根精化。

参数

[in]	factor	待求解因子表达式
[in]	var	变量名
[in]	interval	搜索区间
[in]	opts	求解选项

返回

精化后的数值根列表

在文件 mixed_transcendental_numeric.cpp 第 20 行定义.

{
    std::vector<NumericRoot> roots;
    std::shared_ptr<SymbolicExpr> derivative;
    try {
        if (factor && LMCAS::detail::node(factor)) {
            derivative = make_expression_ptr(
                differentiate_node(node(factor), var, budget));
        }
    } catch (const CasError& error) {
        if (error.code != CasErrc::UnsupportedExpression) throw;
        complete = false;
    }
    complete = false;
    std::optional<CasError> failure;
    auto intervals = isolate_roots_with_context(
        factor, derivative, var, interval, opts,
        budget, &failure, &complete);
    if (failure) {
        return Result<std::vector<NumericRoot>>::failure(*failure);
    }
 
    for (const auto& isolated : intervals) {
        auto refined = refine_root_with_context(
            factor, derivative, var, isolated, opts,
            budget, &failure, &complete);
        if (failure) {
            return Result<std::vector<NumericRoot>>::failure(*failure);
        }
        if (refined) {
            roots.push_back(*refined);
        }
    }
    return Result<std::vector<NumericRoot>>::success(std::move(roots));
}

引用了 budget, LMCAS::CasError::code, differentiate_node(), LMCAS::interval(), isolate_roots_with_context(), make_expression_ptr(), mixed_numerical_path(), node(), refine_root_with_context(), LMCAS::roots() , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 mixed_numerical_path() , 以及 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_factor().

函数调用图:

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

multiply_expression_factors()

std::shared_ptr< SymbolicExpr > LMCAS::detail::multiply_expression_factors ( const std::vector< std::shared_ptr< SymbolicExpr > > & factors )

inline

在文件 multivariate_conversion.hpp 第 27 行定义.

                                                           {
    auto expression = factors.empty()
        ? SymbolicExpr::number(1)
        : factors.front();
    for (std::size_t index = 1; index < factors.size(); ++index) {
        expression = SymbolicExpr::multiply(expression, factors[index]);
    }
    return expression;
}

引用了 multiply_expression_factors().

被这些函数引用 multiply_expression_factors(), multipoly_term_to_expression() , 以及 LMCAS::anonymous_namespace{symbolic_gcd.cpp}::polynomial_term_to_expression().

函数调用图:

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

multipoly_term_factors()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::detail::multipoly_term_factors ( const Monomial & monomial, const Rational & coefficient, const std::vector< std::string > & variables )

inline

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

                                           {
    std::vector<std::shared_ptr<SymbolicExpr>> factors;
    if (coefficient != Rational(1) || total_degree(monomial) == 0) {
        factors.push_back(SymbolicExpr::number(coefficient));
    }
    for (std::size_t index = 0;
         index < variables.size() && index < monomial.size(); ++index) {
        if (monomial[index] == 0) continue;
        auto variable = SymbolicExpr::variable(variables[index]);
        factors.push_back(monomial[index] == 1
            ? variable
            : SymbolicExpr::power(
                  variable, SymbolicExpr::number(monomial[index])));
    }
    return factors;
}

引用了 multipoly_term_factors(), LMCAS::total_degree() , 以及 variable.

被这些函数引用 multipoly_term_factors(), multipoly_term_to_expression() , 以及 LMCAS::anonymous_namespace{symbolic_gcd.cpp}::polynomial_term_to_expression().

函数调用图:

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

multipoly_term_to_expression()

std::shared_ptr< SymbolicExpr > LMCAS::detail::multipoly_term_to_expression ( const Monomial & monomial, const Rational & coefficient, const std::vector< std::string > & variables )

inline

在文件 multivariate_conversion.hpp 第 38 行定义.

                                           {
    return multiply_expression_factors(
        multipoly_term_factors(monomial, coefficient, variables));
}

引用了 multiply_expression_factors(), multipoly_term_factors() , 以及 multipoly_term_to_expression().

被这些函数引用 multipoly_term_to_expression() , 以及 LMCAS::multipoly_to_symbolic().

函数调用图:

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

no_facts()

const FactsQuery & LMCAS::detail::no_facts ( )

noexcept

在文件 facts_query_adapters.cpp 第 96 行定义.

                                      {
    static const NoFacts facts;
    return facts;
}

引用了 facts , 以及 no_facts().

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::check_constant_factor(), LMCAS::anonymous_namespace{poly_utils.cpp}::check_zero_power_base(), compare_pointwise_values(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), LMCAS::SymbolicFactory::create_power(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::filter_denominators(), LMCAS::inflection_points_checked(), integrate_power_primitive(), LMCAS::detail::transcendental::invert_function(), LMCAS::limit_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::linear_interval(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::matrix_multiply_checked(), no_facts(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), LMCAS::NormalizationVisitor::normalize_bound_body(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parameter_constraint(), LMCAS::parametric_nonzero_value(), LMCAS::prepare_fourier_period(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_normalized_residual(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients(), LMCAS::solve_symbolic_polynomial_set(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::square_relation(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::substitute_basis(), LMCAS::integration_table_detail::u_is_real_var(), LMCAS::integration_table_detail::u_is_var_a_nonzero(), LMCAS::ExpandVisitor::visit() , 以及 LMCAS::ExpandVisitor::visit().

函数调用图:

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

node() [1/3]

const SymbolicNodePtr & LMCAS::detail::node ( const ::LMCAS::SymbolicExpr & expression )

inlinenoexcept

在文件 base.hpp 第 91 行定义.

                                                                                 {
    return SymbolicExprAccess::node(expression);
}

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

被这些函数引用 LMCAS::__attribute__(), LMCAS::abs(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::abs_expression(), LMCAS::detail::definite::absolute_argument(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::ComplexProduct::accumulate(), LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), LMCAS::anonymous_namespace{poly_utils.cpp}::add_checked_coefficients(), LMCAS::add_fourier_harmonic(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_lambert_pattern(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_power_pattern(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::alternating_sequence_bound(), LMCAS::analytic_continuation(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::append_condition(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::append_exact_factor_roots(), LMCAS::append_product_families(), LMCAS::expr_detail::ExprParser::apply_integral(), LMCAS::expr_detail::ExprParser::apply_limit(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::apply_root_representation_policy(), LMCAS::expr_detail::ExprParser::apply_rootof(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::asymptote_candidates(), LMCAS::asymptotic_expand(), LMCAS::detail::NumericEvaluator::atan2(), LMCAS::attach_unit(), LMCAS::attach_unit(), binder_view(), LMCAS::binding(), LMCAS::detail::definite::boundary_checked(), LMCAS::calculate_residue_checked(), LMCAS::calculate_residue_impl(), LMCAS::calculus_utils_detail::calculus_utils_expr_equal(), LMCAS::calculus_utils_extract_denominator(), LMCAS::calculus_utils_extract_real_candidate(), LMCAS::calculus_utils_detail::calculus_utils_is_infinity(), LMCAS::calculus_utils_detail::calculus_utils_make_abs(), LMCAS::calculus_utils_oblique_from_rational(), LMCAS::calculus_utils_split_rational(), LMCAS::calculus_utils_try_symbolic_definite(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_bounds(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_target(), LMCAS::calculus_utils_detail::calculus_utils_validate_two_exprs(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_polynomial_gcd(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_variable(), LMCAS::equivalence_detail::canonicalize_complex_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_sum(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::capture_free_integer_parameter(), LMCAS::cauchy_integral_checked(), LMCAS::cauchy_integral_impl(), LMCAS::detail::definite::certify_continuity_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::check_arguments(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::check_constant_factor(), LMCAS::check_equivalent(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::check_interval_forest(), LMCAS::check_zero_residual(), LMCAS::anonymous_namespace{quantity.cpp}::checked_binary(), LMCAS::checked_derivative(), LMCAS::query_detail::checked_expression_result(), LMCAS::query_detail::checked_expression_result(), LMCAS::anonymous_namespace{differential_geometry.cpp}::checked_geometry_expression(), LMCAS::checked_inference_result(), LMCAS::geometry_detail::checked_nonzero_numeric_or_exact(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::checked_piecewise(), checked_transform_expr(), LMCAS::anonymous_namespace{matrix_decomposition_cholesky.cpp}::cholesky_decomposition_impl(), LMCAS::christoffel_first_kind_impl(), LMCAS::christoffel_second_kind_impl(), LMCAS::clamp(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::classify_continuity_point_value(), classify_exact_zero(), LMCAS::classify_first_order_ode(), LMCAS::classify_hessian_eigenvalues(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_sum(), LMCAS::classify_inflection_candidates(), LMCAS::anonymous_namespace{integration_substitution.cpp}::classify_linear_wrapper(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_power(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_sqrt(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_value(), classify_quadric_impl(), LMCAS::classify_ratio_limit(), LMCAS::anonymous_namespace{residual_verification.cpp}::classify_residual(), LMCAS::classify_singular_point_checked(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::detail::inequality_support::close_symbolic_endpoint(), closed_rational_value(), closed_rational_value(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_constant(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), LMCAS::coefficient_power_radius(), LMCAS::collect_bernoulli_coefficients(), LMCAS::collect_exact_solutions(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::collect_fraction_terms(), LMCAS::detail::AssumptionFacts::collect_names(), LMCAS::collect_oblique_asymptote(), LMCAS::InferenceEngine::Impl::collect_power_exponents(), LMCAS::detail::definite::collect_predicate_roots(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_finite_endpoint(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), compare_pointwise_values(), LMCAS::expr_detail::expr_common::comparison_value(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::compatible_periodic_conditions(), LMCAS::complex(), LMCAS::complex_div_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_domain(), LMCAS::InferenceEngine::Impl::composite_integer(), LMCAS::InferenceEngine::Impl::composite_negative(), LMCAS::InferenceEngine::Impl::composite_nonnegative(), LMCAS::InferenceEngine::Impl::composite_nonpositive(), LMCAS::InferenceEngine::Impl::composite_nonzero(), LMCAS::InferenceEngine::Impl::composite_positive(), LMCAS::InferenceEngine::Impl::composite_real(), LMCAS::detail::transcendental::conditional_preimage(), LMCAS::conjugate_checked(), constant_expression(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::construct_roots(), LMCAS::contains(), LMCAS::solver_detail::contains_imaginary(), LMCAS::contains_inverse_candidate(), LMCAS::contains_transcendental_of_var(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_point_value(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), LMCAS::convergence_radius_checked(), LMCAS::convergence_radius_checked(), LMCAS::convergence_test_checked(), LMCAS::convergence_test_impl(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::convert_basis_polynomial(), LMCAS::polynomial_solver_detail::convert_to_rational_poly(), LMCAS::convert_unit(), LMCAS::convert_unit(), LMCAS::cross_product_impl(), LMCAS::vector_calculus_detail::curl_impl(), LMCAS::curvature_checked(), LMCAS::curvature_parametric_checked(), LMCAS::curve_integral_scalar(), LMCAS::curve_integral_vector(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::declared_period(), LMCAS::detail::transcendental::decompose_exp_base_pattern(), LMCAS::detail::transcendental::decompose_lambert_w_pattern(), LMCAS::detail::transcendental::decompose_trig_exp_pattern(), LMCAS::detail::definite::defined_on_interval(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::definite_integral_geometry_checked(), LMCAS::detail::definite::definite_partition_checked(), LMCAS::detail::inequality_support::depends_on_any_param(), LMCAS::depends_on_integration_variable(), LMCAS::anonymous_namespace{relation_store.cpp}::derive_comparison_sign(), LMCAS::detect_parity(), LMCAS::detect_substitution(), LMCAS::detect_trans_substitutions(), LMCAS::detail::inequality_support::determine_leading_sign(), LMCAS::determine_search_interval(), LMCAS::differential(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::differentiate_geometry_checked(), LMCAS::differentiate_if_dependent(), differentiate_node(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::differentiate_surface_checked(), LMCAS::dimension_of(), LMCAS::directional_derivative_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::distinct_denominator_product(), LMCAS::vector_calculus_detail::divergence_impl(), domain_constraints(), LMCAS::dot_product_impl(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_already_collected(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::elementary(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::elementary_value(), LMCAS::eliminate_parametric_column(), LMCAS::endpoints_equivalent(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), equation_predicate(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equation_residual(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::equivalent_with_budget(), LMCAS::essential_exponent(), LMCAS::essential_laurent(), LMCAS::eval_complex(), LMCAS::detail::NumericEvaluator::evaluate(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_exponent(), LMCAS::evaluate_numeric(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::InferenceEngine::Impl::even_power_sign(), LMCAS::detail::matrix_api::exact_matrix_expression(), LMCAS::detail::definite::exact_number(), LMCAS::detail::inequality_support::exact_numeric_sign(), LMCAS::detail::matrix_kernel::exact_rational(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), LMCAS::detail::matrix_decomposition::exact_rational_matrix(), exact_rational_value(), LMCAS::equivalence_detail::expand_equivalence(), expand_node(), LMCAS::explicit_inverse_candidates(), LMCAS::InferenceEngine::Impl::exponential_domain(), LMCAS::InferenceEngine::Impl::exponential_sign(), LMCAS::anonymous_namespace{relation_store.cpp}::expr_equals(), LMCAS::expr_detail::expr_common::expr_from_complex_result(), LMCAS::expr_match(), LMCAS::exterior_derivative_checked(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_component(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_term(), LMCAS::extract_bernoulli_factor(), LMCAS::extract_coeff_value< BigInt >(), LMCAS::extract_coefficient(), LMCAS::extract_constant_term(), LMCAS::extract_laurent_regular_part(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_mixed_coefficients(), extract_rational(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::extract_sec_power(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::extract_sin_cos_powers(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::extract_tan_power(), LMCAS::detail::NumericEvaluator::extremum(), LMCAS::factor_common_polynomial(), LMCAS::factor_multivariate_expression(), LMCAS::factor_numeric_content(), LMCAS::factor_rational_univariate(), LMCAS::factor_symbolic_quadratic(), LMCAS::factor_transcendental(), LMCAS::factor_transcendental_expression(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::filter_denominators(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), LMCAS::find_extrema_impl(), LMCAS::find_integrating_factor_impl(), LMCAS::find_parametric_pivot(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finish(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::finish_cancellation(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::finite_numeric_coeff(), LMCAS::expr_detail::ExprParser::finite_set(), LMCAS::anonymous_namespace{symbolic_set.cpp}::finite_set_node(), LMCAS::fourier_constant_coefficient(), LMCAS::fourier_series_checked(), LMCAS::fourier_transform_core(), LMCAS::detail::NumericEvaluator::function(), LMCAS::function(), LMCAS::expr_detail::ExprParser::function_node(), LMCAS::vector_calculus_detail::gradient_impl(), LMCAS::gram_schmidt(), LMCAS::greens_theorem(), LMCAS::greens_theorem_checked(), LMCAS::has_nonzero_forcing(), LMCAS::vector_calculus_detail::hessian_impl(), LMCAS::imag_part_checked(), LMCAS::implicit_diff(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::independent_of_variables(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::infer(), LMCAS::detail::definite::infinity_sign(), LMCAS::infinity_sign(), LMCAS::inflection_curve_defined(), LMCAS::inflection_points_checked(), LMCAS::InferenceEngine::Impl::integer_power_sign(), LMCAS::detail::series_support::integer_value_from_node(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::integral_power(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_even_case(), LMCAS::integrate_multiple_checked(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_odd_case(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), integrate_power_primitive(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_sec_power(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), LMCAS::integrating_factor_from_antiderivative(), LMCAS::integrating_factor_from_ratio(), LMCAS::expr_detail::ExprParser::interval(), LMCAS::interval_to_expr(), LMCAS::inverse_branch_derivative(), LMCAS::inverse_fourier_transform_checked(), LMCAS::inverse_fourier_transform_core(), LMCAS::inverse_laplace_checked(), LMCAS::inverse_laplace_core(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::inverse_trig(), LMCAS::detail::transcendental::invert_exp_base(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::invert_lambert_w(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::is_analytic_checked(), LMCAS::is_analytic_impl(), LMCAS::is_bernoulli_ode(), LMCAS::is_constant_coefficient(), LMCAS::is_euler_equation(), LMCAS::is_exact_ode(), LMCAS::is_homogeneous_ode(), LMCAS::is_linear_first_order(), LMCAS::detail::AssumptionFacts::is_negative(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_negative(), LMCAS::detail::ScopedFacts::is_negative(), LMCAS::detail::AssumptionFacts::is_nonnegative(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_nonnegative(), LMCAS::detail::ScopedFacts::is_nonnegative(), LMCAS::is_nonreal_sqrt(), LMCAS::detail::AssumptionFacts::is_nonzero(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_nonzero(), LMCAS::detail::ScopedFacts::is_nonzero(), LMCAS::is_polynomial_after_substitution(), LMCAS::detail::AssumptionFacts::is_positive(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_positive(), LMCAS::detail::ScopedFacts::is_positive(), LMCAS::polynomial_solver_detail::is_purely_numeric(), LMCAS::detail::AssumptionFacts::is_real(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_real(), LMCAS::detail::ScopedFacts::is_real(), LMCAS::is_separable(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::is_substitution_polynomial(), LMCAS::anonymous_namespace{integrator.cpp}::is_zero(), LMCAS::isolate_linear_coeff(), LMCAS::vector_calculus_detail::jacobian_impl(), LMCAS::kronecker(), LMCAS::lagrange_multipliers_checked(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::lambert_w_domain(), LMCAS::transform_detail::laplace_transform_core(), LMCAS::vector_calculus_detail::laplacian_impl(), LMCAS::laurent_series_checked(), LMCAS::laurent_series_full_checked(), LMCAS::laurent_series_full_impl(), LMCAS::lie_derivative_checked(), LMCAS::lie_derivative_impl(), LMCAS::lim_inf_checked(), LMCAS::lim_sup_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::linear_interval(), LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_reduced_expression(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::log10(), LMCAS::log_differentiate(), LMCAS::InferenceEngine::Impl::logarithm_domain(), LMCAS::InferenceEngine::Impl::logarithm_sign(), LMCAS::expr_detail::ExprParser::logical(), LMCAS::anonymous_namespace{expr_facade.cpp}::logical_expression(), LMCAS::lookup_integral(), LMCAS::make_abs(), LMCAS::expr_detail::expr_common::make_binary_expr(), LMCAS::expr_detail::expr_common::make_binary_math_expr(), LMCAS::make_finite_set(), LMCAS::make_interval(), LMCAS::make_membership(), LMCAS::make_rootof_checked(), LMCAS::make_unary_function(), LMCAS::expr_detail::expr_common::make_unary_function_expr(), LMCAS::expr_detail::expr_common::make_unary_math_expr(), LMCAS::match_recursive(), materialize_integral(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::matrix_axis_sum(), matrix_eigenspaces_checked(), LMCAS::matrix_eigenvalues_checked(), LMCAS::matrix_exp(), LMCAS::matrix_log(), LMCAS::matrix_norm(), LMCAS::matrix_trace(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::maximum_axis_sum(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::RewriteBudget::measure_result(), LMCAS::detail::RewriteBudget::measure_shape(), LMCAS::expr_detail::ExprParser::membership(), mixed_evaluate_at(), mixed_numerical_path(), LMCAS::anonymous_namespace{poly_utils.cpp}::multiply_checked_coefficients(), LMCAS::multipoly_to_symbolic(), LMCAS::multivariate_factor_expression(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::multivariate_polynomial_to_expression(), LMCAS::detail::definite::needs_segment_expression(), node(), node(), node(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::nonintegral_power(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize_coefficients(), LMCAS::equivalence_detail::normalize_equivalence(), normalize_node(), LMCAS::detail::NumericEvaluator::number(), LMCAS::geometry_detail::numeric_vector_scale_checked(), LMCAS::detail::AssumptionFacts::operator=(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::opposite_exponential_lambert_pattern(), LMCAS::ordinary_frobenius_solution(), LMCAS::ordinary_taylor_coefficients(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parameter_constraint(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_basis(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_input_polynomials(), LMCAS::parametric_linear_solution(), LMCAS::parametric_nonzero_value(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::parse_conditional_relation(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_quadratic_surd(), LMCAS::anonymous_namespace{root_of_identity.cpp}::parse_rootof_request(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::periodicity_checked(), LMCAS::anonymous_namespace{residual_comparison.cpp}::pointwise_values_defined(), LMCAS::polynomial_logic(), LMCAS::polynomial_relation(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::polynomial_term_to_expression(), LMCAS::InferenceEngine::Impl::positive_power_sign(), LMCAS::InferenceEngine::Impl::positive_relation_chain(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::power(), LMCAS::detail::NumericEvaluator::power(), LMCAS::power_series_add(), LMCAS::power_series_compose_checked(), LMCAS::power_series_multiply_checked(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::predicate_truth(), LMCAS::prepare_fourier_period(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prepare_operands(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::NumericEvaluator::product(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::property(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_checked_operands(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_coefficients(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_exact_root_residual(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_normalized_residual(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_piecewise_residual(), LMCAS::equivalence_detail::prove_rational_polynomial_equivalence(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_with_profiles(), LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::qr_decomposition_impl(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::quadratic_coefficients(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign(), LMCAS::quadratic_form_matrix(), query_definedness(), query_definedness(), LMCAS::InferenceEngine::Impl::query_natural(), query_nonnegative_value(), query_nonnegative_value(), query_nonzero_value(), query_nonzero_value(), query_positive_value(), query_positive_value(), LMCAS::InferenceEngine::Impl::query_rational(), query_real_value(), query_real_value(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::query_value(), LMCAS::InferenceEngine::Impl::quotient_sign(), LMCAS::ratio_convergence_test(), LMCAS::detail::definite::rational_checked(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::rational_polynomial_expression(), LMCAS::rational_root_factors(), LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::real_affine_coefficients(), LMCAS::real_part_checked(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::real_valued_function(), LMCAS::recognize_rational_polynomial(), LMCAS::recognize_regular_laurent(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstruct_quadratic_form(), LMCAS::reconstruct_rational_root_factors(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstructs_expression(), LMCAS::record_remainder(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::reduce_fraction(), LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::redundant_variable_candidate(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::register_canonical_radical(), LMCAS::relation(), LMCAS::relation_op(), LMCAS::InferenceEngine::Impl::relation_rhs_nonnegative(), LMCAS::expr_detail::ExprParser::relational(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::relational_predicate_truth(), LMCAS::expr_detail::expr_common::require_dimensionless(), LMCAS::detail::matrix_api::require_matrix(), LMCAS::detail::matrix_api::require_matrix_result(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::restricted_function(), LMCAS::detail::SymbolicRewriter::rewrite(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_absolute(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_operands(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_operands(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_function(), LMCAS::equivalence_detail::rewritten_complex(), LMCAS::riemann_curvature_tensor_with_inverse(), LMCAS::detail::NumericEvaluator::root(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_expression_sign(), LMCAS::detail::inequality_support::root_less_than(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_node_sign(), LMCAS::rootof_simplify(), LMCAS::detail::inequality_support::roots_equal(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::run(), LMCAS::scalar_project_impl(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::scaled_function(), LMCAS::detail::definite::segment_expression_checked(), LMCAS::sequence_extreme_limit(), LMCAS::series_abs(), LMCAS::detail::series_support::series_get_double(), LMCAS::detail::series_support::series_is_infinity(), LMCAS::detail::series_support::series_is_number(), LMCAS::series_negate(), LMCAS::detail::ScopedFacts::shadows(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::sign_condition(), LMCAS::geometry_detail::simplify_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::simplify_exact_rational_expr(), LMCAS::detail::matrix_kernel::simplify_expr(), LMCAS::simplify_finite_limit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::simplify_geometry_checked(), LMCAS::singular_frobenius_solution(), LMCAS::singular_taylor_coefficients(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::skew_distance_from_directions(), LMCAS::solution_is_excluded(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve(), LMCAS::solve_bernoulli_ode_impl(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), LMCAS::solve_closed_form_from_poly(), LMCAS::solve_closed_form_poly(), LMCAS::solve_complex_nth_root_checked(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::solve_condition_truth(), LMCAS::solve_constant_inequality(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), LMCAS::solve_degenerate_cubic(), LMCAS::solve_equation(), LMCAS::solve_euler_ode_checked(), LMCAS::solve_euler_ode_impl(), LMCAS::solve_exact_factor(), LMCAS::solve_exact_ode_impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_factor(), LMCAS::solve_frobenius_checked(), LMCAS::solve_higher_order_ode_checked(), LMCAS::solve_higher_order_ode_impl(), LMCAS::solve_homogeneous_ode_impl(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_initial_guess(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial(), LMCAS::solve_lagrange_strict(), LMCAS::solve_linear2_homogeneous(), LMCAS::solve_linear2_ode(), LMCAS::solve_linear2_ode_checked(), LMCAS::solver_detail::solve_linear_system_impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::solve_mixed_equation(), LMCAS::solve_product_set(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::solve_real_quadratic(), LMCAS::solve_separable_ode(), LMCAS::solve_set_core(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::solve_symbolic_polynomial_set(), LMCAS::solve_symbolic_quadratic(), LMCAS::solve_transcendental(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl(), LMCAS::solve_variation_of_parameters_core(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::specialize_absolute(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), LMCAS::detail::NumericEvaluator::square_root(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::squared_profile(), LMCAS::detail::anonymous_namespace{squared_norm.cpp}::squared_term(), LMCAS::stokes_theorem(), LMCAS::strip_unit(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::structural(), LMCAS::detail::definite::structurally_continuous(), LMCAS::structurally_equal(), LMCAS::substitute(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::substitute_basis(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitute_candidate(), substitute_expression(), substitute_expression(), LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series(), substitute_node(), substitute_raw(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_argument(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive(), LMCAS::detail::NumericEvaluator::sum(), LMCAS::detail::series_support::supported_laurent_integer_power(), LMCAS::surface_area_revolution_x_checked(), LMCAS::surface_area_revolution_y_checked(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_at_point_checked(), LMCAS::surface_integral_scalar(), LMCAS::surface_integral_vector(), LMCAS::symbol_name(), LMCAS::symbolic_cubic_roots(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_point_plane_distance(), LMCAS::symbolic_poly_to_expr(), LMCAS::symbolic_polynomial_content(), LMCAS::symbolic_polynomial_gcd(), LMCAS::symbolic_product(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::symbolic_quadratic_sign(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::polynomial_solver_detail::symbolic_quartic_roots(), LMCAS::symbolic_sum(), symbolic_to_poly_checked(), LMCAS::anonymous_namespace{symbolic_geometry_vector.cpp}::symbolic_vector_finite_numeric(), LMCAS::te_abs_decay(), LMCAS::te_abs_fourier(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_atomic_gaussian_rate(), LMCAS::te_convolve_core(), LMCAS::te_convolve_sum(), LMCAS::te_decay_condition(), LMCAS::transform_detail::te_depends_on(), LMCAS::te_extract_exp(), LMCAS::te_fourier_unevaluated(), LMCAS::transform_detail::te_gt_condition(), LMCAS::te_inv_power(), LMCAS::te_inv_product(), LMCAS::te_is_hyp(), LMCAS::te_is_power_of_var(), LMCAS::transform_detail::te_is_trig(), LMCAS::transform_detail::te_is_zero(), LMCAS::te_laplace_lookup(), LMCAS::te_laplace_roc(), LMCAS::transform_detail::te_match_pure_gaussian(), LMCAS::transform_detail::te_match_scaled_gaussian(), LMCAS::transform_detail::te_split_coeff(), LMCAS::te_unevaluated_inv_laplace(), LMCAS::te_unevaluated_laplace(), LMCAS::te_validate_convolution_inputs(), LMCAS::transform_detail::te_validate_expr_vars(), LMCAS::transform_detail::te_wrap_transform_result(), LMCAS::tf_back_substitute(), LMCAS::tf_build_polynomial_impl(), LMCAS::tf_detect_constraints(), LMCAS::tf_detect_exponential_separation(), LMCAS::tf_detect_multiplicative_structure(), LMCAS::tf_is_linear_irreducible(), LMCAS::tf_polynomial_variables(), LMCAS::tf_select_main_variable(), LMCAS::tf_simplify_pythagorean(), LMCAS::tf_substitute_expr(), LMCAS::tf_validate_polynomial(), LMCAS::groebner_detail::to_poly(), LMCAS::total_differential(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::trigonometric_domain(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_principal_value(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::anonymous_namespace{poly_utils.cpp}::trim_checked_coefficients(), LMCAS::try_eval_double(), LMCAS::anonymous_namespace{solver_assumptions.cpp}::try_get_numeric_value(), LMCAS::RewriteVisitor::try_match(), LMCAS::integration_table_detail::u_is_real_var(), LMCAS::integration_table_detail::u_is_var(), LMCAS::integration_table_detail::u_is_var_a_indep(), LMCAS::integration_table_detail::u_is_var_a_nonzero(), LMCAS::expr_detail::ExprParser::uninterpreted_function(), LMCAS::anonymous_namespace{integration_definite.cpp}::unresolved_integral(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::unsupported_endpoint(), LMCAS::groebner_detail::PolyBuilder::use_numeric_function(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::validate_basis_input(), LMCAS::anonymous_namespace{complex_analysis.cpp}::validate_complex_expr_input(), LMCAS::anonymous_namespace{complex_analysis.cpp}::validate_complex_expr_point_input(), LMCAS::anonymous_namespace{symbolic_complex.cpp}::validate_complex_symbolic(), LMCAS::detail::matrix_decomposition::validate_decomposition_matrix(), LMCAS::detail::matrix_decomposition::validate_decomposition_output(), LMCAS::anonymous_namespace{symbolic_complex.cpp}::validate_expr(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_expr_vector(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_form_coefficients(), LMCAS::validate_frobenius_regular_singular_domain(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::validate_geometry_inputs(), LMCAS::validate_laurent_result(), LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input(), LMCAS::detail::matrix_kernel::validate_matrix(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_metric_matrix(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::validate_mixed_input(), LMCAS::validate_ode_expr_var_pair(), LMCAS::validate_ode_pair_var_pair(), LMCAS::validate_ode_three_expr_one_var(), LMCAS::validate_ode_two_expr_point(), LMCAS::geometry_detail::validate_plane_checked(), LMCAS::detail::series_support::validate_power_series_coefficients(), LMCAS::validate_series_expr_point(), LMCAS::geometry_detail::validate_surface_point(), LMCAS::geometry_detail::validate_symbolic_vector(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign_impl(), LMCAS::detail::NumericEvaluator::variable(), LMCAS::vector_angle_symbolic_impl(), LMCAS::vector_calculus_constant_integrand(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), LMCAS::vector_calculus_definite_integral_strict(), LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict(), LMCAS::vector_calculus_evaluate_hessian_at_point(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_magnitude_squared(), LMCAS::vector_calculus_multiple_integral_strict(), LMCAS::vector_calculus_numerical_definite(), LMCAS::vector_calculus_detail::vector_calculus_point_has_vars(), LMCAS::vector_calculus_detail::vector_calculus_simplify_strict(), LMCAS::vector_calculus_single_dir_deriv(), LMCAS::vector_calculus_substitute_coords_strict(), LMCAS::vector_calculus_try_definite(), LMCAS::vector_calculus_detail::vector_calculus_validate_bound_pair(), LMCAS::vector_calculus_detail::vector_calculus_validate_curve_parametrization(), LMCAS::vector_calculus_detail::vector_calculus_validate_curve_scalar_inputs(), LMCAS::vector_calculus_detail::vector_calculus_validate_curve_vector_inputs(), LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_functions_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_bounds(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_parametrization(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_scalar_inputs(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_vector_inputs(), LMCAS::vector_calculus_detail::vector_calculus_wrap_expr(), LMCAS::vector_calculus_detail::vector_calculus_wrap_field(), LMCAS::vector_dot_checked(), LMCAS::vector_project_impl(), LMCAS::verified_quadratic_boundaries(), LMCAS::verified_real_inverse_candidates(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_decomposition(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_identity(), LMCAS::verify_lagrange_solutions(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::verify_quadratic_boundary(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root(), LMCAS::anonymous_namespace{quantity.cpp}::view(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::detail::SymbolicVisitor::visit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::walk(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_reduce_rational(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace_function(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational(), LMCAS::wrap_ode_solution(), LMCAS::z_transform_core(), LMCAS::InferenceEngine::Impl::zero_power_sign(), LMCAS::zt_abs_expr(), LMCAS::zt_exponential(), LMCAS::zt_is_exp_seq(), LMCAS::zt_is_weighted_exp(), LMCAS::zt_polynomial(), LMCAS::zt_polynomial_pattern(), LMCAS::zt_roc(), LMCAS::zt_trigonometric() , 以及 LMCAS::zt_unevaluated().

函数调用图:

node() [2/3]

const SymbolicNodePtr & LMCAS::detail::node ( const std::shared_ptr< const ::LMCAS::SymbolicExpr > & expression )

inlinenoexcept

在文件 base.hpp 第 101 行定义.

                                                                       {
    static const SymbolicNodePtr empty;
    return expression ? node(*expression) : empty;
}

引用了 node().

函数调用图:

node() [3/3]

const SymbolicNodePtr & LMCAS::detail::node ( const std::shared_ptr<::LMCAS::SymbolicExpr > & expression )

inlinenoexcept

在文件 base.hpp 第 95 行定义.

                                                                 {
    static const SymbolicNodePtr empty;
    return expression ? node(*expression) : empty;
}

引用了 node().

函数调用图:

normalize_node()

SymbolicNodePtr LMCAS::detail::normalize_node	(	const SymbolicNodePtr &	node,
		RewriteBudget &	budget,
		const FactsQuery &	facts,
		Domain	domain )

在文件 symbolic_core.cpp 第 201 行定义.

                                                                       {
    budget.consume();
    if (!node) {
        throw CasError{CasErrc::InvalidArgument, "simplify argument cannot be null",
                       "LMCAS.simplify"};
    }
    budget.measure(node);
    NormalizationVisitor visitor(budget, facts, domain);
    node->accept(visitor);
    auto result = visitor.get_result();
    if (!result) {
        throw CasError{CasErrc::InternalInvariant, "simplify returned null",
                       "LMCAS.simplify"};
    }
    budget.measure(result);
    return result;
}

引用了 budget, LMCAS::detail::RewriteBudget::consume(), domain, facts, LMCAS::NormalizationVisitor::get_result(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, LMCAS::detail::RewriteBudget::measure(), node() , 以及 normalize_node().

被这些函数引用 LMCAS::abs(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic(), LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), LMCAS::add_fourier_harmonic(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_lambert_pattern(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_power_pattern(), LMCAS::alternating_sequence_bound(), LMCAS::analytic_continuation(), LMCAS::asymptotic_expand(), LMCAS::calculus_utils_extract_real_candidate(), LMCAS::calculus_utils_oblique_from_rational(), LMCAS::calculus_utils_product(), LMCAS::calculus_utils_try_symbolic_definite(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_polynomial_gcd(), LMCAS::cauchy_integral_impl(), LMCAS::geometry_detail::checked_nonzero_numeric_or_exact(), LMCAS::christoffel_first_kind_impl(), LMCAS::christoffel_second_kind_impl(), LMCAS::classify_first_order_ode(), LMCAS::classify_hessian_eigenvalues(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_sum(), LMCAS::classify_ratio_limit(), LMCAS::classify_singular_point_checked(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::detail::inequality_support::close_symbolic_endpoint(), LMCAS::coefficient_power_radius(), LMCAS::collect_bernoulli_coefficients(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::collect_fraction_terms(), LMCAS::collect_oblique_asymptote(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_finite_endpoint(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::conjugate_checked(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::convert_basis_polynomial(), LMCAS::polynomial_solver_detail::convert_to_rational_poly(), LMCAS::cross_product_impl(), LMCAS::vector_calculus_detail::curl_impl(), LMCAS::curvature_checked(), LMCAS::curvature_parametric_checked(), LMCAS::curve_integral_scalar(), LMCAS::curve_integral_vector(), LMCAS::detect_parity(), LMCAS::detect_substitution(), LMCAS::detail::inequality_support::determine_leading_sign(), differentiate_node(), LMCAS::vector_calculus_detail::directional_derivative_impl(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::distinct_denominator_product(), LMCAS::vector_calculus_detail::divergence_impl(), LMCAS::dot_product_impl(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_already_collected(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace(), LMCAS::eliminate_parametric_column(), LMCAS::essential_exponent(), LMCAS::essential_laurent(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::detail::inequality_support::exact_numeric_sign(), expand_node(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_component(), LMCAS::extract_bernoulli_factor(), LMCAS::extract_coeff_value< BigInt >(), LMCAS::extract_constant_term(), LMCAS::extract_laurent_regular_part(), LMCAS::factor_common_polynomial(), LMCAS::factor_numeric_content(), LMCAS::factor_rational_univariate(), LMCAS::factor_symbolic_quadratic(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), LMCAS::find_extrema_impl(), LMCAS::find_integrating_factor_impl(), LMCAS::find_parametric_pivot(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::finish_cancellation(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::finite_numeric_coeff(), LMCAS::fourier_constant_coefficient(), LMCAS::fourier_series_checked(), LMCAS::vector_calculus_detail::gradient_impl(), LMCAS::gram_schmidt(), LMCAS::greens_theorem(), LMCAS::vector_calculus_detail::hessian_impl(), LMCAS::imag_part_checked(), LMCAS::inflection_points_checked(), LMCAS::integrate_multiple_checked(), integrate_power_primitive(), LMCAS::integrating_factor_from_antiderivative(), LMCAS::inverse_branch_derivative(), LMCAS::inverse_fourier_transform_core(), LMCAS::detail::transcendental::invert_exp_base(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::invert_lambert_w(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::is_analytic_impl(), LMCAS::is_bernoulli_ode(), LMCAS::is_euler_equation(), LMCAS::is_exact_ode(), LMCAS::is_homogeneous_ode(), LMCAS::is_linear_first_order(), LMCAS::is_nonreal_sqrt(), LMCAS::isolate_linear_coeff(), LMCAS::vector_calculus_detail::jacobian_impl(), LMCAS::kronecker(), LMCAS::vector_calculus_detail::laplacian_impl(), LMCAS::laurent_series_checked(), LMCAS::laurent_series_full_checked(), LMCAS::laurent_series_full_impl(), LMCAS::lie_derivative_impl(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::linear_interval(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::log_differentiate(), LMCAS::lookup_integral(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::matrix_axis_sum(), matrix_eigenspaces_checked(), LMCAS::matrix_eigenvalues_checked(), LMCAS::matrix_exp(), LMCAS::matrix_log(), LMCAS::matrix_norm(), LMCAS::matrix_trace(), LMCAS::multipoly_to_symbolic(), LMCAS::anonymous_namespace{poly_utils.cpp}::normalize_coefficient(), LMCAS::equivalence_detail::normalize_equivalence(), normalize_node(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::opposite_exponential_lambert_pattern(), LMCAS::ordinary_frobenius_solution(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_basis(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_input_polynomials(), LMCAS::parametric_linear_solution(), LMCAS::power_series_add(), LMCAS::power_series_compose_checked(), LMCAS::power_series_multiply_checked(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_normalized_residual(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::quadratic_coefficients(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign(), LMCAS::ratio_convergence_test(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::rational_polynomial_expression(), LMCAS::rational_root_factors(), LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives(), LMCAS::real_part_checked(), LMCAS::reconstruct_rational_root_factors(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstructs_expression(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::reduce_fraction(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::remember_angle(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::riemann_curvature_tensor_with_inverse(), LMCAS::detail::inequality_support::root_less_than(), LMCAS::detail::inequality_support::roots_equal(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::run(), LMCAS::scalar_project_impl(), LMCAS::scale_integral_field(), LMCAS::sequence_extreme_limit(), LMCAS::series_abs(), LMCAS::series_negate(), LMCAS::geometry_detail::simplify_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::simplify_exact_rational_expr(), LMCAS::detail::matrix_kernel::simplify_expr(), simplify_expression(), LMCAS::simplify_finite_limit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::simplify_geometry_checked(), LMCAS::singular_frobenius_solution(), LMCAS::solve_bernoulli_ode_impl(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), LMCAS::solve_closed_form_from_poly(), LMCAS::solve_closed_form_poly(), LMCAS::solve_constant_inequality(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), LMCAS::solve_degenerate_cubic(), LMCAS::solve_euler_ode_checked(), LMCAS::solve_euler_ode_impl(), LMCAS::solve_exact_ode_impl(), LMCAS::solve_higher_order_ode_checked(), LMCAS::solve_higher_order_ode_impl(), LMCAS::solve_homogeneous_ode_impl(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::solve_linear2_homogeneous(), LMCAS::solver_detail::solve_linear_system_impl(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), LMCAS::solve_separable_ode(), LMCAS::solve_set_core(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::solve_symbolic_polynomial_set(), LMCAS::solve_symbolic_quadratic(), LMCAS::solve_transcendental(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant(), LMCAS::solve_variation_of_parameters_core(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::squared_profile(), LMCAS::stokes_theorem(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitute_candidate(), LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series(), substitute_node(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), LMCAS::surface_area_revolution_x_checked(), LMCAS::surface_area_revolution_y_checked(), LMCAS::surface_integral_scalar(), LMCAS::surface_integral_vector(), LMCAS::symbolic_cubic_roots(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), LMCAS::symbolic_poly_to_expr(), LMCAS::symbolic_product(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::polynomial_solver_detail::symbolic_quartic_roots(), LMCAS::symbolic_sum(), LMCAS::te_abs_decay(), LMCAS::te_abs_fourier(), LMCAS::te_convolve_core(), LMCAS::te_convolve_sum(), LMCAS::tf_detect_exponential_separation(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::groebner_detail::PolyBuilder::use_numeric_function(), LMCAS::validate_frobenius_regular_singular_domain(), LMCAS::vector_angle_symbolic_impl(), LMCAS::vector_calculus_constant_integrand(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), LMCAS::vector_calculus_evaluate_hessian_at_point(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_magnitude_squared(), LMCAS::vector_calculus_detail::vector_calculus_simplify_strict(), LMCAS::vector_calculus_single_dir_deriv(), LMCAS::vector_calculus_try_definite(), LMCAS::vector_project_impl(), LMCAS::verified_quadratic_boundaries(), LMCAS::verified_real_inverse_candidates(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational(), LMCAS::z_transform_core(), LMCAS::zt_exponential(), LMCAS::zt_polynomial() , 以及 LMCAS::zt_trigonometric().

函数调用图:

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

nullspace_exact()

Result< std::vector< std::vector< ExprPtr > > > LMCAS::detail::nullspace_exact	(	ExactMatrixData	coefficients,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix_solve.cpp 第 162 行定义.

                                {
    auto valid = validate_matrix(coefficients, operation);
    if (!valid) {
        return Result<std::vector<std::vector<ExprPtr>>>::failure(valid.error());
    }
    const std::size_t columns = coefficients.cols;
    auto eliminated = eliminate_exact(
        std::move(coefficients), columns,
        EliminationForm::ReducedRowEchelon, context, operation);
    if (!eliminated) {
        return Result<std::vector<std::vector<ExprPtr>>>::failure(
            eliminated.error());
    }
    std::set<std::size_t> pivots(
        eliminated.value().pivot_columns.begin(),
        eliminated.value().pivot_columns.end());
    std::vector<std::vector<ExprPtr>> basis;
    for (std::size_t free_column = 0; free_column < columns; ++free_column) {
        if (pivots.count(free_column) != 0) continue;
        std::vector<ExprPtr> vector(columns, SymbolicExpr::number(0));
        vector[free_column] = SymbolicExpr::number(1);
        for (std::size_t row = 0;
             row < eliminated.value().pivot_columns.size(); ++row) {
            vector[eliminated.value().pivot_columns[row]] = exact_negate(
                eliminated.value().matrix.at(row, free_column), context);
        }
        basis.push_back(std::move(vector));
    }
    return Result<std::vector<std::vector<ExprPtr>>>::success(
        std::move(basis));
}

引用了 LMCAS::basis, LMCAS::detail::ExactMatrixData::cols, context, eliminate_exact(), LMCAS::detail::matrix_kernel::exact_negate(), nullspace_exact(), operation, ReducedRowEchelon , 以及 LMCAS::detail::matrix_kernel::validate_matrix().

被这些函数引用 LMCAS::matrix_nullspace_checked() , 以及 nullspace_exact().

函数调用图:

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

numeric_approximation()

Result< ApproxReal > LMCAS::detail::numeric_approximation

(

double

value

)

在文件 numeric_evaluation.cpp 第 28 行定义.

                                                       {
    if (!std::isfinite(value)) {
        return numeric_failure(CasErrc::NumericFailure, "numeric evaluation produced a nonfinite result");
    }
    return Result<ApproxReal>::success(
        ApproxReal{value, std::numeric_limits<double>::infinity(), NumericStatus::Finite});
}

引用了 LMCAS::Finite, numeric_approximation(), numeric_failure(), LMCAS::NumericFailure, LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 LMCAS::detail::NumericEvaluator::atan2(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::elementary(), LMCAS::detail::NumericEvaluator::extremum(), LMCAS::detail::NumericEvaluator::function(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::hyperbolic(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::inverse_trigonometric(), LMCAS::detail::NumericEvaluator::norm(), LMCAS::detail::NumericEvaluator::number(), numeric_approximation(), LMCAS::detail::NumericEvaluator::power(), LMCAS::detail::NumericEvaluator::product(), LMCAS::detail::NumericEvaluator::root(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::special(), LMCAS::detail::NumericEvaluator::square_root(), LMCAS::detail::NumericEvaluator::sum(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::trigonometric() , 以及 LMCAS::detail::NumericEvaluator::variable().

函数调用图:

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

numeric_failure()

Result< ApproxReal > LMCAS::detail::numeric_failure	(	CasErrc	code,
		std::string	message )

在文件 numeric_evaluation.cpp 第 24 行定义.

                                                                    {
    return Result<ApproxReal>::failure(code, std::move(message), kOperation);
}

引用了 LMCAS::Result< T >::failure() , 以及 numeric_failure().

被这些函数引用 LMCAS::detail::NumericEvaluator::atan2(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::elementary(), LMCAS::detail::NumericEvaluator::evaluate(), evaluate_unary_numeric(), LMCAS::detail::NumericEvaluator::extremum(), LMCAS::detail::NumericEvaluator::function(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::inverse_trigonometric(), LMCAS::detail::NumericEvaluator::number(), numeric_approximation(), numeric_failure(), LMCAS::detail::NumericEvaluator::power(), LMCAS::detail::NumericEvaluator::product(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::special(), LMCAS::detail::NumericEvaluator::square_root(), LMCAS::detail::NumericEvaluator::sum(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::trigonometric() , 以及 LMCAS::detail::NumericEvaluator::variable().

函数调用图:

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

parse_finite_decimal()

Result< double > LMCAS::detail::parse_finite_decimal ( std::string_view token )

inline

在文件 numeric_literal.hpp 第 57 行定义.

                                                                 {
    const auto invalid = [] {
        return Result<double>::failure(CasErrc::ParseError,
            "expected a representable finite decimal", "LMCAS.numeric_literal");
    };
    if (!is_signed_decimal_token(token)) { return invalid(); }
    if (token.front() == '+') { token.remove_prefix(1); }
    double value = 0;
#ifdef __APPLE__
    // Xcode 16 uses strtod_l with a fixed C locale for decimal conversion.
    static const locale_t c_locale = newlocale(LC_NUMERIC_MASK, "C", nullptr);
    if (!c_locale) { return invalid(); }
    std::string text(token);
    char* end = nullptr;
    value = strtod_l(text.c_str(), &end, c_locale);
    const bool converted = end == text.c_str() + text.size();
#else
    const auto parsed = std::from_chars(token.data(), token.data() + token.size(),
                                        value, std::chars_format::general);
    const bool converted = parsed.ec == std::errc{} &&
                           parsed.ptr == token.data() + token.size();
#endif
    if (!converted || !std::isfinite(value)) { return invalid(); }
    if (value == 0) {
        for (char c : token) {
            if (c == 'e' || c == 'E') { break; }
            if (c >= '1' && c <= '9') { return invalid(); }
        }
        if (token.front() == '-') { value = -0.0; }
    }
    return value;
}

引用了 LMCAS::c, LMCAS::Result< T >::failure(), is_signed_decimal_token(), parse_finite_decimal(), LMCAS::ParseError , 以及 LMCAS::value.

被这些函数引用 LMCAS::expr_detail::ExprParser::parse_approx_literal(), LMCAS::parse_approximate_atom(), parse_finite_decimal() , 以及 LMCAS::assumption_detail::parse_finite_number_node().

函数调用图:

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

query_definedness() [1/2]

Result< Tribool > LMCAS::detail::query_definedness	(	const Node &	node,
		const FactsQuery &	facts,
		Domain	domain,
		ComputationContext &	context,
		bool *	violated_real_restriction )

在文件 facts_query.cpp 第 703 行定义.

                                                                                                {
    return query_value(node, facts, domain, &ValueFacts::defined, false, context,
                       violated_real_restriction);
}

引用了 context, domain, facts, node() , 以及 query_definedness().

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::anonymous_namespace{poly_utils.cpp}::check_zero_power_base(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::classify_continuity_point_value(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_limit_result(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::declared_period(), LMCAS::detail::definite::defined_on_interval(), domain_constraints(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::function_bounds(), LMCAS::inflection_curve_defined(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::normalization_can_discard(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::anonymous_namespace{residual_comparison.cpp}::pointwise_values_defined(), query_definedness(), query_definedness(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::real_affine_coefficients(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::real_defined(), LMCAS::InferenceEngine::Impl::real_definedness(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth() , 以及 LMCAS::anonymous_namespace{calculus_continuity.cpp}::select_continuity_branch().

函数调用图:

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

query_definedness() [2/2]

Result< Tribool > LMCAS::detail::query_definedness	(	const std::shared_ptr< const SymbolicNode > &	node,
		const FactsQuery &	facts,
		Domain	domain,
		ComputationContext &	context,
		bool *	violated_real_restriction = nullptr )

引用了 context, domain, facts, node() , 以及 query_definedness().

函数调用图:

query_nonnegative_value() [1/2]

Result< Tribool > LMCAS::detail::query_nonnegative_value	(	const Node &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

在文件 facts_query.cpp 第 717 行定义.

                                                                                                                {
    return query_value(node, facts, Domain::Complex, &ValueFacts::nonnegative, true, context);
}

引用了 LMCAS::Complex, context, facts, node() , 以及 query_nonnegative_value().

被这些函数引用 LMCAS::NormalizationVisitor::can_combine_nested_power(), LMCAS::anonymous_namespace{limit_result.cpp}::finite_sign(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::detail::definite::original_conditions_checked(), query_nonnegative_value(), query_nonnegative_value(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::NormalizationVisitor::simplify_assumed_absolute(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::specialize_absolute() , 以及 LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range().

函数调用图:

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

query_nonnegative_value() [2/2]

Result< Tribool > LMCAS::detail::query_nonnegative_value	(	const std::shared_ptr< const SymbolicNode > &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

引用了 context, facts, node() , 以及 query_nonnegative_value().

函数调用图:

query_nonzero_value() [1/2]

Result< Tribool > LMCAS::detail::query_nonzero_value	(	const Node &	node,
		const FactsQuery &	facts,
		Domain	domain,
		ComputationContext &	context )

在文件 facts_query.cpp 第 708 行定义.

                                                                                                                           {
    return query_value(node, facts, domain, &ValueFacts::nonzero, true, context);
}

引用了 context, domain, facts, node() , 以及 query_nonzero_value().

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::check_constant_factor(), LMCAS::anonymous_namespace{poly_utils.cpp}::check_zero_power_base(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::SymbolicFactory::create_power(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_already_collected(), LMCAS::InferenceEngine::Impl::even_power_sign(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::filter_denominators(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), LMCAS::anonymous_namespace{limit_result.cpp}::finite_sign(), integrate_power_primitive(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parameter_constraint(), LMCAS::parametric_nonzero_value(), query_nonzero_value(), query_nonzero_value(), LMCAS::InferenceEngine::Impl::quotient_sign(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::solve_symbolic_polynomial_set(), LMCAS::solve_symbolic_quadratic(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::substitute_basis(), LMCAS::integration_table_detail::u_is_var_a_nonzero(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::visit(), LMCAS::ExpandVisitor::visit() , 以及 LMCAS::InferenceEngine::Impl::zero_power_sign().

函数调用图:

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

query_nonzero_value() [2/2]

Result< Tribool > LMCAS::detail::query_nonzero_value	(	const std::shared_ptr< const SymbolicNode > &	node,
		const FactsQuery &	facts,
		Domain	domain,
		ComputationContext &	context )

引用了 context, domain, facts, node() , 以及 query_nonzero_value().

函数调用图:

query_positive_value() [1/2]

Result< Tribool > LMCAS::detail::query_positive_value	(	const Node &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

在文件 facts_query.cpp 第 714 行定义.

                                                                                                             {
    return query_value(node, facts, Domain::Complex, &ValueFacts::positive, true, context);
}

引用了 LMCAS::Complex, context, facts, node() , 以及 query_positive_value().

被这些函数引用 LMCAS::SymbolicFactory::create_power(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::declared_period(), LMCAS::anonymous_namespace{limit_result.cpp}::finite_sign(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::InferenceEngine::Impl::logarithm_domain(), LMCAS::matrix_log(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexContinuityPoint::positive(), LMCAS::InferenceEngine::Impl::positive_power_sign(), LMCAS::prepare_fourier_period(), query_positive_value(), query_positive_value(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth() , 以及 LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::symbolic_quadratic_sign().

函数调用图:

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

query_positive_value() [2/2]

Result< Tribool > LMCAS::detail::query_positive_value	(	const std::shared_ptr< const SymbolicNode > &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

引用了 context, facts, node() , 以及 query_positive_value().

函数调用图:

query_real_value() [1/2]

Result< Tribool > LMCAS::detail::query_real_value	(	const Node &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

在文件 facts_query.cpp 第 711 行定义.

                                                                                                         {
    return query_value(node, facts, Domain::Complex, &ValueFacts::real, true, context);
}

引用了 LMCAS::Complex, context, facts, node() , 以及 query_real_value().

被这些函数引用 LMCAS::classify_inflection_candidates(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::declared_period(), domain_constraints(), LMCAS::InferenceEngine::Impl::even_power_sign(), LMCAS::InferenceEngine::Impl::exponential_domain(), LMCAS::InferenceEngine::Impl::exponential_sign(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::function_bounds(), LMCAS::inflection_curve_defined(), LMCAS::InferenceEngine::Impl::integer_power_sign(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::InferenceEngine::Impl::positive_power_sign(), LMCAS::InferenceEngine::Impl::product_sign(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_coefficients(), query_real_value(), query_real_value(), LMCAS::InferenceEngine::Impl::quotient_sign(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::real_affine_coefficients(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::real_defined(), LMCAS::InferenceEngine::Impl::real_definedness(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_absolute(), LMCAS::NormalizationVisitor::simplify_assumed_absolute(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::specialize_absolute(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::square_relation(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::symbolic_quadratic_sign(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::integration_table_detail::u_is_real_var(), LMCAS::integration_table_detail::u_is_var_a_nonzero() , 以及 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::visit().

函数调用图:

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

query_real_value() [2/2]

Result< Tribool > LMCAS::detail::query_real_value	(	const std::shared_ptr< const SymbolicNode > &	node,
		const FactsQuery &	facts,
		ComputationContext &	context )

引用了 context, facts, node() , 以及 query_real_value().

函数调用图:

rank_exact()

Result< std::size_t > LMCAS::detail::rank_exact	(	ExactMatrixData	input,
		std::size_t	coefficient_columns,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix.cpp 第 134 行定义.

                                {
    auto eliminated = eliminate_exact(
        std::move(input), coefficient_columns,
        EliminationForm::Echelon, context, operation);
    if (!eliminated) return Result<std::size_t>::failure(eliminated.error());
    return Result<std::size_t>::success(eliminated.value().rank);
}

引用了 context, Echelon, eliminate_exact(), LMCAS::Result< T >::failure(), operation, rank_exact() , 以及 LMCAS::Result< T >::success().

被这些函数引用 LMCAS::matrix_rank_checked() , 以及 rank_exact().

函数调用图:

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

rational_determinant_exact()

Result< Rational > LMCAS::detail::rational_determinant_exact	(	std::size_t	dimension,
		std::vector< Rational >	values,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_rational_determinant.cpp 第 62 行定义.

                                {
    try {
        return rational_determinant_value_impl(
            dimension, std::move(values), context, operation);
    } catch (const std::bad_alloc&) {
        return Result<Rational>::failure(
            CasErrc::ResourceLimit,
            "rational determinant allocation failed",
            operation);
    } catch (const std::exception& error) {
        return Result<Rational>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 context, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, operation, rational_determinant_exact(), rational_determinant_value_impl() , 以及 LMCAS::ResourceLimit.

被这些函数引用 LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::prove_exact_full_column_rank_qr_support(), LMCAS::anonymous_namespace{matrix_decomposition_cholesky.cpp}::prove_exact_spd() , 以及 rational_determinant_exact().

函数调用图:

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

rational_determinant_value_impl()

Result< Rational > LMCAS::detail::rational_determinant_value_impl	(	std::size_t	dimension,
		std::vector< Rational >	values,
		ComputationContext &	context,
		const std::string &	operation )

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

                                {
    if (dimension == 0 ||
        dimension > std::numeric_limits<std::size_t>::max() / dimension ||
        values.size() != dimension * dimension) {
        return Result<Rational>::failure(
            CasErrc::InvalidArgument,
            "rational determinant storage does not match its dimension",
            operation);
    }
    Rational sign(1);
    Rational previous(1);
    if (dimension == 1) return Result<Rational>::success(values[0]);
    for (std::size_t pivot_column = 0;
         pivot_column + 1 < dimension; ++pivot_column) {
        auto budget = context.consume_steps(1, operation);
        if (!budget) return Result<Rational>::failure(budget.error());
        std::size_t pivot_row = pivot_column;
        while (pivot_row < dimension &&
               values[pivot_row * dimension + pivot_column] == Rational(0)) {
            ++pivot_row;
        }
        if (pivot_row == dimension) {
            return Result<Rational>::success(Rational(0));
        }
        if (pivot_row != pivot_column) {
            for (std::size_t column = 0; column < dimension; ++column) {
                std::swap(values[pivot_row * dimension + column],
                          values[pivot_column * dimension + column]);
            }
            sign = -sign;
        }
        const Rational pivot =
            values[pivot_column * dimension + pivot_column];
        for (std::size_t row = pivot_column + 1; row < dimension; ++row) {
            for (std::size_t column = pivot_column + 1;
                 column < dimension; ++column) {
                values[row * dimension + column] =
                    (values[row * dimension + column] * pivot -
                     values[row * dimension + pivot_column] *
                         values[pivot_column * dimension + column]) /
                    previous;
            }
            values[row * dimension + pivot_column] = Rational(0);
        }
        previous = pivot;
    }
    return Result<Rational>::success(
        sign * values[(dimension - 1) * dimension + (dimension - 1)]);
}

引用了 budget, context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, operation, rational_determinant_value_impl() , 以及 LMCAS::Result< T >::success().

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::rational_determinant(), rational_determinant_exact() , 以及 rational_determinant_value_impl().

函数调用图:

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

rational_square_root()

std::optional< Rational > LMCAS::detail::rational_square_root ( const Rational & coefficient )

static

在文件 multivariate_factor_patterns.cpp 第 16 行定义.

                                                                               {
    const BigInt& numerator = coefficient.get_numerator();
    const BigInt& denominator = coefficient.get_denominator();
    if (numerator.is_negative()) { return std::nullopt; }
    BigInt numerator_root = numerator.sqrt();
    if (numerator_root * numerator_root != numerator) { return std::nullopt; }
    BigInt denominator_root = denominator.sqrt();
    if (denominator_root * denominator_root != denominator) { return std::nullopt; }
    return Rational(numerator_root, denominator_root);
}

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

被这些函数引用 detect_difference_of_squares() , 以及 rational_square_root().

函数调用图:

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

rational_system_inconsistent()

bool LMCAS::detail::rational_system_inconsistent	(	std::size_t	rows,
		std::size_t	coefficient_columns,
		const std::vector< Rational > &	matrix )

在文件 exact_rational_solve.cpp 第 57 行定义.

                                       {
    const std::size_t columns = coefficient_columns + 1;
    for (std::size_t row = 0; row < rows; ++row) {
        bool zero = true;
        for (std::size_t column = 0; column < coefficient_columns; ++column) {
            zero = zero && matrix[row * columns + column] == Rational(0);
        }
        if (zero && matrix[row * columns + coefficient_columns] != Rational(0)) {
            return true;
        }
    }
    return false;
}

引用了 rational_system_inconsistent().

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), rational_system_inconsistent() , 以及 solve_rational_unique().

函数调用图:

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

real_quadratic_roots_checked()

Result< CartesianQuadraticRoots > LMCAS::detail::real_quadratic_roots_checked	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 268 行定义.

                                 {
    try {
        auto coefficients = normalize_coefficients({a, b, c}, context);
        if (!coefficients) {
            return Result<CartesianQuadraticRoots>::failure(coefficients.error());
        }
        if (context.assumptions()) {
            return solve_real_quadratic(coefficients.value(), *context.assumptions(), context);
        }
        const AssumptionContext facts;
        return solve_real_quadratic(coefficients.value(), facts, context);
    } catch (const CasError& error) {
        return Result<CartesianQuadraticRoots>::failure(error);
    } catch (const std::bad_alloc&) {
        return Result<CartesianQuadraticRoots>::failure(CasErrc::ResourceLimit,
            "quadratic construction allocation failed", kOperation);
    } catch (const std::exception& error) {
        return Result<CartesianQuadraticRoots>::failure(CasErrc::InternalInvariant,
            error.what(), kOperation);
    }
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, context, facts, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, real_quadratic_roots_checked() , 以及 LMCAS::ResourceLimit.

被这些函数引用 real_quadratic_roots_checked(), LMCAS::solve_complex_quadratic_checked() , 以及 LMCAS::solve_exact_factor().

函数调用图:

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

recognize_affine()

Result< std::optional< detail::AffineForm > > LMCAS::detail::recognize_affine	(	const SymbolicExpr &	expression,
		const std::string &	variable,
		ComputationContext &	context )

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

                                 {
    using AffineResult = Result<std::optional<AffineForm>>;
    auto converted = symbolic_to_poly_checked(expression, variable, context);
    if (!converted) {
        if (converted.error().code == CasErrc::UnsupportedExpression) {
            return std::optional<AffineForm>{};
        }
        return AffineResult::failure(converted.error());
    }
    const auto& polynomial = converted.value();
    if (polynomial.degree() > 1) return std::optional<AffineForm>{};
    return std::optional<AffineForm>{AffineForm{
        polynomial.coeffs.size() > 1 ? polynomial.coeffs[1].val : SymbolicExpr::number(0),
        polynomial.coeffs.empty() ? SymbolicExpr::number(0) : polynomial.coeffs[0].val}};
}

引用了 context, symbolic_to_poly_checked(), LMCAS::UnsupportedExpression , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_pair() , 以及 LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::prepare_trigonometric_affine().

函数调用图:

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

reduce_rational_rows()

std::vector< std::optional< std::size_t > > LMCAS::detail::reduce_rational_rows	(	std::size_t	rows,
		std::size_t	coefficient_columns,
		std::vector< Rational > &	matrix,
		bool	start_at_pivot )

在文件 exact_rational_solve.cpp 第 30 行定义.

                                                      {
    const std::size_t columns = coefficient_columns + 1;
    std::vector<std::optional<std::size_t>> pivot_rows(coefficient_columns);
    std::size_t pivot_row = 0;
    for (std::size_t column = 0;
         column < coefficient_columns && pivot_row < rows; ++column) {
        std::size_t selected = pivot_row;
        while (selected < rows &&
               matrix[selected * columns + column] == Rational(0)) {
            ++selected;
        }
        if (selected == rows) continue;
        if (selected != pivot_row) {
            for (std::size_t target = 0; target < columns; ++target) {
                std::swap(matrix[selected * columns + target],
                          matrix[pivot_row * columns + target]);
            }
        }
        reduce_rational_pivot(matrix, rows, columns, pivot_row, column,
                              start_at_pivot ? column : 0);
        pivot_rows[column] = pivot_row++;
    }
    return pivot_rows;
}

引用了 reduce_rational_rows() , 以及 LMCAS::target.

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), reduce_rational_rows() , 以及 solve_rational_unique().

函数调用图:

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

refine_complex_isolation()

Result< void > LMCAS::detail::refine_complex_isolation	(	const Polynomial< Rational > &	,
		ComplexIsolation &	isolation,
		const NumericEvaluationOptions &	options,
		ComputationContext &	context,
		const std::string &	operation )

在文件 complex_root_rectangles.cpp 第 247 行定义.

                                {
    auto real = refine_exact_real_algebraic_to_tolerance(
        isolation.real_projection,
        options.absolute_tolerance,
        options.relative_tolerance,
        context,
        operation);
    if (!real) return real;
    auto imaginary = refine_exact_real_algebraic_to_tolerance(
        isolation.imaginary_projection,
        options.absolute_tolerance,
        options.relative_tolerance,
        context,
        operation);
    if (!imaginary) return imaginary;
    isolation.real_lower = isolation.real_projection.lower;
    isolation.real_upper = isolation.real_projection.upper;
    isolation.imaginary_lower = isolation.imaginary_projection.lower;
    isolation.imaginary_upper = isolation.imaginary_projection.upper;
    return Result<void>::success();
}

引用了 context, LMCAS::detail::ComplexIsolation::imaginary_lower, LMCAS::detail::ComplexIsolation::imaginary_projection, LMCAS::detail::ComplexIsolation::imaginary_upper, LMCAS::detail::ExactRealAlgebraic::lower, operation, LMCAS::options, LMCAS::real(), LMCAS::detail::ComplexIsolation::real_lower, LMCAS::detail::ComplexIsolation::real_projection, LMCAS::detail::ComplexIsolation::real_upper, refine_complex_isolation(), refine_exact_real_algebraic_to_tolerance(), LMCAS::Result< T >::success() , 以及 LMCAS::detail::ExactRealAlgebraic::upper.

被这些函数引用 evaluate_root_complex() , 以及 refine_complex_isolation().

函数调用图:

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

refine_exact_real_algebraic()

Result< void > LMCAS::detail::refine_exact_real_algebraic	(	ExactRealAlgebraic &	value,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_algebraic.cpp 第 130 行定义.

                                {
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (value.lower == value.upper) return Result<void>::success();
 
    const Rational lower_value = value.polynomial.eval(value.lower);
    if (lower_value == Rational(0)) {
        value.upper = value.lower;
        return Result<void>::success();
    }
    const Rational upper_value = value.polynomial.eval(value.upper);
    if (upper_value == Rational(0)) {
        value.lower = value.upper;
        return Result<void>::success();
    }
 
    const Rational midpoint = (value.lower + value.upper) / Rational(2);
    const Rational midpoint_value = value.polynomial.eval(midpoint);
    if (midpoint_value == Rational(0)) {
        value.lower = midpoint;
        value.upper = midpoint;
        return Result<void>::success();
    }
 
    if (sign(lower_value) != sign(midpoint_value)) {
        value.upper = midpoint;
    } else {
        value.lower = midpoint;
    }
    return Result<void>::success();
}

引用了 context, operation, refine_exact_real_algebraic(), LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::definite::compare_boundaries(), LMCAS::detail::definite::polynomial_at_root_sign(), LMCAS::detail::definite::polynomial_sign_checked(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_endpoint_bound(), LMCAS::detail::definite::recover_rational_cut() , 以及 refine_exact_real_algebraic().

函数调用图:

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

refine_exact_real_algebraic_to_tolerance()

Result< void > LMCAS::detail::refine_exact_real_algebraic_to_tolerance	(	ExactRealAlgebraic &	value,
		double	absolute_tolerance,
		double	relative_tolerance,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_algebraic_refinement.cpp 第 131 行定义.

                                                             {
    if (!(absolute_tolerance > 0.0) || !(relative_tolerance > 0.0) ||
        !std::isfinite(absolute_tolerance) || !std::isfinite(relative_tolerance)) {
        return Result<void>::failure(
            CasErrc::InvalidArgument,
            "algebraic refinement tolerances must be finite and positive", operation);
    }
    if (value.lower == value.upper) {
        return Result<void>::success();
    }
    try {
        auto proposal = propose_dyadic_bracket(
            value, absolute_tolerance, relative_tolerance, operation);
        if (!proposal) {
            return Result<void>::failure(proposal.error());
        }
        for (int depth = std::max(1, proposal.value().initial_depth); depth <= 60; ++depth) {
            auto certified = search_dyadic_scale(value, proposal.value(), depth, context, operation);
            if (!certified) {
                return Result<void>::failure(certified.error());
            }
            if (certified.value()) {
                return Result<void>::success();
            }
        }
        return Result<void>::failure(
            CasErrc::InternalInvariant,
            "exact projection refinement could not certify the suggested bracket", operation);
    } catch (const std::bad_alloc&) {
        return Result<void>::failure(
            CasErrc::ResourceLimit, "algebraic refinement allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<void>::failure(CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 absolute_tolerance, context, LMCAS::depth, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, operation, refine_exact_real_algebraic_to_tolerance(), relative_tolerance, LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), compare_exact_real_algebraic(), refine_complex_isolation(), refine_exact_real_algebraic_to_tolerance() , 以及 LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::refine_projection_interval().

函数调用图:

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

refine_root_with_context()

std::optional< NumericRoot > LMCAS::detail::refine_root_with_context	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	var,
		const IsolatedInterval &	interval,
		const SolveOptions &	opts,
		RewriteBudget &	budget,
		std::optional< CasError > *	failure,
		bool *	complete )

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

                                                    {
    RootRefinement refinement(expr, derivative, var, interval, opts, budget);
    auto endpoint = refinement.endpoint_root();
    if (endpoint) {
        return endpoint;
    }
    if (!derivative) {
        return refinement.bisect(failure, complete);
    }
    return refinement.newton(failure, complete);
}

引用了 budget, LMCAS::interval() , 以及 refine_root_with_context().

被这些函数引用 mixed_numerical_path(), LMCAS::refine_root() , 以及 refine_root_with_context().

函数调用图:

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

reversed_relation()

RelationOp LMCAS::detail::reversed_relation ( RelationOp op )

constexprnoexcept

在文件 expression_analysis.hpp 第 20 行定义.

                                                               {
    switch (op) {
        case RelationOp::GT: return RelationOp::LT;
        case RelationOp::GEQ: return RelationOp::LEQ;
        case RelationOp::LT: return RelationOp::GT;
        case RelationOp::LEQ: return RelationOp::GEQ;
        default: return op;
    }
}

引用了 LMCAS::GEQ, LMCAS::GT, LMCAS::LEQ, LMCAS::LT, LMCAS::op , 以及 reversed_relation().

被这些函数引用 LMCAS::anonymous_namespace{relation_store.cpp}::derive_comparison_sign(), LMCAS::anonymous_namespace{assumption_conditionals.cpp}::evaluate_zero_comparison() , 以及 reversed_relation().

函数调用图:

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

rref_exact()

Result< ExactMatrixData > LMCAS::detail::rref_exact	(	ExactMatrixData	input,
		std::size_t	coefficient_columns,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix.cpp 第 121 行定义.

                                {
    auto eliminated = eliminate_exact(
        std::move(input), coefficient_columns,
        EliminationForm::ReducedRowEchelon, context, operation);
    if (!eliminated) return Result<ExactMatrixData>::failure(eliminated.error());
    return Result<ExactMatrixData>::success(
        std::move(eliminated.value().matrix));
}

引用了 context, eliminate_exact(), LMCAS::Result< T >::failure(), operation, ReducedRowEchelon, rref_exact() , 以及 LMCAS::Result< T >::success().

被这些函数引用 LMCAS::matrix_rref_checked() , 以及 rref_exact().

函数调用图:

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

simplify_expression()

ExpressionResult LMCAS::detail::simplify_expression	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 assumption_simplification.cpp 第 33 行定义.

                                                                  {
    return assumed_transform(expression, context, "LMCAS.simplify", "simplify",
        [](const SymbolicNodePtr& value, RewriteBudget& budget, const FactsQuery& facts) {
            return normalize_node(value, budget, facts);
        });
}

引用了 budget, context, facts, normalize_node(), simplify_expression() , 以及 LMCAS::value.

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_pair(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::merged_half_period_value(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::period_from_slope(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::prepare_trigonometric_affine(), LMCAS::simplify(), simplify_expression(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::zero_difference().

函数调用图:

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

solve_coefficients()

Result< bool > LMCAS::detail::solve_coefficients	(	const Polynomial< Rational > &	numerator,
		const Polynomial< Rational > &	denominator,
		const std::vector< std::pair< Polynomial< Rational >, int > > &	factors,
		std::vector< Polynomial< Rational > > &	numerators,
		ComputationContext &	context )

< P 的增广列。

在文件 integration_rational_coefficients.cpp 第 118 行定义.

                                 {
 
    numerators_out.clear();
 
    size_t num_unknowns = 0;
    std::vector<size_t> unknown_offset_per_term;
    unknown_offset_per_term.reserve(factors.size());
    if (!rd_unknown_offsets(factors, unknown_offset_per_term, num_unknowns)) { return false; }
    int N = Q.degree();
    if (N < 0) { return false; }
    size_t rows = static_cast<size_t>(N);
    size_t cols = num_unknowns + 1; /**< P 的增广列。 */
 
    std::vector<std::vector<Rational>> M(rows, std::vector<Rational>(cols, Rational(0)));
    if (P.degree() >= N) { return false; }
    for (size_t k = 0; k < rows; ++k) {
        Rational c = (k < P.coeffs.size()) ? P.coeffs[k] : Rational(0);
        M[k][num_unknowns] = c;
    }
 
    if (!rd_fill_coefficient_matrix(Q, factors, unknown_offset_per_term, M)) { return false; }
    std::vector<Rational> augmented;
    augmented.reserve(rows * cols);
    for (const auto& row : M) {
        augmented.insert(augmented.end(), row.begin(), row.end());
    }
    auto solved = detail::solve_rational_unique(
        rows, num_unknowns, std::move(augmented), context,
        "integrate.rational.coefficients");
    if (!solved) {
        if (solved.error().code == CasErrc::Inconclusive ||
            solved.error().code == CasErrc::DomainError) {
            return false;
        }
        return Result<bool>::failure(solved.error());
    }
    auto sol = std::move(solved.value());
    numerators_out.reserve(num_unknowns);
    rd_unpack_numerators(factors, unknown_offset_per_term, sol, Q.variable_name, numerators_out);
    return true;
}

引用了 LMCAS::c, LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::DomainError, LMCAS::Result< T >::failure(), LMCAS::Inconclusive, solve_rational_unique() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 LMCAS::anonymous_namespace{integration_rational.cpp}::rd_integrate_proper_fraction().

函数调用图:

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

solve_linear_exact()

Result< ExactLinearSolution > LMCAS::detail::solve_linear_exact	(	ExactMatrixData	augmented,
		std::size_t	coefficient_columns,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_matrix_solve.cpp 第 116 行定义.

                                {
    auto valid = validate_matrix(augmented, operation);
 
    if (!valid) return Result<ExactLinearSolution>::failure(valid.error());
    if (augmented.cols != coefficient_columns + 1) {
        return Result<ExactLinearSolution>::failure(
            CasErrc::InvalidArgument,
            "linear solve requires one augmented right-hand side", operation);
    }
    bool all_rational = true;
    for (const auto& entry : augmented.entries) {
        all_rational = all_rational && exact_rational(entry).has_value();
    }
    if (all_rational) {
        return rational_linear_solve(
            augmented, coefficient_columns, context, operation);
    }
    auto eliminated = eliminate_exact(
        std::move(augmented), coefficient_columns,
        EliminationForm::ReducedRowEchelon, context, operation);
    if (!eliminated) return Result<ExactLinearSolution>::failure(eliminated.error());
    auto& rref = eliminated.value().matrix;
 
    auto inconsistent = inconsistent_symbolic_system(
        rref, coefficient_columns, context, operation);
    if (!inconsistent) return Result<ExactLinearSolution>::failure(inconsistent.error());
    if (inconsistent.value()) {
        return Result<ExactLinearSolution>::success(InconsistentLinearSolution{});
    }
    std::vector<std::optional<std::size_t>> pivot_row(coefficient_columns);
    for (std::size_t index = 0;
         index < eliminated.value().pivot_columns.size(); ++index) {
        const auto column = eliminated.value().pivot_columns[index];
        if (column < coefficient_columns) pivot_row[column] = index;
    }
    return assemble_linear_solution(coefficient_columns, pivot_row,
        [&](std::size_t row, std::size_t column, bool negate) {
            const auto& value = rref.at(row, column);
            return negate ? exact_negate(value, context) : value;
        });
}

引用了 LMCAS::detail::ExactMatrixData::cols, context, eliminate_exact(), LMCAS::detail::ExactMatrixData::entries, LMCAS::detail::matrix_kernel::exact_negate(), LMCAS::detail::matrix_kernel::exact_rational(), LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::polynomial_solver_detail::negate(), operation, ReducedRowEchelon, solve_linear_exact(), LMCAS::Result< T >::success(), LMCAS::detail::matrix_kernel::validate_matrix() , 以及 LMCAS::value.

被这些函数引用 LMCAS::matrix_solve_linear_checked(), solve_linear_exact() , 以及 LMCAS::solver_detail::solve_linear_system_impl().

函数调用图:

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

solve_rational_unique()

Result< std::vector< Rational > > LMCAS::detail::solve_rational_unique	(	std::size_t	rows,
		std::size_t	coefficient_columns,
		std::vector< Rational >	matrix,
		ComputationContext &	context,
		const std::string &	operation )

在文件 exact_rational_solve.cpp 第 73 行定义.

                                {
    const std::size_t columns = coefficient_columns + 1;
    if (rows == 0 || coefficient_columns == 0 ||
        matrix.size() != rows * columns) {
        return Result<std::vector<Rational>>::failure(
            CasErrc::InvalidArgument,
            "rational linear-system storage is invalid", operation);
    }
    auto budget = context.consume_steps(rows * columns, operation);
    if (!budget) return Result<std::vector<Rational>>::failure(budget.error());
    auto pivot_rows = reduce_rational_rows(rows, coefficient_columns, matrix, true);
    if (rational_system_inconsistent(rows, coefficient_columns, matrix)) {
        return Result<std::vector<Rational>>::failure(
            CasErrc::DomainError,
            "rational linear system is inconsistent", operation);
    }
    std::vector<Rational> solution(coefficient_columns, Rational(0));
    for (std::size_t column = 0; column < coefficient_columns; ++column) {
        if (!pivot_rows[column]) {
            return Result<std::vector<Rational>>::failure(
                CasErrc::Inconclusive,
                "rational linear system does not have a unique solution",
                operation);
        }
        solution[column] =
            matrix[*pivot_rows[column] * columns + coefficient_columns];
    }
    return Result<std::vector<Rational>>::success(std::move(solution));
}

引用了 budget, context, LMCAS::DomainError, LMCAS::Inconclusive, LMCAS::InvalidArgument, operation, rational_system_inconsistent(), reduce_rational_rows() , 以及 solve_rational_unique().

被这些函数引用 solve_coefficients() , 以及 solve_rational_unique().

函数调用图:

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

squared_norm_terms()

std::array< const PowerNode *, 2 > LMCAS::detail::squared_norm_terms

(

const SymbolicNode &

root

)

Recognize real-numeric norm forms without evaluating their squares.

在文件 squared_norm.cpp 第 45 行定义.

                                                                           {
    const auto* argument = square_root_argument(root);
    if (const auto* single = squared_term(argument)) {
        return {single, nullptr};
    }
    const auto* sum = dynamic_cast<const AddNode*>(argument);
    if (!sum || sum->operands().size() != 2) {
        return {};
    }
    const auto* first = squared_term(sum->operands()[0].get());
    const auto* second = squared_term(sum->operands()[1].get());
    return first && second ? std::array<const PowerNode*, 2>{first, second}
                           : std::array<const PowerNode*, 2>{};
}

引用了 squared_norm_terms().

被这些函数引用 LMCAS::detail::NumericEvaluator::evaluate(), squared_norm_terms() , 以及 LMCAS::NormalizationVisitor::try_normalize_squared_norm().

函数调用图:

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

strict_cauchy_root_bound()

Rational LMCAS::detail::strict_cauchy_root_bound ( const Polynomial< Rational > & polynomial )

inline

在文件 exact_sturm.hpp 第 14 行定义.

                                            {
    Rational maximum(0);
    const Rational leading = polynomial.lead_coeff().abs();
    for (int degree = 0; degree < polynomial.degree(); ++degree) {
        const Rational ratio =
            polynomial.coeffs[static_cast<std::size_t>(degree)].abs() / leading;
        if (maximum < ratio) maximum = ratio;
    }
    return Rational(2) + maximum;
}

引用了 LMCAS::abs(), LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::lead_coeff() , 以及 strict_cauchy_root_bound().

被这些函数引用 LMCAS::detail::complex_root::isolate_nonreal_roots(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::isolate_sturm_sequence() , 以及 strict_cauchy_root_bound().

函数调用图:

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

substitute_expression() [1/2]

ExpressionResult LMCAS::detail::substitute_expression	(	const ExprPtr &	expression,
		const std::string &	variable,
		const ExprPtr &	replacement,
		ComputationContext &	context )

在文件 assumption_simplification.cpp 第 57 行定义.

                                                                    {
    return assumed_transform(expression, context, "LMCAS.substitute", "substitute",
        [&](const SymbolicNodePtr& value, RewriteBudget& budget, const FactsQuery& facts) {
            return substitute_node(value, variable, node(replacement), budget, facts);
        });
}

引用了 budget, context, facts, node(), replacement, substitute_expression(), substitute_node(), LMCAS::value , 以及 variable.

被这些函数引用 LMCAS::substitute(), LMCAS::substitute(), substitute_expression() , 以及 substitute_expression().

函数调用图:

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

substitute_expression() [2/2]

ExpressionResult LMCAS::detail::substitute_expression	(	const ExprPtr &	expression,
		const std::vector< Binding > &	replacements,
		ComputationContext &	context )

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

                                 {
    return assumed_transform(expression, context, "LMCAS.substitute", "substitute",
        [&](SymbolicNodePtr value, RewriteBudget& budget, const FactsQuery& facts) {
            budget.measure(value);
            for (const auto& replacement : replacements) {
                const auto symbol = std::dynamic_pointer_cast<const VariableNode>(
                    node(replacement.symbol));
                if (!symbol || symbol->is_constant() || !replacement.value ||
                    !node(replacement.value)) {
                    throw CasError{CasErrc::InvalidArgument, "invalid substitution binding",
                                   "LMCAS.substitute"};
                }
                value = substitute_node(value, symbol->name(), node(replacement.value),
                                        budget, facts);
            }
            return value;
        });
}

引用了 budget, context, facts, LMCAS::InvalidArgument, LMCAS::detail::RewriteBudget::measure(), node(), replacement, substitute_expression(), substitute_node() , 以及 LMCAS::value.

函数调用图:

substitute_node()

SymbolicNodePtr LMCAS::detail::substitute_node	(	const SymbolicNodePtr &	node,
		const std::string &	variable,
		const SymbolicNodePtr &	replacement,
		RewriteBudget &	budget,
		const FactsQuery &	facts,
		Domain	domain )

在文件 symbolic_core.cpp 第 247 行定义.

                                                                        {
    budget.consume();
    if (!node || !replacement || variable.empty()) {
        throw CasError{CasErrc::InvalidArgument, "invalid substitution argument",
                       "LMCAS.substitute"};
    }
    budget.measure(node);
    budget.measure(replacement);
    auto result = substitute_free(node, variable, replacement, &budget);
    budget.measure(result);
    return normalize_node(result, budget, facts, domain);
}

引用了 budget, LMCAS::detail::RewriteBudget::consume(), domain, facts, LMCAS::InvalidArgument, LMCAS::detail::RewriteBudget::measure(), node(), normalize_node(), replacement, LMCAS::substitute_free(), substitute_node() , 以及 variable.

被这些函数引用 LMCAS::asymptotic_expand(), LMCAS::cauchy_integral_impl(), LMCAS::classify_singular_point_checked(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_constant(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), LMCAS::curve_integral_scalar(), LMCAS::curve_integral_vector(), LMCAS::detect_parity(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::extract_constant_term(), LMCAS::inflection_curve_defined(), LMCAS::inverse_branch_derivative(), LMCAS::is_analytic_impl(), LMCAS::is_homogeneous_ode(), LMCAS::is_linear_first_order(), LMCAS::transform_detail::laplace_transform_core(), LMCAS::laurent_series_full_impl(), mixed_evaluate_at(), LMCAS::ordinary_taylor_coefficients(), LMCAS::ratio_convergence_test(), LMCAS::singular_taylor_coefficients(), LMCAS::solve_homogeneous_ode_impl(), LMCAS::stokes_theorem(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), substitute_expression(), substitute_expression(), LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series(), substitute_node(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_at_point_checked(), LMCAS::surface_integral_scalar(), LMCAS::surface_integral_vector(), LMCAS::symbolic_product(), LMCAS::symbolic_sum(), LMCAS::tf_back_substitute(), LMCAS::vector_calculus_constant_integrand(), LMCAS::vector_calculus_evaluate_hessian_at_point(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_numerical_definite(), LMCAS::vector_calculus_substitute_coords_strict(), LMCAS::verified_real_inverse_candidates(), LMCAS::verify_lagrange_solutions() , 以及 LMCAS::DifferentiationVisitor::visit().

函数调用图:

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

substitute_raw()

ExprPtr LMCAS::detail::substitute_raw	(	const ExprPtr &	expression,
		const std::string &	variable,
		const ExprPtr &	value )

在文件 solve_solution_finalization.cpp 第 20 行定义.

                                                     {
    return detail::make_expression_ptr(substitute_free(
        detail::node(expression), variable, detail::node(value)));
}

引用了 make_expression_ptr(), node(), LMCAS::substitute_free(), LMCAS::value , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness().

函数调用图:

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

symbolic_to_poly_checked()

Result< Polynomial< SymbolicPolyCoeff > > LMCAS::detail::symbolic_to_poly_checked	(	const SymbolicExpr &	expression,
		const std::string &	variable,
		ComputationContext &	context )

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

                                                                                            {
    using ConversionResult = Result<Polynomial<SymbolicPolyCoeff>>;
    if (!detail::node(expression) || variable.empty()) {
        return ConversionResult::failure(CasErrc::InvalidArgument,
            "Expression and variable must not be empty", "polynomial.convert");
    }
    try {
        auto step = context.consume_steps(1, "polynomial.convert");
        if (!step) return ConversionResult::failure(step.error());
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
            context.limits().max_ast_nodes, "polynomial.convert");
        budget.measure(detail::node(expression));
        return symbolic_to_poly_recursive<SymbolicPolyCoeff>(
            detail::node(expression), variable, &context, &budget);
    } catch (const CasError& error) {
        return ConversionResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ConversionResult::failure(CasErrc::ResourceLimit,
            "Polynomial allocation failed", "polynomial.convert");
    } catch (const std::length_error& error) {
        return ConversionResult::failure(CasErrc::ResourceLimit,
            error.what(), "polynomial.convert");
    }
}

引用了 budget, context, LMCAS::InvalidArgument, LMCAS::detail::RewriteBudget::measure(), node(), LMCAS::ResourceLimit, LMCAS::symbolic_to_poly_recursive() , 以及 variable.

被这些函数引用 recognize_affine().

函数调用图:

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

symmetric_remainder()

BigInt LMCAS::detail::symmetric_remainder ( const BigInt & value, const BigInt & modulus )

inline

在文件 exact_factorization_support.hpp 第 7 行定义.

                                                         {
    if (modulus == BigInt(0)) return value;
    auto remainder = value % modulus;
    if (remainder < BigInt(0)) remainder = remainder + modulus;
    if (remainder > modulus / BigInt(2)) remainder = remainder - modulus;
    return remainder;
}

引用了 symmetric_remainder() , 以及 LMCAS::value.

被这些函数引用 LMCAS::hl_extended_gcd_poly(), LMCAS::hl_poly_divmod(), LMCAS::hl_reduce_coeffs(), symmetric_remainder(), LMCAS::zc_subset_product() , 以及 LMCAS::zc_validate_lifted_product().

函数调用图:

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

try_finite_numeric()

std::optional< double > LMCAS::detail::try_finite_numeric ( const SymbolicExpr & expression, ComputationContext & context )

inline

在文件 numeric_probe.hpp 第 10 行定义.

{
    auto evaluated = evaluate_numeric(expression, NumericBindings{}, context);
    if (!evaluated) {
        switch (evaluated.error().code) {
        case CasErrc::UnboundSymbol:
        case CasErrc::UnsupportedExpression:
        case CasErrc::DomainError:
            return std::nullopt;
        default:
            throw evaluated.error();
        }
    }
    if (!evaluated.value().is_finite()) {
        return std::nullopt;
    }
    if (!std::isfinite(evaluated.value().value)) {
        throw CasError{CasErrc::NumericFailure,
                       "numeric evaluation produced a nonfinite result",
                       "evaluate_numeric"};
    }
    return evaluated.value().value;
}

引用了 context, LMCAS::DomainError, LMCAS::evaluate_numeric(), LMCAS::NumericFailure, try_finite_numeric(), LMCAS::UnboundSymbol , 以及 LMCAS::UnsupportedExpression.

被这些函数引用 mixed_evaluate_at(), LMCAS::detail::inequality_support::try_checked_numeric_constant(), LMCAS::detail::transcendental::try_evaluate_numeric(), try_finite_numeric() , 以及 LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric().

函数调用图:

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

变量说明

absolute_tolerance

double LMCAS::detail::absolute_tolerance

在文件 exact_algebraic.hpp 第 36 行定义.

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::propose_dyadic_bracket() , 以及 refine_exact_real_algebraic_to_tolerance().

budget

const std::string const SymbolicNodePtr RewriteBudget & LMCAS::detail::budget

在文件 expression_transform.hpp 第 16 行定义.

被这些函数引用 LMCAS::detail::RewriteBudget::Measurement::Measurement(), LMCAS::detail::RewriteScope::RewriteScope(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::RootIsolation(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::RootRefinement(), LMCAS::detail::SymbolicVisitor::SymbolicVisitor(), all_variable_names(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::capture_free_integer_parameter(), LMCAS::detail::AssumptionFacts::collect_names(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::determinant_cofactor(), differentiate_expression(), differentiate_node(), expand_expression(), expand_node(), LMCAS::detail::RewriteBudget::input_nodes(), integrate_power_primitive(), integration_depends_on_variable(), isolate_roots_with_context(), materialize_integral(), mixed_evaluate_at(), mixed_evaluate_with_retry(), mixed_numerical_path(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), normalize_node(), LMCAS::detail::AssumptionFacts::operator=(), LMCAS::detail::definite::product_checked(), rational_determinant_value_impl(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), refine_root_with_context(), LMCAS::detail::ScopedFacts::shadows(), simplify_expression(), solve_rational_unique(), substitute_expression(), substitute_expression(), substitute_node() , 以及 symbolic_to_poly_checked().

context

ExactRealAlgebraic ComputationContext & LMCAS::detail::context

在文件 exact_algebraic.hpp 第 27 行定义.

被这些函数引用 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::DomainTraversal(), LMCAS::detail::ExactBoundArithmetic::ExactBoundArithmetic(), LMCAS::detail::anonymous_namespace{rewrite_budget.cpp}::MeasurementRecursion::MeasurementRecursion(), LMCAS::detail::NumericEvaluator::NumericEvaluator(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::RealPrimitiveCandidate(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::SegmentExpression(), __attribute__(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_lambert_pattern(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_power_pattern(), LMCAS::detail::inequality_support::append_affine_root(), LMCAS::detail::inequality_support::append_factor_roots(), LMCAS::detail::inequality_support::append_quadratic_roots(), LMCAS::detail::inequality_support::append_verified_roots(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::detail::definite::boundary_checked(), LMCAS::detail::definite::boundary_value_checked(), LMCAS::detail::inequality_support::build_parametric_intervals(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::capture_free_integer_parameter(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::certify_conjugate_projections(), LMCAS::detail::definite::certify_continuity_checked(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::certify_dyadic_candidate(), LMCAS::detail::anonymous_namespace{exact_constant_bounds.cpp}::checked_bounds(), checked_transform_expr(), LMCAS::detail::matrix_kernel::choose_pivot(), classify_exact_zero(), classify_quadric_impl(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_translated_quadric(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::clear_isolation_endpoints(), LMCAS::detail::inequality_support::close_symbolic_endpoint(), LMCAS::detail::anonymous_namespace{facts_query_rational.cpp}::closed_rational_power(), closed_rational_value(), closed_rational_value(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_constant(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), LMCAS::detail::definite::collect_predicate_roots(), LMCAS::detail::anonymous_namespace{exact_algebraic.cpp}::common_root_in_enclosures(), comparable_endpoint(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_finite_endpoint(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_root(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_surd(), LMCAS::detail::definite::compare_boundaries(), compare_comparable(), compare_exact_real_algebraic(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::compare_isolations(), compare_pointwise_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::construct_roots(), consume_mixed_step(), LMCAS::detail::definite::continuous_children(), LMCAS::detail::complex_root::coordinate_projections(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::count_open_roots(), count_real_roots_exact(), LMCAS::detail::complex_root::count_rectangle_roots(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::count_sheared_edges(), LMCAS::detail::transcendental::decompose_exp_base_pattern(), LMCAS::detail::transcendental::decompose_lambert_w_pattern(), LMCAS::detail::definite::defined_on_interval(), LMCAS::detail::definite::definite_partition_checked(), LMCAS::detail::definite::definite_segment_checked(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::determinant_cofactor(), determinant_exact(), LMCAS::detail::inequality_support::determine_leading_sign(), differentiate_expression(), domain_constraints(), domain_constraints(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::edge_is_clear(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::eliminate_below(), eliminate_exact(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::eliminate_forward(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::eliminate_resultant_row(), equal_exact_real_algebraic(), equivalent_impl(), evaluate_root_complex(), evaluate_root_real(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::detail::matrix_kernel::exact_add(), exact_atan_bounds(), LMCAS::detail::matrix_decomposition::exact_diagonal_entries(), LMCAS::detail::matrix_kernel::exact_divide(), exact_double_rational(), exact_e_bounds(), LMCAS::detail::matrix_kernel::exact_multiply(), LMCAS::detail::matrix_kernel::exact_negate(), LMCAS::detail::inequality_support::exact_numeric_sign(), exact_pi_bounds(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::exact_poly_divide(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), LMCAS::detail::matrix_decomposition::exact_rational_matrix(), LMCAS::detail::matrix_decomposition::exact_rectangular_diagonal_entries(), LMCAS::detail::matrix_kernel::exact_subtract(), expand_expression(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_axis_coefficients(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_mixed_coefficients(), factor_homogeneous_bivariate(), finalize_solution_set(), LMCAS::detail::inequality_support::find_roots_with_multiplicity(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::finite_numeric_coeff(), LMCAS::detail::definite::gcd_checked(), LMCAS::detail::matrix_decomposition::identity_matrix_expr(), LMCAS::detail::inequality_support::include_numeric_root(), LMCAS::detail::inequality_support::include_symbolic_root(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::inconsistent_symbolic_system(), integrate_power_primitive(), inverse_exact(), LMCAS::detail::transcendental::invert_exp_base(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::invert_lambert_w(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::detail::anonymous_namespace{facts_query_adapters.cpp}::NoFacts::is_negative(), LMCAS::detail::AssumptionFacts::is_negative(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_negative(), LMCAS::detail::ScopedFacts::is_negative(), LMCAS::detail::anonymous_namespace{facts_query_adapters.cpp}::NoFacts::is_nonnegative(), LMCAS::detail::AssumptionFacts::is_nonnegative(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_nonnegative(), LMCAS::detail::ScopedFacts::is_nonnegative(), LMCAS::detail::anonymous_namespace{facts_query_adapters.cpp}::NoFacts::is_nonzero(), LMCAS::detail::AssumptionFacts::is_nonzero(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_nonzero(), LMCAS::detail::ScopedFacts::is_nonzero(), LMCAS::detail::anonymous_namespace{facts_query_adapters.cpp}::NoFacts::is_positive(), LMCAS::detail::AssumptionFacts::is_positive(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_positive(), LMCAS::detail::ScopedFacts::is_positive(), LMCAS::detail::anonymous_namespace{facts_query_adapters.cpp}::NoFacts::is_real(), LMCAS::detail::AssumptionFacts::is_real(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_real(), LMCAS::detail::ScopedFacts::is_real(), isolate_exact_root(), isolate_exact_roots(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::isolate_factors(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::isolate_grid_row(), LMCAS::detail::complex_root::isolate_nonreal_roots(), isolate_real_roots_exact(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::isolate_sturm_sequence(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::isolate_unfactored(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::left_pole_sample(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), make_exact_real_algebraic(), make_exact_root_id(), make_rootof_solutions_impl(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::make_sturm_sequence(), matrix_eigenspaces_checked(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::negative_discriminant(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize_coefficients(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalized_root(), nullspace_exact(), LMCAS::detail::AssumptionFacts::operator=(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::opposite_exponential_lambert_pattern(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::order_isolations(), LMCAS::detail::definite::ordered_partition_roots(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::pole_index(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::pole_interval_is_clear(), LMCAS::detail::definite::polynomial_at_root_sign(), LMCAS::detail::definite::polynomial_budget(), LMCAS::detail::definite::polynomial_sign_checked(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::power_pattern(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::predicate_truth(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::prepare_projection_grid(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::prepare_trigonometric_affine(), LMCAS::detail::definite::product_checked(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::property(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_coefficients(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_zero(), query_definedness(), query_definedness(), query_nonnegative_value(), query_nonnegative_value(), query_nonzero_value(), query_nonzero_value(), query_positive_value(), query_positive_value(), query_real_value(), query_real_value(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::query_value(), rank_exact(), LMCAS::detail::definite::rational_checked(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::rational_determinant(), rational_determinant_exact(), rational_determinant_value_impl(), LMCAS::detail::definite::rational_divergence_checked(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), LMCAS::detail::definite::rational_operands_checked(), LMCAS::detail::definite::rational_pole_divergence(), LMCAS::detail::definite::rational_power_checked(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::real_affine_coefficients(), LMCAS::detail::definite::real_assumptions(), real_quadratic_roots_checked(), recognize_affine(), LMCAS::detail::definite::recover_rational_cut(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::reduce_above(), refine_complex_isolation(), refine_exact_real_algebraic(), refine_exact_real_algebraic_to_tolerance(), LMCAS::detail::complex_root::refine_interval(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::refine_pole_interval(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::refine_projection_interval(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::relational_predicate_truth(), LMCAS::detail::matrix_api::require_matrix(), LMCAS::detail::matrix_api::require_square_matrix(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::resultant_determinant(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_expression_sign(), LMCAS::detail::inequality_support::root_less_than(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_node_sign(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_power_sign(), LMCAS::detail::definite::roots_checked(), LMCAS::detail::inequality_support::roots_equal(), rref_exact(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::search_dyadic_scale(), LMCAS::detail::definite::segment_expression_checked(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_imaginary_axis(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_projection_intervals(), LMCAS::detail::ScopedFacts::shadows(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::simplify_exact_rational_expr(), LMCAS::detail::matrix_kernel::simplify_expr(), simplify_expression(), LMCAS::detail::inequality_support::snap_verified_integer_root(), solve_coefficients(), LMCAS::detail::inequality_support::solve_exact_affine_inequality(), LMCAS::detail::inequality_support::solve_exact_polynomial_inequality(), solve_linear_exact(), solve_rational_unique(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::solve_real_quadratic(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::strict_factors(), LMCAS::detail::definite::structurally_continuous(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::subdivide_isolation(), substitute_expression(), substitute_expression(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::subtract_pivot_row(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::sylvester_resultant(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::symbolic_determinant_value(), symbolic_to_poly_checked(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::to_algebraic(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::detail::inequality_support::try_checked_numeric_constant(), LMCAS::detail::transcendental::try_evaluate_numeric(), try_finite_numeric(), LMCAS::detail::anonymous_namespace{facts_query_adapters.cpp}::NoFacts::unknown(), LMCAS::detail::matrix_decomposition::validate_decomposition_matrix(), LMCAS::detail::series_support::validate_series_variable(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign_impl(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::variations_at(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root() , 以及 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::walk().

domain

const std::string const SymbolicNodePtr RewriteBudget const FactsQuery Domain LMCAS::detail::domain = Domain::Real)

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

被这些函数引用 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::DomainTraversal(), LMCAS::detail::anonymous_namespace{facts_query_rational.cpp}::closed_rational_power(), closed_rational_value(), closed_rational_value(), compare_pointwise_values(), differentiate_node(), domain_constraints(), domain_constraints(), expand_node(), finalize_solution_set(), normalize_node(), LMCAS::detail::definite::original_conditions_checked(), query_definedness(), query_definedness(), query_nonzero_value(), query_nonzero_value(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::query_value(), substitute_node(), LMCAS::detail::SymbolicRewriter::visit() , 以及 LMCAS::detail::SymbolicRewriter::visit().

facts

const std::string const SymbolicNodePtr RewriteBudget const FactsQuery & LMCAS::detail::facts = no_facts()

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

被这些函数引用 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::DomainTraversal(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::RealPrimitiveCandidate(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::SegmentExpression(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::detail::definite::certify_continuity_checked(), compare_pointwise_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), LMCAS::detail::definite::continuous_children(), LMCAS::detail::definite::defined_on_interval(), LMCAS::detail::definite::definite_partition_checked(), differentiate_expression(), differentiate_node(), domain_constraints(), domain_constraints(), expand_expression(), expand_node(), integrate_power_primitive(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), matrix_eigenspaces_checked(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::negative_discriminant(), no_facts(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), normalize_node(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::predicate_truth(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_coefficients(), query_definedness(), query_definedness(), query_nonnegative_value(), query_nonnegative_value(), query_nonzero_value(), query_nonzero_value(), query_positive_value(), query_positive_value(), query_real_value(), query_real_value(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::query_value(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::real_affine_coefficients(), real_quadratic_roots_checked(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::relational_predicate_truth(), LMCAS::detail::definite::segment_expression_checked(), simplify_expression(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::solve_real_quadratic(), LMCAS::detail::definite::structurally_continuous(), substitute_expression(), substitute_expression(), substitute_node() , 以及 LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range().

main_var

const std::string& LMCAS::detail::main_var

在文件 multivariate_factor.hpp 第 171 行定义.

被这些函数引用 __attribute__() , 以及 is_linear().

multiplicity

std::size_t std::size_t LMCAS::detail::multiplicity

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

被这些函数引用 LMCAS::detail::inequality_support::append_verified_roots(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), make_exact_real_algebraic() , 以及 LMCAS::detail::definite::rational_pole_divergence().

operation

double double ComputationContext const std::string & LMCAS::detail::operation = "exact_algebraic.refine")

在文件 exact_algebraic.hpp 第 32 行定义.

被这些函数引用 LMCAS::detail::ExactBoundArithmetic::ExactBoundArithmetic(), LMCAS::detail::anonymous_namespace{rewrite_budget.cpp}::MeasurementRecursion::MeasurementRecursion(), LMCAS::detail::RewriteBudget::RewriteBudget(), LMCAS::detail::RewriteBudget::RewriteBudget(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::center_quadric(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::certify_conjugate_projections(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::certify_dyadic_candidate(), LMCAS::detail::anonymous_namespace{exact_constant_bounds.cpp}::checked_bounds(), checked_transform_expr(), LMCAS::detail::matrix_kernel::choose_pivot(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_centered_locus(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_definite_locus(), classify_exact_zero(), classify_quadric_impl(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_rank_two_locus(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_translated_quadric(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::clear_isolation_endpoints(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_constant(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), comparable_endpoint(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_finite_endpoint(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_root(), compare_pointwise_values(), constant_expression(), LMCAS::detail::complex_root::coordinate_projections(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::count_open_roots(), count_real_roots_exact(), LMCAS::detail::complex_root::count_rectangle_roots(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::count_sheared_edges(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::determinant_cofactor(), determinant_exact(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::edge_is_clear(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::eliminate_below(), eliminate_exact(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::eliminate_forward(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::eliminate_resultant_row(), evaluate_root_complex(), evaluate_root_real(), exact_double_rational(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::exact_poly_divide(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_axis_coefficients(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_mixed_coefficients(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::finite_numeric_coeff(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::inconsistent_symbolic_system(), LMCAS::detail::RewriteBudget::input_nodes(), inverse_exact(), isolate_exact_root(), isolate_exact_roots(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::isolate_factors(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::isolate_grid_row(), LMCAS::detail::complex_root::isolate_nonreal_roots(), isolate_real_roots_exact(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::isolate_sturm_sequence(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::isolate_unfactored(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::left_pole_sample(), make_exact_root_id(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::make_sturm_sequence(), matrix_eigenspaces_checked(), nullspace_exact(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::pole_index(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::pole_interval_is_clear(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::prepare_projection_grid(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::project_linear_coefficients(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::propose_dyadic_bracket(), rank_exact(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::rational_determinant(), rational_determinant_exact(), rational_determinant_value_impl(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::reduce_above(), refine_complex_isolation(), refine_exact_real_algebraic(), refine_exact_real_algebraic_to_tolerance(), LMCAS::detail::complex_root::refine_interval(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::refine_pole_interval(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::refine_projection_interval(), LMCAS::detail::matrix_api::require_matrix(), LMCAS::detail::matrix_api::require_matrix_result(), LMCAS::detail::matrix_api::require_square_matrix(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::resultant_determinant(), rref_exact(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::search_dyadic_scale(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_imaginary_axis(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_projection_intervals(), solve_linear_exact(), solve_rational_unique(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::subdivide_isolation(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::sylvester_resultant(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::symbolic_determinant_value(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::unsupported_endpoint(), LMCAS::detail::matrix_decomposition::validate_decomposition_matrix(), LMCAS::detail::matrix_decomposition::validate_decomposition_output(), LMCAS::detail::matrix_kernel::validate_matrix(), LMCAS::detail::series_support::validate_power_series_coefficients(), LMCAS::detail::series_support::validate_series_variable() , 以及 LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::variations_at().

relative_tolerance

double double LMCAS::detail::relative_tolerance

在文件 exact_algebraic.hpp 第 37 行定义.

被这些函数引用 LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::propose_dyadic_bracket() , 以及 refine_exact_real_algebraic_to_tolerance().

replacement

const std::string const SymbolicNodePtr& LMCAS::detail::replacement

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

被这些函数引用 LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::resultant_determinant(), substitute_expression(), substitute_expression() , 以及 substitute_node().

rhs

ExactRealAlgebraic LMCAS::detail::rhs

在文件 exact_algebraic.hpp 第 43 行定义.

被这些函数引用 LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_lambert_pattern(), LMCAS::detail::anonymous_namespace{exact_algebraic.cpp}::common_root_in_enclosures(), compare_exact_real_algebraic(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::constant_trigonometric_preimage(), equal_exact_real_algebraic(), equivalent_impl(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::inconsistent_symbolic_system(), LMCAS::detail::RewriteBudget::input_nodes(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::invert_function(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::detail::anonymous_namespace{exact_algebraic.cpp}::same_polynomial(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_principal_value() , 以及 LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range().

root_index

std::size_t LMCAS::detail::root_index

在文件 exact_algebraic.hpp 第 25 行定义.

被这些函数引用 make_exact_real_algebraic().

variable

const std::string & LMCAS::detail::variable

在文件 expression_transform.hpp 第 22 行定义.

被这些函数引用 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::SegmentFacts(), LMCAS::detail::inequality_support::append_factor_roots(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), LMCAS::detail::AssumptionFacts::collect_names(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::constant_poly(), differentiate_expression(), differentiate_node(), finalize_solution_set(), LMCAS::detail::inequality_support::find_roots_with_multiplicity(), integrate_power_primitive(), integration_depends_on_variable(), materialize_integral(), multipoly_term_factors(), recognize_affine(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::resultant_determinant(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::structural(), substitute_expression(), substitute_node(), substitute_raw(), LMCAS::detail::series_support::supported_laurent_integer_power(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::sylvester_matrix(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::sylvester_resultant(), symbolic_to_poly_checked(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::unsupported_endpoint() , 以及 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::variable_facts().