LMCAS 命名空间参考

命名空间
namespace	anonymous_namespace{assumption_conditionals.cpp}
namespace	anonymous_namespace{assumption_context.cpp}
namespace	anonymous_namespace{assumption_serialization.cpp}
namespace	anonymous_namespace{bigint_arithmetic.cpp}
namespace	anonymous_namespace{bigint_combinatorics.cpp}
namespace	anonymous_namespace{bigint_number_theory.cpp}
namespace	anonymous_namespace{calculus_continuity.cpp}
namespace	anonymous_namespace{complex_analysis.cpp}
namespace	anonymous_namespace{differential_geometry.cpp}
namespace	anonymous_namespace{differentiation_functions.cpp}
namespace	anonymous_namespace{equivalence_engine.cpp}
namespace	anonymous_namespace{equivalence_options.cpp}
namespace	anonymous_namespace{expr_complex_evaluation.cpp}
namespace	anonymous_namespace{expr_errors.cpp}
namespace	anonymous_namespace{expr_facade.cpp}
namespace	anonymous_namespace{expr_number_domains.cpp}
namespace	anonymous_namespace{expr_serialization.cpp}
namespace	anonymous_namespace{expr_serialization_reader.cpp}
namespace	anonymous_namespace{expression_analysis.cpp}
namespace	anonymous_namespace{fglm.cpp}
namespace	anonymous_namespace{fglm_polynomial.cpp}
namespace	anonymous_namespace{inequality_solver.cpp}
namespace	anonymous_namespace{inequality_solver_parametric.cpp}
namespace	anonymous_namespace{inequality_solver_polynomial.cpp}
namespace	anonymous_namespace{inequality_solver_rational.cpp}
namespace	anonymous_namespace{inference_engine_bounds.cpp}
namespace	anonymous_namespace{inference_engine_periodicity.cpp}
namespace	anonymous_namespace{inference_engine_product.cpp}
namespace	anonymous_namespace{integration_by_parts.cpp}
namespace	anonymous_namespace{integration_definite.cpp}
namespace	anonymous_namespace{integration_linearity.cpp}
namespace	anonymous_namespace{integration_rational.cpp}
namespace	anonymous_namespace{integration_rational_coefficients.cpp}
namespace	anonymous_namespace{integration_rational_collection.cpp}
namespace	anonymous_namespace{integration_rational_factorization.cpp}
namespace	anonymous_namespace{integration_rational_terms.cpp}
namespace	anonymous_namespace{integration_special_functions.cpp}
namespace	anonymous_namespace{integration_substitution.cpp}
namespace	anonymous_namespace{integration_trig_substitution.cpp}
namespace	anonymous_namespace{integration_trigonometric.cpp}
namespace	anonymous_namespace{integration_weierstrass.cpp}
namespace	anonymous_namespace{integrator.cpp}
namespace	anonymous_namespace{interval_normalization.cpp}
namespace	anonymous_namespace{interval_set_operations.cpp}
namespace	anonymous_namespace{irrational_representation.cpp}
namespace	anonymous_namespace{irrational_symbolic.cpp}
namespace	anonymous_namespace{limit_result.cpp}
namespace	anonymous_namespace{limit_visitor_asymptotic.cpp}
namespace	anonymous_namespace{limit_visitor_composition.cpp}
namespace	anonymous_namespace{limit_visitor_direction.cpp}
namespace	anonymous_namespace{limit_visitor_taylor.cpp}
namespace	anonymous_namespace{matrix_decomposition.cpp}
namespace	anonymous_namespace{matrix_decomposition_cholesky.cpp}
namespace	anonymous_namespace{matrix_decomposition_eigen.cpp}
namespace	anonymous_namespace{matrix_decomposition_lu.cpp}
namespace	anonymous_namespace{matrix_decomposition_qr.cpp}
namespace	anonymous_namespace{matrix_quadratic_form.cpp}
namespace	anonymous_namespace{mixed_transcendental_classification.cpp}
namespace	anonymous_namespace{mixed_transcendental_search.cpp}
namespace	anonymous_namespace{multivariate_factor_checked.cpp}
namespace	anonymous_namespace{newton_raphson.cpp}
namespace	anonymous_namespace{normalization_arithmetic.cpp}
namespace	anonymous_namespace{normalization_matrices.cpp}
namespace	anonymous_namespace{normalization_norms.cpp}
namespace	anonymous_namespace{normalization_numeric_functions.cpp}
namespace	anonymous_namespace{normalization_numeric_powers.cpp}
namespace	anonymous_namespace{normalization_products.cpp}
namespace	anonymous_namespace{normalization_signs.cpp}
namespace	anonymous_namespace{normalization_trigonometric.cpp}
namespace	anonymous_namespace{numeric_evaluation.cpp}
namespace	anonymous_namespace{numerical_integration.cpp}
namespace	anonymous_namespace{parametric_solver_branches.cpp}
namespace	anonymous_namespace{poly_utils.cpp}
namespace	anonymous_namespace{print_visitor.cpp}
namespace	anonymous_namespace{property_classification.cpp}
namespace	anonymous_namespace{property_store.cpp}
namespace	anonymous_namespace{quantity.cpp}
namespace	anonymous_namespace{query_conditions.cpp}
namespace	anonymous_namespace{rational_parsing.cpp}
namespace	anonymous_namespace{rational_polynomial_recognition.cpp}
namespace	anonymous_namespace{rational_representation.cpp}
namespace	anonymous_namespace{relation_store.cpp}
namespace	anonymous_namespace{residual_comparison.cpp}
namespace	anonymous_namespace{residual_verification.cpp}
namespace	anonymous_namespace{root_of_identity.cpp}
namespace	anonymous_namespace{series_engine.cpp}
namespace	anonymous_namespace{solve_mixed_transcendental.cpp}
namespace	anonymous_namespace{solve_solution_finalization.cpp}
namespace	anonymous_namespace{solve_transcendental.cpp}
namespace	anonymous_namespace{solver_assumptions.cpp}
namespace	anonymous_namespace{solver_groebner.cpp}
namespace	anonymous_namespace{solver_groebner_system.cpp}
namespace	anonymous_namespace{symbolic_algebra_adapter.cpp}
namespace	anonymous_namespace{symbolic_cancel.cpp}
namespace	anonymous_namespace{symbolic_complex.cpp}
namespace	anonymous_namespace{symbolic_construction.cpp}
namespace	anonymous_namespace{symbolic_factor.cpp}
namespace	anonymous_namespace{symbolic_factory.cpp}
namespace	anonymous_namespace{symbolic_gcd.cpp}
namespace	anonymous_namespace{symbolic_geometry.cpp}
namespace	anonymous_namespace{symbolic_geometry_line.cpp}
namespace	anonymous_namespace{symbolic_geometry_line_plane.cpp}
namespace	anonymous_namespace{symbolic_geometry_plane.cpp}
namespace	anonymous_namespace{symbolic_geometry_surface.cpp}
namespace	anonymous_namespace{symbolic_geometry_vector.cpp}
namespace	anonymous_namespace{symbolic_matrix_eigen.cpp}
namespace	anonymous_namespace{symbolic_matrix_transform.cpp}
namespace	anonymous_namespace{symbolic_node_order.cpp}
namespace	anonymous_namespace{symbolic_number_order.cpp}
namespace	anonymous_namespace{symbolic_ode.cpp}
namespace	anonymous_namespace{symbolic_set.cpp}
namespace	anonymous_namespace{transcendental_rewrite.cpp}
namespace	anonymous_namespace{transcendental_solver_substitution.cpp}
namespace	anonymous_namespace{unit.cpp}
namespace	anonymous_namespace{univariate_factor_bridge.cpp}
namespace	anonymous_namespace{value.cpp}
namespace	assumption_detail
namespace	berlekamp_detail
namespace	calculus_utils_detail
namespace	detail
	多元 Hensel 提升（单变量步）
namespace	equivalence_detail
namespace	expr_detail
namespace	fglm_detail
namespace	geometry_detail
namespace	groebner_detail
namespace	integration_table_detail
namespace	modular_detail
namespace	multivariate_checked_detail
namespace	ode_root_detail
namespace	polynomial_solver_detail
namespace	property_detail
namespace	query_detail
namespace	serialization_detail
namespace	solver_detail
namespace	transform_detail
namespace	vector_calculus_detail

类
class	AddNode
	加法节点，表示多个操作数的求和。 更多...
struct	ApproxComplex
struct	ApproxReal
class	AssumptionDecl
	Declaration of an assumption to apply within a with_assumptions block. 更多...
struct	AsymptoteResult
	根据左右极限与函数值，在给定上下文假设下证明实数域中的连续性分类。 跳跃与可去间断的比较需证明逐点不等，相等性需保证各值有定义；形式非恒等不足以证明二者。 参数值或有定义性未确定时返回 Inconclusive；资源、取消和底层证明错误原样传播，不作为分类。 更多...
struct	BerlekampResult
	Berlekamp 分解结果。 更多...
struct	Binding
struct	ByConstructionProof
struct	CacheKey
	由表达式结构哈希、属性和自变量组成缓存键。 更多...
struct	CacheKeyHash
	缓存键哈希，计入周期查询的自变量。 更多...
class	CancellationToken
struct	CasError
struct	CheckedInterval
struct	CholeskyDecomposition
struct	ComparableEndpoint
class	ComplexNode
	复数节点，表示 real + imag * i。 更多...
struct	ComplexSymbolic
	符号复数，由实部和虚部组成 更多...
class	ComputationContext
struct	ConditionalSolutions
struct	ConditionSet
struct	ConvergenceInfo
	收敛性判定信息. 更多...
struct	CriticalPoint
	临界点的坐标、分类及成立条件。 更多...
struct	Diagnostic
class	DiagnosticEngine
class	DifferentiationVisitor
struct	EmptySolutions
struct	EqvBudget
	各限额均为非零值；深度与规模在重写运行中检查，超限返回 ResourceLimit。 更多...
struct	EqvOptions
struct	EvaluatedTransform
	受检变换成功时返回在 conditions 和收敛域 roc 条件下有效的已求值表达式。 支持性未决或收敛条件无法表示时，返回外层 Inconclusive 错误。 更多...
struct	ExactNormalizationProof
struct	ExactResidualProof
struct	ExactRoundTripProof
class	ExpandVisitor
struct	ExprMatch
struct	ExprMatchBinding
class	ExprParser
class	FactsQuery
struct	FiniteLimit
	已证在请求的实数或复数域内有定义的有限值。 表达式树中所有极限均已求定，扩展实数运算均有确定结果。 更多...
class	FiniteSetNode
struct	FiniteSolution
	conditions 是在操作上下文假设下须同时满足的条件。 空条件保留原表达式定义域且不增加约束；整数参数遍历全体整数。 更多...
struct	FiniteSolutions
struct	FourierPeriod
struct	FrobeniusSolution
	Frobenius 级数解结果. 更多...
class	FunctionNode
	函数节点，表示数学函数调用（三角函数、对数、特殊函数等）。 更多...
struct	GcdSamples
struct	HenselLiftPair
	二因子二次 Hensel 提升的状态结构. 更多...
class	IntegralNode
struct	IntegrationStep
class	IntervalNode
struct	IntervalSolution
struct	IntervalSolutions
struct	IsolatedInterval
	隔离子区间,包含至多一个根 更多...
struct	JordanDecomposition
struct	LaurentResult
	洛朗级数展开结果. 更多...
struct	LimitDoesNotExist
class	LimitNode
struct	LineSymbolic
	由一点和方向向量定义的符号直线。 更多...
class	LogicalNode
struct	LUDecomposition
struct	MathResult
struct	MatrixInconsistentLinearSolution
class	MatrixNode
	矩阵节点，支持稠密和稀疏两种存储方式。 更多...
struct	MatrixParametricLinearSolution
struct	MatrixUniqueLinearSolution
class	MembershipNode
class	ModInt
	模整数类，封装模 p 下的算术运算 更多...
class	MonomialOrder
	单项式序比较器，支持 Lex、GrevLex、DegLex、DegRevLex 更多...
struct	MultiFactorResult
	多元因式分解结果 更多...
class	MultiplyNode
	乘法节点，表示多个操作数的乘积。 更多...
struct	NegativeInfinityLimit
struct	NodeCompare
struct	NodeEqual
struct	NodeHash
struct	NodeLess
class	NormalizationVisitor
	统一规范化数值幂。 精确操作数保留整数和有理数运算；近似求根要求指数精确等于 1/2。 有限浮点幂直接折叠，省去倒数中间值；非有限结果保留幂表达式。 更多...
class	NumberNode
struct	NumericRoot
	数值根结果,包含根值,残差和迭代次数. 更多...
struct	ODEClassification
	ODE 分类结果,包含类型及提取的结构信息. 更多...
struct	ODESolution
	ODE 求解结果. 更多...
struct	OdeTaylorCoefficients
struct	ParametricSolution
struct	ParametricSolutions
class	PiecewiseNode
	分段函数节点,表示条件分支表达式. 更多...
struct	PiecewiseSolution
	含参方程组的分段解，按参数条件分类 更多...
struct	PlaneSymbolic
	由法向量和常数 d 定义的符号平面 ax + by + cz = d。 更多...
class	Polynomial
	一元多项式模板类 更多...
struct	PositiveInfinityLimit
class	PowerNode
	幂运算节点，表示 base^exponent。 更多...
class	ProductNode
	连乘节点,表示符号有限/无限连乘 prod_{k=a}^{b} f(k). 更多...
struct	ProvedNonIdentityResidual
	证明残差在原公共定义域上非恒零，例如非零有理多项式。 残差仍可能在特定参数值处为零；点值不等性、定义域及上下文假设下的非零性均需另行证明。 更多...
struct	ProvedZeroResidual
	在表达式的原公共定义域上认证值相等；点值定义域与分母条件需另行证明。 更多...
struct	QRDecomposition
struct	QuadraticBoundaries
struct	QuadratureEstimate
class	QuantifierNode
class	QuantityNode
struct	RationalRootReconstruction
struct	Relation
	A stored relational constraint between two symbolic expressions. 更多...
class	RelationalNode
struct	ResourceLimits
	Per-operation limits for APIs that accept a ComputationContext. 更多...
class	Result
class	Result< void >
class	RewriteVisitor
class	RootOfNode
struct	SearchInterval
	搜索区间 更多...
class	SetBuilderNode
struct	SignChartEntry
	符号图条目,记录区间及其上的符号 更多...
struct	SignHash
	Hash functor for Sign enum to allow use in unordered_set. 更多...
struct	SolveOptions
	方程求解选项,控制数值求解行为和结果形式. 更多...
struct	SquareFreeDecomp
	无平方因子分解结果 更多...
struct	SubstitutionResult
	换元结果，记录换元表达式、换元后的多项式及换元变量名。 更多...
class	SummationNode
	求和节点,表示符号有限/无限求和 sum_{k=a}^{b} f(k). 更多...
struct	SurfaceSymbolic
	隐式曲面 F(x,y,z) = 0。 更多...
struct	SVDDecomposition
class	SymbolicFactory
class	SymbolicNode
struct	SymbolicPolyCoeff
	符号多项式算法使用的表达式系数。 更多...
struct	TfPolyBuildResult
	分解含 sin、cos、exp、ln 等超越函数的表达式。 更多...
struct	TfSquareFreeResult
	执行一步二次 Hensel 提升:mod m -> mod m^2. 更多...
class	TransformNode
	积分变换节点,表示 Laplace,Fourier,Z 变换及其逆变换. 更多...
struct	TransSubstitution
	换元映射条目:超越子表达式 -> 代数不定元名 更多...
struct	TransSubstitutionResult
	换元结果 更多...
struct	TrigSquare
class	UninterpretedFunctionNode
struct	UnitDefinition
struct	UniversalSolutions
struct	UnprovedResidual
class	VariableNode
	变量节点，表示一个符号变量。 更多...
struct	Verified
struct	ZcFactorSearch

类型定义
using	AssumptionSolveResult
using	AssumptionTriboolResult = Result<Tribool>
using	AssumptionVoidResult = Result<void>
using	AsymptoteAnalysisResult = Result<AsymptoteResult>
using	BindingResult = Result<Binding>
using	CholeskyDecompositionResult = Result<CholeskyDecomposition>
using	ComplexBoolResult = Result<bool>
using	ComplexRootsResult = Result<std::vector<ComplexSymbolic>>
using	ComplexSymbolicResult = Result<ComplexSymbolic>
using	ConstExprPtr = std::shared_ptr<const SymbolicExpr>
using	ContinuityResult = Result<ContinuityType>
using	ConvergenceInfoResult = Result<ConvergenceInfo>
using	CrtResult = Result<std::pair<int64_t, int64_t>>
using	DifferentialGeometryExprResult = Result<std::shared_ptr<SymbolicExpr>>
using	DifferentialGeometryVectorResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>
using	Expr = SymbolicExpr
using	ExpressionResult = Result<std::shared_ptr<SymbolicExpr>>
	Result of an operation that produces a symbolic expression.
using	ExprMatchResult = Result<ExprMatch>
using	ExprPtr = std::shared_ptr<SymbolicExpr>
using	ExprResult = Result<ExprPtr>
using	ExprSetResult = Result<ExprSet>
using	ExtremaResult = Result<std::vector<CriticalPoint>>
using	FiniteSolveResult
using	FrobeniusSolutionResult = Result<FrobeniusSolution>
using	HenselLiftResult = Result<std::vector<Polynomial<BigInt>>>
using	InferencePeriodResult = Result<std::optional<SymbolicExpr>>
using	InferenceTriboolResult = Result<Tribool>
using	JordanDecompositionResult = Result<JordanDecomposition>
using	LagrangeResult
using	LaurentSeriesResult = Result<LaurentResult>
using	LimitExpressionResult = Result<LimitExprPtr>
using	LimitExprPtr = std::shared_ptr<SymbolicExpr>
using	LimitOutcome
using	LimitResult = Result<Verified<LimitOutcome>>
using	LineSymbolicResult = Result<LineSymbolic>
using	LUDecompositionResult = Result<LUDecomposition>
using	MatchMap = std::unordered_map<std::string, SymbolicExpr>
	匹配结果映射，通配符名称 → 绑定的表达式
using	MatrixEigenvalueResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>
using	MatrixEigenvectorResult
using	MatrixLinearSolution
using	MatrixLinearSolveResult = Result<MatrixLinearSolution>
using	MatrixNullspaceResult
using	MatrixRankResult = Result<std::size_t>
	计算两个符号矩阵的乘积
using	MixedTranscendentalResult
	受检混合超越方程求解结果.
using	Monomial = std::vector<int>
	单项式类型，以整数向量表示各变量的指数
using	MultiFactorCheckedResult = Result<MathResult<MultiFactorResult>>
template<typename T>
using	NodeMap = std::unordered_map<std::shared_ptr<const SymbolicNode>, T, NodeHash, NodeEqual>
using	NodeSet = std::unordered_set<std::shared_ptr<const SymbolicNode>, NodeHash, NodeEqual>
using	NumericBindings = std::unordered_map<std::string, double>
using	NumericRootResult = Result<std::optional<NumericRoot>>
using	NumericRootsResult = Result<std::vector<NumericRoot>>
using	ODESingularityResult = Result<ODESingularityType>
using	ODESolutionResult = Result<ODESolution>
template<typename T>
using	OptionalRationalPolynomial = std::optional<Polynomial<Rational>>
	将符号表达式转换为一元多项式。
using	ParametricMatrix = std::vector<std::vector<std::shared_ptr<SymbolicExpr>>>
using	ParametricSolutionList
using	ParametricSolutionsResult = Result<ParametricSolutionList>
using	ParametricVector = std::vector<std::shared_ptr<SymbolicExpr>>
using	PlaneSymbolicResult = Result<PlaneSymbolic>
using	PolynomialSystemResult
	多项式方程组求解器，提供线性系统求解、Gröbner 基计算及多项式系统求解功能。
using	PowerSeriesResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>
using	ProofCertificate
using	ProofExprPtr = std::shared_ptr<SymbolicExpr>
using	PropertyStoreResult = Result<void>
using	QRDecompositionResult = Result<QRDecomposition>
using	QuantityResult = Result<std::shared_ptr<SymbolicExpr>>
using	QueryPeriodResult = Result<std::optional<SymbolicExpr>>
using	QueryTriboolResult = Result<Tribool>
using	RationalReconstructionResult = Result<std::pair<int64_t, int64_t>>
using	RelationStoreResult = Result<void>
using	ResidualCheck
using	ResidualCheckResult = Result<ResidualCheck>
using	RootOfComplexEvaluationResult = Result<ApproxComplex>
using	RootOfConstructionResult = Result<std::shared_ptr<SymbolicExpr>>
using	RootOfEvaluationResult = Result<lmmc_real_t>
using	SolutionSet
	成功的 SolveResult 表示操作定义域内的完整解集。 完备性未决时返回外层 Inconclusive 错误；EmptySolutions 表示已证明的空解集。
using	SolveResult = Result<SolutionSet>
using	SolveVectorResult
using	SVDDecompositionResult = Result<SVDDecomposition>
using	SymbolicExprVectorResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>
using	SymbolicGcdResult = Result<std::shared_ptr<SymbolicExpr>>
using	SymbolicSetResult = Result<std::shared_ptr<SymbolicExpr>>
using	TransformEngineResult = Result<Verified<EvaluatedTransform>>
using	UnivariateFactorResult
using	VectorAngleResult = Result<double>
using	VectorCalculusExprResult = Result<std::shared_ptr<SymbolicExpr>>
using	VectorCalculusFieldResult = Result<VectorField>
using	VectorExprListResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>
using	VectorField = std::vector<std::shared_ptr<SymbolicExpr>>
	向量场由标量表达式组成。
using	VectorStringResult = Result<std::string>
using	ZassenhausResult

枚举
enum class	Boundedness { Bounded , Unbounded , Unknown }
	Boundedness classification for symbols. 更多...
enum class	CalculusRealCandidateStatus { Real , NonReal , Inconclusive }
enum class	CasErrc {   InvalidArgument , ParseError , UnboundSymbol , DomainError ,   DimensionMismatch , UnitInvalid , UnitStripTypeMismatch , SetElementTypeMismatch ,   SetOperandTypeMismatch , SetElementNotHashable , UnsupportedExpression , Inconclusive ,   ResourceLimit , Cancelled , NumericFailure , InternalInvariant }
enum class	Completeness { Complete , Inconclusive }
enum class	ContinuityType { Continuous , Removable , Jump , Essential }
	连续性类型枚举. 更多...
enum class	ConvergenceResult { Convergent , Divergent , Inconclusive }
	收敛性结果枚举. 更多...
enum class	CriticalPointClassification {   LocalMinimum , LocalMaximum , Saddle , Degenerate ,   Inconclusive }
enum class	Definiteness {   PositiveDefinite , PositiveSemiDefinite , NegativeDefinite , NegativeSemiDefinite ,   Indefinite , Unknown }
	Matrix definiteness classification. 更多...
enum class	DiagnosticSeverity { Info , Warning , Error }
enum class	Domain {   Complex , Real , Algebraic , Rational ,   Integer , Natural , PositiveInt }
	Mathematical domain hierarchy (least specific → most specific). Complex ⊃ Real ⊃ Algebraic ⊃ Rational ⊃ Integer ⊃ Natural ⊃ PositiveInt 更多...
enum class	EqvProfile { Core , TrigBasic , ExpLogBasic }
enum class	Finiteness { Finite , Divergent , Unknown }
	Finiteness classification for limits and sequences. 更多...
enum class	InequalityType { GreaterThan , GreaterEqual , LessThan , LessEqual }
	不等式类型 更多...
enum class	LimitDirection { Both , FromBelow , FromAbove }
	Direction from which a limit approaches its point. 更多...
enum class	MonomialOrderType { Lex , GrevLex , DegLex , DegRevLex }
	单项式序的类型枚举 更多...
enum class	Monotonicity {   Increasing , Decreasing , NonDecreasing , NonIncreasing ,   Unknown }
	Monotonicity classification for functions over intervals. 更多...
enum class	NumberDomain {   Integers , Rationals , Reals , Complexes ,   Expressions }
enum class	NumericStatus { Finite , PositiveInfinity , NegativeInfinity }
enum class	ODESingularityType { Ordinary , RegularSingular , IrregularSingular }
	对一阶 ODE 进行类型分类. 更多...
enum class	ODEType {   Separable , Linear1 , Linear2_ConstCoeff , Homogeneous ,   Bernoulli , Exact , HigherOrder_ConstCoeff , Euler ,   System , LaplaceMethod , Frobenius , Unknown }
	ODE 类型枚举,标识方程所属的求解类别. 更多...
enum class	Parity { Even , Odd , Unknown }
	Integer parity classification. 更多...
enum class	PropType {   Positive , Negative , NonNegative , NonPositive ,   Real , Integer , NonZero , Algebraic ,   Transcendental , Finite , Divergent , Periodic ,   PositiveDefinite , PositiveSemiDefinite }
	Identifies which property is being queried, used as part of the cache key. 更多...
enum class	RelationOp {   EQ , NEQ , LT , GT ,   LEQ , GEQ }
	Stable relational operator used by public APIs. 更多...
enum class	Sign {   Positive , Negative , NonNegative , NonPositive ,   Zero , NonZero }
	Sign classification for symbols and expressions. 更多...
enum class	SingularityType { Removable , Pole , Essential }
	从无限级数通项计算幂级数收敛半径. 更多...
enum class	SolveStrategy {   ClosedForm , Preprocessing , Transcendental , Numerical ,   RootOf }
	求解策略枚举,标识所使用的求解方法. 更多...
enum class	Tribool { True , False , Unknown }
	Tri-state logic value for property queries. 更多...
enum class	UnitStripMode { BaseValue , DisplayValue }
enum class	ZPolynomialPattern { None , Linear , Quadratic , Cubic }

函数
class	__attribute__ ((visibility("default"))) AssumptionContext
	Scoped assumption context with push/pop management.
__attribute__((visibility("default"))) Result< EqvProfile > eqv_profile_from_name(const std	__attribute__ ((visibility("default"))) BerlekampResult berlekamp_factor(const Polynomial< Rational > &poly
	Berlekamp 模素数分解(内部接口).
template<>
__attribute__((visibility("default"))) Result< SymbolicPolyCoeff > extract_coeff_value< SymbolicPolyCoeff >(const std __attribute__((visibility("default"))) Result< BigInt > extract_coeff_value< BigInt >(const std __attribute__((visibility("default"))) Result< Rational > extract_coeff_value< Rational >(const std	__attribute__ ((visibility("default"))) bool contains(const SymbolicExpr &expression
	判断表达式是否含指定变量的自由出现。
template<typename T>
	__attribute__ ((visibility("default"))) Result< Polynomial< T > > symbolic_to_poly(const std
ExprResult	abs (const ExprPtr &expression)
ExprResult	abs (const ExprPtr &expression, ComputationContext &context)
static bool	accumulate_bernoulli_exponent (int value, int &exponent)
ExprResult	acos (const ExprPtr &expression)
ExprResult	acos (const ExprPtr &expression, ComputationContext &context)
static std::string	active_univariate_variable (const MultiPoly &poly)
Result< QuadratureEstimate >	adaptive_simpson_numeric (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, double tolerance, int max_depth)
Result< QuadratureEstimate >	adaptive_simpson_numeric (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, double tolerance, int max_depth)
ExprResult	add (const ExprPtr &lhs, const ExprPtr &rhs)
ExprResult	add (const ExprPtr &lhs, const ExprPtr &rhs, ComputationContext &context)
static Result< void >	add_fourier_harmonic (Integrator &integrator, const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &half_lo, const std::shared_ptr< SymbolicExpr > &half_hi, const std::shared_ptr< SymbolicExpr > &L, const std::shared_ptr< SymbolicExpr > &arg, bool cosine, std::shared_ptr< SymbolicExpr > &result, ComputationContext &context)
static void	add_lagrange_value (MultiPoly &result, const MultiPoly &value, const std::vector< Rational > &basis_coeffs, const std::vector< std::string > &all_vars, int var_idx)
static std::shared_ptr< const NumberNode >	add_number_nodes (const std::shared_ptr< const NumberNode > &a, const std::shared_ptr< const NumberNode > &b)
std::shared_ptr< const NumberNode >	add_numbers (const std::shared_ptr< const NumberNode > &a, const std::shared_ptr< const NumberNode > &b)
	两个数值节点相加
static ExpressionResult	alternating_sequence_bound (const std::shared_ptr< SymbolicExpr > &remainder, const std::string &n, bool upper, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	analytic_continuation (const std::shared_ptr< SymbolicExpr > &f, const std::string &)
static bool	any_nonreal_sqrt (const std::vector< std::shared_ptr< const SymbolicNode > > &children, ComputationContext &context)
static bool	any_transcendental (const std::vector< std::shared_ptr< const SymbolicNode > > &nodes, const std::string &var)
	判断表达式 AST 中是否包含依赖指定变量的超越函数.
static void	append_factor_solutions (const Polynomial< Rational > &factor, int multiplicity, const std::string &var, std::vector< std::shared_ptr< SymbolicExpr > > &results, ComputationContext &context)
static void	append_product_families (ParametricSolutions &values, const std::set< std::string > &original_names, std::vector< ParametricSolution > &families)
static Result< void >	append_product_roots (FiniteSolutions &values, std::size_t multiplicity, std::vector< FiniteSolution > &finite)
AssumptionVoidResult	apply_assumption_decl_checked (AssumptionContext &ctx, const AssumptionDecl &decl)
static bool	apply_hensel_lift_steps (const MultiPoly &poly, std::vector< MultiPoly > &factors, const std::string &lift_var, int lift_var_idx, const Rational &eval_point, int degree_bound, int factor_count)
ExprResult	approx_real (double value)
ExpressionResult	arc_length_x_checked (std::shared_ptr< SymbolicExpr > fx, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b)
ExpressionResult	arc_length_x_checked (std::shared_ptr< SymbolicExpr > fx, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, ComputationContext &context)
ExpressionResult	arc_length_y_checked (std::shared_ptr< SymbolicExpr > fy, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b)
ExpressionResult	arc_length_y_checked (std::shared_ptr< SymbolicExpr > fy, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, ComputationContext &context)
ExprResult	asin (const ExprPtr &expression)
ExprResult	asin (const ExprPtr &expression, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	assemble_frobenius_polynomial (const std::vector< double > &a, const std::shared_ptr< SymbolicExpr > &x_minus_x0)
static SymbolicExprVectorResult	asymptote_candidates (const std::shared_ptr< SymbolicExpr > &denominator, const std::string &var, ComputationContext &context, const std::string &operation)
AsymptoteAnalysisResult	asymptotes_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var)
AsymptoteAnalysisResult	asymptotes_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	asymptotic_expand (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, int order)
ExprResult	atan (const ExprPtr &expression)
ExprResult	atan (const ExprPtr &expression, ComputationContext &context)
QuantityResult	attach_unit (const std::shared_ptr< SymbolicExpr > &value, const std::string &unit, ComputationContext &context)
QuantityResult	attach_unit (const std::shared_ptr< SymbolicExpr > &value, std::string display_unit, UnitDefinition definition, ComputationContext &context)
BerlekampResult	berlekamp_factor (const Polynomial< Rational > &poly, int64_t prime)
static std::optional< int >	bernoulli_integer_exponent (const NumberNode &number)
BindingResult	binding (ExprPtr symbol, ExprPtr value)
NumericRootResult	bisection_checked (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, lmmc_real_t lower, lmmc_real_t upper, ComputationContext &context, const SolveOptions &options)
NumericRootResult	bisection_checked (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, lmmc_real_t lower, lmmc_real_t upper, const SolveOptions &options)
static Polynomial< ModInt >	bk_to_poly_modint (const std::vector< int64_t > &coeffs, int64_t p, const std::string &var)
	将模 p 系数向量转换为 Polynomial<ModInt>.
static std::shared_ptr< SymbolicExpr >	build_euler_solution (const std::vector< CharRoot > &roots, const std::string &x, std::vector< std::string > &constants)
static std::shared_ptr< SymbolicExpr >	build_homogeneous_solution (const std::vector< CharRoot > &roots, const std::string &x, std::vector< std::string > &constants)
	根据特征根构造齐次通解.
ExpressionResult	calculate_residue_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int order)
ExpressionResult	calculate_residue_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int order, ComputationContext &context)
static ExpressionResult	calculate_residue_impl (const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::shared_ptr< SymbolicExpr > &, int, ComputationContext &)
static bool	calculus_utils_contains_complex (const std::shared_ptr< const SymbolicNode > &node)
static bool	calculus_utils_contains_nonreal_sqrt (const std::shared_ptr< const SymbolicNode > &node, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	calculus_utils_extract_denominator (const std::shared_ptr< SymbolicExpr > &expr)
static CalculusRealCandidateStatus	calculus_utils_extract_real_candidate (const std::shared_ptr< SymbolicExpr > &candidate, std::shared_ptr< SymbolicExpr > &real_candidate, ComputationContext &context)
static bool	calculus_utils_is_minus_one (const std::shared_ptr< const NumberNode > &number)
static bool	calculus_utils_is_negative_number (const std::shared_ptr< const NumberNode > &number)
static bool	calculus_utils_oblique_from_rational (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, std::shared_ptr< SymbolicExpr > &slope, std::shared_ptr< SymbolicExpr > &intercept, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	calculus_utils_product (const std::vector< std::shared_ptr< const SymbolicNode > > &factors, ComputationContext &context)
static bool	calculus_utils_split_rational (const std::shared_ptr< SymbolicExpr > &expr, std::shared_ptr< SymbolicExpr > &numerator, std::shared_ptr< SymbolicExpr > &denominator, ComputationContext &context)
static ExpressionResult	calculus_utils_try_symbolic_definite (const std::shared_ptr< SymbolicExpr > &integrand, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
ExpressionResult	cauchy_integral_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int n)
ExpressionResult	cauchy_integral_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int n, ComputationContext &context)
static ExpressionResult	cauchy_integral_impl (const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::shared_ptr< SymbolicExpr > &, int, ComputationContext &)
static std::shared_ptr< SymbolicExpr >	cbrt_expr (const std::shared_ptr< SymbolicExpr > &x)
ExprResult	ceil (const ExprPtr &expression)
ExprResult	ceil (const ExprPtr &expression, ComputationContext &context)
ResidualCheckResult	check_equivalent (const ExprPtr &left, const ExprPtr &right, ComputationContext &context, const LMCAS::EqvOptions &options)
bool	check_negative_arg (const std::shared_ptr< const SymbolicNode > &argument, std::shared_ptr< const SymbolicNode > &positive, detail::RewriteBudget *budget=nullptr)
ResidualCheckResult	check_zero_residual (const ExprPtr &residual, ComputationContext &context, const LMCAS::EqvOptions &options)
static ExpressionResult	checked_derivative (const ExprPtr &expression, const std::string &variable, ComputationContext &context, const char *operation)
template<typename T>
Result< T >	checked_inference_result (const SymbolicExpr &expr, const std::string &operation, ComputationContext &context, const std::function< Result< T >()> &query)
CholeskyDecompositionResult	cholesky_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A)
CholeskyDecompositionResult	cholesky_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
static std::string	choose_main_variable (const MultiPoly &a, const MultiPoly &b)
DifferentialGeometryExprResult	christoffel_first_kind_checked (const std::shared_ptr< SymbolicExpr > &g_ij, const std::vector< std::string > &coords, int k, int i, int j)
DifferentialGeometryExprResult	christoffel_first_kind_checked (const std::shared_ptr< SymbolicExpr > &g_ij, const std::vector< std::string > &coords, int k, int i, int j, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	christoffel_first_kind_impl (const std::shared_ptr< SymbolicExpr > &, const std::vector< std::string > &, int, int, int, ComputationContext &context)
DifferentialGeometryExprResult	christoffel_second_kind_checked (const std::shared_ptr< SymbolicExpr > &g_ij, const std::shared_ptr< SymbolicExpr > &g_up_ij, const std::vector< std::string > &coords, int k, int i, int j)
DifferentialGeometryExprResult	christoffel_second_kind_checked (const std::shared_ptr< SymbolicExpr > &g_ij, const std::shared_ptr< SymbolicExpr > &g_up_ij, const std::vector< std::string > &coords, int k, int i, int j, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	christoffel_second_kind_impl (const std::shared_ptr< SymbolicExpr > &, const std::shared_ptr< SymbolicExpr > &, const std::vector< std::string > &, int, int, int, ComputationContext &context)
ExprResult	clamp (const ExprPtr &expression, const ExprPtr &lower, const ExprPtr &upper)
ExprResult	clamp (const ExprPtr &expression, const ExprPtr &lower, const ExprPtr &upper, ComputationContext &context)
ODEClassification	classify_first_order_ode (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y)
static CriticalPointClassification	classify_hessian_eigenvalues (const std::vector< std::shared_ptr< SymbolicExpr > > &eigenvals, double tol, ComputationContext &context, detail::RewriteBudget &transform_budget)
static CriticalPointClassification	classify_hessian_pair (const std::vector< double > &numeric_H, double tol)
ODEClassification	classify_higher_order_ode (const std::vector< std::shared_ptr< SymbolicExpr > > &coeffs, const std::shared_ptr< SymbolicExpr > &forcing, const std::string &x, const std::string &)
static SymbolicExprVectorResult	classify_inflection_candidates (const FiniteSolutions &finite, const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &f_prime, const std::shared_ptr< SymbolicExpr > &f_double_prime, const std::string &var, const FactsQuery &facts, ComputationContext &context, const std::string &operation)
std::string	classify_quadratic_form (const ExprPtr &A)
VectorStringResult	classify_quadric_checked (const SurfaceSymbolic &surf)
VectorStringResult	classify_quadric_checked (const SurfaceSymbolic &surf, ComputationContext &context)
static ConvergenceInfo	classify_ratio_limit (const std::shared_ptr< SymbolicExpr > &lim, ComputationContext &context)
ODESingularityResult	classify_singular_point_checked (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x)
ODESingularityResult	classify_singular_point_checked (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	clean_number (double val)
static std::optional< std::shared_ptr< SymbolicExpr > >	coefficient_power_radius (const PowerNode &power, const std::string &index_var, ComputationContext &context)
static bool	collect_bernoulli_coefficients (const std::vector< std::shared_ptr< const SymbolicNode > > &terms, const std::string &y, std::map< int, std::shared_ptr< SymbolicExpr > > &coefficients, ComputationContext &context)
static SolveResult	collect_exact_solutions (std::vector< std::shared_ptr< SymbolicExpr > > roots, ComputationContext &context)
static void	collect_gcd_samples (const MultiPoly &a_prim, const MultiPoly &b_prim, const std::string &main_var, const std::vector< Rational > &eval_pts, int num_points, GcdSamples &samples)
static Result< void >	collect_infinite_asymptotes (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &pos_inf, const std::shared_ptr< SymbolicExpr > &neg_inf, ComputationContext &context, AsymptoteResult &result)
static Result< void >	collect_oblique_asymptote (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &x_expr, const std::shared_ptr< SymbolicExpr > &infinity, ComputationContext &context, AsymptoteResult &result)
static bool	collect_operand_denominators (const std::vector< std::shared_ptr< const SymbolicNode > > &operands, std::vector< std::shared_ptr< const SymbolicNode > > &den_factors, std::vector< std::shared_ptr< SymbolicExpr > > &den_constraints)
static bool	collect_power_denominators (const PowerNode &power, std::vector< std::shared_ptr< const SymbolicNode > > &den_factors, std::vector< std::shared_ptr< SymbolicExpr > > &den_constraints)
static bool	collect_scalar_radical (const SymbolicNode *node, Rational &coefficient, const NumberNode *&radicand)
static Result< void >	collect_vertical_asymptotes (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, ComputationContext &context, AsymptoteResult &result, const std::string &operation)
template<typename Operation>
static std::shared_ptr< const SymbolicNode >	combine_operands (std::vector< std::shared_ptr< const SymbolicNode > > operands)
Result< ComparableEndpoint >	comparable_endpoint (const Endpoint &endpoint, ComputationContext &context, const std::string &operation)
Result< ComparableEndpoint >	comparable_endpoint (const Endpoint &endpoint, ComputationContext &context, const std::string &operation)
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_comparable (const ComparableEndpoint &left, const ComparableEndpoint &right, ComputationContext &context)
Result< int >	compare_comparable (const ComparableEndpoint &left, const ComparableEndpoint &right, ComputationContext &context)
static bool	complementary_square (const std::shared_ptr< const SymbolicNode > &node, const TrigSquare &square)
ExprResult	complex (ExprPtr real, ExprPtr imag)
ExpressionResult	complex_abs_checked (const ComplexSymbolic &z)
ExpressionResult	complex_abs_checked (const ComplexSymbolic &z, ComputationContext &context)
ComplexSymbolicResult	complex_add_checked (const ComplexSymbolic &a, const ComplexSymbolic &b)
ComplexSymbolicResult	complex_add_checked (const ComplexSymbolic &a, const ComplexSymbolic &b, ComputationContext &context)
ExpressionResult	complex_arg_checked (const ComplexSymbolic &z)
ExpressionResult	complex_arg_checked (const ComplexSymbolic &z, ComputationContext &context)
ComplexSymbolicResult	complex_conj_checked (const ComplexSymbolic &z)
ComplexSymbolicResult	complex_conj_checked (const ComplexSymbolic &z, ComputationContext &context)
ComplexSymbolicResult	complex_div_checked (const ComplexSymbolic &a, const ComplexSymbolic &b)
ComplexSymbolicResult	complex_div_checked (const ComplexSymbolic &a, const ComplexSymbolic &b, ComputationContext &context)
ComplexSymbolicResult	complex_exp_form_checked (std::shared_ptr< SymbolicExpr > r, std::shared_ptr< SymbolicExpr > theta)
ComplexSymbolicResult	complex_exp_form_checked (std::shared_ptr< SymbolicExpr > r, std::shared_ptr< SymbolicExpr > theta, ComputationContext &context)
ExpressionResult	complex_locus_circle_checked (const ComplexSymbolic &a, std::shared_ptr< SymbolicExpr > r, const std::string &z_var)
ExpressionResult	complex_locus_circle_checked (const ComplexSymbolic &a, std::shared_ptr< SymbolicExpr > r, const std::string &z_var, ComputationContext &context)
ExpressionResult	complex_locus_perpendicular_bisector_checked (const ComplexSymbolic &a, const ComplexSymbolic &b, const std::string &z_var)
ExpressionResult	complex_locus_perpendicular_bisector_checked (const ComplexSymbolic &a, const ComplexSymbolic &b, const std::string &z_var, ComputationContext &context)
ComplexSymbolicResult	complex_mul_checked (const ComplexSymbolic &a, const ComplexSymbolic &b)
ComplexSymbolicResult	complex_mul_checked (const ComplexSymbolic &a, const ComplexSymbolic &b, ComputationContext &context)
ComplexSymbolicResult	complex_sub_checked (const ComplexSymbolic &a, const ComplexSymbolic &b)
ComplexSymbolicResult	complex_sub_checked (const ComplexSymbolic &a, const ComplexSymbolic &b, ComputationContext &context)
ComplexSymbolicResult	complex_trig_form_checked (std::shared_ptr< SymbolicExpr > r, std::shared_ptr< SymbolicExpr > theta)
ComplexSymbolicResult	complex_trig_form_checked (std::shared_ptr< SymbolicExpr > r, std::shared_ptr< SymbolicExpr > theta, ComputationContext &context)
NumberDomainSet	complexes ()
static Result< void >	composition_inner_powers (const std::vector< std::shared_ptr< SymbolicExpr > > &g, std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > &gp, int order, ComputationContext &context, const std::string &operation)
static SolveResult	conditional_equation (const ExprPtr &original, const std::string &variable)
static SolveResult	conditional_linear_polynomial (const Polynomial< SymbolicPolyCoeff > &polynomial, const ExprPtr &leading, const std::string &variable)
ExprResult	conj (const ExprPtr &expression)
ExprResult	conj (const ExprPtr &expression, ComputationContext &context)
ExpressionResult	conjugate_checked (const std::shared_ptr< SymbolicExpr > &expr)
ExpressionResult	conjugate_checked (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
static bool	consume_digits (const std::string &str, size_t &pos)
static void	consume_sign (const std::string &str, size_t &pos)
bool	contains (const SymbolicExpr &expression, const std::string &variable)
static bool	contains_inverse_candidate (const std::vector< std::shared_ptr< SymbolicExpr > > &candidates, const std::shared_ptr< SymbolicExpr > &candidate)
bool	contains_transcendental_of_var (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
bool	contains_unevaluated_integral (const std::shared_ptr< const SymbolicNode > &node)
ContinuityResult	continuity_at_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &point)
ContinuityResult	continuity_at_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &point, ComputationContext &context)
ExpressionResult	convergence_radius_checked (const std::shared_ptr< SymbolicExpr > &general_coefficient, const std::string &index_var)
ExpressionResult	convergence_radius_checked (const std::shared_ptr< SymbolicExpr > &general_coefficient, const std::string &index_var, ComputationContext &context)
ExpressionResult	convergence_radius_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &coefficients, const std::string &var)
ExpressionResult	convergence_radius_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &coefficients, const std::string &var, ComputationContext &context)
ConvergenceInfoResult	convergence_test_checked (const std::shared_ptr< SymbolicExpr > &general_term, const std::string &index_var)
ConvergenceInfoResult	convergence_test_checked (const std::shared_ptr< SymbolicExpr > &general_term, const std::string &index_var, ComputationContext &context)
static ConvergenceInfoResult	convergence_test_impl (const std::shared_ptr< SymbolicExpr > &, const std::string &, ComputationContext &)
ExprResult	convert_to_unit (const ExprPtr &quantity, const std::string &unit, ComputationContext &context)
ExprResult	convert_to_unit_definition (const ExprPtr &quantity, std::string display_unit, UnitDefinition definition, ComputationContext &context)
QuantityResult	convert_unit (const std::shared_ptr< SymbolicExpr > &expression, const std::string &target_unit, ComputationContext &context)
QuantityResult	convert_unit (const std::shared_ptr< SymbolicExpr > &expression, std::string display_unit, UnitDefinition definition, ComputationContext &context)
TransformEngineResult	convolve_checked (const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &g, const std::string &var)
TransformEngineResult	convolve_checked (const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &g, const std::string &var, ComputationContext &context)
ExprResult	cos (const ExprPtr &expression)
ExprResult	cos (const ExprPtr &expression, ComputationContext &context)
VectorCalculusFieldResult	cross_product (const VectorField &a, const VectorField &b)
static VectorCalculusFieldResult	cross_product_impl (const VectorField &a, const VectorField &b, detail::RewriteBudget &transform_budget)
std::pair< int64_t, int64_t >	crt (int64_t r1, int64_t m1, int64_t r2, int64_t m2)
	中国剩余定理（两模数），返回规范余数与模数乘积。
CrtResult	crt_checked (int64_t r1, int64_t m1, int64_t r2, int64_t m2)
CrtResult	crt_checked (int64_t r1, int64_t m1, int64_t r2, int64_t m2, ComputationContext &context)
	Checked Chinese remainder theorem for two positive coprime moduli.
VectorField	curl (const VectorField &F, const std::vector< std::string > &vars)
VectorCalculusFieldResult	curl_checked (const VectorField &F, const std::vector< std::string > &vars)
VectorCalculusFieldResult	curl_checked (const VectorField &F, const std::vector< std::string > &vars, ComputationContext &context)
ExpressionResult	curvature_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var)
ExpressionResult	curvature_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, ComputationContext &context)
ExpressionResult	curvature_parametric_checked (const std::shared_ptr< SymbolicExpr > &x_t, const std::shared_ptr< SymbolicExpr > &y_t, const std::string &t)
ExpressionResult	curvature_parametric_checked (const std::shared_ptr< SymbolicExpr > &x_t, const std::shared_ptr< SymbolicExpr > &y_t, const std::string &t, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	curve_integral_scalar (const std::shared_ptr< SymbolicExpr > &f, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
VectorCalculusExprResult	curve_integral_scalar_checked (const std::shared_ptr< SymbolicExpr > &f, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
VectorCalculusExprResult	curve_integral_scalar_checked (const std::shared_ptr< SymbolicExpr > &f, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	curve_integral_vector (const VectorField &F, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
VectorCalculusExprResult	curve_integral_vector_checked (const VectorField &F, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
VectorCalculusExprResult	curve_integral_vector_checked (const VectorField &F, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
std::vector< lmmc_real_t >	deduplicate_roots (std::vector< NumericRoot > &roots, lmmc_real_t tolerance, int max_roots)
static void	deflate_rational_root (Polynomial< Rational > &current, const Rational &root, std::vector< Rational > &roots)
static std::shared_ptr< const SymbolicNode >	denominator_factor (const std::shared_ptr< const SymbolicNode > &node)
static Result< bool >	dep_var_is_positive (const std::string &y, const AssumptionContext *ctx, ComputationContext &context)
	Check if the dependent variable is known Positive in the given context.
bool	depends_on_integration_variable (const SymbolicExpr &expression, const std::string &variable)
static std::shared_ptr< const SymbolicNode >	detect_negation (const std::shared_ptr< const SymbolicNode > &node)
	If the node is multiplication by exactly -1, returns the other operand.
static int	detect_parity (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, ComputationContext &context)
Result< std::optional< SubstitutionResult > >	detect_substitution (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
TransSubstitutionResult	detect_trans_substitutions (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
	为依赖 var 的 Sin、Cos、Exp、Ln、Tan 子表达式构造换元结果。
std::optional< SearchInterval >	determine_search_interval (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts)
std::shared_ptr< SymbolicExpr >	differential (const std::shared_ptr< SymbolicExpr > &f, const std::string &var)
ExprResult	differentiate (const ExprPtr &expression, const std::string &variable)
ExprResult	differentiate (const ExprPtr &expression, const std::string &variable, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	differentiate_if_dependent (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable, ComputationContext &context)
ExpressionResult	dihedral_angle_checked (const PlaneSymbolic &p1, const PlaneSymbolic &p2)
ExpressionResult	dihedral_angle_checked (const PlaneSymbolic &p1, const PlaneSymbolic &p2, ComputationContext &context)
Result< DimensionSignature >	dimension_of (const SymbolicExpr &expression)
static bool	diophantine_target (const MultiPoly &target, const std::string &var, const Rational &eval_point, const std::string &main_var, Polynomial< Rational > &target_uni)
static bool	diophantine_univariate_factors (const std::vector< MultiPoly > &factors, const std::string &var, const Rational &eval_point, Polynomial< Rational > &f1_uni, Polynomial< Rational > &f2_uni)
std::shared_ptr< SymbolicExpr >	directional_derivative (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, const VectorField &direction, int order)
VectorCalculusExprResult	directional_derivative_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, const VectorField &direction, int order)
VectorCalculusExprResult	directional_derivative_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, const VectorField &direction, int order, ComputationContext &context)
static SolveResult	dispatch_equation (const ExprPtr &expr, const ExprPtr &f_expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
ExprResult	div (const ExprPtr &numerator, const ExprPtr &denominator)
ExprResult	div (const ExprPtr &numerator, const ExprPtr &denominator, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	divergence (const VectorField &F, const std::vector< std::string > &vars)
VectorCalculusExprResult	divergence_checked (const VectorField &F, const std::vector< std::string > &vars)
VectorCalculusExprResult	divergence_checked (const VectorField &F, const std::vector< std::string > &vars, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	divergence_theorem (const VectorField &F, const std::vector< std::string > &vars, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &x_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &y_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &z_bounds)
VectorCalculusExprResult	divergence_theorem_checked (const VectorField &F, const std::vector< std::string > &vars, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &x_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &y_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &z_bounds)
VectorCalculusExprResult	divergence_theorem_checked (const VectorField &F, const std::vector< std::string > &vars, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &x_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &y_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &z_bounds, ComputationContext &context)
bool	divides_monomial (const Monomial &divisor, const Monomial &target)
	判断 divisor 是否整除 target
static bool	divides_poly (const MultiPoly &dividend, const MultiPoly &divisor)
Result< bool >	domain_contains (const NumberDomainSet &domain, const ExprPtr &element)
static bool	domain_requires_real (Domain domain)
Result< bool >	domain_subset (const NumberDomainSet &lhs, const NumberDomainSet &rhs)
VectorCalculusExprResult	dot_product (const VectorField &a, const VectorField &b)
static VectorCalculusExprResult	dot_product_impl (const VectorField &a, const VectorField &b, detail::RewriteBudget &transform_budget)
static Result< std::vector< Interval > >	double_root_inequality_intervals (const Polynomial< Rational > &polynomial, const Rational &rational_part, bool wants_positive, bool leading_positive, bool strict, detail::RewriteBudget &budget)
ExprResult	e ()
static void	eliminate_parametric_column (ParametricMatrix &A, ParametricVector &b, size_t current_row, size_t col, size_t n, ComputationContext &context)
static MultiPoly	embed_hensel_terms (const MultiPoly &polynomial, const std::vector< std::string > &variables)
static MultiPoly	embed_univariate_gcd (const MultiPoly &result, const std::string &a_var, const std::vector< std::string > &vars)
static std::vector< MultiPoly >	embed_without_lifting (const std::vector< Polynomial< Rational > > &univariate_factors, const std::vector< std::string > &vars)
static bool	endpoints_equivalent (const Endpoint &left, const Endpoint &right)
ExprResult	eq (const ExprPtr &lhs, const ExprPtr &rhs)
ExprResult	eq (const ExprPtr &lhs, const ExprPtr &rhs, ComputationContext &context)
ExprPtr	equation_predicate (const ExprPtr &expression)
Result< bool >	equivalent (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context, const EqvOptions &options)
Result< EqvProfile >	eqv_profile_from_name (const std::string &name)
const char *	error_name (CasErrc code) noexcept
const char *	error_name (const CasError &error) noexcept
static std::optional< int >	essential_exponent (const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &shift, ComputationContext &context)
static LaurentSeriesResult	essential_laurent (const std::shared_ptr< SymbolicExpr > &shift, int m, int order_neg, ComputationContext &context)
Result< ApproxComplex >	eval_complex (const SymbolicExpr &expression, const NumericBindings &bindings)
Result< ApproxComplex >	eval_complex (const SymbolicExpr &expression, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxReal >	evalf (const SymbolicExpr &expression, const NumericBindings &bindings)
Result< ApproxReal >	evalf (const SymbolicExpr &expression, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxReal >	evaluate_numeric (const SymbolicExpr &expression, const NumericBindings &bindings, ComputationContext &context)
Result< ApproxReal >	evaluate_numeric (const SymbolicExpr &expression, const NumericBindings &bindings={})
static std::vector< MultiPoly >	evaluated_lifting_cofactors (const std::vector< MultiPoly > &factors, const std::string &lift_var, const Rational &eval_point, const std::vector< std::string > &vars)
Result< Rational >	exact_double_rational (double value, ComputationContext &context, const std::string &operation)
static std::vector< std::shared_ptr< SymbolicExpr > >	exact_factor_roots (Polynomial< Rational > polynomial, ComputationContext &context)
Rational	exact_number_as_rational (const NumberNode &node)
int	exact_numeric_sign (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
static bool	exact_radical_domain_excludes (const SymbolicNode *node, Domain domain)
static bool	exact_rational_domain_excludes (const Rational &value, Domain domain)
static const NumberNode *	exact_scalar_number (const SymbolicNode *node)
static const NumberNode *	exact_scalar_radicand (const SymbolicNode *node)
std::optional< int >	exact_small_integer_node (const detail::SymbolicNodePtr &node, int min_value, int max_value)
ExprResult	exp (const ExprPtr &expression)
ExprResult	exp (const ExprPtr &expression, ComputationContext &context)
ExprResult	expand (const ExprPtr &expression)
ExprResult	expand (const ExprPtr &expression, ComputationContext &context)
static SymbolicExprVectorResult	explicit_inverse_candidates (const FiniteSolutions &finite, const std::string &operation)
ExprMatchResult	expr_match (const ExprPtr &pattern, const ExprPtr &target, const std::vector< std::string > &wildcards)
ExprMatchResult	expr_match (const ExprPtr &pattern, const ExprPtr &target, const std::vector< std::string > &wildcards, ComputationContext &context)
ExprSetResult	expr_set (std::vector< ExprPtr > elements)
Result< bool >	expr_set_contains (const ExprSet &set, const ExprPtr &element)
ExprSetResult	expr_set_difference (const ExprSet &lhs, const ExprSet &rhs)
ExprSetResult	expr_set_failure (CasErrc code, std::string message, const char *operation)
ExprSetResult	expr_set_intersection (const ExprSet &lhs, const ExprSet &rhs)
Result< bool >	expr_set_not_contains (const ExprSet &set, const ExprPtr &element)
Result< bool >	expr_set_subset (const ExprSet &lhs, const ExprSet &rhs)
Result< bool >	expr_set_subset_domain (const ExprSet &set, const NumberDomainSet &domain)
ExprSetResult	expr_set_symmetric_difference (const ExprSet &lhs, const ExprSet &rhs)
ExprSetResult	expr_set_union (const ExprSet &lhs, const ExprSet &rhs)
bool	expression_depends_on_variable (const detail::SymbolicNodePtr &expression, const std::string &variable, detail::RewriteBudget *budget)
NumberDomainSet	expressions ()
int64_t	extended_gcd (int64_t a, int64_t b, int64_t &s, int64_t &t)
	用扩展欧几里得算法求 gcd(a,b) 及 Bezout 系数。
static MultiPoly	extended_gcd_interpolation (const MultiPoly &a_prim, const MultiPoly &b_prim, const std::string &main_var, const std::vector< std::string > &vars, int degree_bound, const Rational &nc_gcd)
static Polynomial< Rational >	extended_gcd_poly (const Polynomial< Rational > &a, const Polynomial< Rational > &b, Polynomial< Rational > &s, Polynomial< Rational > &t)
	一元多项式扩展 GCD(有理数域上)
DifferentialGeometryVectorResult	exterior_derivative_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &form_coeffs, int degree, const std::vector< std::string > &vars)
DifferentialGeometryVectorResult	exterior_derivative_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &form_coeffs, int degree, const std::vector< std::string > &vars, ComputationContext &context)
static bool	extract_bernoulli_factor (const std::shared_ptr< const SymbolicNode > &factor, const std::string &y, int &exponent, std::shared_ptr< SymbolicExpr > &coefficient, ComputationContext &context)
static bool	extract_bernoulli_monomial (const std::shared_ptr< const SymbolicNode > &term, const std::string &y, int &exponent, std::shared_ptr< SymbolicExpr > &coefficient, ComputationContext &context)
template<typename T>
Result< T >	extract_coeff_value (const std::shared_ptr< SymbolicExpr > &coefficient)
	精确提取系数；不支持的值返回错误，保持数值完整。
template<>
Result< BigInt >	extract_coeff_value< BigInt > (const std::shared_ptr< SymbolicExpr > &coefficient)
template<>
Result< Rational >	extract_coeff_value< Rational > (const std::shared_ptr< SymbolicExpr > &coefficient)
template<>
Result< SymbolicPolyCoeff >	extract_coeff_value< SymbolicPolyCoeff > (const std::shared_ptr< SymbolicExpr > &coefficient)
static std::shared_ptr< SymbolicExpr >	extract_coefficient (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context)
static std::map< int, MultiPoly >	extract_coefficients (const MultiPoly &poly, const std::string &main_var)
static std::shared_ptr< SymbolicExpr >	extract_constant_term (const std::shared_ptr< SymbolicExpr > &expr, const std::vector< std::string > &unknowns, ComputationContext &context)
static Result< int >	extract_laurent_regular_part (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &center, const std::shared_ptr< SymbolicExpr > &shift, std::shared_ptr< SymbolicExpr > &regular, ComputationContext &context)
static std::optional< ExpressionResult >	factor_common_polynomial (const std::shared_ptr< const AddNode > &add_node, ComputationContext &context)
Polynomial< BigInt >	factor_integer_polynomial (const Polynomial< Rational > &polynomial)
MultiFactorCheckedResult	factor_multivariate_checked (const MultiPoly &poly)
MultiFactorCheckedResult	factor_multivariate_checked (const MultiPoly &poly, ComputationContext &context)
static std::optional< ExpressionResult >	factor_multivariate_expression (const std::shared_ptr< SymbolicExpr > &simp, const std::set< std::string > &factor_variables, ComputationContext &context)
static std::optional< ExpressionResult >	factor_numeric_content (const std::shared_ptr< SymbolicExpr > &simp, const std::shared_ptr< const AddNode > &add_node, ComputationContext &context)
static std::optional< ExpressionResult >	factor_rational_univariate (const std::shared_ptr< SymbolicExpr > &simp, const std::string &var, ComputationContext &context)
static std::optional< ExpressionResult >	factor_symbolic_quadratic (const std::shared_ptr< SymbolicExpr > &simp, const std::string &var, ComputationContext &context)
Result< std::vector< std::shared_ptr< SymbolicExpr > > >	factor_transcendental (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
Result< std::vector< std::shared_ptr< SymbolicExpr > > >	factor_transcendental (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context)
static ExpressionResult	factor_transcendental_expression (const std::shared_ptr< SymbolicExpr > &simp, ComputationContext &context)
UnivariateFactorResult	factor_univariate_bridge_checked (const Polynomial< Rational > &polynomial, ComputationContext &context)
static std::optional< ExpressionResult >	factor_variable_rational_roots (const std::shared_ptr< SymbolicExpr > &simp, const std::string &var, ComputationContext &context)
std::vector< FGLMPoly >	fglm_convert (const std::vector< FGLMPoly > &source_basis, const MonomialOrder &source_order, const MonomialOrder &target_order, size_t num_vars)
static std::size_t	find_complementary_square (const std::vector< std::shared_ptr< const SymbolicNode > > &operands, const std::vector< bool > &consumed, std::size_t start, const TrigSquare &square)
std::vector< CriticalPoint >	find_extrema (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
ExtremaResult	find_extrema_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
ExtremaResult	find_extrema_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, ComputationContext &context)
static std::vector< CriticalPoint >	find_extrema_impl (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, ComputationContext &context, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	find_integrating_factor (const std::shared_ptr< SymbolicExpr > &M, const std::shared_ptr< SymbolicExpr > &N, const std::string &x, const std::string &y)
static ExpressionResult	find_integrating_factor_impl (const std::shared_ptr< SymbolicExpr > &M, const std::shared_ptr< SymbolicExpr > &N, const std::string &x, const std::string &y, ComputationContext &context)
static size_t	find_parametric_pivot (ParametricMatrix &matrix, size_t row, size_t column, ComputationContext &context)
std::vector< Rational >	find_rational_roots (const Polynomial< Rational > &poly)
std::vector< std::pair< std::shared_ptr< SymbolicExpr >, int > >	find_roots_with_multiplicity (const std::shared_ptr< SymbolicExpr > &expr, const std::string &variable, ComputationContext &context)
ExprResult	finite_set (std::vector< ExprPtr > elements)
ExprResult	finite_set (std::vector< ExprPtr > elements, ComputationContext &context)
SymbolicSetResult	finite_set_difference (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context)
SymbolicSetResult	finite_set_intersection (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context)
SymbolicSetResult	finite_set_symmetric_difference (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context)
SymbolicSetResult	finite_set_union (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context)
static SolveResult	finite_values_to_set (SolveVectorResult result)
ExprResult	floor (const ExprPtr &expression)
ExprResult	floor (const ExprPtr &expression, ComputationContext &context)
static MultiPoly	formal_derivative (const MultiPoly &poly, const std::string &main_var)
	计算多元多项式关于指定变量的形式偏导数
static ExpressionResult	fourier_constant_coefficient (Integrator &integrator, const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const FourierPeriod &period, ComputationContext &context)
static Result< void >	fourier_harmonics (Integrator &integrator, const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const FourierPeriod &period, const std::shared_ptr< SymbolicExpr > &x, int n_terms, int parity, std::shared_ptr< SymbolicExpr > &result, ComputationContext &context)
ExpressionResult	fourier_series_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &period, int n_terms)
ExpressionResult	fourier_series_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &period, int n_terms, ComputationContext &context)
TransformEngineResult	fourier_transform_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &omega)
TransformEngineResult	fourier_transform_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &omega, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	fourier_transform_core (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &omega, ComputationContext &context, const AssumptionContext &assumptions, std::vector< std::shared_ptr< SymbolicExpr > > &conditions)
std::set< std::string >	free_variables (const detail::SymbolicNodePtr &expression, detail::RewriteBudget *budget)
static CasError	frobenius_arithmetic_failure ()
static Result< double >	frobenius_coefficient_limit (const std::shared_ptr< SymbolicExpr > &coefficient, const std::string &x, const std::shared_ptr< SymbolicExpr > &x0, double value, ComputationContext &context)
static Result< std::pair< double, double > >	frobenius_indicial_roots (double P0, double Q0)
static CasError	frobenius_unsupported_numeric ()
ExprResult	function (const std::string &name, std::vector< ExprPtr > arguments)
template<typename T>
T	gcd_coeff_impl (const T &a, const T &b)
	计算两个系数的最大公约数(泛型实现)
static std::vector< Rational >	gcd_evaluation_points (int bound)
ExprResult	ge (const ExprPtr &lhs, const ExprPtr &rhs)
std::vector< int64_t >	generate_good_primes (int count, const std::vector< BigInt > &leading_coeffs, uint64_t start_from=UINT64_C(1000000000))
	生成指定数量的好素数
static std::optional< ConvergenceInfo >	geometric_term_convergence (const std::shared_ptr< const SymbolicNode > &node, const std::string &index_var)
std::shared_ptr< SymbolicExpr >	get_coeff (const Polynomial< SymbolicPolyCoeff > &p, int deg)
static bool	get_integer_value (const std::shared_ptr< const SymbolicNode > &node, BigInt &value)
BigInt	get_node_degree_helper (const std::shared_ptr< const SymbolicNode > &node)
	计算 AST 节点的多项式次数
bool	get_pi_coeff (const std::shared_ptr< const SymbolicNode > &node, Rational &coefficient)
VectorField	gradient (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
VectorCalculusFieldResult	gradient_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
VectorCalculusFieldResult	gradient_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, ComputationContext &context)
std::vector< std::vector< std::shared_ptr< SymbolicExpr > > >	gram_schmidt (const std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > &vectors, bool normalize)
std::shared_ptr< SymbolicExpr >	greens_theorem (const std::shared_ptr< SymbolicExpr > &P, const std::shared_ptr< SymbolicExpr > &Q, const std::vector< std::string > &vars, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &x_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &y_bounds)
std::shared_ptr< SymbolicExpr >	greens_theorem_area (const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
VectorCalculusExprResult	greens_theorem_area_checked (const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
VectorCalculusExprResult	greens_theorem_area_checked (const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
VectorCalculusExprResult	greens_theorem_checked (const std::shared_ptr< SymbolicExpr > &P, const std::shared_ptr< SymbolicExpr > &Q, const std::vector< std::string > &vars, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &x_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &y_bounds)
VectorCalculusExprResult	greens_theorem_checked (const std::shared_ptr< SymbolicExpr > &P, const std::shared_ptr< SymbolicExpr > &Q, const std::vector< std::string > &vars, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &x_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &y_bounds, ComputationContext &context)
std::vector< FGLMPoly >	grevlex_to_lex (const std::vector< FGLMPoly > &grevlex_basis, size_t num_vars)
ExprResult	gt (const ExprPtr &lhs, const ExprPtr &rhs)
static bool	has_nonzero_forcing (const std::shared_ptr< SymbolicExpr > &forcing)
static bool	has_oblique_asymptote (const AsymptoteResult &result, const std::shared_ptr< SymbolicExpr > &slope, const std::shared_ptr< SymbolicExpr > &intercept)
void	hash_combine (std::size_t &seed, std::size_t value)
	将一个哈希值混合到种子中,用于组合多个字段的哈希.
HenselLiftResult	hensel_lift_checked (const Polynomial< BigInt > &poly, const std::vector< Polynomial< ModInt > > &mod_factors, int64_t prime, int lift_bound)
	Hensel 提升:将模 p 因子提升到 mod p^k.
std::shared_ptr< SymbolicExpr >	hessian (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
VectorCalculusExprResult	hessian_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
VectorCalculusExprResult	hessian_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, ComputationContext &context)
static BigInt	hl_binomial (int n, int k)
	计算二项式系数 C(n, k).
static bool	hl_coeff_vectors_equal (std::vector< BigInt > left, std::vector< BigInt > right)
static int	hl_compute_lift_height (const Polynomial< BigInt > &poly, int64_t prime)
	计算 Hensel 提升所需的高度 k.
static std::pair< std::vector< BigInt >, std::vector< BigInt > >	hl_extended_gcd_poly (const std::vector< BigInt > &g, const std::vector< BigInt > &h, const BigInt &m)
	计算两个多项式在模 m 下的扩展 GCD 的 Bezout 系数.
static bool	hl_is_prime (int64_t value)
static BigInt	hl_l2_norm_squared (const Polynomial< BigInt > &poly)
	计算多项式系数的 L2 范数的平方.
static BigInt	hl_mignotte_bound (const Polynomial< BigInt > &poly)
	计算多项式的 Mignotte 界.
static BigInt	hl_mod_inverse (const BigInt &a, const BigInt &m)
	计算 BigInt 在模 m 下的乘法逆元.
static std::vector< std::vector< BigInt > >	hl_multi_factor_lift (const std::vector< BigInt > &f, const std::vector< std::vector< BigInt > > &factors, int64_t prime, int target_k)
	多因子 Hensel 提升:将 k 个模 p 因子同时提升到 mod p^target_k.
static std::vector< BigInt >	hl_poly_add_mod (const std::vector< BigInt > &a, const std::vector< BigInt > &b, const BigInt &m)
	多项式加法(BigInt 系数),结果模 m 归约.
static std::pair< std::vector< BigInt >, std::vector< BigInt > >	hl_poly_divmod (const std::vector< BigInt > &a, const std::vector< BigInt > &b, const BigInt &m)
	多项式带余除法(BigInt 系数),模 m 下运算.
static std::vector< BigInt >	hl_poly_mul_mod (const std::vector< BigInt > &a, const std::vector< BigInt > &b, const BigInt &m)
	多项式乘法(BigInt 系数),结果模 m 归约.
static std::vector< BigInt >	hl_poly_sub_mod (const std::vector< BigInt > &a, const std::vector< BigInt > &b, const BigInt &m)
	多项式减法(BigInt 系数),结果模 m 归约.
static void	hl_reduce_coeffs (std::vector< BigInt > &poly, const BigInt &m)
	对多项式系数向量执行模归约(对称表示).
HenselLiftPair	hl_two_factor_lift (const std::vector< BigInt > &f, const HenselLiftPair &current)
	执行一步二次 Hensel 提升:mod m -> mod m^2.
static Result< void >	hl_validate_lift_inputs (const Polynomial< BigInt > &poly, const std::vector< std::vector< BigInt > > &factor_vecs, int64_t prime)
ExprResult	imag (const ExprPtr &expression)
ExprResult	imag (const ExprPtr &expression, ComputationContext &context)
ExpressionResult	imag_part_checked (const std::shared_ptr< SymbolicExpr > &expr)
ExpressionResult	imag_part_checked (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
ExprResult	imaginary_unit ()
std::shared_ptr< SymbolicExpr >	implicit_diff (std::shared_ptr< SymbolicExpr > expression, const std::string &independent_variable, const std::string &dependent_variable)
int	infinity_sign (const SymbolicExpr &expression, ComputationContext &context)
static Result< bool >	inflection_curve_defined (const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &f_prime, const std::shared_ptr< SymbolicExpr > &f_double_prime, const std::shared_ptr< SymbolicExpr > &point, const std::string &var, const FactsQuery &facts, const std::string &operation, ComputationContext &context)
SymbolicExprVectorResult	inflection_points_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var)
SymbolicExprVectorResult	inflection_points_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, ComputationContext &context)
ExprResult	integer (const BigInt &value)
ExprResult	integer (int value)
NumberDomainSet	integers ()
Result< SymbolicExpr >	integrate_multiple_checked (const SymbolicExpr &integrand, const std::vector< IntegrationStep > &steps, Integrator &integrator, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	integrating_factor_from_antiderivative (const std::shared_ptr< SymbolicExpr > &antiderivative, const std::string &variable, ComputationContext &context)
static ExpressionResult	integrating_factor_from_ratio (const std::shared_ptr< SymbolicExpr > &ratio, const std::string &variable, const std::string &excluded_variable, Integrator &integrator, ComputationContext &context)
std::optional< int >	integration_bounded_exponent (const NumberNode &number, int minimum_exponent, int maximum_exponent)
ExprResult	interval (const ExprPtr &lower, const ExprPtr &upper, bool lower_closed, bool upper_closed, ComputationContext &context)
ExprResult	interval (ExprPtr lower, ExprPtr upper, bool lower_closed, bool upper_closed)
Result< bool >	interval_contains_checked (const Interval &interval, double value)
Result< bool >	interval_contains_checked (const Interval &interval, double value, ComputationContext &context)
static Result< bool >	interval_covers_checked_impl (const Interval &outer, const Interval &inner, ComputationContext &context)
	判断 outer 是否完全包含 inner。 包含条件为 outer.lower <= inner.lower 且 inner.upper <= outer.upper， 并结合端点的开闭属性判断边界。
Result< bool >	interval_is_empty_checked (const Interval &interval)
Result< bool >	interval_is_empty_checked (const Interval &interval, ComputationContext &context)
static std::shared_ptr< const SymbolicNode >	interval_to_expr (const Interval &interval, const std::shared_ptr< const SymbolicNode > &variable)
static bool	intervals_equivalent (const Interval &left, const Interval &right)
static Result< bool >	intervals_overlap_checked_impl (const Interval &a, const Interval &b, ComputationContext &context)
	判断两个区间是否存在已证明的交集。 端点排序采用受检区间运算；超出支持域时，交集判定仍为未决。
static ExpressionResult	inverse_branch_derivative (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::vector< std::shared_ptr< SymbolicExpr > > &candidates, const std::string &operation, ComputationContext &context)
ExpressionResult	inverse_derivative_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &point)
ExpressionResult	inverse_derivative_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &point, ComputationContext &context)
TransformEngineResult	inverse_fourier_transform_checked (const std::shared_ptr< SymbolicExpr > &F, const std::string &omega, const std::string &t)
TransformEngineResult	inverse_fourier_transform_checked (const std::shared_ptr< SymbolicExpr > &F, const std::string &omega, const std::string &t, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	inverse_fourier_transform_core (const std::shared_ptr< SymbolicExpr > &F, const std::string &omega, const std::string &t, ComputationContext &context)
SymbolicExprVectorResult	inverse_function_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &y)
SymbolicExprVectorResult	inverse_function_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &y, ComputationContext &context)
TransformEngineResult	inverse_laplace_checked (const std::shared_ptr< SymbolicExpr > &F, const std::string &s, const std::string &t)
TransformEngineResult	inverse_laplace_checked (const std::shared_ptr< SymbolicExpr > &F, const std::string &s, const std::string &t, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	inverse_laplace_core (const std::shared_ptr< SymbolicExpr > &F, const std::string &s, const std::string &t, ComputationContext &context)
static bool	is_alternating_factor (const std::shared_ptr< const SymbolicNode > &node, const std::string &n)
ComplexBoolResult	is_analytic_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z)
ComplexBoolResult	is_analytic_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, ComputationContext &context)
static bool	is_analytic_impl (const std::shared_ptr< SymbolicExpr > &, const std::string &, ComputationContext &context)
bool	is_bernoulli_ode (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y, std::shared_ptr< SymbolicExpr > &P, std::shared_ptr< SymbolicExpr > &Q, int &n)
bool	is_constant_coefficient (const std::vector< std::shared_ptr< SymbolicExpr > > &coeffs, const std::string &x)
bool	is_euler_equation (const std::vector< std::shared_ptr< SymbolicExpr > > &coeffs, const std::string &x, std::vector< double > &euler_consts)
bool	is_even_integer_number (const NumberNode &num)
bool	is_exact_ode (const std::shared_ptr< SymbolicExpr > &M, const std::shared_ptr< SymbolicExpr > &N, const std::string &x, const std::string &y)
bool	is_good_prime (int64_t p, const std::vector< BigInt > &leading_coeffs)
	判断素数 p 是否为"好素数"（不整除任何首项系数）
bool	is_homogeneous_ode (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y)
bool	is_integer_number (const NumberNode &num)
bool	is_linear_first_order (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y, std::shared_ptr< SymbolicExpr > &P, std::shared_ptr< SymbolicExpr > &Q)
bool	is_negative_infinity_coefficient (const NumberNode &number)
static bool	is_nonreal_sqrt (const FunctionNode &function, ComputationContext &context)
static bool	is_pi_variable (const VariableNode &variable)
__attribute__((visibility("default"))) MixedTranscendentalResult solve_mixed_transcendental_checked(const std __attribute__((visibility("default"))) MixedTranscendentalResult solve_mixed_transcendental_checked(const std __attribute__((visibility("default"))) bool contains_transcendental_of_var(const std bool	is_polynomial_after_substitution (const TransSubstitutionResult &sub_result)
	在调用方计算上下文中执行混合超越方程求解.
bool	is_positive_integer_number (const NumberNode &num)
static bool	is_representable_small_integer (double value)
	将 double 值转为"干净"的数值表达式.
bool	is_separable (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y)
static bool	is_variable_operand (const std::shared_ptr< const VariableNode > &node)
static Result< bool >	is_vertical_asymptote (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &point, ComputationContext &context)
static bool	is_wildcard (const std::shared_ptr< const SymbolicNode > &node, const std::unordered_set< std::string > &wildcards, std::string &name_out)
bool	is_zero_dimensional (const std::vector< FGLMPoly > &basis, size_t num_vars)
bool	is_zero_number (const NumberNode &num)
static std::pair< SymbolicExpr, SymbolicExpr >	isolate_linear_coeff (const SymbolicExpr &expr, const std::string &var, ComputationContext &context)
Result< std::vector< std::pair< Rational, Rational > > >	isolate_real_roots_checked (const Polynomial< Rational > &polynomial)
Result< std::vector< std::pair< Rational, Rational > > >	isolate_real_roots_checked (const Polynomial< Rational > &polynomial, ComputationContext &context)
std::vector< IsolatedInterval >	isolate_roots (const std::shared_ptr< SymbolicExpr > &expr, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &var, const SearchInterval &interval, const SolveOptions &opts)
std::shared_ptr< SymbolicExpr >	jacobian (const std::vector< std::shared_ptr< SymbolicExpr > > &functions, const std::vector< std::string > &vars)
VectorCalculusExprResult	jacobian_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &functions, const std::vector< std::string > &vars)
VectorCalculusExprResult	jacobian_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &functions, const std::vector< std::string > &vars, ComputationContext &context)
JordanDecompositionResult	jordan_form_checked (const ExprPtr &A)
JordanDecompositionResult	jordan_form_checked (const ExprPtr &A, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	kronecker (const std::shared_ptr< SymbolicExpr > &A, const std::shared_ptr< SymbolicExpr > &B)
static std::vector< Rational >	lagrange_basis_coefficients (const std::vector< Rational > &points, size_t i, const Rational &denom)
static VectorCalculusFieldResult	lagrange_gradient_strict (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, const std::string &operation, detail::RewriteBudget &transform_budget)
static MultiPoly	lagrange_interpolate (const std::vector< Rational > &points, const std::vector< MultiPoly > &values, const std::string &main_var, const std::vector< std::string > &all_vars)
static std::vector< std::string >	lagrange_multiplier_names (size_t count)
std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > >	lagrange_multipliers (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &constraints, const std::vector< std::string > &vars)
LagrangeResult	lagrange_multipliers_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &constraints, const std::vector< std::string > &vars)
LagrangeResult	lagrange_multipliers_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &constraints, const std::vector< std::string > &vars, ComputationContext &context)
static LagrangeResult	lagrange_multipliers_strict (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &constraints, const std::vector< std::string > &vars, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
static std::shared_ptr< SymbolicExpr >	lagrange_stationarity_equation (const VectorField &gradient, const std::vector< VectorField > &constraints, const std::vector< std::string > &multipliers, size_t index)
uint64_t	lammp_gcd (uint64_t a, uint64_t b)
	计算两个无符号整数的最大公约数（调用 LMMP）
bool	lammp_is_prime (uint64_t n)
	判断无符号整数是否为素数
uint64_t	lammp_next_prime (uint64_t n)
	求大于 n 的下一个素数
TransformEngineResult	laplace_transform_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &s)
TransformEngineResult	laplace_transform_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &s, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	laplacian (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
VectorCalculusExprResult	laplacian_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
VectorCalculusExprResult	laplacian_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, ComputationContext &context)
ExpressionResult	laurent_series_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &center, int order_neg, int order_pos)
ExpressionResult	laurent_series_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &center, int order_neg, int order_pos, ComputationContext &context)
LaurentSeriesResult	laurent_series_full_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &center, int order_neg, int order_pos)
LaurentSeriesResult	laurent_series_full_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &center, int order_neg, int order_pos, ComputationContext &context)
static LaurentSeriesResult	laurent_series_full_impl (const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::shared_ptr< SymbolicExpr > &, int, int, ComputationContext &)
Monomial	lcm_monomial (const Monomial &a, const Monomial &b)
	计算两个单项式的最小公倍单项式
ExprResult	le (const ExprPtr &lhs, const ExprPtr &rhs)
DifferentialGeometryExprResult	lie_derivative_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &X, const std::vector< std::string > &vars, int order)
DifferentialGeometryExprResult	lie_derivative_checked (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &X, const std::vector< std::string > &vars, int order, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	lie_derivative_impl (const std::shared_ptr< SymbolicExpr > &, const std::vector< std::shared_ptr< SymbolicExpr > > &, const std::vector< std::string > &, int, ComputationContext &context)
static MultiPoly	lifting_error_coefficient (const MultiPoly &error, const std::string &lift_var, int lift_var_idx, const Rational &eval_point, int k, const std::vector< MultiPoly > &shift_powers, const std::vector< std::string > &vars)
static bool	lifting_residual_is_zero (const MultiPoly &verify_error, int lift_var_idx, int k)
static std::vector< MultiPoly >	lifting_shift_powers (const std::vector< std::string > &vars, int lift_var_idx, const Rational &eval_point, int degree_bound)
ExpressionResult	lim_inf_checked (const std::shared_ptr< SymbolicExpr > &a_n, const std::string &n)
ExpressionResult	lim_inf_checked (const std::shared_ptr< SymbolicExpr > &a_n, const std::string &n, ComputationContext &context)
ExpressionResult	lim_sup_checked (const std::shared_ptr< SymbolicExpr > &a_n, const std::string &n)
ExpressionResult	lim_sup_checked (const std::shared_ptr< SymbolicExpr > &a_n, const std::string &n, ComputationContext &context)
LimitResult	limit_checked (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context, Domain domain)
LimitResult	limit_checked (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, Domain domain)
LimitExpressionResult	limit_expression_checked (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, ComputationContext &context, Domain domain)
LimitExpressionResult	limit_expression_checked (const LimitExprPtr &expression, const std::string &variable, const LimitExprPtr &point, LimitDirection direction, Domain domain)
LineSymbolicResult	line_from_two_points_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &p1, const std::vector< std::shared_ptr< SymbolicExpr > > &p2)
LineSymbolicResult	line_from_two_points_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &p1, const std::vector< std::shared_ptr< SymbolicExpr > > &p2, ComputationContext &context)
VectorExprListResult	line_plane_intersection_checked (const LineSymbolic &line, const PlaneSymbolic &plane)
VectorExprListResult	line_plane_intersection_checked (const LineSymbolic &line, const PlaneSymbolic &plane, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	linear2_root_basis (const std::vector< ode_root_detail::CharRoot > &roots, const std::string &x)
ExprResult	log (const ExprPtr &expression)
ExprResult	log (const ExprPtr &expression, ComputationContext &context)
ExprResult	log10 (const ExprPtr &expression)
ExprResult	log10 (const ExprPtr &expression, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	log_differentiate (const std::shared_ptr< SymbolicExpr > &f, const std::string &var)
ExprResult	logical_and (const ExprPtr &lhs, const ExprPtr &rhs)
ExprResult	logical_not (const ExprPtr &expression)
ExprResult	logical_or (const ExprPtr &lhs, const ExprPtr &rhs)
template<typename Transform>
std::shared_ptr< SymbolicExpr >	lookup_integral (const std::vector< detail::IntegrationEntry > &table, const SymbolicExpr &matched, const std::string &matched_variable, detail::RewriteBudget &budget, Transform &&transform)
ExprResult	lt (const ExprPtr &lhs, const ExprPtr &rhs)
LUDecompositionResult	lu_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A)
LUDecompositionResult	lu_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	make_abs (std::shared_ptr< SymbolicExpr > expr)
	Wrap an expression in abs() to signal positive-branch preference.
std::shared_ptr< SymbolicExpr >	make_arctan (const std::shared_ptr< SymbolicExpr > &operand)
ComplexSymbolic	make_complex (std::shared_ptr< SymbolicExpr > real, std::shared_ptr< SymbolicExpr > imag)
	构造符号复数
SymbolicSetResult	make_finite_set (std::vector< std::shared_ptr< SymbolicExpr > > elements, ComputationContext &context)
SymbolicSetResult	make_interval (const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, bool lower_closed, bool upper_closed, ComputationContext &context)
SymbolicSetResult	make_membership (const std::shared_ptr< SymbolicExpr > &element, const std::shared_ptr< SymbolicExpr > &set, ComputationContext &context)
std::shared_ptr< const SymbolicNode >	make_normalized_multiply_node (const std::vector< std::shared_ptr< const SymbolicNode > > &operands, detail::RewriteBudget *budget=nullptr)
RootOfConstructionResult	make_rootof_checked (const std::shared_ptr< SymbolicExpr > &polynomial, const std::string &variable, std::size_t index)
RootOfConstructionResult	make_rootof_checked (const std::shared_ptr< SymbolicExpr > &polynomial, const std::string &variable, std::size_t index, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	make_rootof_solutions (const Polynomial< SymbolicPolyCoeff > &poly, const std::string &var)
std::shared_ptr< SymbolicExpr >	make_unary_function (FunctionNode::FuncType type, const std::shared_ptr< SymbolicExpr > &operand)
static bool	match_commutative_recursive (const std::vector< std::shared_ptr< const SymbolicNode > > &p_ops, const std::vector< std::shared_ptr< const SymbolicNode > > &t_ops, std::vector< bool > &used_t, size_t p_index, const std::unordered_set< std::string > &wildcards, MatchMap &results)
static bool	match_function (const FunctionNode &pattern, const FunctionNode &target, const std::unordered_set< std::string > &wildcards, MatchMap &results)
template<typename Operation>
static bool	match_operation (const Operation &pattern, const Operation &target, const std::unordered_set< std::string > &wildcards, const char *rest_key, MatchMap &results)
static bool	match_recursive (const std::shared_ptr< const SymbolicNode > &p_node, const std::shared_ptr< const SymbolicNode > &t_node, const std::unordered_set< std::string > &wildcards, MatchMap &results)
ExpressionResult	matrix_characteristic_polynomial_checked (const std::shared_ptr< SymbolicExpr > &A, const std::string &variable)
ExpressionResult	matrix_characteristic_polynomial_checked (const std::shared_ptr< SymbolicExpr > &A, const std::string &variable, ComputationContext &context)
ExpressionResult	matrix_determinant_checked (const std::shared_ptr< SymbolicExpr > &A)
ExpressionResult	matrix_determinant_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
MatrixEigenvalueResult	matrix_eigenvalues_checked (const std::shared_ptr< SymbolicExpr > &A)
MatrixEigenvalueResult	matrix_eigenvalues_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
MatrixEigenvectorResult	matrix_eigenvectors_checked (const std::shared_ptr< SymbolicExpr > &A)
MatrixEigenvectorResult	matrix_eigenvectors_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
ExprPtr	matrix_exp (const ExprPtr &A)
ExpressionResult	matrix_inverse_checked (const std::shared_ptr< SymbolicExpr > &A)
ExpressionResult	matrix_inverse_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
ExprPtr	matrix_log (const ExprPtr &A)
ExpressionResult	matrix_multiply_checked (const std::shared_ptr< SymbolicExpr > &A, const std::shared_ptr< SymbolicExpr > &B)
ExpressionResult	matrix_multiply_checked (const std::shared_ptr< SymbolicExpr > &A, const std::shared_ptr< SymbolicExpr > &B, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	matrix_norm (const std::shared_ptr< SymbolicExpr > &A, const std::string &type)
MatrixNullspaceResult	matrix_nullspace_checked (const std::shared_ptr< SymbolicExpr > &A)
MatrixNullspaceResult	matrix_nullspace_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
MatrixRankResult	matrix_rank_checked (const std::shared_ptr< SymbolicExpr > &A)
MatrixRankResult	matrix_rank_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
ExpressionResult	matrix_reflection_checked (double angle, int dim)
ExpressionResult	matrix_reflection_checked (double angle, int dim, ComputationContext &context)
ExpressionResult	matrix_rotation_checked (double theta, int dim)
ExpressionResult	matrix_rotation_checked (double theta, int dim, ComputationContext &context)
ExpressionResult	matrix_rref_checked (const std::shared_ptr< SymbolicExpr > &A)
ExpressionResult	matrix_rref_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
ExpressionResult	matrix_scaling_checked (double sx, double sy, int dim)
ExpressionResult	matrix_scaling_checked (double sx, double sy, int dim, ComputationContext &context)
MatrixLinearSolveResult	matrix_solve_linear_checked (const std::shared_ptr< SymbolicExpr > &coefficients, const std::shared_ptr< SymbolicExpr > &right_hand_side)
MatrixLinearSolveResult	matrix_solve_linear_checked (const std::shared_ptr< SymbolicExpr > &coefficients, const std::shared_ptr< SymbolicExpr > &right_hand_side, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	matrix_trace (const std::shared_ptr< SymbolicExpr > &A)
ExprResult	member (const ExprPtr &element, const ExprPtr &set, ComputationContext &context)
ExprResult	membership (const ExprPtr &element, const ExprPtr &set, bool negated)
DifferentialGeometryExprResult	metric_inverse_checked (const std::shared_ptr< SymbolicExpr > &g_ij)
DifferentialGeometryExprResult	metric_inverse_checked (const std::shared_ptr< SymbolicExpr > &g_ij, ComputationContext &context)
VectorCalculusExprResult	mixed_product (const VectorField &a, const VectorField &b, const VectorField &c)
static VectorCalculusExprResult	mixed_product_impl (const VectorField &a, const VectorField &b, const VectorField &c, detail::RewriteBudget &transform_budget)
ExprResult	mul (const ExprPtr &lhs, const ExprPtr &rhs)
ExprResult	mul (const ExprPtr &lhs, const ExprPtr &rhs, ComputationContext &context)
std::pair< int64_t, int64_t >	multi_crt (const std::vector< int64_t > &residues, const std::vector< int64_t > &primes)
	多模数中国剩余定理
CrtResult	multi_crt_checked (const std::vector< int64_t > &residues, const std::vector< int64_t > &primes)
CrtResult	multi_crt_checked (const std::vector< int64_t > &residues, const std::vector< int64_t > &primes, ComputationContext &context)
	Checked CRT for a non-empty list of pairwise coprime positive moduli.
static std::shared_ptr< const NumberNode >	multiply_number_nodes (const std::shared_ptr< const NumberNode > &a, const std::shared_ptr< const NumberNode > &b)
std::shared_ptr< const NumberNode >	multiply_numbers (const std::shared_ptr< const NumberNode > &a, const std::shared_ptr< const NumberNode > &b)
	两个数值节点相乘
static std::shared_ptr< SymbolicExpr >	multipoly_to_symbolic (const LMCAS::MultiPoly &poly, ComputationContext &context)
MultiPoly	multivariate_content (const MultiPoly &poly, const std::string &main_var)
std::vector< MultiPoly >	multivariate_diophantine (const std::vector< MultiPoly > &factors, const MultiPoly &target, const std::string &var, const Rational &eval_point, int degree_bound)
	多元丢番图方程求解器
static std::shared_ptr< SymbolicExpr >	multivariate_factor_expression (const MultiFactorResult &result, ComputationContext &context)
MultiPoly	multivariate_gcd (const MultiPoly &a, const MultiPoly &b)
std::vector< MultiPoly >	multivariate_hensel_lift (const MultiPoly &poly, const std::vector< Polynomial< Rational > > &univariate_factors, const std::string &lift_var, const Rational &eval_point, int degree_bound)
	多元 Hensel 提升(单变量步)
MultiPoly	multivariate_primitive_part (const MultiPoly &poly, const std::string &main_var)
ExprResult	ne (const ExprPtr &lhs, const ExprPtr &rhs)
ExprResult	neg (const ExprPtr &expression)
ExprResult	neg (const ExprPtr &expression, ComputationContext &context)
NumericRootResult	newton_raphson_checked (const std::shared_ptr< SymbolicExpr > &function, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &variable, lmmc_real_t initial, ComputationContext &context, const SolveOptions &options)
NumericRootResult	newton_raphson_checked (const std::shared_ptr< SymbolicExpr > &function, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &variable, lmmc_real_t initial, const SolveOptions &options)
NumericRootResult	newton_raphson_checked (const std::shared_ptr< SymbolicExpr > &function, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &variable, lmmc_real_t initial, lmmc_real_t bracket_lower, lmmc_real_t bracket_upper, ComputationContext &context, const SolveOptions &options)
NumericRootResult	newton_raphson_checked (const std::shared_ptr< SymbolicExpr > &function, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &variable, lmmc_real_t initial, lmmc_real_t bracket_lower, lmmc_real_t bracket_upper, const SolveOptions &options)
std::shared_ptr< const SymbolicNode >	norm_subst_index (const std::shared_ptr< const SymbolicNode > &node, const std::string &index_var, const std::shared_ptr< const SymbolicNode > &value, detail::RewriteBudget *budget=nullptr)
FGLMPoly	normal_form (const FGLMPoly &f, const std::vector< FGLMPoly > &basis, const MonomialOrder &order)
void	normalization_append (detail::RewriteBudget *budget, std::size_t &nodes, std::vector< std::shared_ptr< const SymbolicNode > > &children, std::shared_ptr< const SymbolicNode > child)
bool	normalization_can_discard (const std::shared_ptr< const SymbolicNode > &node, const FactsQuery &facts, Domain domain, ComputationContext &context)
template<class Parent>
std::size_t	normalization_check_arithmetic (detail::RewriteBudget *budget, const std::vector< std::shared_ptr< const SymbolicNode > > &children, std::size_t nodes, bool wrapped=true)
template<class Parent, class... Nodes>
std::size_t	normalization_check_arithmetic (detail::RewriteBudget *budget, std::size_t extra_nodes, const std::shared_ptr< const Nodes > &... children)
template<class... Nodes>
void	normalization_check_children (detail::RewriteBudget *budget, std::size_t roots, const std::shared_ptr< const Nodes > &... children)
void	normalization_check_children (detail::RewriteBudget *budget, std::size_t roots, const std::vector< std::shared_ptr< const SymbolicNode > > &children)
std::size_t	normalization_check_count (detail::RewriteBudget *budget, std::size_t rows, std::size_t cols=1, bool wrapped=true)
std::shared_ptr< const NumberNode >	normalization_exact_square_root (const NumberNode &number)
bool	normalization_factor_less (const std::shared_ptr< const SymbolicNode > &left, const std::shared_ptr< const SymbolicNode > &right)
std::shared_ptr< const SymbolicNode >	normalization_imaginary_power (const BigInt &exponent, detail::RewriteBudget *budget=nullptr)
std::shared_ptr< const SymbolicNode >	normalization_numeric_function (FunctionNode::FuncType type, const std::shared_ptr< const NumberNode > &number, detail::RewriteBudget *budget=nullptr)
std::shared_ptr< const SymbolicNode >	normalization_numeric_power (const std::shared_ptr< const NumberNode > &base, const std::shared_ptr< const NumberNode > &exponent, detail::RewriteBudget *budget=nullptr)
std::shared_ptr< const SymbolicNode >	normalization_pi_function (FunctionNode::FuncType type, const Rational &coefficient, detail::RewriteBudget *budget=nullptr)
bool	normalization_proved (const Result< Tribool > &result)
static MultiPoly	normalize_gcd_candidate (MultiPoly candidate, const Rational &content)
Result< std::vector< Interval > >	normalize_intervals_checked (std::vector< Interval > intervals)
Result< std::vector< Interval > >	normalize_intervals_checked (std::vector< Interval > intervals, ComputationContext &context)
static bool	numeric_domain_excludes (double value, Domain domain)
static bool	numeric_sign_excludes (double value, const AssumptionContext &ctx, const std::string &variable)
static std::shared_ptr< SymbolicExpr >	numeric_token_value (const std::string &str, size_t start, size_t &pos, bool decimal)
std::ostream &	operator<< (std::ostream &os, const Irrational &value)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const Polynomial< T > &p)
	多项式流输出运算符
static FrobeniusSolutionResult	ordinary_frobenius_solution (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, const std::shared_ptr< SymbolicExpr > &x_minus_x0, FrobeniusSolution result, ComputationContext &context)
static Result< std::vector< double > >	ordinary_series_recurrence (const OdeTaylorCoefficients &coefficients, int order)
static Result< OdeTaylorCoefficients >	ordinary_taylor_coefficients (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, int order, ComputationContext &context)
static std::map< std::string, std::shared_ptr< SymbolicExpr > >	parametric_linear_solution (const ParametricMatrix &A, const ParametricVector &b, const std::vector< size_t > &pivot_cols, const std::vector< size_t > &pivot_rows, const std::vector< std::string > &unknowns, ComputationContext &context)
static Tribool	parametric_nonzero_value (const std::shared_ptr< SymbolicExpr > &expression, ComputationContext &context)
static bool	parametric_residual_zero (const std::shared_ptr< SymbolicExpr > &expression, ComputationContext &context)
static bool	parametric_zero (const std::shared_ptr< SymbolicExpr > &expression, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	parse_approximate_atom (const std::string &str, size_t &pos)
static bool	parse_endpoint_value (const std::string &str, size_t &pos, Endpoint &ep)
ExprResult	parse_expr (const std::string &source)
ExprResult	parse_expr (const std::string &source, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	parse_fraction (const std::string &str, size_t start, size_t &pos)
static bool	parse_interval_lower (const std::string &str, size_t &pos, Endpoint &lower)
static bool	parse_interval_upper (const std::string &str, size_t &pos, Endpoint &upper)
static std::shared_ptr< SymbolicExpr >	parse_numeric_value (const std::string &str, size_t &pos)
static bool	parse_single_interval (const std::string &str, size_t &pos, Interval &iv)
ExprResult	phi ()
ExprResult	pi ()
PlaneSymbolicResult	plane_from_three_points_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &p1, const std::vector< std::shared_ptr< SymbolicExpr > > &p2, const std::vector< std::shared_ptr< SymbolicExpr > > &p3)
PlaneSymbolicResult	plane_from_three_points_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &p1, const std::vector< std::shared_ptr< SymbolicExpr > > &p2, const std::vector< std::shared_ptr< SymbolicExpr > > &p3, ComputationContext &context)
PlaneSymbolic	plane_general (std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, std::shared_ptr< SymbolicExpr > c, std::shared_ptr< SymbolicExpr > d)
	由一般方程系数构造平面 ax + by + cz = d。
ExpressionResult	point_plane_distance_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &point, const PlaneSymbolic &plane)
ExpressionResult	point_plane_distance_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &point, const PlaneSymbolic &plane, ComputationContext &context)
static ExprPtr	polynomial_logic (const ExprPtr &left, const ExprPtr &right, LogicalNode::Op op)
template<typename T>
bool	polynomial_product_fits (const Polynomial< T > &left, const Polynomial< T > &right)
static ExprPtr	polynomial_relation (const ExprPtr &left, const ExprPtr &right, RelationOp op)
static std::vector< BigInt >	positive_divisors (const BigInt &n)
ExprResult	pow (const ExprPtr &base, const ExprPtr &exponent)
ExprResult	pow (const ExprPtr &base, const ExprPtr &exponent, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	power_series_add (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b)
PowerSeriesResult	power_series_compose_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &g, int order)
PowerSeriesResult	power_series_compose_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &f, const std::vector< std::shared_ptr< SymbolicExpr > > &g, int order, ComputationContext &context)
PowerSeriesResult	power_series_multiply_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b, int order)
PowerSeriesResult	power_series_multiply_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b, int order, ComputationContext &context)
static std::optional< ConvergenceInfo >	power_term_convergence (const std::shared_ptr< const SymbolicNode > &node, const std::string &index_var)
static Result< FourierPeriod >	prepare_fourier_period (const std::shared_ptr< SymbolicExpr > &period, const std::string &var, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	product_without_factor (const MultiplyNode &product, size_t omitted)
static ExprSetResult	project_finite_expr_set (const ExprPtr &original, const std::string &variable, ComputationContext &context, const SolveOptions &options)
QRDecompositionResult	qr_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A)
QRDecompositionResult	qr_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	quadratic_form_matrix (const std::shared_ptr< SymbolicExpr > &expr, const std::vector< std::string > &vars)
Result< QuadratureEstimate >	quadrature_gaussian_numeric (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, int order)
Result< QuadratureEstimate >	quadrature_gaussian_numeric (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, int order)
Result< QuadratureEstimate >	quadrature_simpson_numeric (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, int subdivisions)
Result< QuadratureEstimate >	quadrature_simpson_numeric (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, int subdivisions)
QuantityResult	quantity_add (const std::shared_ptr< SymbolicExpr > &lhs, const std::shared_ptr< SymbolicExpr > &rhs, ComputationContext &context)
QuantityResult	quantity_divide (const std::shared_ptr< SymbolicExpr > &lhs, const std::shared_ptr< SymbolicExpr > &rhs, ComputationContext &context)
QuantityResult	quantity_multiply (const std::shared_ptr< SymbolicExpr > &lhs, const std::shared_ptr< SymbolicExpr > &rhs, ComputationContext &context)
QuantityResult	quantity_power (const std::shared_ptr< SymbolicExpr > &base, const std::shared_ptr< SymbolicExpr > &exponent, ComputationContext &context)
QuantityResult	quantity_subtract (const std::shared_ptr< SymbolicExpr > &lhs, const std::shared_ptr< SymbolicExpr > &rhs, ComputationContext &context)
int	quotient_dimension (const std::vector< FGLMPoly > &basis, size_t num_vars, int max_degree)
static ConvergenceInfoResult	ratio_convergence_test (const std::shared_ptr< SymbolicExpr > &general_term, const std::string &index_var, ComputationContext &context)
ExprResult	rational (const Rational &value)
static Rational	rational_gcd (const Rational &a, const Rational &b)
RationalReconstructionResult	rational_reconstruction_checked (int64_t x, int64_t m)
RationalReconstructionResult	rational_reconstruction_checked (int64_t x, int64_t m, ComputationContext &context)
	Checked rational reconstruction.
static std::optional< Rational >	rational_root_candidate (const Polynomial< Rational > &current)
static std::vector< std::shared_ptr< const SymbolicNode > >	rational_root_factors (const std::vector< Rational > &roots, const Rational &leading, const std::shared_ptr< SymbolicExpr > &x_node, ComputationContext &context)
static Polynomial< Rational >	rational_root_product (const std::vector< Rational > &roots, const Rational &leading, const std::string &var)
static Polynomial< SymbolicPolyCoeff >	rational_to_symbolic_poly (const Polynomial< Rational > &rat_poly)
NumberDomainSet	rationals ()
ExprResult	real (const ExprPtr &expression)
ExprResult	real (const ExprPtr &expression, ComputationContext &context)
ExpressionResult	real_part_checked (const std::shared_ptr< SymbolicExpr > &expr)
ExpressionResult	real_part_checked (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
NumberDomainSet	reals ()
Result< OptionalRationalPolynomial >	recognize_rational_polynomial (const SymbolicExpr &expression, const std::string &variable, ComputationContext &context)
static Result< int >	recognize_regular_laurent (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, ComputationContext &context)
static std::optional< ExpressionResult >	reconstruct_rational_root_factors (const Polynomial< Rational > &polynomial, const std::vector< Rational > &roots, const std::string &var, ComputationContext &context)
static RationalRootReconstruction	reconstruct_rational_roots (const Polynomial< Rational > &polynomial, const std::vector< Rational > &roots, const std::string &variable, ComputationContext &context)
template<typename Operation>
static void	record_remainder (const Operation &target, const std::vector< bool > &used, const char *key, MatchMap &results)
static MultiPoly	recursive_multivariate_gcd (const MultiPoly &a, const MultiPoly &b, const std::vector< std::string > &vars)
std::optional< NumericRoot >	refine_root (const std::shared_ptr< SymbolicExpr > &expr, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &var, const IsolatedInterval &interval, const SolveOptions &opts)
static bool	regular_laurent_type (FunctionNode::FuncType type)
ExprResult	relation (const ExprPtr &lhs, const ExprPtr &rhs, RelationOp op)
std::optional< RelationOp >	relation_op (const ExprPtr &expression) noexcept
ExpressionResult	residue_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int order)
ExpressionResult	residue_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &z, const std::shared_ptr< SymbolicExpr > &z0, int order, ComputationContext &context)
static Monomial	restore_main_exponent (const Monomial &reduced, size_t variable_count, int variable_index, int exponent)
DifferentialGeometryExprResult	riemann_curvature_tensor_checked (const std::shared_ptr< SymbolicExpr > &g_ij, const std::vector< std::string > &coords, int rho, int sigma, int mu, int nu)
DifferentialGeometryExprResult	riemann_curvature_tensor_checked (const std::shared_ptr< SymbolicExpr > &g_ij, const std::vector< std::string > &coords, int rho, int sigma, int mu, int nu, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	riemann_curvature_tensor_with_inverse (const std::shared_ptr< SymbolicExpr > &g_ij, const std::shared_ptr< SymbolicExpr > &g_up_ij, const std::vector< std::string > &coords, int rho, int sigma, int mu, int nu, ComputationContext &context)
bool	root_less_than (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
RootOfEvaluationResult	rootof_evaluate_checked (const std::shared_ptr< SymbolicExpr > &rootof_expr)
RootOfEvaluationResult	rootof_evaluate_checked (const std::shared_ptr< SymbolicExpr > &rootof_expr, ComputationContext &context)
RootOfComplexEvaluationResult	rootof_evaluate_complex_checked (const std::shared_ptr< SymbolicExpr > &rootof_expr)
RootOfComplexEvaluationResult	rootof_evaluate_complex_checked (const std::shared_ptr< SymbolicExpr > &rootof_expr, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	rootof_simplify (const std::shared_ptr< SymbolicExpr > &rootof_expr)
ExprSetResult	roots (const ExprPtr &expression, const std::string &variable, ComputationContext &context, const SolveOptions &options)
ExprSetResult	roots (const ExprPtr &expression, const std::string &variable, const SolveOptions &options)
bool	roots_equal (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
ExprResult	round (const ExprPtr &expression)
ExprResult	round (const ExprPtr &expression, ComputationContext &context)
VectorCalculusExprResult	scalar_project (const VectorField &a, const VectorField &b)
static VectorCalculusExprResult	scalar_project_impl (const VectorField &a, const VectorField &b, detail::RewriteBudget &transform_budget)
static detail::SymbolicNodePtr	scale_integral_field (const detail::SymbolicNodePtr &value, const detail::SymbolicNodePtr &coefficient, detail::RewriteBudget &budget)
static bool	separable_product (const MultiplyNode &product, const std::string &x, const std::string &y)
static bool	separable_reciprocal (const PowerNode &power, const std::string &x, const std::string &y)
static ExpressionResult	sequence_extreme_limit (const std::shared_ptr< SymbolicExpr > &a_n, const std::string &n, bool upper, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	series_abs (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
static bool	series_extract_alternating (const std::shared_ptr< const SymbolicNode > &node, const std::string &n, std::shared_ptr< SymbolicExpr > &remainder)
double	series_get_double (const std::shared_ptr< SymbolicExpr > &expression)
static bool	series_index_variable (const std::shared_ptr< const VariableNode > &variable, const std::string &index_var)
bool	series_is_infinity (const std::shared_ptr< SymbolicExpr > &expression)
bool	series_is_infinity (const std::shared_ptr< SymbolicExpr > &expression)
bool	series_is_number (const std::shared_ptr< SymbolicExpr > &expression)
static std::shared_ptr< SymbolicExpr >	series_negate (const std::shared_ptr< SymbolicExpr > &expr, ComputationContext &context)
double	series_number_value (const NumberNode &number)
Result< void >	set_eqv_budget (EqvOptions &options, std::size_t steps, std::size_t depth, std::size_t growth)
Result< void >	set_eqv_profile (EqvOptions &options, const std::string &name)
ExprResult	simplify (const ExprPtr &expression)
ExprResult	simplify (const ExprPtr &expression, ComputationContext &context)
static bool	simplify_finite_limit (std::shared_ptr< SymbolicExpr > &value, ComputationContext &context)
static std::shared_ptr< const SymbolicNode >	simplify_pythagorean_sum (const AddNode &sum, const std::string &var)
ExprResult	sin (const ExprPtr &expression)
ExprResult	sin (const ExprPtr &expression, ComputationContext &context)
static FrobeniusSolutionResult	singular_frobenius_solution (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, const std::shared_ptr< SymbolicExpr > &x_minus_x0, FrobeniusSolution result, ComputationContext &context)
static Result< std::vector< double > >	singular_series_recurrence (const OdeTaylorCoefficients &coefficients, double P0, double Q0, double r1, int order)
static Result< OdeTaylorCoefficients >	singular_taylor_coefficients (const std::shared_ptr< SymbolicExpr > &xp_expr, const std::shared_ptr< SymbolicExpr > &x2q_expr, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, int order, double P0, double Q0, ComputationContext &context)
ExpressionResult	skew_lines_distance_checked (const LineSymbolic &l1, const LineSymbolic &l2)
ExpressionResult	skew_lines_distance_checked (const LineSymbolic &l1, const LineSymbolic &l2, ComputationContext &context)
static size_t	skip_ws (const std::string &str, size_t pos)
static Result< bool >	solution_is_excluded (const std::shared_ptr< SymbolicExpr > &solution, Domain domain, const AssumptionContext &ctx, const std::string &variable, ComputationContext &context)
ExprSetResult	solve (const ExprPtr &equation, const std::string &variable, ComputationContext &context, const SolveOptions &options)
ExprSetResult	solve (const ExprPtr &equation, const std::string &variable, const SolveOptions &options)
ODESolutionResult	solve_bernoulli_ode_checked (const std::shared_ptr< SymbolicExpr > &P, const std::shared_ptr< SymbolicExpr > &Q, int n, const std::string &x, const std::string &y)
ODESolutionResult	solve_bernoulli_ode_checked (const std::shared_ptr< SymbolicExpr > &P, const std::shared_ptr< SymbolicExpr > &Q, int n, const std::string &x, const std::string &y, ComputationContext &context)
static ODESolutionResult	solve_bernoulli_ode_impl (const std::shared_ptr< SymbolicExpr > &, const std::shared_ptr< SymbolicExpr > &, int, const std::string &, const std::string &, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_biquadratic (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::string &variable)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_by_factoring (const Polynomial< SymbolicPolyCoeff > &poly, const std::string &variable)
static std::vector< std::shared_ptr< SymbolicExpr > >	solve_closed_form_from_poly (const Polynomial< SymbolicPolyCoeff > &poly, const std::string &var, ComputationContext &context)
static std::vector< std::shared_ptr< SymbolicExpr > >	solve_closed_form_poly (const Polynomial< SymbolicPolyCoeff > &poly, const std::string &var, ComputationContext &context)
ComplexRootsResult	solve_complex_nth_root_checked (std::shared_ptr< SymbolicExpr > c, int n)
ComplexRootsResult	solve_complex_nth_root_checked (std::shared_ptr< SymbolicExpr > c, int n, ComputationContext &context)
ComplexRootsResult	solve_complex_quadratic_checked (std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, std::shared_ptr< SymbolicExpr > c)
ComplexRootsResult	solve_complex_quadratic_checked (std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, std::shared_ptr< SymbolicExpr > c, ComputationContext &context)
static IntervalUnion	solve_constant_inequality (const Polynomial< SymbolicPolyCoeff > &poly, InequalityType type, ComputationContext &context)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_cubic (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, const std::string &variable)
static std::vector< std::shared_ptr< SymbolicExpr > >	solve_degenerate_cubic (const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, ComputationContext &context)
static std::vector< MultiPoly >	solve_diophantine_pair (const std::vector< MultiPoly > &factors, const MultiPoly &target, const std::string &var, const Rational &eval_point, int degree_bound)
LMCAS::SolveResult	solve_equation (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
LMCAS::SolveResult	solve_equation (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts)
ODESolutionResult	solve_euler_ode_checked (const std::vector< double > &euler_coeffs, const std::shared_ptr< SymbolicExpr > &forcing, const std::string &x, const std::string &y)
ODESolutionResult	solve_euler_ode_checked (const std::vector< double > &euler_coeffs, const std::shared_ptr< SymbolicExpr > &forcing, const std::string &x, const std::string &y, ComputationContext &context)
static Result< ODESolution >	solve_euler_ode_impl (const std::vector< double > &, const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::string &, ComputationContext &context)
Result< IntervalUnion >	solve_exact_affine_inequality (const Polynomial< Rational > &polynomial, InequalityType type, ComputationContext &context)
static SolveVectorResult	solve_exact_factor (Polynomial< Rational > remainder, const std::string &var, ComputationContext &context)
ODESolutionResult	solve_exact_ode_checked (const std::shared_ptr< SymbolicExpr > &M, const std::shared_ptr< SymbolicExpr > &N, const std::string &x, const std::string &y)
ODESolutionResult	solve_exact_ode_checked (const std::shared_ptr< SymbolicExpr > &M, const std::shared_ptr< SymbolicExpr > &N, const std::string &x, const std::string &y, ComputationContext &context)
static ODESolutionResult	solve_exact_ode_impl (const std::shared_ptr< SymbolicExpr > &, const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::string &, ComputationContext &context)
Result< IntervalUnion >	solve_exact_polynomial_inequality (const Polynomial< Rational > &polynomial, InequalityType type, ComputationContext &context)
static SolveResult	solve_exact_polynomial_set (const Polynomial< Rational > &exact, const std::string &var, ComputationContext &context)
ExprSetResult	solve_expr_set (const ExprPtr &equation, const std::string &variable, ComputationContext &context, const SolveOptions &options)
ExprSetResult	solve_expr_set (const ExprPtr &equation, const std::string &variable, const SolveOptions &options)
LMCAS::FiniteSolveResult	solve_finite_checked (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
LMCAS::FiniteSolveResult	solve_finite_checked (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable, const SolveOptions &options)
static std::optional< SolveVectorResult >	solve_finite_mixed (const std::shared_ptr< SymbolicExpr > &f_expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
FrobeniusSolutionResult	solve_frobenius_checked (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, int order)
FrobeniusSolutionResult	solve_frobenius_checked (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, int order, ComputationContext &context)
static FrobeniusSolutionResult	solve_frobenius_impl (const std::shared_ptr< SymbolicExpr > &, const std::shared_ptr< SymbolicExpr > &, const std::shared_ptr< SymbolicExpr > &, const std::string &, int, ODESingularityType, ComputationContext &)
static SolveVectorResult	solve_higher_exact_roots (const Polynomial< Rational > &remainder, const std::string &var, ComputationContext &context)
ODESolutionResult	solve_higher_order_ode_checked (const std::vector< double > &coeffs, const std::shared_ptr< SymbolicExpr > &forcing, const std::string &x, const std::string &y)
ODESolutionResult	solve_higher_order_ode_checked (const std::vector< double > &coeffs, const std::shared_ptr< SymbolicExpr > &forcing, const std::string &x, const std::string &y, ComputationContext &context)
static Result< ODESolution >	solve_higher_order_ode_impl (const std::vector< double > &, const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::string &, ComputationContext &context)
ODESolutionResult	solve_homogeneous_ode_checked (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y)
ODESolutionResult	solve_homogeneous_ode_checked (const std::shared_ptr< SymbolicExpr > &rhs, const std::string &x, const std::string &y, ComputationContext &context)
static ODESolutionResult	solve_homogeneous_ode_impl (const std::shared_ptr< SymbolicExpr > &, const std::string &, const std::string &, ComputationContext &context)
static LagrangeResult	solve_lagrange_strict (const VectorField &equations, const std::vector< std::string > &all_vars, ComputationContext &context, const std::string &operation)
ExprPtr	solve_linear1_ode (ExprPtr Px, ExprPtr Qx, const std::string &x, const std::string &y, const AssumptionContext *ctx)
static Result< std::shared_ptr< SymbolicExpr > >	solve_linear2_homogeneous (double a, double b, double c, const std::string &x, const std::string &y, const AssumptionContext *ctx, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	solve_linear2_ode (double a, double b, double c, std::shared_ptr< SymbolicExpr > fx, const std::string &x, const std::string &y, const AssumptionContext *ctx)
Result< std::shared_ptr< SymbolicExpr > >	solve_linear2_ode_checked (double a, double b, double c, std::shared_ptr< SymbolicExpr > fx, const std::string &x, const std::string &y, ComputationContext &context, const AssumptionContext *ctx)
Result< std::shared_ptr< SymbolicExpr > >	solve_linear2_ode_checked (double a, double b, double c, std::shared_ptr< SymbolicExpr > fx, const std::string &x, const std::string &y, const AssumptionContext *ctx)
MixedTranscendentalResult	solve_mixed_transcendental_checked (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts)
MixedTranscendentalResult	solve_mixed_transcendental_checked (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts, ComputationContext &context)
NumericRootsResult	solve_numeric_checked (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
NumericRootsResult	solve_numeric_checked (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const SolveOptions &opts)
static SolveResult	solve_product_factor (const detail::SymbolicNodePtr &node, const std::string &variable, ComputationContext &context, const SolveOptions &options, std::size_t &multiplicity)
static std::optional< SolveResult >	solve_product_set (const ExprPtr &expression, const std::string &variable, ComputationContext &context, const SolveOptions &options)
std::vector< std::shared_ptr< SymbolicExpr > >	solve_quartic (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, const std::shared_ptr< SymbolicExpr > &e, const std::string &variable)
ExprPtr	solve_separable_ode (ExprPtr rhs, const std::string &x, const std::string &y, const AssumptionContext *ctx)
SolveResult	solve_set (const ExprPtr &equation, const std::string &variable, ComputationContext &context, const SolveOptions &options)
SolveResult	solve_set (const ExprPtr &equation, const std::string &variable, const SolveOptions &options)
static SolveResult	solve_set_core (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
static SolveResult	solve_symbolic_polynomial_set (const Polynomial< SymbolicPolyCoeff > &polynomial, const ExprPtr &original, const std::string &variable, ComputationContext &context)
static SolveResult	solve_symbolic_quadratic (const Polynomial< SymbolicPolyCoeff > &polynomial, const ExprPtr &leading, const FactsQuery &facts, ComputationContext &context)
SolveResult	solve_transcendental (const ExprPtr &expr, const std::string &var, ComputationContext &context, const SolveOptions &options)
SolveResult	solve_transcendental (const ExprPtr &expr, const std::string &var, const SolveOptions &options)
ODESolutionResult	solve_variation_of_parameters_checked (const std::shared_ptr< SymbolicExpr > &y1, const std::shared_ptr< SymbolicExpr > &y2, const std::shared_ptr< SymbolicExpr > &g, const std::string &x)
ODESolutionResult	solve_variation_of_parameters_checked (const std::shared_ptr< SymbolicExpr > &y1, const std::shared_ptr< SymbolicExpr > &y2, const std::shared_ptr< SymbolicExpr > &g, const std::string &x, ComputationContext &context)
static ODESolutionResult	solve_variation_of_parameters_core (const std::shared_ptr< SymbolicExpr > &y1, const std::shared_ptr< SymbolicExpr > &y2, const std::shared_ptr< SymbolicExpr > &g, const std::string &x, ComputationContext &context)
AssumptionSolveResult	solve_with_assumptions_checked (const std::shared_ptr< SymbolicExpr > &equation, const std::string &variable, const AssumptionContext *assumptions)
AssumptionSolveResult	solve_with_assumptions_checked (const std::shared_ptr< SymbolicExpr > &equation, const std::string &variable, const AssumptionContext *assumptions, ComputationContext &context)
static AssumptionSolveResult	solve_with_assumptions_impl (const std::shared_ptr< SymbolicExpr > &equation, const std::string &variable, const AssumptionContext *ctx, ComputationContext &context)
ExprResult	sqrt (const ExprPtr &expression)
ExprResult	sqrt (const ExprPtr &expression, ComputationContext &context)
SquareFreeDecomp	square_free_decompose (const MultiPoly &poly, const std::string &main_var)
	多元无平方因子分解(Yun 算法的多元推广)
std::vector< std::pair< Polynomial< Rational >, int > >	square_free_factorization (const Polynomial< Rational > &poly)
static bool	starts_with_at (const std::string &str, size_t pos, const std::string &prefix)
std::shared_ptr< SymbolicExpr >	stokes_theorem (const VectorField &F, const std::vector< std::string > &vars, const VectorField &parametrization, const std::string &u, const std::string &v, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &u_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &v_bounds)
VectorCalculusExprResult	stokes_theorem_checked (const VectorField &F, const std::vector< std::string > &vars, const VectorField &parametrization, const std::string &u, const std::string &v, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &u_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &v_bounds)
VectorCalculusExprResult	stokes_theorem_checked (const VectorField &F, const std::vector< std::string > &vars, const VectorField &parametrization, const std::string &u, const std::string &v, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &u_bounds, const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &v_bounds, ComputationContext &context)
ExprResult	strip_to_base_value (const ExprPtr &quantity, ComputationContext &context)
ExprResult	strip_to_display_value (const ExprPtr &quantity, ComputationContext &context)
QuantityResult	strip_unit (const std::shared_ptr< SymbolicExpr > &expression, UnitStripMode mode, ComputationContext &context)
bool	structurally_equal (const SymbolicExpr &lhs, const SymbolicExpr &rhs)
ExprResult	sub (const ExprPtr &lhs, const ExprPtr &rhs)
ExprResult	sub (const ExprPtr &lhs, const ExprPtr &rhs, ComputationContext &context)
ExprResult	substitute (const ExprPtr &expression, const Binding &replacement)
ExprResult	substitute (const ExprPtr &expression, const Binding &replacement, ComputationContext &context)
ExprResult	substitute (const ExprPtr &expression, const std::string &variable, const ExprPtr &value)
ExprResult	substitute (const ExprPtr &expression, const std::string &variable, const ExprPtr &value, ComputationContext &context)
ExprResult	substitute (const ExprPtr &expression, const std::vector< Binding > &replacements)
ExprResult	substitute (const ExprPtr &expression, const std::vector< Binding > &replacements, ComputationContext &context)
detail::SymbolicNodePtr	substitute_free (const detail::SymbolicNodePtr &expression, const std::string &variable, const detail::SymbolicNodePtr &replacement, detail::RewriteBudget *budget)
static std::shared_ptr< const SymbolicNode >	substitute_negative_variable (const VariableNode &node, const std::string &var, const std::string &t_var)
ExprPtr	substitute_raw (const ExprPtr &expression, const std::string &variable, const ExprPtr &value)
std::optional< int >	supported_laurent_integer_power (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable)
std::optional< int >	supported_laurent_integer_power (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable)
ExpressionResult	surface_area_revolution_x_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
ExpressionResult	surface_area_revolution_x_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
ExpressionResult	surface_area_revolution_y_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b)
ExpressionResult	surface_area_revolution_y_checked (const std::shared_ptr< SymbolicExpr > &f, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	surface_integral_scalar (const std::shared_ptr< SymbolicExpr > &f, const VectorField &parametrization, const std::string &u, const std::string &v, const std::shared_ptr< SymbolicExpr > &u_lower, const std::shared_ptr< SymbolicExpr > &u_upper, const std::shared_ptr< SymbolicExpr > &v_lower, const std::shared_ptr< SymbolicExpr > &v_upper)
VectorCalculusExprResult	surface_integral_scalar_checked (const std::shared_ptr< SymbolicExpr > &f, const VectorField &parametrization, const std::string &u, const std::string &v, const std::shared_ptr< SymbolicExpr > &u_lower, const std::shared_ptr< SymbolicExpr > &u_upper, const std::shared_ptr< SymbolicExpr > &v_lower, const std::shared_ptr< SymbolicExpr > &v_upper)
VectorCalculusExprResult	surface_integral_scalar_checked (const std::shared_ptr< SymbolicExpr > &f, const VectorField &parametrization, const std::string &u, const std::string &v, const std::shared_ptr< SymbolicExpr > &u_lower, const std::shared_ptr< SymbolicExpr > &u_upper, const std::shared_ptr< SymbolicExpr > &v_lower, const std::shared_ptr< SymbolicExpr > &v_upper, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	surface_integral_vector (const VectorField &F, const VectorField &parametrization, const std::string &u, const std::string &v, const std::shared_ptr< SymbolicExpr > &u_lower, const std::shared_ptr< SymbolicExpr > &u_upper, const std::shared_ptr< SymbolicExpr > &v_lower, const std::shared_ptr< SymbolicExpr > &v_upper)
VectorCalculusExprResult	surface_integral_vector_checked (const VectorField &F, const VectorField &parametrization, const std::string &u, const std::string &v, const std::shared_ptr< SymbolicExpr > &u_lower, const std::shared_ptr< SymbolicExpr > &u_upper, const std::shared_ptr< SymbolicExpr > &v_lower, const std::shared_ptr< SymbolicExpr > &v_upper)
VectorCalculusExprResult	surface_integral_vector_checked (const VectorField &F, const VectorField &parametrization, const std::string &u, const std::string &v, const std::shared_ptr< SymbolicExpr > &u_lower, const std::shared_ptr< SymbolicExpr > &u_upper, const std::shared_ptr< SymbolicExpr > &v_lower, const std::shared_ptr< SymbolicExpr > &v_upper, ComputationContext &context)
VectorExprListResult	surface_normal_checked (const SurfaceSymbolic &surf, const std::vector< std::shared_ptr< SymbolicExpr > > &point)
VectorExprListResult	surface_normal_checked (const SurfaceSymbolic &surf, const std::vector< std::shared_ptr< SymbolicExpr > > &point, ComputationContext &context)
SVDDecompositionResult	svd_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A)
SVDDecompositionResult	svd_decomposition_checked (const std::shared_ptr< SymbolicExpr > &A, ComputationContext &context)
ExprResult	sym (const std::string &name)
std::shared_ptr< SymbolicExpr >	sym_rational (const BigInt &numerator, const BigInt &denominator)
std::shared_ptr< SymbolicExpr >	sym_sub (const SymbolicExpr &lhs, const SymbolicExpr &rhs)
std::optional< std::string_view >	symbol_name (const ExprPtr &expression) noexcept
static std::vector< std::shared_ptr< SymbolicExpr > >	symbolic_cubic_roots (const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, const std::shared_ptr< SymbolicExpr > &c, const std::shared_ptr< SymbolicExpr > &d, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	symbolic_hessian (const std::vector< double > &numeric_H, size_t n, double tol)
static LMCAS::MultiPoly	symbolic_node_to_multipoly (const std::shared_ptr< const SymbolicNode > &node, const std::vector< std::string > &vars)
static std::shared_ptr< SymbolicExpr >	symbolic_poly_to_expr (const Polynomial< SymbolicPolyCoeff > &poly, ComputationContext &context)
Result< Rational >	symbolic_polynomial_content (const SymbolicExpr &expression, ComputationContext &context)
SymbolicGcdResult	symbolic_polynomial_gcd (const SymbolicExpr &lhs, const SymbolicExpr &rhs, ComputationContext &context)
template<typename T>
Result< Polynomial< T > >	symbolic_power_to_poly (const PowerNode &power, const std::string &variable, ComputationContext *context, detail::RewriteBudget *budget)
std::shared_ptr< SymbolicExpr >	symbolic_product (const std::shared_ptr< SymbolicExpr > &body, const std::string &index, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper)
template<typename T>
Result< Polynomial< T > >	symbolic_product_to_poly (const MultiplyNode &multiply, const std::string &variable, ComputationContext *context, detail::RewriteBudget *budget)
static std::shared_ptr< SymbolicExpr >	symbolic_root_term (const std::shared_ptr< SymbolicExpr > &coefficient, const std::string &variable, int degree)
std::shared_ptr< SymbolicExpr >	symbolic_sum (const std::shared_ptr< SymbolicExpr > &body, const std::string &index, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper)
template<typename T>
Result< Polynomial< T > >	symbolic_sum_to_poly (const AddNode &add, const std::string &variable, ComputationContext *context, detail::RewriteBudget *budget)
template<typename T>
Result< Polynomial< T > >	symbolic_to_poly_recursive (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable, ComputationContext *context, detail::RewriteBudget *budget)
ExprResult	tan (const ExprPtr &expression)
ExprResult	tan (const ExprPtr &expression, ComputationContext &context)
PlaneSymbolicResult	tangent_plane_checked (const SurfaceSymbolic &surf, const std::vector< std::shared_ptr< SymbolicExpr > > &point)
PlaneSymbolicResult	tangent_plane_checked (const SurfaceSymbolic &surf, const std::vector< std::shared_ptr< SymbolicExpr > > &point, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	te_abs_decay (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	te_abs_fourier (const std::shared_ptr< SymbolicExpr > &rate, const std::string &omega, ComputationContext &context)
static bool	te_accept_decay (const std::shared_ptr< SymbolicExpr > &rate, const AssumptionContext &assumptions, std::vector< std::shared_ptr< SymbolicExpr > > &conditions, ComputationContext &context)
static TransformEngineResult	te_convolve_core (const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &g, const std::string &variable, ComputationContext &context)
static TransformEngineResult	te_convolve_sum (const AddNode &addition, const std::shared_ptr< SymbolicExpr > &other, bool sum_is_left, const std::string &variable, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	te_decay_condition (const std::shared_ptr< SymbolicExpr > &rate)
static bool	te_extract_exp (const std::shared_ptr< SymbolicExpr > &e, const std::string &t, std::shared_ptr< SymbolicExpr > &a_out, std::shared_ptr< SymbolicExpr > &rem_out)
static std::shared_ptr< SymbolicExpr >	te_fourier_sum (const AddNode &addition, const std::string &t, const std::string &omega, ComputationContext &context, const AssumptionContext &assumptions, std::vector< std::shared_ptr< SymbolicExpr > > &conditions)
static std::shared_ptr< SymbolicExpr >	te_fourier_unevaluated (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &omega)
static std::shared_ptr< SymbolicExpr >	te_gaussian_fourier (const Rational &rate, const std::string &omega)
static std::shared_ptr< SymbolicExpr >	te_inv_power (const std::shared_ptr< SymbolicExpr > &F, const std::string &s, const std::string &t, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	te_inv_product (const std::shared_ptr< SymbolicExpr > &F, const std::string &s, const std::string &t, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	te_inverse_pole (const std::shared_ptr< const SymbolicNode > &base, const std::string &variable)
static std::shared_ptr< SymbolicExpr >	te_inverse_pole_term (const AddNode &addition, std::size_t i, const std::string &variable)
static bool	te_is_abs_variable (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable)
static bool	te_is_denominator_factor (const std::shared_ptr< const SymbolicNode > &expression, const std::string &variable)
static bool	te_is_hyp (const std::shared_ptr< SymbolicExpr > &e, const std::string &v, bool &is_sinh, std::shared_ptr< SymbolicExpr > &freq)
static bool	te_is_power_of_var (const std::shared_ptr< SymbolicExpr > &e, const std::string &v, BigInt &n)
static std::shared_ptr< SymbolicExpr >	te_laplace_lookup (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &s, ComputationContext &context)
static std::vector< std::shared_ptr< SymbolicExpr > >	te_laplace_roc (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &s)
static std::shared_ptr< SymbolicExpr >	te_laplace_sum (const std::shared_ptr< SymbolicExpr > &f, const AddNode &addition, const std::string &t, const std::string &s, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	te_unevaluated_inv_laplace (const std::shared_ptr< SymbolicExpr > &F, const std::string &s, const std::string &t)
static std::shared_ptr< SymbolicExpr >	te_unevaluated_laplace (const std::shared_ptr< SymbolicExpr > &f, const std::string &t, const std::string &s)
static Result< void >	te_validate_convolution_inputs (const std::shared_ptr< SymbolicExpr > &f, const std::shared_ptr< SymbolicExpr > &g, const std::string &var, ComputationContext &context, const std::string &operation)
std::shared_ptr< SymbolicExpr >	tf_back_substitute (const std::shared_ptr< SymbolicExpr > &factor_expr, const std::vector< TransSubstitution > &mappings, ComputationContext &context)
	将因子表达式中的不定元变量替换回原始超越子表达式.
Result< TfPolyBuildResult >	tf_build_polynomial (const std::shared_ptr< SymbolicExpr > &poly_expr, const std::vector< std::string > &indeterminates, const std::string &original_var)
Result< TfPolyBuildResult >	tf_build_polynomial_impl (const std::shared_ptr< SymbolicExpr > &expression, const std::vector< std::string > &indeterminates, const std::string &original_variable, ComputationContext &context)
static void	tf_collect_transcendental (const std::shared_ptr< const SymbolicNode > &node, const std::string &var, std::vector< std::shared_ptr< const SymbolicNode > > &candidates)
	按先序收集依赖 var 的超越函数子表达式。
bool	tf_contains_transcendental (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable)
static Result< TfPolyBuildResult >	tf_convert_main_variable (TfPolyBuildResult result, const std::shared_ptr< SymbolicExpr > &expanded, const std::vector< std::string > &all_variables)
static void	tf_deduplicate (std::vector< std::shared_ptr< const SymbolicNode > > &candidates)
	按结构哈希和 equals 比较去重，保留首次出现的顺序。
int	tf_degree_in (const std::shared_ptr< const SymbolicNode > &node, const std::string &variable)
static void	tf_detect_constraints (TransSubstitutionResult &result)
std::vector< std::shared_ptr< SymbolicExpr > >	tf_detect_exponential_separation (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context)
	检测加法表达式中的公共指数因子并执行分离.
std::vector< std::shared_ptr< SymbolicExpr > >	tf_detect_multiplicative_structure (const std::shared_ptr< SymbolicExpr > &expr)
	检测表达式是否已为独立子表达式的乘积形式.
static bool	tf_extract_coeff_trig_squared (const std::shared_ptr< const SymbolicNode > &node, std::shared_ptr< const SymbolicNode > &coeff, FunctionNode::FuncType &func_type, std::shared_ptr< const SymbolicNode > &argument)
	从 a*sin^2(f) 或 a*cos^2(f) 提取系数和三角平方项。
static std::shared_ptr< const SymbolicNode >	tf_extract_exp_factor (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
	从乘积项中提取指数函数因子.
static Result< std::vector< std::shared_ptr< SymbolicExpr > > >	tf_factor_substitution (const TransSubstitutionResult &sub_result, const std::string &var, const std::shared_ptr< SymbolicExpr > &pyth_simplified, ComputationContext &context)
bool	tf_is_linear_irreducible (const TransSubstitutionResult &sub_result, const std::string &var)
	判断换元后的表达式是否对所有不定元和原始变量均为线性.
static bool	tf_is_negation_of (const std::shared_ptr< const SymbolicNode > &node, const std::shared_ptr< const SymbolicNode > &arg)
	匹配 (-1)*arg 或 arg*(-1) 的二因子乘积结构。
static bool	tf_is_sine_cosine_pair (FunctionNode::FuncType first, FunctionNode::FuncType second)
bool	tf_is_transcendental_type (FunctionNode::FuncType ft)
	判断函数类型是否支持超越函数换元。
static bool	tf_is_trig_squared (const std::shared_ptr< const SymbolicNode > &node, FunctionNode::FuncType &func_type, std::shared_ptr< const SymbolicNode > &argument)
	匹配 sin^2(f) 或 cos^2(f)，提取函数类型和参数。
static bool	tf_is_variable_exponential (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
static bool	tf_nodes_equal (const std::shared_ptr< const SymbolicNode > &a, const std::shared_ptr< const SymbolicNode > &b)
	判断两个 AST 节点是否结构相等。
static std::shared_ptr< SymbolicExpr >	tf_pair_constraint (const TransSubstitution &left, const TransSubstitution &right, const FunctionNode &first, const FunctionNode &second)
static std::vector< std::string >	tf_polynomial_variables (const std::shared_ptr< SymbolicExpr > &expression, const std::vector< std::string > &indeterminates, const std::string &original_var)
static int	tf_power_degree (const PowerNode &power, const std::string &var)
static std::shared_ptr< const SymbolicNode >	tf_remove_exp_factor (const std::shared_ptr< const SymbolicNode > &node, const std::shared_ptr< const SymbolicNode > &exp_factor)
	从乘积项中移除指定的指数函数因子,返回剩余部分.
static std::vector< std::shared_ptr< SymbolicExpr > >	tf_restore_factors (const std::vector< Polynomial< Rational > > &true_factors, const TransSubstitutionResult &sub_result, const std::shared_ptr< SymbolicExpr > &pyth_simplified, ComputationContext &context)
static void	tf_select_main_variable (TfPolyBuildResult &result, const std::shared_ptr< SymbolicExpr > &expanded, const std::vector< std::string > &variables, int &max_degree)
std::vector< std::shared_ptr< SymbolicExpr > >	tf_simplify_factors (std::vector< std::shared_ptr< SymbolicExpr > > &factors)
	化简逆换元后的因子，合并数值因子及乘积的数值前导系数。 保留非常数部分，将非 1 的常数积置于结果首位。
std::vector< std::shared_ptr< SymbolicExpr > >	tf_simplify_factors_impl (const std::vector< std::shared_ptr< SymbolicExpr > > &factors, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	tf_simplify_pythagorean (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var)
	在因式分解前用 sin^2(f) + cos^2(f) = 1 化简表达式。
static std::shared_ptr< const SymbolicNode >	tf_simplify_pythagorean_node (const std::shared_ptr< const SymbolicNode > &node, const std::string &var)
	递归化简 a*sin^2(f) + a*cos^2(f) 为 a，系数为 1 时结果为 1。
TfSquareFreeResult	tf_square_free (const Polynomial< Rational > &poly)
	计算多项式的无平方因子部分，用于 Berlekamp 模分解预处理。
static std::shared_ptr< const SymbolicNode >	tf_substitute_expr (const std::shared_ptr< const SymbolicNode > &node, const std::vector< TransSubstitution > &mappings)
	按映射顺序将超越子表达式替换为不定元，递归重建未匹配节点。
static bool	tf_validate_polynomial (const std::shared_ptr< SymbolicExpr > &poly_expr, const std::vector< std::string > &all_variables)
	判断换元式是否为候选变量的多项式。 各候选变量的次数须可确定为非负整数，且超越函数不得依赖不定元或原始变量。
int	total_degree (const Monomial &m)
	计算单项式的全次数
std::vector< std::pair< std::shared_ptr< SymbolicExpr >, std::string > >	total_differential (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars)
static MultiPoly	truncate_mod_var (const MultiPoly &poly, const std::string &var, int degree_bound)
	将 MultiPoly 截断为关于指定变量次数 < degree_bound 的部分
static MultiPoly	truncated_factor_product (const std::vector< MultiPoly > &factors, const std::string &variable, int degree_bound)
double	try_eval_double (const std::shared_ptr< SymbolicExpr > &expr)
	尝试将表达式求值为 double。
bool	try_get_integer_value (const std::shared_ptr< const NumberNode > &node, BigInt &value)
static MultiPoly	univariate_gcd (const MultiPoly &a, const MultiPoly &b, const std::vector< std::string > &vars)
static bool	unsupported_euler_forcing (const std::shared_ptr< SymbolicExpr > &forcing, const std::vector< double > &coefficients)
static bool	valid_classifier_variables (const std::string &x, const std::string &y)
static bool	valid_newton_bracket (lmmc_real_t initial, lmmc_real_t lower, lmmc_real_t upper)
static Result< void >	validate_frobenius_regular_singular_domain (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, ComputationContext &context, const std::string &operation)
static bool	validate_integration_steps (const std::vector< IntegrationStep > &steps)
Result< void >	validate_laurent_orders (int order_neg, int order_pos, const std::string &operation)
static Result< void >	validate_laurent_result (const LaurentResult &result, const std::optional< int > &supported_power, const std::shared_ptr< SymbolicExpr > &center, const std::string &operation)
Result< void >	validate_numeric_ode_coefficients (const std::vector< double > &coefficients, std::size_t minimum_size, std::size_t maximum_size, const std::string &operation)
Result< void >	validate_ode_expr_var_pair (const std::shared_ptr< SymbolicExpr > &expr, const std::string &x, const std::string &y, ComputationContext &context, const std::string &operation)
Result< void >	validate_ode_pair_var_pair (const std::shared_ptr< SymbolicExpr > &first, const std::shared_ptr< SymbolicExpr > &second, const std::string &x, const std::string &y, ComputationContext &context, const std::string &operation)
Result< void >	validate_ode_three_expr_one_var (const std::shared_ptr< SymbolicExpr > &first, const std::shared_ptr< SymbolicExpr > &second, const std::shared_ptr< SymbolicExpr > &third, const std::string &x, ComputationContext &context, const std::string &operation)
Result< void >	validate_ode_two_expr_point (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::shared_ptr< SymbolicExpr > &x0, const std::string &x, ComputationContext &context, const std::string &operation)
Result< void >	validate_ode_variables (const std::string &x, const std::string &y, ComputationContext &context, const std::string &operation)
Result< void >	validate_power_series_coefficients (const std::vector< std::shared_ptr< SymbolicExpr > > &coefficients, const std::string &operation, const std::string &name)
Result< void >	validate_power_series_coefficients (const std::vector< std::shared_ptr< SymbolicExpr > > &coefficients, const std::string &operation, const std::string &name)
PropertyStoreResult	validate_property_interval (const Interval &interval, ComputationContext &context, const std::string &operation)
Result< void >	validate_series_expr_point (const std::shared_ptr< SymbolicExpr > &expr, const std::shared_ptr< SymbolicExpr > &center, const std::string &var, ComputationContext &context, const std::string &operation)
Result< void >	validate_series_variable (const std::string &variable, ComputationContext &context, const std::string &operation)
Result< void >	validate_series_variable (const std::string &variable, ComputationContext &context, const std::string &operation)
VectorAngleResult	vector_angle_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b)
VectorAngleResult	vector_angle_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b, ComputationContext &context)
VectorCalculusExprResult	vector_angle_symbolic (const VectorField &a, const VectorField &b)
static VectorCalculusExprResult	vector_angle_symbolic_impl (const VectorField &a, const VectorField &b, detail::RewriteBudget &transform_budget)
static CriticalPointClassification	vector_calculus_classify_critical_point (const std::vector< double > &numeric_H, size_t n, ComputationContext &context, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_constant_integrand (const std::shared_ptr< SymbolicExpr > &integrand, const std::string &variable, ComputationContext &context, detail::RewriteBudget &transform_budget)
static Result< VectorField >	vector_calculus_cross_product_partials_strict (const VectorField &parametrization, const std::string &u, const std::string &v, const std::string &operation, detail::RewriteBudget &transform_budget)
static Result< VectorField >	vector_calculus_curl_strict (const VectorField &F, const std::vector< std::string > &vars, const std::string &operation, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_definite_integral_strict (const std::shared_ptr< SymbolicExpr > &integrand, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
static bool	vector_calculus_evaluate_hessian_at_point (const std::shared_ptr< SymbolicExpr > &H, const std::vector< std::string > &, const std::map< std::string, std::shared_ptr< SymbolicExpr > > &pt, size_t n, std::vector< double > &numeric_H, ComputationContext &context, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_inconclusive (const std::string &operation, const std::string &message)
static std::shared_ptr< SymbolicExpr >	vector_calculus_magnitude_squared (const VectorField &v, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_multiple_integral_strict (const std::shared_ptr< SymbolicExpr > &integrand, const std::vector< IntegrationStep > &steps, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_numerical_definite (const std::shared_ptr< SymbolicExpr > &integrand, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context, detail::RewriteBudget &transform_budget)
static std::shared_ptr< SymbolicExpr >	vector_calculus_single_dir_deriv (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, const VectorField &unit_dir, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_substitute_coords_strict (const std::shared_ptr< SymbolicExpr > &expr, const std::vector< std::string > &coord_vars, const VectorField &values, const std::string &operation, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_surface_dot_strict (const VectorField &field, const std::vector< std::string > &coordinates, const VectorField &parametrization, const VectorField &normal, const std::string &message, const std::string &operation, detail::RewriteBudget &transform_budget)
static VectorCalculusExprResult	vector_calculus_try_definite (const std::shared_ptr< SymbolicExpr > &integrand, const std::string &var, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context, detail::RewriteBudget &transform_budget)
std::vector< std::shared_ptr< SymbolicExpr > >	vector_cross (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b)
VectorExprListResult	vector_cross_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b)
VectorExprListResult	vector_cross_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	vector_dot (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b)
ExpressionResult	vector_dot_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b)
ExpressionResult	vector_dot_checked (const std::vector< std::shared_ptr< SymbolicExpr > > &a, const std::vector< std::shared_ptr< SymbolicExpr > > &b, ComputationContext &context)
VectorCalculusFieldResult	vector_project (const VectorField &a, const VectorField &b)
static VectorCalculusFieldResult	vector_project_impl (const VectorField &a, const VectorField &b, detail::RewriteBudget &transform_budget)
static Result< QuadraticBoundaries >	verified_quadratic_boundaries (const Polynomial< Rational > &polynomial, const Rational &rational_part, const Rational &denominator, const Rational &discriminant, detail::RewriteBudget &budget)
static SymbolicExprVectorResult	verified_real_inverse_candidates (const std::vector< std::shared_ptr< SymbolicExpr > > &candidates, const std::shared_ptr< SymbolicExpr > &equation, const std::string &var, const std::string &operation, ComputationContext &context)
static LagrangeResult	verify_lagrange_solutions (const std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > &full_solutions, const VectorField &equations, const std::vector< std::string > &all_vars, const std::vector< std::string > &vars, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
ExpressionResult	volume_of_revolution_x_checked (std::shared_ptr< SymbolicExpr > fx, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b)
ExpressionResult	volume_of_revolution_x_checked (std::shared_ptr< SymbolicExpr > fx, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, ComputationContext &context)
ExpressionResult	volume_of_revolution_y_checked (std::shared_ptr< SymbolicExpr > fy, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b)
ExpressionResult	volume_of_revolution_y_checked (std::shared_ptr< SymbolicExpr > fy, std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, ComputationContext &context)
SymbolicExpr	wildcard (const std::string &name)
template<typename F>
auto	with_assumptions (AssumptionContext &ctx, const std::vector< AssumptionDecl > &decls, F &&callable) -> std::enable_if_t< std::is_void_v< decltype(callable())>, AssumptionVoidResult >
template<typename F>
auto	with_assumptions (AssumptionContext &ctx, const std::vector< AssumptionDecl > &decls, F &&callable) -> std::enable_if_t<!std::is_void_v< decltype(callable())>, Result< decltype(callable())> >
	Execute a callable within a temporary assumption scope.
template<typename F>
auto	with_assumptions (AssumptionContext &ctx, std::initializer_list< AssumptionDecl > decls, F &&callable) -> decltype(with_assumptions(ctx, std::vector< AssumptionDecl >(decls), std::forward< F >(callable)))
ExprResult	with_unit (const ExprPtr &value, const std::string &unit, ComputationContext &context)
ExprResult	with_unit_definition (const ExprPtr &value, std::string display_unit, UnitDefinition definition, ComputationContext &context)
ODESolutionResult	wrap_ode_solution (ODESolution solution, ODEType expected_method, const std::string &operation)
TransformEngineResult	z_transform_checked (const std::shared_ptr< SymbolicExpr > &f_n, const std::string &n, const std::string &z)
TransformEngineResult	z_transform_checked (const std::shared_ptr< SymbolicExpr > &f_n, const std::string &n, const std::string &z, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	z_transform_core (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::string &z, ComputationContext &context)
ZassenhausResult	zassenhaus_combine_checked (const Polynomial< Rational > &poly, const std::vector< Polynomial< BigInt > > &lifted_factors, const BigInt &reconstruction_modulus)
ZassenhausResult	zassenhaus_combine_checked (const Polynomial< Rational > &poly, const std::vector< Polynomial< BigInt > > &lifted_factors, const BigInt &reconstruction_modulus, ComputationContext &context)
static ZassenhausResult	zassenhaus_combine_impl (const Polynomial< Rational > &poly, const std::vector< Polynomial< BigInt > > &lifted_factors, const BigInt &reconstruction_modulus, ComputationContext &context)
static Polynomial< Rational >	zc_bigint_to_rational_poly (const std::vector< BigInt > &coeffs, const std::string &var)
	将 BigInt 系数向量转换为有理系数多项式.
static bool	zc_divides_exactly (const Polynomial< Rational > &f, const Polynomial< Rational > &candidate)
	检验候选因子是否整除原多项式(精确有理除法).
static ZassenhausResult	zc_enumerate (const Polynomial< Rational > &poly, const std::vector< Polynomial< BigInt > > &lifted_factors, const BigInt &modulus, ComputationContext &context)
static ZassenhausResult	zc_finalize (const Polynomial< Rational > &original, std::vector< Polynomial< Rational > > factors, Polynomial< Rational > remaining, Completeness completeness, std::string reason)
static Result< bool >	zc_find_factor (ZcFactorSearch &search)
static Polynomial< Rational >	zc_make_primitive (const Polynomial< Rational > &poly)
	使候选多项式首一化(首项系数归一).
static bool	zc_next_combination (std::vector< size_t > &positions, size_t count)
static bool	zc_rational_reconstruction (const BigInt &a, const BigInt &m, BigInt &num, BigInt &den)
	对 BigInt 系数执行有理数重构.
static Polynomial< Rational >	zc_reconstruct_candidate (const std::vector< BigInt > &product_coeffs, const BigInt &mod, const std::string &var)
	对子集乘积的所有系数执行有理重构,构造有理系数多项式.
static std::vector< size_t >	zc_select_indices (const std::vector< size_t > &active, const std::vector< size_t > &positions)
static Result< std::vector< BigInt > >	zc_subset_product (const std::vector< Polynomial< BigInt > > &lifted_factors, const std::vector< size_t > &indices, const BigInt &mod, ComputationContext &context)
	在模 m 下乘以按字典序枚举的提升因子子集.
static Result< bool >	zc_try_candidate (ZcFactorSearch &search, const std::vector< size_t > &positions)
static Result< void >	zc_validate_lifted_product (const Polynomial< Rational > &poly, const std::vector< Polynomial< BigInt > > &lifted_factors, const BigInt &modulus, ComputationContext &context)
static bool	zero_remainder (const detail::SymbolicNodePtr &value, detail::RewriteBudget &budget)
static std::shared_ptr< SymbolicExpr >	zt_abs_expr (const std::shared_ptr< SymbolicExpr > &expr)
static std::vector< std::shared_ptr< SymbolicExpr > >	zt_base_roc (const std::shared_ptr< SymbolicExpr > &base, const std::string &z)
static std::shared_ptr< SymbolicExpr >	zt_exponential (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::shared_ptr< SymbolicExpr > &z, ComputationContext &context)
static bool	zt_is_exp_seq (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, std::shared_ptr< SymbolicExpr > &base_out)
static bool	zt_is_weighted_exp (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, std::shared_ptr< SymbolicExpr > &base)
static std::vector< std::shared_ptr< SymbolicExpr > >	zt_lookup_roc (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::string &z)
static std::shared_ptr< SymbolicExpr >	zt_polynomial (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::shared_ptr< SymbolicExpr > &z, const std::string &z_var, ComputationContext &context)
static ZPolynomialPattern	zt_polynomial_pattern (const std::shared_ptr< SymbolicExpr > &f, const std::string &n)
static std::vector< std::shared_ptr< SymbolicExpr > >	zt_roc (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::string &z)
static std::shared_ptr< SymbolicExpr >	zt_sum (const std::shared_ptr< SymbolicExpr > &f, const AddNode &addition, const std::string &n, const std::string &z, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	zt_trigonometric (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::shared_ptr< SymbolicExpr > &z, ComputationContext &context)
static std::shared_ptr< SymbolicExpr >	zt_unevaluated (const std::shared_ptr< SymbolicExpr > &f, const std::string &n, const std::string &z)
static std::vector< std::shared_ptr< SymbolicExpr > >	zt_unit_roc (const std::string &z)

变量
__attribute__((visibility("default"))) VectorCalculusExprResult curve_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult curve_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string const std::shared_ptr< SymbolicExpr > &	a
const MultiPoly &	b
const std::vector< FGLMPoly > &	basis
const Binding &	binding
const std::vector< Binding > &	bindings = {})
const VectorField const VectorField &	c
const std::vector< Polynomial< BigInt > > const BigInt ComputationContext &	context
std::string UnitDefinition	definition
const ExprPtr &	denominator
std::size_t std::size_t	depth
__attribute__((visibility("default"))) MatrixRankResult matrix_rank_checked(const std __attribute__((visibility("default"))) MatrixRankResult matrix_rank_checked(const std __attribute__((visibility("default"))) ExpressionResult matrix_rref_checked(const std __attribute__((visibility("default"))) ExpressionResult matrix_rref_checked(const std __attribute__((visibility("default"))) MatrixNullspaceResult matrix_nullspace_checked(const std __attribute__((visibility("default"))) MatrixNullspaceResult matrix_nullspace_checked(const std __attribute__((visibility("default"))) MatrixLinearSolveResult matrix_solve_linear_checked(const std __attribute__((visibility("default"))) MatrixLinearSolveResult matrix_solve_linear_checked(const std int	dim
const std::string const LimitExprPtr LimitDirection	direction = LimitDirection::Both
std::string	display_unit
const NumberDomainSet &	domain = Domain::Real)
const ExprPtr &	element
const ExprPtr &	exponent
std::size_t std::size_t std::size_t	growth
ExprPtr	imag
template<typename Integer, std::enable_if_t< std::is_integral_v< Integer > &&!std::is_same_v< Integer, int >, int > = 0>
ExprResult	integer (Integer)=delete
const std::vector< IntegrationStep > Integrator &	integrator
constexpr const char *	kEquivalentOperation = "LMCAS.equivalent"
constexpr const char *	kEquivalentProfileOperation
constexpr const char *	kEvalComplexOperation = "LMCAS.eval_complex"
constexpr const char *	kExprSetOperation = "LMCAS.expr_set"
constexpr const char *	kParseOperation
constexpr const char *	kSolveExprSetOperation = "LMCAS.solve_expr_set"
__attribute__((visibility("default"))) ExpressionResult point_plane_distance_checked(const std __attribute__((visibility("default"))) ExpressionResult point_plane_distance_checked(const std const LineSymbolic &	l2
const std::vector< Polynomial< ModInt > > int64_t int	lift_bound
const std::vector< Polynomial< BigInt > > &	lifted_factors
const ExprPtr &	lower
__attribute__((visibility("default"))) ExprResult function(const std __attribute__((visibility("default"))) ExprResult finite_set(std ExprPtr bool	lower_closed
const std::string &	main_var
const std::vector< Polynomial< ModInt > > &	mod_factors
constexpr int64_t	MODULAR_PRIMES []
	预定义的大素数表，用于模运算多素数方案
__attribute__((visibility("default"))) Result< EqvProfile > eqv_profile_from_name(const std const std::string &	name
const ExprPtr bool	negated = false)
constexpr size_t	NUM_MODULAR_PRIMES = sizeof(MODULAR_PRIMES) / sizeof(MODULAR_PRIMES[0])
	预定义素数表的长度
const ExprPtr RelationOp	op
const std::string ComputationContext const SolveOptions &	options = {})
const std::vector< FGLMPoly > const MonomialOrder &	order
__attribute__((visibility("default"))) LineSymbolicResult line_from_two_points_checked(const std __attribute__((visibility("default"))) LineSymbolicResult line_from_two_points_checked(const std __attribute__((visibility("default"))) PlaneSymbolicResult plane_from_three_points_checked(const std __attribute__((visibility("default"))) PlaneSymbolicResult plane_from_three_points_checked(const std const PlaneSymbolic &	p2
__attribute__((visibility("default"))) VectorCalculusExprResult curve_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult curve_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField &	parametrization
const PlaneSymbolic &	plane
const std::string const LimitExprPtr &	point
int64_t	prime
__attribute__((visibility("default"))) ComplexSymbolicResult complex_exp_form_checked(std __attribute__((visibility("default"))) ComplexSymbolicResult complex_exp_form_checked(std __attribute__((visibility("default"))) ComplexSymbolicResult complex_trig_form_checked(std __attribute__((visibility("default"))) ComplexSymbolicResult complex_trig_form_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_nth_root_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_nth_root_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_quadratic_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_quadratic_checked(std std::shared_ptr< SymbolicExpr >	r
const std::vector< Polynomial< BigInt > > const BigInt &	reconstruction_modulus
const ExprPtr &	rhs
const ExprPtr &	right
const ExprPtr &	set
std::size_t	steps
double	sy
__attribute__((visibility("default"))) VectorCalculusExprResult curve_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult curve_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string &	t
const ExprPtr &	target
__attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string &	u
__attribute__((visibility("default"))) std const std::vector< std::string > const VectorField const std::string const std::string const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	u_bounds
__attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > &	u_lower
__attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > &	u_upper
const std::string &	unit
__attribute__((visibility("default"))) ExprResult function(const std __attribute__((visibility("default"))) ExprResult finite_set(std ExprPtr	upper
__attribute__((visibility("default"))) ExprResult function(const std __attribute__((visibility("default"))) ExprResult finite_set(std ExprPtr bool bool	upper_closed
__attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string const std::string &	v
__attribute__((visibility("default"))) std const std::vector< std::string > const VectorField const std::string const std::string const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	v_bounds
__attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > &	v_lower
__attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) VectorCalculusExprResult surface_integral_scalar_checked(const std __attribute__((visibility("default"))) std const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > &	v_upper
const std::string const ExprPtr &	value
const std::string &	variable
__attribute__((visibility("default"))) VectorCalculusFieldResult gradient_checked(const std __attribute__((visibility("default"))) VectorCalculusFieldResult gradient_checked(const std __attribute__((visibility("default"))) VectorField gradient(const std const std::vector< std::string > &	vars
const ExprPtr const std::vector< std::string > &	wildcards
__attribute__((visibility("default"))) std const std::vector< std::string > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds
__attribute__((visibility("default"))) std const std::vector< std::string > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds
__attribute__((visibility("default"))) std const std::vector< std::string > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	z_bounds
__attribute__((visibility("default"))) ComplexSymbolicResult complex_exp_form_checked(std __attribute__((visibility("default"))) ComplexSymbolicResult complex_exp_form_checked(std __attribute__((visibility("default"))) ComplexSymbolicResult complex_trig_form_checked(std __attribute__((visibility("default"))) ComplexSymbolicResult complex_trig_form_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_nth_root_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_nth_root_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_quadratic_checked(std __attribute__((visibility("default"))) ComplexRootsResult solve_complex_quadratic_checked(std std::shared_ptr< SymbolicExpr > const std::string &	z_var = "z")

---

类说明

LMCAS::Binding

struct LMCAS::Binding

在文件 symbolic.hpp 第 33 行定义.

LMCAS::Binding 的协作图:

类成员
shared_ptr< SymbolicExpr >	symbol
shared_ptr< SymbolicExpr >	value

LMCAS::ByConstructionProof

struct LMCAS::ByConstructionProof

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

LMCAS::ByConstructionProof 的协作图:

LMCAS::CasError

struct LMCAS::CasError

在文件 result.hpp 第 31 行定义.

LMCAS::CasError 的协作图:

类成员
CasErrc	code = CasErrc::InternalInvariant
string	message
string	operation

LMCAS::CheckedInterval

struct LMCAS::CheckedInterval

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

LMCAS::CheckedInterval 的协作图:

类成员
Interval	interval
ComparableEndpoint	lower
ComparableEndpoint	upper

LMCAS::CholeskyDecomposition

struct LMCAS::CholeskyDecomposition

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

LMCAS::CholeskyDecomposition 的协作图:

类成员
shared_ptr< SymbolicExpr >	L

LMCAS::ComplexSymbolic

struct LMCAS::ComplexSymbolic

符号复数，由实部和虚部组成

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

LMCAS::ComplexSymbolic 的协作图:

类成员
shared_ptr< SymbolicExpr >	imag	虚部
shared_ptr< SymbolicExpr >	real	实部

LMCAS::ConditionalSolutions

struct LMCAS::ConditionalSolutions

在文件 conditional_result.hpp 第 59 行定义.

LMCAS::ConditionalSolutions 的协作图:

类成员
ConditionSet	value

LMCAS::ConditionSet

struct LMCAS::ConditionSet

在文件 conditional_result.hpp 第 45 行定义.

LMCAS::ConditionSet 的协作图:

类成员
vector< ExprPtr >	conditions
ExprPtr	predicate
string	variable

LMCAS::ConvergenceInfo

struct LMCAS::ConvergenceInfo

收敛性判定信息.

在文件 series_engine.hpp 第 31 行定义.

LMCAS::ConvergenceInfo 的协作图:

类成员
ConvergenceResult	result	判定结果
string	test_used	使用的判定方法("ratio", "root", "comparison")

LMCAS::Diagnostic

struct LMCAS::Diagnostic

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

LMCAS::Diagnostic 的协作图:

类成员
string	message
string	operation
DiagnosticSeverity	severity = DiagnosticSeverity::Info

LMCAS::EmptySolutions

struct LMCAS::EmptySolutions

在文件 conditional_result.hpp 第 51 行定义.

LMCAS::EmptySolutions 的协作图:

LMCAS::EqvBudget

struct LMCAS::EqvBudget

各限额均为非零值；深度与规模在重写运行中检查，超限返回 ResourceLimit。

在文件 equivalence_options.hpp 第 18 行定义.

LMCAS::EqvBudget 的协作图:

类成员
size_t	max_node_growth_factor = 4	候选树及未封装孩子列表的规模上限取 context.max_ast_nodes 与原始两输入节点总数乘此因子的较小值。 每次子树引用分别计数；整个证明及 profile 切换共用原始基数。 乘法饱和为 SIZE_MAX；真实输入节点和溢出返回 ResourceLimit。
size_t	max_rewrite_depth = 64	同时活动的重写及嵌套 visitor 层数，根为第 1 层。
size_t	max_rewrite_steps = 256	一次证明及 profile 切换共享的重写遍历、候选追加与阶段步数。 形状查询和缓存清空的实际工作计入 ResourceLimits::max_steps。

LMCAS::EqvOptions

struct LMCAS::EqvOptions

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

LMCAS::EqvOptions 的协作图:

类成员
EqvBudget	budget = {}
EqvProfile	profile = EqvProfile::Core

LMCAS::EvaluatedTransform

struct LMCAS::EvaluatedTransform

受检变换成功时返回在 conditions 和收敛域 roc 条件下有效的已求值表达式。 支持性未决或收敛条件无法表示时，返回外层 Inconclusive 错误。

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

LMCAS::EvaluatedTransform 的协作图:

类成员
vector< ExprPtr >	conditions
ExprPtr	expression
vector< ExprPtr >	roc

LMCAS::ExactNormalizationProof

struct LMCAS::ExactNormalizationProof

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

LMCAS::ExactNormalizationProof 的协作图:

类成员
ProofExprPtr	normalized_residual

LMCAS::ExactResidualProof

struct LMCAS::ExactResidualProof

在文件 proof_outcome.hpp 第 18 行定义.

LMCAS::ExactResidualProof 的协作图:

类成员
ProofExprPtr	normalized_residual

LMCAS::ExactRoundTripProof

struct LMCAS::ExactRoundTripProof

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

LMCAS::ExactRoundTripProof 的协作图:

类成员
ProofExprPtr	normalized_residual

LMCAS::ExprMatch

struct LMCAS::ExprMatch

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

LMCAS::ExprMatch 的协作图:

类成员
vector< ExprMatchBinding >	bindings
bool	matched = false

LMCAS::ExprMatchBinding

struct LMCAS::ExprMatchBinding

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

LMCAS::ExprMatchBinding 的协作图:

类成员
string	name
ExprPtr	value

LMCAS::FiniteLimit

struct LMCAS::FiniteLimit

已证在请求的实数或复数域内有定义的有限值。 表达式树中所有极限均已求定，扩展实数运算均有确定结果。

在文件 limit_value.hpp 第 18 行定义.

LMCAS::FiniteLimit 的协作图:

类成员
LimitExprPtr	value

LMCAS::FiniteSolution

struct LMCAS::FiniteSolution

conditions 是在操作上下文假设下须同时满足的条件。 空条件保留原表达式定义域且不增加约束；整数参数遍历全体整数。

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

LMCAS::FiniteSolution 的协作图:

类成员
vector< ExprPtr >	conditions
size_t	multiplicity = 1
ExprPtr	value

LMCAS::FiniteSolutions

struct LMCAS::FiniteSolutions

在文件 conditional_result.hpp 第 53 行定义.

LMCAS::FiniteSolutions 的协作图:

类成员
vector< FiniteSolution >	values

LMCAS::FourierPeriod

struct LMCAS::FourierPeriod

在文件 series_expansions.cpp 第 195 行定义.

LMCAS::FourierPeriod 的协作图:

类成员
shared_ptr< SymbolicExpr >	frequency
shared_ptr< SymbolicExpr >	half_length
shared_ptr< SymbolicExpr >	lower
shared_ptr< SymbolicExpr >	two
shared_ptr< SymbolicExpr >	upper

LMCAS::FrobeniusSolution

struct LMCAS::FrobeniusSolution

Frobenius 级数解结果.

在文件 symbolic_ode_engine.hpp 第 435 行定义.

LMCAS::FrobeniusSolution 的协作图:

类成员
optional< ProofCertificate >	certificate
vector< double >	indicial_roots	指标方程的根(正则奇点时)
shared_ptr< SymbolicExpr >	normalized_residual
ODESingularityType	point_type	展开点的奇点类型
shared_ptr< SymbolicExpr >	series_solution	截断级数解
int	truncation_order	截断阶数

LMCAS::GcdSamples

struct LMCAS::GcdSamples

在文件 multivariate_factor.cpp 第 257 行定义.

LMCAS::GcdSamples 的协作图:

类成员
vector< Rational >	points
int	target_degree = -1
vector< MultiPoly >	values

LMCAS::HenselLiftPair

struct LMCAS::HenselLiftPair

二因子二次 Hensel 提升的状态结构.

存储一对因子 g, h 及其 Bezout 系数 s, t,满足:

• f == g * h (mod modulus)
• s * g + t * h == 1 (mod modulus)

系数按升幂存储:coeffs[i] 对应 x^i 的系数.

在文件 exact_factorization.hpp 第 81 行定义.

LMCAS::HenselLiftPair 的协作图:

类成员
vector< BigInt >	g	第一个因子的系数。
vector< BigInt >	h	第二个因子的系数。
BigInt	modulus	当前模数。
vector< BigInt >	s	g 的 Bezout 系数。
vector< BigInt >	t	h 的 Bezout 系数。

LMCAS::IntegrationStep

struct LMCAS::IntegrationStep

在文件 multiple_integral.hpp 第 9 行定义.

LMCAS::IntegrationStep 的协作图:

类成员
shared_ptr< SymbolicExpr >	lower
shared_ptr< SymbolicExpr >	upper
string	variable

LMCAS::IntervalSolution

struct LMCAS::IntervalSolution

在文件 conditional_result.hpp 第 31 行定义.

LMCAS::IntervalSolution 的协作图:

类成员
vector< ExprPtr >	conditions
ExprPtr	lower
bool	lower_closed = true
ExprPtr	upper
bool	upper_closed = true

LMCAS::IntervalSolutions

struct LMCAS::IntervalSolutions

在文件 conditional_result.hpp 第 56 行定义.

LMCAS::IntervalSolutions 的协作图:

类成员
vector< IntervalSolution >	values

LMCAS::IsolatedInterval

struct LMCAS::IsolatedInterval

隔离子区间,包含至多一个根

在文件 solve_mixed_transcendental.hpp 第 31 行定义.

LMCAS::IsolatedInterval 的协作图:

类成员
bool	confirmed	若导数单调性确认恰含一个根则为 true
lmmc_real_t	hi	子区间上界
lmmc_real_t	lo	子区间下界

LMCAS::JordanDecomposition

struct LMCAS::JordanDecomposition

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

LMCAS::JordanDecomposition 的协作图:

类成员
shared_ptr< SymbolicExpr >	J
shared_ptr< SymbolicExpr >	P

LMCAS::LaurentResult

struct LMCAS::LaurentResult

洛朗级数展开结果.

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

LMCAS::LaurentResult 的协作图:

类成员
int	pole_order	极点阶数(非极点时为 0)
shared_ptr< SymbolicExpr >	residue	留数((z-z_0)-¹ 的系数)
shared_ptr< SymbolicExpr >	series	洛朗级数表达式
SingularityType	singularity	奇点类型

LMCAS::LimitDoesNotExist

struct LMCAS::LimitDoesNotExist

在文件 limit_value.hpp 第 23 行定义.

LMCAS::LimitDoesNotExist 的协作图:

LMCAS::LineSymbolic

struct LMCAS::LineSymbolic

由一点和方向向量定义的符号直线。

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

LMCAS::LineSymbolic 的协作图:

类成员
vector< shared_ptr< SymbolicExpr > >	direction	方向向量。
vector< shared_ptr< SymbolicExpr > >	point	直线上一点。

LMCAS::LUDecomposition

struct LMCAS::LUDecomposition

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

LMCAS::LUDecomposition 的协作图:

类成员
shared_ptr< SymbolicExpr >	L
shared_ptr< SymbolicExpr >	P
shared_ptr< SymbolicExpr >	U

LMCAS::MathResult

struct LMCAS::MathResult

template<typename T>
struct LMCAS::MathResult< T >

在文件 result.hpp 第 125 行定义.

LMCAS::MathResult< T > 的协作图:

类成员
Completeness	completeness = Completeness::Complete
string	reason
T	value

LMCAS::MatrixInconsistentLinearSolution

struct LMCAS::MatrixInconsistentLinearSolution

在文件 symbolic_matrix.hpp 第 88 行定义.

LMCAS::MatrixInconsistentLinearSolution 的协作图:

LMCAS::MatrixUniqueLinearSolution

struct LMCAS::MatrixUniqueLinearSolution

在文件 symbolic_matrix.hpp 第 78 行定义.

LMCAS::MatrixUniqueLinearSolution 的协作图:

类成员
vector< shared_ptr< SymbolicExpr > >	values

LMCAS::MultiFactorResult

struct LMCAS::MultiFactorResult

多元因式分解结果

满足不变量：constant * ∏(factors[i] ^ multiplicities[i]) == 原多项式。 Complete 结果的终端因子已证明不可约；Inconclusive 结果保留精确乘积。

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

LMCAS::MultiFactorResult 的协作图:

类成员
Rational	constant	数值常数因子
vector< MultiPoly >	factors	精确因子列表（各因子本原）
vector< int >	multiplicities	各因子的重数

LMCAS::NegativeInfinityLimit

struct LMCAS::NegativeInfinityLimit

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

LMCAS::NegativeInfinityLimit 的协作图:

LMCAS::NumericRoot

struct LMCAS::NumericRoot

数值根结果,包含根值,残差和迭代次数.

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

LMCAS::NumericRoot 的协作图:

类成员
int	iterations	收敛所用迭代次数
lmmc_real_t	residual	残差(将根代入方程后的绝对值)
lmmc_real_t	value	根的数值

LMCAS::ODEClassification

struct LMCAS::ODEClassification

ODE 分类结果,包含类型及提取的结构信息.

在文件 symbolic_ode_engine.hpp 第 42 行定义.

LMCAS::ODEClassification 的协作图:

类成员
int	bernoulli_n = 0
shared_ptr< SymbolicExpr >	bernoulli_P	Bernoulli: P(x), Q(x), n 使得 y' + P(x)y = Q(x)y^n
shared_ptr< SymbolicExpr >	bernoulli_Q
vector< double >	const_coeffs	常系数: 系数列表 [a_n, a_{n-1}, ..., a_1, a_0] 和非齐次项 f(x)
vector< double >	euler_coeffs	Euler 方程: 系数列表 [a_n, ..., a_0] 对应 x^n*y^(n) + ... + a_0*y = f(x)
shared_ptr< SymbolicExpr >	euler_forcing
shared_ptr< SymbolicExpr >	exact_M	恰当方程: M(x,y), N(x,y)
shared_ptr< SymbolicExpr >	exact_N
shared_ptr< SymbolicExpr >	forcing_func
int	order = 0	方程阶数
shared_ptr< SymbolicExpr >	P_coeff	一阶线性: P(x), Q(x) 使得 y' + P(x)y = Q(x)
shared_ptr< SymbolicExpr >	Q_coeff
ODEType	type = ODEType::Unknown	识别出的 ODE 类型

LMCAS::ODESolution

struct LMCAS::ODESolution

ODE 求解结果.

在文件 symbolic_ode_engine.hpp 第 71 行定义.

LMCAS::ODESolution 的协作图:

类成员
optional< ProofCertificate >	certificate
vector< string >	constants	任意常数名称列表 (C1, C2, ...)
shared_ptr< SymbolicExpr >	general_solution	通解表达式
ODEType	method_used = ODEType::Unknown	使用的求解方法
shared_ptr< SymbolicExpr >	normalized_residual

LMCAS::OdeTaylorCoefficients

struct LMCAS::OdeTaylorCoefficients

在文件 ode_frobenius.cpp 第 43 行定义.

LMCAS::OdeTaylorCoefficients 的协作图:

类成员
vector< double >	p
vector< double >	q

LMCAS::ParametricSolution

struct LMCAS::ParametricSolution

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

LMCAS::ParametricSolution 的协作图:

类成员
vector< ExprPtr >	conditions
vector< string >	integer_parameters
ExprPtr	value

LMCAS::ParametricSolutions

struct LMCAS::ParametricSolutions

在文件 conditional_result.hpp 第 62 行定义.

LMCAS::ParametricSolutions 的协作图:

类成员
vector< ParametricSolution >	values

LMCAS::PiecewiseSolution

struct LMCAS::PiecewiseSolution

含参方程组的分段解，按参数条件分类

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

LMCAS::PiecewiseSolution 的协作图:

类成员
vector< Case >	cases	所有分段

LMCAS::PlaneSymbolic

struct LMCAS::PlaneSymbolic

由法向量和常数 d 定义的符号平面 ax + by + cz = d。

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

LMCAS::PlaneSymbolic 的协作图:

类成员
shared_ptr< SymbolicExpr >	d	常数项。
vector< shared_ptr< SymbolicExpr > >	normal	法向量。

LMCAS::PositiveInfinityLimit

struct LMCAS::PositiveInfinityLimit

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

LMCAS::PositiveInfinityLimit 的协作图:

LMCAS::ProvedNonIdentityResidual

struct LMCAS::ProvedNonIdentityResidual

证明残差在原公共定义域上非恒零，例如非零有理多项式。 残差仍可能在特定参数值处为零；点值不等性、定义域及上下文假设下的非零性均需另行证明。

在文件 residual_verification.hpp 第 23 行定义.

LMCAS::ProvedNonIdentityResidual 的协作图:

类成员
ExprPtr	normalized_residual

LMCAS::ProvedZeroResidual

struct LMCAS::ProvedZeroResidual

在表达式的原公共定义域上认证值相等；点值定义域与分母条件需另行证明。

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

LMCAS::ProvedZeroResidual 的协作图:

类成员
ProofCertificate	certificate

LMCAS::QRDecomposition

struct LMCAS::QRDecomposition

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

LMCAS::QRDecomposition 的协作图:

类成员
shared_ptr< SymbolicExpr >	Q
shared_ptr< SymbolicExpr >	R

LMCAS::QuadraticBoundaries

struct LMCAS::QuadraticBoundaries

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

LMCAS::QuadraticBoundaries 的协作图:

类成员
shared_ptr< SymbolicExpr >	first
shared_ptr< SymbolicExpr >	second

LMCAS::QuadratureEstimate

struct LMCAS::QuadratureEstimate

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

LMCAS::QuadratureEstimate 的协作图:

类成员
double	estimated_error = 0.0
double	value = 0.0

LMCAS::RationalRootReconstruction

struct LMCAS::RationalRootReconstruction

在文件 symbolic_factor.cpp 第 274 行定义.

LMCAS::RationalRootReconstruction 的协作图:

类成员
vector< shared_ptr< const SymbolicNode > >	factors
Polynomial< Rational >	quotient
Polynomial< Rational >	remainder

LMCAS::Relation

struct LMCAS::Relation

A stored relational constraint between two symbolic expressions.

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

LMCAS::Relation 的协作图:

类成员
SymbolicExpr	lhs	Left-hand side expression
RelationOp	op	Relational operator (GT, LT, GEQ, LEQ, NEQ, EQ)
SymbolicExpr	rhs	Right-hand side expression

LMCAS::ResourceLimits

struct LMCAS::ResourceLimits

Per-operation limits for APIs that accept a ComputationContext.

Context-free BigInt and symbolic constructors are intentionally unbounded; use checked, context-aware entry points when processing untrusted input.

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

LMCAS::ResourceLimits 的协作图:

类成员
size_t	max_ast_nodes = 1'000'000	Reference-expanded nodes per AST or output forest.
size_t	max_diagnostics = 10'000	Stored diagnostics.
size_t	max_expansion_terms = 100'000	One checked expansion.
size_t	max_input_bytes = 1'048'576	One checked input buffer.
size_t	max_integer_bits = 1'000'000	One checked integer result.
size_t	max_recursion_depth = 256	Simultaneous checked depth.
size_t	max_steps = 10'000'000	Cumulative checked steps.

LMCAS::SearchInterval

struct LMCAS::SearchInterval

搜索区间

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

LMCAS::SearchInterval 的协作图:

类成员
lmmc_real_t	hi	上界
lmmc_real_t	lo	下界

LMCAS::SignChartEntry

struct LMCAS::SignChartEntry

符号图条目,记录区间及其上的符号

在文件 inequality_solver.hpp 第 19 行定义.

LMCAS::SignChartEntry 的协作图:

类成员
Interval	interval	区间
int	sign	该区间上表达式的符号(+1, 0, -1)

LMCAS::SolveOptions

struct LMCAS::SolveOptions

方程求解选项,控制数值求解行为和结果形式.

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

LMCAS::SolveOptions 的协作图:

类成员
bool	allow_numeric = false	是否允许数值求解
bool	has_initial_guess = false	是否指定了初始猜测值
bool	has_search_interval = false	是否指定了搜索区间
lmmc_real_t	initial_guess = 0.0	数值迭代初始猜测值
int	max_newton_iterations = 100	Newton 迭代最大次数
int	max_roots = -1	数值候选数量预算；精确解集和整数解族保持完整。
bool	return_rootof = true	为 false 时，任何不可表示的根使整个求解返回 Inconclusive。
lmmc_real_t	search_hi = 10.0	搜索区间上界(默认 10)
lmmc_real_t	search_lo = -10.0	搜索区间下界(默认 -10)
lmmc_real_t	tolerance = 1e-12	收敛容差

LMCAS::SquareFreeDecomp

struct LMCAS::SquareFreeDecomp

无平方因子分解结果

components[i] 的重数为 i+1。 满足：f = components[0] * components[1]² * components[2]³ * ...（至多差常数）。

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

LMCAS::SquareFreeDecomp 的协作图:

类成员
vector< MultiPoly >	components	各无平方分量，components[i] 重数为 i+1

LMCAS::SubstitutionResult

struct LMCAS::SubstitutionResult

换元结果，记录换元表达式、换元后的多项式及换元变量名。

在文件 solve_transcendental.hpp 第 18 行定义.

LMCAS::SubstitutionResult 的协作图:

类成员
shared_ptr< SymbolicExpr >	poly_in_u	换元后关于 u 的多项式
shared_ptr< SymbolicExpr >	u_expr	换元表达式（u = f(x) 中的 f(x)）
string	u_var	换元变量名

LMCAS::SurfaceSymbolic

struct LMCAS::SurfaceSymbolic

隐式曲面 F(x,y,z) = 0。

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

LMCAS::SurfaceSymbolic 的协作图:

类成员
shared_ptr< SymbolicExpr >	F	曲面方程左端，等于零。
vector< string >	vars	坐标变量名 {x,y,z}。

LMCAS::SVDDecomposition

struct LMCAS::SVDDecomposition

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

LMCAS::SVDDecomposition 的协作图:

类成员
shared_ptr< SymbolicExpr >	S
shared_ptr< SymbolicExpr >	U
shared_ptr< SymbolicExpr >	V

LMCAS::TransSubstitution

struct LMCAS::TransSubstitution

换元映射条目:超越子表达式 -> 代数不定元名

在文件 transcendental_factor.hpp 第 23 行定义.

LMCAS::TransSubstitution 的协作图:

类成员
string	indeterminate	代数不定元名 (e.g., "u0")
shared_ptr< SymbolicExpr >	trans_expr	原始超越子表达式 (e.g., sin(x))

LMCAS::TransSubstitutionResult

struct LMCAS::TransSubstitutionResult

换元结果

在文件 transcendental_factor.hpp 第 29 行定义.

LMCAS::TransSubstitutionResult 的协作图:

类成员
vector< shared_ptr< SymbolicExpr > >	constraints	代数约束 (e.g., u0^2+u1^2-1=0)
vector< TransSubstitution >	mappings	所有换元映射
shared_ptr< SymbolicExpr >	poly_expr	换元后的多项式表达式

LMCAS::TrigSquare

struct LMCAS::TrigSquare

在文件 transcendental_pythagorean.cpp 第 105 行定义.

LMCAS::TrigSquare 的协作图:

类成员
shared_ptr< const SymbolicNode >	argument
shared_ptr< const SymbolicNode >	coefficient
FuncType	type

LMCAS::UnitDefinition

struct LMCAS::UnitDefinition

在文件 unit.hpp 第 42 行定义.

LMCAS::UnitDefinition 的协作图:

类成员
DimensionSignature	dimension
Rational	scale_to_base = Rational(1)

LMCAS::UniversalSolutions

struct LMCAS::UniversalSolutions

在文件 conditional_result.hpp 第 52 行定义.

LMCAS::UniversalSolutions 的协作图:

LMCAS::UnprovedResidual

struct LMCAS::UnprovedResidual

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

LMCAS::UnprovedResidual 的协作图:

类成员
ExprPtr	normalized_residual

LMCAS::Verified

struct LMCAS::Verified

template<class T>
struct LMCAS::Verified< T >

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

LMCAS::Verified< T > 的协作图:

类成员
ProofCertificate	certificate
T	value

LMCAS::ZcFactorSearch

struct LMCAS::ZcFactorSearch

在文件 zassenhaus_combine.cpp 第 347 行定义.

LMCAS::ZcFactorSearch 的协作图:

类成员
vector< size_t >	active
ComputationContext &	context
vector< Polynomial< Rational > >	factors
const vector< Polynomial< BigInt > > &	lifted
const BigInt &	modulus
Polynomial< Rational >	remaining

类型定义说明

AssumptionSolveResult

using LMCAS::AssumptionSolveResult

初始值:

 
Result<std::vector<std::shared_ptr<SymbolicExpr>>>

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

AssumptionTriboolResult

using LMCAS::AssumptionTriboolResult = Result<Tribool>

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

AssumptionVoidResult

using LMCAS::AssumptionVoidResult = Result<void>

在文件 assumption_context.hpp 第 33 行定义.

AsymptoteAnalysisResult

using LMCAS::AsymptoteAnalysisResult = Result<AsymptoteResult>

在文件 calculus_utils.hpp 第 54 行定义.

BindingResult

using LMCAS::BindingResult = Result<Binding>

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

CholeskyDecompositionResult

using LMCAS::CholeskyDecompositionResult = Result<CholeskyDecomposition>

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

ComplexBoolResult

using LMCAS::ComplexBoolResult = Result<bool>

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

ComplexRootsResult

using LMCAS::ComplexRootsResult = Result<std::vector<ComplexSymbolic>>

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

ComplexSymbolicResult

using LMCAS::ComplexSymbolicResult = Result<ComplexSymbolic>

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

ConstExprPtr

using LMCAS::ConstExprPtr = std::shared_ptr<const SymbolicExpr>

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

ContinuityResult

using LMCAS::ContinuityResult = Result<ContinuityType>

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

ConvergenceInfoResult

using LMCAS::ConvergenceInfoResult = Result<ConvergenceInfo>

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

CrtResult

using LMCAS::CrtResult = Result<std::pair<int64_t, int64_t>>

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

DifferentialGeometryExprResult

using LMCAS::DifferentialGeometryExprResult = Result<std::shared_ptr<SymbolicExpr>>

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

DifferentialGeometryVectorResult

using LMCAS::DifferentialGeometryVectorResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>

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

Expr

using LMCAS::Expr = SymbolicExpr

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

ExpressionResult

using LMCAS::ExpressionResult = Result<std::shared_ptr<SymbolicExpr>>

Result of an operation that produces a symbolic expression.

在文件 symbolic.hpp 第 31 行定义.

ExprMatchResult

using LMCAS::ExprMatchResult = Result<ExprMatch>

在文件 expr.hpp 第 42 行定义.

ExprPtr

using LMCAS::ExprPtr = std::shared_ptr<SymbolicExpr>

在文件 conditional_result.hpp 第 19 行定义.

ExprResult

using LMCAS::ExprResult = Result<ExprPtr>

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

ExprSetResult

using LMCAS::ExprSetResult = Result<ExprSet>

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

ExtremaResult

using LMCAS::ExtremaResult = Result<std::vector<CriticalPoint>>

在文件 vector_calculus_extrema.hpp 第 23 行定义.

FiniteSolveResult

using LMCAS::FiniteSolveResult

初始值:

 
Result<std::vector<std::shared_ptr<SymbolicExpr>>>

在文件 solve_strategies.hpp 第 78 行定义.

FrobeniusSolutionResult

using LMCAS::FrobeniusSolutionResult = Result<FrobeniusSolution>

在文件 symbolic_ode_engine.hpp 第 444 行定义.

HenselLiftResult

using LMCAS::HenselLiftResult = Result<std::vector<Polynomial<BigInt>>>

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

InferencePeriodResult

using LMCAS::InferencePeriodResult = Result<std::optional<SymbolicExpr>>

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

InferenceTriboolResult

using LMCAS::InferenceTriboolResult = Result<Tribool>

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

JordanDecompositionResult

using LMCAS::JordanDecompositionResult = Result<JordanDecomposition>

在文件 matrix_decomposition.hpp 第 45 行定义.

LagrangeResult

using LMCAS::LagrangeResult

初始值:

 
Result<std::vector<std::map<std::string, std::shared_ptr<SymbolicExpr>>>>

在文件 vector_calculus_extrema.hpp 第 24 行定义.

LaurentSeriesResult

using LMCAS::LaurentSeriesResult = Result<LaurentResult>

在文件 series_engine.hpp 第 178 行定义.

LimitExpressionResult

using LMCAS::LimitExpressionResult = Result<LimitExprPtr>

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

LimitExprPtr

using LMCAS::LimitExprPtr = std::shared_ptr<SymbolicExpr>

在文件 limit_value.hpp 第 12 行定义.

LimitOutcome

using LMCAS::LimitOutcome

初始值:

std::variant<
   FiniteLimit, PositiveInfinityLimit, NegativeInfinityLimit, LimitDoesNotExist>

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

LimitResult

using LMCAS::LimitResult = Result<Verified<LimitOutcome>>

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

LineSymbolicResult

using LMCAS::LineSymbolicResult = Result<LineSymbolic>

在文件 symbolic_geometry_line_plane.hpp 第 12 行定义.

LUDecompositionResult

using LMCAS::LUDecompositionResult = Result<LUDecomposition>

在文件 matrix_decomposition.hpp 第 41 行定义.

MatchMap

using LMCAS::MatchMap = std::unordered_map<std::string, SymbolicExpr>

匹配结果映射，通配符名称 → 绑定的表达式

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

MatrixEigenvalueResult

using LMCAS::MatrixEigenvalueResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>

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

MatrixEigenvectorResult

using LMCAS::MatrixEigenvectorResult

初始值:

 
Result<std::vector<std::vector<std::shared_ptr<SymbolicExpr>>>>

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

MatrixLinearSolution

using LMCAS::MatrixLinearSolution

初始值:

std::variant<
   MatrixUniqueLinearSolution,
   MatrixParametricLinearSolution,
   MatrixInconsistentLinearSolution>

在文件 symbolic_matrix.hpp 第 90 行定义.

MatrixLinearSolveResult

using LMCAS::MatrixLinearSolveResult = Result<MatrixLinearSolution>

在文件 symbolic_matrix.hpp 第 94 行定义.

MatrixNullspaceResult

using LMCAS::MatrixNullspaceResult

初始值:

 
Result<std::vector<std::vector<std::shared_ptr<SymbolicExpr>>>>

在文件 symbolic_matrix.hpp 第 75 行定义.

MatrixRankResult

using LMCAS::MatrixRankResult = Result<std::size_t>

计算两个符号矩阵的乘积

归一化后的近似元素保留浮点计算值，精确元素保持精确算术。 误差容限用于显式数值比较，不参与矩阵元素的归一化。 矩阵因子按输入顺序相乘，结果形状为左矩阵行数乘以右矩阵列数。 成功返回已归一化的显式矩阵；稀疏存储及全零乘积不会丢失结果维度。

参数

A	左矩阵
B	右矩阵

返回

乘积矩阵的符号表达式

计算符号矩阵的行列式

参数

A

输入矩阵

返回

行列式的符号表达式

计算符号矩阵的逆矩阵

参数

A

输入矩阵

返回

逆矩阵的符号表达式

在文件 symbolic_matrix.hpp 第 74 行定义.

MixedTranscendentalResult

using LMCAS::MixedTranscendentalResult

初始值:

 
Result<MathResult<std::vector<std::shared_ptr<SymbolicExpr>>>>

受检混合超越方程求解结果.

Complete 表示给定有界区间内的全部求解路径均已穷尽; Inconclusive 可携带已经通过区间与残差验证的候选根。恒零方程和 仅依赖未绑定参数的方程也返回 Inconclusive,因为有限向量无法表示其解集。

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

Monomial

using LMCAS::Monomial = std::vector<int>

单项式类型，以整数向量表示各变量的指数

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

MultiFactorCheckedResult

using LMCAS::MultiFactorCheckedResult = Result<MathResult<MultiFactorResult>>

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

NodeMap

template<typename T>

using LMCAS::NodeMap = std::unordered_map<std::shared_ptr<const SymbolicNode>, T, NodeHash, NodeEqual>

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

NodeSet

using LMCAS::NodeSet = std::unordered_set<std::shared_ptr<const SymbolicNode>, NodeHash, NodeEqual>

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

NumericBindings

using LMCAS::NumericBindings = std::unordered_map<std::string, double>

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

NumericRootResult

using LMCAS::NumericRootResult = Result<std::optional<NumericRoot>>

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

NumericRootsResult

using LMCAS::NumericRootsResult = Result<std::vector<NumericRoot>>

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

ODESingularityResult

using LMCAS::ODESingularityResult = Result<ODESingularityType>

在文件 symbolic_ode_engine.hpp 第 430 行定义.

ODESolutionResult

using LMCAS::ODESolutionResult = Result<ODESolution>

在文件 symbolic_ode_engine.hpp 第 79 行定义.

OptionalRationalPolynomial

template<typename T>

using LMCAS::OptionalRationalPolynomial = std::optional<Polynomial<Rational>>

将符号表达式转换为一元多项式。

支持 BigInt、Rational 和 SymbolicPolyCoeff 系数。 不支持的子树或无法表示的系数使整个转换返回 UnsupportedExpression； 成功返回的零多项式表示数学上的零。空输入或变量名返回 InvalidArgument。 幂展开次数须为小于 1000 的非负整数；更大次数或超出 int 次数表示范围的 系数存储返回 ResourceLimit。有限 double 按精确 binary64 值转换； 证明源表达式精确性请用 recognize_rational_polynomial()。

将支持的一元多项式转换为符号表达式。

支持 BigInt、Rational 和 SymbolicPolyCoeff 系数。

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

ParametricMatrix

using LMCAS::ParametricMatrix = std::vector<std::vector<std::shared_ptr<SymbolicExpr>>>

在文件 parametric_solver.cpp 第 69 行定义.

ParametricSolutionList

using LMCAS::ParametricSolutionList

初始值:

 
std::vector<std::map<std::string, std::shared_ptr<SymbolicExpr>>>

在文件 parametric_solver.hpp 第 24 行定义.

ParametricSolutionsResult

using LMCAS::ParametricSolutionsResult = Result<ParametricSolutionList>

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

ParametricVector

using LMCAS::ParametricVector = std::vector<std::shared_ptr<SymbolicExpr>>

在文件 parametric_solver.cpp 第 70 行定义.

PlaneSymbolicResult

using LMCAS::PlaneSymbolicResult = Result<PlaneSymbolic>

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

PolynomialSystemResult

using LMCAS::PolynomialSystemResult

初始值:

 
Result<std::vector<std::map<std::string, SymbolicExpr>>>

多项式方程组求解器，提供线性系统求解、Gröbner 基计算及多项式系统求解功能。

在文件 solver.hpp 第 19 行定义.

PowerSeriesResult

using LMCAS::PowerSeriesResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>

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

ProofCertificate

using LMCAS::ProofCertificate

初始值:

std::variant<
   ByConstructionProof,
   ExactNormalizationProof,
   ExactResidualProof,
   ExactRoundTripProof>

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

ProofExprPtr

using LMCAS::ProofExprPtr = std::shared_ptr<SymbolicExpr>

在文件 proof_outcome.hpp 第 12 行定义.

PropertyStoreResult

using LMCAS::PropertyStoreResult = Result<void>

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

QRDecompositionResult

using LMCAS::QRDecompositionResult = Result<QRDecomposition>

在文件 matrix_decomposition.hpp 第 42 行定义.

QuantityResult

using LMCAS::QuantityResult = Result<std::shared_ptr<SymbolicExpr>>

在文件 quantity.hpp 第 12 行定义.

QueryPeriodResult

using LMCAS::QueryPeriodResult = Result<std::optional<SymbolicExpr>>

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

QueryTriboolResult

using LMCAS::QueryTriboolResult = Result<Tribool>

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

RationalReconstructionResult

using LMCAS::RationalReconstructionResult = Result<std::pair<int64_t, int64_t>>

在文件 modular_arithmetic.hpp 第 23 行定义.

RelationStoreResult

using LMCAS::RelationStoreResult = Result<void>

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

ResidualCheck

using LMCAS::ResidualCheck

初始值:

std::variant<
   ProvedZeroResidual,
   ProvedNonIdentityResidual,
   UnprovedResidual>

在文件 residual_verification.hpp 第 31 行定义.

ResidualCheckResult

using LMCAS::ResidualCheckResult = Result<ResidualCheck>

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

RootOfComplexEvaluationResult

using LMCAS::RootOfComplexEvaluationResult = Result<ApproxComplex>

在文件 root_of_identity.hpp 第 19 行定义.

RootOfConstructionResult

using LMCAS::RootOfConstructionResult = Result<std::shared_ptr<SymbolicExpr>>

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

RootOfEvaluationResult

using LMCAS::RootOfEvaluationResult = Result<lmmc_real_t>

在文件 root_of_identity.hpp 第 18 行定义.

SolutionSet

using LMCAS::SolutionSet

初始值:

std::variant<
   EmptySolutions,
   UniversalSolutions,
   FiniteSolutions,
   IntervalSolutions,
   ConditionalSolutions,
   ParametricSolutions>

成功的 SolveResult 表示操作定义域内的完整解集。 完备性未决时返回外层 Inconclusive 错误；EmptySolutions 表示已证明的空解集。

在文件 conditional_result.hpp 第 70 行定义.

SolveResult

using LMCAS::SolveResult = Result<SolutionSet>

在文件 conditional_result.hpp 第 77 行定义.

SolveVectorResult

using LMCAS::SolveVectorResult

初始值:

 
LMCAS::Result<std::vector<std::shared_ptr<SymbolicExpr>>>

在文件 solve_visitor.cpp 第 36 行定义.

SVDDecompositionResult

using LMCAS::SVDDecompositionResult = Result<SVDDecomposition>

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

SymbolicExprVectorResult

using LMCAS::SymbolicExprVectorResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>

在文件 calculus_utils.hpp 第 55 行定义.

SymbolicGcdResult

using LMCAS::SymbolicGcdResult = Result<std::shared_ptr<SymbolicExpr>>

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

SymbolicSetResult

using LMCAS::SymbolicSetResult = Result<std::shared_ptr<SymbolicExpr>>

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

TransformEngineResult

using LMCAS::TransformEngineResult = Result<Verified<EvaluatedTransform>>

在文件 conditional_result.hpp 第 88 行定义.

UnivariateFactorResult

using LMCAS::UnivariateFactorResult

初始值:

 
Result<MathResult<std::vector<Polynomial<Rational>>>>

在文件 multivariate_factor_support.hpp 第 9 行定义.

VectorAngleResult

using LMCAS::VectorAngleResult = Result<double>

在文件 symbolic_geometry_vector.hpp 第 12 行定义.

VectorCalculusExprResult

using LMCAS::VectorCalculusExprResult = Result<std::shared_ptr<SymbolicExpr>>

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

VectorCalculusFieldResult

using LMCAS::VectorCalculusFieldResult = Result<VectorField>

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

VectorExprListResult

using LMCAS::VectorExprListResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>

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

VectorField

using LMCAS::VectorField = std::vector<std::shared_ptr<SymbolicExpr>>

向量场由标量表达式组成。

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

VectorStringResult

using LMCAS::VectorStringResult = Result<std::string>

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

ZassenhausResult

using LMCAS::ZassenhausResult

初始值:

 
Result<MathResult<std::vector<Polynomial<Rational>>>>

在文件 exact_factorization.hpp 第 53 行定义.

枚举类型说明

Boundedness

enum class LMCAS::Boundedness

strong

Boundedness classification for symbols.

枚举值
Bounded	Symbol has finite bounds
Unbounded	Symbol is unbounded
Unknown	Boundedness not determined

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

                       {
    Bounded,      ///< Symbol has finite bounds
    Unbounded,    ///< Symbol is unbounded
    Unknown       ///< Boundedness not determined
};

CalculusRealCandidateStatus

enum class LMCAS::CalculusRealCandidateStatus

strong

枚举值
Real
NonReal
Inconclusive

在文件 calculus_inverse.cpp 第 123 行定义.

                                       {
    Real,
    NonReal,
    Inconclusive
};

CasErrc

enum class LMCAS::CasErrc

strong

枚举值
InvalidArgument
ParseError
UnboundSymbol
DomainError
DimensionMismatch
UnitInvalid
UnitStripTypeMismatch
SetElementTypeMismatch
SetOperandTypeMismatch
SetElementNotHashable
UnsupportedExpression
Inconclusive
ResourceLimit
Cancelled
NumericFailure
InternalInvariant

在文件 result.hpp 第 12 行定义.

                   {
    InvalidArgument,
    ParseError,
    UnboundSymbol,
    DomainError,
    DimensionMismatch,
    UnitInvalid,
    UnitStripTypeMismatch,
    SetElementTypeMismatch,
    SetOperandTypeMismatch,
    SetElementNotHashable,
    UnsupportedExpression,
    Inconclusive,
    ResourceLimit,
    Cancelled,
    NumericFailure,
    InternalInvariant
};

Completeness

enum class LMCAS::Completeness

strong

枚举值
Complete
Inconclusive

在文件 result.hpp 第 122 行定义.

{ Complete, Inconclusive };

ContinuityType

enum class LMCAS::ContinuityType

strong

连续性类型枚举.

枚举值
Continuous	连续:左极限 = 右极限 = 函数值
Removable	可去间断点:左极限 = 右极限 != 函数值(或函数无定义)
Jump	跳跃间断点:左极限 != 右极限,但两侧极限均存在
Essential	本性间断点:至少一侧极限不存在或为无穷

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

                          {
    Continuous,  ///< 连续:左极限 = 右极限 = 函数值
    Removable,   ///< 可去间断点:左极限 = 右极限 != 函数值(或函数无定义)
    Jump,        ///< 跳跃间断点:左极限 != 右极限,但两侧极限均存在
    Essential    ///< 本性间断点:至少一侧极限不存在或为无穷
};

ConvergenceResult

enum class LMCAS::ConvergenceResult

strong

收敛性结果枚举.

枚举值
Convergent	收敛
Divergent	发散
Inconclusive	无法判定

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

                             {
    Convergent,   ///< 收敛
    Divergent,    ///< 发散
    Inconclusive  ///< 无法判定
};

CriticalPointClassification

enum class LMCAS::CriticalPointClassification

strong

枚举值
LocalMinimum
LocalMaximum
Saddle
Degenerate
Inconclusive

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

                                       {
    LocalMinimum,
    LocalMaximum,
    Saddle,
    Degenerate,
    Inconclusive
};

Definiteness

enum class LMCAS::Definiteness

strong

Matrix definiteness classification.

枚举值
PositiveDefinite	All eigenvalues positive
PositiveSemiDefinite	All eigenvalues non-negative
NegativeDefinite	All eigenvalues negative
NegativeSemiDefinite	All eigenvalues non-positive
Indefinite	Mixed eigenvalue signs
Unknown	Definiteness not determined

在文件 assumption.hpp 第 66 行定义.

                        {
    PositiveDefinite,      ///< All eigenvalues positive
    PositiveSemiDefinite,  ///< All eigenvalues non-negative
    NegativeDefinite,      ///< All eigenvalues negative
    NegativeSemiDefinite,  ///< All eigenvalues non-positive
    Indefinite,            ///< Mixed eigenvalue signs
    Unknown                ///< Definiteness not determined
};

DiagnosticSeverity

enum class LMCAS::DiagnosticSeverity

strong

枚举值
Info
Warning
Error

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

{ Info, Warning, Error };

Domain

enum class LMCAS::Domain

strong

Mathematical domain hierarchy (least specific → most specific). Complex ⊃ Real ⊃ Algebraic ⊃ Rational ⊃ Integer ⊃ Natural ⊃ PositiveInt

枚举值
Complex	Complex numbers (default, least specific)
Real	Real numbers
Algebraic	Algebraic numbers (roots of polynomials with rational coefficients)
Rational	Rational numbers
Integer	Integers
Natural	Non-negative integers (0, 1, 2, ...)
PositiveInt	Positive integers (1, 2, 3, ...)

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

                  {
    Complex,      ///< Complex numbers (default, least specific)
    Real,         ///< Real numbers
    Algebraic,    ///< Algebraic numbers (roots of polynomials with rational coefficients)
    Rational,     ///< Rational numbers
    Integer,      ///< Integers
    Natural,      ///< Non-negative integers (0, 1, 2, ...)
    PositiveInt   ///< Positive integers (1, 2, 3, ...)
};

EqvProfile

enum class LMCAS::EqvProfile

strong

枚举值
Core
TrigBasic
ExpLogBasic

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

                      {
    Core,
    TrigBasic,
    ExpLogBasic
};

Finiteness

enum class LMCAS::Finiteness

strong

Finiteness classification for limits and sequences.

枚举值
Finite	Has a finite value or limit
Divergent	Diverges to infinity or oscillates
Unknown	Finiteness not determined

在文件 assumption.hpp 第 76 行定义.

                      {
    Finite,    ///< Has a finite value or limit
    Divergent, ///< Diverges to infinity or oscillates
    Unknown    ///< Finiteness not determined
};

InequalityType

enum class LMCAS::InequalityType

strong

不等式类型

枚举值
GreaterThan	严格大于
GreaterEqual	大于等于
LessThan	严格小于
LessEqual	小于等于

在文件 interval.hpp 第 18 行定义.

                          {
    GreaterThan,  ///< 严格大于
    GreaterEqual, ///< 大于等于
    LessThan,     ///< 严格小于
    LessEqual     ///< 小于等于
};

LimitDirection

enum class LMCAS::LimitDirection

strong

Direction from which a limit approaches its point.

枚举值
Both
FromBelow
FromAbove

在文件 limit_direction.hpp 第 6 行定义.

                          {
    Both,
    FromBelow,
    FromAbove
};

MonomialOrderType

enum class LMCAS::MonomialOrderType

strong

单项式序的类型枚举

枚举值
Lex	字典序
GrevLex	分次逆字典序
DegLex	分次字典序
DegRevLex	分次逆字典序（同 GrevLex）

在文件 monomial_order.hpp 第 18 行定义.

                             {
    Lex,        ///< 字典序
    GrevLex,    ///< 分次逆字典序
    DegLex,     ///< 分次字典序
    DegRevLex   ///< 分次逆字典序（同 GrevLex）
};

Monotonicity

enum class LMCAS::Monotonicity

strong

Monotonicity classification for functions over intervals.

枚举值
Increasing	Strictly increasing
Decreasing	Strictly decreasing
NonDecreasing	Non-decreasing (weakly increasing)
NonIncreasing	Non-increasing (weakly decreasing)
Unknown	Monotonicity not determined

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

                        {
    Increasing,      ///< Strictly increasing
    Decreasing,      ///< Strictly decreasing
    NonDecreasing,   ///< Non-decreasing (weakly increasing)
    NonIncreasing,   ///< Non-increasing (weakly decreasing)
    Unknown          ///< Monotonicity not determined
};

NumberDomain

enum class LMCAS::NumberDomain

strong

枚举值
Integers
Rationals
Reals
Complexes
Expressions

在文件 expr.hpp 第 85 行定义.

                        {
    Integers,
    Rationals,
    Reals,
    Complexes,
    Expressions
};

NumericStatus

enum class LMCAS::NumericStatus

strong

枚举值
Finite
PositiveInfinity
NegativeInfinity

在文件 numeric_value.hpp 第 5 行定义.

{ Finite, PositiveInfinity, NegativeInfinity };

ODESingularityType

enum class LMCAS::ODESingularityType

strong

对一阶 ODE 进行类型分类.

给定 dy/dx = rhs(x, y) 形式的方程右端,检测其属于哪种可求解类型. 检测顺序:可分离 -> 一阶线性 -> 齐次 -> Bernoulli -> 恰当. 空 rhs 返回 Unknown。

参数

[in]	rhs	方程右端表达式 (dy/dx = rhs)
[in]	x	自变量名
[in]	y	因变量名

返回

分类结果

对高阶线性 ODE 进行类型分类.

给定系数列表和非齐次项,检测是否为常系数或 Euler 类型. 系数列表按降阶排列:coeffs[0] 对应最高阶导数. 常系数分类仅在所有系数都能表示为有限 double 时返回；否则返回 Unknown， 避免在 const_coeffs 中伪造数值。

参数

[in]	coeffs	各阶导数的系数表达式列表(降阶排列)
[in]	forcing	非齐次项 f(x)
[in]	x	自变量名
[in]	y	因变量名

返回

分类结果

检测表达式是否为可分离变量形式 f(x)*g(y).

空 rhs、空变量名或相同的 x/y 变量名返回 false。

参数

[in]	rhs	方程右端表达式
[in]	x	自变量名
[in]	y	因变量名

返回

若可分离返回 true

检测一阶 ODE 是否为线性形式 y' + P(x)y = Q(x).

空 rhs、空变量名或相同的 x/y 变量名返回 false；返回 false 时 P、Q 均置空。

参数

[in]	rhs	方程右端表达式 (dy/dx = rhs)
[in]	x	自变量名
[in]	y	因变量名
[out]	P	若为线性,输出 P(x)
[out]	Q	若为线性,输出 Q(x)

返回

若为一阶线性返回 true

检测一阶 ODE 是否为齐次形式 y' = f(y/x).

通过检查 f(tx, ty) = f(x, y) 来判断齐次性. 判定只接受符号等价性证明；有限采样点相等不会被当作恒等证明。 空变量名或相同的 x/y 变量名返回 false。

参数

[in]	rhs	方程右端表达式
[in]	x	自变量名
[in]	y	因变量名

返回

若为齐次返回 true

检测一阶 ODE 是否为 Bernoulli 形式 y' + P(x)y = Q(x)y^n.

支持可由 AST 精确分解的任意 int 幂次，包括负幂；不通过有限点采样猜测 幂次。 空 rhs、空变量名或相同的 x/y 变量名返回 false；返回 false 时 P、Q 均置空且 n 置零。

参数

[in]	rhs	方程右端表达式 (dy/dx = rhs)
[in]	x	自变量名
[in]	y	因变量名
[out]	P	若为 Bernoulli,输出 P(x)
[out]	Q	若为 Bernoulli,输出 Q(x)
[out]	n	若为 Bernoulli,输出幂次 n (n != 0, 1)

返回

若为 Bernoulli 返回 true

检测方程是否为恰当形式 M(x,y) + N(x,y)y' = 0,即 partialM/partialy = partialN/partialx. 判定只接受符号等价性证明；有限采样点相等不会被当作恒等证明。 空表达式、空变量名或相同的 x/y 变量名返回 false。

参数

[in]	M	M(x,y) 表达式
[in]	N	N(x,y) 表达式
[in]	x	自变量名
[in]	y	因变量名

返回

若恰当返回 true

检测高阶 ODE 系数是否全为常数.

系数列表和自变量名必须非空，否则返回 false。

参数

[in]	coeffs	各阶导数的系数表达式列表
[in]	x	自变量名

返回

若所有系数不依赖 x 返回 true

检测高阶 ODE 是否为 Euler (Cauchy-Euler) 形式.

Euler 方程形如 x^n*y^(n) + a_{n-1}*x^{n-1}*y^{n-1} + ... + a_0*y = f(x), 即第 k 阶导数的系数为常数乘以 x^k. 系数列表和自变量名必须非空，最高阶系数必须非零。判定要求每个比值 coefficient_k/x^k 可被符号化简为有限常数，不用有限采样代替恒等证明。 返回 false 时 euler_consts 置空。

参数

[in]	coeffs	各阶导数的系数表达式列表(降阶排列)
[in]	x	自变量名
[out]	euler_consts	提取的常数系数列表

返回

若为 Euler 方程返回 true

求解齐次 ODE y' = f(y/x).

算法:令 v = y/x,则 y = vx,y' = v + xv'. 代入得 v + xv' = f(v),即 xv' = f(v) - v, 分离变量后积分,最后回代 v = y/x.

参数

[in]	rhs	方程右端表达式 f(x, y)(满足 f(tx,ty)=f(x,y))
[in]	x	自变量名
[in]	y	因变量名

返回

求解结果

使用默认计算上下文求解齐次 ODE,并显式报告无效输入和未覆盖域.

求解 Bernoulli 方程 y' + P(x)y = Q(x)y^n.

算法:令 v = y^(1-n),则 v' = (1-n)y^(-n)y'. 代入得线性方程 v' + (1-n)P(x)v = (1-n)Q(x), 用积分因子法求解后回代 y = v^(1/(1-n)).

参数

[in]	P	P(x) 系数
[in]	Q	Q(x) 系数
[in]	n	幂次 (n != 0, 1)
[in]	x	自变量名
[in]	y	因变量名

返回

求解结果

使用默认计算上下文求解 Bernoulli 方程,并显式报告无效输入和未覆盖域.

求解恰当方程 M(x,y)dx + N(x,y)dy = 0.

算法:当 partialM/partialy = partialN/partialx 时,存在势函数 F(x,y) 使得 partialF/partialx = M, partialF/partialy = N.通过对 M 关于 x 积分并从 N 确定 y 相关部分来构造 F,解为 F(x,y) = C.

当方程不恰当时,尝试寻找积分因子 mu(x) 或 mu(y).

参数

[in]	M	M(x,y) 表达式
[in]	N	N(x,y) 表达式
[in]	x	自变量名
[in]	y	因变量名

返回

求解结果(隐式解 F(x,y) = C)

使用默认计算上下文求解恰当方程,并显式报告无效输入和未覆盖域.

寻找积分因子使非恰当方程变为恰当方程.

尝试以下形式的积分因子:

1. mu = mu(x):当 (partialM/partialy - partialN/partialx)/N 仅依赖 x 时
2. mu = mu(y):当 (partialN/partialx - partialM/partialy)/M 仅依赖 y 时

参数

[in]	M	M(x,y) 表达式
[in]	N	N(x,y) 表达式
[in]	x	自变量名
[in]	y	因变量名

返回

积分因子表达式,若找不到返回 nullptr

求解高阶常系数线性 ODE.

算法:构造特征多项式；二次实根使用避免相消的稳定公式；三至六次 多项式先用变量尺度平衡系数，再用多项式与其导数的近似 GCD 提取 高阶重根；最后根据根的类型构造通解:

• 实根 r(重数 m):e^(rx), x*e^(rx), ..., x^(m-1)*e^(rx)
• 复根 alpha+/-betai(重数 m):e^(alphax)(cos(betax), sin(betax)), x*e^(alphax)(cos(betax), sin(betax)), ...

非齐次支持域当前限于常数 forcing 且 y 的系数非零。 支持阶数最高为 6。统一乘以任意有限非零常数不改变输入方程。 特征根迭代必须收敛且通过后向误差检查；实根分类验证实轴投影相对于 候选根的误差，复根必须形成经尺度平衡后多项式验证的共轭对，不使用 会吞掉小非零虚部的固定绝对容差。归一化、尺度恢复、迭代或验证超出 有限 double 域时返回 CasErrc::NumericFailure。

参数

[in]	coeffs	各阶导数的数值系数(降阶排列:coeffs[0] 对应最高阶)
[in]	forcing	非齐次项 f(x),齐次时为 nullptr 或零
[in]	x	自变量名
[in]	y	因变量名

返回

求解结果

使用默认计算上下文求解高阶常系数 ODE,并显式报告无效输入和未覆盖域.

求解 Euler (Cauchy-Euler) 方程.

算法:对 Euler 方程 a_n*x^n*y^(n) + ... + a_0*y = f(x), 令 x = e^t(即 t = ln(x)),将方程转化为关于 t 的常系数 ODE, 求解后回代 t = ln(x).

支持二阶和三阶 Euler 方程.

参数

[in]	euler_coeffs	Euler 方程的常数系数列表(降阶排列)
[in]	forcing	非齐次项 f(x),齐次时为 nullptr 或零
[in]	x	自变量名
[in]	y	因变量名

返回

求解结果

使用默认计算上下文求解 Euler 方程,并显式报告无效输入和未覆盖域.

奇点类型枚举.

枚举值
Ordinary	常点
RegularSingular	正则奇点
IrregularSingular	非正则奇点

在文件 symbolic_ode_engine.hpp 第 425 行定义.

                              {
    Ordinary,         ///< 常点
    RegularSingular,  ///< 正则奇点
    IrregularSingular ///< 非正则奇点
};

ODEType

enum class LMCAS::ODEType

strong

ODE 类型枚举,标识方程所属的求解类别.

枚举值
Separable	可分离变量型 dy/dx = f(x)g(y)
Linear1	一阶线性 dy/dx + P(x)y = Q(x)
Linear2_ConstCoeff	二阶常系数线性
Homogeneous	齐次方程 y' = f(y/x)
Bernoulli	Bernoulli 方程 y' + P(x)y = Q(x)y^n
Exact	恰当方程 M(x,y)dx + N(x,y)dy = 0
HigherOrder_ConstCoeff	高阶常系数线性
Euler	Euler (Cauchy-Euler) 方程
System	ODE 系统
LaplaceMethod	Laplace 变换法
Frobenius	Frobenius 级数解法
Unknown	无法识别的类型

在文件 symbolic_ode_engine.hpp 第 24 行定义.

                   {
    Separable,              ///< 可分离变量型 dy/dx = f(x)g(y)
    Linear1,                ///< 一阶线性 dy/dx + P(x)y = Q(x)
    Linear2_ConstCoeff,     ///< 二阶常系数线性
    Homogeneous,            ///< 齐次方程 y' = f(y/x)
    Bernoulli,              ///< Bernoulli 方程 y' + P(x)y = Q(x)y^n
    Exact,                  ///< 恰当方程 M(x,y)dx + N(x,y)dy = 0
    HigherOrder_ConstCoeff, ///< 高阶常系数线性
    Euler,                  ///< Euler (Cauchy-Euler) 方程
    System,                 ///< ODE 系统
    LaplaceMethod,          ///< Laplace 变换法
    Frobenius,              ///< Frobenius 级数解法
    Unknown                 ///< 无法识别的类型
};

Parity

enum class LMCAS::Parity

strong

Integer parity classification.

枚举值
Even	Even integer
Odd	Odd integer
Unknown	Parity not determined

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

                  {
    Even,         ///< Even integer
    Odd,          ///< Odd integer
    Unknown       ///< Parity not determined
};

PropType

enum class LMCAS::PropType

strong

Identifies which property is being queried, used as part of the cache key.

枚举值
Positive
Negative
NonNegative
NonPositive
Real
Integer
NonZero
Algebraic
Transcendental
Finite
Divergent
Periodic
PositiveDefinite
PositiveSemiDefinite

在文件 query_interface.hpp 第 33 行定义.

                    {
    Positive,
    Negative,
    NonNegative,
    NonPositive,
    Real,
    Integer,
    NonZero,
    Algebraic,
    Transcendental,
    Finite,
    Divergent,
    Periodic,
    PositiveDefinite,
    PositiveSemiDefinite
};

RelationOp

enum class LMCAS::RelationOp

strong

Stable relational operator used by public APIs.

枚举值
EQ
NEQ
LT
GT
LEQ
GEQ

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

                      {
    EQ,
    NEQ,
    LT,
    GT,
    LEQ,
    GEQ
};

Sign

enum class LMCAS::Sign

strong

Sign classification for symbols and expressions.

枚举值
Positive	0
Negative	< 0
NonNegative	>= 0
NonPositive	<= 0
Zero	== 0
NonZero	!= 0

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

                {
    Positive,     ///< > 0
    Negative,     ///< < 0
    NonNegative,  ///< >= 0
    NonPositive,  ///< <= 0
    Zero,         ///< == 0
    NonZero       ///< != 0
};

SingularityType

enum class LMCAS::SingularityType

strong

从无限级数通项计算幂级数收敛半径.

当前对常数通项,b^n 和 n^p 给出精确结果;无法证明尾项行为时返回 ::CasErrc::Inconclusive,不会从有限样本外推极限.

参数

[in]	general_coefficient	系数通项 a_n
[in]	index_var	系数指标变量名

返回

已证明的收敛半径表达式

返回有限系数多项式的收敛半径.

coefficients 完整表示有限多项式,未列出的高阶系数均为零,因此非空 有效输入的收敛半径恒为 infinity.若要表示无限级数,应使用通项重载; 有限前缀不足以证明无限尾项的收敛半径.

判定无穷级数的收敛性.

依次尝试比值判别法,根值判别法和比较判别法.

参数

[in]	general_term	通项表达式 a_n
[in]	index_var	求和指标变量名

返回

收敛性判定信息

幂级数加法:逐项相加.

参数

[in]	a	第一个幂级数系数列表
[in]	b	第二个幂级数系数列表

返回

和级数的系数列表

幂级数乘法:柯西乘积(卷积).

参数

[in]	a	第一个幂级数系数列表
[in]	b	第二个幂级数系数列表
[in]	order	截断阶数

返回

乘积级数的系数列表(截断到 order 项)

幂级数复合:计算 f(g(x)) 的系数,要求 g(0) = 0.

参数

[in]	f	外层幂级数系数列表
[in]	g	内层幂级数系数列表(g[0] 必须为 0)
[in]	order	截断阶数

返回

复合级数的系数列表

Computes a bounded truncated Fourier expansion.

All coefficient integrations share context. Resource exhaustion, cancellation, invalid inputs, and nested integration failures are returned without being collapsed to a null expression.

奇点类型枚举.

枚举值
Removable	可去奇点
Pole	极点
Essential	本性奇点

在文件 series_engine.hpp 第 162 行定义.

                           {
    Removable,  ///< 可去奇点
    Pole,       ///< 极点
    Essential   ///< 本性奇点
};

SolveStrategy

enum class LMCAS::SolveStrategy

strong

求解策略枚举,标识所使用的求解方法.

枚举值
ClosedForm	闭式公式求解
Preprocessing	预处理(化简,换元等)
Transcendental	超越方程求解
Numerical	数值迭代求解
RootOf	以 RootOf 表达式表示

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

                         {
    ClosedForm,       ///< 闭式公式求解
    Preprocessing,    ///< 预处理(化简,换元等)
    Transcendental,   ///< 超越方程求解
    Numerical,        ///< 数值迭代求解
    RootOf            ///< 以 RootOf 表达式表示
};

Tribool

enum class LMCAS::Tribool

strong

Tri-state logic value for property queries.

枚举值
True	Property definitely holds
False	Property definitely does not hold
Unknown	Property cannot be determined

在文件 assumption.hpp 第 50 行定义.

                   {
    True,         ///< Property definitely holds
    False,        ///< Property definitely does not hold
    Unknown       ///< Property cannot be determined
};

UnitStripMode

enum class LMCAS::UnitStripMode

strong

枚举值
BaseValue
DisplayValue

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

                         {
    BaseValue,
    DisplayValue
};

ZPolynomialPattern

enum class LMCAS::ZPolynomialPattern

strong

枚举值
None
Linear
Quadratic
Cubic

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

{ None, Linear, Quadratic, Cubic };

函数说明

__attribute__() [1/4]

LMCAS::__attribute__ ( (visibility("default")) )

finalnoexcept

Scoped assumption context with push/pop management.

运行时统一值类型,支持数值,符号,容器等类型的动态表示

Owns unit declarations for one computation context.

A canonical product of base dimensions raised to exact rational powers.

生成缩放矩阵

生成反射矩阵

生成旋转矩阵

求解三角、指数、对数类超越方程。

投影完整、无条件的有限解集，并保留重数。 空集投影为空向量；无限解集或条件解集返回 Inconclusive。

Solves an equation using a default computation context.

在已验证支持域内求方程的完整解集。 精确有理多项式保留全部复根及重数，以精确根式或 RootOf 表示，保持系数精确。 实超越反演保留原操作数定义域、整数参数和未决条件；系数退化未知时， 返回完整的 ConditionalSolutions，并以条件限定通用根。 数值搜索可辅助求解；候选残差全部通过仍不足以证明完备性。 完备性未证或完整定义域无法表示时返回 CasErrc::Inconclusive。 成功表示在上下文假设及所有返回条件下，得到操作定义域内的完整解集。 UniversalSolutions 仅在该域内普遍成立，原式极点始终排除。 候选残差恒等式仅证明公共定义域上的正确性；可定义性、根的互异性及覆盖性须另证。 未决逐点条件须保留为条件或 Inconclusive，形式非恒等式不足以消除这些条件。 资源耗尽与取消仍作为外层错误返回。

Stores relational constraints and derives sign properties for simple patterns.

精确有理数类，以 BigInt 分子/分母表示，构造时自动约分

Stores and validates mathematical properties for named symbols.

含参方程组求解器，支持线性与多项式方程组的参数化求解

Numerically solves using an isolated default computation context.

在受支持的一元表达式域内执行数值求根.

稀疏多元多项式。

基于规则的表达式重写引擎

重写规则，定义模式到替换表达式的变换

符号表达式模式匹配器

保留精确系数和无平方因子的被开方数。

区间并集，表示不等式的解集

单个区间 [a, b] 或 (a, b) 等

区间端点，支持有限值与正负无穷

不等式求解器,提供多项式,有理式及参数化不等式的求解

参数化不等式的分段解集

FGLM 算法中使用的多项式表示,以 (单项式, 系数) 对列表存储

借用单个符号的名称。

Maintains a stack of scopes, each containing a PropertyStore and RelationStore. Queries use read-through semantics: searching from the top scope down to root, 查询按子作用域到父作用域的顺序定位首个符号声明. 子作用域声明覆盖查询结果,同时保留父作用域状态;弹出作用域后恢复先前结果.

返回

空表达式、非符号表达式或数学常量返回 nullopt。

注解

借用名称仅在原表达式存活且未被重新赋值时有效。

查看关系运算符；空表达式或非关系表达式返回 nullopt。 Versioned, lossless semantic expression encoding (independent of to_string).

商保留精确分子与分母，仅 to_double() 执行舍入；相等性比较使用精确交叉乘积。 排序及 is_positive()/is_negative() 使用近似判断，不能作为精确证明。 sign_checked()/abs_checked() 使用认证包围区间；含 pi/e 的组合在 4096 位时仍跨零， 返回 Inconclusive。纯根式持续细化，直至完成认证或耗尽预算。 无上下文的基本运算与 BigInt 一样不限预算；受检便捷入口及 abs() 使用默认 ComputationContext。

以 (Monomial, Rational) 对的有序列表表示多元多项式。 单项式按指定的 MonomialOrder 排序。 支持加减乘、求值、度数查询和一元转换。 非零操作数必须具有按名称和排列完全相同的变量表，否则加减乘和整除 抛出 std::invalid_argument；不自动合并变量或重排变量坐标。 加减乘结果使用左侧单项式序；一侧为零时使用非零侧的变量表和序， 双方为零时保留左侧表示。不同单项式序不改变同一变量环中的数学值。

多项式输入先由 Sturm 序列隔离实根,再执行受检精化；隔离区间通过 溢出安全的中点生成 Newton 初值，包括最大有限浮点端点。 其他输入使用 Newton 初值,缺省初值为零；求值、取消与资源诊断 均通过 Result 通道返回调用方。

参见

Jacques Charles François Sturm, "Mémoire sur la résolution des équations numériques," 1829.

Supports domain hierarchy implication, sign implication, contradiction detection, and cross-constraint checking between domains and signs.

When a relation of the form variable op 0 is added, the RelationStore notifies the PropertyStore to mark the variable with the corresponding sign:

• GT -> Positive
• GEQ -> NonNegative
• LT -> Negative
• LEQ -> NonPositive
• NEQ -> NonZero

复合关系(多变量左端或任意右端)按原结构存储,供 InferenceEngine 后续推导.

参数

expr	待求解的表达式（视为等于零）。
var	求解变量名。

返回

完整实数解集。三角函数解族使用精确符号 pi 和新引入的整数参数； 未求出的原像保留原始谓词，超出处理范围的变换返回 Inconclusive 而非部分根。

参数

theta	有限的旋转角度（弧度）
dim	矩阵维度，默认为 2

返回

二维旋转矩阵；上下文错误优先，其次维度错误，非有限角度返回 InvalidArgument。

参数

angle	反射轴角度（弧度）
dim	矩阵维度，默认为 2

返回

反射矩阵的符号表达式

参数

sx	有限的 x 方向缩放因子
sy	有限的 y 方向缩放因子
dim	矩阵维度，默认为 2

返回

二维缩放矩阵；上下文错误优先，其次维度错误，非有限因子返回 InvalidArgument。

Push a new scope onto the stack.

Pop the current scope.

Return the current nesting depth (number of scopes on the stack).

访问当前作用域可修改的 PropertyStore，用于声明。 push 可能使引用失效，pop 销毁弹出的存储；仍有效的引用可观察后续提交。

Access the current scope's PropertyStore (const).

Access the current scope's RelationStore (mutable).

Access the current scope's RelationStore (const).

Check if a symbol has a specific sign (read-through all scopes).

Check if a symbol has at least the given domain specificity (read-through).

Get the most specific domain for a symbol (read-through).

Get all signs for a symbol (read-through).

Get parity for a symbol (read-through).

Get boundedness for a symbol (read-through).

Get interval bounds for a symbol (read-through).

仅查询周期声明元数据；不透明周期符号仍按非常量处理。

继承父作用域关系时排除被较近声明遮蔽的关系；仅使用已有关系，不构造跨作用域传递闭包。

Declare domain for a variable in the current scope. Returns an explicit error if the variable name is empty or contradictory.

Declares a domain and reports invalid or contradictory input.

Declare sign for a variable in the current scope. Returns an explicit error if the variable name is empty or contradictory.

Declares a sign and reports invalid or contradictory input.

Store a relational constraint. The expression's root must be a RelationalNode. Invalid or contradictory relations are returned as an explicit error.

Stores a relation and reports invalid or contradictory input.

Store a conditional assumption: if condition holds, conclude conclusion.

The conditional is stored in the current scope and discarded on scope pop. When a query depends on the conclusion, the system checks if the condition is satisfied by the current assumption state. If satisfied, the conclusion is used; if not verifiable, the conditional is inactive.

参数

condition	A relational expression (e.g., x > 1) serving as the guard
conclusion	A relational expression (e.g., ln(x) > 0) to use when condition holds Invalid or contradictory relations are returned as an explicit error.

Stores a guarded conclusion and reports invalid input.

A conditional assumption: "if condition then conclusion".

Retrieve all active conditional assumptions across all scopes (top to bottom).

Used by the QueryInterface/InferenceEngine to check if any conditional conclusions are applicable given the current assumption state.

返回

Vector of all conditional assumptions from all scopes (most recent first)

Evaluate whether a condition expression is satisfied by the current state.

Checks if the condition (a RelationalNode) can be verified against the current RelationStore and PropertyStore. Returns True if the condition is provably satisfied, False if provably unsatisfied, Unknown otherwise.

参数

condition

The condition expression to evaluate

返回

Tribool indicating whether the condition is satisfied

Query whether the expression is positive (> 0).

Queries positivity and propagates computation failures.

Query whether the expression is negative (< 0).

Queries negativity and propagates computation failures.

Query whether the expression is non-negative (>= 0).

Queries non-negativity and propagates computation failures.

Query whether the expression is real.

Queries real-domain membership and propagates computation failures.

Query whether the expression is an integer.

Queries integer-domain membership and propagates computation failures.

Query whether the expression is non-zero (!= 0).

Queries nonzero status and propagates computation failures.

Serialize the entire AssumptionContext to a human-readable string.

Format is line-oriented with SCOPE delimiters. Each scope's properties, relations, and conditionals are serialized one per line. The output ends with "END".

返回

Serialized string representation of all scopes.

Deserialize a string into a fully reconstructed AssumptionContext.

Parses the line-oriented format produced by serialize().

参数

data	Serialized string (as produced by serialize()).

返回

Reconstructed context or a parse/contradiction error.

面向不可信输入的受检反序列化接口,通过 CasError 传递格式与约束诊断.

Checked deserialization using the caller's resource and cancellation policy.

Query whether a symbol is continuous on a given interval (read-through all scopes).

参数

symbol	Symbol name to query.
interval	Interval on which to check continuity.

返回

True if continuous, False if not, Unknown if undetermined.

Queries interval continuity and propagates computation failures.

Query whether a symbol is differentiable on a given interval (read-through all scopes).

参数

symbol	Symbol name to query.
interval	Interval on which to check differentiability.

返回

True if differentiable, False if not, Unknown if undetermined.

Queries interval differentiability and propagates computation failures.

Query whether a symbol (matrix) is positive definite (read-through all scopes).

参数

symbol

Symbol name to query.

返回

True if positive definite, False if known not, Unknown if undetermined.

Queries positive definiteness and propagates computation failures.

Query whether a symbol (matrix) is positive semidefinite (read-through all scopes).

参数

symbol

Symbol name to query.

返回

True if positive semidefinite, False if known not, Unknown if undetermined.

Queries positive semidefiniteness and propagates computation failures.

Set the maximum recursion depth for inference queries.

This depth limit is wired to the InferenceEngine used by QueryInterface.

参数

depth

Maximum depth (must be > 0). Default is 32.

Get the current maximum recursion depth for inference queries.

返回

The configured maximum depth.

Maximum recursion depth for inference queries (default 32).

QueryInterface 观察到的缓存代数；存储提交采用惰性检测。

观察事务修订并返回当前缓存代数。

符号枚举

默认构造，值为 0

拷贝构造

移动构造

拷贝赋值

移动赋值

精确导入有符号机器整数，包括其最小值。

精确导入无符号机器整数，保留各数位的完整宽度。

从十进制字符串构造

参数

str	十进制数字字符串，可带正负号

异常

std::invalid_argument

若字符串为空、仅含符号或包含非十进制字符

转换为十进制字符串

返回

十进制表示的字符串

转换为 int（溢出时饱和到 int 范围）

返回

对应的 int 值

精确转换为 int64_t；超出范围时返回空。

精确转换非负值，负值或超出范围时失败。

返回绝对值的二进制位数，零的位数为 0。

转换为浮点数

返回

对应的 double 值

比较两个 BigInt 的绝对值

参数

a	第一个操作数
b	第二个操作数

返回

1 表示 |a|>|b|，-1 表示 |a|<|b|，0 表示相等

判断是否为零

获取 limb 数组的副本

返回

各 limb 值组成的 vector

计算哈希值

返回

哈希值

取绝对值

返回

|*this|

判断是否为负数

取相反数

返回

-*this

一元负号运算符

绝对值加法（内部使用）

参数

dst	结果
a	加数
b	加数

绝对值减法（内部使用，要求 |a| >= |b|）

参数

dst	结果
a	被减数
b	减数

加法运算符

减法运算符

乘法运算符

除法运算符（整数除法，截断）

参数

other

除数

返回

商

异常

std::domain_error

除数为零时抛出

取模运算符

参数

other

模数

返回

余数

异常

std::domain_error

模数为零时抛出

整数幂运算

参数

exp

非负指数

返回

this^exp

整数幂运算（BigInt 指数）

参数

exp	非负 BigInt 指数

返回

this^exp

异常

std::domain_error

指数为负时抛出

整数平方根（向下取整）

返回

floor(sqrt(*this))

异常

std::domain_error

负数时抛出

判断是否为奇数

判断是否为偶数

计算末尾零比特数

返回

二进制表示中末尾连续 0 的个数

右移赋值

参数

shift

移位比特数

返回

*this

左移赋值

参数

shift

移位比特数

返回

*this

右移运算符

左移运算符

计算阶乘

参数

n

非负整数

返回

n!

计算排列数 P(n, r)

参数

n	总数
r	选取数

返回

n! / (n-r)!

计算组合数 C(n, r)

参数

n	总数
r	选取数

返回

n! / (r! * (n-r)!)

计算多项式系数（多重组合数）

参数

n	总数（应等于 r 各元素之和）
r	各组大小

返回

n! / (r[0]! * r[1]! * ... * r[k]!)

异常

std::invalid_argument

r 之和不等于 n 时抛出

计算最大公约数

参数

a	第一个大整数
b	第二个大整数

返回

gcd(|a|, |b|)

计算最小公倍数

参数

a	第一个大整数
b	第二个大整数

返回

lcm(|a|, |b|)

Compute the canonical residue base^exp mod mod.

参数

base	Signed integer base.
exp	Nonnegative integer exponent.
mod	Strictly positive modulus.

返回

A value in the half-open interval [0,mod).

异常

std::domain_error

If exp is negative or mod is not positive.

判断整数的素性并保留无法证明的结论。 单个机器字使用确定性判定；较大整数发现合数证据时返回 false， 尚无法证明素性时返回 CasErrc::Inconclusive。

判断是否为完全平方数

返回

是完全平方数返回 true

构造具有非空表达式的规范空有限集。

快照输入包装对象，后续赋值保持集合成员不变。

返回由规范有限集表达式派生的只读包装视图。

< 项列表

< 变量个数

默认构造

构造指定变量数的零多项式

参数

n

变量个数

判断是否为零多项式

获取首项单项式

获取首项系数

添加一项

参数

m	单项式
c	系数(零系数不添加)

按指定单项式序排序各项

参数

order

单项式序

合并同类项并去除零项

对给定基进行多项式约化

参数

basis	Gröbner 基
order	单项式序

返回

约化后的余式

从单项式构造多项式(系数为 1)

参数

m	单项式
num_vars	变量个数

返回

仅含一项的多项式

构造零多项式

参数

num_vars

变量个数

返回

零多项式

单个分段:条件 + 对应解集

< 参数满足的条件

< 该条件下的解集

< 所有分段

判断结果是否为空

返回

无分段时返回 true

判断是否只有一个分段

返回

恰好一个分段时返回 true

获取唯一分段的解集

is_single() 为真时返回该分段;多分段解依赖参数取值, 因而映射为空集以完整保留分段语义.

返回

单一分段的解集;多分段结果映射为空集

在计算上下文预算内求解精确有理系数的单变量多项式不等式。

注解

近似系数或符号参数返回 CasErrc::Inconclusive。

Solve a conjunction of inequalities through the checked solver.

Every component must lie in the checked scalar support domain and every required endpoint comparison must be exact. An empty conjunction denotes the entire real line.

求解单个不等式

参数

expr	不等式左端表达式(右端为 0)
type	不等式类型
variable	求解变量名

返回

解集

Exact quadratic coefficients are converted to numerical roots with a cancellation-resistant quadratic formula. Integer snapping requires an exactly integral approximation, and exact roots are deduplicated symbolically rather than by a fixed floating-point distance before the sign chart is constructed. Prefer solve_inequality_checked() when a proved exact result is required.

求解不等式组(取交集)

参数

inequalities	不等式列表,每项为 (表达式, 不等式类型)
variable	求解变量名

返回

解集

求解有理不等式 numerator/denominator >/< 0

参数

numerator	分子表达式
denominator	分母表达式
type	不等式类型
variable	求解变量名

返回

解集

在计算上下文预算内求解可证明的参数多项式不等式。

注解

无法证明完整参数分支时返回 CasErrc::Inconclusive。

< 端点值（无穷时为空）

< 是否为开端点

< 是否为负无穷

< 是否为正无穷

构造负无穷端点

返回

负无穷端点

构造正无穷端点

返回

正无穷端点

构造闭端点

参数

val

端点值

返回

闭端点

构造开端点

参数

val

端点值

返回

开端点

< 下端点

< 上端点

判断数值是否在区间内

参数

value

待判断的数值

返回

包含返回 true

判断区间是否为空

返回

空区间返回 true

判断区间是否为整条实数轴

返回

是整条实数轴返回 true

构造空区间

返回

空区间

构造整条实数轴 (-∞, +∞)

返回

全实数轴区间

构造单点区间 [val, val]

参数

val

点值

返回

单点区间

从区间列表构造并集

参数

intervals

区间列表

从单个区间构造并集

参数

iv

区间

返回

包含单个区间的并集

Validate and construct an interval union with an explicit context.

Validate and construct an interval union with a default context.

构造空集

返回

空的区间并集

构造全实数轴

返回

表示 (-∞, +∞) 的并集

与另一个并集求交

参数

other

另一个区间并集

返回

交集结果

Checked intersection with explicit endpoint-validation errors.

参数

other	另一个区间并集
context	计算上下文和资源预算

返回

成功时返回交集；端点不可比较或资源耗尽时返回错误

与另一个并集求并

参数

other

另一个区间并集

返回

并集结果

Checked union with exact endpoint ordering.

参数

other	另一个区间并集
context	计算上下文和资源预算

返回

成功时返回并集；端点不可比较或资源耗尽时返回错误

求补集

返回

补集结果

Checked complement with exact endpoint ordering.

参数

context

计算上下文和资源预算

返回

成功时返回补集；端点不可比较或资源耗尽时返回错误

判断数值是否在并集内

参数

value

待判断的数值

返回

包含返回 true

判断并集是否为空

返回

空集返回 true

判断并集是否为全实数轴

返回

是全实数轴返回 true

获取内部区间列表

返回

区间列表的常引用

转换为字符串表示

返回

区间并集的字符串形式

从规范字符串解析数值端点区间并集

参数

str	区间表示；端点支持任意精度十进制整数、精确分数和有限浮点数

返回

解析及区间规范化成功时返回并集；无效输入返回 nullopt

转换为符号表达式

参数

var

变量名

返回

表示该区间并集的符号表达式；空集为有限空集，全实数域为恒真关系

负被开方数返回 DomainError；预算耗尽时返回错误，保持精确性。

认证符号，成功值为 Negative、Zero 或 Positive。

计算经过认证的绝对值。

异常

std::domain_error	对应 DomainError。
std::length_error	对应 ResourceLimit。
std::logic_error	对应 InternalInvariant。
std::runtime_error	对应其余受检失败（包括 Inconclusive、Cancelled），附带原因。

用任意精度整数保存数学指数与被开方数。

将模式与目标表达式进行匹配

参数

pattern	模式表达式
target	目标表达式
wildcards	模式中的通配符名称集合
results	匹配成功时输出绑定结果

返回

匹配成功返回 true

将绑定结果代入模板表达式

参数

template_expr	模板表达式
bindings	通配符绑定映射
use_rest	是否使用剩余项替换

返回

替换后的表达式

< 匹配模式

< 替换模板

< 通配符集合

< 附加匹配条件（可选）

使用匹配绑定与假设上下文检查附加条件。

两个条件均存在时须同时成立；缺少上下文时跳过规则并保留回调未调用的状态。

添加重写规则

参数

rule

规则对象

反复应用规则直到不动点或达到最大迭代次数

参数

expr	输入表达式
max_iterations	最大迭代次数

返回

重写后的表达式

对表达式应用一步重写

参数

expr

输入表达式

返回

重写后的表达式，若无规则匹配则返回原表达式

获取当前所有规则

返回

规则列表的常引用

项类型：(单项式, 系数)

构造零多项式

从项列表和变量名列表构造多元多项式

参数

[in]	terms	项列表，每项为 (单项式, 系数) 对
[in]	vars	变量名列表，确定各分量对应的变量
[in]	order	单项式序类型，默认分次逆字典序

从常数构造多元多项式

参数

[in]	constant	常数值
[in]	vars	变量名列表

— 算术运算 —

多项式加法

多项式减法

多项式乘法

一元取负

同一变量表内按系数和单项式判等，不受单项式序影响

返回

两个零多项式始终相等；非零对象的变量表不同时返回 false

判不等

标量乘法

参数

[in]

scalar

有理数标量

返回

各项系数乘以 scalar 后的多项式

精确除法（假设整除）

参数

[in]

divisor

除数多项式

返回

商多项式 同一变量表允许不同单项式序；结果使用被除数的序。 零被除数的商使用除数的变量表和序。

异常

std::runtime_error	除数为零或不整除时抛出
std::invalid_argument	两个非零操作数的变量表或排列不同时抛出

— 求值 —

将指定变量代入有理数值，返回降维后的多项式

参数

[in]	var	待代入的变量名
[in]	val	代入值

返回

代入后的多项式（变量数减一或不变）

将多个变量同时代入有理数值

参数

[in]

substitution

变量名到值的映射

返回

代入后的多项式

— 度数查询 —

计算多项式的全次数

返回

所有项中单项式全次数的最大值；零多项式返回 -1

计算关于指定变量的次数

参数

[in]

var

变量名

返回

该变量在所有项中指数的最大值；零多项式返回 -1

获取关于指定变量的首项系数

将多项式视为 var 的一元多项式，返回最高次项的系数（为辅助变量的多项式）。

参数

[in]

var

主变量名

返回

首项系数多项式

— 转换 —

转换为一元 Polynomial<Rational>

仅当多项式实际只含一个变量时有效。

返回

对应的一元多项式

异常

std::invalid_argument

含多个有效变量时抛出

从一元多项式构造多元多项式

参数

[in]	poly	一元多项式
[in]	var	对应的变量名

返回

等价的 MultiPoly 表示

— 属性查询 —

判断是否为零多项式

判断是否为常数多项式

判断是否实质为一元多项式（仅一个变量出现非零指数）

判断是否为齐次多项式（所有项全次数相同）

获取非零项数

获取变量个数

获取变量名列表

返回

变量名列表的常引用

获取项列表

返回

有序项列表的常引用

— 工具方法 —

提取数值内容（所有系数的 GCD）

返回

所有系数绝对值的最大公约数（有理数形式）

使多项式本原化（除以数值内容）

返回

本原多项式（数值内容为 1）

转换为可读字符串表示

返回

多项式的字符串形式

< 有序项列表（按 order_ 降序）

< 变量名列表

< 单项式序类型

规范化：合并同类项、去零项、按单项式序排序

求解含参方程组，返回所有解

参数

equations	方程列表（每个表达式 = 0）
unknowns	未知数名称列表
parameters	参数名称列表

返回

解的列表，每个解为变量名到表达式的映射

求解含参方程组，返回按参数条件分段的解

参数

equations	方程列表（每个表达式 = 0）
unknowns	未知数名称列表
parameters	参数名称列表

返回

分段解集

求解关于未知数为线性的含参方程组

求解关于未知数为多项式的含参方程组

判断方程组是否关于未知数为线性

参数

equations	方程列表
unknowns	未知数名称列表

返回

线性返回 true

成功提交（含赋值）均更新此存储的修订号。

Declare domain for a symbol and report contradictions.

Declares a domain and reports contradictions.

Declare sign for a symbol and report contradictions.

Declares a sign and reports contradictions.

Declare parity for a symbol and report contradictions.

Declares parity and reports contradictions.

Declare boundedness for a symbol, optionally with interval bounds.

Declares boundedness and reports contradictions.

Query the most specific domain for a symbol (default: Complex).

Query all signs stored for a symbol.

Query parity for a symbol (default: Unknown).

Query boundedness for a symbol (default: Unknown).

Get stored interval bounds (if any).

Check if symbol has a specific sign (explicit or implied).

Check if symbol has at least the given domain specificity.

Declare a symbol as continuous on a specified interval.

参数

symbol	Symbol name.
interval	Interval on which continuity holds. Contradictory overlapping declarations are returned as CasError.

Declare a symbol as differentiable on a specified interval.

Differentiability implies continuity, so this also ensures the symbol is recorded as continuous on the same interval.

参数

symbol	Symbol name.
interval	Interval on which differentiability holds. Contradictory overlapping declarations are returned as CasError.

Query whether a symbol is continuous on a given interval.

参数

symbol	Symbol name.
interval	Interval to check.

返回

true if the symbol has been declared continuous (or differentiable) on an interval that covers the queried interval.

Query whether a symbol is differentiable on a given interval.

参数

symbol	Symbol name.
interval	Interval to check.

返回

true if the symbol has been declared differentiable on an interval that covers the queried interval.

Declare a symbol as transcendental.

Sets the symbol's domain to Real and marks it transcendental. Returns an error if the symbol already has an algebraic sub-domain.

参数

symbol

Symbol name

Declares transcendence and reports domain contradictions.

Query whether a symbol has been declared transcendental.

参数

symbol

Symbol name

返回

true if the symbol is marked transcendental

Declare finiteness for a symbol.

Finite implies Bounded. Contradictions are returned as CasError.

参数

symbol	Symbol name
f	Finiteness value (Finite, Divergent, or Unknown)

Declares finiteness and reports contradictions.

Query the finiteness classification of a symbol.

参数

symbol

Symbol name

返回

Finiteness value (default: Unknown)

Declare matrix definiteness for a symbol.

PositiveDefinite implies PositiveSemiDefinite. NegativeDefinite implies NegativeSemiDefinite. Contradictions are returned as CasError.

参数

symbol	Symbol name
d	Definiteness value

Declares matrix definiteness and reports contradictions.

Query the definiteness classification of a symbol.

参数

symbol

Symbol name

返回

Definiteness value (default: Unknown)

声明符号关于指定变量的候选周期。

参数

symbol	符号名
variable	非空自变量名
period	非空候选周期；已知非正值会被拒绝。

Declares periodicity and reports invalid periods.

获取符号关于指定变量声明的候选周期。

使用者须证明符号周期为正实数，且相对于该自变量为常量。

查询周期声明是否存在；符号周期的有效性需另行证明。

借用按变量索引的全部声明，用于确定性序列化。

Get all symbol names that have any declared properties.

返回

Vector of symbol names with at least one non-default property.

Continuity declaration (public type for serialization access).

Monotonicity declaration (public type for serialization access).

Get all continuity/differentiability declarations for a symbol.

参数

symbol

Symbol name.

返回

Vector of continuity declarations.

Get all monotonicity declarations for a symbol.

参数

symbol

Symbol name.

返回

Vector of monotonicity declarations.

Declare monotonicity of a symbol with respect to a variable on an interval.

Stores a MonotonicityDecl recording that the symbol is monotonically increasing/decreasing (or non-decreasing/non-increasing) with respect to the given variable over the specified interval.

参数

symbol	The symbol (expression name) being declared monotone.
variable	The variable with respect to which monotonicity holds.
interval	The interval on which the monotonicity property holds.
mono	The type of monotonicity (Increasing, Decreasing, etc.).

Query the monotonicity of a symbol with respect to a variable on an interval.

Searches stored MonotonicityDecl entries for the symbol. Returns the monotonicity type if the queried interval is covered by a stored declaration (i.e., the stored interval contains the queried interval), otherwise returns Monotonicity::Unknown.

参数

symbol	The symbol to query.
variable	The variable with respect to which monotonicity is queried.
interval	The interval to check coverage for.

返回

The monotonicity type if covered, or Monotonicity::Unknown.

Whether the symbol is classified as transcendental.

Finiteness classification (Finite, Divergent, or Unknown).

Matrix definiteness classification.

按自变量索引的候选周期。

Continuity declaration over an interval.

< Interval on which continuity/differentiability holds

< True if differentiable (implies continuous)

Declared continuity/differentiability intervals.

Monotonicity declaration with respect to a variable over an interval.

< Variable with respect to which monotonicity holds

< Interval on which monotonicity holds

< Type of monotonicity

Declared monotonicity intervals.

Check domain-sign cross-constraints. Throws on contradiction.

Check sign contradiction pairs. Throws on contradiction.

Get all signs implied by a given sign.

Get the specificity level of a domain (higher = more specific).

默认构造，值为 0

从 BigInt 构造整数有理数

参数

num

分子（分母为 1）

从分子分母构造有理数

参数

num	分子
den	分母（不可为零）

从 int 构造整数有理数

参数

num

整数值

从 int 分子分母构造有理数

参数

num	分子
den	分母

从字符串构造有理数，支持小数、科学计数法、循环小数

参数

num

数字字符串

从 double 构造精确有理数。

参数

value

有限的 binary64 浮点数值

返回

binary64 存储值对应的精确有理数，而非十进制显示文本的值

异常

std::invalid_argument

若 value 为 NaN 或无穷大

获取分子

获取分母

判断是否为整数（分母为 1）

判断是否为零

计算哈希值

返回

哈希值

转换为分数字符串（如 "3/4"）

返回

字符串表示

转换为十进制小数字符串（自动检测循环节）

返回

小数字符串，循环部分用括号标记

转换为指定精度的十进制小数字符串

参数

n	小数位数（正数为小数点后位数，负数为整数部分截断位数）

返回

定精度小数字符串

就地向零截断到指定十进制精度，区别于数学下取整。

参数

n	正数为小数位，零为整数位，负数为十进制整数位

异常

std::length_error

|n| 超过 1,000,000 时抛出，原值不变

牛顿迭代法计算平方根（就地修改）

参数

n

精度位数

计算平方根（返回新值）

参数

n

精度位数

返回

平方根的有理近似

牛顿迭代法计算 n 次方根（就地修改）

参数

radical	根次数
n	精度位数

计算 n 次方根（返回新值）

参数

radical	根次数
n	精度位数

返回

n 次方根的有理近似

转换为 BigInt（仅当为整数时有效）

返回

对应的 BigInt

异常

std::runtime_error

非整数时抛出

转换为浮点数。

精确值可按 binary64 round-to-nearest 转为有限值时返回有限结果， 包括正负最大有限端点及其半 ULP 内邻域； 超出有限舍入范围或非零值下溢为零时抛出范围异常。

返回

对应的 double 值

有理数加法

有理数减法

有理数乘法

有理数除法

参数

other

除数

返回

商

异常

std::runtime_error

除数为零时抛出

有理数整数幂

参数

exponent

指数（可为负）

返回

this^exponent

异常

std::runtime_error

零的负幂或 0^0 时抛出

有理数的有理数幂（就地修改）

参数

exponent	有理数指数
n	精度位数

有理数的有理数幂（返回新值）

参数

exponent	有理数指数
n	精度位数

返回

结果的有理近似

取倒数

返回

1 / *this

异常

std::runtime_error

零的倒数时抛出

取绝对值

返回

|*this|

一元负号运算符

成功提交（含赋值）均更新此存储的修订号。

Store a relation and optionally derive sign properties.

If the relation compares one variable with exact zero, the corresponding sign property is declared on the PropertyStore.

参数

lhs	Left-hand side expression
rhs	Right-hand side expression
op	Relational operator
prop_store	PropertyStore to notify for simple variable > 0 patterns

Checked relation insertion with explicit failure reporting.

Applies the relation plus derived property declarations transactionally. On failure, neither this store nor the PropertyStore is modified.

Retrieve all stored relations.

返回

Const reference to the vector of stored relations

Check if a specific relation is stored.

Compares LHS, RHS, and operator using structural equality of the AST nodes.

参数

lhs	Left-hand side expression
rhs	Right-hand side expression
op	Relational operator

返回

true if the relation is found in the store

Clear all stored relations (used during scope pop).

Maximum number of new relations deduced per add_relation call via transitive closure.

新增关系后计算传递闭包。

从新关系开始 BFS，仅对 GT、GEQ 进行传递组合： GT+GT→GT、GT+GEQ→GT、GEQ+GT→GT、GEQ+GEQ→GEQ。 最多新增 MAX_TRANSITIVE_DEDUCTIONS 个结论，之后仍登记已有结论的替代证明。

参数

new_relation	触发本轮闭包计算的关系索引
prop_store	用于推导关系符号的属性存储

返回

本轮是否新增结论或替代证明。

求解线性方程组。

参数

equations	方程列表（每个方程视为等于零的表达式）
variables	待求解的变量名列表

返回

变量名到解表达式的映射

计算多项式集合的 Gröbner 基。

参数

polynomials	输入多项式列表
variables	变量名列表（决定单项式序）

返回

Gröbner 基多项式列表

求解多项式方程组，显式报告失败。

计算约化 Gröbner 基。

参数

polynomials	输入多项式列表
variables	变量名列表

返回

约化 Gröbner 基多项式列表

判断多项式是否属于给定 Gröbner 基生成的理想。

参数

polynomial	待检测的多项式
basis	Gröbner 基
variables	变量名列表

返回

若多项式属于该理想则返回 true

计算消元理想，消去前 elim_count 个变量。

参数

basis	Gröbner 基
variables	变量名列表（前 elim_count 个将被消去）
elim_count	要消去的变量数量

返回

消元理想的生成元列表

值的类型枚举

< 当前值的类型

内部存储的 variant 类型

< 实际存储的数据

返回只读类型标记。

返回只读底层存储，调用方不能破坏类型不变量。

默认构造,初始化为 Null

字符串使用独立的 Type::String 标记,与 Null 保持类型区分.

Checked conversion to a floating-point value.

Checked conversion to a rational value.

Checked conversion to an irrational-value wrapper.

Checked conversion to a symbolic expression.

判断值是否可转换为符号表达式

返回

若可转换则返回 true

将值转换为可读字符串

返回

格式化的字符串表示

Checked element-wise vector addition.

Checked vector dot product.

Checked matrix multiplication.

< 字符串构造时的缓存(兼容旧测试)

在文件 assumption_context.hpp 第 1 行定义.

                                  {
public:
    AssumptionContext();
    AssumptionContext(const AssumptionContext&) = default;
    AssumptionContext(AssumptionContext&& other);
    AssumptionContext& operator=(const AssumptionContext& other);
    AssumptionContext& operator=(AssumptionContext&& other) noexcept;
 
 
    // --- Scope management ---
 
    /// Push a new scope onto the stack.
    void push();
 
    /// Pop the current scope.
    AssumptionVoidResult pop();
 
    /// Return the current nesting depth (number of scopes on the stack).
    int depth() const;
 
    // --- Direct access to current (top) scope stores ---
 
    /**
     * @brief 访问当前作用域可修改的 PropertyStore，用于声明。
     * push 可能使引用失效，pop 销毁弹出的存储；仍有效的引用可观察后续提交。
     */
    PropertyStore& current_properties();
 
    /// Access the current scope's PropertyStore (const).
    const PropertyStore& current_properties() const;
 
    /// Access the current scope's RelationStore (mutable).
    RelationStore& current_relations();
 
    /// Access the current scope's RelationStore (const).
    const RelationStore& current_relations() const;
 
    // --- Read-through query methods ---
    // These search from the top scope down to root, returning the first
    // scope's value that has a declaration for the symbol. This provides
    // shadowing semantics: child declarations override parent declarations.
 
    /// Check if a symbol has a specific sign (read-through all scopes).
    bool has_sign(const std::string& symbol, Sign sign) const;
 
    /// Check if a symbol has at least the given domain specificity (read-through).
    bool has_domain(const std::string& symbol, Domain domain) const;
 
    /// Get the most specific domain for a symbol (read-through).
    Domain get_domain(const std::string& symbol) const;
 
    /// Get all signs for a symbol (read-through).
    std::unordered_set<Sign, SignHash> get_signs(const std::string& symbol) const;
 
    /// Get parity for a symbol (read-through).
    Parity get_parity(const std::string& symbol) const;
 
    /// Get boundedness for a symbol (read-through).
    Boundedness get_boundedness(const std::string& symbol) const;
 
    /// Get interval bounds for a symbol (read-through).
    std::optional<Interval> get_bounds(const std::string& symbol) const;
 
    bool is_transcendental(const std::string& symbol) const;
    Finiteness get_finiteness(const std::string& symbol) const;
    Definiteness get_definiteness(const std::string& symbol) const;
    std::optional<SymbolicExpr> get_period(
        const std::string& symbol, const std::string& variable) const;
    bool is_periodic(const std::string& symbol, const std::string& variable) const;
    /** @brief 仅查询周期声明元数据；不透明周期符号仍按非常量处理。 */
    bool has_period_declarations(const std::string& symbol) const;
    Result<Monotonicity> get_monotonicity_checked(
        const std::string& symbol, const std::string& variable,
        const Interval& interval) const;
 
    /** @brief 继承父作用域关系时排除被较近声明遮蔽的关系；仅使用已有关系，不构造跨作用域传递闭包。 */
    bool has_relation(const SymbolicExpr& lhs, const SymbolicExpr& rhs, RelationOp op) const;
    std::vector<Relation> get_visible_relations() const;
    Result<bool> has_relation_checked(
        const SymbolicExpr& lhs, const SymbolicExpr& rhs, RelationOp op,
        ComputationContext& context) const;
    Result<std::vector<Relation>> get_visible_relations_checked(
        ComputationContext& context) const;
 
    /// Declare domain for a variable in the current scope.
    /// Returns an explicit error if the variable name is empty or contradictory.
    AssumptionVoidResult assume_domain(const std::string& variable, Domain domain);
 
    /** @brief Declares a domain and reports invalid or contradictory input. */
    AssumptionVoidResult assume_domain_checked(const std::string& variable, Domain domain);
 
    /// Declare sign for a variable in the current scope.
    /// Returns an explicit error if the variable name is empty or contradictory.
    AssumptionVoidResult assume_sign(const std::string& variable, Sign sign);
 
    /** @brief Declares a sign and reports invalid or contradictory input. */
    AssumptionVoidResult assume_sign_checked(const std::string& variable, Sign sign);
 
    /// Store a relational constraint. The expression's root must be a RelationalNode.
    /// Invalid or contradictory relations are returned as an explicit error.
    AssumptionVoidResult assume(const SymbolicExpr& relation);
 
    /** @brief Stores a relation and reports invalid or contradictory input. */
    AssumptionVoidResult assume_checked(const SymbolicExpr& relation);
 
    /**
     * @brief Store a conditional assumption: if condition holds, conclude conclusion.
     *
     * The conditional is stored in the current scope and discarded on scope pop.
     * When a query depends on the conclusion, the system checks if the condition
     * is satisfied by the current assumption state. If satisfied, the conclusion
     * is used; if not verifiable, the conditional is inactive.
     *
     * @param condition  A relational expression (e.g., x > 1) serving as the guard
     * @param conclusion A relational expression (e.g., ln(x) > 0) to use when condition holds
     * Invalid or contradictory relations are returned as an explicit error.
     */
    AssumptionVoidResult assume_conditional(const SymbolicExpr& condition, const SymbolicExpr& conclusion);
 
    /** @brief Stores a guarded conclusion and reports invalid input. */
    AssumptionVoidResult assume_conditional_checked(
        const SymbolicExpr& condition,
        const SymbolicExpr& conclusion);
 
    /**
     * @brief A conditional assumption: "if condition then conclusion".
     */
    struct ConditionalAssumption {
        SymbolicExpr condition;
        SymbolicExpr conclusion;
    };
 
    /**
     * @brief Retrieve all active conditional assumptions across all scopes (top to bottom).
     *
     * Used by the QueryInterface/InferenceEngine to check if any conditional
     * conclusions are applicable given the current assumption state.
     *
     * @return Vector of all conditional assumptions from all scopes (most recent first)
     */
    std::vector<ConditionalAssumption> get_active_conditionals() const;
 
    /**
     * @brief Evaluate whether a condition expression is satisfied by the current state.
     *
     * Checks if the condition (a RelationalNode) can be verified against the
     * current RelationStore and PropertyStore. Returns True if the condition
     * is provably satisfied, False if provably unsatisfied, Unknown otherwise.
     *
     * @param condition The condition expression to evaluate
     * @return Tribool indicating whether the condition is satisfied
     */
    Tribool evaluate_condition(const SymbolicExpr& condition) const;
 
    // --- Expression property queries ---
 
    /// Query whether the expression is positive (> 0).
    AssumptionTriboolResult is_positive(const SymbolicExpr& expr) const;
 
    /** @brief Queries positivity and propagates computation failures. */
    AssumptionTriboolResult is_positive_checked(const SymbolicExpr& expr) const;
    AssumptionTriboolResult is_positive_checked(
        const SymbolicExpr& expr, ComputationContext& context) const;
 
    /// Query whether the expression is negative (< 0).
    AssumptionTriboolResult is_negative(const SymbolicExpr& expr) const;
 
    /** @brief Queries negativity and propagates computation failures. */
    AssumptionTriboolResult is_negative_checked(const SymbolicExpr& expr) const;
    AssumptionTriboolResult is_negative_checked(
        const SymbolicExpr& expr, ComputationContext& context) const;
 
    /// Query whether the expression is non-negative (>= 0).
    AssumptionTriboolResult is_nonnegative(const SymbolicExpr& expr) const;
 
    /** @brief Queries non-negativity and propagates computation failures. */
    AssumptionTriboolResult is_nonnegative_checked(const SymbolicExpr& expr) const;
    AssumptionTriboolResult is_nonnegative_checked(
        const SymbolicExpr& expr, ComputationContext& context) const;
 
    /// Query whether the expression is real.
    AssumptionTriboolResult is_real(const SymbolicExpr& expr) const;
 
    /** @brief Queries real-domain membership and propagates computation failures. */
    AssumptionTriboolResult is_real_checked(const SymbolicExpr& expr) const;
    AssumptionTriboolResult is_real_checked(
        const SymbolicExpr& expr, ComputationContext& context) const;
 
    /// Query whether the expression is an integer.
    AssumptionTriboolResult is_integer(const SymbolicExpr& expr) const;
 
    /** @brief Queries integer-domain membership and propagates computation failures. */
    AssumptionTriboolResult is_integer_checked(const SymbolicExpr& expr) const;
    AssumptionTriboolResult is_integer_checked(
        const SymbolicExpr& expr, ComputationContext& context) const;
 
    /// Query whether the expression is non-zero (!= 0).
    AssumptionTriboolResult is_nonzero(const SymbolicExpr& expr) const;
 
    /** @brief Queries nonzero status and propagates computation failures. */
    AssumptionTriboolResult is_nonzero_checked(const SymbolicExpr& expr) const;
    AssumptionTriboolResult is_nonzero_checked(
        const SymbolicExpr& expr, ComputationContext& context) const;
 
    /**
     * @brief Serialize the entire AssumptionContext to a human-readable string.
     *
     * Format is line-oriented with SCOPE delimiters. Each scope's properties,
     * relations, and conditionals are serialized one per line. The output ends
     * with "END".
     *
     * @return Serialized string representation of all scopes.
     */
    std::string serialize() const;
 
    /**
     * @brief Deserialize a string into a fully reconstructed AssumptionContext.
     *
     * Parses the line-oriented format produced by serialize().
     *
     * @param data Serialized string (as produced by serialize()).
     * @return Reconstructed context or a parse/contradiction error.
     */
    static Result<AssumptionContext> deserialize(const std::string& data);
 
    /// 面向不可信输入的受检反序列化接口,通过 CasError 传递格式与约束诊断.
    static Result<AssumptionContext> deserialize_checked(const std::string& data);
    /// Checked deserialization using the caller's resource and cancellation policy.
    static Result<AssumptionContext> deserialize_checked(
        const std::string& data, ComputationContext& context);
 
    /**
     * @brief Query whether a symbol is continuous on a given interval (read-through all scopes).
     * @param symbol Symbol name to query.
     * @param interval Interval on which to check continuity.
     * @return True if continuous, False if not, Unknown if undetermined.
     */
    AssumptionTriboolResult is_continuous(const std::string& symbol, const Interval& interval) const;
 
    /** @brief Queries interval continuity and propagates computation failures. */
    AssumptionTriboolResult is_continuous_checked(
        const std::string& symbol,
        const Interval& interval) const;
 
    /**
     * @brief Query whether a symbol is differentiable on a given interval (read-through all scopes).
     * @param symbol Symbol name to query.
     * @param interval Interval on which to check differentiability.
     * @return True if differentiable, False if not, Unknown if undetermined.
     */
    AssumptionTriboolResult is_differentiable(const std::string& symbol, const Interval& interval) const;
 
    /** @brief Queries interval differentiability and propagates computation failures. */
    AssumptionTriboolResult is_differentiable_checked(
        const std::string& symbol,
        const Interval& interval) const;
 
    /**
     * @brief Query whether a symbol (matrix) is positive definite (read-through all scopes).
     * @param symbol Symbol name to query.
     * @return True if positive definite, False if known not, Unknown if undetermined.
     */
    AssumptionTriboolResult is_positive_definite(const std::string& symbol) const;
 
    /** @brief Queries positive definiteness and propagates computation failures. */
    AssumptionTriboolResult is_positive_definite_checked(const std::string& symbol) const;
 
    /**
     * @brief Query whether a symbol (matrix) is positive semidefinite (read-through all scopes).
     * @param symbol Symbol name to query.
     * @return True if positive semidefinite, False if known not, Unknown if undetermined.
     */
    AssumptionTriboolResult is_positive_semidefinite(const std::string& symbol) const;
 
    /** @brief Queries positive semidefiniteness and propagates computation failures. */
    AssumptionTriboolResult is_positive_semidefinite_checked(const std::string& symbol) const;
 
    /**
     * @brief Set the maximum recursion depth for inference queries.
     *
     * This depth limit is wired to the InferenceEngine used by QueryInterface.
     * @param depth Maximum depth (must be > 0). Default is 32.
     */
    void set_max_query_depth(int depth);
 
    /**
     * @brief Get the current maximum recursion depth for inference queries.
     * @return The configured maximum depth.
     */
    int get_max_query_depth() const;
 
private:
    friend class detail::AssumptionFacts;
 
    static AssumptionContext deserialize_impl(
        const std::string& data, ComputationContext& context);
 
    struct Scope {
        PropertyStore properties;
        RelationStore relations;
        std::vector<ConditionalAssumption> conditionals;
        mutable std::uint64_t observed_property_revision = 0;
        mutable std::uint64_t observed_relation_revision = 0;
    };
 
    std::vector<Scope> scope_stack_;
    struct RelationShadowing;
    RelationShadowing collect_relation_shadowing(
        std::size_t scope, detail::RewriteBudget& budget) const;
    static bool relation_shadowed(
        const Relation& relation, const RelationShadowing& shadowing,
        detail::RewriteBudget& budget);
    std::vector<bool> relation_visibility(
        std::size_t scope, detail::RewriteBudget& budget) const;
    Result<bool> has_relation_in_scope(
        std::size_t scope, const SymbolicExpr& lhs, const SymbolicExpr& rhs,
        RelationOp op, detail::RewriteBudget& budget) const;
 
    /// Maximum recursion depth for inference queries (default 32).
    int max_query_depth_ = 32;
 
    /** @brief QueryInterface 观察到的缓存代数；存储提交采用惰性检测。 */
    mutable uint64_t cache_generation_ = 0;
 
public:
    /** @brief 观察事务修订并返回当前缓存代数。 */
    uint64_t cache_generation() const;
};

__attribute__() [2/4]

LMCAS::__attribute__ ( (visibility("default")) ) const &

noexcept

Berlekamp 模素数分解(内部接口).

计算三个三维向量的混合积 a·(b×c)。

计算两个向量夹角 arccos(a·b / (|a|·|b|))。

计算向量 a 在向量 b 上的标量投影 a·b / |b|。

计算向量 a 在向量 b 上的投影向量 proj_b(a) = (a·b / b·b)·b。

计算两个三维向量的叉积 a×b。

计算两个向量的点积 a·b = ∑aᵢbᵢ。

使用默认计算上下文计算斯托克斯定理曲面积分，并显式报告无效输入和未覆盖域。

斯托克斯定理：计算 ∬_S (∇×F)·dS。

使用默认计算上下文计算散度定理体积分，并显式报告无效输入和未覆盖域。

散度定理（高斯定理）：计算 ∭_V ∇·F dV。

使用默认计算上下文计算格林面积公式，并显式报告无效输入和未覆盖域。

格林定理：计算 ∬_R (∂Q/∂x - ∂P/∂y) dA。

用默认上下文计算第二类曲面积分，报告无效输入与未覆盖域。

计算第一类曲面积分（标量场在曲面上的积分）。

使用默认上下文计算旋度；无效输入返回错误。

计算向量场的旋度 ∇×F。

使用默认上下文计算散度；无效输入返回错误。

计算标量函数的梯度 ∇f。

使用默认上下文计算第二类曲线积分，报告无效输入与未覆盖域。

计算第一类曲线积分（标量场沿曲线的积分）。

Constructs an immutable finite set with structural deduplication.

计算曲面在某点的切平面。

计算曲面在某点的单位法向量 ∇F/|∇F|。

对二次曲面进行分类。 对称特征分解将含混合项的二次型旋转到主轴，再完成平方， 依据中心常数和惯性判定实数轨迹。零空间线性分量采用逐主轴点积误差界， 使抛物方向的判定独立于其他轴的大系数；秩一非中心二次型归为抛物柱面。 非零特征值落入特征分解反向误差界时返回 Inconclusive，保持原秩； 空集、单点、直线和平面对按退化情形处理。

由两点构造直线。

计算点到平面的距离。

计算直线与平面的交点。

将极坐标形式转换为指数形式复数 r*e^(i*theta)

计算复数的辐角

计算复数的模

计算复数的共轭

复数除法

复数乘法

复数减法

复数加法

成功时返回恒等、非恒等或未知分类，计算错误由外层 Result 返回。 假设可辅助恒等规则；形式非恒等与点值事实分别判定，未知分类仍属成功返回。

Attaches a declared unit to a scalar symbolic expression.

证明表达式是精确的一元有理系数多项式。

Return the positive coefficient content of an exact rational polynomial.

Compute the monic GCD of two exact rational multivariate polynomials.

Evaluate a real expression using explicit symbol bindings and a computation context.

多元无平方因子分解

计算多元多项式 GCD

计算多元本原部分

内部算法组件（供测试使用）

受检精确多元因式分解.

将有限值与有符号无穷极限投影为表达式。 DoesNotExist 转为 Inconclusive，表达式载荷仅承载极限值。

证明单侧极限，并在有限点合并两侧结果。 两侧已证极限不相容时返回 LimitDoesNotExist；证明不足时返回 Inconclusive。 资源与取消错误原样保留。无穷点表示尾部趋近，仅有一种趋近方向。 Domain::Real 保留实分支与有定义性约束。 Domain::Complex 在支持的分支切割之外用连续性证明有限极限； 已证去心邻域有定义时也支持多项式分母的可去奇点，要求方向为 Both、极限点有限， 并采用复域邻域语义。 成功认证的是上下文假设下的带标签结果，可能为无穷或极限不存在。 有限单侧值按指定域逐点比较；残差非恒等于零仍可能在部分允许参数值处为零。 恒等式认证相等前须证明有定义性；参数比较未知时返回 Inconclusive。

Checked emptiness decision for an interval.

Checked numeric membership test for an interval.

计算多项式关于基的标准形(余式)

Explicitly evaluate an expression as a finite complex value.

Construct the complex modulus in square-sum form.

计算多项式的无平方因子部分.

在计算预算内执行精确 Zassenhaus 因子组合。 要求重构模数为正，且提升因子乘积与 poly 的整数归一化结果同余。 候选子集按字典序枚举，支持任意因子数；预算耗尽时以 Inconclusive 返回精确部分分解。

执行 Hensel 提升并诊断前置条件。 空因子列表、非法素数、零或常数输入、零因子及模 p 因子乘积 与原多项式不符时，通过 CasError 返回具体诊断。

在有限域 F_p 上对有理系数多项式执行 Berlekamp 算法, 返回模 p 下的不可约因子列表.

参数

[in]	poly	有理系数多项式
[in]	prime	选定的素数 p

返回

Berlekamp 分解结果

以 gcd(f, f') 分离重复因子，为 Berlekamp 分解提供无平方因子部分。

参数

[in]

poly

输入的有理系数多项式

返回

无平方因子预处理结果,包含 square-free 部分和重复因子信息

Exact numeric components retain exact simplification. Approximate components and bound real components use a scaled norm without forming their squares.

Powers with integer exponents in [-64, 64] use exponentiation by squaring. Exact exponent expressions are normalized before numeric conversion, with rational exponents classified in their exact number domain. Negative powers first form the reciprocal base, keeping the computation on the magnitude scale of the requested result. Complex traversal and real-component evaluation share the context's active recursion budget. Each frame releases its depth on return or stack unwinding. Complex products use LMMC's component-wise binary scaling at exponent boundaries and retain the propagated component error estimates.

参数

f	待约化多项式
basis	Gröbner 基
order	单项式序

返回

标准形

每个成功值都精确重构 poly.`Complete` 还证明所有终端因子在已实现 的精确路径下不可约;有界或尚不支持的精确部分结果标记为 Inconclusive.资源、取消、分配与内部不变量失败均通过 CasError 返回.

计算多元容度

将多项式视为主变量的一元多项式，计算所有系数多项式（辅助变量的多项式）的 GCD。

参数

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

返回

容度多项式（辅助变量的多项式）

将多项式除以其关于主变量的容度，得到本原部分。 满足：multivariate_content(poly, var) * multivariate_primitive_part(poly, var) == poly（至多差符号）。

参数

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

返回

本原部分多项式

采用递归求值-插值算法，避开降次的坏求值点，并对恢复的 候选多项式执行精确整除验证。

参数

[in]	a	第一个多项式
[in]	b	第二个多项式

返回

gcd(a, b)

通过计算 gcd(f, ∂f/∂x_main) 检测重因子，将多项式分解为 f = f₁ · f₂² · f₃³ · ... 的形式，其中每个 fᵢ 无平方。

参数

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

返回

无平方因子分解结果

Square roots of one or two real squares are evaluated as absolute values or hypot, avoiding intermediate overflow and underflow in norm expressions.

参见

ISO C11 committee draft N1570, 7.12.7.3 (hypot). https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

Exact numeric exponents retain their integer classification and parity on negative real bases. Non-integral powers of negative real values report DomainError rather than rounding the exponent into the integer domain.

参见

ISO C11 committee draft N1570, 7.12.7.4 (pow). https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

Complex phase on a real argument embeds the value as x + i(+0) and evaluates its principal argument with atan2(+0, x). Negative reals, including negative zero and negative-infinity bindings, therefore have phase +pi; positive reals and positive zero have phase +0. Argument-evaluation failures propagate through Result.

参见

ISO C11 committee draft N1570, 7.3.9.1 (carg), principal argument. https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

The expressions may contain any number of symbolic variables, exact integer or rational coefficients, addition, multiplication, and nonnegative integer powers. Approximate numbers and non-polynomial nodes are rejected. A successful result is verified to divide both inputs exactly.

成功且 optional 为空表示表达式超出当前结构支持域。 精确系数仅取自精确数值节点；遍历与展开计入上下文预算。

Attaches a resolved unit definition. Converts a quantity to a declared unit of the same dimension. Converts to a resolved unit definition. Removes a quantity annotation using the requested scale.

参数

a	加数
b	加数

返回

和

参数

a	被减数
b	减数

返回

差

参数

a	乘数
b	乘数

返回

积

参数

a	被除数
b	除数

返回

商

参数

z

输入复数

返回

共轭复数

参数

z

输入复数

返回

模的符号表达式

参数

z

输入复数

返回

辐角的符号表达式

参数

r	模
theta	辐角

返回

对应的符号复数

将极坐标形式转换为三角形式复数 r*(cos(theta) + i*sin(theta))

参数

r	模
theta	辐角

返回

对应的符号复数

求复数 c 的 n 次方根

参数

c	被开方的复数表达式
n	根的次数

返回

n 个复数根的列表

求解系数已证为实数且 a 非零的方程 az^2 + bz + c = 0。

按公式的 (+sqrt, -sqrt) 顺序返回两个直角坐标形式的根，保留重数。 负判别式的平方根仅进入虚部；返回前须将所有候选根代入 直角坐标多项式并将残差化简为零。 空输入返回 InvalidArgument；a 已证为零返回 DomainError； 系数未证为实数返回 UnsupportedExpression。 a 的非零性、判别式符号或零残差未获证明时返回 Inconclusive。 使用上下文假设并传播计算错误。

有限向量的点积或交点坐标更新存在溢出、下溢风险时，按最大分量 缩放相关向量和坐标，并同步缩放平面常数及直线参数化。 点积按维数预留累加余量；非零尺度变换保持交点不变。

参数

line	直线
plane	平面

返回

交点坐标向量

有限法向量的平方或点积部分和存在溢出、下溢风险时，同尺度缩放 法向量与常数项，保持平面和距离不变。点积按维数预留累加余量， 使最终可表示的抵消结果免受部分和溢出影响。

参数

point	空间点坐标
plane	平面

返回

距离的符号表达式

计算两条异面直线之间的距离。

有限方向向量分别按自身最大分量归一化后计算叉积。 有限点坐标差可能溢出时，先按公共最大分量缩放两点， 求出距离比值后恢复点尺度；方向及临时点尺度保持距离不变。

参数

l1	第一条直线
l2	第二条直线

返回

距离的符号表达式

有限点坐标差可能溢出时，先按两点的公共最大分量缩放再求差； 公共方向尺度保持直线不变。

参数

p1	第一个点
p2	第二个点

返回

直线（point = p1, direction = p2 - p1）

由三点构造平面（法向量 = (p2-p1)×(p3-p1)）。

有限点坐标差可能溢出时，按三点的公共尺度构造边； 叉积或其范数平方仍有溢出、下溢风险时，分别缩放两条边。 这些尺度变换保持平面不变。

参数

p1	第一个点
p2	第二个点
p3	第三个点

返回

平面（法向量 + 常数 d = n·p1）

计算两平面之间的二面角 arccos(|n₁·n₂| / (|n₁||n₂|))。

有限法向量的非零验证和角度计算均避开直接分量平方和， 支持方向可表示但平方会溢出的法向量。

参数

p1	第一个平面
p2	第二个平面

返回

二面角表达式（弧度）

参数

surf

隐式曲面。

返回

分类字符串："sphere"、"ellipsoid"、"paraboloid"、"hyperboloid"、 "cone"、"cylinder"、"unknown"。

数值梯度采用按最大分量缩放的二范数归一化，因此有限梯度的平方 即使超出 double 范围，只要单位方向可表示仍能返回结果。

参数

surf	隐式曲面
point	曲面上的点（变量名到值的映射）

返回

单位法向量分量

奇异点判断直接检查有限梯度分量，不构造可能溢出的平方和。有限数值 梯度与切点的点积存在中间溢出风险时，等比例缩放平面系数后计算常数。

参数

surf	隐式曲面
point	切点

返回

切平面（法向量与 ∇F(point) 同向）

Constructs a real interval. Endpoint ordering is validated when decidable. Constructs and simplifies a membership proposition when membership is decidable.

计算 ∫ₐᵇ f(r(t))·|r'(t)| dt，其中 r(t) 为参数化曲线。

参数

[in]	f	标量函数表达式（以曲线参数化中的坐标变量表示）
[in]	parametrization	参数化曲线 [x(t), y(t)] 或 [x(t), y(t), z(t)]
[in]	t	参数变量名
[in]	a	参数下界
[in]	b	参数上界

返回

曲线积分结果表达式

使用默认上下文计算第一类曲线积分，报告无效输入与未覆盖域。

计算第二类曲线积分（向量场沿曲线的积分）。

计算 ∫ₐᵇ F(r(t))·r'(t) dt，其中 r(t) 为参数化曲线。

参数

[in]	F	向量场（各分量以坐标变量表示）
[in]	parametrization	参数化曲线 [x(t), y(t)] 或 [x(t), y(t), z(t)]
[in]	t	参数变量名
[in]	a	参数下界
[in]	b	参数上界

返回

曲线积分结果表达式

参数

[in]	f	标量函数表达式
[in]	vars	变量名列表

返回

梯度向量，各分量为偏导数 ∂f/∂xᵢ

使用默认上下文计算梯度；无效输入返回错误。

计算向量场的散度 ∇·F = ∑∂Fᵢ/∂xᵢ。

参数

[in]	F	向量场（各分量为标量表达式）
[in]	vars	变量名列表（与 F 的分量一一对应）

返回

散度标量表达式

三维情况返回三分量向量；二维情况返回标量旋度（单分量向量）。

参数

[in]	F	向量场
[in]	vars	变量名列表

返回

旋度向量场

计算 ∬ f(r(u,v))·|r_u × r_v| du dv，其中 r(u,v) 为参数化曲面。

参数

[in]	f	标量函数表达式（以坐标变量表示）
[in]	parametrization	参数化曲面 [x(u,v), y(u,v), z(u,v)]
[in]	u	第一参数变量名
[in]	v	第二参数变量名
[in]	u_lower	u 参数下界
[in]	u_upper	u 参数上界
[in]	v_lower	v 参数下界
[in]	v_upper	v 参数上界

返回

曲面积分结果表达式

用默认上下文计算第一类曲面积分，报告无效输入与未覆盖域。

计算第二类曲面积分（向量场通过曲面的通量）。

计算 ∬ F·(r_u × r_v) du dv，其中 r(u,v) 为参数化曲面。

参数

[in]	F	向量场（三分量，以坐标变量表示）
[in]	parametrization	参数化曲面 [x(u,v), y(u,v), z(u,v)]
[in]	u	第一参数变量名
[in]	v	第二参数变量名
[in]	u_lower	u 参数下界
[in]	u_upper	u 参数上界
[in]	v_lower	v 参数下界
[in]	v_upper	v 参数上界

返回

曲面积分结果表达式

等价于闭合曲线积分 ∮_C P dx + Q dy。 region 以积分区间表示：x ∈ [x_lo, x_hi], y ∈ [y_lo(x), y_hi(x)]。

参数

[in]	P	向量场 x 分量
[in]	Q	向量场 y 分量
[in]	vars	变量名列表 {x_var, y_var}
[in]	x_bounds	x 的积分区间 {下界, 上界}
[in]	y_bounds	y 的积分区间 {下界(可含x), 上界(可含x)}

返回

格林定理计算的二重积分结果

使用默认计算上下文计算格林定理面积分，并显式报告无效输入和未覆盖域。

利用格林定理计算封闭曲线围成的面积 A = (1/2)∮(x dy - y dx)。

参数

[in]	parametrization	曲线参数化 r(t) = (x(t), y(t))
[in]	t	参数变量名
[in]	a	参数下界
[in]	b	参数上界

返回

面积表达式

等价于封闭曲面上的通量积分 ∬_S F·dS。 volume_bounds 以迭代积分区间表示。

参数

[in]	F	三维向量场
[in]	vars	变量名列表 {x, y, z}
[in]	x_bounds	x 的积分区间
[in]	y_bounds	y 的积分区间（可含 x）
[in]	z_bounds	z 的积分区间（可含 x, y）

返回

散度定理计算的三重积分结果

等价于边界曲线上的环量积分 ∮_C F·dr。 通过参数化曲面计算 ∬(∇×F)·(r_u × r_v) du dv。

参数

[in]	F	三维向量场
[in]	vars	变量名列表 {x, y, z}
[in]	parametrization	曲面参数化 r(u,v) = (x(u,v), y(u,v), z(u,v))
[in]	u	第一参数变量名
[in]	v	第二参数变量名
[in]	u_bounds	u 的积分区间
[in]	v_bounds	v 的积分区间

返回

斯托克斯定理计算的曲面积分结果

参数

[in]	a	向量 a
[in]	b	向量 b（维度需与 a 相同）

返回

点积标量表达式

参数

[in]	a	三维向量 a
[in]	b	三维向量 b

返回

叉积向量（三分量）

参数

[in]	a	被投影向量
[in]	b	投影方向向量

返回

投影向量；b 为零向量时返回零向量

参数

[in]	a	被投影向量
[in]	b	投影方向向量

返回

标量投影表达式；b 为零向量时返回 nullptr

参数

[in]	a	向量 a
[in]	b	向量 b

返回

夹角表达式（弧度）；任一向量为零时返回 nullptr

参数

[in]	a	向量 a
[in]	b	向量 b
[in]	c	向量 c

返回

混合积标量表达式（等于以 a,b,c 为行的行列式）

引用了 LMCAS_API, options , 以及 set_eqv_profile().

函数调用图:

__attribute__() [3/4]

template<>

__attribute__((visibility("default"))) Result< SymbolicPolyCoeff > extract_coeff_value< SymbolicPolyCoeff >(const std __attribute__((visibility("default"))) Result< BigInt > extract_coeff_value< BigInt >(const std __attribute__((visibility("default"))) Result< Rational > extract_coeff_value< Rational >(const std LMCAS::__attribute__

(

(visibility("default"))

)

const &

判断表达式是否含指定变量的自由出现。

引用了 contains(), LMCAS_API , 以及 variable.

函数调用图:

__attribute__() [4/4]

template<typename T>

LMCAS::__attribute__

(

(visibility("default"))

)

const

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

                               {
    if (!expression || !LMCAS::detail::node(expression) || variable.empty()) {
        return Result<Polynomial<T>>::failure(CasErrc::InvalidArgument,
            "Expression and variable must not be empty", "polynomial.convert");
    }
    try {
        ComputationContext context;
        return symbolic_to_poly_recursive<T>(LMCAS::detail::node(expression), variable, &context, nullptr);
    } catch (const CasError& error) {
        return Result<Polynomial<T>>::failure(error);
    } catch (const std::bad_alloc&) {
        return Result<Polynomial<T>>::failure(CasErrc::ResourceLimit,
            "Polynomial allocation failed", "polynomial.convert");
    } catch (const std::length_error& error) {
        return Result<Polynomial<T>>::failure(CasErrc::ResourceLimit,
            error.what(), "polynomial.convert");
    }
}

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

函数调用图:

abs() [1/2]

ExprResult LMCAS::abs

(

const ExprPtr &

expression

)

在文件 expr_arithmetic.cpp 第 172 行定义.

                                          {
    ComputationContext context;
    return abs(expression, context);
}

引用了 abs() , 以及 context.

函数调用图:

abs() [2/2]

ExprResult LMCAS::abs	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 128 行定义.

                                                                           {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto step = context.consume_steps(1, kAbsOperation);
    if (!step) {
        return ExprResult::failure(step.error());
    }
    auto re = real(expression, context);
    if (!re) {
        return re;
    }
    auto im = imag(expression, context);
    if (!im) {
        return im;
    }
    try {
        auto re_squared = SymbolicExpr::power(re.value(), SymbolicExpr::number(2));
        auto im_squared = SymbolicExpr::power(im.value(), SymbolicExpr::number(2));
        auto sum = SymbolicExpr::add(re_squared, im_squared);
        auto result = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::sqrt(sum)), transform_budget));
        if (!result || !LMCAS::detail::node(result)) {
            return expression_failure(CasErrc::InternalInvariant,
                                      "complex absolute value construction failed",
                                      kAbsOperation);
        }
        return ExprResult::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "complex absolute value allocation failed",
                                  kAbsOperation);
    } catch (const std::length_error& error) { return ExprResult::failure(CasErrc::ResourceLimit, error.what(), "abs"); } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kAbsOperation);
    }
} catch (const CasError& error) {
    return ExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExprResult::failure(CasErrc::ResourceLimit, "allocation failed", "abs");
} catch (const std::length_error& error) {
    return ExprResult::failure(CasErrc::ResourceLimit, error.what(), "abs");
} catch (const std::exception& error) {
    return ExprResult::failure(CasErrc::InternalInvariant, error.what(), "abs");
}

引用了 abs(), context, LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::Result< ExprPtr >::failure(), imag, InternalInvariant, LMCAS::expr_detail::expr_common::kAbsOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), real(), ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 abs(), abs(), LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function() , 以及 LMCAS::detail::strict_cauchy_root_bound().

函数调用图:

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

accumulate_bernoulli_exponent()

bool LMCAS::accumulate_bernoulli_exponent ( int value, int & exponent )

static

在文件 ode_classification.cpp 第 207 行定义.

                                                                    {
    if (value > 0 && exponent > std::numeric_limits<int>::max() - value) {
        return false;
    }
    if (value < 0 && exponent < std::numeric_limits<int>::min() - value) {
        return false;
    }
    exponent += value;
    return true;
}

引用了 accumulate_bernoulli_exponent(), exponent , 以及 value.

被这些函数引用 accumulate_bernoulli_exponent() , 以及 extract_bernoulli_factor().

函数调用图:

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

acos() [1/2]

ExprResult LMCAS::acos

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 93 行定义.

                                           {
    ComputationContext context;
    return acos(expression, context);
}

引用了 acos() , 以及 context.

函数调用图:

acos() [2/2]

ExprResult LMCAS::acos	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 86 行定义.

                                                                        {
    auto valid = require_dimensionless(expression, "acos");
    if (!valid) { return valid; }
    return make_unary_function_expr(expression, context, "acos",
                                    FunctionNode::FuncType::ArcCos);
}

引用了 acos(), LMCAS::FunctionNode::ArcCos, context, LMCAS::expr_detail::expr_common::make_unary_function_expr() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

被这些函数引用 acos(), acos() , 以及 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function().

函数调用图:

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

active_univariate_variable()

std::string LMCAS::active_univariate_variable ( const MultiPoly & poly )

static

在文件 multivariate_factor.cpp 第 208 行定义.

                                                                   {
    for (const auto& variable : poly.variables()) {
        if (poly.degree(variable) > 0) { return variable; }
    }
    return {};
}

引用了 active_univariate_variable() , 以及 variable.

被这些函数引用 active_univariate_variable() , 以及 univariate_gcd().

函数调用图:

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

adaptive_simpson_numeric() [1/2]

Result< QuadratureEstimate > LMCAS::adaptive_simpson_numeric	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		double	tolerance,
		int	max_depth )

在文件 numerical_integration.cpp 第 299 行定义.

                   {
    constexpr const char* operation = "adaptive_simpson";
    auto valid = validate_quadrature_args(
        function, variable, lower, upper, operation);
    if (!valid) return Result<QuadratureEstimate>::failure(valid.error());
    if (!(tolerance > 0.0) || !std::isfinite(tolerance)) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::InvalidArgument,
            "tolerance must be finite and positive",
            operation);
    }
    if (max_depth < 0) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::InvalidArgument,
            "maximum recursion depth must be non-negative",
            operation);
    }
    auto interval = evaluate_interval(lower, upper, context, operation);
    if (!interval) return Result<QuadratureEstimate>::failure(interval.error());
    if (interval.value().lower == interval.value().upper) {
        return Result<QuadratureEstimate>::success(zero_quadrature_result());
    }
    auto recursion = context.enter_recursion(operation);
    if (!recursion) return Result<QuadratureEstimate>::failure(recursion.error());
    struct RecursionGuard {
        ComputationContext& context;
        ~RecursionGuard() { context.leave_recursion(); }
    } recursion_guard{context};
    const std::size_t remaining_depth =
        context.limits().max_recursion_depth > context.recursion_depth()
            ? context.limits().max_recursion_depth - context.recursion_depth()
            : 0;
    const std::size_t effective_depth = std::min(
        static_cast<std::size_t>(max_depth), remaining_depth);
 
    detail::ensure_lmmc_lifecycle();
    QuadratureCallback callback{
        &function, &variable, &context, operation, std::nullopt};
    lmmc_quad_result_t backend_result{};
    const auto status = lmmc_quad_adaptive(
        evaluate_quadrature_callback, &callback,
        interval.value().lower, interval.value().upper,
        tolerance, 0.0, effective_depth, &backend_result);
    if (callback.error) return Result<QuadratureEstimate>::failure(*callback.error);
    if (status == LMMC_STATUS_WARNING_MAX_DEPTH) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::ResourceLimit,
            "adaptive Simpson recursion limit reached before meeting tolerance",
            operation);
    }
    if (status != LMMC_STATUS_OK) {
        return quadrature_failure<QuadratureEstimate>(status, operation);
    }
    QuadratureEstimate result;
    result.value = interval.value().sign * backend_result.value;
    result.estimated_error = std::abs(backend_result.error) +
        std::numeric_limits<double>::epsilon() *
            std::max(1.0, std::abs(result.value)) * 16.0;
    if (!std::isfinite(result.value) || !std::isfinite(result.estimated_error)) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::NumericFailure,
            "adaptive Simpson result is not finite",
            operation);
    }
    return Result<QuadratureEstimate>::success(result);
}

引用了 adaptive_simpson_numeric(), context, LMCAS::detail::ensure_lmmc_lifecycle(), LMCAS::Result< T >::error(), LMCAS::QuadratureEstimate::estimated_error, LMCAS::Result< T >::failure(), function(), interval(), InvalidArgument, lower, NumericFailure, ResourceLimit, LMCAS::Result< T >::success(), upper, LMCAS::QuadratureEstimate::value, LMCAS::Result< T >::value() , 以及 variable.

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

函数调用图:

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

adaptive_simpson_numeric() [2/2]

Result< QuadratureEstimate > LMCAS::adaptive_simpson_numeric	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		double	tolerance,
		int	max_depth )

在文件 numerical_integration.cpp 第 373 行定义.

                   {
    ComputationContext context;
    return adaptive_simpson_numeric(
        function, variable, lower, upper, context, tolerance, max_depth);
}

引用了 adaptive_simpson_numeric(), context, function(), lower, upper , 以及 variable.

函数调用图:

add() [1/2]

ExprResult LMCAS::add	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

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

                                                       {
    ComputationContext context;
    return add(lhs, rhs, context);
}

引用了 add(), context , 以及 rhs.

函数调用图:

add() [2/2]

ExprResult LMCAS::add	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 18 行定义.

                                            {
    return quantity_add(lhs, rhs, context);
}

引用了 add(), context, quantity_add() , 以及 rhs.

被这些函数引用 add(), add(), calculus_utils_contains_complex(), calculus_utils_contains_nonreal_sqrt(), LMCAS::equivalence_detail::canonicalize_complex_product(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_sum(), LMCAS::solver_detail::collect_denominator_factors(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_proof.cpp}::collect_polynomial_variable_names(), LMCAS::anonymous_namespace{residual_verification.cpp}::collect_residual_profiles(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::collect_transcendental_subexprs(), 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::SymbolicFactory::create_add(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::degree_in_var(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_node(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_node(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::exact_rational_sum(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::extract_linear_coefficient(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::has_exp_k_var_terms(), inverse_laplace_core(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::is_poly_expr_node(), LMCAS::solver_detail::is_polynomial_node(), LMCAS::transform_detail::laplace_transform_core(), match_recursive(), LMCAS::AddNode::normalize_operands(), LMCAS::expr_detail::ExprParser::parse_additive(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_quadratic_surd(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_surd_sum(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::propagate(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_rational(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_sum(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_node(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_sum(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::SubstNodeVisitor::replace(), LMCAS::anonymous_namespace{residual_verification.cpp}::residual_piecewise(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::rewrite_exp_as_u_power(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_radical(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_sum(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::structural(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::sum_bounds(), LMCAS::anonymous_namespace{query_conditions.cpp}::sum_conditions(), LMCAS::InferenceEngine::Impl::sum_nonzero(), LMCAS::InferenceEngine::Impl::sum_relation_sign(), symbolic_node_to_multipoly(), symbolic_sum_to_poly(), symbolic_to_poly_recursive(), tf_collect_transcendental(), tf_contains_transcendental(), tf_degree_in(), tf_detect_exponential_separation(), tf_simplify_pythagorean_node(), tf_substitute_expr(), LMCAS::NormalizationVisitor::visit(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_has_trig_of_var(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_is_rational_trig(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational().

函数调用图:

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

add_fourier_harmonic()

Result< void > LMCAS::add_fourier_harmonic ( Integrator & integrator, const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::shared_ptr< SymbolicExpr > & half_lo, const std::shared_ptr< SymbolicExpr > & half_hi, const std::shared_ptr< SymbolicExpr > & L, const std::shared_ptr< SymbolicExpr > & arg, bool cosine, std::shared_ptr< SymbolicExpr > & result, ComputationContext & context )

static

在文件 series_expansions.cpp 第 161 行定义.

                                                                          {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto integrand = SymbolicExpr::multiply(
        f, cosine ? SymbolicExpr::cos(arg) : SymbolicExpr::sin(arg));
    auto integrated = integrator.integrate_def_checked(
        *integrand, var, *half_lo, *half_hi, context);
    if (!integrated) {
        return Result<void>::failure(integrated.error());
    }
    auto coefficient = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
        detail::make_expression_ptr(integrated.value()), L)), transform_budget));
    if (!(detail::node(coefficient) && detail::node(coefficient)->is_zero())) {
        result = SymbolicExpr::add(
            result, SymbolicExpr::multiply(
                coefficient, cosine ? SymbolicExpr::cos(arg) : SymbolicExpr::sin(arg)));
    }
    return Result<void>::success();
} catch (const CasError& error) {
    return Result<void>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<void>::failure(CasErrc::ResourceLimit, "allocation failed", "add_fourier_harmonic");
} catch (const std::length_error& error) {
    return Result<void>::failure(CasErrc::ResourceLimit, error.what(), "add_fourier_harmonic");
} catch (const std::exception& error) {
    return Result<void>::failure(CasErrc::InternalInvariant, error.what(), "add_fourier_harmonic");
}

引用了 add_fourier_harmonic(), context, LMCAS::Result< T >::failure(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::Result< T >::success().

被这些函数引用 add_fourier_harmonic() , 以及 fourier_harmonics().

函数调用图:

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

add_lagrange_value()

void LMCAS::add_lagrange_value ( MultiPoly & result, const MultiPoly & value, const std::vector< Rational > & basis_coeffs, const std::vector< std::string > & all_vars, int var_idx )

static

在文件 multivariate_factor.cpp 第 111 行定义.

                                                       {
    for (size_t k = 0; k < basis_coeffs.size(); ++k) {
        if (basis_coeffs[k].is_zero()) { continue; }
        MultiPoly scaled = value * basis_coeffs[k];
        if (scaled.is_zero()) { continue; }
        for (const auto& term : scaled.terms()) {
            Monomial full_mono = restore_main_exponent(
                term.first, all_vars.size(), var_idx, static_cast<int>(k));
            std::vector<MultiPoly::Term> t = {{full_mono, term.second}};
            result = result + MultiPoly(std::move(t), all_vars);
        }
    }
}

引用了 add_lagrange_value(), restore_main_exponent(), t , 以及 value.

被这些函数引用 add_lagrange_value() , 以及 lagrange_interpolate().

函数调用图:

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

add_number_nodes()

std::shared_ptr< const NumberNode > LMCAS::add_number_nodes ( const std::shared_ptr< const NumberNode > & a, const std::shared_ptr< const NumberNode > & b )

static

在文件 solver_linear.cpp 第 50 行定义.

                                                                                                                                            {
    if (std::holds_alternative<Rational>(a->value()) || std::holds_alternative<Rational>(b->value())) {
        Rational r1 = std::holds_alternative<Rational>(a->value()) ? std::get<Rational>(a->value()) : Rational(std::get<BigInt>(a->value()));
        Rational r2 = std::holds_alternative<Rational>(b->value()) ? std::get<Rational>(b->value()) : Rational(std::get<BigInt>(b->value()));
        return LMCAS::detail::make_node<NumberNode>(r1 + r2);
    }
 
    return LMCAS::detail::make_node<NumberNode>(std::get<BigInt>(a->value()) + std::get<BigInt>(b->value()));
}

引用了 a, add_number_nodes(), b, LMCAS::detail::make_node() , 以及 LMCAS::Result< T >::value().

被这些函数引用 add_number_nodes() , 以及 LMCAS::solver_detail::multiply_no_expand().

函数调用图:

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

add_numbers()

std::shared_ptr< const NumberNode > LMCAS::add_numbers	(	const std::shared_ptr< const NumberNode > &	a,
		const std::shared_ptr< const NumberNode > &	b )

两个数值节点相加

参数

a	加数节点
b	加数节点

返回

和的数值节点

在文件 normalization_utils.cpp 第 150 行定义.

                                                                                                                                {
     if (std::holds_alternative<Rational>(a->value()) || std::holds_alternative<Rational>(b->value())) {
         const Rational r1 = exact_number_as_rational(*a);
         const Rational r2 = exact_number_as_rational(*b);
         return LMCAS::detail::make_node<NumberNode>(r1 + r2);
     }
 
     return LMCAS::detail::make_node<NumberNode>(
         std::get<BigInt>(a->value()) + std::get<BigInt>(b->value()));
}

引用了 a, add_numbers(), b, exact_number_as_rational(), LMCAS::detail::make_node() , 以及 LMCAS::Result< T >::value().

被这些函数引用 LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::add_base(), add_numbers() , 以及 LMCAS::NormalizationVisitor::collect_sum().

函数调用图:

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

alternating_sequence_bound()

ExpressionResult LMCAS::alternating_sequence_bound ( const std::shared_ptr< SymbolicExpr > & remainder, const std::string & n, bool upper, ComputationContext & context )

static

在文件 series_sequence_limits.cpp 第 88 行定义.

                                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto limited = limit_expression_checked(
        remainder, n, SymbolicExpr::infinity(), LimitDirection::Both, context);
    if (!limited) {
        return limited;
    }
    auto limit = std::move(limited.value());
    auto simplified = limit ? detail::make_expression_ptr(detail::normalize_node(detail::node(limit), transform_budget)) : nullptr;
    if (simplified && !series_is_infinity(simplified)) {
        auto magnitude = series_abs(simplified, context);
        return upper ? magnitude : series_negate(magnitude, context);
    }
    if (series_is_infinity(simplified)) {
        return upper ? SymbolicExpr::infinity() : SymbolicExpr::infinity(-1);
    }
    auto magnitude = series_abs(limit, context);
    return upper ? magnitude : series_negate(magnitude, context);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "alternating_sequence_bound");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "alternating_sequence_bound");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "alternating_sequence_bound");
}

引用了 alternating_sequence_bound(), Both, context, limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), series_abs(), series_is_infinity(), series_negate() , 以及 upper.

被这些函数引用 alternating_sequence_bound() , 以及 sequence_extreme_limit().

函数调用图:

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

analytic_continuation()

std::shared_ptr< SymbolicExpr > LMCAS::analytic_continuation	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	)

Basic analytic continuation via symbolic simplification Simplification often reduces locally defined series (if represented) to their global analytic forms (e.g. geometric series).

在文件 complex_analysis.cpp 第 377 行定义.

                      {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    /// Basic analytic continuation via symbolic simplification
    /// Simplification often reduces locally defined series (if represented)
    /// to their global analytic forms (e.g. geometric series).
    if (!f) return f;
    return detail::make_expression_ptr(detail::normalize_node(detail::node(f), transform_budget));
}

引用了 analytic_continuation(), context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 analytic_continuation().

函数调用图:

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

any_nonreal_sqrt()

bool LMCAS::any_nonreal_sqrt ( const std::vector< std::shared_ptr< const SymbolicNode > > & children, ComputationContext & context )

static

在文件 calculus_inverse.cpp 第 83 行定义.

{
    for (const auto& child : children) {
        if (calculus_utils_contains_nonreal_sqrt(child, context)) {
            return true;
        }
    }
    return false;
}

引用了 any_nonreal_sqrt(), calculus_utils_contains_nonreal_sqrt() , 以及 context.

被这些函数引用 any_nonreal_sqrt() , 以及 calculus_utils_contains_nonreal_sqrt().

函数调用图:

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

any_transcendental()

bool LMCAS::any_transcendental ( const std::vector< std::shared_ptr< const SymbolicNode > > & nodes, const std::string & var )

static

判断表达式 AST 中是否包含依赖指定变量的超越函数.

递归遍历 AST,若发现任何 FunctionNode 类型为 Sin/Cos/Exp/Ln/Tan 且其参数依赖 var,则返回 true.

参数

[in]	node	当前 AST 节点
[in]	var	目标变量名

返回

包含超越函数返回 true

在文件 transcendental_rewrite.cpp 第 481 行定义.

                          {
    for (const auto& node : nodes) {
        if (tf_contains_transcendental(node, var)) {
            return true;
        }
    }
    return false;
}

引用了 any_transcendental() , 以及 tf_contains_transcendental().

被这些函数引用 any_transcendental() , 以及 tf_contains_transcendental().

函数调用图:

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

append_factor_solutions()

void LMCAS::append_factor_solutions ( const Polynomial< Rational > & factor, int multiplicity, const std::string & var, std::vector< std::shared_ptr< SymbolicExpr > > & results, ComputationContext & context )

static

在文件 solve_polynomial.cpp 第 55 行定义.

                                 {
    if (factor.degree() <= 0) { return; }
    auto symbolic = rational_to_symbolic_poly(factor);
    auto solutions = factor.degree() <= 4 ?
        solve_closed_form_poly(symbolic, var, context) :
        detail::make_rootof_solutions_impl(symbolic, var, context);
    for (int copy = 0; copy < multiplicity; ++copy) {
        results.insert(results.end(), solutions.begin(), solutions.end());
    }
}

引用了 append_factor_solutions(), context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::detail::make_rootof_solutions_impl(), rational_to_symbolic_poly() , 以及 solve_closed_form_poly().

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

函数调用图:

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

append_product_families()

void LMCAS::append_product_families ( ParametricSolutions & values, const std::set< std::string > & original_names, std::vector< ParametricSolution > & families )

static

在文件 solve_visitor.cpp 第 266 行定义.

                                                                                      {
    for (auto& family : values.values) {
        auto occupied = original_names;
        const auto value_names = detail::all_variable_names(detail::node(family.value));
        occupied.insert(value_names.begin(), value_names.end());
        for (auto& parameter : family.integer_parameters) {
            if (!original_names.count(parameter)) { continue; }
            std::string fresh = "_k";
            for (std::size_t suffix = 1; occupied.count(fresh); ++suffix) {
                fresh = "_k" + std::to_string(suffix);
            }
            auto symbol = SymbolicExpr::variable(fresh);
            family.value = substitute_raw(family.value, parameter, symbol);
            for (auto& condition : family.conditions) {
                condition = substitute_raw(condition, parameter, symbol);
            }
            parameter = fresh;
            occupied.insert(fresh);
        }
        families.push_back(std::move(family));
    }
}

引用了 LMCAS::detail::all_variable_names(), append_product_families(), LMCAS::detail::node(), substitute_raw() , 以及 LMCAS::ParametricSolutions::values.

被这些函数引用 append_product_families() , 以及 solve_product_set().

函数调用图:

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

append_product_roots()

Result< void > LMCAS::append_product_roots ( FiniteSolutions & values, std::size_t multiplicity, std::vector< FiniteSolution > & finite )

static

在文件 solve_visitor.cpp 第 244 行定义.

                                       {
    for (auto& value : values.values) {
        if (value.multiplicity > std::numeric_limits<std::size_t>::max() / multiplicity) {
            return Result<void>::failure(CasErrc::ResourceLimit, "root multiplicity overflow", "solve.product");
        }
        value.multiplicity *= multiplicity;
        auto existing = std::find_if(finite.begin(), finite.end(), [&](const FiniteSolution& candidate) {
            return detail::node(candidate.value)->equals(*detail::node(value.value)) &&
                candidate.conditions.empty() && value.conditions.empty();
        });
        if (existing == finite.end()) { finite.push_back(std::move(value)); }
        else {
            if (existing->multiplicity > std::numeric_limits<std::size_t>::max() - value.multiplicity) {
                return Result<void>::failure(CasErrc::ResourceLimit, "root multiplicity overflow", "solve.product");
            }
            existing->multiplicity += value.multiplicity;
        }
    }
    return Result<void>::success();
}

引用了 append_product_roots(), LMCAS::Result< T >::failure(), ResourceLimit, LMCAS::Result< T >::success(), value , 以及 LMCAS::FiniteSolutions::values.

被这些函数引用 append_product_roots() , 以及 solve_product_set().

函数调用图:

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

apply_assumption_decl_checked()

AssumptionVoidResult LMCAS::apply_assumption_decl_checked ( AssumptionContext & ctx, const AssumptionDecl & decl )

inline

在文件 assumption_context.hpp 第 450 行定义.

                                {
    switch (decl.type()) {
        case AssumptionDecl::Type::Domain:
            return ctx.assume_domain_checked(decl.symbol(), decl.domain());
        case AssumptionDecl::Type::Sign:
            return ctx.assume_sign_checked(decl.symbol(), decl.sign());
        case AssumptionDecl::Type::Relation:
            return ctx.assume_checked(decl.relation());
    }
    return AssumptionVoidResult::failure(
        CasErrc::InternalInvariant, "unknown assumption declaration type", "with_assumptions");
}

引用了 apply_assumption_decl_checked(), LMCAS::AssumptionDecl::Domain, LMCAS::AssumptionDecl::domain(), LMCAS::Result< void >::failure(), InternalInvariant, LMCAS::AssumptionDecl::Relation, LMCAS::AssumptionDecl::relation(), LMCAS::AssumptionDecl::Sign, LMCAS::AssumptionDecl::sign(), LMCAS::AssumptionDecl::symbol() , 以及 LMCAS::AssumptionDecl::type().

被这些函数引用 apply_assumption_decl_checked(), with_assumptions() , 以及 with_assumptions().

函数调用图:

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

apply_hensel_lift_steps()

bool LMCAS::apply_hensel_lift_steps ( const MultiPoly & poly, std::vector< MultiPoly > & factors, const std::string & lift_var, int lift_var_idx, const Rational & eval_point, int degree_bound, int factor_count )

static

在文件 multivariate_hensel.cpp 第 180 行定义.

                                                                    {
    const auto& vars = poly.variables();
    auto shift_powers = lifting_shift_powers(vars, lift_var_idx,
                                             eval_point, degree_bound);
    for (int k = 1; k <= degree_bound; ++k) {
        MultiPoly product = truncated_factor_product(factors, lift_var, k + 1);
        MultiPoly poly_trunc = truncate_mod_var(poly, lift_var, k + 1);
        MultiPoly error = poly_trunc - product;
        if (error.is_zero()) { continue; }
        auto error_k = lifting_error_coefficient(error, lift_var, lift_var_idx,
                                                  eval_point, k, shift_powers, vars);
        if (error_k.is_zero()) { continue; }
        auto cofactors = evaluated_lifting_cofactors(factors, lift_var,
                                                       eval_point, vars);
        std::vector<MultiPoly> corrections = multivariate_diophantine(
            cofactors, error_k, lift_var, eval_point, k + 1);
        if (corrections.size() != static_cast<size_t>(factor_count)) { return false; }
        for (int i = 0; i < factor_count; ++i) {
            if (corrections[i].is_zero()) { continue; }
            MultiPoly correction_poly = corrections[i] * shift_powers[k];
            factors[i] = factors[i] + correction_poly;
        }
        MultiPoly verify_product = truncated_factor_product(factors, lift_var, k + 1);
        MultiPoly verify_error = poly_trunc - verify_product;
        if (!lifting_residual_is_zero(verify_error, lift_var_idx, k)) { break; }
    }
    return true;
}

引用了 apply_hensel_lift_steps(), evaluated_lifting_cofactors(), lifting_error_coefficient(), lifting_residual_is_zero(), lifting_shift_powers(), multivariate_diophantine(), truncate_mod_var(), truncated_factor_product() , 以及 vars.

被这些函数引用 apply_hensel_lift_steps() , 以及 multivariate_hensel_lift().

函数调用图:

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

approx_real()

ExprResult LMCAS::approx_real

(

double

value

)

在文件 expr_values.cpp 第 93 行定义.

                                     {
    if (!std::isfinite(value)) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "approximate real must be finite", kApproxOperation);
    }
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "approximate real allocation failed", kApproxOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kApproxOperation);
    }
}

引用了 approx_real(), LMCAS::expr_detail::expr_common::expression_failure(), InternalInvariant, InvalidArgument, LMCAS::expr_detail::expr_common::kApproxOperation, ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 value.

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

函数调用图:

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

arc_length_x_checked() [1/2]

ExpressionResult LMCAS::arc_length_x_checked	(	std::shared_ptr< SymbolicExpr >	fx,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b )

在文件 symbolic_geometry.cpp 第 264 行定义.

  {
    ComputationContext context;
    return arc_length_x_checked(std::move(fx), std::move(a), std::move(b), context);
}

引用了 a, arc_length_x_checked(), b , 以及 context.

函数调用图:

arc_length_x_checked() [2/2]

ExpressionResult LMCAS::arc_length_x_checked	(	std::shared_ptr< SymbolicExpr >	fx,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b,
		ComputationContext &	context )

在文件 symbolic_geometry.cpp 第 253 行定义.

  {
    return arc_length_checked_impl(
        std::move(fx), std::move(a), std::move(b), "x",
        context, "arc_length_x");
}

引用了 a, arc_length_x_checked(), b , 以及 context.

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

函数调用图:

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

arc_length_y_checked() [1/2]

ExpressionResult LMCAS::arc_length_y_checked	(	std::shared_ptr< SymbolicExpr >	fy,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b )

在文件 symbolic_geometry.cpp 第 307 行定义.

  {
    ComputationContext context;
    return arc_length_y_checked(std::move(fy), std::move(a), std::move(b), context);
}

引用了 a, arc_length_y_checked(), b , 以及 context.

函数调用图:

arc_length_y_checked() [2/2]

ExpressionResult LMCAS::arc_length_y_checked	(	std::shared_ptr< SymbolicExpr >	fy,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b,
		ComputationContext &	context )

在文件 symbolic_geometry.cpp 第 296 行定义.

  {
    return arc_length_checked_impl(
        std::move(fy), std::move(a), std::move(b), "y",
        context, "arc_length_y");
}

引用了 a, arc_length_y_checked(), b , 以及 context.

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

函数调用图:

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

asin() [1/2]

ExprResult LMCAS::asin

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 81 行定义.

                                           {
    ComputationContext context;
    return asin(expression, context);
}

引用了 asin() , 以及 context.

函数调用图:

asin() [2/2]

ExprResult LMCAS::asin	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 74 行定义.

                                                                        {
    auto valid = require_dimensionless(expression, "asin");
    if (!valid) { return valid; }
    return make_unary_function_expr(expression, context, "asin",
                                    FunctionNode::FuncType::ArcSin);
}

引用了 LMCAS::FunctionNode::ArcSin, asin(), context, LMCAS::expr_detail::expr_common::make_unary_function_expr() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

被这些函数引用 asin(), asin() , 以及 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function().

函数调用图:

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

assemble_frobenius_polynomial()

std::shared_ptr< SymbolicExpr > LMCAS::assemble_frobenius_polynomial ( const std::vector< double > & a, const std::shared_ptr< SymbolicExpr > & x_minus_x0 )

static

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

                                                   {
    const int order = static_cast<int>(a.size()) - 1;
        auto series_sol = SymbolicExpr::number(0);
        for (int k = 0; k <= order; ++k) {
            if (std::abs(a[k]) < 1e-15) {
                continue;
            }
            auto coeff = SymbolicExpr::number(a[k]);
            auto power_term = (k == 0) ? SymbolicExpr::number(1)
                : SymbolicExpr::power(x_minus_x0, SymbolicExpr::number(k));
            series_sol = SymbolicExpr::add(series_sol,
                SymbolicExpr::multiply(coeff, power_term));
        }
 
    return series_sol;
}

引用了 a, assemble_frobenius_polynomial(), e() , 以及 order.

被这些函数引用 assemble_frobenius_polynomial(), ordinary_frobenius_solution() , 以及 singular_frobenius_solution().

函数调用图:

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

asymptote_candidates()

SymbolicExprVectorResult LMCAS::asymptote_candidates ( const std::shared_ptr< SymbolicExpr > & denominator, const std::string & var, ComputationContext & context, const std::string & operation )

static

在文件 calculus_asymptotes.cpp 第 165 行定义.

{
    auto solved = solve_equation(denominator, var, context, SolveOptions{});
    if (!solved) {
        return SymbolicExprVectorResult::failure(solved.error());
    }
    const auto& zero_set = solved.value();
    const auto* finite = std::get_if<FiniteSolutions>(&zero_set);
    if (!std::holds_alternative<EmptySolutions>(zero_set) && !finite) {
        return SymbolicExprVectorResult::failure(
            CasErrc::Inconclusive,
            "asymptote denominator zeros are outside the finite exact support domain",
            operation);
    }
    std::vector<std::shared_ptr<SymbolicExpr>> zeros;
    if (!finite) {
        return SymbolicExprVectorResult::success(std::move(zeros));
    }
    zeros.reserve(finite->values.size());
    for (const auto& solution : finite->values) {
        if (!solution.value || !LMCAS::detail::node(solution.value)) {
            return SymbolicExprVectorResult::failure(
                CasErrc::InternalInvariant,
                "checked solver returned a null vertical-asymptote candidate", operation);
        }
        auto candidate = rootof_simplify(solution.value);
        if (!candidate || !LMCAS::detail::node(candidate)) {
            return SymbolicExprVectorResult::failure(
                CasErrc::InternalInvariant,
                "checked solver returned a malformed vertical-asymptote candidate", operation);
        }
        if (LMCAS::detail::contains_node_type<RootOfNode>(LMCAS::detail::node(candidate))) {
            return SymbolicExprVectorResult::failure(
                CasErrc::Inconclusive,
                "vertical-asymptote candidate could not be reduced to an exact explicit point",
                operation);
        }
        zeros.push_back(candidate);
    }
    return SymbolicExprVectorResult::success(std::move(zeros));
}

引用了 asymptote_candidates(), LMCAS::detail::contains_node_type(), context, denominator, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::node(), rootof_simplify(), solve_equation(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 asymptote_candidates() , 以及 collect_vertical_asymptotes().

函数调用图:

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

asymptotes_checked() [1/2]

AsymptoteAnalysisResult LMCAS::asymptotes_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var )

在文件 calculus_asymptotes.cpp 第 404 行定义.

{
    ComputationContext context;
    return asymptotes_checked(f, var, context);
}

引用了 asymptotes_checked() , 以及 context.

函数调用图:

asymptotes_checked() [2/2]

AsymptoteAnalysisResult LMCAS::asymptotes_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		ComputationContext &	context )

在文件 calculus_asymptotes.cpp 第 373 行定义.

{
    try {
        AsymptoteResult result;
        const std::string operation = "asymptotes";
        auto input = calculus_utils_validate_expr(f, var, context, operation);
        if (!input) {
            return AsymptoteAnalysisResult::failure(input.error());
        }
        auto pos_inf = SymbolicExpr::infinity(1);
        auto neg_inf = SymbolicExpr::infinity(-1);
        auto vertical = collect_vertical_asymptotes(f, var, context, result, operation);
        if (!vertical) {
            return AsymptoteAnalysisResult::failure(vertical.error());
        }
        auto infinite = collect_infinite_asymptotes(f, var, pos_inf, neg_inf, context, result);
        if (!infinite) {
            return AsymptoteAnalysisResult::failure(infinite.error());
        }
        return AsymptoteAnalysisResult::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return AsymptoteAnalysisResult::failure(
            CasErrc::ResourceLimit, "asymptote analysis allocation failed", "asymptotes");
    } catch (const std::exception& ex) {
        return AsymptoteAnalysisResult::failure(
            CasErrc::InternalInvariant, ex.what(), "asymptotes");
    }
}

引用了 asymptotes_checked(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr(), collect_infinite_asymptotes(), collect_vertical_asymptotes(), context, LMCAS::Result< AsymptoteResult >::failure(), InternalInvariant, ResourceLimit , 以及 LMCAS::Result< AsymptoteResult >::success().

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

函数调用图:

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

asymptotic_expand()

std::shared_ptr< SymbolicExpr > LMCAS::asymptotic_expand	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		int	order )

通过 x = 1/t 替换,在 t=0 处做 Taylor 展开,再回代 t = 1/x, 得到按 x 递减幂次的渐近展开.

回代 t = 1/x

在文件 series_expansions.cpp 第 654 行定义.

                                                                           {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f || order < 0) {
        return nullptr;
    }
    /// 通过 x = 1/t 替换,在 t=0 处做 Taylor 展开,再回代 t = 1/x,
    /// 得到按 x 递减幂次的渐近展开.
    auto x = SymbolicExpr::variable(var);
    std::string tname = var + "__asym_t";
    auto t = SymbolicExpr::variable(tname);
    auto inv_t = SymbolicExpr::divide(SymbolicExpr::number(1), t);
    auto g = detail::make_expression_ptr(detail::substitute_node(detail::node(f), var, detail::node(inv_t), transform_budget));
    if (!g) {
        return nullptr;
    }
    g = detail::make_expression_ptr(detail::normalize_node(detail::node(g), transform_budget));
    auto taylor_t = g->series(tname, SymbolicExpr::number(0), order + 1);
    if (!taylor_t) {
        return nullptr;
    }
    /// 回代 t = 1/x
    auto inv_x = SymbolicExpr::divide(SymbolicExpr::number(1), x);
    auto back = detail::make_expression_ptr(detail::substitute_node(detail::node(taylor_t), tname, detail::node(inv_x), transform_budget));
    if (!back) {
        return nullptr;
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(back), transform_budget));
}

引用了 asymptotic_expand(), context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), order, LMCAS::detail::substitute_node() , 以及 t.

被这些函数引用 asymptotic_expand().

函数调用图:

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

atan() [1/2]

ExprResult LMCAS::atan

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 105 行定义.

                                           {
    ComputationContext context;
    return atan(expression, context);
}

引用了 atan() , 以及 context.

函数调用图:

atan() [2/2]

ExprResult LMCAS::atan	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 98 行定义.

                                                                        {
    auto valid = require_dimensionless(expression, "atan");
    if (!valid) { return valid; }
    return make_unary_function_expr(expression, context, "atan",
                                    FunctionNode::FuncType::ArcTan);
}

引用了 LMCAS::FunctionNode::ArcTan, atan(), context, LMCAS::expr_detail::expr_common::make_unary_function_expr() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

被这些函数引用 atan(), atan() , 以及 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function().

函数调用图:

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

attach_unit() [1/2]

QuantityResult LMCAS::attach_unit	(	const std::shared_ptr< SymbolicExpr > &	value,
		const std::string &	unit,
		ComputationContext &	context )

在文件 quantity.cpp 第 91 行定义.

                                                        {
    auto step = context.consume_steps(1, kOperation);
    if (!step) return QuantityResult::failure(step.error());
    if (!value || !detail::node(value)) {
        return failure(CasErrc::InvalidArgument, "quantity value cannot be null");
    }
    if (std::dynamic_pointer_cast<const QuantityNode>(detail::node(value))) {
        return failure(CasErrc::UnitInvalid, "a quantity cannot receive a second unit");
    }
    auto definition = context.units().resolve(unit);
    if (!definition) return QuantityResult::failure(definition.error());
    return make_quantity(detail::node(value), definition.value().dimension,
                         definition.value().scale_to_base, unit);
}

引用了 attach_unit(), context, definition, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, LMCAS::detail::node(), unit, UnitInvalid , 以及 value.

被这些函数引用 attach_unit(), attach_unit(), with_unit() , 以及 with_unit_definition().

函数调用图:

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

attach_unit() [2/2]

QuantityResult LMCAS::attach_unit	(	const std::shared_ptr< SymbolicExpr > &	value,
		std::string	display_unit,
		UnitDefinition	definition,
		ComputationContext &	context )

在文件 quantity.cpp 第 108 行定义.

                                                        {
    auto step = context.consume_steps(1, kOperation);
    if (!step) return QuantityResult::failure(step.error());
    if (!value || !detail::node(value)) {
        return failure(CasErrc::InvalidArgument, "quantity value cannot be null");
    }
    if (std::dynamic_pointer_cast<const QuantityNode>(detail::node(value))) {
        return failure(CasErrc::UnitInvalid, "a quantity cannot receive a second unit");
    }
    if (display_unit.empty() || definition.scale_to_base <= Rational(0)) {
        return failure(CasErrc::UnitInvalid, "resolved unit definition is invalid");
    }
    return make_quantity(detail::node(value), std::move(definition.dimension),
                         std::move(definition.scale_to_base),
                         std::move(display_unit));
}

引用了 attach_unit(), context, definition, display_unit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, LMCAS::detail::node(), UnitInvalid , 以及 value.

函数调用图:

berlekamp_factor()

BerlekampResult LMCAS::berlekamp_factor	(	const Polynomial< Rational > &	poly,
		int64_t	prime )

零多项式或常数多项式:无因子

显式和自动模数都必须保持次数且使约化多项式无平方。

将多项式约化到 F_p

首一化

线性多项式:本身不可约

构造 Berlekamp 矩阵 Q

计算 (Q - I)^T 的零空间

存储零空间信息

零空间维度 = 1:多项式在 F_p 上不可约

零空间维度 > 1:多项式可分解,使用基向量分裂

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

                   {
 
    BerlekampResult result;
 
    /// 零多项式或常数多项式:无因子
    if (poly.is_zero() || poly.degree() <= 0) {
        return result;
    }
 
    /// 显式和自动模数都必须保持次数且使约化多项式无平方。
    int64_t p = prime;
    if (p > 0) {
        if (!bk_is_suitable_prime(poly, p)) {
            return result;
        }
    } else {
        p = bk_select_prime(poly);
        if (p < 0) {
            return result;
        }
    }
 
    result.prime = p;
 
    /// 将多项式约化到 F_p
    std::vector<int64_t> f_coeffs = bk_reduce_to_mod_coeffs(poly, p);
 
    /// 首一化
    if (!f_coeffs.empty()) {
        int64_t lc = f_coeffs.back();
        if (lc != 1) {
            int64_t lc_inv = bk_mod_inverse(lc, p);
            for (auto& c : f_coeffs) {
                c = (c * lc_inv) % p;
            }
        }
    }
 
    /// 线性多项式:本身不可约
    if (f_coeffs.size() <= 2) {
        result.factors.push_back(bk_to_poly_modint(f_coeffs, p, poly.variable_name));
        return result;
    }
 
    /// 构造 Berlekamp 矩阵 Q
    auto Q = bk_build_q_matrix(f_coeffs, p);
 
    /// 计算 (Q - I)^T 的零空间
    auto null_basis = bk_null_space(Q, p);
    int null_dim = static_cast<int>(null_basis.size());
 
    /// 存储零空间信息
    result.null_space_dim = null_dim;
    result.null_space_basis = null_basis;
 
    /// 零空间维度 = 1:多项式在 F_p 上不可约
    if (null_dim <= 1) {
        result.factors.push_back(bk_to_poly_modint(f_coeffs, p, poly.variable_name));
        return result;
    }
 
    /// 零空间维度 > 1:多项式可分解,使用基向量分裂
    auto split = bk_split_factors(f_coeffs, null_basis, null_dim, p);
    for (const auto& factor_coeffs : split) {
        result.factors.push_back(bk_to_poly_modint(factor_coeffs, p, poly.variable_name));
    }
    return result;
}

引用了 berlekamp_factor(), LMCAS::berlekamp_detail::bk_build_q_matrix(), LMCAS::berlekamp_detail::bk_is_suitable_prime(), LMCAS::berlekamp_detail::bk_mod_inverse(), LMCAS::berlekamp_detail::bk_null_space(), LMCAS::berlekamp_detail::bk_reduce_to_mod_coeffs(), LMCAS::berlekamp_detail::bk_select_prime(), LMCAS::berlekamp_detail::bk_split_factors(), bk_to_poly_modint(), c, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::BerlekampResult::factors, LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::BerlekampResult::null_space_basis, LMCAS::BerlekampResult::null_space_dim, LMCAS::BerlekampResult::prime, prime , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 berlekamp_factor() , 以及 LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_reduction().

函数调用图:

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

bernoulli_integer_exponent()

std::optional< int > LMCAS::bernoulli_integer_exponent ( const NumberNode & number )

static

在文件 ode_classification.cpp 第 188 行定义.

{
    std::optional<std::int64_t> value;
    if (std::holds_alternative<BigInt>(number.value())) {
        value = std::get<BigInt>(number.value()).try_to_int64();
    } else if (std::holds_alternative<Rational>(number.value())) {
        const auto& rational = std::get<Rational>(number.value());
        if (!rational.is_integer()) {
            return std::nullopt;
        }
        value = rational.to_bigint().try_to_int64();
    }
    if (!value || *value < std::numeric_limits<int>::min() ||
        *value > std::numeric_limits<int>::max()) {
        return std::nullopt;
    }
    return static_cast<int>(*value);
}

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

被这些函数引用 bernoulli_integer_exponent() , 以及 extract_bernoulli_factor().

函数调用图:

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

binding()

BindingResult LMCAS::binding	(	ExprPtr	symbol,
		ExprPtr	value )

在文件 expr_transform.cpp 第 84 行定义.

                                                     {
    if (!symbol || !LMCAS::detail::node(symbol)) {
        return BindingResult::failure(
            CasErrc::InvalidArgument, "binding symbol cannot be null",
            kSubstituteOperation);
    }
    if (!value || !LMCAS::detail::node(value)) {
        return BindingResult::failure(
            CasErrc::InvalidArgument, "binding value cannot be null",
            kSubstituteOperation);
    }
    const auto variable = std::dynamic_pointer_cast<const VariableNode>(
        LMCAS::detail::node(symbol));
    if (!variable || variable->is_constant()) {
        return BindingResult::failure(
            CasErrc::InvalidArgument,
            "binding left-hand side must be a symbol",
            kSubstituteOperation);
    }
    return BindingResult::success(Binding{std::move(symbol), std::move(value)});
}

引用了 binding, LMCAS::Result< Binding >::failure(), InvalidArgument, LMCAS::expr_detail::expr_common::kSubstituteOperation, LMCAS::detail::node(), LMCAS::Result< Binding >::success(), value , 以及 variable.

函数调用图:

bisection_checked() [1/2]

NumericRootResult LMCAS::bisection_checked	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		lmmc_real_t	lower,
		lmmc_real_t	upper,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 newton_raphson.cpp 第 326 行定义.

                                 {
    auto valid = invalid_root_options(options, kBisectionOperation);
    if (!valid) {
        return valid;
    }
    if (!function || variable.empty() || !std::isfinite(lower) ||
        !std::isfinite(upper) || lower > upper) {
        return NumericRootResult::failure(
            CasErrc::InvalidArgument,
            "bisection function, variable, and ordered finite interval are required",
            kBisectionOperation);
    }
    return run_bisection_backend(
        function, variable, lower, upper, context, options,
        kBisectionOperation);
}

引用了 bisection_checked(), context, LMCAS::Result< std::optional< NumericRoot > >::failure(), function(), InvalidArgument, lower, options, upper , 以及 variable.

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

函数调用图:

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

bisection_checked() [2/2]

NumericRootResult LMCAS::bisection_checked	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		lmmc_real_t	lower,
		lmmc_real_t	upper,
		const SolveOptions &	options )

在文件 newton_raphson.cpp 第 349 行定义.

                                 {
    ComputationContext context;
    return bisection_checked(
        function, variable, lower, upper, context, options);
}

引用了 bisection_checked(), context, function(), lower, options, upper , 以及 variable.

函数调用图:

bk_to_poly_modint()

Polynomial< ModInt > LMCAS::bk_to_poly_modint ( const std::vector< int64_t > & coeffs, int64_t p, const std::string & var )

static

将模 p 系数向量转换为 Polynomial<ModInt>.

参数

[in]	coeffs	系数向量(升幂排列)
[in]	p	素数模数
[in]	var	变量名

返回

对应的 Polynomial<ModInt>

直接构造,不调用 trim()(已保证无高次零系数)

在文件 berlekamp.cpp 第 15 行定义.

                          {
 
    std::vector<ModInt> mod_coeffs;
    mod_coeffs.reserve(coeffs.size());
    for (int64_t c : coeffs) {
        mod_coeffs.emplace_back(c, p);
    }
    /// 直接构造,不调用 trim()(已保证无高次零系数)
    Polynomial<ModInt> result(var);
    result.coeffs = std::move(mod_coeffs);
    return result;
}

引用了 bk_to_poly_modint(), c , 以及 LMCAS::Polynomial< CoeffType >::coeffs.

被这些函数引用 berlekamp_factor() , 以及 bk_to_poly_modint().

函数调用图:

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

build_euler_solution()

std::shared_ptr< SymbolicExpr > LMCAS::build_euler_solution ( const std::vector< CharRoot > & roots, const std::string & x, std::vector< std::string > & constants )

static

在文件 ode_linear.cpp 第 175 行定义.

{
    auto x_var = SymbolicExpr::variable(x);
    auto ln_x = SymbolicExpr::ln(x_var);
    std::shared_ptr<SymbolicExpr> solution = nullptr;
    int const_idx = 1;
 
    for (const auto& root : roots) {
        for (int k = 0; k < root.multiplicity; ++k) {
            std::shared_ptr<SymbolicExpr> log_factor = nullptr;
            if (k > 0) {
                log_factor = SymbolicExpr::power(ln_x, SymbolicExpr::number(k));
            }
 
            if (!root.is_complex) {
                std::string c_name = "C" + std::to_string(const_idx++);
                constants.push_back(c_name);
                auto term = SymbolicExpr::variable(c_name);
 
                auto exponent = clean_number(root.real_part);
                term = SymbolicExpr::multiply(
                    term,
                    SymbolicExpr::power(x_var, exponent));
                if (log_factor) {
                    term = SymbolicExpr::multiply(term, log_factor);
                }
                solution = solution ? SymbolicExpr::add(solution, term) : term;
            } else {
                std::string ca_name = "C" + std::to_string(const_idx++);
                std::string cb_name = "C" + std::to_string(const_idx++);
                constants.push_back(ca_name);
                constants.push_back(cb_name);
 
                auto alpha_expr = clean_number(root.real_part);
                auto beta_expr = clean_number(root.imag_part);
                auto beta_ln_x = SymbolicExpr::multiply(beta_expr, ln_x);
                auto trig = SymbolicExpr::add(
                    SymbolicExpr::multiply(SymbolicExpr::variable(ca_name),
                                           SymbolicExpr::cos(beta_ln_x)),
                    SymbolicExpr::multiply(SymbolicExpr::variable(cb_name),
                                           SymbolicExpr::sin(beta_ln_x)));
                auto term = SymbolicExpr::multiply(
                    SymbolicExpr::power(x_var, alpha_expr),
                    trig);
                if (log_factor) {
                    term = SymbolicExpr::multiply(term, log_factor);
                }
                solution = solution ? SymbolicExpr::add(solution, term) : term;
            }
        }
    }
 
    return solution;
}

引用了 build_euler_solution(), clean_number(), exponent , 以及 roots().

被这些函数引用 build_euler_solution() , 以及 solve_euler_ode_impl().

函数调用图:

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

build_homogeneous_solution()

std::shared_ptr< SymbolicExpr > LMCAS::build_homogeneous_solution ( const std::vector< CharRoot > & roots, const std::string & x, std::vector< std::string > & constants )

static

根据特征根构造齐次通解.

• 实根 r(重数 m):C_k * x^k * e^(rx),k = 0, ..., m-1
• 复根 alpha+/-betai(重数 m):x^k * e^(alphax) * (C_a*cos(betax) + C_b*sin(betax))

实根: C_i * x^k * e^(r*x)

x^k 因子

e^(r*x) 因子。精确零才可省略；小的非零根仍改变解。

复根 alpha+/-betai: 产生两个基本解 C_a * x^k * e^(alphax) * cos(betax) C_b * x^k * e^(alphax) * sin(betax)

e^(alphax) 因子。精确零才可省略。

x^k 因子

构造 cos 项: Ca * x^k * e^(alphax) * cos(betax)

构造 sin 项: Cb * x^k * e^(alphax) * sin(betax)

在文件 ode_linear.cpp 第 82 行定义.

{
    auto x_var = SymbolicExpr::variable(x);
    std::shared_ptr<SymbolicExpr> solution = nullptr;
    int const_idx = 1;
 
    for (const auto& root : roots) {
        for (int k = 0; k < root.multiplicity; ++k) {
            if (!root.is_complex) {
                /// 实根: C_i * x^k * e^(r*x)
                std::string c_name = "C" + std::to_string(const_idx++);
                constants.push_back(c_name);
                auto C = SymbolicExpr::variable(c_name);
 
                std::shared_ptr<SymbolicExpr> term = C;
 
                /// x^k 因子
                if (k > 0) {
                    auto x_pow = SymbolicExpr::power(x_var, SymbolicExpr::number(k));
                    term = SymbolicExpr::multiply(term, x_pow);
                }
 
                /// e^(r*x) 因子。精确零才可省略；小的非零根仍改变解。
                if (root.real_part != 0.0) {
                    auto r_expr = clean_number(root.real_part);
                    auto exp_arg = SymbolicExpr::multiply(r_expr, x_var);
                    auto exp_term = SymbolicExpr::exp(exp_arg);
                    term = SymbolicExpr::multiply(term, exp_term);
                }
 
                solution = solution ? SymbolicExpr::add(solution, term) : term;
            } else {
                /// 复根 alpha+/-betai: 产生两个基本解
                /// C_a * x^k * e^(alphax) * cos(betax)
                /// C_b * x^k * e^(alphax) * sin(betax)
                std::string ca_name = "C" + std::to_string(const_idx++);
                std::string cb_name = "C" + std::to_string(const_idx++);
                constants.push_back(ca_name);
                constants.push_back(cb_name);
                auto Ca = SymbolicExpr::variable(ca_name);
                auto Cb = SymbolicExpr::variable(cb_name);
 
                auto beta_expr = clean_number(root.imag_part);
                auto beta_x = SymbolicExpr::multiply(beta_expr, x_var);
                auto cos_term = SymbolicExpr::cos(beta_x);
                auto sin_term = SymbolicExpr::sin(beta_x);
 
                /// e^(alphax) 因子。精确零才可省略。
                std::shared_ptr<SymbolicExpr> exp_factor = nullptr;
                if (root.real_part != 0.0) {
                    auto alpha_expr = clean_number(root.real_part);
                    auto exp_arg = SymbolicExpr::multiply(alpha_expr, x_var);
                    exp_factor = SymbolicExpr::exp(exp_arg);
                }
 
                /// x^k 因子
                std::shared_ptr<SymbolicExpr> x_pow_factor = nullptr;
                if (k > 0) {
                    x_pow_factor = SymbolicExpr::power(x_var, SymbolicExpr::number(k));
                }
 
                /// 构造 cos 项: Ca * x^k * e^(alphax) * cos(betax)
                auto term_cos = Ca;
                if (x_pow_factor) {
                    term_cos = SymbolicExpr::multiply(term_cos, x_pow_factor);
                }
                if (exp_factor) {
                    term_cos = SymbolicExpr::multiply(term_cos, exp_factor);
                }
                term_cos = SymbolicExpr::multiply(term_cos, cos_term);
 
                /// 构造 sin 项: Cb * x^k * e^(alphax) * sin(betax)
                auto term_sin = Cb;
                if (x_pow_factor) {
                    term_sin = SymbolicExpr::multiply(term_sin, x_pow_factor);
                }
                if (exp_factor) {
                    term_sin = SymbolicExpr::multiply(term_sin, exp_factor);
                }
                term_sin = SymbolicExpr::multiply(term_sin, sin_term);
 
                solution = solution ? SymbolicExpr::add(solution, term_cos) : term_cos;
                solution = SymbolicExpr::add(solution, term_sin);
            }
        }
    }
 
    return solution;
}

引用了 build_homogeneous_solution(), clean_number() , 以及 roots().

被这些函数引用 build_homogeneous_solution() , 以及 solve_higher_order_ode_impl().

函数调用图:

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

calculate_residue_checked() [1/2]

ExpressionResult LMCAS::calculate_residue_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	order )

在文件 complex_analysis.cpp 第 240 行定义.

{
    ComputationContext context;
    return calculate_residue_checked(f, z, z0, order, context);
}

引用了 calculate_residue_checked(), context , 以及 order.

函数调用图:

calculate_residue_checked() [2/2]

ExpressionResult LMCAS::calculate_residue_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	order,
		ComputationContext &	context )

在文件 complex_analysis.cpp 第 203 行定义.

{
    const std::string operation = "calculate_residue";
    auto input = validate_complex_expr_point_input(f, z, z0, order, context, operation);
    if (!input) return ExpressionResult::failure(input.error());
    auto budget = context.consume_steps(static_cast<std::size_t>(order) * 12 + 12,
                                        operation);
    if (!budget) return ExpressionResult::failure(budget.error());
 
    try {
        auto calculated =
            calculate_residue_impl(f, z, z0, order, context);
        if (!calculated) return calculated;
        auto result = std::move(calculated.value());
        if (!result || !LMCAS::detail::node(result)) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "residue could not be constructed in the supported symbolic domain",
                operation);
        }
        return result;
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                          "allocation failed while calculating residue",
                                          operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                          ex.what(),
                                          operation);
    }
}

引用了 calculate_residue_checked(), calculate_residue_impl(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::node(), order , 以及 ResourceLimit.

被这些函数引用 calculate_residue_checked(), calculate_residue_checked(), residue_checked() , 以及 residue_checked().

函数调用图:

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

calculate_residue_impl()

ExpressionResult LMCAS::calculate_residue_impl ( const std::shared_ptr< SymbolicExpr > & f, const std::string & z, const std::shared_ptr< SymbolicExpr > & z0, int order, ComputationContext & context )

static

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

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (order < 1) return SymbolicExpr::number(0);
    
    auto var_z = SymbolicExpr::variable(z);
    auto z_minus_z0 = SymbolicExpr::add(var_z, SymbolicExpr::multiply(z0, SymbolicExpr::number(-1)));
    auto pow_term = SymbolicExpr::power(z_minus_z0, SymbolicExpr::number(order));
    
    auto F = SymbolicExpr::multiply(pow_term, f);
    
    for (int i = 0; i < order - 1; i++) {
        F = detail::make_expression_ptr(detail::differentiate_node(detail::node(F), z, transform_budget));
    }
    
    auto fact = BigInt::factorial_checked(BigInt(order - 1), context);
    if (!fact) return ExpressionResult::failure(fact.error());
 
    F = SymbolicExpr::divide(F, SymbolicExpr::number(fact.value()));
    
    return limit_expression_checked(
        F, z, z0, LimitDirection::Both, context, Domain::Complex);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "calculate_residue_impl");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "calculate_residue_impl");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "calculate_residue_impl");
}

引用了 Both, calculate_residue_impl(), Complex, context, LMCAS::detail::differentiate_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 order.

被这些函数引用 calculate_residue_checked() , 以及 calculate_residue_impl().

函数调用图:

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

calculus_utils_contains_complex()

bool LMCAS::calculus_utils_contains_complex ( const std::shared_ptr< const SymbolicNode > & node )

static

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

{
    if (!node) {
        return false;
    }
 
    if (std::dynamic_pointer_cast<const ComplexNode>(node)) {
        return true;
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        for (const auto& argument : function->arguments()) {
            if (calculus_utils_contains_complex(argument)) {
                return true;
            }
        }
        return false;
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (const auto& operand : add->operands()) {
            if (calculus_utils_contains_complex(operand)) {
                return true;
            }
        }
        return false;
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (const auto& operand : multiply->operands()) {
            if (calculus_utils_contains_complex(operand)) {
                return true;
            }
        }
        return false;
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return calculus_utils_contains_complex(power->base()) ||
               calculus_utils_contains_complex(power->exponent());
    }
    return false;
}

引用了 add(), calculus_utils_contains_complex() , 以及 function().

被这些函数引用 calculus_utils_contains_complex() , 以及 calculus_utils_extract_real_candidate().

函数调用图:

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

calculus_utils_contains_nonreal_sqrt()

bool LMCAS::calculus_utils_contains_nonreal_sqrt ( const std::shared_ptr< const SymbolicNode > & node, ComputationContext & context )

static

在文件 calculus_inverse.cpp 第 94 行定义.

{
    if (!node) {
        return false;
    }
 
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (is_nonreal_sqrt(*function, context)) {
            return true;
        }
        return any_nonreal_sqrt(function->arguments(), context);
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return any_nonreal_sqrt(add->operands(), context);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return any_nonreal_sqrt(multiply->operands(), context);
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return calculus_utils_contains_nonreal_sqrt(power->base(), context) ||
               calculus_utils_contains_nonreal_sqrt(power->exponent(), context);
    }
    if (auto complex = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        return calculus_utils_contains_nonreal_sqrt(complex->real(), context) ||
               calculus_utils_contains_nonreal_sqrt(complex->imag(), context);
    }
    return false;
}

引用了 add(), any_nonreal_sqrt(), calculus_utils_contains_nonreal_sqrt(), complex(), context, function() , 以及 is_nonreal_sqrt().

被这些函数引用 any_nonreal_sqrt(), calculus_utils_contains_nonreal_sqrt() , 以及 calculus_utils_extract_real_candidate().

函数调用图:

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

calculus_utils_extract_denominator()

std::shared_ptr< SymbolicExpr > LMCAS::calculus_utils_extract_denominator ( const std::shared_ptr< SymbolicExpr > & expr )

static

在文件 calculus_asymptotes.cpp 第 38 行定义.

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return nullptr;
    }
    auto factor = denominator_factor(LMCAS::detail::node(expr));
    if (factor) {
        return LMCAS::detail::make_expression_ptr(factor);
    }
    auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr));
    if (!multiply) {
        return nullptr;
    }
    std::vector<std::shared_ptr<const SymbolicNode>> factors;
    for (const auto& operand : multiply->operands()) {
        auto denominator = denominator_factor(operand);
        if (denominator) factors.push_back(std::move(denominator));
    }
    if (factors.empty()) {
        return nullptr;
    }
    if (factors.size() == 1) {
        return LMCAS::detail::make_expression_ptr(factors[0]);
    }
    return LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<MultiplyNode>(factors));
}

引用了 calculus_utils_extract_denominator(), denominator, denominator_factor(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node() , 以及 LMCAS::detail::node().

被这些函数引用 calculus_utils_extract_denominator() , 以及 collect_vertical_asymptotes().

函数调用图:

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

calculus_utils_extract_real_candidate()

CalculusRealCandidateStatus LMCAS::calculus_utils_extract_real_candidate ( const std::shared_ptr< SymbolicExpr > & candidate, std::shared_ptr< SymbolicExpr > & real_candidate, ComputationContext & context )

static

在文件 calculus_inverse.cpp 第 129 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    real_candidate.reset();
    auto simplified_candidate = rootof_simplify(candidate);
    if (!simplified_candidate || !LMCAS::detail::node(simplified_candidate)) {
        return CalculusRealCandidateStatus::Inconclusive;
    }
    if (LMCAS::detail::contains_node_type<RootOfNode>(LMCAS::detail::node(simplified_candidate))) {
        return CalculusRealCandidateStatus::Inconclusive;
    }
    if (calculus_utils_contains_nonreal_sqrt(LMCAS::detail::node(simplified_candidate), context)) {
        return CalculusRealCandidateStatus::NonReal;
    }
 
    if (auto complex = std::dynamic_pointer_cast<const ComplexNode>(
            LMCAS::detail::node(simplified_candidate))) {
        auto imag = detail::make_expression_ptr(detail::normalize_node(complex->imag(), transform_budget));
        if (!imag || !LMCAS::detail::node(imag)) {
            return CalculusRealCandidateStatus::Inconclusive;
        }
        if (imag->is_zero()) {
            auto real = detail::make_expression_ptr(detail::normalize_node(complex->real(), transform_budget));
            if (!real || !LMCAS::detail::node(real)) {
                return CalculusRealCandidateStatus::Inconclusive;
            }
            real_candidate = real;
            return CalculusRealCandidateStatus::Real;
        }
        return CalculusRealCandidateStatus::NonReal;
    }
 
    if (calculus_utils_contains_complex(LMCAS::detail::node(simplified_candidate))) {
        return CalculusRealCandidateStatus::Inconclusive;
    }
 
    real_candidate = simplified_candidate;
    return CalculusRealCandidateStatus::Real;
}

引用了 calculus_utils_contains_complex(), calculus_utils_contains_nonreal_sqrt(), calculus_utils_extract_real_candidate(), complex(), LMCAS::detail::contains_node_type(), context, imag, Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), NonReal, LMCAS::detail::normalize_node(), Real, real() , 以及 rootof_simplify().

被这些函数引用 calculus_utils_extract_real_candidate() , 以及 verified_real_inverse_candidates().

函数调用图:

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

calculus_utils_is_minus_one()

bool LMCAS::calculus_utils_is_minus_one ( const std::shared_ptr< const NumberNode > & number )

static

在文件 calculus_asymptotes.cpp 第 82 行定义.

{
    if (!number) {
        return false;
    }
    if (std::holds_alternative<BigInt>(number->value())) {
        return std::get<BigInt>(number->value()) == BigInt(-1);
    }
    return std::get<Rational>(number->value()) == Rational(-1);
}

引用了 calculus_utils_is_minus_one().

被这些函数引用 calculus_utils_is_minus_one() , 以及 calculus_utils_split_rational().

函数调用图:

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

calculus_utils_is_negative_number()

bool LMCAS::calculus_utils_is_negative_number ( const std::shared_ptr< const NumberNode > & number )

static

在文件 calculus_inverse.cpp 第 53 行定义.

{
    if (!number) {
        return false;
    }
    if (std::holds_alternative<BigInt>(number->value())) {
        return std::get<BigInt>(number->value()) < BigInt(0);
    }
    return std::get<Rational>(number->value()) < Rational(0);
}

引用了 calculus_utils_is_negative_number().

被这些函数引用 calculus_utils_is_negative_number() , 以及 is_nonreal_sqrt().

函数调用图:

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

calculus_utils_oblique_from_rational()

bool LMCAS::calculus_utils_oblique_from_rational ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, std::shared_ptr< SymbolicExpr > & slope, std::shared_ptr< SymbolicExpr > & intercept, ComputationContext & context )

static

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

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::shared_ptr<SymbolicExpr> numerator;
    std::shared_ptr<SymbolicExpr> denominator;
    if (!calculus_utils_split_rational(f, numerator, denominator, context)) {
        return false;
    }
 
    try {
        auto num_poly = symbolic_to_poly<Rational>(detail::make_expression_ptr(detail::expand_node(detail::node(numerator), transform_budget)), var);
        auto den_poly = symbolic_to_poly<Rational>(detail::make_expression_ptr(detail::expand_node(detail::node(denominator), transform_budget)), var);
        if (!num_poly || !den_poly || den_poly.value().is_zero()) {
            return false;
        }
        auto [quotient, remainder] = num_poly.value().div_mod(den_poly.value());
        (void)remainder;
        if (quotient.degree() != 1 || quotient.coeffs.size() < 2) {
            return false;
        }
        intercept = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::number(quotient.coeffs[0])), transform_budget));
        slope = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::number(quotient.coeffs[1])), transform_budget));
        return !slope->is_zero();
    } catch (const std::invalid_argument&) {
        return false;
    } catch (const std::out_of_range&) {
        return false;
    }
}

引用了 calculus_utils_oblique_from_rational(), calculus_utils_split_rational(), context, denominator, LMCAS::detail::expand_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 calculus_utils_oblique_from_rational() , 以及 collect_infinite_asymptotes().

函数调用图:

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

calculus_utils_product()

std::shared_ptr< SymbolicExpr > LMCAS::calculus_utils_product ( const std::vector< std::shared_ptr< const SymbolicNode > > & factors, ComputationContext & context )

static

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

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (factors.empty()) {
        return SymbolicExpr::number(1);
    }
    if (factors.size() == 1) {
        return LMCAS::detail::make_expression_ptr(factors[0]);
    }
    return detail::make_expression_ptr(detail::normalize_node(LMCAS::detail::make_node<MultiplyNode>(factors), transform_budget));
}

引用了 calculus_utils_product(), context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 calculus_utils_product() , 以及 calculus_utils_split_rational().

函数调用图:

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

calculus_utils_split_rational()

bool LMCAS::calculus_utils_split_rational ( const std::shared_ptr< SymbolicExpr > & expr, std::shared_ptr< SymbolicExpr > & numerator, std::shared_ptr< SymbolicExpr > & denominator, ComputationContext & context )

static

在文件 calculus_asymptotes.cpp 第 93 行定义.

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
 
    std::vector<std::shared_ptr<const SymbolicNode>> num_factors;
    std::vector<std::shared_ptr<const SymbolicNode>> den_factors;
 
    auto collect_factor = [&](const std::shared_ptr<const SymbolicNode>& factor) {
        if (auto power = std::dynamic_pointer_cast<const PowerNode>(factor)) {
            auto exponent = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
            if (calculus_utils_is_minus_one(exponent)) {
                den_factors.push_back(power->base());
                return;
            }
        }
        num_factors.push_back(factor);
    };
 
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr))) {
        for (const auto& factor : multiply->operands()) collect_factor(factor);
    } else {
        collect_factor(LMCAS::detail::node(expr));
    }
 
    if (den_factors.empty()) {
        return false;
    }
    numerator = calculus_utils_product(num_factors, context);
    denominator = calculus_utils_product(den_factors, context);
    return numerator && denominator;
}

引用了 calculus_utils_is_minus_one(), calculus_utils_product(), calculus_utils_split_rational(), context, denominator, exponent , 以及 LMCAS::detail::node().

被这些函数引用 calculus_utils_oblique_from_rational() , 以及 calculus_utils_split_rational().

函数调用图:

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

calculus_utils_try_symbolic_definite()

ExpressionResult LMCAS::calculus_utils_try_symbolic_definite ( const std::shared_ptr< SymbolicExpr > & integrand, const std::string & var, const std::shared_ptr< SymbolicExpr > & a, const std::shared_ptr< SymbolicExpr > & b, ComputationContext & context )

static

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

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    Integrator integrator;
    auto integrated = integrator.integrate_def_checked(
        *integrand, var, *a, *b, context);
    if (!integrated) {
        return ExpressionResult::failure(integrated.error());
    }
    SymbolicExpr result = std::move(integrated.value());
 
    if (contains_unevaluated_integral(LMCAS::detail::node(result))) {
        return std::shared_ptr<SymbolicExpr>{};
    }
    auto res = LMCAS::detail::make_expression_ptr(result);
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(res), transform_budget));
    if (simplified &&
        contains_unevaluated_integral(LMCAS::detail::node(simplified))) {
        return std::shared_ptr<SymbolicExpr>{};
    }
    return simplified ? simplified : res;
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "calculus_utils_try_symbolic_definite");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "calculus_utils_try_symbolic_definite");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "calculus_utils_try_symbolic_definite");
}

引用了 a, b, calculus_utils_try_symbolic_definite(), contains_unevaluated_integral(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 calculus_utils_try_symbolic_definite(), surface_area_revolution_x_checked() , 以及 surface_area_revolution_y_checked().

函数调用图:

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

cauchy_integral_checked() [1/2]

ExpressionResult LMCAS::cauchy_integral_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	n )

在文件 complex_analysis.cpp 第 323 行定义.

{
    ComputationContext context;
    return cauchy_integral_checked(f, z, z0, n, context);
}

引用了 cauchy_integral_checked() , 以及 context.

函数调用图:

cauchy_integral_checked() [2/2]

ExpressionResult LMCAS::cauchy_integral_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	n,
		ComputationContext &	context )

在文件 complex_analysis.cpp 第 287 行定义.

{
    const std::string operation = "cauchy_integral";
    auto input = validate_complex_expr_point_input(f, z, z0, n, context, operation);
    if (!input) return ExpressionResult::failure(input.error());
    auto budget = context.consume_steps(static_cast<std::size_t>(n) * 12 + 12,
                                        operation);
    if (!budget) return ExpressionResult::failure(budget.error());
 
    try {
        auto calculated = cauchy_integral_impl(f, z, z0, n, context);
        if (!calculated) return calculated;
        auto result = std::move(calculated.value());
        if (!result || !LMCAS::detail::node(result)) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "Cauchy integral formula could not be constructed in the supported symbolic domain",
                operation);
        }
        return ExpressionResult::success(result);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                          "allocation failed while applying Cauchy integral formula",
                                          operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                          ex.what(),
                                          operation);
    }
}

引用了 cauchy_integral_checked(), cauchy_integral_impl(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::node(), ResourceLimit , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

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

函数调用图:

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

cauchy_integral_impl()

ExpressionResult LMCAS::cauchy_integral_impl ( const std::shared_ptr< SymbolicExpr > & f, const std::string & z, const std::shared_ptr< SymbolicExpr > & z0, int n, ComputationContext & context )

static

n is the power in the denominator: \oint f(z)/(z-z0)^n dz

在文件 complex_analysis.cpp 第 333 行定义.

                                            {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    
    /// n is the power in the denominator: \oint f(z)/(z-z0)^n dz
    if (n < 1) return SymbolicExpr::number(0);
    
    auto deriv = f;
    for (int i = 0; i < n - 1; i++) {
        deriv = detail::make_expression_ptr(detail::differentiate_node(detail::node(deriv), z, transform_budget));
    }
    
    auto f_n_minus_1_z0 = detail::make_expression_ptr(detail::substitute_node(detail::node(deriv), z, detail::node(z0), transform_budget));
    
    auto fact = BigInt::factorial_checked(BigInt(n - 1), context);
    if (!fact) return ExpressionResult::failure(fact.error());
 
    auto term = SymbolicExpr::divide(f_n_minus_1_z0, SymbolicExpr::number(fact.value()));
    
    auto pi_node = LMCAS::detail::make_node<VariableNode>("pi", true);
    auto i_node = SymbolicFactory::create_complex(
        LMCAS::detail::node(SymbolicExpr::number(0)),
        LMCAS::detail::node(SymbolicExpr::number(1)));
    
    auto pi_expr = LMCAS::detail::make_expression_ptr(pi_node);
    auto i_expr = LMCAS::detail::make_expression_ptr(i_node);
    
    auto two_pi_i = SymbolicExpr::multiply(SymbolicExpr::number(2), SymbolicExpr::multiply(pi_expr, i_expr));
    
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(two_pi_i, term)), transform_budget));
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "cauchy_integral_impl");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "cauchy_integral_impl");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "cauchy_integral_impl");
}

引用了 cauchy_integral_impl(), context, LMCAS::SymbolicFactory::create_complex(), LMCAS::detail::differentiate_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::detail::substitute_node().

被这些函数引用 cauchy_integral_checked() , 以及 cauchy_integral_impl().

函数调用图:

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

cbrt_expr()

std::shared_ptr< SymbolicExpr > LMCAS::cbrt_expr ( const std::shared_ptr< SymbolicExpr > & x )

static

在文件 solve_polynomial_cubic.cpp 第 14 行定义.

                                                                                   {
    return SymbolicExpr::power(x, SymbolicExpr::number(Rational(1, 3)));
}

引用了 cbrt_expr().

被这些函数引用 cbrt_expr() , 以及 symbolic_cubic_roots().

函数调用图:

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

ceil() [1/2]

ExprResult LMCAS::ceil

(

const ExprPtr &

expression

)

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

                                           {
    ComputationContext context;
    return ceil(expression, context);
}

引用了 ceil() , 以及 context.

函数调用图:

ceil() [2/2]

ExprResult LMCAS::ceil	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 179 行定义.

                                                                        {
    return make_unary_function_expr(expression, context, "ceil",
                                    FunctionNode::FuncType::Ceil);
}

引用了 LMCAS::FunctionNode::Ceil, ceil(), context , 以及 LMCAS::expr_detail::expr_common::make_unary_function_expr().

被这些函数引用 ceil(), ceil() , 以及 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function().

函数调用图:

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

check_equivalent()

ResidualCheckResult LMCAS::check_equivalent	(	const ExprPtr &	left,
		const ExprPtr &	right,
		ComputationContext &	context,
		const LMCAS::EqvOptions &	options )

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

                                    {
    if (!left || !right || !detail::node(left) || !detail::node(right)) {
        return ResidualCheckResult::failure(
            CasErrc::InvalidArgument,
            "equivalence check requires two expressions",
            "residual.check_equivalent");
    }
    auto access = context.consume_steps(1, "residual.check_equivalent");
    if (!access) return ResidualCheckResult::failure(access.error());
    try {
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                     context.limits().max_ast_nodes,
                                     "residual.check_equivalent");
        budget.measure(detail::node(left));
        budget.measure(detail::node(right));
        if (detail::node(left)->equals(*detail::node(right))) {
            return ResidualCheckResult::success(ProvedZeroResidual{
                ExactNormalizationProof{left}});
        }
        auto residual = SymbolicExpr::add(
            left,
            SymbolicExpr::multiply(SymbolicExpr::number(-1), right));
        return check_zero_residual(residual, context, options);
    } catch (const CasError& error) {
        return ResidualCheckResult::failure(error);
    } catch (const std::length_error& error) {
        return ResidualCheckResult::failure(
            CasErrc::ResourceLimit, error.what(), "residual.check_equivalent");
    } catch (const std::bad_alloc&) {
        return ResidualCheckResult::failure(
            CasErrc::ResourceLimit,
            "equivalence residual allocation failed",
            "residual.check_equivalent");
    } catch (const std::exception& error) {
        return ResidualCheckResult::failure(
            CasErrc::InternalInvariant, error.what(),
            "residual.check_equivalent");
    }
}

引用了 check_equivalent(), check_zero_residual(), context, LMCAS::Result< ResidualCheck >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), options, ResourceLimit, right , 以及 LMCAS::Result< ResidualCheck >::success().

被这些函数引用 check_equivalent(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), inverse_fourier_transform_checked(), inverse_laplace_checked(), solve_variation_of_parameters_core() , 以及 vector_calculus_constant_integrand().

函数调用图:

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

check_negative_arg()

bool LMCAS::check_negative_arg	(	const std::shared_ptr< const SymbolicNode > &	argument,
		std::shared_ptr< const SymbolicNode > &	positive,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_signs.cpp 第 21 行定义.

                                                                                                  {
    if (budget) { budget->require_nodes(1); }
    if (const auto number = std::dynamic_pointer_cast<const NumberNode>(argument)) {
        auto absolute = positive_negative_number(*number);
        if (!absolute) {
            return false;
        }
        positive = std::move(absolute);
        return true;
    }
    const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(argument);
    if (!multiply || multiply->operands().empty()) {
        return false;
    }
    const auto number = std::dynamic_pointer_cast<const NumberNode>(multiply->operands().front());
    if (!number) {
        return false;
    }
    auto absolute = positive_negative_number(*number);
    if (!absolute) {
        return false;
    }
    std::vector<std::shared_ptr<const SymbolicNode>> operands;
    std::size_t nodes = 0;
    for (const auto& operand : multiply->operands()) {
        normalization_append(budget, nodes, operands, operand);
    }
    if (number->is_negative_one()) {
        operands.erase(operands.begin());
        if (budget) { --nodes; }
    } else {
        operands.front() = std::move(absolute);
    }
    positive = make_normalized_multiply_node(operands, budget);
    return true;
}

引用了 check_negative_arg(), make_normalized_multiply_node(), normalization_append() , 以及 LMCAS::detail::RewriteBudget::require_nodes().

被这些函数引用 check_negative_arg() , 以及 LMCAS::NormalizationVisitor::normalize_function_parity().

函数调用图:

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

check_zero_residual()

ResidualCheckResult LMCAS::check_zero_residual	(	const ExprPtr &	residual,
		ComputationContext &	context,
		const LMCAS::EqvOptions &	options )

在文件 residual_verification.cpp 第 1036 行定义.

                                    {
    constexpr const char* operation = "residual.check_zero";
    if (!residual || !detail::node(residual)) {
        return ResidualCheckResult::failure(
            CasErrc::InvalidArgument,
            "residual expression cannot be null", operation);
    }
    auto access = context.consume_steps(1, operation);
    if (!access) { return ResidualCheckResult::failure(access.error()); }
 
    try {
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                     context.limits().max_ast_nodes, operation);
        budget.measure(detail::node(residual));
        if (auto piecewise = prove_piecewise_residual(residual, budget, options)) {
            return std::move(*piecewise);
        }
        auto root_proof = prove_exact_root_residual(residual, budget, operation);
        if (!root_proof ||
            std::holds_alternative<ProvedZeroResidual>(root_proof.value())) {
            return root_proof;
        }
        auto formal = FormalResidual(budget).prove(detail::node(residual));
        if (!formal) { return ResidualCheckResult::failure(formal.error()); }
        if (formal.value())
            { return ResidualCheckResult::success(ProvedZeroResidual{ExactResidualProof{residual}}); }
        return prove_normalized_residual(residual, budget, options, operation);
    } catch (const CasError& error) {
        return ResidualCheckResult::failure(error);
    } catch (const std::length_error& error) {
        return ResidualCheckResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::bad_alloc&) {
        return ResidualCheckResult::failure(
            CasErrc::ResourceLimit,
            "residual verification allocation failed", operation);
    } catch (const std::exception& error) {
        return ResidualCheckResult::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 check_zero_residual(), context, LMCAS::Result< ResidualCheck >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), options, ResourceLimit , 以及 LMCAS::Result< ResidualCheck >::success().

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness(), check_equivalent(), check_zero_residual(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equality_condition_truth(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), find_integrating_factor_impl(), is_exact_ode(), is_homogeneous_ode(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parameter_constraint(), parametric_residual_zero(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_piecewise_residual(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_zero(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::substitute_basis(), verify_lagrange_solutions() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::zero_difference().

函数调用图:

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

checked_derivative()

ExpressionResult LMCAS::checked_derivative ( const ExprPtr & expression, const std::string & variable, ComputationContext & context, const char * operation )

static

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

    {
    return detail::checked_transform_expr(
        expression, context, operation, "differentiate",
        [&variable, &context, operation](const SymbolicExpr& value) {
            detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                         context.limits().max_ast_nodes, operation);
            return detail::make_expression_ptr(
                detail::differentiate_node(detail::node(value), variable, budget));
        });
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "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_derivative(), LMCAS::detail::checked_transform_expr(), context, LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), value , 以及 variable.

被这些函数引用 checked_derivative(), curvature_checked(), curvature_parametric_checked() , 以及 inflection_points_checked().

函数调用图:

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

checked_inference_result()

template<typename T>

Result< T > LMCAS::checked_inference_result	(	const SymbolicExpr &	expr,
		const std::string &	operation,
		ComputationContext &	context,
		const std::function< Result< T >()> &	query )

在文件 inference_engine_impl.hpp 第 62 行定义.

                                           {
    if (!detail::node(expr)) {
        return Result<T>::failure(
            CasErrc::InvalidArgument,
            "inference expression must not be null", operation);
    }
    try {
        auto entered = context.enter_recursion(operation);
        if (!entered) return Result<T>::failure(entered.error());
        struct Leave {
            ComputationContext& context;
            ~Leave() { context.leave_recursion(); }
        } leave{context};
        return query();
    } catch (const CasError& error) {
        return Result<T>::failure(error);
    } catch (const std::bad_alloc&) {
        return Result<T>::failure(
            CasErrc::ResourceLimit,
            "inference query allocation failed", operation);
    } catch (const std::exception& error) {
        return Result<T>::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 checked_inference_result(), context, LMCAS::Result< T >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::node() , 以及 ResourceLimit.

被这些函数引用 checked_inference_result(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::periodicity_checked() , 以及 LMCAS::InferenceEngine::Impl::query_natural().

函数调用图:

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

cholesky_decomposition_checked() [1/2]

CholeskyDecompositionResult LMCAS::cholesky_decomposition_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 matrix_decomposition_cholesky.cpp 第 109 行定义.

{
    ComputationContext context;
    return cholesky_decomposition_checked(A, context);
}

引用了 cholesky_decomposition_checked() , 以及 context.

函数调用图:

cholesky_decomposition_checked() [2/2]

CholeskyDecompositionResult LMCAS::cholesky_decomposition_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

在文件 matrix_decomposition_cholesky.cpp 第 74 行定义.

{
    const std::string operation = "cholesky_decomposition";
    auto matrix = validate_decomposition_matrix(A, true, context, operation);
    if (!matrix) return CholeskyDecompositionResult::failure(matrix.error());
    auto budget = context.consume_steps(matrix.value()->rows() * matrix.value()->cols() * 10 + 8,
                                        operation);
    if (!budget) return CholeskyDecompositionResult::failure(budget.error());
    auto spd = prove_exact_spd(matrix.value(), context, operation);
    if (!spd) return CholeskyDecompositionResult::failure(spd.error());
    try {
        std::shared_ptr<SymbolicExpr> L;
        if (!cholesky_decomposition_impl(A, L)) {
            return CholeskyDecompositionResult::failure(
                CasErrc::Inconclusive,
                "Cholesky decomposition could not be constructed in the supported symbolic domain",
                operation);
        }
        auto l_check = validate_decomposition_output(L, "L", operation);
        if (!l_check) return CholeskyDecompositionResult::failure(l_check.error());
        return CholeskyDecompositionResult::success(CholeskyDecomposition{L});
    } catch (const std::bad_alloc&) {
        return CholeskyDecompositionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while calculating Cholesky decomposition",
            operation);
    } catch (const std::exception& ex) {
        return CholeskyDecompositionResult::failure(CasErrc::InternalInvariant,
                                                   ex.what(),
                                                   operation);
    }
}

引用了 cholesky_decomposition_checked(), context, LMCAS::Result< CholeskyDecomposition >::failure(), Inconclusive, InternalInvariant, ResourceLimit, LMCAS::Result< CholeskyDecomposition >::success(), LMCAS::detail::matrix_decomposition::validate_decomposition_matrix() , 以及 LMCAS::detail::matrix_decomposition::validate_decomposition_output().

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

函数调用图:

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

choose_main_variable()

std::string LMCAS::choose_main_variable ( const MultiPoly & a, const MultiPoly & b )

static

在文件 multivariate_factor.cpp 第 58 行定义.

{
    const auto& vars = a.variables();
    if (vars.empty()) { return ""; }
    std::string best_var = vars[0];
    int best_deg = a.degree(vars[0]) + b.degree(vars[0]);
    for (size_t i = 1; i < vars.size(); ++i) {
        int deg = a.degree(vars[i]) + b.degree(vars[i]);
        if (deg > best_deg) { best_deg = deg; best_var = vars[i]; }
    }
    return best_var;
}

引用了 a, b, choose_main_variable() , 以及 vars.

被这些函数引用 choose_main_variable() , 以及 recursive_multivariate_gcd().

函数调用图:

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

christoffel_first_kind_checked() [1/2]

DifferentialGeometryExprResult LMCAS::christoffel_first_kind_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		const std::vector< std::string > &	coords,
		int	k,
		int	i,
		int	j )

在文件 differential_geometry.cpp 第 414 行定义.

{
    ComputationContext context;
    return christoffel_first_kind_checked(g_ij, coords, k, i, j, context);
}

引用了 christoffel_first_kind_checked() , 以及 context.

函数调用图:

christoffel_first_kind_checked() [2/2]

DifferentialGeometryExprResult LMCAS::christoffel_first_kind_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		const std::vector< std::string > &	coords,
		int	k,
		int	i,
		int	j,
		ComputationContext &	context )

在文件 differential_geometry.cpp 第 370 行定义.

{
    const std::string operation = "christoffel_first_kind";
    auto metric = validate_metric_matrix(g_ij, &coords, context, operation);
    if (!metric) {
        return DifferentialGeometryExprResult::failure(metric.error());
    }
    const std::size_t dim = metric.value()->rows();
    auto k_check = validate_index(k, dim, "k", operation);
    if (!k_check) {
        return DifferentialGeometryExprResult::failure(k_check.error());
    }
    auto i_check = validate_index(i, dim, "i", operation);
    if (!i_check) {
        return DifferentialGeometryExprResult::failure(i_check.error());
    }
    auto j_check = validate_index(j, dim, "j", operation);
    if (!j_check) {
        return DifferentialGeometryExprResult::failure(j_check.error());
    }
    auto budget = context.consume_steps(16, operation);
    if (!budget) {
        return DifferentialGeometryExprResult::failure(budget.error());
    }
    try {
        auto result = christoffel_first_kind_impl(g_ij, coords, k, i, j, context);
        return checked_geometry_expression(std::move(result), CasErrc::Inconclusive,
                                           "Christoffel symbol could not be constructed",
                                           operation);
    } catch (const std::bad_alloc&) {
        return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit,
                                                       "allocation failed while calculating Christoffel symbol",
                                                       operation);
    } catch (const std::exception& ex) {
        return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant,
                                                       ex.what(),
                                                       operation);
    }
}

引用了 christoffel_first_kind_checked(), christoffel_first_kind_impl(), context, dim, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, ResourceLimit , 以及 LMCAS::Result< T >::value().

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

函数调用图:

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

christoffel_first_kind_impl()

std::shared_ptr< SymbolicExpr > LMCAS::christoffel_first_kind_impl ( const std::shared_ptr< SymbolicExpr > & g_ij, const std::vector< std::string > & coords, int k, int i, int j, ComputationContext & context )

static

在文件 differential_geometry.cpp 第 423 行定义.

                                                      {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    
    auto mat = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(g_ij));
    if (!mat) return SymbolicExpr::number(0);
    
    auto g_jk = LMCAS::detail::make_expression_ptr(mat->get(j, k));
    auto g_ik = LMCAS::detail::make_expression_ptr(mat->get(i, k));
    auto g_ij_comp = LMCAS::detail::make_expression_ptr(mat->get(i, j));
    
    auto term1 = detail::make_expression_ptr(detail::differentiate_node(detail::node(g_jk), coords[i], transform_budget));
    auto term2 = detail::make_expression_ptr(detail::differentiate_node(detail::node(g_ik), coords[j], transform_budget));
    auto term3 = detail::make_expression_ptr(detail::differentiate_node(detail::node(g_ij_comp), coords[k], transform_budget));
    
    auto sum12 = SymbolicExpr::add(term1, term2);
    auto diff = SymbolicExpr::add(sum12, SymbolicExpr::multiply(term3, SymbolicExpr::number(-1)));
    
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
        SymbolicExpr::number(Rational(BigInt(1), BigInt(2))),
        diff)), transform_budget));
}

引用了 christoffel_first_kind_impl(), context, LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 christoffel_first_kind_checked(), christoffel_first_kind_impl() , 以及 christoffel_second_kind_impl().

函数调用图:

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

christoffel_second_kind_checked() [1/2]

DifferentialGeometryExprResult LMCAS::christoffel_second_kind_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		const std::shared_ptr< SymbolicExpr > &	g_up_ij,
		const std::vector< std::string > &	coords,
		int	k,
		int	i,
		int	j )

在文件 differential_geometry.cpp 第 499 行定义.

{
    ComputationContext context;
    return christoffel_second_kind_checked(g_ij, g_up_ij, coords, k, i, j, context);
}

引用了 christoffel_second_kind_checked() , 以及 context.

函数调用图:

christoffel_second_kind_checked() [2/2]

DifferentialGeometryExprResult LMCAS::christoffel_second_kind_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		const std::shared_ptr< SymbolicExpr > &	g_up_ij,
		const std::vector< std::string > &	coords,
		int	k,
		int	i,
		int	j,
		ComputationContext &	context )

在文件 differential_geometry.cpp 第 450 行定义.

{
    const std::string operation = "christoffel_second_kind";
    auto metric = validate_metric_matrix(g_ij, &coords, context, operation);
    if (!metric) {
        return DifferentialGeometryExprResult::failure(metric.error());
    }
    auto inverse_metric = validate_metric_matrix(g_up_ij, &coords, context, operation);
    if (!inverse_metric) {
        return DifferentialGeometryExprResult::failure(inverse_metric.error());
    }
    const std::size_t dim = metric.value()->rows();
    auto k_check = validate_index(k, dim, "k", operation);
    if (!k_check) {
        return DifferentialGeometryExprResult::failure(k_check.error());
    }
    auto i_check = validate_index(i, dim, "i", operation);
    if (!i_check) {
        return DifferentialGeometryExprResult::failure(i_check.error());
    }
    auto j_check = validate_index(j, dim, "j", operation);
    if (!j_check) {
        return DifferentialGeometryExprResult::failure(j_check.error());
    }
    auto budget = context.consume_steps(dim * 20 + 12, operation);
    if (!budget) {
        return DifferentialGeometryExprResult::failure(budget.error());
    }
    try {
        auto result = christoffel_second_kind_impl(g_ij, g_up_ij, coords, k, i, j, context);
        return checked_geometry_expression(std::move(result), CasErrc::Inconclusive,
                                           "Christoffel symbol could not be constructed",
                                           operation);
    } catch (const std::bad_alloc&) {
        return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit,
                                                       "allocation failed while calculating Christoffel symbol",
                                                       operation);
    } catch (const std::exception& ex) {
        return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant,
                                                       ex.what(),
                                                       operation);
    }
}

引用了 christoffel_second_kind_checked(), christoffel_second_kind_impl(), context, dim, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, ResourceLimit , 以及 LMCAS::Result< T >::value().

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

函数调用图:

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

christoffel_second_kind_impl()

std::shared_ptr< SymbolicExpr > LMCAS::christoffel_second_kind_impl ( const std::shared_ptr< SymbolicExpr > & g_ij, const std::shared_ptr< SymbolicExpr > & g_up_ij, const std::vector< std::string > & coords, int k, int i, int j, ComputationContext & context )

static

在文件 differential_geometry.cpp 第 509 行定义.

                                                      {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    
    auto mat_up = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(g_up_ij));
    if (!mat_up) return SymbolicExpr::number(0);
    
    size_t dim = coords.size();
    auto result = SymbolicExpr::number(0);
    
    for (size_t m = 0; m < dim; m++) {
        auto g_up_km = LMCAS::detail::make_expression_ptr(mat_up->get(k, m));
        auto gamma_first = christoffel_first_kind_impl(g_ij, coords, m, i, j, context);
        auto term = SymbolicExpr::multiply(g_up_km, gamma_first);
        result = SymbolicExpr::add(result, term);
    }
    
    return detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
}

引用了 christoffel_first_kind_impl(), christoffel_second_kind_impl(), context, dim, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 christoffel_second_kind_checked(), christoffel_second_kind_impl() , 以及 riemann_curvature_tensor_with_inverse().

函数调用图:

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

clamp() [1/2]

ExprResult LMCAS::clamp	(	const ExprPtr &	expression,
		const ExprPtr &	lower,
		const ExprPtr &	upper )

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

                                       {
    ComputationContext context;
    return clamp(expression, lower, upper, context);
}

引用了 clamp(), context, lower , 以及 upper.

函数调用图:

clamp() [2/2]

ExprResult LMCAS::clamp	(	const ExprPtr &	expression,
		const ExprPtr &	lower,
		const ExprPtr &	upper,
		ComputationContext &	context )

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

                                              {
    auto step = context.consume_steps(1, kMathOperation);
    if (!step) { return ExprResult::failure(step.error()); }
    if (!expression || !LMCAS::detail::node(expression) ||
        !lower || !LMCAS::detail::node(lower) ||
        !upper || !LMCAS::detail::node(upper)) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "clamp arguments cannot be null",
                                  kMathOperation);
    }
    try {
        auto max_node = LMCAS::detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Max,
            std::vector<std::shared_ptr<const SymbolicNode>>{
                LMCAS::detail::node(expression), LMCAS::detail::node(lower)});
        auto min_node = LMCAS::detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Min,
            std::vector<std::shared_ptr<const SymbolicNode>>{
                std::move(max_node), LMCAS::detail::node(upper)});
        return ExprResult::success(
            LMCAS::detail::make_expression_ptr(std::move(min_node)));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "clamp expression allocation failed",
                                  kMathOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kMathOperation);
    }
}

引用了 clamp(), context, LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::Result< ExprPtr >::failure(), InternalInvariant, InvalidArgument, LMCAS::expr_detail::expr_common::kMathOperation, lower, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::FunctionNode::Max, LMCAS::FunctionNode::Min, LMCAS::detail::node(), ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 upper.

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

函数调用图:

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

classify_first_order_ode()

ODEClassification LMCAS::classify_first_order_ode	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y )

1. 检测可分离变量

1. 检测一阶线性

1. 检测齐次方程

1. 检测 Bernoulli

1. 检测恰当方程 将 y' = rhs 改写为 M + N*y' = 0 形式: -rhs + y' = 0 即 M = -rhs, N = 1（标准形式 M*dx + N*dy = 0 → M + N*dy/dx = 0） 更一般地: 若 rhs = f(x,y)，则 -f(x,y)*dx + dy = 0 M = -f(x,y), N = 1

在文件 ode_classification.cpp 第 490 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    ODEClassification result;
    result.order = 1;
 
    if (!rhs || !LMCAS::detail::node(rhs)) {
        result.type = ODEType::Unknown;
        return result;
    }
 
    /// 1. 检测可分离变量
    if (is_separable(rhs, x, y)) {
        result.type = ODEType::Separable;
        return result;
    }
 
    /// 2. 检测一阶线性
    std::shared_ptr<SymbolicExpr> P, Q;
    if (is_linear_first_order(rhs, x, y, P, Q)) {
        result.type = ODEType::Linear1;
        result.P_coeff = P;
        result.Q_coeff = Q;
        return result;
    }
 
    /// 3. 检测齐次方程
    if (is_homogeneous_ode(rhs, x, y)) {
        result.type = ODEType::Homogeneous;
        return result;
    }
 
    /// 4. 检测 Bernoulli
    std::shared_ptr<SymbolicExpr> bP, bQ;
    int bn;
    if (is_bernoulli_ode(rhs, x, y, bP, bQ, bn)) {
        result.type = ODEType::Bernoulli;
        result.bernoulli_P = bP;
        result.bernoulli_Q = bQ;
        result.bernoulli_n = bn;
        return result;
    }
 
    /// 5. 检测恰当方程
    /// 将 y' = rhs 改写为 M + N*y' = 0 形式: -rhs + y' = 0
    /// 即 M = -rhs, N = 1（标准形式 M*dx + N*dy = 0 → M + N*dy/dx = 0）
    /// 更一般地: 若 rhs = f(x,y)，则 -f(x,y)*dx + dy = 0
    /// M = -f(x,y), N = 1
    auto neg_rhs = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), rhs)), transform_budget));
    auto one = SymbolicExpr::number(1);
    if (is_exact_ode(neg_rhs, one, x, y)) {
        result.type = ODEType::Exact;
        result.exact_M = neg_rhs;
        result.exact_N = one;
        return result;
    }
 
    result.type = ODEType::Unknown;
    return result;
}

引用了 Bernoulli, LMCAS::ODEClassification::bernoulli_n, LMCAS::ODEClassification::bernoulli_P, LMCAS::ODEClassification::bernoulli_Q, classify_first_order_ode(), context, Exact, LMCAS::ODEClassification::exact_M, LMCAS::ODEClassification::exact_N, Homogeneous, is_bernoulli_ode(), is_exact_ode(), is_homogeneous_ode(), is_linear_first_order(), is_separable(), Linear1, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::ODEClassification::order, LMCAS::ODEClassification::P_coeff, LMCAS::ODEClassification::Q_coeff, rhs, Separable, LMCAS::ODEClassification::type , 以及 Unknown.

被这些函数引用 classify_first_order_ode().

函数调用图:

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

classify_hessian_eigenvalues()

CriticalPointClassification LMCAS::classify_hessian_eigenvalues ( const std::vector< std::shared_ptr< SymbolicExpr > > & eigenvals, double tol, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_extrema.cpp 第 122 行定义.

{
    bool all_positive = true;
    bool all_negative = true;
    bool has_zero = false;
 
    for (const auto& ev : eigenvals) {
        if (!ev) {
            return CriticalPointClassification::Inconclusive;
        }
        auto ev_simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(ev), transform_budget));
        double val = 0.0;
        if (!vector_calculus_checked_finite_numeric(ev_simplified, val, context)) {
            return CriticalPointClassification::Inconclusive;
        }
 
        if (std::abs(val) < tol) {
            has_zero = true;
            all_positive = false;
            all_negative = false;
        } else if (val > 0) {
            all_negative = false;
        } else {
            all_positive = false;
        }
    }
 
    if (has_zero) {
        return CriticalPointClassification::Degenerate;
    }
    if (all_positive) {
        return CriticalPointClassification::LocalMinimum;
    }
    if (all_negative) {
        return CriticalPointClassification::LocalMaximum;
    }
    return CriticalPointClassification::Saddle;
}

引用了 classify_hessian_eigenvalues(), context, Degenerate, Inconclusive, LocalMaximum, LocalMinimum, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), Saddle , 以及 LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric().

被这些函数引用 classify_hessian_eigenvalues() , 以及 vector_calculus_classify_critical_point().

函数调用图:

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

classify_hessian_pair()

CriticalPointClassification LMCAS::classify_hessian_pair ( const std::vector< double > & numeric_H, double tol )

static

在文件 vector_calculus_extrema.cpp 第 75 行定义.

{
        double a = numeric_H[0], b = numeric_H[1];
        double c = numeric_H[2], d = numeric_H[3];
        double det = a * d - b * c;
        double trace = a + d;
 
        if (std::abs(det) < tol) {
            return CriticalPointClassification::Degenerate;
        }
        if (det > 0 && trace > 0) {
            return CriticalPointClassification::LocalMinimum;
        }
        if (det > 0 && trace < 0) {
            return CriticalPointClassification::LocalMaximum;
        }
        return CriticalPointClassification::Saddle;
}

引用了 a, b, c, classify_hessian_pair(), Degenerate, LocalMaximum, LocalMinimum , 以及 Saddle.

被这些函数引用 classify_hessian_pair() , 以及 vector_calculus_classify_critical_point().

函数调用图:

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

classify_higher_order_ode()

ODEClassification LMCAS::classify_higher_order_ode	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coeffs,
		const std::shared_ptr< SymbolicExpr > &	forcing,
		const std::string &	x,
		const std::string &	)

1. 检测当前数值分类结果能够表示的常系数

1. 检测 Euler 方程

在文件 ode_classification.cpp 第 557 行定义.

{
    ODEClassification result;
    result.order = static_cast<int>(coeffs.size()) - 1;
 
    if (coeffs.empty()) {
        result.type = ODEType::Unknown;
        return result;
    }
 
    /// 1. 检测当前数值分类结果能够表示的常系数
    if (is_constant_coefficient(coeffs, x)) {
        std::vector<double> numeric_coeffs;
        numeric_coeffs.reserve(coeffs.size());
        for (const auto& c : coeffs) {
            double val = try_eval_double(c);
            if (!std::isfinite(val)) {
                result.type = ODEType::Unknown;
                return result;
            }
            numeric_coeffs.push_back(val);
        }
 
        result.type = result.order == 2
            ? ODEType::Linear2_ConstCoeff
            : ODEType::HigherOrder_ConstCoeff;
        result.const_coeffs = std::move(numeric_coeffs);
        result.forcing_func = forcing;
        return result;
    }
 
    /// 2. 检测 Euler 方程
    std::vector<double> euler_consts;
    if (is_euler_equation(coeffs, x, euler_consts)) {
        result.type = ODEType::Euler;
        result.euler_coeffs = euler_consts;
        result.euler_forcing = forcing;
        return result;
    }
 
    result.type = ODEType::Unknown;
    return result;
}

引用了 c, classify_higher_order_ode(), LMCAS::ODEClassification::const_coeffs, Euler, LMCAS::ODEClassification::euler_coeffs, LMCAS::ODEClassification::euler_forcing, LMCAS::ODEClassification::forcing_func, HigherOrder_ConstCoeff, is_constant_coefficient(), is_euler_equation(), Linear2_ConstCoeff, LMCAS::ODEClassification::order, try_eval_double(), LMCAS::ODEClassification::type , 以及 Unknown.

被这些函数引用 classify_higher_order_ode().

函数调用图:

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

classify_inflection_candidates()

SymbolicExprVectorResult LMCAS::classify_inflection_candidates ( const FiniteSolutions & finite, const std::shared_ptr< SymbolicExpr > & f, const std::shared_ptr< SymbolicExpr > & f_prime, const std::shared_ptr< SymbolicExpr > & f_double_prime, const std::string & var, const FactsQuery & facts, ComputationContext & context, const std::string & operation )

static

在文件 calculus_curvature.cpp 第 208 行定义.

                                                                                      {
    std::vector<std::shared_ptr<SymbolicExpr>> points;
    points.reserve(finite.values.size());
    for (const auto& solution : finite.values) {
        auto step = context.consume_steps(1, operation);
        if (!step) { return SymbolicExprVectorResult::failure(step.error()); }
        if (!solution.value || !LMCAS::detail::node(solution.value)) {
            return SymbolicExprVectorResult::failure(CasErrc::InternalInvariant,
                "checked solver returned a null inflection candidate", operation);
        }
        auto real = detail::query_real_value(detail::node(solution.value), facts, context);
        if (!real) { return SymbolicExprVectorResult::failure(real.error()); }
        if (real.value() == Tribool::False) { continue; }
        if (real.value() != Tribool::True || !solution.conditions.empty()) {
            return SymbolicExprVectorResult::failure(CasErrc::Inconclusive,
                "inflection candidate is not proved unconditionally real", operation);
        }
        auto defined = inflection_curve_defined(
            f, f_prime, f_double_prime, solution.value, var, facts, operation, context);
        if (!defined) { return SymbolicExprVectorResult::failure(defined.error()); }
        if (!defined.value()) { continue; }
        points.push_back(solution.value);
    }
    return SymbolicExprVectorResult::success(std::move(points));
}

引用了 classify_inflection_candidates(), context, LMCAS::Result< T >::error(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), False, Inconclusive, inflection_curve_defined(), InternalInvariant, LMCAS::detail::node(), LMCAS::detail::query_real_value(), real(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success(), True, LMCAS::Result< T >::value() , 以及 LMCAS::FiniteSolutions::values.

被这些函数引用 classify_inflection_candidates() , 以及 inflection_points_checked().

函数调用图:

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

classify_quadratic_form()

std::string LMCAS::classify_quadratic_form

(

const ExprPtr &

A

)

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

                                                    {
    ComputationContext context;
    auto eigenvalues = matrix_eigenvalues_checked(A, context);
    if (!eigenvalues || eigenvalues.value().empty()) { return "unknown"; }
    AssumptionContext assumptions;
    detail::AssumptionFacts facts(assumptions);
    QuadraticSigns signs;
    for (const auto& eigenvalue : eigenvalues.value()) {
        auto sign = quadratic_eigenvalue_sign(eigenvalue, facts, context);
        if (!sign) { return "unknown"; }
        signs.include(*sign);
    }
    return signs.classification();
}

引用了 classify_quadratic_form(), context , 以及 matrix_eigenvalues_checked().

被这些函数引用 classify_quadratic_form().

函数调用图:

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

classify_quadric_checked() [1/2]

VectorStringResult LMCAS::classify_quadric_checked

(

const SurfaceSymbolic &

surf

)

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

                                                                         {
    ComputationContext context;
    return classify_quadric_checked(surf, context);
}

引用了 classify_quadric_checked() , 以及 context.

函数调用图:

classify_quadric_checked() [2/2]

VectorStringResult LMCAS::classify_quadric_checked	(	const SurfaceSymbolic &	surf,
		ComputationContext &	context )

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

                                 {
    const std::string operation = "classify_quadric";
    try {
        auto valid = validate_surface_point(
            surf,
            std::vector<std::shared_ptr<SymbolicExpr>>(
                surf.vars.size(), SymbolicExpr::number(0)),
            context,
            operation);
        if (!valid) return VectorStringResult::failure(valid.error());
        if (surf.vars.size() != 3) {
            return VectorStringResult::failure(
                CasErrc::InvalidArgument,
                "quadric classification requires exactly three variables",
                operation);
        }
        auto step = context.consume_steps(12, operation);
        if (!step) return VectorStringResult::failure(step.error());
        return detail::classify_quadric_impl(surf, context, operation);
    } catch (const std::bad_alloc&) {
        return VectorStringResult::failure(CasErrc::ResourceLimit,
                                           "vector geometry allocation failed",
                                           operation);
    } catch (const std::exception& e) {
        return VectorStringResult::failure(CasErrc::Inconclusive,
                                           e.what(), operation);
    }
}

引用了 classify_quadric_checked(), LMCAS::detail::classify_quadric_impl(), context, e(), LMCAS::Result< std::string >::failure(), Inconclusive, InvalidArgument, ResourceLimit, LMCAS::geometry_detail::validate_surface_point() , 以及 LMCAS::SurfaceSymbolic::vars.

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

函数调用图:

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

classify_ratio_limit()

ConvergenceInfo LMCAS::classify_ratio_limit ( const std::shared_ptr< SymbolicExpr > & lim, ComputationContext & context )

static

在文件 series_convergence.cpp 第 316 行定义.

                                                                         {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!lim) {
        return {ConvergenceResult::Inconclusive, ""};
    }
    auto ls = detail::make_expression_ptr(detail::normalize_node(detail::node(lim), transform_budget));
    auto infinity = ls
        ? std::dynamic_pointer_cast<const FunctionNode>(detail::node(ls))
        : nullptr;
    if (infinity && infinity->type() == FunctionNode::FuncType::Infinity) {
        return {ConvergenceResult::Divergent, "ratio"};
    }
    auto number = ls
        ? std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(ls))
        : nullptr;
    if (!number) {
        return {ConvergenceResult::Inconclusive, ""};
    }
    if (const auto* integer = std::get_if<BigInt>(&number->value())) {
        return {*integer < BigInt(1) ? ConvergenceResult::Convergent
                                     : *integer > BigInt(1) ? ConvergenceResult::Divergent
                                                            : ConvergenceResult::Inconclusive, "ratio"};
    }
    if (const auto* rational = std::get_if<Rational>(&number->value())) {
        return {*rational < Rational(1) ? ConvergenceResult::Convergent
                                        : *rational > Rational(1) ? ConvergenceResult::Divergent
                                                                  : ConvergenceResult::Inconclusive, "ratio"};
    }
    return {ConvergenceResult::Inconclusive, ""};
}

引用了 classify_ratio_limit(), context, Convergent, Divergent, Inconclusive, LMCAS::FunctionNode::Infinity, integer, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 rational().

被这些函数引用 classify_ratio_limit() , 以及 ratio_convergence_test().

函数调用图:

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

classify_singular_point_checked() [1/2]

ODESingularityResult LMCAS::classify_singular_point_checked	(	const std::shared_ptr< SymbolicExpr > &	p,
		const std::shared_ptr< SymbolicExpr > &	q,
		const std::shared_ptr< SymbolicExpr > &	x0,
		const std::string &	x )

在文件 ode_frobenius.cpp 第 463 行定义.

{
    ComputationContext context;
    return classify_singular_point_checked(p, q, x0, x, context);
}

引用了 classify_singular_point_checked() , 以及 context.

函数调用图:

classify_singular_point_checked() [2/2]

ODESingularityResult LMCAS::classify_singular_point_checked	(	const std::shared_ptr< SymbolicExpr > &	p,
		const std::shared_ptr< SymbolicExpr > &	q,
		const std::shared_ptr< SymbolicExpr > &	x0,
		const std::string &	x,
		ComputationContext &	context )

在文件 ode_frobenius.cpp 第 395 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "classify_singular_point";
    auto valid = validate_ode_two_expr_point(p, q, x0, x, context, operation);
    if (!valid) {
        return ODESingularityResult::failure(valid.error());
    }
    try {
        auto p_at_x0 = detail::make_expression_ptr(detail::substitute_node(detail::node(p), x, detail::node(x0), transform_budget));
        auto q_at_x0 = detail::make_expression_ptr(detail::substitute_node(detail::node(q), x, detail::node(x0), transform_budget));
        const double p_val = try_eval_double(p_at_x0);
        const double q_val = try_eval_double(q_at_x0);
        if (std::isfinite(p_val) && std::isfinite(q_val)) {
            return ODESingularityResult::success(
                ODESingularityType::Ordinary);
        }
        if ((!std::isfinite(p_val) &&
             !free_variables(detail::node(p_at_x0)).empty()) ||
            (!std::isfinite(q_val) &&
             !free_variables(detail::node(q_at_x0)).empty())) {
            return ODESingularityResult::failure(
                CasErrc::Inconclusive,
                "singularity classification requires numeric coefficient values",
                operation);
        }
 
        auto x_var = SymbolicExpr::variable(x);
        auto x_minus_x0 = SymbolicExpr::add(
            x_var, SymbolicExpr::multiply(SymbolicExpr::number(-1), x0));
        auto xp = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(x_minus_x0, p)), transform_budget));
        auto x2q = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            SymbolicExpr::power(x_minus_x0, SymbolicExpr::number(2)),
            q)), transform_budget));
        auto xp_limit = limit_checked(xp, x, x0, LimitDirection::Both, context);
        if (!xp_limit) return ODESingularityResult::failure(xp_limit.error());
        auto x2q_limit = limit_checked(x2q, x, x0, LimitDirection::Both, context);
        if (!x2q_limit) return ODESingularityResult::failure(x2q_limit.error());
        return ODESingularityResult::success(
            std::holds_alternative<FiniteLimit>(xp_limit.value().value) &&
            std::holds_alternative<FiniteLimit>(x2q_limit.value().value)
                ? ODESingularityType::RegularSingular
                : ODESingularityType::IrregularSingular);
    } catch (const std::bad_alloc&) {
        return ODESingularityResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while classifying ODE singularity",
            operation);
    } catch (const std::length_error& error) { return ODESingularityResult::failure(CasErrc::ResourceLimit, error.what(), "classify_singular_point"); } catch (const std::exception& ex) {
        return ODESingularityResult::failure(
            CasErrc::InternalInvariant, ex.what(), operation);
    }
} catch (const CasError& error) {
    return ODESingularityResult::failure(error);
} catch (const std::bad_alloc&) {
    return ODESingularityResult::failure(CasErrc::ResourceLimit, "allocation failed", "classify_singular_point");
} catch (const std::length_error& error) {
    return ODESingularityResult::failure(CasErrc::ResourceLimit, error.what(), "classify_singular_point");
} catch (const std::exception& error) {
    return ODESingularityResult::failure(CasErrc::InternalInvariant, error.what(), "classify_singular_point");
}

引用了 Both, classify_singular_point_checked(), context, LMCAS::Result< ODESingularityType >::failure(), free_variables(), Inconclusive, InternalInvariant, IrregularSingular, limit_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), Ordinary, RegularSingular, ResourceLimit, LMCAS::detail::substitute_node(), LMCAS::Result< ODESingularityType >::success(), try_eval_double() , 以及 validate_ode_two_expr_point().

被这些函数引用 classify_singular_point_checked(), classify_singular_point_checked() , 以及 solve_frobenius_checked().

函数调用图:

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

clean_number()

std::shared_ptr< SymbolicExpr > LMCAS::clean_number ( double val )

static

只在转换可表示时提升为精确小整数，避免浮点到整数的越界转换。

检查可由简单分数 p/q (q <= 12) 精确表示的 double 值。

在文件 ode_linear.cpp 第 49 行定义.

                                                            {
    /// 只在转换可表示时提升为精确小整数，避免浮点到整数的越界转换。
    double rounded = std::round(val);
    if (is_representable_small_integer(rounded) && val == rounded) {
        return SymbolicExpr::number(static_cast<int>(rounded));
    }
 
    /// 检查可由简单分数 p/q (q <= 12) 精确表示的 double 值。
    for (int q = 2; q <= 12; ++q) {
        double p = val * q;
        double p_rounded = std::round(p);
        if (is_representable_small_integer(p_rounded) &&
            val == p_rounded / q) {
            return SymbolicExpr::divide(
                SymbolicExpr::number(static_cast<int>(p_rounded)),
                SymbolicExpr::number(q));
        }
    }
 
    return SymbolicExpr::number(val);
}

引用了 clean_number() , 以及 is_representable_small_integer().

被这些函数引用 build_euler_solution(), build_homogeneous_solution() , 以及 clean_number().

函数调用图:

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

coefficient_power_radius()

std::optional< std::shared_ptr< SymbolicExpr > > LMCAS::coefficient_power_radius ( const PowerNode & power, const std::string & index_var, ComputationContext & context )

static

在文件 series_convergence.cpp 第 77 行定义.

                                                                                     {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto exponent_variable = std::dynamic_pointer_cast<const VariableNode>(
        power.exponent());
    if (series_index_variable(exponent_variable, index_var) &&
        !expression_depends_on_variable(power.base(), index_var)) {
        auto absolute = LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<FunctionNode>(
                FunctionNode::FuncType::Abs,
                std::vector<std::shared_ptr<const SymbolicNode>>{
                    power.base()}));
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(SymbolicExpr::number(1), absolute)), transform_budget));
    }
    auto base_variable = std::dynamic_pointer_cast<const VariableNode>(
        power.base());
    if (series_index_variable(base_variable, index_var) &&
        !expression_depends_on_variable(power.exponent(), index_var)) {
        return SymbolicExpr::number(1);
    }
    return std::nullopt;
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::PowerNode::base(), coefficient_power_radius(), context, LMCAS::PowerNode::exponent(), expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 series_index_variable().

被这些函数引用 coefficient_power_radius() , 以及 convergence_radius_checked().

函数调用图:

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

collect_bernoulli_coefficients()

bool LMCAS::collect_bernoulli_coefficients ( const std::vector< std::shared_ptr< const SymbolicNode > > & terms, const std::string & y, std::map< int, std::shared_ptr< SymbolicExpr > > & coefficients, ComputationContext & context )

static

在文件 ode_classification.cpp 第 278 行定义.

                                                                                         {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    for (const auto& term : terms) {
        int exponent = 0;
        std::shared_ptr<SymbolicExpr> coefficient;
        if (!extract_bernoulli_monomial(
                term, y, exponent, coefficient, context)) {
            return false;
        }
        auto& combined = coefficients[exponent];
        combined = combined
            ? detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(combined, coefficient)), transform_budget))
            : detail::make_expression_ptr(detail::normalize_node(detail::node(coefficient), transform_budget));
    }
    return true;
}

引用了 collect_bernoulli_coefficients(), context, exponent, extract_bernoulli_monomial(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 collect_bernoulli_coefficients() , 以及 is_bernoulli_ode().

函数调用图:

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

collect_exact_solutions()

SolveResult LMCAS::collect_exact_solutions ( std::vector< std::shared_ptr< SymbolicExpr > > roots, ComputationContext & context )

static

在文件 solve_visitor.cpp 第 319 行定义.

                                                                               {
    constexpr const char* operation = "solve_equation";
    std::vector<FiniteSolution> solutions;
    for (auto& root : roots) {
        auto root_step = context.consume_steps(1, operation);
        if (!root_step) {
            return SolveResult::failure(root_step.error());
        }
        if (!root || !LMCAS::detail::node(root)) {
            return SolveResult::failure(
                CasErrc::InternalInvariant,
                "polynomial solver produced a null root", operation);
        }
        auto existing = std::find_if(
            solutions.begin(), solutions.end(),
            [&](const FiniteSolution& solution) {
                return LMCAS::detail::node(solution.value)->equals(
                    *LMCAS::detail::node(root));
            });
        if (existing != solutions.end()) {
            ++existing->multiplicity;
        } else {
            solutions.push_back(
                FiniteSolution{std::move(root), 1, {}});
        }
    }
    return SolveResult::success(
        SolutionSet{FiniteSolutions{std::move(solutions)}});
}

引用了 collect_exact_solutions(), context, LMCAS::Result< SolutionSet >::failure(), InternalInvariant, LMCAS::detail::node(), roots() , 以及 LMCAS::Result< SolutionSet >::success().

被这些函数引用 collect_exact_solutions() , 以及 solve_exact_polynomial_set().

函数调用图:

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

collect_gcd_samples()

void LMCAS::collect_gcd_samples ( const MultiPoly & a_prim, const MultiPoly & b_prim, const std::string & main_var, const std::vector< Rational > & eval_pts, int num_points, GcdSamples & samples )

static

在文件 multivariate_factor.cpp 第 273 行定义.

                                                                              {
    auto& used_pts = samples.points;
    auto& gcd_vals = samples.values;
    auto& target_deg = samples.target_degree;
    for (size_t pi = 0; pi < eval_pts.size() &&
         static_cast<int>(used_pts.size()) < num_points; ++pi) {
        Rational pt = eval_pts[pi];
        MultiPoly lc_a = a_prim.leading_coeff(main_var);
        MultiPoly lc_b = b_prim.leading_coeff(main_var);
        MultiPoly lca_ev = lc_a.eval(main_var, pt);
        MultiPoly lcb_ev = lc_b.eval(main_var, pt);
        if (lca_ev.is_zero() || lcb_ev.is_zero()) { continue; }
        MultiPoly a_ev = a_prim.eval(main_var, pt);
        MultiPoly b_ev = b_prim.eval(main_var, pt);
        MultiPoly g_ev = multivariate_gcd(a_ev, b_ev);
        int gd = g_ev.is_zero() ? -1 : g_ev.total_degree();
        if (target_deg < 0) { target_deg = gd; }
        else if (gd < target_deg) { used_pts.clear(); gcd_vals.clear(); target_deg = gd; }
        else if (gd > target_deg) { continue; }
        if (!g_ev.is_zero()) { g_ev = g_ev.make_primitive(); }
        used_pts.push_back(pt);
        gcd_vals.push_back(g_ev);
    }
}

引用了 collect_gcd_samples(), main_var, multivariate_gcd(), pi(), LMCAS::GcdSamples::points, LMCAS::GcdSamples::target_degree , 以及 LMCAS::GcdSamples::values.

被这些函数引用 collect_gcd_samples(), extended_gcd_interpolation() , 以及 recursive_multivariate_gcd().

函数调用图:

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

collect_infinite_asymptotes()

Result< void > LMCAS::collect_infinite_asymptotes ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::shared_ptr< SymbolicExpr > & pos_inf, const std::shared_ptr< SymbolicExpr > & neg_inf, ComputationContext & context, AsymptoteResult & result )

static

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

{
    auto positive = limit_expression_checked(f, var, pos_inf, LimitDirection::Both, context);
    if (!positive) {
        return Result<void>::failure(positive.error());
    }
    auto negative = limit_expression_checked(f, var, neg_inf, LimitDirection::Both, context);
    if (!negative) {
        return Result<void>::failure(negative.error());
    }
    auto lim_pos = std::move(positive.value());
    auto lim_neg = std::move(negative.value());
    const bool horizontal_pos = simplify_finite_limit(lim_pos, context);
    const bool horizontal_neg = simplify_finite_limit(lim_neg, context);
    if (horizontal_pos) result.horizontal.push_back(lim_pos);
    if (horizontal_neg) {
        if (!horizontal_pos || !calculus_utils_expr_equal(lim_pos, lim_neg)) {
            result.horizontal.push_back(lim_neg);
        }
    }
    auto x_expr = SymbolicExpr::variable(var);
    if (!horizontal_pos && !horizontal_neg) {
        std::shared_ptr<SymbolicExpr> slope;
        std::shared_ptr<SymbolicExpr> intercept;
        if (calculus_utils_oblique_from_rational(f, var, slope, intercept, context)) {
            result.oblique.emplace_back(slope, intercept);
            return Result<void>::success();
        }
    }
    if (!horizontal_pos) {
        auto status = collect_oblique_asymptote(f, var, x_expr, pos_inf, context, result);
        if (!status) {
            return status;
        }
    }
    if (!horizontal_neg) {
        return collect_oblique_asymptote(f, var, x_expr, neg_inf, context, result);
    }
    return Result<void>::success();
}

引用了 Both, LMCAS::calculus_utils_detail::calculus_utils_expr_equal(), calculus_utils_oblique_from_rational(), collect_infinite_asymptotes(), collect_oblique_asymptote(), context, LMCAS::Result< T >::failure(), LMCAS::AsymptoteResult::horizontal, limit_expression_checked(), LMCAS::AsymptoteResult::oblique, simplify_finite_limit() , 以及 LMCAS::Result< T >::success().

被这些函数引用 asymptotes_checked() , 以及 collect_infinite_asymptotes().

函数调用图:

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

collect_oblique_asymptote()

Result< void > LMCAS::collect_oblique_asymptote ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::shared_ptr< SymbolicExpr > & x_expr, const std::shared_ptr< SymbolicExpr > & infinity, ComputationContext & context, AsymptoteResult & result )

static

在文件 calculus_asymptotes.cpp 第 271 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto quotient = SymbolicExpr::multiply(f,
        SymbolicExpr::power(x_expr, SymbolicExpr::number(-1)));
    auto slope_result = limit_expression_checked(
        quotient, var, infinity, LimitDirection::Both, context);
    if (!slope_result) {
        return Result<void>::failure(slope_result.error());
    }
    auto slope = std::move(slope_result.value());
    if (slope) slope = detail::make_expression_ptr(detail::normalize_node(detail::node(slope), transform_budget));
    if (!slope || calculus_utils_is_infinity(slope) || slope->is_zero()) {
        return Result<void>::success();
    }
    auto linear = SymbolicExpr::multiply(slope, x_expr);
    auto remainder = SymbolicExpr::add(f,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), linear));
    auto intercept_result = limit_expression_checked(
        remainder, var, infinity, LimitDirection::Both, context);
    if (!intercept_result) {
        return Result<void>::failure(intercept_result.error());
    }
    auto intercept = std::move(intercept_result.value());
    if (intercept) intercept = detail::make_expression_ptr(detail::normalize_node(detail::node(intercept), transform_budget));
    if (intercept && !calculus_utils_is_infinity(intercept)) {
        if (!has_oblique_asymptote(result, slope, intercept)) {
            result.oblique.emplace_back(slope, intercept);
        }
    }
    return Result<void>::success();
} catch (const CasError& error) {
    return Result<void>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<void>::failure(CasErrc::ResourceLimit, "allocation failed", "collect_oblique_asymptote");
} catch (const std::length_error& error) {
    return Result<void>::failure(CasErrc::ResourceLimit, error.what(), "collect_oblique_asymptote");
} catch (const std::exception& error) {
    return Result<void>::failure(CasErrc::InternalInvariant, error.what(), "collect_oblique_asymptote");
}

引用了 Both, LMCAS::calculus_utils_detail::calculus_utils_is_infinity(), collect_oblique_asymptote(), context, LMCAS::Result< T >::failure(), has_oblique_asymptote(), limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::AsymptoteResult::oblique , 以及 LMCAS::Result< T >::success().

被这些函数引用 collect_infinite_asymptotes() , 以及 collect_oblique_asymptote().

函数调用图:

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

collect_operand_denominators()

bool LMCAS::collect_operand_denominators ( const std::vector< std::shared_ptr< const SymbolicNode > > & operands, std::vector< std::shared_ptr< const SymbolicNode > > & den_factors, std::vector< std::shared_ptr< SymbolicExpr > > & den_constraints )

static

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

                                                             {
    for (const auto& operand : operands) {
        if (!collect_denominator_factors(operand, den_factors, den_constraints)) {
            return false;
        }
    }
    return true;
}

引用了 LMCAS::solver_detail::collect_denominator_factors() , 以及 collect_operand_denominators().

被这些函数引用 LMCAS::solver_detail::collect_denominator_factors() , 以及 collect_operand_denominators().

函数调用图:

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

collect_power_denominators()

bool LMCAS::collect_power_denominators ( const PowerNode & power, std::vector< std::shared_ptr< const SymbolicNode > > & den_factors, std::vector< std::shared_ptr< SymbolicExpr > > & den_constraints )

static

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

                                                             {
    BigInt exp(0);
    if (!get_integer_value(power.exponent(), exp)) {
        return false;
    }
 
    if (exp < 0) {
        if (!is_polynomial_node(power.base())) {
            return false;
        }
        BigInt k = -exp;
        if (k == 1) {
            den_factors.push_back(power.base());
        } else {
            den_factors.push_back(SymbolicFactory::create_power(power.base(), SymbolicFactory::create_number(k)));
        }
        den_constraints.push_back(LMCAS::detail::make_expression_ptr(power.base()));
        return true;
    }
 
    if (!collect_denominator_factors(power.base(), den_factors, den_constraints)) {
        return false;
    }
    return true;
}

引用了 LMCAS::PowerNode::base(), LMCAS::solver_detail::collect_denominator_factors(), collect_power_denominators(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_power(), exp(), LMCAS::PowerNode::exponent(), get_integer_value(), LMCAS::solver_detail::is_polynomial_node() , 以及 LMCAS::detail::make_expression_ptr().

被这些函数引用 LMCAS::solver_detail::collect_denominator_factors() , 以及 collect_power_denominators().

函数调用图:

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

collect_scalar_radical()

bool LMCAS::collect_scalar_radical ( const SymbolicNode * node, Rational & coefficient, const NumberNode *& radicand )

static

在文件 solver_assumptions.cpp 第 122 行定义.

                                                                {
    const auto* product = dynamic_cast<const MultiplyNode*>(node);
    if (!product) {
        radicand = exact_scalar_radicand(node);
        return radicand != nullptr;
    }
    for (const auto& factor : product->operands()) {
        if (const auto* number = exact_scalar_number(factor.get())) {
            coefficient = coefficient * exact_number_as_rational(*number);
        } else {
            if (radicand) {
                return false;
            }
            radicand = exact_scalar_radicand(factor.get());
            if (!radicand) {
                return false;
            }
        }
    }
    return radicand != nullptr;
}

引用了 collect_scalar_radical(), exact_number_as_rational(), exact_scalar_number() , 以及 exact_scalar_radicand().

被这些函数引用 collect_scalar_radical() , 以及 exact_radical_domain_excludes().

函数调用图:

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

collect_vertical_asymptotes()

Result< void > LMCAS::collect_vertical_asymptotes ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, ComputationContext & context, AsymptoteResult & result, const std::string & operation )

static

在文件 calculus_asymptotes.cpp 第 232 行定义.

{
    auto denominator = calculus_utils_extract_denominator(f);
    if (!denominator) {
        return Result<void>::success();
    }
    auto zeros = asymptote_candidates(denominator, var, context, operation);
    if (!zeros) {
        return Result<void>::failure(zeros.error());
    }
    for (const auto& point : zeros.value()) {
        if (!point || calculus_utils_is_infinity(point)) {
            continue;
        }
        auto vertical = is_vertical_asymptote(f, var, point, context);
        if (!vertical) {
            return Result<void>::failure(vertical.error());
        }
        if (vertical.value()) result.vertical.push_back(point);
    }
    return Result<void>::success();
}

引用了 asymptote_candidates(), calculus_utils_extract_denominator(), LMCAS::calculus_utils_detail::calculus_utils_is_infinity(), collect_vertical_asymptotes(), context, denominator, LMCAS::Result< T >::failure(), is_vertical_asymptote(), point, LMCAS::Result< T >::success() , 以及 LMCAS::AsymptoteResult::vertical.

被这些函数引用 asymptotes_checked() , 以及 collect_vertical_asymptotes().

函数调用图:

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

combine_operands()

template<typename Operation>

std::shared_ptr< const SymbolicNode > LMCAS::combine_operands ( std::vector< std::shared_ptr< const SymbolicNode > > operands )

static

在文件 matcher.cpp 第 68 行定义.

                                                           {
    if constexpr (std::is_same_v<Operation, AddNode>) {
        return SymbolicFactory::create_add(std::move(operands));
    } else {
        return SymbolicFactory::create_multiply(std::move(operands));
    }
}

引用了 combine_operands(), LMCAS::SymbolicFactory::create_add() , 以及 LMCAS::SymbolicFactory::create_multiply().

被这些函数引用 combine_operands() , 以及 record_remainder().

函数调用图:

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

comparable_endpoint() [1/3]

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);
}

被这些函数引用 LMCAS::anonymous_namespace{interval_set_operations.cpp}::checked_interval_views(), LMCAS::anonymous_namespace{interval_normalization.cpp}::collect_nonempty_intervals(), interval_contains_checked() , 以及 interval_is_empty_checked().

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

comparable_endpoint() [2/3]

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() [3/3]

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);
}

compare_comparable() [1/3]

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::anonymous_namespace{interval_normalization.cpp}::collect_nonempty_intervals(), interval_contains_checked(), interval_is_empty_checked(), LMCAS::anonymous_namespace{interval_normalization.cpp}::merge_checked_intervals() , 以及 LMCAS::anonymous_namespace{interval_normalization.cpp}::sort_checked_intervals().

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

compare_comparable() [2/3]

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);
}

compare_comparable() [3/3]

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);
}

complementary_square()

bool LMCAS::complementary_square ( const std::shared_ptr< const SymbolicNode > & node, const TrigSquare & square )

static

在文件 transcendental_pythagorean.cpp 第 111 行定义.

                                                                             {
    TrigSquare other;
    if (!tf_extract_coeff_trig_squared(
            node, other.coefficient, other.type, other.argument)) {
        return false;
    }
    const auto target = square.type == FunctionNode::FuncType::Sin
        ? FunctionNode::FuncType::Cos : FunctionNode::FuncType::Sin;
    if (other.type != target || !square.argument || !other.argument ||
        !square.argument->equals(*other.argument)) {
        return false;
    }
    if (!square.coefficient || !other.coefficient) {
        return !square.coefficient && !other.coefficient;
    }
    return square.coefficient->equals(*other.coefficient);
}

引用了 LMCAS::TrigSquare::argument, LMCAS::TrigSquare::coefficient, complementary_square(), LMCAS::FunctionNode::Cos, LMCAS::SymbolicNode::equals(), LMCAS::FunctionNode::Sin, target, tf_extract_coeff_trig_squared() , 以及 LMCAS::TrigSquare::type.

被这些函数引用 complementary_square() , 以及 find_complementary_square().

函数调用图:

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

complex()

ExprResult LMCAS::complex	(	ExprPtr	real,
		ExprPtr	imag )

在文件 expr_values.cpp 第 128 行定义.

                                               {
    if (!real || !imag) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "complex expression parts cannot be null",
                                  kComplexOperation);
    }
    try {
        auto node = SymbolicFactory::create_complex(LMCAS::detail::node(real),
                                                    LMCAS::detail::node(imag));
        return ExprResult::success(LMCAS::detail::make_expression_ptr(std::move(node)));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "complex expression allocation failed",
                                  kComplexOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kComplexOperation);
    }
}

引用了 complex(), LMCAS::SymbolicFactory::create_complex(), LMCAS::expr_detail::expr_common::expression_failure(), imag, InternalInvariant, InvalidArgument, LMCAS::expr_detail::expr_common::kComplexOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), real(), ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::ComplexProduct::accumulate(), calculus_utils_contains_nonreal_sqrt(), calculus_utils_extract_real_candidate(), LMCAS::equivalence_detail::canonicalize_complex_product(), LMCAS::anonymous_namespace{residual_verification.cpp}::collect_residual_profiles(), complex(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::complex_facts(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_node(), LMCAS::anonymous_namespace{limit_result.cpp}::elementary_continuous_structure(), LMCAS::detail::evaluate_root_complex(), LMCAS::NormalizationVisitor::expand_product(), imaginary_unit(), LMCAS::NormalizationVisitor::merge_complex_terms() , 以及 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::structural().

函数调用图:

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

complex_abs_checked() [1/2]

ExpressionResult LMCAS::complex_abs_checked

(

const ComplexSymbolic &

z

)

在文件 symbolic_complex.cpp 第 193 行定义.

                                                               {
    ComputationContext context;
    return complex_abs_checked(z, context);
}

引用了 complex_abs_checked() , 以及 context.

函数调用图:

complex_abs_checked() [2/2]

ExpressionResult LMCAS::complex_abs_checked	(	const ComplexSymbolic &	z,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 182 行定义.

                                                                                            {
    auto vz = validate_complex_symbolic(z, "z", context, kComplexAbsOperation);
    if (!vz) return ExpressionResult::failure(vz.error());
    auto budget = context.consume_steps(8, kComplexAbsOperation);
    if (!budget) return ExpressionResult::failure(budget.error());
    return checked_construct<std::shared_ptr<SymbolicExpr>>([&]() {
        return SymbolicExpr::sqrt(SymbolicExpr::add(
            SymbolicExpr::power(z.real, SymbolicExpr::number(2)),
            SymbolicExpr::power(z.imag, SymbolicExpr::number(2))));
    }, kComplexAbsOperation);
}

引用了 complex_abs_checked(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::ComplexSymbolic::imag , 以及 LMCAS::ComplexSymbolic::real.

被这些函数引用 complex_abs_checked(), complex_abs_checked(), complex_locus_circle_checked() , 以及 complex_locus_perpendicular_bisector_checked().

函数调用图:

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

complex_add_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_add_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b )

在文件 symbolic_complex.cpp 第 91 行定义.

                                                                                              {
    ComputationContext context;
    return complex_add_checked(a, b, context);
}

引用了 a, b, complex_add_checked() , 以及 context.

函数调用图:

complex_add_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_add_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 79 行定义.

                                                                       {
    auto va = validate_complex_symbolic(a, "a", context, kComplexAddOperation);
    if (!va) return ComplexSymbolicResult::failure(va.error());
    auto vb = validate_complex_symbolic(b, "b", context, kComplexAddOperation);
    if (!vb) return ComplexSymbolicResult::failure(vb.error());
    auto budget = context.consume_steps(4, kComplexAddOperation);
    if (!budget) return ComplexSymbolicResult::failure(budget.error());
    return checked_construct<ComplexSymbolic>([&]() {
        return make_complex(SymbolicExpr::add(a.real, b.real), SymbolicExpr::add(a.imag, b.imag));
    }, kComplexAddOperation);
}

引用了 a, b, complex_add_checked(), context, LMCAS::Result< ComplexSymbolic >::failure() , 以及 make_complex().

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

函数调用图:

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

complex_arg_checked() [1/2]

ExpressionResult LMCAS::complex_arg_checked

(

const ComplexSymbolic &

z

)

在文件 symbolic_complex.cpp 第 207 行定义.

                                                               {
    ComputationContext context;
    return complex_arg_checked(z, context);
}

引用了 complex_arg_checked() , 以及 context.

函数调用图:

complex_arg_checked() [2/2]

ExpressionResult LMCAS::complex_arg_checked	(	const ComplexSymbolic &	z,
		ComputationContext &	context )

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

                                                                                            {
    auto vz = validate_complex_symbolic(z, "z", context, kComplexArgOperation);
    if (!vz) return ExpressionResult::failure(vz.error());
    auto budget = context.consume_steps(4, kComplexArgOperation);
    if (!budget) return ExpressionResult::failure(budget.error());
    return checked_construct<std::shared_ptr<SymbolicExpr>>([&]() {
        return SymbolicExpr::atan2(z.imag, z.real);
    }, kComplexArgOperation);
}

引用了 complex_arg_checked(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::ComplexSymbolic::imag , 以及 LMCAS::ComplexSymbolic::real.

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

函数调用图:

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

complex_conj_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_conj_checked

(

const ComplexSymbolic &

z

)

在文件 symbolic_complex.cpp 第 177 行定义.

                                                                     {
    ComputationContext context;
    return complex_conj_checked(z, context);
}

引用了 complex_conj_checked() , 以及 context.

函数调用图:

complex_conj_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_conj_checked	(	const ComplexSymbolic &	z,
		ComputationContext &	context )

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

                                                                                                  {
    auto vz = validate_complex_symbolic(z, "z", context, kComplexConjOperation);
    if (!vz) return ComplexSymbolicResult::failure(vz.error());
    auto budget = context.consume_steps(3, kComplexConjOperation);
    if (!budget) return ComplexSymbolicResult::failure(budget.error());
    return checked_construct<ComplexSymbolic>([&]() {
        return make_complex(z.real, SymbolicExpr::multiply(SymbolicExpr::number(-1), z.imag));
    }, kComplexConjOperation);
}

引用了 complex_conj_checked(), context, LMCAS::Result< ComplexSymbolic >::failure(), LMCAS::ComplexSymbolic::imag, make_complex() , 以及 LMCAS::ComplexSymbolic::real.

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

函数调用图:

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

complex_div_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_div_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b )

在文件 symbolic_complex.cpp 第 163 行定义.

                                                                                              {
    ComputationContext context;
    return complex_div_checked(a, b, context);
}

引用了 a, b, complex_div_checked() , 以及 context.

函数调用图:

complex_div_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_div_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 137 行定义.

                                                                       {
    auto va = validate_complex_symbolic(a, "a", context, kComplexDivOperation);
    if (!va) return ComplexSymbolicResult::failure(va.error());
    auto vb = validate_complex_symbolic(b, "b", context, kComplexDivOperation);
    if (!vb) return ComplexSymbolicResult::failure(vb.error());
    if (LMCAS::detail::node(b.real)->is_zero() && LMCAS::detail::node(b.imag)->is_zero()) {
        return ComplexSymbolicResult::failure(
            CasErrc::DomainError, "complex division by zero", kComplexDivOperation);
    }
    auto budget = context.consume_steps(16, kComplexDivOperation);
    if (!budget) return ComplexSymbolicResult::failure(budget.error());
    return checked_construct<ComplexSymbolic>([&]() {
        auto denom = SymbolicExpr::add(SymbolicExpr::power(b.real, SymbolicExpr::number(2)),
                                       SymbolicExpr::power(b.imag, SymbolicExpr::number(2)));
        auto real = SymbolicExpr::divide(
            SymbolicExpr::add(SymbolicExpr::multiply(a.real, b.real), SymbolicExpr::multiply(a.imag, b.imag)),
            denom);
        auto imag = SymbolicExpr::divide(
            SymbolicExpr::add(SymbolicExpr::multiply(a.imag, b.real),
                              SymbolicExpr::multiply(SymbolicExpr::number(-1),
                                                     SymbolicExpr::multiply(a.real, b.imag))),
            denom);
        return make_complex(real, imag);
    }, kComplexDivOperation);
}

引用了 a, b, complex_div_checked(), context, DomainError, LMCAS::Result< ComplexSymbolic >::failure(), imag, LMCAS::SymbolicNode::is_zero(), make_complex(), LMCAS::detail::node() , 以及 real().

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

函数调用图:

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

complex_exp_form_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_exp_form_checked	(	std::shared_ptr< SymbolicExpr >	r,
		std::shared_ptr< SymbolicExpr >	theta )

在文件 symbolic_complex.cpp 第 227 行定义.

                                                                                  {
    ComputationContext context;
    return complex_exp_form_checked(std::move(r), std::move(theta), context);
}

引用了 complex_exp_form_checked(), context , 以及 r.

函数调用图:

complex_exp_form_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_exp_form_checked	(	std::shared_ptr< SymbolicExpr >	r,
		std::shared_ptr< SymbolicExpr >	theta,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 212 行定义.

                                                                            {
    auto vr = validate_expr(r, "r", context, kComplexPolarOperation);
    if (!vr) return ComplexSymbolicResult::failure(vr.error());
    auto vt = validate_expr(theta, "theta", context, kComplexPolarOperation);
    if (!vt) return ComplexSymbolicResult::failure(vt.error());
    auto budget = context.consume_steps(6, kComplexPolarOperation);
    if (!budget) return ComplexSymbolicResult::failure(budget.error());
    return checked_construct<ComplexSymbolic>([&]() {
        auto real = SymbolicExpr::multiply(r, SymbolicExpr::cos(theta));
        auto imag = SymbolicExpr::multiply(r, SymbolicExpr::sin(theta));
        return make_complex(real, imag);
    }, kComplexPolarOperation);
}

引用了 complex_exp_form_checked(), context, LMCAS::Result< ComplexSymbolic >::failure(), imag, make_complex(), r , 以及 real().

被这些函数引用 complex_exp_form_checked(), complex_exp_form_checked(), complex_trig_form_checked() , 以及 solve_complex_nth_root_checked().

函数调用图:

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

complex_locus_circle_checked() [1/2]

ExpressionResult LMCAS::complex_locus_circle_checked	(	const ComplexSymbolic &	a,
		std::shared_ptr< SymbolicExpr >	r,
		const std::string &	z_var )

在文件 symbolic_complex.cpp 第 347 行定义.

                            {
    ComputationContext context;
    return complex_locus_circle_checked(a, std::move(r), z_var, context);
}

引用了 a, complex_locus_circle_checked(), context, r , 以及 z_var.

函数调用图:

complex_locus_circle_checked() [2/2]

ExpressionResult LMCAS::complex_locus_circle_checked	(	const ComplexSymbolic &	a,
		std::shared_ptr< SymbolicExpr >	r,
		const std::string &	z_var,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 317 行定义.

                                                         {
    auto va = validate_complex_symbolic(
        a, "a", context, kComplexLocusCircleOperation);
    if (!va) return ExpressionResult::failure(va.error());
    auto vr = validate_expr(r, "r", context, kComplexLocusCircleOperation);
    if (!vr) return ExpressionResult::failure(vr.error());
    if (z_var.empty()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument, "complex variable must not be empty",
            kComplexLocusCircleOperation);
    }
    return checked_construct<std::shared_ptr<SymbolicExpr>>(
        [&]() -> ExpressionResult {
            auto z = SymbolicExpr::variable(z_var);
            auto difference = complex_sub_checked(
                make_complex(z, SymbolicExpr::number(0)), a, context);
            if (!difference) {
                return ExpressionResult::failure(difference.error());
            }
            auto magnitude =
                complex_abs_checked(difference.value(), context);
            if (!magnitude) {
                return ExpressionResult::failure(magnitude.error());
            }
            return SymbolicExpr::eq(magnitude.value(), r);
        }, kComplexLocusCircleOperation);
}

引用了 a, complex_abs_checked(), complex_locus_circle_checked(), complex_sub_checked(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, make_complex(), r , 以及 z_var.

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

函数调用图:

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

complex_locus_perpendicular_bisector_checked() [1/2]

ExpressionResult LMCAS::complex_locus_perpendicular_bisector_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b,
		const std::string &	z_var )

在文件 symbolic_complex.cpp 第 391 行定义.

                            {
    ComputationContext context;
    return complex_locus_perpendicular_bisector_checked(
        a, b, z_var, context);
}

引用了 a, b, complex_locus_perpendicular_bisector_checked(), context , 以及 z_var.

函数调用图:

complex_locus_perpendicular_bisector_checked() [2/2]

ExpressionResult LMCAS::complex_locus_perpendicular_bisector_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b,
		const std::string &	z_var,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 354 行定义.

                                                         {
    auto va = validate_complex_symbolic(
        a, "a", context, kComplexLocusBisectorOperation);
    if (!va) return ExpressionResult::failure(va.error());
    auto vb = validate_complex_symbolic(
        b, "b", context, kComplexLocusBisectorOperation);
    if (!vb) return ExpressionResult::failure(vb.error());
    if (z_var.empty()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument, "complex variable must not be empty",
            kComplexLocusBisectorOperation);
    }
    return checked_construct<std::shared_ptr<SymbolicExpr>>(
        [&]() -> ExpressionResult {
            auto z = SymbolicExpr::variable(z_var);
            auto z_as_complex =
                make_complex(z, SymbolicExpr::number(0));
            auto from_a = complex_sub_checked(z_as_complex, a, context);
            if (!from_a) return ExpressionResult::failure(from_a.error());
            auto from_b = complex_sub_checked(z_as_complex, b, context);
            if (!from_b) return ExpressionResult::failure(from_b.error());
            auto distance_a =
                complex_abs_checked(from_a.value(), context);
            if (!distance_a) {
                return ExpressionResult::failure(distance_a.error());
            }
            auto distance_b =
                complex_abs_checked(from_b.value(), context);
            if (!distance_b) {
                return ExpressionResult::failure(distance_b.error());
            }
            return SymbolicExpr::eq(distance_a.value(), distance_b.value());
        }, kComplexLocusBisectorOperation);
}

引用了 a, b, complex_abs_checked(), complex_locus_perpendicular_bisector_checked(), complex_sub_checked(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, make_complex() , 以及 z_var.

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

函数调用图:

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

complex_mul_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_mul_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b )

在文件 symbolic_complex.cpp 第 132 行定义.

                                                                                              {
    ComputationContext context;
    return complex_mul_checked(a, b, context);
}

引用了 a, b, complex_mul_checked() , 以及 context.

函数调用图:

complex_mul_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_mul_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b,
		ComputationContext &	context )

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

                                                                       {
    auto va = validate_complex_symbolic(a, "a", context, kComplexMulOperation);
    if (!va) return ComplexSymbolicResult::failure(va.error());
    auto vb = validate_complex_symbolic(b, "b", context, kComplexMulOperation);
    if (!vb) return ComplexSymbolicResult::failure(vb.error());
    auto budget = context.consume_steps(10, kComplexMulOperation);
    if (!budget) return ComplexSymbolicResult::failure(budget.error());
    return checked_construct<ComplexSymbolic>([&]() {
        auto real = SymbolicExpr::add(
            SymbolicExpr::multiply(a.real, b.real),
            SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::multiply(a.imag, b.imag)));
        auto imag = SymbolicExpr::add(SymbolicExpr::multiply(a.real, b.imag),
                                      SymbolicExpr::multiply(a.imag, b.real));
        return make_complex(real, imag);
    }, kComplexMulOperation);
}

引用了 a, b, complex_mul_checked(), context, LMCAS::Result< ComplexSymbolic >::failure(), imag, make_complex() , 以及 real().

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

函数调用图:

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

complex_sub_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_sub_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b )

在文件 symbolic_complex.cpp 第 110 行定义.

                                                                                              {
    ComputationContext context;
    return complex_sub_checked(a, b, context);
}

引用了 a, b, complex_sub_checked() , 以及 context.

函数调用图:

complex_sub_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_sub_checked	(	const ComplexSymbolic &	a,
		const ComplexSymbolic &	b,
		ComputationContext &	context )

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

                                                                       {
    auto va = validate_complex_symbolic(a, "a", context, kComplexSubOperation);
    if (!va) return ComplexSymbolicResult::failure(va.error());
    auto vb = validate_complex_symbolic(b, "b", context, kComplexSubOperation);
    if (!vb) return ComplexSymbolicResult::failure(vb.error());
    auto budget = context.consume_steps(6, kComplexSubOperation);
    if (!budget) return ComplexSymbolicResult::failure(budget.error());
    return checked_construct<ComplexSymbolic>([&]() {
        return make_complex(
            SymbolicExpr::add(a.real, SymbolicExpr::multiply(SymbolicExpr::number(-1), b.real)),
            SymbolicExpr::add(a.imag, SymbolicExpr::multiply(SymbolicExpr::number(-1), b.imag)));
    }, kComplexSubOperation);
}

引用了 a, b, complex_sub_checked(), context, LMCAS::Result< ComplexSymbolic >::failure() , 以及 make_complex().

被这些函数引用 complex_locus_circle_checked(), complex_locus_perpendicular_bisector_checked(), complex_sub_checked() , 以及 complex_sub_checked().

函数调用图:

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

complex_trig_form_checked() [1/2]

ComplexSymbolicResult LMCAS::complex_trig_form_checked	(	std::shared_ptr< SymbolicExpr >	r,
		std::shared_ptr< SymbolicExpr >	theta )

在文件 symbolic_complex.cpp 第 238 行定义.

                                                                                   {
    ComputationContext context;
    return complex_trig_form_checked(std::move(r), std::move(theta), context);
}

引用了 complex_trig_form_checked(), context , 以及 r.

函数调用图:

complex_trig_form_checked() [2/2]

ComplexSymbolicResult LMCAS::complex_trig_form_checked	(	std::shared_ptr< SymbolicExpr >	r,
		std::shared_ptr< SymbolicExpr >	theta,
		ComputationContext &	context )

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

                                                                             {
    return complex_exp_form_checked(std::move(r), std::move(theta), context);
}

引用了 complex_exp_form_checked(), complex_trig_form_checked(), context , 以及 r.

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

函数调用图:

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

complexes()

NumberDomainSet LMCAS::complexes

(

)

在文件 expr_number_domains.cpp 第 369 行定义.

                            {
    return NumberDomainSet(NumberDomain::Complexes);
}

引用了 Complexes , 以及 complexes().

被这些函数引用 complexes().

函数调用图:

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

composition_inner_powers()

Result< void > LMCAS::composition_inner_powers ( const std::vector< std::shared_ptr< SymbolicExpr > > & g, std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > & gp, int order, ComputationContext & context, const std::string & operation )

static

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

                                                                        {
    const size_t n = gp.size();
    gp[0].resize(n, SymbolicExpr::number(0));
    gp[0][0] = SymbolicExpr::number(1);
    if (n > 1) {
        gp[1].resize(n, SymbolicExpr::number(0));
        for (size_t i = 0; i < std::min(g.size(), n); ++i) {
            gp[1][i] = g[i] ? g[i] : SymbolicExpr::number(0);
        }
    }
    for (size_t k = 2; k < n; ++k) {
        auto step = context.consume_steps(1, operation);
        if (!step) {
            return step;
        }
        auto multiplied = power_series_multiply_checked(gp[k-1], gp[1], order, context);
        if (!multiplied) {
            return Result<void>::failure(multiplied.error());
        }
        gp[k] = std::move(multiplied.value());
    }
    return Result<void>::success();
}

引用了 composition_inner_powers(), context, LMCAS::Result< T >::failure(), order, power_series_multiply_checked() , 以及 LMCAS::Result< T >::success().

被这些函数引用 composition_inner_powers() , 以及 power_series_compose_checked().

函数调用图:

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

conditional_equation()

SolveResult LMCAS::conditional_equation ( const ExprPtr & original, const std::string & variable )

static

在文件 solve_visitor.cpp 第 55 行定义.

                                                                                            {
    return SolutionSet{ConditionalSolutions{ConditionSet{variable, equation_predicate(original), {}}}};
}

引用了 conditional_equation(), equation_predicate() , 以及 variable.

被这些函数引用 conditional_equation(), solve_product_set() , 以及 solve_symbolic_polynomial_set().

函数调用图:

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

conditional_linear_polynomial()

SolveResult LMCAS::conditional_linear_polynomial ( const Polynomial< SymbolicPolyCoeff > & polynomial, const ExprPtr & leading, const std::string & variable )

static

在文件 solve_visitor.cpp 第 74 行定义.

                                                       {
    auto constant = get_coeff(polynomial, 0);
    auto zero = SymbolicExpr::number(0);
    auto generic = polynomial_logic(
        polynomial_relation(leading, zero, RelationOp::NEQ),
        polynomial_relation(
            SymbolicExpr::multiply(
                leading, SymbolicExpr::variable(variable)),
            SymbolicExpr::multiply(
                SymbolicExpr::number(-1), constant),
            RelationOp::EQ),
        LogicalNode::Op::And);
    auto degenerate = polynomial_logic(
        polynomial_relation(leading, zero, RelationOp::EQ),
        polynomial_relation(constant, zero, RelationOp::EQ),
        LogicalNode::Op::And);
    return SolutionSet{ConditionalSolutions{ConditionSet{
        variable,
        polynomial_logic(generic, degenerate, LogicalNode::Op::Or),
        {}}}};
}

引用了 LMCAS::LogicalNode::And, conditional_linear_polynomial(), EQ, get_coeff(), NEQ, LMCAS::LogicalNode::Or, polynomial_logic(), polynomial_relation() , 以及 variable.

被这些函数引用 conditional_linear_polynomial() , 以及 solve_symbolic_polynomial_set().

函数调用图:

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

conj() [1/2]

ExprResult LMCAS::conj

(

const ExprPtr &

expression

)

在文件 expr_arithmetic.cpp 第 123 行定义.

                                           {
    ComputationContext context;
    return conj(expression, context);
}

引用了 conj() , 以及 context.

函数调用图:

conj() [2/2]

ExprResult LMCAS::conj	(	const ExprPtr &	expression,
		ComputationContext &	context )

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

                                                                        {
    return expr_from_complex_result(conjugate_checked(expression, context),
                                    kConjOperation);
}

引用了 conj(), conjugate_checked(), context, LMCAS::expr_detail::expr_common::expr_from_complex_result() , 以及 LMCAS::expr_detail::expr_common::kConjOperation.

被这些函数引用 conj(), conj() , 以及 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function().

函数调用图:

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

conjugate_checked() [1/2]

ExpressionResult LMCAS::conjugate_checked

(

const std::shared_ptr< SymbolicExpr > &

expr

)

在文件 complex_analysis.cpp 第 621 行定义.

                                                                            {
    ComputationContext context;
    return conjugate_checked(expr, context);
}

引用了 conjugate_checked() , 以及 context.

函数调用图:

conjugate_checked() [2/2]

ExpressionResult LMCAS::conjugate_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context )

conj(a+bi) = a - bi

在文件 complex_analysis.cpp 第 571 行定义.

                                                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "conjugate";
    auto input = validate_complex_expr_input(expr, context, operation);
    if (!input) return ExpressionResult::failure(input.error());
    if (has_function_of_explicit_complex(LMCAS::detail::node(expr))) {
        return ExpressionResult::failure(
            CasErrc::Inconclusive,
            "conjugate of functions with complex arguments is outside the current support domain",
            operation);
    }
 
    std::shared_ptr<SymbolicExpr> re, im;
    split_real_imag(LMCAS::detail::node(expr), re, im, context);
    /// conj(a+bi) = a - bi
    auto neg_im = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), im)), transform_budget));
    if (!re || !LMCAS::detail::node(re) || !neg_im || !LMCAS::detail::node(neg_im)) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                          "conjugate construction failed",
                                          operation);
    }
    if (LMCAS::detail::node(neg_im) && LMCAS::detail::node(neg_im)->is_zero()) {
        auto simplified_re = detail::make_expression_ptr(detail::normalize_node(detail::node(re), transform_budget));
        if (!simplified_re || !LMCAS::detail::node(simplified_re)) {
            return ExpressionResult::failure(CasErrc::InternalInvariant,
                                              "conjugate construction failed",
                                              operation);
        }
        return ExpressionResult::success(simplified_re);
    }
    auto cn = SymbolicFactory::create_complex(
        detail::normalize_node(detail::node(re), transform_budget), LMCAS::detail::node(neg_im));
    if (!cn) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                          "conjugate construction failed",
                                          operation);
    }
    return ExpressionResult::success(LMCAS::detail::make_expression_ptr(cn));
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "conjugate");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "conjugate");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "conjugate");
}

引用了 conjugate_checked(), context, LMCAS::SymbolicFactory::create_complex(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 conj(), conjugate_checked() , 以及 conjugate_checked().

函数调用图:

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

consume_digits()

bool LMCAS::consume_digits ( const std::string & str, size_t & pos )

static

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

                                                              {
    const size_t start = pos;
    while (pos < str.size() &&
           std::isdigit(static_cast<unsigned char>(str[pos]))) {
        ++pos;
    }
    return pos != start;
}

引用了 consume_digits().

被这些函数引用 consume_digits(), parse_fraction() , 以及 parse_numeric_value().

函数调用图:

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

consume_sign()

void LMCAS::consume_sign ( const std::string & str, size_t & pos )

static

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

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

引用了 consume_sign().

被这些函数引用 consume_sign() , 以及 parse_numeric_value().

函数调用图:

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

contains()

bool LMCAS::contains	(	const SymbolicExpr &	expression,
		const std::string &	variable )

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

                                                                         {
    return expression_depends_on_variable(
        LMCAS::detail::node(expression), variable);
}

引用了 contains(), expression_depends_on_variable(), LMCAS::detail::node() , 以及 variable.

被这些函数引用 __attribute__(), contains(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::depends_on_remaining(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::depends_on_remaining_unknown(), expr_set_subset_domain(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::select_equation() , 以及 LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::select_target().

函数调用图:

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

contains_inverse_candidate()

bool LMCAS::contains_inverse_candidate ( const std::vector< std::shared_ptr< SymbolicExpr > > & candidates, const std::shared_ptr< SymbolicExpr > & candidate )

static

在文件 calculus_inverse.cpp 第 172 行定义.

{
    for (const auto& existing : candidates) {
        if (existing && LMCAS::detail::node(existing) &&
            LMCAS::detail::node(existing)->equals(*LMCAS::detail::node(candidate))) {
            return true;
        }
    }
    return false;
}

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

被这些函数引用 contains_inverse_candidate() , 以及 verified_real_inverse_candidates().

函数调用图:

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

contains_transcendental_of_var()

bool LMCAS::contains_transcendental_of_var	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var )

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

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    TranscendentalDetector detector(var);
    LMCAS::detail::node(expr)->accept(detector);
    return detector.found;
}

引用了 LMCAS::SymbolicNode::accept(), contains_transcendental_of_var() , 以及 LMCAS::detail::node().

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

函数调用图:

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

contains_unevaluated_integral()

bool LMCAS::contains_unevaluated_integral ( const std::shared_ptr< const SymbolicNode > & node )

inline

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

                                                   {
    return detail::contains_node_type<IntegralNode>(node);
}

引用了 LMCAS::detail::contains_node_type() , 以及 contains_unevaluated_integral().

被这些函数引用 calculus_utils_try_symbolic_definite(), contains_unevaluated_integral(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::definite_integral_geometry_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), lookup_integral(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::simplify_geometry_checked() , 以及 vector_calculus_try_definite().

函数调用图:

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

continuity_at_checked() [1/2]

ContinuityResult LMCAS::continuity_at_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	point )

在文件 calculus_continuity.cpp 第 144 行定义.

                                              {
    ComputationContext context;
    return continuity_at_checked(f, var, point, context);
}

引用了 context, continuity_at_checked() , 以及 point.

函数调用图:

continuity_at_checked() [2/2]

ContinuityResult LMCAS::continuity_at_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	point,
		ComputationContext &	context )

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

                                                                           {
    const std::string operation = "continuity_at";
    try {
        if (!f || !point || var.empty()) {
            return ContinuityResult::failure(CasErrc::InvalidArgument,
                "continuity analysis requires an expression, point, and variable", operation);
        }
        auto input = calculus_utils_validate_expr(f, var, context, operation);
        if (!input) { return ContinuityResult::failure(input.error()); }
        auto left = limit_checked(f, var, point, LimitDirection::FromBelow, context);
        if (!left) { return ContinuityResult::failure(left.error()); }
        auto right = limit_checked(f, var, point, LimitDirection::FromAbove, context);
        if (!right) { return ContinuityResult::failure(right.error()); }
        return continuity_from_limits(f, var, point, left.value().value, right.value().value, context);
    } catch (const std::bad_alloc&) {
        return ContinuityResult::failure(CasErrc::ResourceLimit, "continuity analysis allocation failed", operation);
    } catch (const std::exception& ex) {
        return ContinuityResult::failure(CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_validate_expr(), context, continuity_at_checked(), LMCAS::Result< ContinuityType >::failure(), FromAbove, FromBelow, InternalInvariant, InvalidArgument, limit_checked(), point, ResourceLimit , 以及 right.

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

函数调用图:

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

convergence_radius_checked() [1/4]

ExpressionResult LMCAS::convergence_radius_checked	(	const std::shared_ptr< SymbolicExpr > &	general_coefficient,
		const std::string &	index_var )

在文件 series_convergence.cpp 第 136 行定义.

                                {
    ComputationContext context;
    return convergence_radius_checked(
        general_coefficient, index_var, context);
}

引用了 context , 以及 convergence_radius_checked().

函数调用图:

convergence_radius_checked() [2/4]

ExpressionResult LMCAS::convergence_radius_checked	(	const std::shared_ptr< SymbolicExpr > &	general_coefficient,
		const std::string &	index_var,
		ComputationContext &	context )

在文件 series_convergence.cpp 第 102 行定义.

                                 {
    constexpr const char* operation = "convergence_radius";
    if (!general_coefficient || !LMCAS::detail::node(general_coefficient) ||
        index_var.empty()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "convergence radius requires a coefficient term and index variable",
            operation);
    }
    auto step = context.consume_steps(2, operation);
    if (!step) {
        return ExpressionResult::failure(step.error());
    }
    auto node = LMCAS::detail::node(general_coefficient);
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(node)) {
        return ExpressionResult::success(
            number->is_zero() ? SymbolicExpr::infinity()
                              : SymbolicExpr::number(1));
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto radius = coefficient_power_radius(*power, index_var, context);
        if (radius) {
            return ExpressionResult::success(std::move(*radius));
        }
    }
    return ExpressionResult::failure(
        CasErrc::Inconclusive,
        "coefficient-term limit is outside the supported ratio/root-test domain",
        operation);
}

引用了 coefficient_power_radius(), context, convergence_radius_checked(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InvalidArgument, LMCAS::detail::node() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

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

函数调用图:

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

convergence_radius_checked() [3/4]

ExpressionResult LMCAS::convergence_radius_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coefficients,
		const std::string &	var )

在文件 series_convergence.cpp 第 195 行定义.

{
    ComputationContext context;
    return convergence_radius_checked(coefficients, var, context);
}

引用了 context , 以及 convergence_radius_checked().

函数调用图:

convergence_radius_checked() [4/4]

ExpressionResult LMCAS::convergence_radius_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coefficients,
		const std::string &	var,
		ComputationContext &	context )

有限系数列表完整地表示一个多项式,其收敛半径恒为无穷. 无限级数必须使用通项重载,有限前缀不能证明其尾项行为.

在文件 series_convergence.cpp 第 144 行定义.

{
    const std::string operation = "convergence_radius";
    auto var_check = validate_series_variable(var, context, operation);
    if (!var_check) {
        return ExpressionResult::failure(var_check.error());
    }
    if (coefficients.empty()) {
        return ExpressionResult::failure(CasErrc::InvalidArgument,
                                         "coefficient list cannot be empty",
                                         operation);
    }
    auto coeff_check = validate_power_series_coefficients(
        coefficients, operation, "polynomial");
    if (!coeff_check) {
        return ExpressionResult::failure(coeff_check.error());
    }
    auto budget = context.consume_steps(coefficients.size() + 1, operation);
    if (!budget) {
        return ExpressionResult::failure(budget.error());
    }
 
    for (size_t index = 0; index < coefficients.size(); ++index) {
        if (expression_depends_on_variable(
                LMCAS::detail::node(coefficients[index]), var)) {
            return ExpressionResult::failure(
                CasErrc::InvalidArgument,
                "coefficient at index " + std::to_string(index) +
                    " depends on the series variable",
                operation);
        }
    }
 
    try {
        /// 有限系数列表完整地表示一个多项式,其收敛半径恒为无穷.
        /// 无限级数必须使用通项重载,有限前缀不能证明其尾项行为.
        return ExpressionResult::success(SymbolicExpr::infinity());
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while constructing convergence radius",
            operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(
            CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, convergence_radius_checked(), expression_depends_on_variable(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::node(), ResourceLimit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), validate_power_series_coefficients() , 以及 validate_series_variable().

函数调用图:

convergence_test_checked() [1/2]

ConvergenceInfoResult LMCAS::convergence_test_checked	(	const std::shared_ptr< SymbolicExpr > &	general_term,
		const std::string &	index_var )

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

{
    ComputationContext context;
    return convergence_test_checked(general_term, index_var, context);
}

引用了 context , 以及 convergence_test_checked().

函数调用图:

convergence_test_checked() [2/2]

ConvergenceInfoResult LMCAS::convergence_test_checked	(	const std::shared_ptr< SymbolicExpr > &	general_term,
		const std::string &	index_var,
		ComputationContext &	context )

在文件 series_convergence.cpp 第 204 行定义.

{
    const std::string operation = "convergence_test";
    auto var_check = validate_series_variable(index_var, context, operation);
    if (!var_check) {
        return ConvergenceInfoResult::failure(var_check.error());
    }
    if (!general_term || !LMCAS::detail::node(general_term)) {
        return ConvergenceInfoResult::failure(CasErrc::InvalidArgument,
                                              "general term cannot be null",
                                              operation);
    }
    auto budget = context.consume_steps(32, operation);
    if (!budget) {
        return ConvergenceInfoResult::failure(budget.error());
    }
    try {
        auto analyzed =
            convergence_test_impl(general_term, index_var, context);
        if (!analyzed) {
            return analyzed;
        }
        auto info = std::move(analyzed.value());
        if (info.result == ConvergenceResult::Inconclusive) {
            return ConvergenceInfoResult::failure(
                CasErrc::Inconclusive,
                "convergence test is outside the current supported domain",
                operation);
        }
        return info;
    } catch (const CasError& error) {
        return ConvergenceInfoResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ConvergenceInfoResult::failure(CasErrc::ResourceLimit,
                                              "allocation failed while testing convergence",
                                              operation);
    } catch (const std::exception& ex) {
        return ConvergenceInfoResult::failure(CasErrc::InternalInvariant,
                                              ex.what(),
                                              operation);
    }
}

引用了 context, convergence_test_checked(), convergence_test_impl(), LMCAS::Result< ConvergenceInfo >::failure(), Inconclusive, InternalInvariant, InvalidArgument, LMCAS::detail::node(), ResourceLimit , 以及 validate_series_variable().

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

函数调用图:

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

convergence_test_impl()

ConvergenceInfoResult LMCAS::convergence_test_impl ( const std::shared_ptr< SymbolicExpr > & general_term, const std::string & index_var, ComputationContext & context )

static

对 Laurent 单项式 c*n^e 直接应用 p 级数判据。 倒数幂沿用线性规则，省去 Abs 比值极限的递归化简。

在文件 series_convergence.cpp 第 387 行定义.

                                 {
    if (!general_term || !LMCAS::detail::node(general_term)) {
        return ConvergenceInfo{
            ConvergenceResult::Inconclusive, ""};
    }
    if (auto geometric = geometric_term_convergence(
            detail::node(general_term), index_var)) {
        return std::move(*geometric);
    }
    auto power_info = power_term_convergence(detail::node(general_term), index_var);
    if (power_info) {
        return std::move(*power_info);
    }
    /**
     * @brief 对 Laurent 单项式 c*n^e 直接应用 p 级数判据。
     * 倒数幂沿用线性规则，省去 Abs 比值极限的递归化简。
     */
    if (const auto laurent_power = supported_laurent_integer_power(
            LMCAS::detail::node(general_term), index_var)) {
        if (*laurent_power < -1) {
            return ConvergenceInfo{
                ConvergenceResult::Convergent, "p-series"};
        }
        if (*laurent_power >= -1) {
            return ConvergenceInfo{
                ConvergenceResult::Divergent, "p-series"};
        }
    }
    return ratio_convergence_test(general_term, index_var, context);
}

引用了 context, convergence_test_impl(), Convergent, Divergent, geometric_term_convergence(), Inconclusive, LMCAS::detail::node(), power_term_convergence(), ratio_convergence_test() , 以及 supported_laurent_integer_power().

被这些函数引用 convergence_test_checked() , 以及 convergence_test_impl().

函数调用图:

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

convert_to_unit()

ExprResult LMCAS::convert_to_unit	(	const ExprPtr &	quantity,
		const std::string &	unit,
		ComputationContext &	context )

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

                                                        {
    return convert_unit(quantity, unit, context);
}

引用了 context, convert_to_unit(), convert_unit() , 以及 unit.

被这些函数引用 convert_to_unit().

函数调用图:

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

convert_to_unit_definition()

ExprResult LMCAS::convert_to_unit_definition	(	const ExprPtr &	quantity,
		std::string	display_unit,
		UnitDefinition	definition,
		ComputationContext &	context )

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

                                                                   {
    return convert_unit(quantity, std::move(display_unit), std::move(definition), context);
}

引用了 context, convert_to_unit_definition(), convert_unit(), definition , 以及 display_unit.

被这些函数引用 convert_to_unit_definition().

函数调用图:

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

convert_unit() [1/2]

QuantityResult LMCAS::convert_unit	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	target_unit,
		ComputationContext &	context )

在文件 quantity.cpp 第 128 行定义.

                                                         {
    auto step = context.consume_steps(1, kOperation);
    if (!step) return QuantityResult::failure(step.error());
    auto quantity = expression
        ? std::dynamic_pointer_cast<const QuantityNode>(detail::node(expression))
        : nullptr;
    if (!quantity) {
        return failure(CasErrc::UnitStripTypeMismatch,
                       "unit conversion requires a quantity expression");
    }
    auto target = context.units().resolve(target_unit);
    if (!target) return QuantityResult::failure(target.error());
    if (quantity->dimension() != target.value().dimension) {
        return failure(CasErrc::DimensionMismatch,
                       "unit conversion requires equal dimensions");
    }
    const Rational factor = quantity->scale_to_base() / target.value().scale_to_base;
    auto value = SymbolicFactory::create_multiply(
        {quantity->value(), rational_node(factor)});
    return make_quantity(std::move(value), target.value().dimension,
                         target.value().scale_to_base, target_unit);
}

引用了 context, convert_unit(), LMCAS::SymbolicFactory::create_multiply(), DimensionMismatch, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::node(), target, UnitStripTypeMismatch , 以及 value.

被这些函数引用 convert_to_unit(), convert_to_unit_definition(), convert_unit() , 以及 convert_unit().

函数调用图:

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

convert_unit() [2/2]

QuantityResult LMCAS::convert_unit	(	const std::shared_ptr< SymbolicExpr > &	expression,
		std::string	display_unit,
		UnitDefinition	definition,
		ComputationContext &	context )

在文件 quantity.cpp 第 153 行定义.

                                                         {
    auto step = context.consume_steps(1, kOperation);
    if (!step) return QuantityResult::failure(step.error());
    auto quantity = expression
        ? std::dynamic_pointer_cast<const QuantityNode>(detail::node(expression))
        : nullptr;
    if (!quantity) {
        return failure(CasErrc::UnitStripTypeMismatch,
                       "unit conversion requires a quantity expression");
    }
    if (display_unit.empty() || definition.scale_to_base <= Rational(0)) {
        return failure(CasErrc::UnitInvalid, "resolved unit definition is invalid");
    }
    if (quantity->dimension() != definition.dimension) {
        return failure(CasErrc::DimensionMismatch,
                       "unit conversion requires equal dimensions");
    }
    const Rational factor = quantity->scale_to_base() / definition.scale_to_base;
    auto value = SymbolicFactory::create_multiply(
        {quantity->value(), rational_node(factor)});
    return make_quantity(std::move(value), std::move(definition.dimension),
                         std::move(definition.scale_to_base),
                         std::move(display_unit));
}

引用了 context, convert_unit(), LMCAS::SymbolicFactory::create_multiply(), definition, DimensionMismatch, display_unit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::node(), UnitInvalid, UnitStripTypeMismatch , 以及 value.

函数调用图:

convolve_checked() [1/2]

TransformEngineResult LMCAS::convolve_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::shared_ptr< SymbolicExpr > &	g,
		const std::string &	var )

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

                          {
    ComputationContext context;
    return convolve_checked(f, g, var, context);
}

引用了 context , 以及 convolve_checked().

函数调用图:

convolve_checked() [2/2]

TransformEngineResult LMCAS::convolve_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::shared_ptr< SymbolicExpr > &	g,
		const std::string &	var,
		ComputationContext &	context )

在文件 transform_convolution.cpp 第 142 行定义.

                                 {
    const std::string operation = "convolve";
    auto valid =
        te_validate_convolution_inputs(f, g, var, context, operation);
    if (!valid) return TransformEngineResult::failure(valid.error());
    try {
        return te_convolve_core(f, g, var, context);
    } catch (const std::bad_alloc&) {
        return TransformEngineResult::failure(
            CasErrc::ResourceLimit, "双边卷积分配失败", operation);
    } catch (const std::exception& error) {
        return TransformEngineResult::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
}

引用了 context, convolve_checked(), LMCAS::Result< Verified< EvaluatedTransform > >::failure(), InternalInvariant, ResourceLimit, te_convolve_core() , 以及 te_validate_convolution_inputs().

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

函数调用图:

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

cos() [1/2]

ExprResult LMCAS::cos

(

const ExprPtr &

expression

)

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

                                          {
    ComputationContext context;
    return cos(expression, context);
}

引用了 context , 以及 cos().

函数调用图:

cos() [2/2]

ExprResult LMCAS::cos	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 50 行定义.

                                                                       {
    auto valid = require_dimensionless(expression, "cos");
    if (!valid) { return valid; }
    return make_unary_math_expr(expression, context, "cos",
                                SymbolicExpr::cos);
}

引用了 context, cos(), LMCAS::expr_detail::expr_common::make_unary_math_expr() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

被这些函数引用 cos(), cos() , 以及 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function().

函数调用图:

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

cross_product()

VectorCalculusFieldResult LMCAS::cross_product	(	const VectorField &	a,
		const VectorField &	b )

在文件 vector_calculus_algebra.cpp 第 152 行定义.

                                                    {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "cross_product");
    return cross_product_impl(a, b, transform_budget);
} catch (const CasError& error) {
    return VectorCalculusFieldResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit,
        "vector calculus allocation failed", "cross_product");
} catch (const std::length_error& error) {
    return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit, error.what(), "cross_product");
} catch (const std::exception& error) {
    return VectorCalculusFieldResult::failure(CasErrc::InternalInvariant, error.what(), "cross_product");
}

引用了 a, b, context, cross_product() , 以及 cross_product_impl().

被这些函数引用 cross_product().

函数调用图:

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

cross_product_impl()

VectorCalculusFieldResult LMCAS::cross_product_impl ( const VectorField & a, const VectorField & b, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_algebra.cpp 第 40 行定义.

                                                                                       {
    if (a.size() != 3 || b.size() != 3) {
        return VectorCalculusFieldResult::failure(
            CasErrc::DimensionMismatch,
            "vectors must be three-dimensional",
            "cross_product");
    }
    VectorField result;
    result.reserve(3);
    for (std::size_t index = 0; index < 3; ++index) {
        result.push_back(
            detail::make_expression_ptr(detail::normalize_node(detail::node(vector_calculus_cross_component(a, b, index)), transform_budget)));
    }
    return VectorCalculusFieldResult::success(std::move(result));
}

引用了 a, b, cross_product_impl(), DimensionMismatch, LMCAS::Result< VectorField >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< VectorField >::success() , 以及 LMCAS::vector_calculus_detail::vector_calculus_cross_component().

被这些函数引用 cross_product(), cross_product_impl() , 以及 mixed_product_impl().

函数调用图:

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

crt()

std::pair< int64_t, int64_t > LMCAS::crt ( int64_t r1, int64_t m1, int64_t r2, int64_t m2 )

inline

中国剩余定理（两模数），返回规范余数与模数乘积。

异常

std::domain_error	模数非正或不互素。
std::overflow_error	合并模数超出机器内核范围。

在文件 modular_arithmetic.hpp 第 305 行定义.

                                                    {
    auto merged = crt_checked(r1, m1, r2, m2);
    if (merged) return merged.value();
    if (merged.error().code == CasErrc::ResourceLimit) {
        throw std::overflow_error(merged.error().message);
    }
    throw std::domain_error(merged.error().message);
}

引用了 crt(), crt_checked() , 以及 ResourceLimit.

被这些函数引用 crt() , 以及 multi_crt().

函数调用图:

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

crt_checked() [1/2]

CrtResult LMCAS::crt_checked ( int64_t r1, int64_t m1, int64_t r2, int64_t m2 )

inline

在文件 modular_arithmetic.hpp 第 296 行定义.

                                                                             {
    ComputationContext context;
    return crt_checked(r1, m1, r2, m2, context);
}

引用了 context , 以及 crt_checked().

函数调用图:

crt_checked() [2/2]

CrtResult LMCAS::crt_checked ( int64_t r1, int64_t m1, int64_t r2, int64_t m2, ComputationContext & context )

inline

Checked Chinese remainder theorem for two positive coprime moduli.

factor < m2 且 m1*m2 <= INT64_MAX，保证 m1*factor 在机器整数范围内。

在文件 modular_arithmetic.hpp 第 265 行定义.

                                                          {
    constexpr const char* operation = "crt";
    auto step = context.consume_steps(1, operation);
    if (!step) return CrtResult::failure(step.error());
    if (m1 <= 0 || m2 <= 0) {
        return CrtResult::failure(CasErrc::InvalidArgument,
                                  "CRT moduli must be positive", operation);
    }
 
    int64_t product = 0;
    if (!modular_detail::checked_positive_product(m1, m2, product)) {
        return CrtResult::failure(CasErrc::ResourceLimit,
                                  "CRT modulus product exceeds int64 range", operation);
    }
 
    int64_t s = 0;
    int64_t t = 0;
    int64_t g = extended_gcd(m1, m2, s, t);
    if (g != 1) {
        return CrtResult::failure(CasErrc::InvalidArgument,
                                  "CRT moduli must be coprime", operation);
    }
 
    const auto factor = ((ModInt(r2, m2) - ModInt(r1, m2)) * ModInt(s, m2)).value();
    /** @brief factor < m2 且 m1*m2 <= INT64_MAX，保证 m1*factor 在机器整数范围内。 */
    const auto merged = ModInt(r1, product) + ModInt(m1 * factor, product);
    return CrtResult::success({merged.value(), product});
}

引用了 LMCAS::ModInt::ModInt(), LMCAS::modular_detail::checked_positive_product(), context, crt_checked(), extended_gcd(), LMCAS::Result< std::pair< int64_t, int64_t > >::failure(), InvalidArgument, ResourceLimit, LMCAS::Result< std::pair< int64_t, int64_t > >::success(), t , 以及 value.

被这些函数引用 crt(), crt_checked(), crt_checked() , 以及 multi_crt_checked().

函数调用图:

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

curl()

VectorField LMCAS::curl	(	const VectorField &	F,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_differential.cpp 第 350 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "curl");
    return curl_impl(F, vars, transform_budget);
}

引用了 context, curl(), LMCAS::vector_calculus_detail::curl_impl() , 以及 vars.

被这些函数引用 curl().

函数调用图:

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

curl_checked() [1/2]

VectorCalculusFieldResult LMCAS::curl_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_differential.cpp 第 186 行定义.

{
    ComputationContext context;
    return curl_checked(F, vars, context);
}

引用了 context, curl_checked() , 以及 vars.

函数调用图:

curl_checked() [2/2]

VectorCalculusFieldResult LMCAS::curl_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

在文件 vector_calculus_differential.cpp 第 149 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "curl");
    const std::string operation = "curl";
    auto valid = vector_calculus_validate_field_vars(F, vars, context, operation);
    if (!valid) {
        return VectorCalculusFieldResult::failure(valid.error());
    }
    if (F.size() != 2 && F.size() != 3) {
        return VectorCalculusFieldResult::failure(
            CasErrc::InvalidArgument,
            "curl requires a 2D or 3D vector field",
            operation);
    }
    auto step = context.consume_steps(F.size(), operation);
    if (!step) {
        return VectorCalculusFieldResult::failure(step.error());
    }
    try {
        return vector_calculus_wrap_field(curl_impl(F, vars, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusFieldResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit,
                                                  "vector calculus allocation failed",
                                                  operation);
    } catch (const std::length_error& error) {
        return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusFieldResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, curl_checked(), LMCAS::vector_calculus_detail::curl_impl(), e(), LMCAS::Result< VectorField >::failure(), InternalInvariant, InvalidArgument, ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_field().

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

函数调用图:

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

curvature_checked() [1/2]

ExpressionResult LMCAS::curvature_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var )

在文件 calculus_curvature.cpp 第 82 行定义.

{
    ComputationContext context;
    return curvature_checked(f, var, context);
}

引用了 context , 以及 curvature_checked().

函数调用图:

curvature_checked() [2/2]

ExpressionResult LMCAS::curvature_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		ComputationContext &	context )

在文件 calculus_curvature.cpp 第 34 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "curvature";
    auto input = calculus_utils_validate_expr(f, var, context, operation);
    if (!input) {
        return ExpressionResult::failure(input.error());
    }
 
    auto first = checked_derivative(f, var, context, operation.c_str());
    if (!first) {
        return ExpressionResult::failure(first.error());
    }
    const auto& f_prime = first.value();
    auto second = checked_derivative(f_prime, var, context, operation.c_str());
    if (!second) {
        return ExpressionResult::failure(second.error());
    }
    const auto& f_double_prime = second.value();
 
    auto abs_f_pp = calculus_utils_make_abs(f_double_prime);
    if (!abs_f_pp || !LMCAS::detail::node(abs_f_pp)) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                           "absolute value node construction failed",
                                           operation);
    }
 
    auto f_prime_sq = SymbolicExpr::power(f_prime, SymbolicExpr::number(2));
    auto one_plus_fp_sq = SymbolicExpr::add(SymbolicExpr::number(1), f_prime_sq);
 
    auto three_half = SymbolicExpr::number(Rational(3, 2));
    auto denom = SymbolicExpr::power(one_plus_fp_sq, three_half);
    auto result = SymbolicExpr::divide(abs_f_pp, denom);
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
    return ExpressionResult::success(simplified ? simplified : result);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "curvature");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "curvature");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "curvature");
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_make_abs(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr(), checked_derivative(), context, curvature_checked(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

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

函数调用图:

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

curvature_parametric_checked() [1/2]

ExpressionResult LMCAS::curvature_parametric_checked	(	const std::shared_ptr< SymbolicExpr > &	x_t,
		const std::shared_ptr< SymbolicExpr > &	y_t,
		const std::string &	t )

在文件 calculus_curvature.cpp 第 163 行定义.

{
    ComputationContext context;
    return curvature_parametric_checked(x_t, y_t, t, context);
}

引用了 context, curvature_parametric_checked() , 以及 t.

函数调用图:

curvature_parametric_checked() [2/2]

ExpressionResult LMCAS::curvature_parametric_checked	(	const std::shared_ptr< SymbolicExpr > &	x_t,
		const std::shared_ptr< SymbolicExpr > &	y_t,
		const std::string &	t,
		ComputationContext &	context )

在文件 calculus_curvature.cpp 第 90 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "curvature_parametric";
    auto input = calculus_utils_validate_two_exprs(x_t, y_t, t, context, operation);
    if (!input) {
        return ExpressionResult::failure(input.error());
    }
 
    auto x_first = checked_derivative(x_t, t, context, operation.c_str());
    if (!x_first) {
        return ExpressionResult::failure(x_first.error());
    }
    const auto& x_prime = x_first.value();
    auto x_second = checked_derivative(x_prime, t, context, operation.c_str());
    if (!x_second) {
        return ExpressionResult::failure(x_second.error());
    }
    const auto& x_double_prime = x_second.value();
 
    auto y_first = checked_derivative(y_t, t, context, operation.c_str());
    if (!y_first) {
        return ExpressionResult::failure(y_first.error());
    }
    const auto& y_prime = y_first.value();
    auto y_second = checked_derivative(y_prime, t, context, operation.c_str());
    if (!y_second) {
        return ExpressionResult::failure(y_second.error());
    }
    const auto& y_double_prime = y_second.value();
 
    if (x_prime->is_zero() && y_prime->is_zero()) {
        return ExpressionResult::failure(CasErrc::DomainError,
                                           "parametric curvature is undefined for zero velocity",
                                           operation);
    }
 
    auto cross_term = SymbolicExpr::add(
        SymbolicExpr::multiply(x_prime, y_double_prime),
        SymbolicExpr::multiply(
            SymbolicExpr::number(-1),
            SymbolicExpr::multiply(y_prime, x_double_prime)));
 
    auto abs_cross = calculus_utils_make_abs(cross_term);
    if (!abs_cross || !LMCAS::detail::node(abs_cross)) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                           "absolute value node construction failed",
                                           operation);
    }
 
    auto x_prime_sq = SymbolicExpr::power(x_prime, SymbolicExpr::number(2));
    auto y_prime_sq = SymbolicExpr::power(y_prime, SymbolicExpr::number(2));
    auto sum_sq = SymbolicExpr::add(x_prime_sq, y_prime_sq);
 
    auto three_half = SymbolicExpr::number(Rational(3, 2));
    auto denom = SymbolicExpr::power(sum_sq, three_half);
    auto result = SymbolicExpr::divide(abs_cross, denom);
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
    return ExpressionResult::success(simplified ? simplified : result);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "curvature_parametric");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "curvature_parametric");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "curvature_parametric");
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_make_abs(), LMCAS::calculus_utils_detail::calculus_utils_validate_two_exprs(), checked_derivative(), context, curvature_parametric_checked(), DomainError, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 t.

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

函数调用图:

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

curve_integral_scalar()

std::shared_ptr< SymbolicExpr > LMCAS::curve_integral_scalar	(	const std::shared_ptr< SymbolicExpr > &	f,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

在文件 vector_calculus_curves.cpp 第 55 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f) {
        throw std::invalid_argument("curve_integral_scalar: f must not be null");
    }
    if (parametrization.empty()) {
        throw std::invalid_argument("curve_integral_scalar: parametrization must not be empty");
    }
    if (!a || !b) {
        throw std::invalid_argument("curve_integral_scalar: bounds must not be null");
    }
 
    size_t dim = parametrization.size();
    auto coord_vars = vector_calculus_coord_vars(dim);
 
    auto f_composed = f;
    for (size_t i = 0; i < dim; ++i) {
        f_composed = detail::make_expression_ptr(detail::substitute_node(detail::node(f_composed), coord_vars[i], detail::node(parametrization[i]), transform_budget));
    }
    f_composed = detail::make_expression_ptr(detail::normalize_node(detail::node(f_composed), transform_budget));
 
    std::shared_ptr<SymbolicExpr> speed_sq = nullptr;
    for (size_t i = 0; i < dim; ++i) {
        auto deriv = detail::make_expression_ptr(detail::differentiate_node(detail::node(parametrization[i]), t, transform_budget));
        if (!deriv) {
            continue;
        }
        deriv = detail::make_expression_ptr(detail::normalize_node(detail::node(deriv), transform_budget));
        auto sq = SymbolicExpr::power(deriv, SymbolicExpr::number(2));
        sq = detail::make_expression_ptr(detail::normalize_node(detail::node(sq), transform_budget));
        if (!speed_sq) {
            speed_sq = sq;
        } else {
            speed_sq = SymbolicExpr::add(speed_sq, sq);
            speed_sq = detail::make_expression_ptr(detail::normalize_node(detail::node(speed_sq), transform_budget));
        }
    }
 
    if (!speed_sq) {
        return SymbolicExpr::number(0);
    }
 
    auto speed = SymbolicExpr::sqrt(speed_sq);
    speed = detail::make_expression_ptr(detail::normalize_node(detail::node(speed), transform_budget));
 
    auto integrand = SymbolicExpr::multiply(f_composed, speed);
    integrand = detail::make_expression_ptr(detail::normalize_node(detail::node(integrand), transform_budget));
 
 
    return vector_calculus_integrate_with_fallback(integrand, t, a, b, context, transform_budget);
}

引用了 a, b, context, curve_integral_scalar(), LMCAS::detail::differentiate_node(), dim, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), parametrization, LMCAS::detail::substitute_node(), t, LMCAS::vector_calculus_detail::vector_calculus_coord_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback().

被这些函数引用 curve_integral_scalar().

函数调用图:

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

curve_integral_scalar_checked() [1/2]

VectorCalculusExprResult LMCAS::curve_integral_scalar_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

在文件 vector_calculus_curves.cpp 第 46 行定义.

{
    ComputationContext context;
    return curve_integral_scalar_checked(f, parametrization, t, a, b, context);
}

引用了 a, b, context, curve_integral_scalar_checked(), parametrization , 以及 t.

函数调用图:

curve_integral_scalar_checked() [2/2]

VectorCalculusExprResult LMCAS::curve_integral_scalar_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "curve_integral_scalar");
    const std::string operation = "curve_integral_scalar";
    auto valid = vector_calculus_validate_curve_scalar_inputs(
        f, parametrization, t, a, b, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
 
    auto step = context.consume_steps(parametrization.size() * 4 + 4, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return curve_integral_scalar_strict(f, parametrization, t, a, b, context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "curve integral allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 a, b, context, curve_integral_scalar_checked(), LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, parametrization, ResourceLimit, t , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_curve_scalar_inputs().

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

函数调用图:

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

curve_integral_vector()

std::shared_ptr< SymbolicExpr > LMCAS::curve_integral_vector	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

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

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (F.empty()) {
        throw std::invalid_argument("curve_integral_vector: F must not be empty");
    }
    if (parametrization.empty()) {
        throw std::invalid_argument("curve_integral_vector: parametrization must not be empty");
    }
    if (F.size() != parametrization.size()) {
        throw std::invalid_argument(
            "curve_integral_vector: F and parametrization must have the same dimension");
    }
    if (!a || !b) {
        throw std::invalid_argument("curve_integral_vector: bounds must not be null");
    }
 
    size_t dim = parametrization.size();
    auto coord_vars = vector_calculus_coord_vars(dim);
 
    std::shared_ptr<SymbolicExpr> dot_product = nullptr;
    for (size_t i = 0; i < dim; ++i) {
        if (!F[i]) {
            continue;
        }
 
        auto Fi_composed = F[i];
        for (size_t j = 0; j < dim; ++j) {
            Fi_composed = detail::make_expression_ptr(detail::substitute_node(detail::node(Fi_composed), coord_vars[j], detail::node(parametrization[j]), transform_budget));
        }
        Fi_composed = detail::make_expression_ptr(detail::normalize_node(detail::node(Fi_composed), transform_budget));
 
        auto ri_prime = detail::make_expression_ptr(detail::differentiate_node(detail::node(parametrization[i]), t, transform_budget));
        if (!ri_prime) {
            continue;
        }
        ri_prime = detail::make_expression_ptr(detail::normalize_node(detail::node(ri_prime), transform_budget));
 
        auto term = SymbolicExpr::multiply(Fi_composed, ri_prime);
        term = detail::make_expression_ptr(detail::normalize_node(detail::node(term), transform_budget));
 
        if (!dot_product) {
            dot_product = term;
        } else {
            dot_product = SymbolicExpr::add(dot_product, term);
            dot_product = detail::make_expression_ptr(detail::normalize_node(detail::node(dot_product), transform_budget));
        }
    }
 
    if (!dot_product) {
        return SymbolicExpr::number(0);
    }
 
 
    return vector_calculus_integrate_with_fallback(dot_product, t, a, b, context, transform_budget);
}

引用了 a, b, context, curve_integral_vector(), LMCAS::detail::differentiate_node(), dim, dot_product(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), parametrization, LMCAS::detail::substitute_node(), t, LMCAS::vector_calculus_detail::vector_calculus_coord_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback().

被这些函数引用 curve_integral_vector().

函数调用图:

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

curve_integral_vector_checked() [1/2]

VectorCalculusExprResult LMCAS::curve_integral_vector_checked	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

在文件 vector_calculus_curves.cpp 第 151 行定义.

{
    ComputationContext context;
    return curve_integral_vector_checked(F, parametrization, t, a, b, context);
}

引用了 a, b, context, curve_integral_vector_checked(), parametrization , 以及 t.

函数调用图:

curve_integral_vector_checked() [2/2]

VectorCalculusExprResult LMCAS::curve_integral_vector_checked	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "curve_integral_vector");
    const std::string operation = "curve_integral_vector";
    auto valid = vector_calculus_validate_curve_vector_inputs(
        F, parametrization, t, a, b, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
 
    auto step = context.consume_steps(F.size() * parametrization.size() +
                                      parametrization.size() * 3 + 4,
                                      operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return curve_integral_vector_strict(F, parametrization, t, a, b, context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "curve integral allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 a, b, context, curve_integral_vector_checked(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, parametrization, ResourceLimit, t , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_curve_vector_inputs().

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

函数调用图:

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

deduplicate_roots()

std::vector< lmmc_real_t > LMCAS::deduplicate_roots	(	std::vector< NumericRoot > &	roots,
		lmmc_real_t	tolerance,
		int	max_roots )

在文件 mixed_transcendental_deduplication.cpp 第 7 行定义.

{
    if (roots.empty()) {
        return {};
    }
 
    std::sort(roots.begin(), roots.end(),
        [](const NumericRoot& a, const NumericRoot& b) {
            return a.value < b.value;
        });
    lmmc_real_t threshold = 10.0 * tolerance;
    std::vector<NumericRoot> survivors;
    survivors.reserve(roots.size());
    survivors.push_back(roots[0]);
 
    for (size_t i = 1; i < roots.size(); ++i) {
        NumericRoot& last = survivors.back();
        if (std::fabs(roots[i].value - last.value) < threshold) {
            if (roots[i].residual < last.residual) {
                last = roots[i];
            }
        } else {
            survivors.push_back(roots[i]);
        }
    }
    std::vector<lmmc_real_t> result;
    result.reserve(survivors.size());
    for (const auto& r : survivors) {
        result.push_back(r.value);
    }
 
    if (max_roots > 0 && result.size() > static_cast<std::size_t>(max_roots)) {
        result.resize(static_cast<size_t>(max_roots));
    }
 
    return result;
}

引用了 a, b, deduplicate_roots(), r, LMCAS::NumericRoot::residual, roots(), LMCAS::NumericRoot::value, LMCAS::Result< T >::value() , 以及 value.

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

函数调用图:

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

deflate_rational_root()

void LMCAS::deflate_rational_root ( Polynomial< Rational > & current, const Rational & root, std::vector< Rational > & roots )

static

在文件 rational_polynomial.cpp 第 56 行定义.

                                                              {
    Polynomial<Rational> linear({-root, Rational(1)}, current.variable_name);
    while (current.degree() >= 1) {
        auto [quotient, remainder] = current.div_mod(linear);
        if (!remainder.is_zero()) break;
        roots.push_back(root);
        current = std::move(quotient);
        if (current.degree() < 1 || current.eval(root) != Rational(0)) break;
    }
}

引用了 deflate_rational_root(), LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::eval(), roots() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 deflate_rational_root() , 以及 find_rational_roots().

函数调用图:

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

denominator_factor()

std::shared_ptr< const SymbolicNode > LMCAS::LimitVisitor::denominator_factor ( const std::shared_ptr< const SymbolicNode > & node )

static

在文件 calculus_asymptotes.cpp 第 14 行定义.

{
    auto power = std::dynamic_pointer_cast<const PowerNode>(node);
    if (!power) {
        return nullptr;
    }
    auto number = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
    if (!number) {
        return nullptr;
    }
    const Rational exponent = std::holds_alternative<BigInt>(number->value())
        ? Rational(std::get<BigInt>(number->value()))
        : std::get<Rational>(number->value());
    if (!(exponent < Rational(0))) {
        return nullptr;
    }
    if (exponent == Rational(-1)) {
        return power->base();
    }
    auto positive = LMCAS::detail::make_node<NumberNode>(-exponent);
    return LMCAS::detail::make_node<PowerNode>(power->base(), positive);
}

引用了 denominator_factor(), exponent , 以及 LMCAS::detail::make_node().

被这些函数引用 calculus_utils_extract_denominator() , 以及 denominator_factor().

函数调用图:

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

dep_var_is_positive()

Result< bool > LMCAS::dep_var_is_positive ( const std::string & y, const AssumptionContext * ctx, ComputationContext & context )

static

Check if the dependent variable is known Positive in the given context.

在文件 symbolic_ode.cpp 第 52 行定义.

                                                                                   {
    if (!ctx) {
        return false;
    }
    auto y_expr = SymbolicExpr::variable(y);
    auto positive = ctx->is_positive_checked(*y_expr, context);
    if (!positive) { return Result<bool>::failure(positive.error()); }
    return positive.value() == Tribool::True;
}

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

被这些函数引用 dep_var_is_positive(), solve_linear1_ode(), solve_linear2_homogeneous() , 以及 solve_separable_ode().

函数调用图:

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

depends_on_integration_variable()

bool LMCAS::depends_on_integration_variable ( const SymbolicExpr & expression, const std::string & variable )

inline

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

                               {
    return detail::integration_depends_on_variable(detail::node(expression), variable);
}

引用了 depends_on_integration_variable(), LMCAS::detail::integration_depends_on_variable(), LMCAS::detail::node() , 以及 variable.

被这些函数引用 depends_on_integration_variable(), LMCAS::detail::integrate_power_primitive(), 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_substitution.cpp}::substitute_candidate().

函数调用图:

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

detect_negation()

std::shared_ptr< const SymbolicNode > LMCAS::detect_negation ( const std::shared_ptr< const SymbolicNode > & node )

static

If the node is multiplication by exactly -1, returns the other operand.

在文件 inference_engine_monotonicity.cpp 第 173 行定义.

                                                   {
    const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!multiply || multiply->operands().size() != 2) {
        return nullptr;
    }
    for (std::size_t index = 0; index < 2; ++index) {
        const auto number = std::dynamic_pointer_cast<const NumberNode>(
            multiply->operands()[index]);
        if (number && number->is_negative_one()) {
            return multiply->operands()[1 - index];
        }
    }
    return nullptr;
}

引用了 detect_negation().

被这些函数引用 detect_negation().

函数调用图:

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

detect_parity()

int LMCAS::detect_parity ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, ComputationContext & context )

static

在文件 series_expansions.cpp 第 23 行定义.

                                                                                                                  {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f) {
        return 0;
    }
    auto neg_x = SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::variable(var));
    auto f_neg = detail::make_expression_ptr(detail::substitute_node(detail::node(f), var, detail::node(neg_x), transform_budget));
    if (!f_neg) {
        return 0;
    }
    f_neg = detail::make_expression_ptr(detail::normalize_node(detail::node(f_neg), transform_budget));
    auto f_s = detail::make_expression_ptr(detail::normalize_node(detail::node(f), transform_budget));
    auto diff_even = SymbolicExpr::add(f_neg, SymbolicExpr::multiply(SymbolicExpr::number(-1), f_s));
    if (diff_even) { diff_even = detail::make_expression_ptr(detail::normalize_node(detail::node(diff_even), transform_budget)); if (diff_even->is_zero()) {
        return 1;
    } }
    auto diff_odd = SymbolicExpr::add(f_neg, f_s);
    if (diff_odd) { diff_odd = detail::make_expression_ptr(detail::normalize_node(detail::node(diff_odd), transform_budget)); if (diff_odd->is_zero()) {
        return -1;
    } }
    return 0;
}

引用了 context, detect_parity(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::detail::substitute_node().

被这些函数引用 detect_parity() , 以及 fourier_series_checked().

函数调用图:

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

detect_substitution()

Result< std::optional< SubstitutionResult > > LMCAS::detect_substitution	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var )

在文件 transcendental_solver_substitution.cpp 第 324 行定义.

                              {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (!expr || !LMCAS::detail::node(expr)) {
        return std::optional<SubstitutionResult>{};
    }
 
    if (!expression_depends_on_variable(LMCAS::detail::node(expr), var)) {
        return std::optional<SubstitutionResult>{};
    }
 
    const std::string u_var = "_u_subst";
 
    std::vector<std::shared_ptr<SymbolicExpr>> candidates;
    collect_transcendental_subexprs(LMCAS::detail::node(expr), var, candidates);
    deduplicate_candidates(candidates);
 
    for (auto& h : candidates) {
 
        auto redundant = redundant_variable_candidate(h, expr, var);
        if (!redundant) {
            return Result<std::optional<SubstitutionResult>>::failure(redundant.error());
        }
        if (redundant.value()) {
            continue;
        }
 
 
 
        SubstNodeVisitor visitor;
        visitor.target = LMCAS::detail::node(h);
        visitor.u_name = u_var;
 
        auto substituted_node = visitor.replace(LMCAS::detail::node(expr));
        auto substituted_expr = LMCAS::detail::make_expression_ptr(substituted_node);
        substituted_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(substituted_expr), transform_budget));
 
        auto polynomial = is_substitution_polynomial(substituted_expr, var, u_var);
        if (!polynomial) {
            return Result<std::optional<SubstitutionResult>>::failure(polynomial.error());
        }
        if (polynomial.value()) {
            return std::optional<SubstitutionResult>{{h, substituted_expr, u_var}};
        }
    }
 
    if (has_exp_k_var_terms(LMCAS::detail::node(expr), var)) {
        auto rewritten_node = rewrite_exp_as_u_power(LMCAS::detail::node(expr), var, u_var);
        auto rewritten_expr = LMCAS::detail::make_expression_ptr(rewritten_node);
        rewritten_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(rewritten_expr), transform_budget));
 
        auto polynomial = is_substitution_polynomial(rewritten_expr, var, u_var);
        if (!polynomial) {
            return Result<std::optional<SubstitutionResult>>::failure(polynomial.error());
        }
        if (polynomial.value()) {
            auto exp_x = SymbolicExpr::exp(SymbolicExpr::variable(var));
            return std::optional<SubstitutionResult>{{exp_x, rewritten_expr, u_var}};
        }
    }
 
    return std::optional<SubstitutionResult>{};
} catch (const CasError& error) {
    return Result<std::optional<SubstitutionResult>>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<std::optional<SubstitutionResult>>::failure(CasErrc::ResourceLimit, "allocation failed", "detect_substitution");
} catch (const std::length_error& error) {
    return Result<std::optional<SubstitutionResult>>::failure(CasErrc::ResourceLimit, error.what(), "detect_substitution");
} catch (const std::exception& error) {
    return Result<std::optional<SubstitutionResult>>::failure(CasErrc::InternalInvariant, error.what(), "detect_substitution");
}

引用了 context, detect_substitution(), expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 detect_substitution() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl().

函数调用图:

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

detect_trans_substitutions()

TransSubstitutionResult LMCAS::detect_trans_substitutions	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var )

为依赖 var 的 Sin、Cos、Exp、Ln、Tan 子表达式构造换元结果。

按结构去重后，依次分配不定元 u0、u1、u2 等。

参数

[in]	expr	待检测的符号表达式
[in]	var	目标变量名

返回

换元映射、代数约束及替换后的表达式；无匹配时保留原表达式。

在文件 transcendental_substitution.cpp 第 264 行定义.

                          {
 
    TransSubstitutionResult result;
    result.poly_expr = nullptr;
 
    if (!expr || !LMCAS::detail::node(expr)) {
        return result;
    }
 
    std::vector<std::shared_ptr<const SymbolicNode>> candidates;
    tf_collect_transcendental(LMCAS::detail::node(expr), var, candidates);
 
    tf_deduplicate(candidates);
 
    for (size_t i = 0; i < candidates.size(); ++i) {
        TransSubstitution mapping;
        mapping.trans_expr = LMCAS::detail::make_expression_ptr(candidates[i]);
        mapping.indeterminate = "u" + std::to_string(i);
        result.mappings.push_back(std::move(mapping));
    }
 
    tf_detect_constraints(result);
 
    if (!result.mappings.empty()) {
        auto substituted = tf_substitute_expr(LMCAS::detail::node(expr), result.mappings);
        result.poly_expr = LMCAS::detail::make_expression_ptr(substituted);
    } else {
        result.poly_expr = expr;
    }
 
    return result;
}

引用了 detect_trans_substitutions(), LMCAS::TransSubstitution::indeterminate, LMCAS::detail::make_expression_ptr(), LMCAS::TransSubstitutionResult::mappings, LMCAS::detail::node(), LMCAS::TransSubstitutionResult::poly_expr, tf_collect_transcendental(), tf_deduplicate(), tf_detect_constraints(), tf_substitute_expr() , 以及 LMCAS::TransSubstitution::trans_expr.

被这些函数引用 detect_trans_substitutions(), factor_transcendental() , 以及 solve_finite_mixed().

函数调用图:

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

determine_search_interval()

std::optional< SearchInterval > LMCAS::determine_search_interval	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts )

在文件 mixed_transcendental_search.cpp 第 143 行定义.

{
    if (opts.has_search_interval) {
        if (opts.search_lo >= opts.search_hi) {
            return std::nullopt;
        }
        if ((opts.search_hi - opts.search_lo) <= opts.tolerance) {
            return std::nullopt;
        }
        return SearchInterval{opts.search_lo, opts.search_hi};
    }
 
    lmmc_real_t lo = -10.0;
    lmmc_real_t hi = 10.0;
 
    if (expr && LMCAS::detail::node(expr)) {
        PeriodicCollector collector(var);
        LMCAS::detail::node(expr)->accept(collector);
 
        if (collector.found_periodic && !collector.has_nonlinear_periodic && collector.max_period > 0.0) {
            // [-period, period] covers two complete periods around zero.
            lmmc_real_t half_span = collector.max_period;
            if (half_span > lo * -1.0 || half_span > hi) {
                lo = -half_span;
                hi = half_span;
            }
            // Cap automatic interval growth to keep numeric scanning bounded.
            if (lo < -100.0) {
                lo = -100.0;
            }
            if (hi > 100.0) {
                hi = 100.0;
            }
        }
    }
 
    if (lo >= hi) {
        return std::nullopt;
    }
    if ((hi - lo) <= opts.tolerance) {
        return std::nullopt;
    }
 
    return SearchInterval{lo, hi};
}

引用了 LMCAS::SymbolicNode::accept(), determine_search_interval(), LMCAS::SolveOptions::has_search_interval, LMCAS::detail::node(), LMCAS::SolveOptions::search_hi, LMCAS::SolveOptions::search_lo , 以及 LMCAS::SolveOptions::tolerance.

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

函数调用图:

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

differential()

std::shared_ptr< SymbolicExpr > LMCAS::differential	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var )

微分 df = f'(var) * dx,返回系数 f'(var)

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

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f || !LMCAS::detail::node(f)) {
        return nullptr;
    }
 
    /// 微分 df = f'(var) * dx,返回系数 f'(var)
    return detail::make_expression_ptr(detail::differentiate_node(detail::node(f), var, transform_budget));
}

引用了 context, differential(), LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr() , 以及 LMCAS::detail::node().

被这些函数引用 differential().

函数调用图:

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

differentiate() [1/2]

ExprResult LMCAS::differentiate	(	const ExprPtr &	expression,
		const std::string &	variable )

在文件 expr_transform.cpp 第 47 行定义.

                                                    {
    ComputationContext context;
    return differentiate(expression, variable, context);
}

引用了 context, differentiate() , 以及 variable.

函数调用图:

differentiate() [2/2]

ExprResult LMCAS::differentiate	(	const ExprPtr &	expression,
		const std::string &	variable,
		ComputationContext &	context )

在文件 expr_transform.cpp 第 36 行定义.

                                                      {
    if (variable.empty()) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "differentiate variable cannot be empty",
                                  kDifferentiateOperation);
    }
    return detail::differentiate_expression(expression, variable, context);
}

引用了 context, differentiate(), LMCAS::detail::differentiate_expression(), LMCAS::expr_detail::expr_common::expression_failure(), InvalidArgument, LMCAS::expr_detail::expr_common::kDifferentiateOperation , 以及 variable.

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

函数调用图:

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

differentiate_if_dependent()

std::shared_ptr< SymbolicExpr > LMCAS::differentiate_if_dependent ( const std::shared_ptr< SymbolicExpr > & expression, const std::string & variable, ComputationContext & context )

static

在文件 complex_analysis.cpp 第 669 行定义.

                                                            {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expression_depends_on_variable(detail::node(expression), variable)) {
        return SymbolicExpr::number(0);
    }
    return detail::make_expression_ptr(detail::differentiate_node(detail::node(expression), variable, transform_budget));
}

引用了 context, differentiate_if_dependent(), LMCAS::detail::differentiate_node(), expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 variable.

被这些函数引用 differentiate_if_dependent() , 以及 is_analytic_impl().

函数调用图:

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

dihedral_angle_checked() [1/2]

ExpressionResult LMCAS::dihedral_angle_checked	(	const PlaneSymbolic &	p1,
		const PlaneSymbolic &	p2 )

在文件 symbolic_geometry_plane.cpp 第 308 行定义.

                             {
    ComputationContext context;
    return dihedral_angle_checked(p1, p2, context);
}

引用了 context, dihedral_angle_checked() , 以及 p2.

函数调用图:

dihedral_angle_checked() [2/2]

ExpressionResult LMCAS::dihedral_angle_checked	(	const PlaneSymbolic &	p1,
		const PlaneSymbolic &	p2,
		ComputationContext &	context )

在文件 symbolic_geometry_plane.cpp 第 280 行定义.

                                 {
    const std::string operation = "dihedral_angle";
    try {
        auto p1_valid = validate_plane_checked(p1, context, operation);
        if (!p1_valid) return ExpressionResult::failure(p1_valid.error());
        auto p2_valid = validate_plane_checked(p2, context, operation);
        if (!p2_valid) return ExpressionResult::failure(p2_valid.error());
 
        auto angle = vector_angle_checked(p1.normal, p2.normal, context);
        if (!angle) return ExpressionResult::failure(angle.error());
        const double pi = std::acos(-1.0);
        const double acute_angle =
            std::min(angle.value(), pi - angle.value());
        return ExpressionResult::success(
            SymbolicExpr::number(acute_angle));
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                         "vector geometry allocation failed",
                                         operation);
    } catch (const std::exception& e) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                         e.what(), operation);
    }
}

引用了 context, dihedral_angle_checked(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, LMCAS::PlaneSymbolic::normal, p2, pi(), ResourceLimit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), LMCAS::geometry_detail::validate_plane_checked(), LMCAS::Result< T >::value() , 以及 vector_angle_checked().

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

函数调用图:

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

dimension_of()

Result< DimensionSignature > LMCAS::dimension_of

(

const SymbolicExpr &

expression

)

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

                                                                        {
    if (!detail::node(expression)) {
        return Result<DimensionSignature>::failure(
            CasErrc::InvalidArgument, "expression cannot be empty", kOperation);
    }
    if (auto quantity = std::dynamic_pointer_cast<const QuantityNode>(detail::node(expression))) {
        return Result<DimensionSignature>::success(quantity->dimension());
    }
    return Result<DimensionSignature>::success(DimensionSignature{});
}

引用了 dimension_of(), LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node() , 以及 LMCAS::Result< T >::success().

被这些函数引用 dimension_of(), eq(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_checked_operands() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

函数调用图:

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

diophantine_target()

bool LMCAS::diophantine_target ( const MultiPoly & target, const std::string & var, const Rational & eval_point, const std::string & main_var, Polynomial< Rational > & target_uni )

static

同一一元变量域内可直接转换。 仅含提升变量的目标须先在提升点求值。

在文件 multivariate_hensel.cpp 第 417 行定义.

                                                                 {
    try {
        target_uni = target.to_univariate();
        /**
         * @brief 同一一元变量域内可直接转换。
         * 仅含提升变量的目标须先在提升点求值。
         */
        if (target_uni.degree() > 0 &&
            target_uni.variable_name != main_var) {
            throw std::logic_error("target uses the lift variable");
        }
    } catch (const std::logic_error&) {
        try {
            MultiPoly target_eval = target.eval(var, eval_point);
            target_uni = target_eval.to_univariate();
        } catch (const std::invalid_argument&) {
            if (target.is_constant()) {
                Rational c = target.is_zero() ? Rational(0) : target.terms()[0].second;
                target_uni = Polynomial<Rational>({c}, main_var);
            } else {
                return false;
            }
        }
    }
    if (target_uni.degree() <= 0) {
        target_uni.variable_name = main_var;
    } else if (target_uni.variable_name != main_var) {
        return false;
    }
    return true;
}

引用了 c, LMCAS::Polynomial< CoeffType >::degree(), diophantine_target(), main_var, target , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 diophantine_target() , 以及 solve_diophantine_pair().

函数调用图:

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

diophantine_univariate_factors()

bool LMCAS::diophantine_univariate_factors ( const std::vector< MultiPoly > & factors, const std::string & var, const Rational & eval_point, Polynomial< Rational > & f1_uni, Polynomial< Rational > & f2_uni )

static

常数转换的默认变量名不代表其系数环。 仅常数可嵌入另一变量环；不同活跃变量须保持区分。

在文件 multivariate_hensel.cpp 第 380 行定义.

                                  {
    bool converted = false;
 
    try {
        f1_uni = factors[0].to_univariate();
        f2_uni = factors[1].to_univariate();
        converted = true;
    } catch (const std::invalid_argument&) {
        try {
            MultiPoly f1_eval = factors[0].eval(var, eval_point);
            MultiPoly f2_eval = factors[1].eval(var, eval_point);
            f1_uni = f1_eval.to_univariate();
            f2_uni = f2_eval.to_univariate();
            converted = true;
        } catch (const std::invalid_argument&) {
            converted = false;
        }
    }
    if (converted && f1_uni.variable_name != f2_uni.variable_name) {
        /**
         * @brief 常数转换的默认变量名不代表其系数环。
         * 仅常数可嵌入另一变量环；不同活跃变量须保持区分。
         */
        if (f1_uni.degree() <= 0) {
            f1_uni = Polynomial<Rational>(f1_uni.coeffs, f2_uni.variable_name);
        } else if (f2_uni.degree() <= 0) {
            f2_uni = Polynomial<Rational>(f2_uni.coeffs, f1_uni.variable_name);
        } else {
            return false;
        }
    }
    return converted;
}

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

被这些函数引用 diophantine_univariate_factors() , 以及 solve_diophantine_pair().

函数调用图:

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

directional_derivative()

std::shared_ptr< SymbolicExpr > LMCAS::directional_derivative	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		const VectorField &	direction,
		int	order )

在文件 vector_calculus_directional.cpp 第 178 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "directional_derivative");
    return directional_derivative_impl(f, vars, direction, order, transform_budget);
}

引用了 context, direction, directional_derivative(), LMCAS::vector_calculus_detail::directional_derivative_impl(), order , 以及 vars.

被这些函数引用 directional_derivative().

函数调用图:

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

directional_derivative_checked() [1/2]

VectorCalculusExprResult LMCAS::directional_derivative_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		const VectorField &	direction,
		int	order )

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

{
    ComputationContext context;
    return directional_derivative_checked(f, vars, direction, order, context);
}

引用了 context, direction, directional_derivative_checked(), order , 以及 vars.

函数调用图:

directional_derivative_checked() [2/2]

VectorCalculusExprResult LMCAS::directional_derivative_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		const VectorField &	direction,
		int	order,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "directional_derivative");
    const std::string operation = "directional_derivative";
    auto valid = vector_calculus_validate_expr_vars(f, vars, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
    auto dir_valid = vector_calculus_validate_field_vars(direction, vars, context, operation);
    if (!dir_valid) {
        return VectorCalculusExprResult::failure(dir_valid.error());
    }
    if (order < 1) {
        return VectorCalculusExprResult::failure(CasErrc::InvalidArgument,
                                                 "directional derivative order must be positive",
                                                 operation);
    }
    try {
        auto mag_sq = vector_calculus_magnitude_squared(direction, transform_budget);
        if (!mag_sq || !LMCAS::detail::node(mag_sq)) {
            return VectorCalculusExprResult::failure(
                CasErrc::InternalInvariant,
                "direction magnitude construction failed",
                operation);
        }
        if (mag_sq->is_zero()) {
            return VectorCalculusExprResult::failure(CasErrc::DomainError,
                                                     "direction vector cannot be zero",
                                                     operation);
        }
        auto step = context.consume_steps(vars.size() * static_cast<std::size_t>(order),
                                          operation);
        if (!step) {
            return VectorCalculusExprResult::failure(step.error());
        }
        return vector_calculus_wrap_expr(
            directional_derivative_impl(f, vars, direction, order, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "vector calculus allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, direction, directional_derivative_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl(), DomainError, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::node(), order, ResourceLimit, vars, vector_calculus_magnitude_squared(), LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_expr().

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

函数调用图:

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

dispatch_equation()

SolveResult LMCAS::dispatch_equation ( const ExprPtr & expr, const ExprPtr & f_expr, const std::string & var, ComputationContext & context, const SolveOptions & opts )

static

在文件 solve_visitor.cpp 第 429 行定义.

                                                                                 {
    auto polynomial = recognize_rational_polynomial(*f_expr, var, context);
    if (!polynomial) { return SolveResult::failure(polynomial.error()); }
    if (polynomial.value()) {
        auto solved = solve_exact_polynomial_set(*polynomial.value(), var, context);
        if (!solved) { return solved; }
        return detail::finalize_solution_set(expr, var, std::move(solved.value()), context, Domain::Complex, opts);
    }
    auto symbolic = symbolic_to_poly<SymbolicPolyCoeff>(f_expr, var);
    if (symbolic) {
        auto solved = solve_symbolic_polynomial_set(symbolic.value(), f_expr, var, context);
        if (!solved) { return solved; }
        return detail::finalize_solution_set(expr, var, std::move(solved.value()), context, Domain::Complex, opts);
    }
    if (symbolic.error().code != CasErrc::UnsupportedExpression) {
        return SolveResult::failure(symbolic.error());
    }
    if (auto product = solve_product_set(f_expr, var, context, opts)) {
        if (!*product) { return std::move(*product); }
        return detail::finalize_solution_set(expr, var, std::move(product->value()), context, Domain::Real, opts);
    }
    auto solved = solve_set_core(f_expr, var, context, opts);
    if (!solved) { return solved; }
    return detail::finalize_solution_set(expr, var, std::move(solved.value()), context, Domain::Real, opts);
}

引用了 Complex, context, dispatch_equation(), LMCAS::Result< SolutionSet >::failure(), LMCAS::detail::finalize_solution_set(), Real, recognize_rational_polynomial(), solve_exact_polynomial_set(), solve_product_set(), solve_set_core(), solve_symbolic_polynomial_set() , 以及 UnsupportedExpression.

被这些函数引用 dispatch_equation() , 以及 solve_equation().

函数调用图:

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

div() [1/2]

ExprResult LMCAS::div	(	const ExprPtr &	numerator,
		const ExprPtr &	denominator )

在文件 expr_arithmetic.cpp 第 46 行定义.

                                                                     {
    ComputationContext context;
    return div(numerator, denominator, context);
}

引用了 context, denominator , 以及 div().

函数调用图:

div() [2/2]

ExprResult LMCAS::div	(	const ExprPtr &	numerator,
		const ExprPtr &	denominator,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 40 行定义.

                                            {
    return quantity_divide(numerator, denominator, context);
}

引用了 context, denominator, div() , 以及 quantity_divide().

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

函数调用图:

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

divergence()

std::shared_ptr< SymbolicExpr > LMCAS::divergence	(	const VectorField &	F,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_differential.cpp 第 341 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "divergence");
    return divergence_impl(F, vars, transform_budget);
}

引用了 context, divergence(), LMCAS::vector_calculus_detail::divergence_impl() , 以及 vars.

被这些函数引用 divergence(), LMCAS::detail::definite::include_divergence(), LMCAS::detail::definite::rational_divergence_checked(), LMCAS::detail::definite::rational_pole_divergence() , 以及 LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked().

函数调用图:

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

divergence_checked() [1/2]

VectorCalculusExprResult LMCAS::divergence_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars )

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

{
    ComputationContext context;
    return divergence_checked(F, vars, context);
}

引用了 context, divergence_checked() , 以及 vars.

函数调用图:

divergence_checked() [2/2]

VectorCalculusExprResult LMCAS::divergence_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "divergence");
    const std::string operation = "divergence";
    auto valid = vector_calculus_validate_field_vars(F, vars, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
    auto step = context.consume_steps(F.size(), operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
    try {
        return vector_calculus_wrap_expr(divergence_impl(F, vars, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "vector calculus allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, divergence_checked(), LMCAS::vector_calculus_detail::divergence_impl(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_expr().

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

函数调用图:

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

divergence_theorem()

std::shared_ptr< SymbolicExpr > LMCAS::divergence_theorem	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	z_bounds )

计算散度 ∇·F = ∂F₁/∂x + ∂F₂/∂y + ∂F₃/∂z

在文件 vector_calculus_integral_api.cpp 第 269 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "divergence_theorem");
    if (F.size() != 3) {
        throw std::invalid_argument("divergence_theorem: F must have 3 components");
    }
    if (vars.size() != 3) {
        throw std::invalid_argument("divergence_theorem: vars must have exactly 3 elements");
    }
    if (!x_bounds.first || !x_bounds.second ||
        !y_bounds.first || !y_bounds.second ||
        !z_bounds.first || !z_bounds.second) {
        throw std::invalid_argument("divergence_theorem: bounds must not be null");
    }
 
    /// 计算散度 ∇·F = ∂F₁/∂x + ∂F₂/∂y + ∂F₃/∂z
    auto div_F = divergence_impl(F, vars, transform_budget);
 
    Integrator integrator;
    std::vector<IntegrationStep> steps = {
        {vars[2], z_bounds.first, z_bounds.second},
        {vars[1], y_bounds.first, y_bounds.second},
        {vars[0], x_bounds.first, x_bounds.second},
    };
    auto result = integrate_multiple_checked(*div_F, steps, integrator, context);
    if (!result) throw result.error();
    return LMCAS::detail::make_expression_ptr(result.value());
}

引用了 context, LMCAS::vector_calculus_detail::divergence_impl(), divergence_theorem(), integrate_multiple_checked(), integrator, LMCAS::detail::make_expression_ptr(), steps, vars, x_bounds, y_bounds , 以及 z_bounds.

被这些函数引用 divergence_theorem().

函数调用图:

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

divergence_theorem_checked() [1/2]

VectorCalculusExprResult LMCAS::divergence_theorem_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	z_bounds )

在文件 vector_calculus_integral_api.cpp 第 258 行定义.

{
    ComputationContext context;
    return divergence_theorem_checked(F, vars, x_bounds, y_bounds, z_bounds, context);
}

引用了 context, divergence_theorem_checked(), vars, x_bounds, y_bounds , 以及 z_bounds.

函数调用图:

divergence_theorem_checked() [2/2]

VectorCalculusExprResult LMCAS::divergence_theorem_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	z_bounds,
		ComputationContext &	context )

在文件 vector_calculus_integral_api.cpp 第 207 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "divergence_theorem");
    const std::string operation = "divergence_theorem";
    auto field_valid = vector_calculus_validate_field_vars(F, vars, context, operation);
    if (!field_valid) {
        return VectorCalculusExprResult::failure(field_valid.error());
    }
    auto vars_valid = vector_calculus_validate_distinct_vars(vars, 3, context, operation);
    if (!vars_valid) {
        return VectorCalculusExprResult::failure(vars_valid.error());
    }
    auto x_valid = vector_calculus_validate_bound_pair(x_bounds, context, operation, "x");
    if (!x_valid) {
        return VectorCalculusExprResult::failure(x_valid.error());
    }
    auto y_valid = vector_calculus_validate_bound_pair(y_bounds, context, operation, "y");
    if (!y_valid) {
        return VectorCalculusExprResult::failure(y_valid.error());
    }
    auto z_valid = vector_calculus_validate_bound_pair(z_bounds, context, operation, "z");
    if (!z_valid) {
        return VectorCalculusExprResult::failure(z_valid.error());
    }
    auto step = context.consume_steps(14, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return divergence_theorem_strict(F, vars, x_bounds, y_bounds, z_bounds, context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "divergence theorem allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, divergence_theorem_checked(), LMCAS::vector_calculus_detail::divergence_theorem_strict(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_bound_pair(), LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars(), x_bounds, y_bounds , 以及 z_bounds.

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

函数调用图:

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

divides_monomial()

bool LMCAS::divides_monomial ( const Monomial & divisor, const Monomial & target )

inline

判断 divisor 是否整除 target

参数

divisor	除数单项式
target	被除数单项式

返回

divisor 的每个分量都不超过 target 对应分量时返回 true

在文件 monomial_order.hpp 第 55 行定义.

                                                                              {
    if (divisor.size() > target.size()) {
        for (size_t i = target.size(); i < divisor.size(); ++i)
            if (divisor[i] != 0) return false;
    }
    for (size_t i = 0; i < std::min(divisor.size(), target.size()); ++i) {
        if (divisor[i] > target[i]) return false;
    }
    return true;
}

引用了 divides_monomial() , 以及 target.

被这些函数引用 divides_monomial(), LMCAS::fglm_detail::is_standard() , 以及 LMCAS::anonymous_namespace{fglm_polynomial.cpp}::reduce_leading_term().

函数调用图:

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

divides_poly()

bool LMCAS::divides_poly ( const MultiPoly & dividend, const MultiPoly & divisor )

static

在文件 multivariate_factor.cpp 第 51 行定义.

{
    if (divisor.is_zero()) { return false; }
    if (dividend.is_zero()) { return true; }
    try { dividend.exact_div(divisor); return true; }
    catch (const std::runtime_error&) { return false; }
}

引用了 divides_poly().

被这些函数引用 divides_poly(), extended_gcd_interpolation() , 以及 recursive_multivariate_gcd().

函数调用图:

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

domain_contains()

Result< bool > LMCAS::domain_contains	(	const NumberDomainSet &	domain,
		const ExprPtr &	element )

在文件 expr_number_domains.cpp 第 377 行定义.

                                                                                    {
    return domain.contains(element);
}

引用了 domain, domain_contains() , 以及 element.

被这些函数引用 domain_contains().

函数调用图:

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

domain_requires_real()

bool LMCAS::domain_requires_real ( Domain domain )

static

在文件 solver_assumptions.cpp 第 53 行定义.

                                                {
    return domain == Domain::Real || domain == Domain::Algebraic ||
           domain == Domain::Rational || domain == Domain::Integer ||
           domain == Domain::Natural || domain == Domain::PositiveInt;
}

引用了 Algebraic, domain, domain_requires_real(), Integer, Natural, PositiveInt, Rational , 以及 Real.

被这些函数引用 domain_requires_real() , 以及 solution_is_excluded().

函数调用图:

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

domain_subset()

Result< bool > LMCAS::domain_subset	(	const NumberDomainSet &	lhs,
		const NumberDomainSet &	rhs )

在文件 expr_number_domains.cpp 第 381 行定义.

                                                                                   {
    return Result<bool>::success(lhs.subset_of(rhs));
}

引用了 domain_subset(), rhs , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_subset().

函数调用图:

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

dot_product()

VectorCalculusExprResult LMCAS::dot_product	(	const VectorField &	a,
		const VectorField &	b )

在文件 vector_calculus_algebra.cpp 第 136 行定义.

                                                                                     {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "dot_product");
    return dot_product_impl(a, b, transform_budget);
} catch (const CasError& error) {
    return VectorCalculusExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
        "vector calculus allocation failed", "dot_product");
} catch (const std::length_error& error) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), "dot_product");
} catch (const std::exception& error) {
    return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, error.what(), "dot_product");
}

引用了 a, b, context, dot_product() , 以及 dot_product_impl().

被这些函数引用 curve_integral_vector(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), dot_product(), stokes_theorem(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), surface_integral_vector(), LMCAS::vector_calculus_detail::surface_integral_vector_strict() , 以及 vector_calculus_surface_dot_strict().

函数调用图:

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

dot_product_impl()

VectorCalculusExprResult LMCAS::dot_product_impl ( const VectorField & a, const VectorField & b, detail::RewriteBudget & transform_budget )

static

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

{
    if (a.size() != b.size()) {
        return VectorCalculusExprResult::failure(
            CasErrc::DimensionMismatch,
            "vectors must have the same dimension",
            "dot_product");
    }
    std::shared_ptr<SymbolicExpr> sum = SymbolicExpr::number(0);
    for (size_t i = 0; i < a.size(); ++i) {
        if (!a[i] || !b[i]) continue;
        sum = SymbolicExpr::add(sum, SymbolicExpr::multiply(a[i], b[i]));
    }
    return VectorCalculusExprResult::success(detail::make_expression_ptr(detail::normalize_node(detail::node(sum), transform_budget)));
}

引用了 a, b, DimensionMismatch, dot_product_impl(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 dot_product(), dot_product_impl(), mixed_product_impl(), scalar_project_impl(), vector_angle_symbolic_impl() , 以及 vector_project_impl().

函数调用图:

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

double_root_inequality_intervals()

Result< std::vector< Interval > > LMCAS::double_root_inequality_intervals ( const Polynomial< Rational > & polynomial, const Rational & rational_part, bool wants_positive, bool leading_positive, bool strict, detail::RewriteBudget & budget )

static

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

                                 {
    auto& context = budget.context();
    auto root = SymbolicExpr::number(rational_part);
    auto verified = verify_quadratic_boundary(
        polynomial, root, rational_part, Rational(0), Rational(0), context);
    if (!verified) {
        return Result<std::vector<Interval>>::failure(verified.error());
    }
 
    if (wants_positive == leading_positive) {
        if (!strict) {
            return Result<std::vector<Interval>>::success({Interval::entire_line()});
        }
        std::vector<Interval> rays{
            Interval{Endpoint::neg_inf(), Endpoint::open(root)},
            Interval{Endpoint::open(root), Endpoint::pos_inf()}
        };
        check_interval_forest(rays, budget);
        return Result<std::vector<Interval>>::success(std::move(rays));
    }
    if (strict) {
        return Result<std::vector<Interval>>::success({});
    }
    std::vector<Interval> point{Interval::point(root)};
    check_interval_forest(point, budget);
    return Result<std::vector<Interval>>::success(std::move(point));
}

引用了 context, LMCAS::detail::RewriteBudget::context(), double_root_inequality_intervals() , 以及 point.

被这些函数引用 double_root_inequality_intervals().

函数调用图:

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

e()

ExprResult LMCAS::e

(

)

在文件 expr_values.cpp 第 112 行定义.

               {
    return detail::constant_expression("e");
}

引用了 LMCAS::detail::constant_expression() , 以及 e().

被这些函数引用 LMCAS::PowerNode::PowerNode(), LMCAS::RewriteVisitor::RewriteVisitor(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::abs_expression(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::arc_length_checked_impl(), assemble_frobenius_polynomial(), LMCAS::berlekamp_detail::bk_poly_pow_mod(), classify_quadric_checked(), LMCAS::MatrixNode::clone(), LMCAS::detail::compare_exact_real_algebraic(), LMCAS::groebner_detail::compute_spoly_sugar(), curl_checked(), curve_integral_scalar_checked(), curve_integral_vector_checked(), dihedral_angle_checked(), directional_derivative_checked(), divergence_checked(), divergence_theorem_checked(), e(), find_extrema_checked(), fourier_transform_checked(), frobenius_indicial_roots(), get_node_degree_helper(), gradient_checked(), greens_theorem_area_checked(), greens_theorem_checked(), hessian_checked(), hl_two_factor_lift(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_by_parts_score(), inverse_derivative_checked(), inverse_fourier_transform_checked(), inverse_function_checked(), inverse_laplace_checked(), LMCAS::anonymous_namespace{solver_assumptions.cpp}::is_integer_value(), LMCAS::ode_root_detail::anonymous_namespace{ode_characteristic_roots.cpp}::iterate_characteristic_roots(), jacobian_checked(), lagrange_multipliers_checked(), laplace_transform_checked(), laplacian_checked(), line_from_two_points_checked(), line_plane_intersection_checked(), matrix_norm(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::newton(), LMCAS::ode_root_detail::Complex::operator/(), LMCAS::expr_detail::ExprParser::parse_identifier_or_call(), plane_from_three_points_checked(), point_plane_distance_checked(), LMCAS::ode_root_detail::polynomial_remainder_is_small(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::refine_projection_interval(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_power_sign(), separable_reciprocal(), singular_series_recurrence(), skew_lines_distance_checked(), solve_bernoulli_ode_checked(), solve_closed_form_from_poly(), solve_exact_ode_checked(), solve_homogeneous_ode_checked(), solve_quartic(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), stokes_theorem_checked(), surface_area_revolution_x_checked(), surface_area_revolution_y_checked(), surface_integral_scalar_checked(), surface_integral_vector_checked(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), te_extract_exp(), te_is_hyp(), te_is_power_of_var(), LMCAS::transform_detail::te_is_zero(), LMCAS::transform_detail::te_split_coeff(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int(), LMCAS::ode_root_detail::trim_polynomial(), validate_frobenius_regular_singular_domain(), vector_calculus_classify_critical_point(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl() , 以及 z_transform_checked().

函数调用图:

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

eliminate_parametric_column()

void LMCAS::eliminate_parametric_column ( ParametricMatrix & A, ParametricVector & b, size_t current_row, size_t col, size_t n, ComputationContext & context )

static

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

                                                                                                               {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    size_t m = A.size();
    auto pivot = A[current_row][col];
 
    for (size_t r = 0; r < m; ++r) {
        if (r == current_row) {
            continue;
        }
        auto entry = detail::make_expression_ptr(detail::normalize_node(detail::node(A[r][col]), transform_budget));
        if (entry->is_zero()) {
            continue;
        }
 
        auto factor = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(entry, pivot)), transform_budget));
 
        for (size_t k = col; k < n; ++k) {
            auto term = SymbolicExpr::multiply(factor, A[current_row][k]);
            A[r][k] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(A[r][k], SymbolicExpr::multiply(term, SymbolicExpr::number(-1)))), transform_budget));
        }
 
        auto b_term = SymbolicExpr::multiply(factor, b[current_row]);
        b[r] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(b[r], SymbolicExpr::multiply(b_term, SymbolicExpr::number(-1)))), transform_budget));
    }
}

引用了 b, context, eliminate_parametric_column(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 r.

被这些函数引用 eliminate_parametric_column().

函数调用图:

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

embed_hensel_terms()

MultiPoly LMCAS::embed_hensel_terms ( const MultiPoly & polynomial, const std::vector< std::string > & variables )

static

在文件 multivariate_hensel.cpp 第 18 行定义.

                                           {
    if (polynomial.variables() == variables) { return polynomial; }
    if (polynomial.is_constant()) {
        return MultiPoly(
            polynomial.is_zero() ? Rational(0) : polynomial.terms().front().second,
            variables);
    }
    std::vector<size_t> coordinates;
    coordinates.reserve(polynomial.variables().size());
    for (const auto& variable : polynomial.variables()) {
        auto position = std::find(variables.begin(), variables.end(), variable);
        if (position == variables.end()) {
            throw std::invalid_argument("Hensel embedding: variable is absent from target ring");
        }
        coordinates.push_back(static_cast<size_t>(position - variables.begin()));
    }
    std::vector<MultiPoly::Term> terms;
    terms.reserve(polynomial.terms().size());
    for (const auto& term : polynomial.terms()) {
        Monomial monomial(variables.size(), 0);
        for (size_t i = 0; i < term.first.size(); ++i) {
            monomial[coordinates[i]] = term.first[i];
        }
        terms.emplace_back(std::move(monomial), term.second);
    }
    return MultiPoly(std::move(terms), variables);
}

引用了 embed_hensel_terms() , 以及 variable.

被这些函数引用 embed_hensel_terms(), embed_without_lifting(), evaluated_lifting_cofactors(), lifting_error_coefficient() , 以及 solve_diophantine_pair().

函数调用图:

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

embed_univariate_gcd()

MultiPoly LMCAS::embed_univariate_gcd ( const MultiPoly & result, const std::string & a_var, const std::vector< std::string > & vars )

static

在文件 multivariate_factor.cpp 第 215 行定义.

                                                              {
    int avi = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == a_var) { avi = static_cast<int>(i); break; }
    }
    std::vector<MultiPoly::Term> nt;
    for (const auto& term : result.terms()) {
        Monomial fm(vars.size(), 0);
        if (avi >= 0 && !term.first.empty()) { fm[static_cast<size_t>(avi)] = term.first[0]; }
        nt.emplace_back(std::move(fm), term.second);
    }
    return MultiPoly(std::move(nt), vars);
}

引用了 embed_univariate_gcd() , 以及 vars.

被这些函数引用 embed_univariate_gcd() , 以及 univariate_gcd().

函数调用图:

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

embed_without_lifting()

std::vector< MultiPoly > LMCAS::embed_without_lifting ( const std::vector< Polynomial< Rational > > & univariate_factors, const std::vector< std::string > & vars )

static

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

                                      {
    std::vector<MultiPoly> result;
    result.reserve(univariate_factors.size());
    for (const auto& uf : univariate_factors) {
        result.push_back(embed_hensel_terms(
            MultiPoly::from_univariate(uf, uf.variable_name), vars));
    }
    return result;
}

引用了 embed_hensel_terms(), embed_without_lifting() , 以及 vars.

被这些函数引用 embed_without_lifting() , 以及 multivariate_hensel_lift().

函数调用图:

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

endpoints_equivalent()

bool LMCAS::endpoints_equivalent ( const Endpoint & left, const Endpoint & right )

static

在文件 property_intervals.cpp 第 26 行定义.

                                                                              {
    if (left.is_open != right.is_open ||
        left.is_neg_infinity != right.is_neg_infinity ||
        left.is_pos_infinity != right.is_pos_infinity) {
        return false;
    }
    if (!left.value || !right.value) {
        return left.value == right.value;
    }
    if (!LMCAS::detail::node(left.value) || !LMCAS::detail::node(right.value)) {
        return LMCAS::detail::node(left.value) == LMCAS::detail::node(right.value);
    }
    return LMCAS::detail::node(left.value)->compare(*LMCAS::detail::node(right.value)) == 0;
}

引用了 LMCAS::SymbolicNode::compare(), endpoints_equivalent(), LMCAS::detail::node() , 以及 right.

被这些函数引用 endpoints_equivalent() , 以及 intervals_equivalent().

函数调用图:

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

eq() [1/2]

ExprResult LMCAS::eq	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_arithmetic.cpp 第 92 行定义.

                                                      {
    ComputationContext context;
    return eq(lhs, rhs, context);
}

引用了 context, eq() , 以及 rhs.

函数调用图:

eq() [2/2]

ExprResult LMCAS::eq	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		ComputationContext &	context )

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

                                           {
    if (!lhs || !rhs) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "eq operands cannot be null", kExprOperation);
    }
    auto left_dimension = dimension_of(*lhs);
    if (!left_dimension) { return ExprResult::failure(left_dimension.error()); }
    auto right_dimension = dimension_of(*rhs);
    if (!right_dimension) { return ExprResult::failure(right_dimension.error()); }
    if (left_dimension.value() != right_dimension.value()) { return integer(0); }
    auto left = comparison_value(lhs, context);
    if (!left) { return left; }
    auto right = comparison_value(rhs, context);
    if (!right) { return right; }
    return make_binary_expr(left.value(), right.value(), context, "eq", SymbolicExpr::eq);
}

引用了 LMCAS::expr_detail::expr_common::comparison_value(), context, dimension_of(), eq(), LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::Result< ExprPtr >::failure(), integer, InvalidArgument, LMCAS::expr_detail::expr_common::kExprOperation, LMCAS::expr_detail::expr_common::make_binary_expr(), rhs , 以及 right.

被这些函数引用 eq(), eq(), find_extrema_impl(), frobenius_indicial_roots(), inverse_derivative_checked(), inverse_function_checked(), LMCAS::anonymous_namespace{solver_assumptions.cpp}::is_integer_value(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_input_polynomials(), solve_lagrange_strict() , 以及 verify_lagrange_solutions().

函数调用图:

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

equation_predicate()

ExprPtr LMCAS::detail::equation_predicate

(

const ExprPtr &

expression

)

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

                                                            {
    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));
}

被这些函数引用 conditional_equation().

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

equivalent()

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

在文件 expr_equivalence.cpp 第 7 行定义.

                                                   {
    return detail::equivalent_impl(lhs, rhs, context, options);
}

引用了 context, equivalent(), LMCAS::detail::equivalent_impl(), options , 以及 rhs.

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

函数调用图:

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

eqv_profile_from_name()

Result< EqvProfile > LMCAS::eqv_profile_from_name

(

const std::string &

name

)

在文件 equivalence_options.cpp 第 42 行定义.

                                                                {
    if (name == "Core") {
        return Result<EqvProfile>::success(EqvProfile::Core);
    }
    if (name == "Trig-Basic") {
        return Result<EqvProfile>::success(EqvProfile::TrigBasic);
    }
    if (name == "ExpLog-Basic") {
        return Result<EqvProfile>::success(EqvProfile::ExpLogBasic);
    }
    return eqv_profile_failure("unsupported equivalence profile: " + name);
}

引用了 Core, eqv_profile_from_name(), ExpLogBasic, name, LMCAS::Result< T >::success() , 以及 TrigBasic.

被这些函数引用 eqv_profile_from_name() , 以及 set_eqv_profile().

函数调用图:

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

error_name() [1/2]

const char * LMCAS::error_name ( CasErrc code )

noexcept

在文件 expr_errors.cpp 第 52 行定义.

                                              {
    switch (code) {
    case CasErrc::InvalidArgument: {
        return "InvalidArgument";
    }
    case CasErrc::ParseError: {
        return "ParseError";
    }
    case CasErrc::UnboundSymbol: {
        return "UnboundSymbol";
    }
    case CasErrc::DomainError: {
        return "DomainError";
    }
    case CasErrc::UnsupportedExpression: {
        return "UnsupportedExpression";
    }
    case CasErrc::Inconclusive: {
        return "Inconclusive";
    }
    case CasErrc::ResourceLimit: {
        return "ResourceLimit";
    }
    case CasErrc::Cancelled: {
        return "Cancelled";
    }
    case CasErrc::NumericFailure: {
        return "NumericFailure";
    }
    case CasErrc::InternalInvariant: {
        return "InternalInvariant";
    }
    default: {
        return unit_set_error_name(code);
    }
    }
}

引用了 Cancelled, DomainError, error_name(), Inconclusive, InternalInvariant, InvalidArgument, NumericFailure, ParseError, ResourceLimit, UnboundSymbol , 以及 UnsupportedExpression.

被这些函数引用 LMCAS::anonymous_namespace{expr_errors.cpp}::equivalence_error_name(), error_name() , 以及 error_name().

函数调用图:

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

error_name() [2/2]

const char * LMCAS::error_name ( const CasError & error )

noexcept

在文件 expr_errors.cpp 第 90 行定义.

                                                       {
    if (error.operation == kSymOperation &&
        error.code == CasErrc::InvalidArgument &&
        error.message.find("imaginary unit") != std::string::npos) {
        return "ImaginaryUnitReserved";
    }
    if (error.operation == kEvalComplexOperation &&
        error.code == CasErrc::UnboundSymbol) {
        return "ComplexEvalUnboundSymbol";
    }
    if (error.operation == kComplexOperation &&
        error.code == CasErrc::InvalidArgument) {
        return "ComplexTypeMismatch";
    }
    if (error.operation == kExprSetOperation &&
        error.code == CasErrc::InvalidArgument) {
        return "SetElementTypeMismatch";
    }
    if (error.operation == kSolveExprSetOperation &&
        error.code == CasErrc::Inconclusive) {
        return "SetResultInconclusive";
    }
    return equivalence_error_name(error);
}

引用了 error_name(), Inconclusive, InvalidArgument, LMCAS::expr_detail::expr_common::kComplexOperation, kEvalComplexOperation, kExprSetOperation, kSolveExprSetOperation, LMCAS::expr_detail::expr_common::kSymOperation , 以及 UnboundSymbol.

函数调用图:

essential_exponent()

std::optional< int > LMCAS::essential_exponent ( const std::shared_ptr< SymbolicExpr > & f, const std::shared_ptr< SymbolicExpr > & shift, ComputationContext & context )

static

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

                                                                           {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto fn = std::dynamic_pointer_cast<const FunctionNode>(detail::node(f));
    if (!fn || fn->type() != FunctionNode::FuncType::Exp ||
        fn->arguments().size() != 1) {
        return std::nullopt;
    }
    auto argument = detail::make_expression_ptr(detail::normalize_node(fn->arguments()[0], transform_budget));
    auto power = std::dynamic_pointer_cast<const PowerNode>(detail::node(argument));
    if (!power) {
        return std::nullopt;
    }
    auto exponent = exact_small_integer_node(
        power->exponent(), -std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
    if (!exponent) {
        return std::nullopt;
    }
    auto base = detail::make_expression_ptr(detail::normalize_node(power->base(), transform_budget));
    auto delta = detail::make_expression_ptr(detail::normalize_node(detail::node(shift), transform_budget));
    if (base->compare(delta) == 0 && *exponent < 0) {
        return -*exponent;
    }
    auto nested = std::dynamic_pointer_cast<const PowerNode>(detail::node(base));
    if (nested && *exponent == -1) {
        auto m = exact_small_integer_node(
            nested->exponent(), 1, std::numeric_limits<int>::max());
        auto nested_base = detail::make_expression_ptr(detail::normalize_node(nested->base(), transform_budget));
        if (m && nested_base->compare(delta) == 0) {
            return m;
        }
    }
    return std::nullopt;
}

引用了 context, essential_exponent(), exact_small_integer_node(), LMCAS::FunctionNode::Exp, exponent, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 essential_exponent() , 以及 laurent_series_full_impl().

函数调用图:

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

essential_laurent()

LaurentSeriesResult LMCAS::essential_laurent ( const std::shared_ptr< SymbolicExpr > & shift, int m, int order_neg, ComputationContext & context )

static

在文件 series_expansions.cpp 第 123 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "laurent_series_full";
    auto series = SymbolicExpr::number(1);
    BigInt factorial(1);
    for (int k = 1; k <= order_neg / m; ++k) {
        auto step = context.consume_steps(1, operation);
        if (!step) {
            return LaurentSeriesResult::failure(step.error());
        }
        factorial *= BigInt(k);
        auto term = SymbolicExpr::divide(
            SymbolicExpr::number(1),
            SymbolicExpr::multiply(
                SymbolicExpr::number(factorial),
                SymbolicExpr::power(shift, SymbolicExpr::number(m * k))));
        series = SymbolicExpr::add(series, term);
    }
    return LaurentResult{
        detail::make_expression_ptr(detail::normalize_node(detail::node(series), transform_budget)), SingularityType::Essential, 0,
        SymbolicExpr::number(m == 1 ? 1 : 0)};
} catch (const CasError& error) {
    return LaurentSeriesResult::failure(error);
} catch (const std::bad_alloc&) {
    return LaurentSeriesResult::failure(CasErrc::ResourceLimit, "allocation failed", "laurent_series_full");
} catch (const std::length_error& error) {
    return LaurentSeriesResult::failure(CasErrc::ResourceLimit, error.what(), "laurent_series_full");
} catch (const std::exception& error) {
    return LaurentSeriesResult::failure(CasErrc::InternalInvariant, error.what(), "laurent_series_full");
}

引用了 context, Essential, essential_laurent(), LMCAS::Result< LaurentResult >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 essential_laurent() , 以及 laurent_series_full_impl().

函数调用图:

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

eval_complex() [1/2]

Result< ApproxComplex > LMCAS::eval_complex	(	const SymbolicExpr &	expression,
		const NumericBindings &	bindings )

在文件 expr_complex_evaluation.cpp 第 333 行定义.

                                                                    {
    ComputationContext context;
    return eval_complex(expression, bindings, context);
}

引用了 bindings, context , 以及 eval_complex().

函数调用图:

eval_complex() [2/2]

Result< ApproxComplex > LMCAS::eval_complex	(	const SymbolicExpr &	expression,
		const NumericBindings &	bindings,
		ComputationContext &	context )

在文件 expr_complex_evaluation.cpp 第 312 行定义.

                                                                {
    try {
        if (!LMCAS::detail::node(expression)) {
            return complex_failure(CasErrc::InvalidArgument,
                                   "cannot evaluate an empty expression as complex",
                                   kEvalComplexOperation);
        }
        return evaluate_complex_node(LMCAS::detail::node(expression),
                                     bindings, context);
    } catch (const std::bad_alloc&) {
        return complex_failure(CasErrc::ResourceLimit,
                               "complex evaluation allocation failed",
                               kEvalComplexOperation);
    } catch (const std::exception& error) {
        return complex_failure(CasErrc::InternalInvariant, error.what(),
                               kEvalComplexOperation);
    }
}

引用了 bindings, context, eval_complex(), InternalInvariant, InvalidArgument, kEvalComplexOperation, LMCAS::detail::node() , 以及 ResourceLimit.

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

函数调用图:

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

evalf() [1/2]

Result< ApproxReal > LMCAS::evalf	(	const SymbolicExpr &	expression,
		const NumericBindings &	bindings )

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

                                                          {
    ComputationContext context;
    return evalf(expression, bindings, context);
}

引用了 bindings, context , 以及 evalf().

函数调用图:

evalf() [2/2]

Result< ApproxReal > LMCAS::evalf	(	const SymbolicExpr &	expression,
		const NumericBindings &	bindings,
		ComputationContext &	context )

在文件 expr_complex_evaluation.cpp 第 291 行定义.

                                                      {
    auto evaluated = evaluate_numeric(expression, bindings, context);
    if (!evaluated) { return evaluated; }
    if (!evaluated.value().is_finite() ||
        !std::isfinite(evaluated.value().value)) {
        return Result<ApproxReal>::failure(
            CasErrc::NumericFailure,
            "LMCAS evalf produced a non-finite result",
            kEvalfOperation);
    }
    return evaluated;
}

引用了 bindings, context, evalf(), evaluate_numeric(), LMCAS::Result< T >::failure() , 以及 NumericFailure.

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

函数调用图:

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

evaluate_numeric() [1/2]

Result< ApproxReal > LMCAS::evaluate_numeric	(	const SymbolicExpr &	expression,
		const NumericBindings &	bindings,
		ComputationContext &	context )

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

                                                                     {
    if (!detail::node(expression)) {
        return Result<ApproxReal>::failure(CasErrc::InvalidArgument,
                                           "cannot evaluate an empty expression", kOperation);
    }
    detail::NumericEvaluator evaluator(bindings, context);
    return evaluator.evaluate(detail::node(expression));
}
catch (const CasError& error) {
    return Result<ApproxReal>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<ApproxReal>::failure(
        CasErrc::ResourceLimit, "numeric evaluation allocation failed", kOperation);
} catch (const std::length_error& error) {
    return Result<ApproxReal>::failure(CasErrc::ResourceLimit, error.what(), kOperation);
} catch (const std::exception& error) {
    return Result<ApproxReal>::failure(CasErrc::InternalInvariant, error.what(), kOperation);
}

引用了 bindings, context, LMCAS::detail::NumericEvaluator::evaluate(), evaluate_numeric(), LMCAS::Result< T >::failure(), InvalidArgument , 以及 LMCAS::detail::node().

函数调用图:

evaluate_numeric() [2/2]

Result< ApproxReal > LMCAS::evaluate_numeric ( const SymbolicExpr & expression, const NumericBindings & bindings = {} )

inline

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

                                                                           {}) {
    ComputationContext context;
    return evaluate_numeric(expression, bindings, context);
}

引用了 bindings , 以及 evaluate_numeric().

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic(), LMCAS::geometry_detail::checked_nonzero_numeric_or_exact(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::classify_constant_equation(), LMCAS::anonymous_namespace{numerical_integration.cpp}::eval_bound_checked(), evalf(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_components(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_node(), evaluate_numeric(), evaluate_numeric(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_quadrature_callback(), LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_function(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::finite_numeric_coeff(), line_plane_intersection_checked(), LMCAS::geometry_detail::numeric_vector_scale_checked(), LMCAS::anonymous_namespace{symbolic_geometry_vector.cpp}::symbolic_vector_finite_numeric() , 以及 LMCAS::detail::try_finite_numeric().

函数调用图:

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

evaluated_lifting_cofactors()

std::vector< MultiPoly > LMCAS::evaluated_lifting_cofactors ( const std::vector< MultiPoly > & factors, const std::string & lift_var, const Rational & eval_point, const std::vector< std::string > & vars )

static

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

                                                                  {
    const int r = static_cast<int>(factors.size());
    std::vector<MultiPoly> cofactors;
    cofactors.reserve(r);
    for (int i = 0; i < r; ++i) {
        MultiPoly cof(Rational(1), vars);
        for (int j = 0; j < r; ++j) {
            if (j == i) { continue; }
            MultiPoly fj_eval = embed_hensel_terms(
                factors[j].eval(lift_var, eval_point), vars);
            cof = cof * fj_eval;
        }
        cofactors.push_back(cof);
    }
    return cofactors;
}

引用了 embed_hensel_terms(), evaluated_lifting_cofactors(), r , 以及 vars.

被这些函数引用 apply_hensel_lift_steps() , 以及 evaluated_lifting_cofactors().

函数调用图:

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

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));
}

被这些函数引用 interval_contains_checked().

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

exact_factor_roots()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::exact_factor_roots ( Polynomial< Rational > polynomial, ComputationContext & context )

static

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

                                                                  {
 
    std::vector<std::shared_ptr<SymbolicExpr>> roots;
    while (polynomial.degree() >= 3 && polynomial.coeffs[0] == Rational(0)) {
        roots.push_back(SymbolicExpr::number(0));
        polynomial.coeffs.erase(polynomial.coeffs.begin());
    }
    if (polynomial.degree() >= 3) {
        if (bounded_rational_root_search(polynomial)) {
            for (const auto& root : find_rational_roots(polynomial)) {
                Polynomial<Rational> linear(
                    {-root, Rational(1)}, polynomial.variable_name);
                auto [quotient, remainder] = polynomial.div_mod(linear);
                if (!remainder.is_zero()) {
                    throw std::logic_error("polynomial solver: inexact rational root division");
                }
                roots.push_back(SymbolicExpr::number(root));
                polynomial = std::move(quotient);
            }
        }
    }
    if (polynomial.degree() == 1) {
        roots.push_back(SymbolicExpr::number(
            -polynomial.coeffs[0] / polynomial.coeffs[1]));
    } else if (polynomial.degree() == 2) {
        auto quadratic = solve_quadratic_internal(
            SymbolicExpr::number(polynomial.coeffs[2]),
            SymbolicExpr::number(polynomial.coeffs[1]),
            SymbolicExpr::number(polynomial.coeffs[0]), context);
        roots.insert(roots.end(), quadratic.begin(), quadratic.end());
    } else if (polynomial.degree() == 4 &&
               polynomial.coeffs[3] == Rational(0) &&
               polynomial.coeffs[1] == Rational(0)) {
        auto biquadratic = solve_biquadratic_impl(
            SymbolicExpr::number(polynomial.coeffs[4]),
            SymbolicExpr::number(polynomial.coeffs[2]),
            SymbolicExpr::number(polynomial.coeffs[0]),
            polynomial.variable_name, context);
        roots.insert(roots.end(), biquadratic.begin(), biquadratic.end());
    } else if (polynomial.degree() >= 3) {
        auto expression = poly_to_symbolic(polynomial);
        for (int index = 0; index < polynomial.degree(); ++index) {
            auto root = make_rootof_checked(expression, polynomial.variable_name,
                static_cast<std::size_t>(index), context);
            if (!root) throw root.error();
            roots.push_back(std::move(root.value()));
        }
    }
    return roots;
}

引用了 LMCAS::polynomial_solver_detail::bounded_rational_root_search(), LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), exact_factor_roots(), find_rational_roots(), make_rootof_checked(), roots(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), LMCAS::polynomial_solver_detail::solve_quadratic_internal() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 exact_factor_roots() , 以及 LMCAS::polynomial_solver_detail::exact_polynomial_roots().

函数调用图:

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

exact_number_as_rational()

Rational LMCAS::exact_number_as_rational

(

const NumberNode &

node

)

在文件 normalization_utils.cpp 第 137 行定义.

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

引用了 exact_number_as_rational() , 以及 rational().

被这些函数引用 LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::accumulate_numeric_product(), add_numbers(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append_mixed_product(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append_number(), LMCAS::detail::closed_rational_value(), collect_scalar_radical(), LMCAS::detail::definite::exact_number(), exact_number_as_rational(), exact_radical_domain_excludes(), exact_scalar_radicand(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::logarithm(), multiply_numbers(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::node_to_multivariate_polynomial(), symbolic_node_to_multipoly() , 以及 LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::trigonometric_domain().

函数调用图:

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

exact_numeric_sign()

int LMCAS::detail::inequality_support::exact_numeric_sign	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context )

在文件 inequality_solver_numeric.cpp 第 26 行定义.

                                                    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expr || !LMCAS::detail::node(expr)) {
        return 0;
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(expr), transform_budget));
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return 0;
    }
    auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(simplified));
    if (!num) {
        return 0;
    }
    if (std::holds_alternative<BigInt>(num->value())) {
        const auto& value = std::get<BigInt>(num->value());
        if (value.is_zero()) {
            return 0;
        }
        return value.is_negative() ? -1 : 1;
    }
    const auto& value = std::get<Rational>(num->value());
    if (value.get_numerator().is_zero()) {
        return 0;
    }
    return value.get_numerator().is_negative() ? -1 : 1;
}

exact_radical_domain_excludes()

bool LMCAS::exact_radical_domain_excludes ( const SymbolicNode * node, Domain domain )

static

在文件 solver_assumptions.cpp 第 161 行定义.

                                                                                   {
    if (domain != Domain::Rational && domain != Domain::Integer &&
        domain != Domain::Natural && domain != Domain::PositiveInt) {
        return false;
    }
    Rational coefficient(1);
    const NumberNode* radicand = nullptr;
    if (!collect_scalar_radical(node, coefficient, radicand)) {
        return false;
    }
    if (coefficient == Rational(0)) {
        return exact_rational_domain_excludes(coefficient, domain);
    }
    if (exact_number_as_rational(*radicand) < Rational(0)) {
        return false;
    }
    const auto root = normalization_exact_square_root(*radicand);
    if (!root) {
        return true;
    }
    return exact_rational_domain_excludes(
        coefficient * exact_number_as_rational(*root), domain);
}

引用了 collect_scalar_radical(), domain, exact_number_as_rational(), exact_radical_domain_excludes(), exact_rational_domain_excludes(), Integer, Natural, normalization_exact_square_root(), PositiveInt , 以及 Rational.

被这些函数引用 exact_radical_domain_excludes() , 以及 solution_is_excluded().

函数调用图:

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

exact_rational_domain_excludes()

bool LMCAS::exact_rational_domain_excludes ( const Rational & value, Domain domain )

static

在文件 solver_assumptions.cpp 第 145 行定义.

                                                                                 {
    if (domain == Domain::Rational) {
        return false;
    }
    if (!value.is_integer()) {
        return true;
    }
    if (domain == Domain::Natural) {
        return value < Rational(0);
    }
    if (domain == Domain::PositiveInt) {
        return value <= Rational(0);
    }
    return false;
}

引用了 domain, exact_rational_domain_excludes(), Natural, PositiveInt, Rational , 以及 value.

被这些函数引用 exact_radical_domain_excludes() , 以及 exact_rational_domain_excludes().

函数调用图:

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

exact_scalar_number()

const NumberNode * LMCAS::exact_scalar_number ( const SymbolicNode * node )

static

在文件 solver_assumptions.cpp 第 102 行定义.

                                                                       {
    return dynamic_cast<const NumberNode*>(node);
}

引用了 exact_scalar_number().

被这些函数引用 collect_scalar_radical(), exact_scalar_number() , 以及 exact_scalar_radicand().

函数调用图:

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

exact_scalar_radicand()

const NumberNode * LMCAS::exact_scalar_radicand ( const SymbolicNode * node )

static

在文件 solver_assumptions.cpp 第 106 行定义.

                                                                         {
    if (const auto* power = dynamic_cast<const PowerNode*>(node)) {
        const auto* exponent = exact_scalar_number(power->exponent().get());
        if (exponent && exact_number_as_rational(*exponent) == Rational(1, 2)) {
            return exact_scalar_number(power->base().get());
        }
    }
    if (const auto* function = dynamic_cast<const FunctionNode*>(node)) {
        if (function->type() == FunctionNode::FuncType::Sqrt &&
            function->arguments().size() == 1) {
            return exact_scalar_number(function->arguments()[0].get());
        }
    }
    return nullptr;
}

引用了 exact_number_as_rational(), exact_scalar_number(), exact_scalar_radicand(), exponent, function() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 collect_scalar_radical() , 以及 exact_scalar_radicand().

函数调用图:

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

exact_small_integer_node()

std::optional< int > LMCAS::exact_small_integer_node	(	const detail::SymbolicNodePtr &	node,
		int	min_value,
		int	max_value )

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

                                                                     {
    auto number = std::dynamic_pointer_cast<const NumberNode>(node);
    if (!number) return std::nullopt;
 
    BigInt value;
    if (std::holds_alternative<BigInt>(number->value())) {
        value = std::get<BigInt>(number->value());
    } else if (std::holds_alternative<Rational>(number->value())) {
        const Rational& rational = std::get<Rational>(number->value());
        if (!rational.is_integer()) return std::nullopt;
        value = rational.to_bigint();
    } else {
        return std::nullopt;
    }
 
    const auto exact = value.try_to_int64();
    if (!exact || *exact < min_value || *exact > max_value) {
        return std::nullopt;
    }
    return static_cast<int>(*exact);
}

引用了 exact_small_integer_node(), rational() , 以及 value.

被这些函数引用 LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), essential_exponent(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_polynomial_nodes(), exact_small_integer_node(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_is_variable_square() , 以及 LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values().

函数调用图:

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

exp() [1/2]

ExprResult LMCAS::exp

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 117 行定义.

                                          {
    ComputationContext context;
    return exp(expression, context);
}

引用了 context , 以及 exp().

函数调用图:

exp() [2/2]

ExprResult LMCAS::exp	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 110 行定义.

                                                                       {
    auto valid = require_dimensionless(expression, "exp");
    if (!valid) { return valid; }
    return make_unary_math_expr(expression, context, "exp",
                                SymbolicExpr::exp);
}

引用了 context, exp(), LMCAS::expr_detail::expr_common::make_unary_math_expr() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

被这些函数引用 LMCAS::anonymous_namespace{bigint_number_theory.cpp}::binary_modular_power(), LMCAS::berlekamp_detail::bk_poly_pow_mod(), collect_power_denominators(), exp(), exp(), extract_coefficients(), LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), formal_derivative(), LMCAS::solver_detail::is_polynomial_node(), lifting_error_coefficient(), lifting_residual_is_zero(), LMCAS::solver_detail::multiply_no_expand(), LMCAS::ModInt::pow(), LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_linear_term() , 以及 truncate_mod_var().

函数调用图:

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

expand() [1/2]

ExprResult LMCAS::expand

(

const ExprPtr &

expression

)

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

                                             {
    ComputationContext context;
    return expand(expression, context);
}

引用了 context , 以及 expand().

函数调用图:

expand() [2/2]

ExprResult LMCAS::expand	(	const ExprPtr &	expression,
		ComputationContext &	context )

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

                                                                          {
    return detail::expand_expression(expression, context);
}

引用了 context, expand() , 以及 LMCAS::detail::expand_expression().

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

函数调用图:

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

explicit_inverse_candidates()

SymbolicExprVectorResult LMCAS::explicit_inverse_candidates ( const FiniteSolutions & finite, const std::string & operation )

static

在文件 calculus_inverse.cpp 第 295 行定义.

{
            std::vector<std::shared_ptr<SymbolicExpr>> values;
            values.reserve(finite.values.size());
            for (const auto& solution : finite.values) {
                if (!solution.value || !LMCAS::detail::node(solution.value)) {
                    return SymbolicExprVectorResult::failure(
                        CasErrc::InternalInvariant,
                        "checked solver returned a null inverse candidate",
                        operation);
                }
                auto candidate = rootof_simplify(solution.value);
                if (!candidate || !LMCAS::detail::node(candidate)) {
                    return SymbolicExprVectorResult::failure(
                        CasErrc::InternalInvariant,
                        "checked solver returned a malformed inverse candidate",
                        operation);
                }
                values.push_back(candidate);
            }
            return SymbolicExprVectorResult::success(std::move(values));
}

引用了 explicit_inverse_candidates(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), InternalInvariant, LMCAS::detail::node(), rootof_simplify(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 LMCAS::FiniteSolutions::values.

被这些函数引用 explicit_inverse_candidates() , 以及 inverse_function_checked().

函数调用图:

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

expr_match() [1/2]

ExprMatchResult LMCAS::expr_match	(	const ExprPtr &	pattern,
		const ExprPtr &	target,
		const std::vector< std::string > &	wildcards )

在文件 expr_transform.cpp 第 207 行定义.

                                                                  {
    ComputationContext context;
    return expr_match(pattern, target, wildcards, context);
}

引用了 context, expr_match(), target , 以及 wildcards.

函数调用图:

expr_match() [2/2]

ExprMatchResult LMCAS::expr_match	(	const ExprPtr &	pattern,
		const ExprPtr &	target,
		const std::vector< std::string > &	wildcards,
		ComputationContext &	context )

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

                                                        {
    auto step = context.consume_steps(1, kExprMatchOperation);
    if (!step) return ExprMatchResult::failure(step.error());
    if (!pattern || !LMCAS::detail::node(pattern)) {
        return expr_match_failure(CasErrc::InvalidArgument,
                                  "match pattern cannot be null",
                                  kExprMatchOperation);
    }
    if (!target || !LMCAS::detail::node(target)) {
        return expr_match_failure(CasErrc::InvalidArgument,
                                  "match target cannot be null",
                                  kExprMatchOperation);
    }
 
    std::unordered_set<std::string> wildcard_set;
    wildcard_set.reserve(wildcards.size());
    for (const auto& wildcard : wildcards) {
        if (wildcard.empty()) {
            return expr_match_failure(CasErrc::InvalidArgument,
                                      "wildcard names cannot be empty",
                                      kExprMatchOperation);
        }
        if (!wildcard_set.insert(wildcard).second) {
            return expr_match_failure(CasErrc::InvalidArgument,
                                      "wildcard names must be unique",
                                      kExprMatchOperation);
        }
    }
 
    try {
        MatchMap raw_bindings;
        const bool matched = Matcher::match(
            *pattern, *target, wildcard_set, raw_bindings);
        if (!matched) {
            return ExprMatchResult::success(ExprMatch{false, {}});
        }
 
        std::vector<std::string> names;
        names.reserve(raw_bindings.size());
        for (const auto& binding : raw_bindings) {
            names.push_back(binding.first);
        }
        std::sort(names.begin(), names.end());
 
        ExprMatch result;
        result.matched = true;
        result.bindings.reserve(names.size());
        for (const auto& name : names) {
            const auto& value = raw_bindings.at(name);
            auto node = LMCAS::detail::node(value);
            if (!node) {
                return expr_match_failure(CasErrc::InternalInvariant,
                                          "matcher produced a null binding",
                                          kExprMatchOperation);
            }
            result.bindings.push_back(
                ExprMatchBinding{name,
                                 LMCAS::detail::make_expression_ptr(node)});
        }
        return ExprMatchResult::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return expr_match_failure(CasErrc::ResourceLimit,
                                  "expression matching allocation failed",
                                  kExprMatchOperation);
    } catch (const std::exception& error) {
        return expr_match_failure(CasErrc::InternalInvariant, error.what(),
                                  kExprMatchOperation);
    }
}

引用了 binding, LMCAS::ExprMatch::bindings, context, expr_match(), LMCAS::expr_detail::expr_common::expr_match_failure(), LMCAS::Result< ExprMatch >::failure(), InternalInvariant, InvalidArgument, LMCAS::expr_detail::expr_common::kExprMatchOperation, LMCAS::detail::make_expression_ptr(), LMCAS::ExprMatch::matched, name, LMCAS::detail::node(), ResourceLimit, LMCAS::Result< ExprMatch >::success(), target, value, wildcard() , 以及 wildcards.

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

函数调用图:

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

expr_set()

ExprSetResult LMCAS::expr_set

(

std::vector< ExprPtr >

elements

)

在文件 expr_sets.cpp 第 82 行定义.

                                                    {
    try {
        return ExprSet::make(std::move(elements));
    } catch (const std::bad_alloc&) {
        return expr_set_failure(CasErrc::ResourceLimit,
                                "set<Expr> allocation failed",
                                kExprSetOperation);
    } catch (const std::exception& error) {
        return expr_set_failure(CasErrc::InternalInvariant, error.what(),
                                kExprSetOperation);
    }
}

引用了 expr_set(), expr_set_failure(), InternalInvariant, kExprSetOperation , 以及 ResourceLimit.

被这些函数引用 expr_set() , 以及 project_finite_expr_set().

函数调用图:

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

expr_set_contains()

Result< bool > LMCAS::expr_set_contains	(	const ExprSet &	set,
		const ExprPtr &	element )

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

                                                       {
    if (!element) {
        return Result<bool>::failure(CasErrc::InvalidArgument,
                                     "set<Expr> membership element cannot be null",
                                     kExprSetOperation);
    }
    return Result<bool>::success(set.contains(*element));
}

引用了 element, expr_set_contains(), LMCAS::Result< T >::failure(), InvalidArgument, kExprSetOperation, set , 以及 LMCAS::Result< T >::success().

被这些函数引用 expr_set_contains() , 以及 expr_set_not_contains().

函数调用图:

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

expr_set_difference()

ExprSetResult LMCAS::expr_set_difference	(	const ExprSet &	lhs,
		const ExprSet &	rhs )

在文件 expr_sets.cpp 第 171 行定义.

{
    try {
        ComputationContext context;
        auto expression =
            finite_set_difference(*lhs.expression_, *rhs.expression_, context);
        if (!expression) {
            return ExprSetResult::failure(expression.error());
        }
        return ExprSetResult::success(ExprSet(
            std::make_shared<const SymbolicExpr>(*expression.value())));
    } catch (const std::bad_alloc&) {
        return expr_set_failure(
            CasErrc::ResourceLimit,
            "set<Expr> difference allocation failed",
            kExprSetOperation);
    }
}

引用了 context, expr_set_difference(), expr_set_failure(), LMCAS::Result< ExprSet >::failure(), finite_set_difference(), kExprSetOperation, ResourceLimit, rhs , 以及 LMCAS::Result< ExprSet >::success().

被这些函数引用 expr_set_difference().

函数调用图:

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

expr_set_failure()

ExprSetResult LMCAS::expr_set_failure ( CasErrc code, std::string message, const char * operation )

inline

在文件 expr_internal.hpp 第 18 行定义.

                                                             {
    return ExprSetResult::failure(code, std::move(message), operation);
}

引用了 expr_set_failure() , 以及 LMCAS::Result< ExprSet >::failure().

被这些函数引用 expr_set(), expr_set_difference(), expr_set_failure(), expr_set_intersection(), expr_set_symmetric_difference(), expr_set_union() , 以及 project_finite_expr_set().

函数调用图:

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

expr_set_intersection()

ExprSetResult LMCAS::expr_set_intersection	(	const ExprSet &	lhs,
		const ExprSet &	rhs )

在文件 expr_sets.cpp 第 151 行定义.

{
    try {
        ComputationContext context;
        auto expression = finite_set_intersection(
            *lhs.expression_, *rhs.expression_, context);
        if (!expression) {
            return ExprSetResult::failure(expression.error());
        }
        return ExprSetResult::success(ExprSet(
            std::make_shared<const SymbolicExpr>(*expression.value())));
    } catch (const std::bad_alloc&) {
        return expr_set_failure(
            CasErrc::ResourceLimit,
            "set<Expr> intersection allocation failed",
            kExprSetOperation);
    }
}

引用了 context, expr_set_failure(), expr_set_intersection(), LMCAS::Result< ExprSet >::failure(), finite_set_intersection(), kExprSetOperation, ResourceLimit, rhs , 以及 LMCAS::Result< ExprSet >::success().

被这些函数引用 expr_set_intersection().

函数调用图:

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

expr_set_not_contains()

Result< bool > LMCAS::expr_set_not_contains	(	const ExprSet &	set,
		const ExprPtr &	element )

在文件 expr_sets.cpp 第 106 行定义.

                                                           {
    auto result = expr_set_contains(set, element);
    if (!result) { return result; }
    return Result<bool>::success(!result.value());
}

引用了 element, expr_set_contains(), expr_set_not_contains(), set , 以及 LMCAS::Result< T >::success().

被这些函数引用 expr_set_not_contains().

函数调用图:

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

expr_set_subset()

Result< bool > LMCAS::expr_set_subset	(	const ExprSet &	lhs,
		const ExprSet &	rhs )

在文件 expr_sets.cpp 第 113 行定义.

                                                 {
    return Result<bool>::success(lhs.subset_of(rhs));
}

引用了 expr_set_subset(), rhs , 以及 LMCAS::Result< T >::success().

被这些函数引用 expr_set_subset().

函数调用图:

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

expr_set_subset_domain()

Result< bool > LMCAS::expr_set_subset_domain	(	const ExprSet &	set,
		const NumberDomainSet &	domain )

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

                                                                   {
    for (const auto& element : set.elements()) {
        auto contains = domain.contains(element);
        if (!contains) {
            return contains;
        }
        if (!contains.value()) {
            return Result<bool>::success(false);
        }
    }
    return Result<bool>::success(true);
}

引用了 contains(), domain, element, expr_set_subset_domain(), set , 以及 LMCAS::Result< T >::success().

被这些函数引用 expr_set_subset_domain().

函数调用图:

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

expr_set_symmetric_difference()

ExprSetResult LMCAS::expr_set_symmetric_difference	(	const ExprSet &	lhs,
		const ExprSet &	rhs )

在文件 expr_sets.cpp 第 191 行定义.

{
    try {
        ComputationContext context;
        auto expression = finite_set_symmetric_difference(
            *lhs.expression_, *rhs.expression_, context);
        if (!expression) {
            return ExprSetResult::failure(expression.error());
        }
        return ExprSetResult::success(ExprSet(
            std::make_shared<const SymbolicExpr>(*expression.value())));
    } catch (const std::bad_alloc&) {
        return expr_set_failure(
            CasErrc::ResourceLimit,
            "set<Expr> symmetric difference allocation failed",
            kExprSetOperation);
    }
}

引用了 context, expr_set_failure(), expr_set_symmetric_difference(), LMCAS::Result< ExprSet >::failure(), finite_set_symmetric_difference(), kExprSetOperation, ResourceLimit, rhs , 以及 LMCAS::Result< ExprSet >::success().

被这些函数引用 expr_set_symmetric_difference().

函数调用图:

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

expr_set_union()

ExprSetResult LMCAS::expr_set_union	(	const ExprSet &	lhs,
		const ExprSet &	rhs )

在文件 expr_sets.cpp 第 132 行定义.

{
    try {
        ComputationContext context;
        auto expression =
            finite_set_union(*lhs.expression_, *rhs.expression_, context);
        if (!expression) {
            return ExprSetResult::failure(expression.error());
        }
        return ExprSetResult::success(ExprSet(
            std::make_shared<const SymbolicExpr>(*expression.value())));
    } catch (const std::bad_alloc&) {
        return expr_set_failure(
            CasErrc::ResourceLimit, "set<Expr> union allocation failed",
            kExprSetOperation);
    }
}

引用了 context, expr_set_failure(), expr_set_union(), LMCAS::Result< ExprSet >::failure(), finite_set_union(), kExprSetOperation, ResourceLimit, rhs , 以及 LMCAS::Result< ExprSet >::success().

被这些函数引用 expr_set_union().

函数调用图:

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

expression_depends_on_variable()

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

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

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

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

被这些函数引用 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::anonymous_namespace{limit_result.cpp}::classify_limit_result(), LMCAS::anonymous_namespace{integration_substitution.cpp}::classify_linear_wrapper(), coefficient_power_radius(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::PeriodicCollector::collect_period(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::compatible_periodic_conditions(), contains(), convergence_radius_checked(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::degree_in_var(), LMCAS::detail::inequality_support::depends_on_any_param(), detect_substitution(), differentiate_if_dependent(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), expression_depends_on_variable(), extract_bernoulli_factor(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::extract_linear_coefficient(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::function_candidate(), LMCAS::groebner_detail::PolyBuilder::function_depends_on_variables(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::independent_of_variables(), integrating_factor_from_ratio(), is_bernoulli_ode(), is_constant_coefficient(), is_euler_equation(), is_linear_first_order(), is_polynomial_after_substitution(), is_separable(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::is_substitution_polynomial(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::lambert_inner(), laurent_series_full_impl(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::opposite_exponential_lambert_pattern(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::power_candidate(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::power_pattern(), prepare_fourier_period(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::rewrite_scoped(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::scaled_function(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), separable_product(), separable_reciprocal(), LMCAS::detail::ScopedFacts::shadows(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_factor(), solve_separable_ode(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl(), symbolic_to_poly_recursive(), LMCAS::transform_detail::te_depends_on(), te_is_denominator_factor(), LMCAS::transform_detail::te_linear_coefficient(), LMCAS::transform_detail::te_split_coeff(), tf_back_substitute(), tf_collect_transcendental(), tf_contains_transcendental(), tf_degree_in(), tf_is_linear_irreducible(), tf_is_variable_exponential(), tf_polynomial_variables(), tf_validate_polynomial(), LMCAS::integration_table_detail::u_is_var_a_indep(), LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input(), vector_calculus_constant_integrand(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit(), LMCAS::anonymous_namespace{complex_analysis.cpp}::FunctionDependencyFinder::visit_function() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_function().

函数调用图:

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

expressions()

NumberDomainSet LMCAS::expressions

(

)

在文件 expr_number_domains.cpp 第 373 行定义.

                              {
    return NumberDomainSet(NumberDomain::Expressions);
}

引用了 Expressions , 以及 expressions().

被这些函数引用 LMCAS::geometry_detail::checked_nonzero_numeric_vector(), LMCAS::anonymous_namespace{solver_groebner.cpp}::convert_polynomials(), expressions(), LMCAS::geometry_detail::numeric_vector_scale_checked() , 以及 LMCAS::anonymous_namespace{solver_groebner.cpp}::reconstruct_basis().

函数调用图:

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

extended_gcd()

int64_t LMCAS::extended_gcd ( int64_t a, int64_t b, int64_t & s, int64_t & t )

inline

用扩展欧几里得算法求 gcd(a,b) 及 Bezout 系数。

参数

a	第一个有符号机器整数
b	第二个有符号机器整数
s	输出 Bezout 系数 s，满足 a*s + b*t = gcd(a,b)
t	输出 Bezout 系数 t

返回

非负的 gcd(a, b)

异常

std::overflow_error

任一输入为 INT64_MIN，其绝对值无法由返回类型表示

输出参数仅在计算成功后写入。

余数及交替 Bezout 系数以 max(|a|,|b|) 为界，包括余数归零的最后一步。

在文件 modular_arithmetic.hpp 第 55 行定义.

                                                                          {
    const uint64_t magnitude_a = modular_detail::abs_to_u64(a);
    const uint64_t magnitude_b = modular_detail::abs_to_u64(b);
    const auto maximum =
        static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
    if (magnitude_a > maximum || magnitude_b > maximum) {
        throw std::overflow_error(
            "modular extended_gcd does not support INT64_MIN");
    }
 
    /** @brief 余数及交替 Bezout 系数以 max(|a|,|b|) 为界，包括余数归零的最后一步。 */
    int64_t old_r = static_cast<int64_t>(magnitude_a);
    int64_t r = static_cast<int64_t>(magnitude_b);
    int64_t old_s = 1;
    int64_t next_s = 0;
    int64_t old_t = 0;
    int64_t next_t = 1;
 
    while (r != 0) {
        const int64_t quotient = old_r / r;
        int64_t temporary = r;
        r = old_r - quotient * r;
        old_r = temporary;
 
        temporary = next_s;
        next_s = old_s - quotient * next_s;
        old_s = temporary;
 
        temporary = next_t;
        next_t = old_t - quotient * next_t;
        old_t = temporary;
    }
 
    const int64_t result_s = a < 0 ? -old_s : old_s;
    const int64_t result_t = b < 0 ? -old_t : old_t;
    s = result_s;
    t = result_t;
    return old_r;
}

引用了 a, LMCAS::modular_detail::abs_to_u64(), b, extended_gcd(), r , 以及 t.

被这些函数引用 LMCAS::berlekamp_detail::bk_mod_inverse(), crt_checked(), extended_gcd(), LMCAS::ModInt::inverse() , 以及 rational_reconstruction_checked().

函数调用图:

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

extended_gcd_interpolation()

MultiPoly LMCAS::extended_gcd_interpolation ( const MultiPoly & a_prim, const MultiPoly & b_prim, const std::string & main_var, const std::vector< std::string > & vars, int degree_bound, const Rational & nc_gcd )

static

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

                            {
    int ext_bound = degree_bound + 5;
    auto all_pts = gcd_evaluation_points(ext_bound + 10);
    GcdSamples samples;
    collect_gcd_samples(a_prim, b_prim, main_var, all_pts, ext_bound + 1, samples);
    if (samples.target_degree <= 0 || samples.points.empty()) {
        return MultiPoly(nc_gcd, vars);
    }
    auto cand = lagrange_interpolate(samples.points, samples.values, main_var, vars);
    if (cand.is_zero()) { return MultiPoly(nc_gcd, vars); }
    cand = cand.make_primitive();
    if (divides_poly(a_prim, cand) && divides_poly(b_prim, cand)) {
        return normalize_gcd_candidate(std::move(cand), nc_gcd);
    }
    return MultiPoly(nc_gcd, vars);
}

引用了 collect_gcd_samples(), divides_poly(), extended_gcd_interpolation(), gcd_evaluation_points(), lagrange_interpolate(), main_var, normalize_gcd_candidate(), LMCAS::GcdSamples::points, LMCAS::GcdSamples::target_degree, LMCAS::GcdSamples::values , 以及 vars.

被这些函数引用 extended_gcd_interpolation() , 以及 recursive_multivariate_gcd().

函数调用图:

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

extended_gcd_poly()

Polynomial< Rational > LMCAS::extended_gcd_poly ( const Polynomial< Rational > & a, const Polynomial< Rational > & b, Polynomial< Rational > & s, Polynomial< Rational > & t )

static

一元多项式扩展 GCD(有理数域上)

给定 a, b in Q[x],计算 gcd(a, b) 及 Bezout 系数 s, t, 使得 s*a + t*b = gcd(a, b).

参数

[in]	a	第一个多项式
[in]	b	第二个多项式
[out]	s	Bezout 系数 s
[out]	t	Bezout 系数 t

返回

gcd(a, b)

r0 = a, r1 = b s0*a + t0*b = r0 s1*a + t1*b = r1

归一化使 gcd 为首一多项式

在文件 multivariate_hensel.cpp 第 300 行定义.

{
    std::string var = a.variable_name;
 
    /// r0 = a, r1 = b
    /// s0*a + t0*b = r0
    /// s1*a + t1*b = r1
    Polynomial<Rational> r0 = a, r1 = b;
    Polynomial<Rational> s0({Rational(1)}, var), s1(var);  // s0=1, s1=0
    Polynomial<Rational> t0(var), t1({Rational(1)}, var);  // t0=0, t1=1
 
    while (!r1.is_zero()) {
        auto [q, r] = r0.div_mod(r1);
 
        Polynomial<Rational> r_new = r;
        Polynomial<Rational> s_new = s0 - q * s1;
        Polynomial<Rational> t_new = t0 - q * t1;
 
        r0 = r1; r1 = r_new;
        s0 = s1; s1 = s_new;
        t0 = t1; t1 = t_new;
    }
 
    /// 归一化使 gcd 为首一多项式
    if (!r0.is_zero()) {
        Rational lc = r0.lead_coeff();
        if (lc != Rational(1)) {
            Rational inv = Rational(1) / lc;
            for (auto& c : r0.coeffs) c = c * inv;
            for (auto& c : s0.coeffs) c = c * inv;
            for (auto& c : t0.coeffs) c = c * inv;
        }
    }
 
    s = s0;
    t = t0;
    return r0;
}

引用了 a, b, c, LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::div_mod(), extended_gcd_poly(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::lead_coeff(), r , 以及 t.

被这些函数引用 extended_gcd_poly() , 以及 solve_diophantine_pair().

函数调用图:

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

exterior_derivative_checked() [1/2]

DifferentialGeometryVectorResult LMCAS::exterior_derivative_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	form_coeffs,
		int	degree,
		const std::vector< std::string > &	vars )

在文件 differential_geometry.cpp 第 770 行定义.

{
    ComputationContext context;
    return exterior_derivative_checked(form_coeffs, degree, vars, context);
}

引用了 context, exterior_derivative_checked() , 以及 vars.

函数调用图:

exterior_derivative_checked() [2/2]

DifferentialGeometryVectorResult LMCAS::exterior_derivative_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	form_coeffs,
		int	degree,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

在文件 differential_geometry.cpp 第 709 行定义.

{
    const std::string operation = "exterior_derivative";
    auto step = context.consume_steps(1, operation);
    if (!step) return DifferentialGeometryVectorResult::failure(step.error());
    const auto input_count =
        validate_form_coefficients(form_coeffs, degree, vars, context, operation);
    if (!input_count) return DifferentialGeometryVectorResult::failure(input_count.error());
    const auto output_count = bounded_binomial(vars.size(),
                                               static_cast<std::size_t>(degree) + 1,
                                               context.limits().max_expansion_terms,
                                               operation);
    if (!output_count) return DifferentialGeometryVectorResult::failure(output_count.error());
    try {
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                     context.limits().max_ast_nodes, operation.c_str());
        std::size_t input_nodes = 0;
        for (const auto& coefficient : form_coeffs) {
            input_nodes = budget.append_size(
                input_nodes, budget.measure(detail::node(coefficient)));
        }
        const auto input_indices = index_combinations(vars.size(),
                                                      static_cast<std::size_t>(degree),
                                                      input_count.value());
        const auto output_indices = index_combinations(vars.size(),
                                                       static_cast<std::size_t>(degree) + 1,
                                                       output_count.value());
        std::map<std::vector<std::size_t>, std::size_t> coefficient_index;
        for (std::size_t i = 0; i < input_indices.size(); ++i) {
            coefficient_index.emplace(input_indices[i], i);
        }
 
        std::vector<std::shared_ptr<SymbolicExpr>> result;
        result.reserve(output_count.value());
        std::size_t output_nodes = 0;
        for (const auto& output_index : output_indices) {
            auto component = exterior_derivative_component(
                form_coeffs, vars, coefficient_index, output_index, budget, operation);
            if (!component) return DifferentialGeometryVectorResult::failure(component.error());
            output_nodes = budget.append_size(
                output_nodes, budget.measure(detail::node(component.value())));
            result.push_back(std::move(component.value()));
        }
        return DifferentialGeometryVectorResult::success(std::move(result));
    } catch (const CasError& error) {
        return DifferentialGeometryVectorResult::failure(error);
    } catch (const std::bad_alloc&) {
        return DifferentialGeometryVectorResult::failure(CasErrc::ResourceLimit,
                                                         "allocation failed while calculating exterior derivative",
                                                         operation);
    } catch (const std::exception& ex) {
        return DifferentialGeometryVectorResult::failure(CasErrc::InternalInvariant,
                                                         ex.what(),
                                                         operation);
    }
}

引用了 LMCAS::detail::RewriteBudget::append_size(), context, exterior_derivative_checked(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), InternalInvariant, LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), ResourceLimit, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success(), LMCAS::Result< T >::value() , 以及 vars.

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

函数调用图:

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

extract_bernoulli_factor()

bool LMCAS::extract_bernoulli_factor ( const std::shared_ptr< const SymbolicNode > & factor, const std::string & y, int & exponent, std::shared_ptr< SymbolicExpr > & coefficient, ComputationContext & context )

static

在文件 ode_classification.cpp 第 218 行定义.

                                                                                          {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
        if (auto variable =
                std::dynamic_pointer_cast<const VariableNode>(factor);
            variable && !variable->is_constant() && variable->name() == y) {
            if (exponent == std::numeric_limits<int>::max()) {
                return false;
            }
            ++exponent;
            return true;
        }
 
        if (auto power = std::dynamic_pointer_cast<const PowerNode>(factor)) {
            auto base =
                std::dynamic_pointer_cast<const VariableNode>(power->base());
            auto power_value =
                std::dynamic_pointer_cast<const NumberNode>(power->exponent());
            if (base && !base->is_constant() && base->name() == y && power_value) {
                auto value = bernoulli_integer_exponent(*power_value);
                if (!value) {
                    return false;
                }
                return accumulate_bernoulli_exponent(*value, exponent);
            }
        }
        if (expression_depends_on_variable(factor, y)) {
            return false;
        }
        coefficient = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            coefficient, LMCAS::detail::make_expression_ptr(factor))), transform_budget));
    return true;
}

引用了 accumulate_bernoulli_exponent(), bernoulli_integer_exponent(), context, exponent, expression_depends_on_variable(), extract_bernoulli_factor(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), value , 以及 variable.

被这些函数引用 extract_bernoulli_factor() , 以及 extract_bernoulli_monomial().

函数调用图:

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

extract_bernoulli_monomial()

bool LMCAS::extract_bernoulli_monomial ( const std::shared_ptr< const SymbolicNode > & term, const std::string & y, int & exponent, std::shared_ptr< SymbolicExpr > & coefficient, ComputationContext & context )

static

在文件 ode_classification.cpp 第 255 行定义.

{
    exponent = 0;
    coefficient = SymbolicExpr::number(1);
    std::vector<std::shared_ptr<const SymbolicNode>> factors;
    if (auto product = std::dynamic_pointer_cast<const MultiplyNode>(term)) {
        factors = product->operands();
    } else {
        factors.push_back(term);
    }
 
    for (const auto& factor : factors) {
        if (!extract_bernoulli_factor(factor, y, exponent, coefficient, context)) {
            return false;
        }
    }
    return true;
}

引用了 context, exponent, extract_bernoulli_factor() , 以及 extract_bernoulli_monomial().

被这些函数引用 collect_bernoulli_coefficients() , 以及 extract_bernoulli_monomial().

函数调用图:

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

extract_coeff_value()

template<typename T>

Result< T > LMCAS::extract_coeff_value

(

const std::shared_ptr< SymbolicExpr > &

coefficient

)

精确提取系数；不支持的值返回错误，保持数值完整。

引用了 extract_coeff_value() , 以及 LMCAS_API.

被这些函数引用 LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_power(), LMCAS::anonymous_namespace{poly_utils.cpp}::constant_to_poly(), extract_coeff_value(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_square_absolute(), tf_build_polynomial_impl() , 以及 LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::visit().

函数调用图:

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

extract_coeff_value< BigInt >()

template<>

Result< BigInt > LMCAS::extract_coeff_value< BigInt >

(

const std::shared_ptr< SymbolicExpr > &

coefficient

)

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

                                                        {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!coefficient || !detail::node(coefficient)) {
        return Result<BigInt>::failure(CasErrc::InvalidArgument,
            "Coefficient must have an expression", "polynomial.coefficient");
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(coefficient), transform_budget));
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(
            LMCAS::detail::node(simplified))) {
        if (std::holds_alternative<BigInt>(number->value())) {
            return std::get<BigInt>(number->value());
        }
        if (std::holds_alternative<Rational>(number->value())) {
            const Rational& value = std::get<Rational>(number->value());
            if (value.is_integer()) return value.to_bigint();
        }
    }
    return Result<BigInt>::failure(CasErrc::UnsupportedExpression,
        "Coefficient is not an integer", "polynomial.coefficient");
}
catch (const CasError& error) {
    return Result<BigInt>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<BigInt>::failure(CasErrc::ResourceLimit, "allocation failed", "extract_coeff_value");
} catch (const std::length_error& error) {
    return Result<BigInt>::failure(CasErrc::ResourceLimit, error.what(), "extract_coeff_value");
} catch (const std::exception& error) {
    return Result<BigInt>::failure(CasErrc::InternalInvariant, error.what(), "extract_coeff_value");
}

引用了 context, LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::SymbolicPolyCoeff::val.

函数调用图:

extract_coeff_value< Rational >()

template<>

Result< Rational > LMCAS::extract_coeff_value< Rational >

(

const std::shared_ptr< SymbolicExpr > &

coefficient

)

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

                                                        {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!coefficient || !detail::node(coefficient)) {
        return Result<Rational>::failure(CasErrc::InvalidArgument,
            "Coefficient must have an expression", "polynomial.coefficient");
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(coefficient), transform_budget));
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(
            LMCAS::detail::node(simplified))) {
        if (std::holds_alternative<Rational>(number->value())) {
            return std::get<Rational>(number->value());
        }
        if (std::holds_alternative<BigInt>(number->value())) {
            return Rational(std::get<BigInt>(number->value()));
        }
    }
    if (simplified->is_one()) return Rational(1);
    return Result<Rational>::failure(CasErrc::UnsupportedExpression,
        "Coefficient is not representable as a rational", "polynomial.coefficient");
}
catch (const CasError& error) {
    return Result<Rational>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<Rational>::failure(CasErrc::ResourceLimit, "allocation failed", "extract_coeff_value");
} catch (const std::length_error& error) {
    return Result<Rational>::failure(CasErrc::ResourceLimit, error.what(), "extract_coeff_value");
} catch (const std::exception& error) {
    return Result<Rational>::failure(CasErrc::InternalInvariant, error.what(), "extract_coeff_value");
}

引用了 LMCAS::Result< T >::failure().

函数调用图:

extract_coeff_value< SymbolicPolyCoeff >()

template<>

Result< SymbolicPolyCoeff > LMCAS::extract_coeff_value< SymbolicPolyCoeff >

(

const std::shared_ptr< SymbolicExpr > &

coefficient

)

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

                                                    {
    if (!coefficient || !detail::node(coefficient)) {
        return Result<SymbolicPolyCoeff>::failure(CasErrc::InvalidArgument,
            "Coefficient must have an expression", "polynomial.coefficient");
    }
    return SymbolicPolyCoeff(coefficient);
}

extract_coefficient()

std::shared_ptr< SymbolicExpr > LMCAS::extract_coefficient ( const std::shared_ptr< SymbolicExpr > & expr, const std::string & var, ComputationContext & context )

static

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

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    return detail::make_expression_ptr(detail::differentiate_node(detail::node(expr), var, transform_budget));
}

引用了 context, LMCAS::detail::differentiate_node(), extract_coefficient(), LMCAS::detail::make_expression_ptr() , 以及 LMCAS::detail::node().

被这些函数引用 extract_coefficient().

函数调用图:

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

extract_coefficients()

std::map< int, MultiPoly > LMCAS::extract_coefficients ( const MultiPoly & poly, const std::string & main_var )

static

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

{
    const auto& vars = poly.variables();
    int var_idx = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == main_var) { var_idx = static_cast<int>(i); break; }
    }
    std::vector<std::string> remaining_vars;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (static_cast<int>(i) != var_idx) { remaining_vars.push_back(vars[i]); }
    }
    std::map<int, MultiPoly> coeffs;
    if (var_idx < 0) { coeffs[0] = poly; return coeffs; }
    for (const auto& term : poly.terms()) {
        const Monomial& mono = term.first;
        int exp = (static_cast<size_t>(var_idx) < mono.size()) ? mono[var_idx] : 0;
        Monomial reduced_mono;
        reduced_mono.reserve(vars.size() - 1);
        for (size_t i = 0; i < mono.size(); ++i) {
            if (static_cast<int>(i) != var_idx) { reduced_mono.push_back(mono[i]); }
        }
        std::vector<MultiPoly::Term> t_vec = {{reduced_mono, term.second}};
        MultiPoly term_poly(std::move(t_vec), remaining_vars);
        if (coeffs.find(exp) == coeffs.end()) {
            coeffs[exp] = term_poly;
        } else {
            coeffs[exp] = coeffs[exp] + term_poly;
        }
    }
    return coeffs;
}

引用了 exp(), extract_coefficients(), main_var , 以及 vars.

被这些函数引用 extract_coefficients() , 以及 multivariate_content().

函数调用图:

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

extract_constant_term()

std::shared_ptr< SymbolicExpr > LMCAS::extract_constant_term ( const std::shared_ptr< SymbolicExpr > & expr, const std::vector< std::string > & unknowns, ComputationContext & context )

static

在文件 parametric_solver.cpp 第 23 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
 
    auto constant = expr;
    for (const auto& var : unknowns) {
        constant = detail::make_expression_ptr(detail::substitute_node(detail::node(constant), var, detail::node(SymbolicExpr::number(0)), transform_budget));
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(constant), transform_budget));
}

引用了 context, extract_constant_term(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::detail::substitute_node().

被这些函数引用 extract_constant_term().

函数调用图:

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

extract_laurent_regular_part()

Result< int > LMCAS::extract_laurent_regular_part ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::shared_ptr< SymbolicExpr > & center, const std::shared_ptr< SymbolicExpr > & shift, std::shared_ptr< SymbolicExpr > & regular, ComputationContext & context )

static

在文件 series_expansions.cpp 第 513 行定义.

                                                                           {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "laurent_series_full";
    auto center_number = std::dynamic_pointer_cast<const NumberNode>(detail::node(center));
    if (!center_number) {
        return Result<int>::failure(CasErrc::Inconclusive,
                                    "Laurent center must be an exact number", operation);
    }
    Rational point = std::holds_alternative<BigInt>(center_number->value())
        ? Rational(std::get<BigInt>(center_number->value()))
        : std::get<Rational>(center_number->value());
    Polynomial<Rational> numerator(var), denominator(var);
    auto recognized = detail::extract_rational(*f, var, numerator, denominator);
    if (!recognized) {
        return Result<int>::failure(recognized.error());
    }
    if (!recognized.value()) {
        return recognize_regular_laurent(f, var, context);
    }
    if (numerator.is_zero()) {
        return 0;
    }
    const Polynomial<Rational> factor({Rational(0) - point, Rational(1)}, var);
    int pole_order = 0;
    while (denominator.eval(point) == Rational(0)) {
        auto step = context.consume_steps(1, operation);
        if (!step) {
            return Result<int>::failure(step.error());
        }
        if (pole_order >= 64) {
            return Result<int>::failure(CasErrc::Inconclusive,
                                        "Laurent pole order exceeds supported range", operation);
        }
        denominator = denominator.div_mod(factor).first;
        ++pole_order;
    }
    if (pole_order > 0) {
        regular = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            SymbolicExpr::power(shift, SymbolicExpr::number(pole_order)), f)->cancel()), transform_budget));
    }
    return pole_order;
} catch (const CasError& error) {
    return Result<int>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<int>::failure(CasErrc::ResourceLimit, "allocation failed", "laurent_series_full");
} catch (const std::length_error& error) {
    return Result<int>::failure(CasErrc::ResourceLimit, error.what(), "laurent_series_full");
} catch (const std::exception& error) {
    return Result<int>::failure(CasErrc::InternalInvariant, error.what(), "laurent_series_full");
}

引用了 context, denominator, extract_laurent_regular_part(), LMCAS::detail::extract_rational(), LMCAS::Result< T >::failure(), Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), point , 以及 recognize_regular_laurent().

被这些函数引用 extract_laurent_regular_part() , 以及 laurent_series_full_impl().

函数调用图:

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

factor_common_polynomial()

std::optional< ExpressionResult > LMCAS::factor_common_polynomial ( const std::shared_ptr< const AddNode > & add_node, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 194 行定义.

                                                                               {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::shared_ptr<SymbolicExpr> common = nullptr;
    for (const auto& op : add_node->operands()) {
         auto expr_op = LMCAS::detail::make_expression_ptr(op);
         if (!common) {
             common = expr_op;
         } else {
             auto gcd = LMCAS::symbolic_polynomial_gcd(*common, *expr_op, context);
             if (!gcd) {
                 if (gcd.error().code == CasErrc::UnsupportedExpression) {
                     return std::nullopt;
                 }
                 return gcd;
             }
             common = std::move(gcd.value());
         }
    }
 
    if (common && !common->is_one() && !common->is_zero()) {
         std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
         for (const auto& op : add_node->operands()) {
              auto term = LMCAS::detail::make_expression_ptr(op);
 
              auto inv_common = SymbolicExpr::power(common, SymbolicExpr::number(-1));
              auto quot = SymbolicExpr::multiply(term, inv_common);
              quot = detail::make_expression_ptr(detail::normalize_node(detail::node(quot), transform_budget));
              new_ops.push_back(LMCAS::detail::node(quot));
         }
         auto new_sum = LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<AddNode>(new_ops));
 
         auto factored_sum = new_sum->factor_checked(context);
         if (!factored_sum) { return factored_sum; }
 
         std::vector<std::shared_ptr<const SymbolicNode>> final_ops = {
             LMCAS::detail::node(common),
             LMCAS::detail::node(factored_sum.value())};
         return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<MultiplyNode>(final_ops));
    }
    return std::nullopt;
}

引用了 context, factor_common_polynomial(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), op, symbolic_polynomial_gcd() , 以及 UnsupportedExpression.

被这些函数引用 factor_common_polynomial().

函数调用图:

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

factor_integer_polynomial()

Polynomial< BigInt > LMCAS::factor_integer_polynomial

(

const Polynomial< Rational > &

polynomial

)

在文件 univariate_factor_bridge.cpp 第 9 行定义.

                                                                               {
    BigInt denominator_lcm(1);
    for (const auto& coefficient : poly.coeffs) {
        denominator_lcm = BigInt::lcm(
            denominator_lcm, coefficient.get_denominator());
    }
    std::vector<BigInt> coefficients;
    coefficients.reserve(poly.coeffs.size());
    for (const auto& coefficient : poly.coeffs) {
        coefficients.push_back(coefficient.get_numerator() *
            (denominator_lcm / coefficient.get_denominator()));
    }
    return Polynomial<BigInt>(coefficients, poly.variable_name);
}

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

被这些函数引用 LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_and_combine() , 以及 factor_integer_polynomial().

函数调用图:

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

factor_multivariate_checked() [1/2]

MultiFactorCheckedResult LMCAS::factor_multivariate_checked

(

const MultiPoly &

poly

)

在文件 multivariate_factor_checked.cpp 第 332 行定义.

{
    ComputationContext context;
    return factor_multivariate_checked(poly, context);
}

引用了 context , 以及 factor_multivariate_checked().

函数调用图:

factor_multivariate_checked() [2/2]

MultiFactorCheckedResult LMCAS::factor_multivariate_checked	(	const MultiPoly &	poly,
		ComputationContext &	context )

在文件 multivariate_factor_checked.cpp 第 309 行定义.

{
    try {
        auto factored = factor_multivariate_impl(poly, context);
        if (factored && factored.value().completeness == Completeness::Inconclusive) {
            return multivariate_checked_detail::assemble_checked_factorization(
                poly, {poly}, {1}, Completeness::Inconclusive,
                std::move(factored.value().reason));
        }
        return factored;
    } catch (const std::bad_alloc&) {
        return MultiFactorCheckedResult::failure(
            CasErrc::ResourceLimit, "多元分解分配失败",
            "factor_multivariate");
    } catch (const std::exception& error) {
        return MultiFactorCheckedResult::failure(
            CasErrc::InternalInvariant, error.what(),
            "factor_multivariate");
    }
}

引用了 LMCAS::multivariate_checked_detail::assemble_checked_factorization(), context, factor_multivariate_checked(), LMCAS::Result< MathResult< MultiFactorResult > >::failure(), Inconclusive, InternalInvariant , 以及 ResourceLimit.

被这些函数引用 factor_multivariate_checked(), factor_multivariate_checked() , 以及 factor_multivariate_expression().

函数调用图:

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

factor_multivariate_expression()

std::optional< ExpressionResult > LMCAS::factor_multivariate_expression ( const std::shared_ptr< SymbolicExpr > & simp, const std::set< std::string > & factor_variables, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 415 行定义.

                                                                            {
    if (!is_poly_expr_node(detail::node(simp))) { return std::nullopt; }
    try {
        std::vector<std::string> var_list(
            factor_variables.begin(), factor_variables.end());
        auto mpoly = symbolic_node_to_multipoly(LMCAS::detail::node(simp), var_list);
 
        if (!mpoly.is_zero() && !mpoly.is_constant()) {
            auto factorization =
                LMCAS::factor_multivariate_checked(
                    mpoly, context);
            if (!factorization) {
                return LMCAS::ExpressionResult::failure(
                    factorization.error());
            }
            const auto& checked = factorization.value();
            if (checked.completeness !=
                LMCAS::Completeness::Complete) {
                return simp;
            }
            const auto& result = checked.value;
 
            if (!result.factors.empty()) {
                auto expression = multivariate_factor_expression(result, context);
                if (expression) { return expression; }
            }
        }
    } catch (const std::invalid_argument&) {
        return std::nullopt;
    } catch (const std::out_of_range&) {
        return std::nullopt;
    }
    return std::nullopt;
}

引用了 Complete, context, factor_multivariate_checked(), factor_multivariate_expression(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), multivariate_factor_expression(), LMCAS::detail::node() , 以及 symbolic_node_to_multipoly().

被这些函数引用 factor_multivariate_expression().

函数调用图:

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

factor_numeric_content()

std::optional< ExpressionResult > LMCAS::factor_numeric_content ( const std::shared_ptr< SymbolicExpr > & simp, const std::shared_ptr< const AddNode > & add_node, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 153 行定义.

                                                                               {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto content_result =
        LMCAS::symbolic_polynomial_content(*simp, context);
    if (!content_result) {
        if (content_result.error().code == CasErrc::UnsupportedExpression) {
            return std::nullopt;
        }
        return LMCAS::ExpressionResult::failure(
            content_result.error());
    }
    const Rational content_value = content_result.value();
    if (content_value != Rational(0) && content_value != Rational(1)) {
        auto content = content_value.is_integer()
            ? SymbolicExpr::number(content_value.to_bigint())
            : SymbolicExpr::number(content_value);
        const Rational inverse_value = Rational(1) / content_value;
        auto inverse_content = inverse_value.is_integer()
            ? SymbolicExpr::number(inverse_value.to_bigint())
            : SymbolicExpr::number(inverse_value);
        std::vector<std::shared_ptr<const SymbolicNode>> primitive_terms;
        primitive_terms.reserve(add_node->operands().size());
        for (const auto& operand : add_node->operands()) {
            auto term = LMCAS::detail::make_expression_ptr(operand);
            auto primitive_term = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(term, inverse_content)), transform_budget));
            primitive_terms.push_back(LMCAS::detail::node(primitive_term));
        }
        auto primitive_sum = LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<AddNode>(primitive_terms));
        auto factored_primitive =
            primitive_sum->factor_checked(context);
        if (!factored_primitive) { return factored_primitive; }
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            content, factored_primitive.value())), transform_budget));
    }
    return std::nullopt;
}

引用了 context, factor_numeric_content(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), symbolic_polynomial_content() , 以及 UnsupportedExpression.

被这些函数引用 factor_numeric_content().

函数调用图:

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

factor_rational_univariate()

std::optional< ExpressionResult > LMCAS::factor_rational_univariate ( const std::shared_ptr< SymbolicExpr > & simp, const std::string & var, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 293 行定义.

                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    try {
        auto converted = symbolic_to_poly<Rational>(simp, var);
        if (!converted) {
            if (converted.error().code == CasErrc::UnsupportedExpression) return std::nullopt;
            return ExpressionResult::failure(converted.error());
        }
        const auto& poly = converted.value();
        if (poly.degree() < 2) { return std::nullopt; }
        auto roots = find_rational_roots(poly);
        if (roots.empty()) { return std::nullopt; }
        auto reconstruction =
            reconstruct_rational_roots(poly, roots, var, context);
        if (!reconstruction.remainder.is_zero()) return std::nullopt;
        auto& factors = reconstruction.factors;
        auto& quotient = reconstruction.quotient;
        if (quotient.degree() >= 1) {
            auto q_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(poly_to_symbolic(quotient)), transform_budget));
            if (quotient.degree() >= 2) {
                auto q_factored = q_expr->factor_checked(context);
                if (!q_factored) { return q_factored; }
                factors.push_back(detail::node(q_factored.value()));
            } else {
                factors.push_back(detail::node(q_expr));
            }
        }
        if (factors.size() > 1) {
            return detail::make_expression_ptr(detail::make_node<MultiplyNode>(factors));
        }
        if (factors.size() == 1) { return detail::make_expression_ptr(factors[0]); }
    } catch (const std::invalid_argument&) {
        return std::nullopt;
    } catch (const std::out_of_range&) {
        return std::nullopt;
    }
    return std::nullopt;
}

引用了 context, factor_rational_univariate(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), find_rational_roots(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), reconstruct_rational_roots(), roots() , 以及 UnsupportedExpression.

被这些函数引用 factor_rational_univariate().

函数调用图:

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

factor_symbolic_quadratic()

std::optional< ExpressionResult > LMCAS::factor_symbolic_quadratic ( const std::shared_ptr< SymbolicExpr > & simp, const std::string & var, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 335 行定义.

                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    try {
        auto converted = LMCAS::symbolic_to_poly<LMCAS::SymbolicPolyCoeff>(simp, var);
        if (!converted) {
            if (converted.error().code == CasErrc::UnsupportedExpression) return std::nullopt;
            return ExpressionResult::failure(converted.error());
        }
        const auto& poly = converted.value();
        if (poly.degree() == 2) {
              auto solved =
                 LMCAS::solve_finite_checked(simp, var, context);
             if (!solved) {
                 return LMCAS::ExpressionResult::failure(
                     solved.error());
             }
             auto solutions = std::move(solved.value());
             if (solutions.size() == 2) {
                  auto leading = poly.coeffs[2].val;
                  if (!leading) { leading = SymbolicExpr::number(1); }
                  leading = detail::make_expression_ptr(detail::normalize_node(detail::node(leading), transform_budget));
 
                  auto x_node = LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<VariableNode>(var));
 
                  auto t1 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(x_node, SymbolicExpr::multiply(solutions[0], SymbolicExpr::number(-1)))), transform_budget));
                  auto t2 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(x_node, SymbolicExpr::multiply(solutions[1], SymbolicExpr::number(-1)))), transform_budget));
 
                  std::vector<std::shared_ptr<const SymbolicNode>> factors;
                  if (!leading->is_one()) { factors.push_back(LMCAS::detail::node(leading)); }
                  factors.push_back(LMCAS::detail::node(t1));
                  factors.push_back(LMCAS::detail::node(t2));
 
                  return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<MultiplyNode>(factors));
             }
        }
    } catch (const std::invalid_argument&) {
        return std::nullopt;
    } catch (const std::out_of_range&) {
        return std::nullopt;
    }
    return std::nullopt;
}

引用了 context, factor_symbolic_quadratic(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_finite_checked() , 以及 UnsupportedExpression.

被这些函数引用 factor_symbolic_quadratic().

函数调用图:

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

factor_transcendental() [1/2]

Result< std::vector< std::shared_ptr< SymbolicExpr > > > LMCAS::factor_transcendental	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var )

在文件 transcendental_factor.cpp 第 136 行定义.

                          {
    ComputationContext context;
    return factor_transcendental(expr, var, context);
}

引用了 context , 以及 factor_transcendental().

函数调用图:

factor_transcendental() [2/2]

Result< std::vector< std::shared_ptr< SymbolicExpr > > > LMCAS::factor_transcendental	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context )

在文件 transcendental_factor.cpp 第 88 行定义.

                                     {
 
    using FactorsResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>;
    if (!expr || !LMCAS::detail::node(expr) || var.empty()) {
        return FactorsResult::failure(CasErrc::InvalidArgument,
            "expression and variable must be nonempty", "factor_transcendental");
    }
    auto step = context.consume_steps(1, "factor_transcendental");
    if (!step) {
        return FactorsResult::failure(step.error());
    }
    auto pyth_simplified = tf_simplify_pythagorean(expr, var);
    auto mult_factors = tf_detect_multiplicative_structure(pyth_simplified);
    if (!mult_factors.empty()) {
        return mult_factors;
    }
    auto exp_factors = tf_detect_exponential_separation(pyth_simplified, var, context);
    if (!exp_factors.empty()) {
        return exp_factors;
    }
 
    if (!tf_contains_transcendental(LMCAS::detail::node(pyth_simplified), var)) {
        return FactorsResult::success({pyth_simplified});
    }
 
    TransSubstitutionResult sub_result = detect_trans_substitutions(pyth_simplified, var);
    if (sub_result.mappings.empty()) {
        return FactorsResult::success({pyth_simplified});
    }
    if (tf_is_linear_irreducible(sub_result, var)) {
        return FactorsResult::success({pyth_simplified});
    }
 
    return tf_factor_substitution(
        sub_result, var, pyth_simplified, context);
}
catch (const std::bad_alloc&) {
    return Result<std::vector<std::shared_ptr<SymbolicExpr>>>::failure(
        CasErrc::ResourceLimit, "allocation failed while factoring expression",
        "factor_transcendental");
} catch (const std::exception& ex) {
    return Result<std::vector<std::shared_ptr<SymbolicExpr>>>::failure(
        CasErrc::InternalInvariant, ex.what(), "factor_transcendental");
}

引用了 context, detect_trans_substitutions(), factor_transcendental(), InvalidArgument, LMCAS::TransSubstitutionResult::mappings, LMCAS::detail::node(), tf_contains_transcendental(), tf_detect_exponential_separation(), tf_detect_multiplicative_structure(), tf_factor_substitution(), tf_is_linear_irreducible() , 以及 tf_simplify_pythagorean().

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

函数调用图:

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

factor_transcendental_expression()

ExpressionResult LMCAS::factor_transcendental_expression ( const std::shared_ptr< SymbolicExpr > & simp, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 507 行定义.

                                 {
    const auto transform_variables = LMCAS::free_variables(LMCAS::detail::node(simp));
    if (transform_variables.empty()) { return simp; }
 
    auto converted = LMCAS::factor_transcendental(
        simp, *transform_variables.begin(), context);
    if (!converted) { return ExpressionResult::failure(converted.error()); }
    const auto& trans_factors = converted.value();
    if (trans_factors.size() > 1) {
        std::vector<std::shared_ptr<const SymbolicNode>> factor_nodes;
        factor_nodes.reserve(trans_factors.size());
        for (const auto& factor : trans_factors) {
            if (factor && LMCAS::detail::node(factor)) {
                factor_nodes.push_back(LMCAS::detail::node(factor));
            }
        }
        if (factor_nodes.size() > 1) {
            return LMCAS::detail::make_expression_ptr(
                LMCAS::detail::make_node<MultiplyNode>(std::move(factor_nodes)));
        }
    }
    return simp;
}

引用了 context, factor_transcendental(), factor_transcendental_expression(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), free_variables(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node() , 以及 LMCAS::detail::node().

被这些函数引用 factor_transcendental_expression().

函数调用图:

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

factor_univariate_bridge_checked()

UnivariateFactorResult LMCAS::factor_univariate_bridge_checked	(	const Polynomial< Rational > &	polynomial,
		ComputationContext &	context )

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

                                                                   {
    auto step = context.consume_steps(1, bridge_operation);
    if (!step) return UnivariateFactorResult::failure(step.error());
    if (poly.is_zero() || poly.degree() <= 0) {
        return UnivariateFactorResult::success(
            MathResult<std::vector<Polynomial<Rational>>>{
                poly.is_zero() ? std::vector<Polynomial<Rational>>{}
                               : std::vector<Polynomial<Rational>>{poly},
                Completeness::Complete, {}});
    }
    if (poly.degree() == 1) {
        return UnivariateFactorResult::success(
            MathResult<std::vector<Polynomial<Rational>>>{
                {poly.make_monic()}, Completeness::Complete, {}});
    }
    try {
        return bridge_factor(poly, context);
    } catch (const std::bad_alloc&) {
        return UnivariateFactorResult::failure(
            CasErrc::ResourceLimit, "一元分解分配失败", bridge_operation);
    } catch (const std::exception& error) {
        return UnivariateFactorResult::failure(
            CasErrc::InternalInvariant, error.what(), bridge_operation);
    }
}

引用了 Complete, context, LMCAS::Polynomial< CoeffType >::degree(), factor_univariate_bridge_checked(), LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::failure(), InternalInvariant, LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::make_monic(), ResourceLimit , 以及 LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::success().

被这些函数引用 LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_append_repeated(), LMCAS::multivariate_checked_detail::collect_linear_samples(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_embedded_univariate(), LMCAS::multivariate_checked_detail::factor_evaluated_linear(), LMCAS::detail::factor_homogeneous_bivariate(), factor_univariate_bridge_checked(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::strict_factors() , 以及 tf_factor_substitution().

函数调用图:

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

factor_variable_rational_roots()

std::optional< ExpressionResult > LMCAS::factor_variable_rational_roots ( const std::shared_ptr< SymbolicExpr > & simp, const std::string & var, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 479 行定义.

                                                                                                {
    try {
        auto poly = LMCAS::symbolic_to_poly<LMCAS::SymbolicPolyCoeff>(simp, var);
        if (!poly) {
            if (poly.error().code == CasErrc::UnsupportedExpression) { return std::nullopt; }
            return ExpressionResult::failure(poly.error());
        }
        if (poly.value().degree() >= 2) {
            auto converted = LMCAS::symbolic_to_poly<Rational>(simp, var);
            if (!converted) {
                if (converted.error().code == CasErrc::UnsupportedExpression) { return std::nullopt; }
                return ExpressionResult::failure(converted.error());
            }
            const auto& poly_r = converted.value();
            auto roots = LMCAS::find_rational_roots(poly_r);
            if (!roots.empty()) {
                return reconstruct_rational_root_factors(poly_r, roots, var, context);
            }
        }
    } catch (const std::invalid_argument&) {
        return std::nullopt;
    } catch (const std::out_of_range&) {
        return std::nullopt;
    }
    return std::nullopt;
}

引用了 context, factor_variable_rational_roots(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), find_rational_roots(), reconstruct_rational_root_factors(), roots() , 以及 UnsupportedExpression.

被这些函数引用 factor_variable_rational_roots().

函数调用图:

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

fglm_convert()

std::vector< FGLMPoly > LMCAS::fglm_convert	(	const std::vector< FGLMPoly > &	source_basis,
		const MonomialOrder &	source_order,
		const MonomialOrder &	target_order,
		size_t	num_vars )

在文件 fglm.cpp 第 88 行定义.

                                                   {
    int dimension = checked_dimension(source_basis, num_vars);
    std::vector<FGLMPoly> target_basis;
    std::vector<Monomial> basis_monomials;
    auto standard = standard_basis(source_basis, num_vars, dimension);
    std::map<Monomial, size_t> monomial_index;
    for (size_t index = 0; index < standard.size(); ++index) {
        monomial_index[standard[index]] = index;
    }
    fglm_detail::GaussianEliminator gauss;
    fglm_detail::MonomialEnumerator enumerator(num_vars, target_order, dimension + 5);
    std::vector<Monomial> target_leading;
    const int max_iterations = dimension * 10 + 50;
    int iterations = 0;
    Monomial monomial;
    while (iterations < max_iterations && enumerator.next(monomial)) {
        ++iterations;
        if (!fglm_detail::is_standard(monomial, target_leading)) continue;
        auto polynomial = FGLMPoly::from_monomial(monomial, num_vars);
        auto normal = normal_form(polynomial, source_basis, source_order);
        auto vector = coordinates(normal, monomial_index);
        std::vector<Rational> combination;
        if (gauss.add_vector(vector, combination)) {
            basis_monomials.push_back(monomial);
        } else {
            auto dependent = dependent_polynomial(monomial, combination,
                                                   basis_monomials, target_order,
                                                   num_vars);
            if (!dependent.is_zero()) {
                target_leading.push_back(dependent.lead_monomial());
                target_basis.push_back(std::move(dependent));
            }
        }
        if (static_cast<int>(basis_monomials.size()) == dimension &&
            fglm_detail::has_pure_generators(target_leading, num_vars)) {
            return target_basis;
        }
    }
    throw std::runtime_error(
        "FGLM: enumeration ended before the target basis was complete");
}

引用了 LMCAS::fglm_detail::GaussianEliminator::add_vector(), fglm_convert(), LMCAS::fglm_detail::has_pure_generators(), LMCAS::fglm_detail::is_standard(), LMCAS::fglm_detail::MonomialEnumerator::next() , 以及 normal_form().

被这些函数引用 fglm_convert() , 以及 grevlex_to_lex().

函数调用图:

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

find_complementary_square()

std::size_t LMCAS::find_complementary_square ( const std::vector< std::shared_ptr< const SymbolicNode > > & operands, const std::vector< bool > & consumed, std::size_t start, const TrigSquare & square )

static

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

                                                                                {
    for (std::size_t i = start; i < operands.size(); ++i) {
        if (!consumed[i] && complementary_square(operands[i], square)) {
            return i;
        }
    }
    return operands.size();
}

引用了 complementary_square() , 以及 find_complementary_square().

被这些函数引用 find_complementary_square() , 以及 simplify_pythagorean_sum().

函数调用图:

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

find_extrema()

std::vector< CriticalPoint > LMCAS::find_extrema	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_extrema.cpp 第 373 行定义.

                                                                            {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "find_extrema");
    return find_extrema_impl(f, vars, context, transform_budget);
}

引用了 context, find_extrema(), find_extrema_impl() , 以及 vars.

被这些函数引用 find_extrema().

函数调用图:

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

find_extrema_checked() [1/2]

ExtremaResult LMCAS::find_extrema_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_extrema.cpp 第 274 行定义.

{
    ComputationContext context;
    return find_extrema_checked(f, vars, context);
}

引用了 context, find_extrema_checked() , 以及 vars.

函数调用图:

find_extrema_checked() [2/2]

ExtremaResult LMCAS::find_extrema_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "find_extrema");
    const std::string operation = "find_extrema";
    auto valid = vector_calculus_validate_expr_vars(f, vars, context, operation);
    if (!valid) {
        return ExtremaResult::failure(valid.error());
    }
    auto distinct = vector_calculus_validate_distinct_vars(vars, vars.size(), context, operation);
    if (!distinct) {
        return ExtremaResult::failure(distinct.error());
    }
    auto step = context.consume_steps(vars.size() * vars.size() + vars.size() * 8 + 8,
                                      operation);
    if (!step) {
        return ExtremaResult::failure(step.error());
    }
 
    try {
        std::vector<std::shared_ptr<SymbolicExpr>> gradient;
        gradient.reserve(vars.size());
        for (const auto& var : vars) {
            auto partial = vector_calculus_differentiate_strict(f, var, operation, transform_budget);
            if (!partial) {
                return ExtremaResult::failure(partial.error());
            }
            gradient.push_back(std::move(partial.value()));
        }
 
        auto extrema = find_extrema_impl(f, vars, context, transform_budget);
        if (extrema.empty()) {
            return ExtremaResult::failure(
                CasErrc::Inconclusive,
                "extrema solver produced no verifiable critical points in the supported domain",
                operation);
        }
 
        for (const auto& cp : extrema) {
            if (!vector_calculus_point_has_vars(cp.point, vars)) {
                return ExtremaResult::failure(
                    CasErrc::Inconclusive,
                    "extrema candidate omits one or more variables",
                    operation);
            }
            for (const auto& partial : gradient) {
                if (!vector_calculus_expr_zero_after_substitution(partial, cp.point, context, transform_budget)) {
                    return ExtremaResult::failure(
                        CasErrc::Inconclusive,
                        "extrema candidate does not verify against the gradient",
                        operation);
                }
            }
            if (cp.classification == CriticalPointClassification::Inconclusive) {
                return ExtremaResult::failure(
                    CasErrc::Inconclusive,
                    "extrema candidate has no verified classification",
                    operation);
            }
        }
        return ExtremaResult::success(std::move(extrema));
    } catch (const CasError& error) {
        return ExtremaResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ExtremaResult::failure(CasErrc::ResourceLimit,
                                      "extrema allocation failed",
                                      operation);
    } catch (const std::length_error& error) {
        return ExtremaResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return ExtremaResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::vector< CriticalPoint > >::failure(), find_extrema_checked(), find_extrema_impl(), gradient(), Inconclusive, InternalInvariant, ResourceLimit, LMCAS::Result< std::vector< CriticalPoint > >::success(), vars, LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_detail::vector_calculus_point_has_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars().

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

函数调用图:

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

find_extrema_impl()

std::vector< CriticalPoint > LMCAS::find_extrema_impl ( const std::shared_ptr< SymbolicExpr > & f, const std::vector< std::string > & vars, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

计算梯度 gradf

求解 gradf = 0 系统(使用多项式系统求解器)

如果多项式求解器失败,尝试线性求解器

计算海森矩阵

对每个临界点进行分类

在临界点处求值海森矩阵

在文件 vector_calculus_extrema.cpp 第 282 行定义.

{
    if (!f || vars.empty()) {
        return {};
    }
 
    size_t n = vars.size();
 
    /// 计算梯度 gradf
    std::vector<std::shared_ptr<SymbolicExpr>> grad_eqs;
    grad_eqs.reserve(n);
    for (const auto& var : vars) {
        auto partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), var, transform_budget));
        if (partial) {
            partial = detail::make_expression_ptr(detail::normalize_node(detail::node(partial), transform_budget));
        }
        grad_eqs.push_back(partial);
    }
 
    /// 求解 gradf = 0 系统(使用多项式系统求解器)
    std::vector<std::map<std::string, std::shared_ptr<SymbolicExpr>>> solutions;
 
    std::vector<SymbolicExpr> poly_eqs;
    poly_eqs.reserve(n);
    for (const auto& eq : grad_eqs) {
        if (eq) poly_eqs.push_back(*eq);
    }
    if (poly_eqs.size() == n) {
        auto checked_solutions =
            Solver::solve_polynomial_system_checked(poly_eqs, vars, context);
        if (!checked_solutions &&
            checked_solutions.error().code != CasErrc::Inconclusive &&
            checked_solutions.error().code != CasErrc::UnsupportedExpression) {
            throw checked_solutions.error();
        }
        const auto poly_solutions = checked_solutions
            ? std::move(checked_solutions.value())
            : std::vector<std::map<std::string, SymbolicExpr>>{};
        for (const auto& sol : poly_solutions) {
            std::map<std::string, std::shared_ptr<SymbolicExpr>> pt;
            for (const auto& [name, val] : sol) {
                pt[name] = LMCAS::detail::make_expression_ptr(val);
            }
            solutions.push_back(pt);
        }
    }
 
    /// 如果多项式求解器失败,尝试线性求解器
    if (solutions.empty()) {
        auto solved = solver_detail::solve_linear_system_impl(poly_eqs, vars, context);
        if (!solved.empty()) {
            std::map<std::string, std::shared_ptr<SymbolicExpr>> point;
            for (auto& [variable, value] : solved) {
                point.emplace(variable, detail::make_expression_ptr(std::move(value)));
            }
            solutions.push_back(std::move(point));
        }
    }
 
    if (solutions.empty()) {
        return {};
    }
 
    /// 计算海森矩阵
    auto H = hessian_impl(f, vars, transform_budget);
 
    /// 对每个临界点进行分类
    std::vector<CriticalPoint> result;
    result.reserve(solutions.size());
 
    for (const auto& sol : solutions) {
        CriticalPoint cp;
        cp.point = sol;
 
        /// 在临界点处求值海森矩阵
        std::vector<double> numeric_H;
        if (vector_calculus_evaluate_hessian_at_point(H, vars, sol, n, numeric_H, context, transform_budget)) {
            cp.classification = vector_calculus_classify_critical_point(numeric_H, n, context, transform_budget);
        } else {
            cp.classification = CriticalPointClassification::Inconclusive;
        }
 
        result.push_back(std::move(cp));
    }
 
    return result;
}

引用了 LMCAS::CriticalPoint::classification, context, LMCAS::detail::differentiate_node(), eq(), find_extrema_impl(), LMCAS::vector_calculus_detail::hessian_impl(), Inconclusive, LMCAS::detail::make_expression_ptr(), name, LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::CriticalPoint::point, point, LMCAS::solver_detail::solve_linear_system_impl(), UnsupportedExpression, value, variable, vars, vector_calculus_classify_critical_point() , 以及 vector_calculus_evaluate_hessian_at_point().

被这些函数引用 find_extrema(), find_extrema_checked() , 以及 find_extrema_impl().

函数调用图:

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

find_integrating_factor()

std::shared_ptr< SymbolicExpr > LMCAS::find_integrating_factor	(	const std::shared_ptr< SymbolicExpr > &	M,
		const std::shared_ptr< SymbolicExpr > &	N,
		const std::string &	x,
		const std::string &	y )

在文件 ode_first_order.cpp 第 368 行定义.

{
    ComputationContext context;
    auto result = find_integrating_factor_impl(M, N, x, y, context);
    if (!result) { throw result.error(); }
    return std::move(result.value());
}

引用了 context, find_integrating_factor() , 以及 find_integrating_factor_impl().

被这些函数引用 find_integrating_factor().

函数调用图:

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

find_integrating_factor_impl()

ExpressionResult LMCAS::find_integrating_factor_impl ( const std::shared_ptr< SymbolicExpr > & M, const std::shared_ptr< SymbolicExpr > & N, const std::string & x, const std::string & y, ComputationContext & context )

static

计算 partialM/partialy - partialN/partialx

已经恰当,积分因子为 1

尝试 mu = mu(x): (partialM/partialy - partialN/partialx) / N 仅依赖 x

尝试 mu = mu(y): (partialN/partialx - partialM/partialy) / M 仅依赖 y

在文件 ode_first_order.cpp 第 323 行定义.

{
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!M || !N) {
        return std::shared_ptr<SymbolicExpr>{};
    }
 
    /// 计算 partialM/partialy - partialN/partialx
    auto dM_dy = detail::make_expression_ptr(detail::differentiate_node(detail::node(M), y, transform_budget));
    auto dN_dx = detail::make_expression_ptr(detail::differentiate_node(detail::node(N), x, transform_budget));
 
    auto diff = SymbolicExpr::add(dM_dy,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dN_dx));
    diff = detail::make_expression_ptr(detail::normalize_node(detail::node(diff), transform_budget));
 
    auto exact = check_zero_residual(diff, context);
    if (!exact) { return ExpressionResult::failure(exact.error()); }
    if (std::holds_alternative<ProvedZeroResidual>(exact.value())) {
        /// 已经恰当,积分因子为 1
        return SymbolicExpr::number(1);
    }
 
    Integrator integrator;
    /// 尝试 mu = mu(x): (partialM/partialy - partialN/partialx) / N 仅依赖 x
    if (N && !N->is_zero()) {
        auto ratio_x = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(diff, N)), transform_budget));
        auto factor = integrating_factor_from_ratio(ratio_x, x, y, integrator, context);
        if (!factor || factor.value()) { return factor; }
    }
 
    /// 尝试 mu = mu(y): (partialN/partialx - partialM/partialy) / M 仅依赖 y
    if (M && !M->is_zero()) {
        auto neg_diff = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), diff)), transform_budget));
        auto ratio_y = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(neg_diff, M)), transform_budget));
        auto factor = integrating_factor_from_ratio(ratio_y, y, x, integrator, context);
        if (!factor || factor.value()) { return factor; }
    }
 
    return std::shared_ptr<SymbolicExpr>{};
}

引用了 check_zero_residual(), context, LMCAS::detail::differentiate_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), find_integrating_factor_impl(), integrating_factor_from_ratio(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 find_integrating_factor(), find_integrating_factor_impl() , 以及 solve_exact_ode_impl().

函数调用图:

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

find_parametric_pivot()

size_t LMCAS::find_parametric_pivot ( ParametricMatrix & matrix, size_t row, size_t column, ComputationContext & context )

static

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

                                                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    while (row < matrix.size()) {
        auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(matrix[row][column]), transform_budget));
        matrix[row][column] = simplified;
        if (!parametric_zero(simplified, context)) {
            break;
        }
        ++row;
    }
    return row;
}

引用了 context, find_parametric_pivot(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 parametric_zero().

被这些函数引用 find_parametric_pivot().

函数调用图:

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

find_rational_roots()

std::vector< Rational > LMCAS::find_rational_roots

(

const Polynomial< Rational > &

poly

)

在文件 rational_polynomial.cpp 第 69 行定义.

                                                                          {
    std::vector<Rational> roots;
    if (poly.is_zero() || poly.degree() < 1) return roots;
    Polynomial<Rational> current = poly.make_monic();
    while (current.degree() >= 1) {
        if (current.coeffs[0] == Rational(0)) {
            roots.push_back(Rational(0));
            std::vector<Rational> coefficients(
                current.coeffs.begin() + 1, current.coeffs.end());
            current = Polynomial<Rational>(coefficients, current.variable_name);
            continue;
        }
        if (current.degree() == 1) {
            roots.push_back(-current.coeffs[0] / current.lead_coeff());
            break;
        }
        auto candidate = rational_root_candidate(current);
        if (!candidate) break;
        deflate_rational_root(current, *candidate, roots);
    }
    return roots;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, deflate_rational_root(), LMCAS::Polynomial< CoeffType >::degree(), find_rational_roots(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::lead_coeff(), LMCAS::Polynomial< CoeffType >::make_monic(), rational_root_candidate(), roots() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 exact_factor_roots(), factor_rational_univariate(), factor_variable_rational_roots(), find_rational_roots(), LMCAS::detail::make_exact_real_algebraic(), LMCAS::anonymous_namespace{integration_rational_factorization.cpp}::rd_factor_piece(), LMCAS::anonymous_namespace{integration_rational_factorization.cpp}::rd_factor_quadratic(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl() , 以及 solve_exact_factor().

函数调用图:

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

find_roots_with_multiplicity()

std::vector< std::pair< std::shared_ptr< SymbolicExpr >, int > > LMCAS::detail::inequality_support::find_roots_with_multiplicity	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	variable,
		ComputationContext &	context )

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

                                                            {
 
    std::vector<std::pair<std::shared_ptr<SymbolicExpr>, int>> result;
 
    auto converted = symbolic_to_poly<Rational>(expr, variable);
    if (!converted) throw std::invalid_argument(converted.error().message);
    const auto& poly_rat = converted.value();
    if (poly_rat.is_zero() || poly_rat.degree() <= 0) {
        return result;
    }
 
    auto factors = square_free_factorization(poly_rat);
    if (factors.empty()) {
        auto symbolic = symbolic_to_poly<SymbolicPolyCoeff>(expr, variable);
        if (!symbolic) throw std::invalid_argument(symbolic.error().message);
        const auto& poly_spc = symbolic.value();
        if (!poly_spc.is_zero() && poly_spc.degree() >= 1) {
            auto roots = polynomial_solver_detail::solve_by_factoring_impl(
                poly_spc, variable, context);
            append_verified_roots(result, poly_rat, roots, 1, context);
        }
        return result;
    }
    for (const auto& [factor, mult] : factors) {
        if (factor.degree() <= 0) {
            continue;
        }
        if (factor.degree() == 1) {
            append_affine_root(result, factor, mult, context);
        } else if (factor.degree() == 2) {
            append_quadratic_roots(result, factor, mult, context);
        } else {
            append_factor_roots(result, factor, mult, variable, context);
        }
    }
    return result;
}

finite_set() [1/2]

ExprResult LMCAS::finite_set

(

std::vector< ExprPtr >

elements

)

在文件 expr_facade.cpp 第 163 行定义.

                                                   {
    ComputationContext context;
    return finite_set(std::move(elements), context);
}

引用了 context , 以及 finite_set().

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

函数调用图:

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

finite_set() [2/2]

ExprResult LMCAS::finite_set	(	std::vector< ExprPtr >	elements,
		ComputationContext &	context )

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

                                                   {
    return make_finite_set(std::move(elements), context);
}

引用了 context, finite_set() , 以及 make_finite_set().

函数调用图:

finite_set_difference()

SymbolicSetResult LMCAS::finite_set_difference	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs,
		ComputationContext &	context )

在文件 symbolic_set.cpp 第 175 行定义.

                                 {
    auto step = consume(context);
    if (!step) return SymbolicSetResult::failure(step.error());
    auto left = finite_set_node(lhs);
    auto right = finite_set_node(rhs);
    if (!left || !right) return failure(CasErrc::SetOperandTypeMismatch,
                                        "set difference requires two finite sets");
    std::vector<std::shared_ptr<const SymbolicNode>> elements;
    for (const auto& element : left->elements()) {
        if (!right->contains(*element)) elements.push_back(element);
    }
    return from_nodes(std::move(elements));
}

引用了 context, element, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), finite_set_difference(), rhs, right , 以及 SetOperandTypeMismatch.

被这些函数引用 expr_set_difference(), finite_set_difference() , 以及 finite_set_symmetric_difference().

函数调用图:

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

finite_set_intersection()

SymbolicSetResult LMCAS::finite_set_intersection	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs,
		ComputationContext &	context )

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

                                 {
    auto step = consume(context);
    if (!step) return SymbolicSetResult::failure(step.error());
    auto left = finite_set_node(lhs);
    auto right = finite_set_node(rhs);
    if (!left || !right) return failure(CasErrc::SetOperandTypeMismatch,
                                        "set intersection requires two finite sets");
    std::vector<std::shared_ptr<const SymbolicNode>> elements;
    for (const auto& element : left->elements()) {
        if (right->contains(*element)) elements.push_back(element);
    }
    return from_nodes(std::move(elements));
}

引用了 context, element, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), finite_set_intersection(), rhs, right , 以及 SetOperandTypeMismatch.

被这些函数引用 expr_set_intersection() , 以及 finite_set_intersection().

函数调用图:

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

finite_set_symmetric_difference()

SymbolicSetResult LMCAS::finite_set_symmetric_difference	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs,
		ComputationContext &	context )

在文件 symbolic_set.cpp 第 191 行定义.

                                 {
    auto left = finite_set_difference(lhs, rhs, context);
    if (!left) return left;
    auto right = finite_set_difference(rhs, lhs, context);
    if (!right) return right;
    return finite_set_union(*left.value(), *right.value(), context);
}

引用了 context, finite_set_difference(), finite_set_symmetric_difference(), finite_set_union(), rhs , 以及 right.

被这些函数引用 expr_set_symmetric_difference() , 以及 finite_set_symmetric_difference().

函数调用图:

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

finite_set_union()

SymbolicSetResult LMCAS::finite_set_union	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs,
		ComputationContext &	context )

在文件 symbolic_set.cpp 第 145 行定义.

                                 {
    auto step = consume(context);
    if (!step) return SymbolicSetResult::failure(step.error());
    auto left = finite_set_node(lhs);
    auto right = finite_set_node(rhs);
    if (!left || !right) return failure(CasErrc::SetOperandTypeMismatch,
                                        "set union requires two finite sets");
    auto elements = left->elements();
    elements.insert(elements.end(), right->elements().begin(), right->elements().end());
    return from_nodes(std::move(elements));
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), finite_set_union(), rhs, right , 以及 SetOperandTypeMismatch.

被这些函数引用 expr_set_union(), finite_set_symmetric_difference() , 以及 finite_set_union().

函数调用图:

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

finite_values_to_set()

SolveResult LMCAS::finite_values_to_set ( SolveVectorResult result )

static

在文件 solve_visitor.cpp 第 542 行定义.

                                                                  {
    if (!result) return SolveResult::failure(result.error());
    if (result.value().empty()) {
        return SolveResult::success(SolutionSet{EmptySolutions{}});
    }
    std::vector<FiniteSolution> solutions;
    solutions.reserve(result.value().size());
    for (auto& value : result.value()) {
        solutions.push_back(FiniteSolution{std::move(value), 1, {}});
    }
    return SolveResult::success(SolutionSet{FiniteSolutions{std::move(solutions)}});
}

引用了 LMCAS::Result< T >::error(), LMCAS::Result< SolutionSet >::failure(), finite_values_to_set(), LMCAS::Result< SolutionSet >::success(), LMCAS::Result< T >::value() , 以及 value.

被这些函数引用 finite_values_to_set() , 以及 solve_set_core().

函数调用图:

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

floor() [1/2]

ExprResult LMCAS::floor

(

const ExprPtr &

expression

)

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

                                            {
    ComputationContext context;
    return floor(expression, context);
}

引用了 context , 以及 floor().

函数调用图:

floor() [2/2]

ExprResult LMCAS::floor	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 169 行定义.

                                                                         {
    return make_unary_function_expr(expression, context, "floor",
                                    FunctionNode::FuncType::Floor);
}

引用了 context, LMCAS::FunctionNode::Floor, floor() , 以及 LMCAS::expr_detail::expr_common::make_unary_function_expr().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), floor() , 以及 floor().

函数调用图:

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

formal_derivative()

MultiPoly LMCAS::formal_derivative ( const MultiPoly & poly, const std::string & main_var )

static

计算多元多项式关于指定变量的形式偏导数

对每个含 main_var 的项,新系数 = 原系数 x 指数,新指数 = 原指数 - 1. 指数为 0 的项被丢弃.

参数

[in]	poly	输入多元多项式
[in]	main_var	求导变量名

返回

partialpoly/partialmain_var

main_var 不在变量列表中,导数为零

在文件 multivariate_factor.cpp 第 389 行定义.

{
    if (poly.is_zero()) { return poly; }
 
    const auto& vars = poly.variables();
    int var_idx = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == main_var) { var_idx = static_cast<int>(i); break; }
    }
    if (var_idx < 0) {
        /// main_var 不在变量列表中,导数为零
        return MultiPoly(Rational(0), vars);
    }
 
    std::vector<MultiPoly::Term> result_terms;
    for (const auto& term : poly.terms()) {
        const Monomial& mono = term.first;
        int exp = (static_cast<size_t>(var_idx) < mono.size()) ? mono[var_idx] : 0;
        if (exp == 0) { continue; } /**< 常数项关于该变量的导数为零。 */
 
        Rational new_coeff = term.second * Rational(exp);
        Monomial new_mono = mono;
        new_mono[var_idx] = exp - 1;
        result_terms.emplace_back(std::move(new_mono), std::move(new_coeff));
    }
 
    if (result_terms.empty()) { return MultiPoly(Rational(0), vars); }
    return MultiPoly(std::move(result_terms), vars);
}

引用了 exp(), formal_derivative(), main_var , 以及 vars.

被这些函数引用 formal_derivative() , 以及 square_free_decompose().

函数调用图:

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

fourier_constant_coefficient()

ExpressionResult LMCAS::fourier_constant_coefficient ( Integrator & integrator, const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const FourierPeriod & period, ComputationContext & context )

static

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

                                                                  {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto a0_integral = integrator.integrate_def_checked(
        *f, var, *period.lower, *period.upper, context);
    if (!a0_integral) { return ExpressionResult::failure(a0_integral.error()); }
    auto a0 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
        LMCAS::detail::make_expression_ptr(a0_integral.value()), period.half_length)), transform_budget));
    return SymbolicExpr::divide(a0, period.two);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "fourier_constant_coefficient");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "fourier_constant_coefficient");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "fourier_constant_coefficient");
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), fourier_constant_coefficient(), LMCAS::FourierPeriod::half_length, integrator, LMCAS::FourierPeriod::lower, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::FourierPeriod::two , 以及 LMCAS::FourierPeriod::upper.

被这些函数引用 fourier_constant_coefficient() , 以及 fourier_series_checked().

函数调用图:

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

fourier_harmonics()

Result< void > LMCAS::fourier_harmonics ( Integrator & integrator, const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const FourierPeriod & period, const std::shared_ptr< SymbolicExpr > & x, int n_terms, int parity, std::shared_ptr< SymbolicExpr > & result, ComputationContext & context )

static

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

                                                                                               {
    for (int k = 1; k <= n_terms; ++k) {
        auto kw = SymbolicExpr::multiply(SymbolicExpr::number(k), period.frequency);
        auto arg = SymbolicExpr::multiply(kw, x);
        if (parity != -1) {
            auto added = add_fourier_harmonic(integrator, f, var, period.lower,
                period.upper, period.half_length, arg, true, result, context);
            if (!added) { return added; }
        }
        if (parity != 1) {
            auto added = add_fourier_harmonic(integrator, f, var, period.lower,
                period.upper, period.half_length, arg, false, result, context);
            if (!added) { return added; }
        }
    }
    return Result<void>::success();
}

引用了 add_fourier_harmonic(), context, fourier_harmonics(), LMCAS::FourierPeriod::frequency, LMCAS::FourierPeriod::half_length, integrator, LMCAS::FourierPeriod::lower, LMCAS::Result< T >::success() , 以及 LMCAS::FourierPeriod::upper.

被这些函数引用 fourier_harmonics() , 以及 fourier_series_checked().

函数调用图:

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

fourier_series_checked() [1/2]

ExpressionResult LMCAS::fourier_series_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	period,
		int	n_terms )

在文件 series_expansions.cpp 第 330 行定义.

                                                            {
    ComputationContext context;
    return fourier_series_checked(f, var, period, n_terms, context);
}

引用了 context , 以及 fourier_series_checked().

函数调用图:

fourier_series_checked() [2/2]

ExpressionResult LMCAS::fourier_series_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	period,
		int	n_terms,
		ComputationContext &	context )

在文件 series_expansions.cpp 第 271 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "fourier_series";
    if (!f || !period || var.empty() || n_terms < 0) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "Fourier expansion requires an expression, variable, positive period, and non-negative term count",
            operation);
    }
    const std::size_t expansion_terms =
        1 + 2 * static_cast<std::size_t>(n_terms);
    if (expansion_terms > context.limits().max_expansion_terms) {
        return ExpressionResult::failure(
            CasErrc::ResourceLimit,
            "Fourier term count exceeds the expansion budget", operation);
    }
 
    try {
        auto access = context.consume_steps(1, operation);
        if (!access) {
            return ExpressionResult::failure(access.error());
        }
 
        auto prepared = prepare_fourier_period(period, var, context);
        if (!prepared) { return ExpressionResult::failure(prepared.error()); }
 
        int parity = detect_parity(f, var, context);
        Integrator integrator;
        auto x = SymbolicExpr::variable(var);
 
        auto constant = fourier_constant_coefficient(integrator, f, var, prepared.value(), context);
        if (!constant) { return constant; }
        auto result = std::move(constant.value());
        auto harmonics = fourier_harmonics(
            integrator, f, var, prepared.value(), x, n_terms, parity, result, context);
        if (!harmonics) { return ExpressionResult::failure(harmonics.error()); }
        return ExpressionResult::success(detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget)));
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(
            CasErrc::ResourceLimit,
            "Fourier expansion allocation failed", operation);
    } catch (const std::length_error& error) { return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "fourier_series"); } catch (const std::exception& error) {
        return ExpressionResult::failure(
            CasErrc::InternalInvariant, error.what(), operation);
    }
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "fourier_series");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "fourier_series");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "fourier_series");
}

引用了 context, detect_parity(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), fourier_constant_coefficient(), fourier_harmonics(), fourier_series_checked(), integrator, InternalInvariant, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), prepare_fourier_period(), ResourceLimit , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

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

函数调用图:

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

fourier_transform_checked() [1/2]

TransformEngineResult LMCAS::fourier_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	t,
		const std::string &	omega )

在文件 transform_fourier.cpp 第 208 行定义.

                            {
    ComputationContext context;
    return fourier_transform_checked(f, t, omega, context);
}

引用了 context, fourier_transform_checked() , 以及 t.

函数调用图:

fourier_transform_checked() [2/2]

TransformEngineResult LMCAS::fourier_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	t,
		const std::string &	omega,
		ComputationContext &	context )

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

                                 {
    const std::string operation = "fourier_transform";
    auto valid = te_validate_expr_vars(f, t, omega, context, operation);
    if (!valid) return TransformEngineResult::failure(valid.error());
    auto step = context.consume_steps(8, operation);
    if (!step) return TransformEngineResult::failure(step.error());
    try {
        AssumptionContext empty_assumptions;
        const auto& assumptions = context.assumptions() ? *context.assumptions() : empty_assumptions;
        std::vector<std::shared_ptr<SymbolicExpr>> conditions;
        auto expression = fourier_transform_core(f, t, omega, context, assumptions, conditions);
        auto final_access = context.consume_steps(0, operation);
        if (!final_access) {
            return TransformEngineResult::failure(final_access.error());
        }
        auto result = te_wrap_transform_result(std::move(expression), operation);
        if (result) result.value().value.conditions = std::move(conditions);
        return result;
    } catch (const CasError& error) {
        return TransformEngineResult::failure(error);
    } catch (const std::bad_alloc&) {
        return TransformEngineResult::failure(CasErrc::ResourceLimit,
                                              "transform allocation failed",
                                              operation);
    } catch (const std::exception& e) {
        return TransformEngineResult::failure(CasErrc::InternalInvariant,
                                              e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< Verified< EvaluatedTransform > >::failure(), fourier_transform_checked(), fourier_transform_core(), InternalInvariant, ResourceLimit, t, LMCAS::transform_detail::te_validate_expr_vars() , 以及 LMCAS::transform_detail::te_wrap_transform_result().

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

函数调用图:

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

fourier_transform_core()

std::shared_ptr< SymbolicExpr > LMCAS::fourier_transform_core ( const std::shared_ptr< SymbolicExpr > & f, const std::string & t, const std::string & omega, ComputationContext & context, const AssumptionContext & assumptions, std::vector< std::shared_ptr< SymbolicExpr > > & conditions )

static

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

                                                        {
    auto step = context.consume_steps(1, "fourier_transform.recursive");
    if (!step) {
        return nullptr;
    }
    if (!f || !detail::node(f)) {
        return nullptr;
    }
    if (!te_depends_on(f, t)) {
        return te_fourier_unevaluated(f, t, omega);
    }
    auto addition = std::dynamic_pointer_cast<const AddNode>(detail::node(f));
    if (addition) {
        return te_fourier_sum(*addition, t, omega, context, assumptions, conditions);
    }
    auto [coefficient, body] = te_split_coeff(f, t);
    if (!coefficient->is_one()) {
        auto transformed = fourier_transform_core(body, t, omega, context, assumptions, conditions);
        if (transformed) {
            return SymbolicExpr::multiply(coefficient, transformed);
        }
    }
    if (const auto gaussian_rate = te_match_pure_gaussian(f, t)) {
        return te_gaussian_fourier(*gaussian_rate, omega);
    }
    auto decay = te_abs_decay(f, t, context);
    if (decay) {
        if (te_accept_decay(decay, assumptions, conditions, context)) {
            return te_abs_fourier(decay, omega, context);
        }
        return te_fourier_unevaluated(f, t, omega);
    }
    return te_fourier_unevaluated(f, t, omega);
}

引用了 context, fourier_transform_core(), LMCAS::detail::node(), t, te_abs_decay(), te_abs_fourier(), te_accept_decay(), LMCAS::transform_detail::te_depends_on(), te_fourier_sum(), te_fourier_unevaluated(), te_gaussian_fourier(), LMCAS::transform_detail::te_match_pure_gaussian() , 以及 LMCAS::transform_detail::te_split_coeff().

被这些函数引用 fourier_transform_checked(), fourier_transform_core(), inverse_fourier_transform_checked() , 以及 te_fourier_sum().

函数调用图:

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

free_variables()

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

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

                                                                  {
    FreeVariableCollector collector(budget);
    if (expression) expression->accept(collector);
    return std::move(collector.variables);
}

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

被这些函数引用 LMCAS::anonymous_namespace{residual_verification.cpp}::classify_residual(), classify_singular_point_checked(), LMCAS::detail::AssumptionFacts::collect_names(), factor_transcendental_expression(), free_variables(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::independent(), LMCAS::polynomial_solver_detail::is_purely_numeric(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::reduce_fraction(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::solve_mixed_equation() , 以及 substitute_free().

函数调用图:

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

frobenius_arithmetic_failure()

CasError LMCAS::frobenius_arithmetic_failure ( )

static

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

                                               {
    return {CasErrc::NumericFailure,
            "Frobenius coefficient recurrence produced a non-finite value",
            "solve_frobenius"};
}

引用了 frobenius_arithmetic_failure() , 以及 NumericFailure.

被这些函数引用 frobenius_arithmetic_failure(), frobenius_indicial_roots(), ordinary_series_recurrence() , 以及 singular_series_recurrence().

函数调用图:

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

frobenius_coefficient_limit()

Result< double > LMCAS::frobenius_coefficient_limit ( const std::shared_ptr< SymbolicExpr > & coefficient, const std::string & x, const std::shared_ptr< SymbolicExpr > & x0, double value, ComputationContext & context )

static

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

                                               {
    if (std::isfinite(value)) {
        return value;
    }
    auto limited = limit_expression_checked(
        coefficient, x, x0, LimitDirection::Both, context);
    if (!limited) {
        return Result<double>::failure(limited.error());
    }
    const auto& lim = limited.value();
    return lim ? try_eval_double(lim)
               : std::numeric_limits<double>::quiet_NaN();
}

引用了 Both, context, LMCAS::Result< T >::failure(), frobenius_coefficient_limit(), limit_expression_checked(), try_eval_double() , 以及 value.

被这些函数引用 frobenius_coefficient_limit() , 以及 singular_taylor_coefficients().

函数调用图:

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

frobenius_indicial_roots()

Result< std::pair< double, double > > LMCAS::frobenius_indicial_roots ( double P0, double Q0 )

static

在文件 ode_frobenius.cpp 第 137 行定义.

                          {
    double ind_b = P0 - 1.0;
    double ind_c = Q0;
    double ind_D = ind_b * ind_b - 4.0 * ind_c;
    if (!std::isfinite(ind_D)) {
        return Result<std::pair<double, double>>::failure(frobenius_arithmetic_failure());
    }
 
    double r1, r2;
    int eq;
    lmmc_double_nearly_equal_tol(ind_D, 0.0, 1e-12, 1e-12, &eq);
    if (!eq && ind_D > 0) {
        r1 = (-ind_b + std::sqrt(ind_D)) / 2.0;
        r2 = (-ind_b - std::sqrt(ind_D)) / 2.0;
    } else if (eq) {
        r1 = -ind_b / 2.0;
        r2 = r1;
    } else {
        r1 = -ind_b / 2.0;
        r2 = r1;
    }
    if (r1 < r2) {
        std::swap(r1, r2);
    }
 
    return std::make_pair(r1, r2);
}

引用了 e(), eq(), frobenius_arithmetic_failure() , 以及 frobenius_indicial_roots().

被这些函数引用 frobenius_indicial_roots() , 以及 singular_frobenius_solution().

函数调用图:

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

frobenius_unsupported_numeric()

CasError LMCAS::frobenius_unsupported_numeric ( )

static

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

                                                {
    return {CasErrc::Inconclusive,
            "Frobenius series coefficients are outside the checked numeric support domain",
            "solve_frobenius"};
}

引用了 frobenius_unsupported_numeric() , 以及 Inconclusive.

被这些函数引用 frobenius_unsupported_numeric(), ordinary_taylor_coefficients(), singular_frobenius_solution() , 以及 singular_taylor_coefficients().

函数调用图:

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

function()

ExprResult LMCAS::function	(	const std::string &	name,
		std::vector< ExprPtr >	arguments )

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

                                                                         {
    constexpr const char* operation = "LMCAS.function";
    if (name.empty()) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "function name cannot be empty", operation);
    }
    std::vector<std::shared_ptr<const SymbolicNode>> nodes;
    nodes.reserve(arguments.size());
    for (const auto& argument : arguments) {
        if (!argument || !LMCAS::detail::node(argument)) {
            return expression_failure(CasErrc::InvalidArgument,
                                      "function arguments cannot be null", operation);
        }
        nodes.push_back(LMCAS::detail::node(argument));
    }
    try {
        return ExprResult::success(LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<UninterpretedFunctionNode>(
                name, std::move(nodes))));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "function allocation failed", operation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant,
                                  error.what(), operation);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), function(), InternalInvariant, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), name, LMCAS::detail::node(), ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 LMCAS::detail::definite::absolute_argument(), adaptive_simpson_numeric(), adaptive_simpson_numeric(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::additive_function_pattern(), bisection_checked(), bisection_checked(), calculus_utils_contains_complex(), calculus_utils_contains_nonreal_sqrt(), LMCAS::detail::anonymous_namespace{exact_constant_bounds.cpp}::checked_bounds(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_function(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_limit_result(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_sqrt(), LMCAS::anonymous_namespace{residual_verification.cpp}::collect_function_profile(), LMCAS::anonymous_namespace{residual_verification.cpp}::collect_residual_profiles(), LMCAS::UninterpretedFunctionNode::compare_same_type(), LMCAS::MultiplyNode::contains_matrix(), LMCAS::detail::transcendental::decompose_trig_exp_pattern(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_function(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_node(), LMCAS::anonymous_namespace{limit_result.cpp}::elementary_continuous_structure(), exact_scalar_radicand(), LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), function(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::function_bounds(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::function_candidate(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::function_period(), infinity_sign(), integrating_factor_from_antiderivative(), LMCAS::anonymous_namespace{integration_linearity.cpp}::integration_exponential_argument(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::invertible_function(), LMCAS::calculus_utils_detail::is_infinity_node(), is_nonreal_sqrt(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::lambert_inner(), LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_reduced_expression(), LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_substitutable_function(), match_recursive(), LMCAS::detail::definite::needs_segment_expression(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), LMCAS::NormalizationVisitor::normalize_function_parity(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::detail::definite::original_conditions_checked(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::outside_real_function_domain(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_quadratic_surd(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::propagate(), quadrature_gaussian_numeric(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), quadrature_simpson_numeric(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_exp_log_function(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_function(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_node_sign(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_newton_backend(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::scaled_function(), LMCAS::detail::anonymous_namespace{squared_norm.cpp}::square_root_argument(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::square_root_is_imaginary(), LMCAS::detail::definite::structurally_continuous(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_argument(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive(), te_abs_decay(), te_is_abs_variable(), LMCAS::transform_detail::te_is_trig(), LMCAS::transform_detail::te_match_pure_gaussian(), LMCAS::transform_detail::te_match_scaled_gaussian(), tf_is_variable_exponential(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::trig_square(), LMCAS::NormalizationVisitor::try_assumption_simplify(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::unsupported_endpoint(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::validate_geometry_inputs(), LMCAS::anonymous_namespace{numerical_integration.cpp}::validate_quadrature_args(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_functions_vars(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_trig_of_variable().

函数调用图:

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

gcd_coeff_impl()

template<typename T>

T LMCAS::gcd_coeff_impl	(	const T &	a,
		const T &	b )

计算两个系数的最大公约数(泛型实现)

模板参数

T

系数类型

参数

a	第一个系数
b	第二个系数

返回

gcd(a, b)

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

                                         {
    if constexpr (std::is_integral_v<T>) {
        return std::abs(std::gcd(a, b));
    }
    else if constexpr (std::is_same_v<T, BigInt>) {
        return BigInt::gcd(a, b);
    }
    else if constexpr (std::is_same_v<T, Rational>) {
        return Rational(1);
    }
    else {
        return T(1);
    }
}

引用了 a, b , 以及 gcd_coeff_impl().

被这些函数引用 LMCAS::Polynomial< CoeffType >::gcd() , 以及 gcd_coeff_impl().

函数调用图:

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

gcd_evaluation_points()

std::vector< Rational > LMCAS::gcd_evaluation_points ( int bound )

static

在文件 multivariate_factor.cpp 第 263 行定义.

                                                            {
    std::vector<Rational> points;
    points.push_back(Rational(0));
    for (int k = 1; static_cast<int>(points.size()) < bound; ++k) {
        points.push_back(Rational(k));
        points.push_back(Rational(-k));
    }
    return points;
}

引用了 gcd_evaluation_points().

被这些函数引用 extended_gcd_interpolation(), gcd_evaluation_points() , 以及 recursive_multivariate_gcd().

函数调用图:

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

ge()

ExprResult LMCAS::ge	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_facade.cpp 第 209 行定义.

                                                      {
    return relation(lhs, rhs, RelationOp::GEQ);
}

引用了 ge(), GEQ, relation() , 以及 rhs.

被这些函数引用 ge().

函数调用图:

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

generate_good_primes()

std::vector< int64_t > LMCAS::generate_good_primes ( int count, const std::vector< BigInt > & leading_coeffs, uint64_t start_from = UINT64_C(1000000000) )

inline

生成指定数量的好素数

参数

count	需要的素数个数
leading_coeffs	首项系数列表（用于过滤）
start_from	搜索起始值

返回

好素数列表

在文件 modular_arithmetic.hpp 第 491 行定义.

                                              {
    if (count < 0) {
        throw std::invalid_argument("prime count must be nonnegative");
    }
    const auto requested = static_cast<std::size_t>(count);
    const auto maximum = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
    std::vector<int64_t> result;
    result.reserve(requested);
    uint64_t candidate = start_from;
    while (result.size() < requested) {
        if (candidate >= maximum) {
            throw std::overflow_error("prime search exceeds the signed residue range");
        }
        const uint64_t next = lmmp_next_prime_ulong_(candidate);
        if (next <= candidate || next > maximum) {
            throw std::overflow_error("prime search exhausted the signed residue range");
        }
        candidate = next;
        const auto prime = static_cast<int64_t>(candidate);
        if (is_good_prime(prime, leading_coeffs)) {
            result.push_back(prime);
        }
    }
    return result;
}

引用了 generate_good_primes(), is_good_prime() , 以及 prime.

被这些函数引用 generate_good_primes().

函数调用图:

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

geometric_term_convergence()

std::optional< ConvergenceInfo > LMCAS::geometric_term_convergence ( const std::shared_ptr< const SymbolicNode > & node, const std::string & index_var )

static

在文件 series_convergence.cpp 第 258 行定义.

                                {
    auto power = std::dynamic_pointer_cast<const PowerNode>(node);
    if (!power) {
        return std::nullopt;
    }
    auto exponent = std::dynamic_pointer_cast<const VariableNode>(power->exponent());
    auto base = std::dynamic_pointer_cast<const NumberNode>(power->base());
    if (!exponent || exponent->is_constant() || exponent->name() != index_var || !base) {
        return std::nullopt;
    }
 
    bool inside_unit_circle = false;
    if (const auto* integer = std::get_if<BigInt>(&base->value())) {
        inside_unit_circle = *integer > BigInt(-1) && *integer < BigInt(1);
    } else if (const auto* rational = std::get_if<Rational>(&base->value())) {
        inside_unit_circle = *rational > Rational(-1) && *rational < Rational(1);
    }
    return ConvergenceInfo{
        inside_unit_circle ? ConvergenceResult::Convergent
                           : ConvergenceResult::Divergent,
        "geometric"};
}

引用了 Convergent, Divergent, exponent, geometric_term_convergence(), integer , 以及 rational().

被这些函数引用 convergence_test_impl() , 以及 geometric_term_convergence().

函数调用图:

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

get_coeff()

std::shared_ptr< SymbolicExpr > LMCAS::get_coeff	(	const Polynomial< SymbolicPolyCoeff > &	p,
		int	deg )

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

                                                                                       {
    if (deg < 0 || deg > p.degree()) {
        return SymbolicExpr::number(0);
    }
    return p.coeffs[deg].val;
}

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

被这些函数引用 conditional_linear_polynomial(), get_coeff(), solve_closed_form_from_poly(), solve_closed_form_poly(), LMCAS::detail::inequality_support::solve_symbolic_poly(), solve_symbolic_polynomial_set() , 以及 solve_symbolic_quadratic().

函数调用图:

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

get_integer_value()

bool LMCAS::get_integer_value ( const std::shared_ptr< const SymbolicNode > & node, BigInt & value )

static

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

                                                                                            {
    auto num = std::dynamic_pointer_cast<const NumberNode>(node);
    if (!num) {
        return false;
    }
    if (std::holds_alternative<BigInt>(num->value())) {
        value = std::get<BigInt>(num->value());
        return true;
    }
    if (std::holds_alternative<Rational>(num->value())) {
        const auto& r = std::get<Rational>(num->value());
        if (!r.is_integer()) {
            return false;
        }
        value = r.to_bigint();
        return true;
    }
    return false;
}

引用了 get_integer_value(), LMCAS::polynomial_solver_detail::num(), r , 以及 value.

被这些函数引用 collect_power_denominators(), get_integer_value() , 以及 LMCAS::solver_detail::is_polynomial_node().

函数调用图:

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

get_node_degree_helper()

BigInt LMCAS::get_node_degree_helper

(

const std::shared_ptr< const SymbolicNode > &

node

)

计算 AST 节点的多项式次数

参数

node

输入节点

返回

节点对应的多项式次数

在文件 normalization_utils.cpp 第 61 行定义.

                                                                             {
    if (!node) {
        return BigInt(0);
    }
    if (std::dynamic_pointer_cast<const VariableNode>(node)) {
        return BigInt(1);
    }
    if (auto p = std::dynamic_pointer_cast<const PowerNode>(node)) {
        const auto e = std::dynamic_pointer_cast<const NumberNode>(p->exponent());
        BigInt degree;
        if (try_get_integer_value(e, degree)) {
            return degree;
        }
        return BigInt(1);
    }
    if (auto m = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        BigInt d(0);
        for (auto& op : m->operands()) d += get_node_degree_helper(op);
        return d;
    }
    return BigInt(0);
}

引用了 e(), get_node_degree_helper(), op , 以及 try_get_integer_value().

被这些函数引用 get_node_degree_helper(), normalization_factor_less(), LMCAS::NodeCompare::operator()() , 以及 LMCAS::anonymous_namespace{normalization_arithmetic.cpp}::sum_term_less().

函数调用图:

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

get_pi_coeff()

bool LMCAS::get_pi_coeff	(	const std::shared_ptr< const SymbolicNode > &	node,
		Rational &	coefficient )

在文件 normalization_utils.cpp 第 182 行定义.

                                                                              {
    const auto variable = std::dynamic_pointer_cast<const VariableNode>(node);
    if (variable && is_pi_variable(*variable)) {
        k = Rational(1);
        return true;
    }
    const auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!multiply) {
        return false;
    }
    bool has_pi = false;
    k = Rational(1);
    for (const auto& operand : multiply->operands()) {
        if (const auto variable = std::dynamic_pointer_cast<const VariableNode>(operand)) {
            if (has_pi || !is_pi_variable(*variable)) return false;
            has_pi = true;
            continue;
        }
        const auto number = std::dynamic_pointer_cast<const NumberNode>(operand);
        if (!number) {
            return false;
        }
        if (const auto* rational = std::get_if<Rational>(&number->value())) {
            k = k * *rational;
            continue;
        }
        const auto* integer = std::get_if<BigInt>(&number->value());
        if (!integer) {
            return false;
        }
        k = k * Rational(*integer);
    }
    return has_pi;
}

引用了 get_pi_coeff(), integer, is_pi_variable(), rational() , 以及 variable.

被这些函数引用 get_pi_coeff() , 以及 LMCAS::NormalizationVisitor::normalize_unary_function().

函数调用图:

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

gradient()

VectorField LMCAS::gradient	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_differential.cpp 第 332 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "gradient");
    return gradient_impl(f, vars, transform_budget);
}

引用了 context, gradient(), LMCAS::vector_calculus_detail::gradient_impl() , 以及 vars.

被这些函数引用 find_extrema_checked(), gradient(), lagrange_gradient_strict(), lagrange_multipliers_strict(), lagrange_stationarity_equation(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_at_point_checked(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_scale_checked(), surface_normal_checked() , 以及 tangent_plane_checked().

函数调用图:

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

gradient_checked() [1/2]

VectorCalculusFieldResult LMCAS::gradient_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

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

{
    ComputationContext context;
    return gradient_checked(f, vars, context);
}

引用了 context, gradient_checked() , 以及 vars.

函数调用图:

gradient_checked() [2/2]

VectorCalculusFieldResult LMCAS::gradient_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "gradient");
    const std::string operation = "gradient";
    auto valid = vector_calculus_validate_expr_vars(f, vars, context, operation);
    if (!valid) {
        return VectorCalculusFieldResult::failure(valid.error());
    }
    auto step = context.consume_steps(vars.size(), operation);
    if (!step) {
        return VectorCalculusFieldResult::failure(step.error());
    }
    try {
        return vector_calculus_wrap_field(gradient_impl(f, vars, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusFieldResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit,
                                                  "vector calculus allocation failed",
                                                  operation);
    } catch (const std::length_error& error) {
        return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusFieldResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< VectorField >::failure(), gradient_checked(), LMCAS::vector_calculus_detail::gradient_impl(), InternalInvariant, ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_field().

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

函数调用图:

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

gram_schmidt()

std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > LMCAS::gram_schmidt	(	const std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > &	vectors,
		bool	normalize )

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

                    {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> basis;
    for (const auto& v : vectors) {
        std::vector<std::shared_ptr<SymbolicExpr>> u = v;
        for (const auto& b : basis) {
            auto vb = SymbolicExpr::number(0);
            auto bb = SymbolicExpr::number(0);
            for (size_t k = 0; k < u.size(); ++k) {
                vb = SymbolicExpr::add(vb, SymbolicExpr::multiply(v[k], b[k]));
                bb = SymbolicExpr::add(bb, SymbolicExpr::multiply(b[k], b[k]));
            }
            if (LMCAS::detail::node(bb) && LMCAS::detail::node(bb)->is_zero()) continue;
            auto coeff = SymbolicExpr::divide(vb, bb);
            for (size_t k = 0; k < u.size(); ++k) {
                u[k] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(u[k],
                    SymbolicExpr::multiply(SymbolicExpr::number(-1),
                        SymbolicExpr::multiply(coeff, b[k])))), transform_budget));
            }
        }
        auto norm_sq = SymbolicExpr::number(0);
        for (auto& x : u) norm_sq = SymbolicExpr::add(norm_sq, SymbolicExpr::multiply(x, x));
        norm_sq = detail::make_expression_ptr(detail::normalize_node(detail::node(norm_sq), transform_budget));
        if (LMCAS::detail::node(norm_sq) && LMCAS::detail::node(norm_sq)->is_zero()) continue;
        basis.push_back(u);
    }
    if (normalize) {
        for (auto& u : basis) {
            auto norm_sq = SymbolicExpr::number(0);
            for (auto& x : u) norm_sq = SymbolicExpr::add(norm_sq, SymbolicExpr::multiply(x, x));
            auto norm = SymbolicExpr::sqrt(norm_sq);
            for (auto& x : u) x = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(x, norm)), transform_budget));
        }
    }
    return basis;
}

引用了 b, basis, context, gram_schmidt(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), u , 以及 v.

被这些函数引用 gram_schmidt().

函数调用图:

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

greens_theorem()

std::shared_ptr< SymbolicExpr > LMCAS::greens_theorem	(	const std::shared_ptr< SymbolicExpr > &	P,
		const std::shared_ptr< SymbolicExpr > &	Q,
		const std::vector< std::string > &	vars,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds )

计算被积函数: ∂Q/∂x - ∂P/∂y

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

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!P || !Q) {
        throw std::invalid_argument("greens_theorem: P and Q must not be null");
    }
    if (vars.size() != 2) {
        throw std::invalid_argument("greens_theorem: vars must have exactly 2 elements");
    }
    if (!x_bounds.first || !x_bounds.second ||
        !y_bounds.first || !y_bounds.second) {
        throw std::invalid_argument("greens_theorem: bounds must not be null");
    }
 
    const std::string& x_var = vars[0];
    const std::string& y_var = vars[1];
 
    /// 计算被积函数: ∂Q/∂x - ∂P/∂y
    auto dQ_dx = detail::make_expression_ptr(detail::differentiate_node(detail::node(Q), x_var, transform_budget));
    auto dP_dy = detail::make_expression_ptr(detail::differentiate_node(detail::node(P), y_var, transform_budget));
 
    if (!dQ_dx) dQ_dx = SymbolicExpr::number(0);
    if (!dP_dy) dP_dy = SymbolicExpr::number(0);
 
    dQ_dx = detail::make_expression_ptr(detail::normalize_node(detail::node(dQ_dx), transform_budget));
    dP_dy = detail::make_expression_ptr(detail::normalize_node(detail::node(dP_dy), transform_budget));
 
    auto integrand = SymbolicExpr::add(
        dQ_dx,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dP_dy));
    integrand = detail::make_expression_ptr(detail::normalize_node(detail::node(integrand), transform_budget));
 
    Integrator integrator;
 
    std::vector<IntegrationStep> steps = {
        {y_var, y_bounds.first, y_bounds.second},
        {x_var, x_bounds.first, x_bounds.second},
    };
    auto result = integrate_multiple_checked(*integrand, steps, integrator, context);
    if (!result) throw result.error();
    return LMCAS::detail::make_expression_ptr(result.value());
}

引用了 context, LMCAS::detail::differentiate_node(), greens_theorem(), integrate_multiple_checked(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), steps, vars, x_bounds , 以及 y_bounds.

被这些函数引用 greens_theorem().

函数调用图:

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

greens_theorem_area()

std::shared_ptr< SymbolicExpr > LMCAS::greens_theorem_area	(	const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

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

{
    if (parametrization.size() != 2) {
        throw std::invalid_argument(
            "greens_theorem_area: parametrization must have 2 components (x(t), y(t))");
    }
    if (!a || !b) {
        throw std::invalid_argument("greens_theorem_area: bounds must not be null");
    }
 
    auto x_t = parametrization[0];
    auto y_t = parametrization[1];
 
    if (!x_t || !y_t) {
        throw std::invalid_argument("greens_theorem_area: parametrization components must not be null");
    }
 
    ComputationContext context;
    auto area = greens_theorem_area_checked(
        parametrization, t, a, b, context);
    if (!area && area.error().code != CasErrc::Inconclusive &&
        area.error().code != CasErrc::UnsupportedExpression &&
        area.error().code != CasErrc::DomainError) {
        throw area.error();
    }
    return area ? std::move(area.value()) : nullptr;
}

引用了 a, b, context, DomainError, greens_theorem_area(), greens_theorem_area_checked(), Inconclusive, parametrization, t , 以及 UnsupportedExpression.

被这些函数引用 greens_theorem_area().

函数调用图:

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

greens_theorem_area_checked() [1/2]

VectorCalculusExprResult LMCAS::greens_theorem_area_checked	(	const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

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

{
    ComputationContext context;
    return greens_theorem_area_checked(parametrization, t, a, b, context);
}

引用了 a, b, context, greens_theorem_area_checked(), parametrization , 以及 t.

函数调用图:

greens_theorem_area_checked() [2/2]

VectorCalculusExprResult LMCAS::greens_theorem_area_checked	(	const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

在文件 vector_calculus_integral_api.cpp 第 123 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "greens_theorem_area");
    const std::string operation = "greens_theorem_area";
    auto valid = vector_calculus_validate_curve_parametrization(
        parametrization, t, a, b, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
    if (parametrization.size() != 2) {
        return VectorCalculusExprResult::failure(
            CasErrc::InvalidArgument,
            "Green's area parametrization must be two-dimensional",
            operation);
    }
    auto step = context.consume_steps(10, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return greens_theorem_area_strict(parametrization, t, a, b, context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "Green's area allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 a, b, context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), greens_theorem_area_checked(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), InternalInvariant, InvalidArgument, parametrization, ResourceLimit, t , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_curve_parametrization().

被这些函数引用 greens_theorem_area(), greens_theorem_area_checked() , 以及 greens_theorem_area_checked().

函数调用图:

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

greens_theorem_checked() [1/2]

VectorCalculusExprResult LMCAS::greens_theorem_checked	(	const std::shared_ptr< SymbolicExpr > &	P,
		const std::shared_ptr< SymbolicExpr > &	Q,
		const std::vector< std::string > &	vars,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds )

在文件 vector_calculus_integral_api.cpp 第 61 行定义.

{
    ComputationContext context;
    return greens_theorem_checked(P, Q, vars, x_bounds, y_bounds, context);
}

引用了 context, greens_theorem_checked(), vars, x_bounds , 以及 y_bounds.

函数调用图:

greens_theorem_checked() [2/2]

VectorCalculusExprResult LMCAS::greens_theorem_checked	(	const std::shared_ptr< SymbolicExpr > &	P,
		const std::shared_ptr< SymbolicExpr > &	Q,
		const std::vector< std::string > &	vars,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	x_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	y_bounds,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "greens_theorem");
    const std::string operation = "greens_theorem";
    auto vars_valid = vector_calculus_validate_distinct_vars(vars, 2, context, operation);
    if (!vars_valid) {
        return VectorCalculusExprResult::failure(vars_valid.error());
    }
    if (!P || !LMCAS::detail::node(P) || !Q || !LMCAS::detail::node(Q)) {
        return VectorCalculusExprResult::failure(
            CasErrc::InvalidArgument,
            "Green's theorem vector-field components cannot be null",
            operation);
    }
    auto x_valid = vector_calculus_validate_bound_pair(x_bounds, context, operation, "x");
    if (!x_valid) {
        return VectorCalculusExprResult::failure(x_valid.error());
    }
    auto y_valid = vector_calculus_validate_bound_pair(y_bounds, context, operation, "y");
    if (!y_valid) {
        return VectorCalculusExprResult::failure(y_valid.error());
    }
    auto step = context.consume_steps(10, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return greens_theorem_strict(P, Q, vars, x_bounds, y_bounds, context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "Green's theorem allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), greens_theorem_checked(), LMCAS::vector_calculus_detail::greens_theorem_strict(), InternalInvariant, InvalidArgument, LMCAS::detail::node(), ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_bound_pair(), LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars(), x_bounds , 以及 y_bounds.

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

函数调用图:

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

grevlex_to_lex()

std::vector< FGLMPoly > LMCAS::grevlex_to_lex	(	const std::vector< FGLMPoly > &	grevlex_basis,
		size_t	num_vars )

在文件 fglm.cpp 第 133 行定义.

                                                     {
    return fglm_convert(grevlex_basis, MonomialOrder::grevlex(),
                        MonomialOrder::lex(), num_vars);
}

引用了 fglm_convert(), LMCAS::MonomialOrder::grevlex(), grevlex_to_lex() , 以及 LMCAS::MonomialOrder::lex().

被这些函数引用 grevlex_to_lex().

函数调用图:

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

gt()

ExprResult LMCAS::gt	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_facade.cpp 第 205 行定义.

                                                      {
    return relation(lhs, rhs, RelationOp::GT);
}

引用了 GT, gt(), relation() , 以及 rhs.

被这些函数引用 LMCAS::InferenceEngine::Impl::accumulate_sum_relation_sign(), gt() , 以及 LMCAS::InferenceEngine::Impl::product_relation_sign().

函数调用图:

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

has_nonzero_forcing()

bool LMCAS::has_nonzero_forcing ( const std::shared_ptr< SymbolicExpr > & forcing )

static

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

                                                                            {
    return forcing && LMCAS::detail::node(forcing) && !forcing->is_zero();
}

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

被这些函数引用 has_nonzero_forcing(), solve_euler_ode_checked(), solve_euler_ode_impl(), solve_higher_order_ode_checked() , 以及 solve_higher_order_ode_impl().

函数调用图:

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

has_oblique_asymptote()

bool LMCAS::has_oblique_asymptote ( const AsymptoteResult & result, const std::shared_ptr< SymbolicExpr > & slope, const std::shared_ptr< SymbolicExpr > & intercept )

static

在文件 calculus_asymptotes.cpp 第 258 行定义.

{
    for (const auto& entry : result.oblique) {
        if (calculus_utils_expr_equal(entry.first, slope) &&
            calculus_utils_expr_equal(entry.second, intercept)) {
            return true;
        }
    }
    return false;
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_expr_equal(), has_oblique_asymptote() , 以及 LMCAS::AsymptoteResult::oblique.

被这些函数引用 collect_oblique_asymptote() , 以及 has_oblique_asymptote().

函数调用图:

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

hash_combine()

void LMCAS::hash_combine ( std::size_t & seed, std::size_t value )

inline

将一个哈希值混合到种子中,用于组合多个字段的哈希.

参数

seed	当前哈希种子,混合后就地更新
value	要混合的哈希值

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

                                                           {
    seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

引用了 hash_combine() , 以及 value.

被这些函数引用 LMCAS::AddNode::compute_hash(), LMCAS::ComplexNode::compute_hash(), LMCAS::FiniteSetNode::compute_hash(), LMCAS::FunctionNode::compute_hash(), LMCAS::IntegralNode::compute_hash(), LMCAS::IntervalNode::compute_hash(), LMCAS::LimitNode::compute_hash(), LMCAS::LogicalNode::compute_hash(), LMCAS::MatrixNode::compute_hash(), LMCAS::MembershipNode::compute_hash(), LMCAS::MultiplyNode::compute_hash(), LMCAS::PiecewiseNode::compute_hash(), LMCAS::PowerNode::compute_hash(), LMCAS::ProductNode::compute_hash(), LMCAS::QuantifierNode::compute_hash(), LMCAS::QuantityNode::compute_hash(), LMCAS::RelationalNode::compute_hash(), LMCAS::RootOfNode::compute_hash(), LMCAS::SetBuilderNode::compute_hash(), LMCAS::SummationNode::compute_hash(), LMCAS::TransformNode::compute_hash(), LMCAS::UninterpretedFunctionNode::compute_hash(), LMCAS::VariableNode::compute_hash() , 以及 hash_combine().

函数调用图:

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

hensel_lift_checked()

HenselLiftResult LMCAS::hensel_lift_checked	(	const Polynomial< BigInt > &	poly,
		const std::vector< Polynomial< ModInt > > &	mod_factors,
		int64_t	prime,
		int	lift_bound )

Hensel 提升:将模 p 因子提升到 mod p^k.

将 Berlekamp 分解得到的模 p 不可约因子通过二次 Hensel 提升 升至 mod p^k,其中 k 由 Mignotte 界确定.

流程:

1. 将 Polynomial<ModInt> 因子转换为 vector<BigInt> 内部表示
2. 调用 hl_multi_factor_lift 执行多因子提升
3. 将结果转换回 Polynomial<BigInt>

参数

[in]	poly	整系数多项式
[in]	mod_factors	模 p 下的不可约因子
[in]	prime	素数 p
[in]	lift_bound	提升次数上界 k(若为 0 则自动计算)

返回

提升后的整系数因子列表(系数在对称表示 [-p^k/2, p^k/2] 下)

将原始多项式转换为系数向量

将 Polynomial<ModInt> 因子转换为 vector<BigInt> 表示

若调用方未指定提升界,则自动计算

执行多因子 Hensel 提升

将结果转换回 Polynomial<BigInt>

在文件 hensel_lift.cpp 第 695 行定义.

                    {
    constexpr const char* operation = "hensel_lift";
 
    /// 将原始多项式转换为系数向量
    std::vector<BigInt> f_vec = poly.coeffs;
 
    /// 将 Polynomial<ModInt> 因子转换为 vector<BigInt> 表示
    std::vector<std::vector<BigInt>> factor_vecs;
    factor_vecs.reserve(mod_factors.size());
    for (const auto& mf : mod_factors) {
        std::vector<BigInt> fv;
        fv.reserve(mf.coeffs.size());
        for (const auto& c : mf.coeffs) {
            fv.push_back(BigInt(static_cast<std::int64_t>(c.value())));
        }
        factor_vecs.push_back(std::move(fv));
    }
 
    auto valid = hl_validate_lift_inputs(poly, factor_vecs, prime);
    if (!valid) return HenselLiftResult::failure(valid.error());
 
    /// 若调用方未指定提升界,则自动计算
    int k = lift_bound;
    if (k <= 0) {
        k = hl_compute_lift_height(poly, prime);
    }
 
    /// 执行多因子 Hensel 提升
    std::vector<std::vector<BigInt>> lifted_vecs;
    try {
        lifted_vecs = hl_multi_factor_lift(f_vec, factor_vecs, prime, k);
    } catch (const std::exception& ex) {
        return HenselLiftResult::failure(CasErrc::InternalInvariant,
                                         ex.what(),
                                         operation);
    }
 
    /// 将结果转换回 Polynomial<BigInt>
    std::vector<Polynomial<BigInt>> result;
    result.reserve(lifted_vecs.size());
    for (auto& lv : lifted_vecs) {
        result.emplace_back(std::move(lv), poly.variable_name);
    }
 
    return HenselLiftResult::success(std::move(result));
}

引用了 c, LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Result< std::vector< Polynomial< BigInt > > >::failure(), hensel_lift_checked(), hl_compute_lift_height(), hl_multi_factor_lift(), hl_validate_lift_inputs(), InternalInvariant, lift_bound, mod_factors, prime, LMCAS::Result< std::vector< Polynomial< BigInt > > >::success() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_and_combine() , 以及 hensel_lift_checked().

函数调用图:

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

hessian()

std::shared_ptr< SymbolicExpr > LMCAS::hessian	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

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

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "hessian");
    return hessian_impl(f, vars, transform_budget);
}

引用了 context, hessian(), LMCAS::vector_calculus_detail::hessian_impl() , 以及 vars.

被这些函数引用 hessian().

函数调用图:

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

hessian_checked() [1/2]

VectorCalculusExprResult LMCAS::hessian_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_matrices.cpp 第 111 行定义.

{
    ComputationContext context;
    return hessian_checked(f, vars, context);
}

引用了 context, hessian_checked() , 以及 vars.

函数调用图:

hessian_checked() [2/2]

VectorCalculusExprResult LMCAS::hessian_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "hessian");
    const std::string operation = "hessian";
    auto valid = vector_calculus_validate_expr_vars(f, vars, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
    auto step = context.consume_steps(vars.size() * vars.size(), operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
    try {
        return vector_calculus_wrap_expr(hessian_impl(f, vars, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "vector calculus allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), hessian_checked(), LMCAS::vector_calculus_detail::hessian_impl(), InternalInvariant, ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_expr().

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

函数调用图:

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

hl_binomial()

BigInt LMCAS::hl_binomial ( int n, int k )

static

计算二项式系数 C(n, k).

使用乘法公式 C(n, k) = n! / (k! * (n-k)!) 逐步计算; BigInt 承载全部中间结果,k = min(k, n-k) 缩短迭代路径.

参数

[in]	n	上标(非负整数)
[in]	k	下标(0 <= k <= n)

返回

C(n, k) 的精确值

利用对称性 C(n, k) = C(n, n-k)

在文件 hensel_lift.cpp 第 39 行定义.

                                        {
    if (k < 0 || k > n) return BigInt(0);
    if (k == 0 || k == n) return BigInt(1);
 
    /// 利用对称性 C(n, k) = C(n, n-k)
    if (k > n - k) {
        k = n - k;
    }
 
    BigInt result(1);
    for (int i = 0; i < k; ++i) {
        result = result * BigInt(n - i);
        result = result / BigInt(i + 1);
    }
    return result;
}

引用了 hl_binomial().

被这些函数引用 hl_binomial() , 以及 hl_mignotte_bound().

函数调用图:

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

hl_coeff_vectors_equal()

bool LMCAS::hl_coeff_vectors_equal ( std::vector< BigInt > left, std::vector< BigInt > right )

static

在文件 hensel_lift.cpp 第 367 行定义.

                                                            {
    while (!left.empty() && left.back().is_zero()) left.pop_back();
    while (!right.empty() && right.back().is_zero()) right.pop_back();
    const std::size_t size = std::max(left.size(), right.size());
    left.resize(size, BigInt(0));
    right.resize(size, BigInt(0));
    return left == right;
}

引用了 hl_coeff_vectors_equal() , 以及 right.

被这些函数引用 hl_coeff_vectors_equal() , 以及 hl_validate_lift_inputs().

函数调用图:

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

hl_compute_lift_height()

int LMCAS::hl_compute_lift_height ( const Polynomial< BigInt > & poly, int64_t prime )

static

计算 Hensel 提升所需的高度 k.

提升高度 k 需满足 p^k > 2 * B * |lc(f)|,其中:

• B 为 Mignotte 界
• lc(f) 为多项式首项系数
• p 为选定的素数

通过连续乘以 p 直至超过阈值确定 k,使界计算保持在整数域内.

参数

[in]	poly	整系数多项式(非零,次数 >= 1)
[in]	prime	选定的素数 p

返回

所需的提升高度 k(正整数)

阈值 threshold = 2 * B * |lc(f)|

计算最小 k 使得 p^k > threshold

至少提升 1 次

在文件 hensel_lift.cpp 第 129 行定义.

                                                                                 {
    if (poly.is_zero() || poly.degree() <= 0) return 1;
 
    BigInt B = hl_mignotte_bound(poly);
    BigInt lc = poly.lead_coeff().abs();
 
    /// 阈值 threshold = 2 * B * |lc(f)|
    BigInt threshold = BigInt(2) * B * lc;
 
    /// 计算最小 k 使得 p^k > threshold
    BigInt p_power(1);
    BigInt big_p(static_cast<std::int64_t>(prime));
    int k = 0;
 
    while (p_power <= threshold) {
        p_power = p_power * big_p;
        k++;
    }
 
    /// 至少提升 1 次
    if (k < 1) k = 1;
 
    return k;
}

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

被这些函数引用 hensel_lift_checked() , 以及 hl_compute_lift_height().

函数调用图:

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

hl_extended_gcd_poly()

std::pair< std::vector< BigInt >, std::vector< BigInt > > LMCAS::hl_extended_gcd_poly ( const std::vector< BigInt > & g, const std::vector< BigInt > & h, const BigInt & m )

static

计算两个多项式在模 m 下的扩展 GCD 的 Bezout 系数.

给定互素多项式 g, h(mod m),求 s, t 使得 s*g + t*h == 1 (mod m), 且 deg(s) < deg(h), deg(t) < deg(g).

使用扩展欧几里得算法在 Z/mZ[x] 上运算.

参数

[in]	g	第一个多项式系数向量
[in]	h	第二个多项式系数向量
[in]	m	模数

返回

pair(s, t) 满足 s*g + t*h == 1 (mod m)

扩展欧几里得算法:r0 = g, r1 = h s0*g + t0*h = r0, s1*g + t1*h = r1

r_new = r0 - q*r1

s_new = s0 - q*s1

t_new = t0 - q*t1

r0 = gcd,应为常数(可逆元) 归一化使 gcd = 1

去除高次零系数

在文件 hensel_lift.cpp 第 526 行定义.

                                      {
    /// 扩展欧几里得算法:r0 = g, r1 = h
    /// s0*g + t0*h = r0, s1*g + t1*h = r1
    std::vector<BigInt> r0 = g, r1 = h;
    std::vector<BigInt> s0 = {BigInt(1)}, s1 = {};  // s0=1, s1=0
    std::vector<BigInt> t0 = {}, t1 = {BigInt(1)};  // t0=0, t1=1
 
    while (!r1.empty()) {
        auto [q, r] = hl_poly_divmod(r0, r1, m);
 
        /// r_new = r0 - q*r1
        std::vector<BigInt> r_new = r;
 
        /// s_new = s0 - q*s1
        std::vector<BigInt> qs1 = hl_poly_mul_mod(q, s1, m);
        std::vector<BigInt> s_new = hl_poly_sub_mod(s0, qs1, m);
 
        /// t_new = t0 - q*t1
        std::vector<BigInt> qt1 = hl_poly_mul_mod(q, t1, m);
        std::vector<BigInt> t_new = hl_poly_sub_mod(t0, qt1, m);
 
        r0 = r1; r1 = r_new;
        s0 = s1; s1 = s_new;
        t0 = t1; t1 = t_new;
    }
 
    /// r0 = gcd,应为常数(可逆元)
    /// 归一化使 gcd = 1
    if (!r0.empty() && r0[0] != BigInt(1)) {
        BigInt inv = hl_mod_inverse(r0[0], m);
        for (auto& c : s0) {
            c = detail::symmetric_remainder(c * inv, m);
        }
        for (auto& c : t0) {
            c = detail::symmetric_remainder(c * inv, m);
        }
    }
 
    /// 去除高次零系数
    while (!s0.empty() && s0.back().is_zero()) s0.pop_back();
    while (!t0.empty() && t0.back().is_zero()) t0.pop_back();
 
    return {s0, t0};
}

引用了 c, hl_extended_gcd_poly(), hl_mod_inverse(), hl_poly_divmod(), hl_poly_mul_mod(), hl_poly_sub_mod(), r , 以及 LMCAS::detail::symmetric_remainder().

被这些函数引用 hl_extended_gcd_poly() , 以及 hl_multi_factor_lift().

函数调用图:

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

hl_is_prime()

bool LMCAS::hl_is_prime ( int64_t value )

static

在文件 hensel_lift.cpp 第 357 行定义.

                                       {
    if (value < 2) return false;
    if (value == 2) return true;
    if (value % 2 == 0) return false;
    for (int64_t divisor = 3; divisor <= value / divisor; divisor += 2) {
        if (value % divisor == 0) return false;
    }
    return true;
}

引用了 hl_is_prime() , 以及 value.

被这些函数引用 hl_is_prime() , 以及 hl_validate_lift_inputs().

函数调用图:

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

hl_l2_norm_squared()

BigInt LMCAS::hl_l2_norm_squared ( const Polynomial< BigInt > & poly )

static

计算多项式系数的 L2 范数的平方.

即 ||f||_2^2 = sum(a_i^2),其中 a_i 为多项式各项系数.

参数

[in]

poly

整系数多项式

返回

系数平方和(BigInt 精确值)

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

                                                                 {
    BigInt sum(0);
    for (const auto& c : poly.coeffs) {
        sum = sum + c * c;
    }
    return sum;
}

引用了 c, LMCAS::Polynomial< CoeffType >::coeffs , 以及 hl_l2_norm_squared().

被这些函数引用 hl_l2_norm_squared() , 以及 hl_mignotte_bound().

函数调用图:

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

hl_mignotte_bound()

BigInt LMCAS::hl_mignotte_bound ( const Polynomial< BigInt > & poly )

static

计算多项式的 Mignotte 界.

对于次数为 n 的多项式 f(x),其任意因子的系数绝对值上界为: B = C(n, floor(n/2)) * ||f||_2

其中 C(n, k) 为二项式系数,||f||_2 为系数向量的 L2 范数.

实现使用 B^2 = C(n, floor(n/2))^2 * ||f||_2^2 在整数域内计算, 最后由 BigInt::sqrt() 求向上取整的整数平方根.

参数

[in]

poly

整系数多项式(非零,次数 >= 1)

返回

Mignotte 界 B

参见

Mignotte, M. "An inequality about factors of polynomials." Mathematics of Computation, 28(128), 1974.

C(n, floor(n/2))

||f||_2^2

B^2 = binom^2 * norm_sq

B = ceil(sqrt(B^2)) BigInt::sqrt() 返回 floor(sqrt(x)),需要检查是否精确

在文件 hensel_lift.cpp 第 91 行定义.

                                                                {
    int n = poly.degree();
    if (n <= 0) return BigInt(1);
 
    /// C(n, floor(n/2))
    BigInt binom = hl_binomial(n, n / 2);
 
    /// ||f||_2^2
    BigInt norm_sq = hl_l2_norm_squared(poly);
 
    /// B^2 = binom^2 * norm_sq
    BigInt b_squared = binom * binom * norm_sq;
 
    /// B = ceil(sqrt(B^2))
    /// BigInt::sqrt() 返回 floor(sqrt(x)),需要检查是否精确
    BigInt b = b_squared.sqrt();
    if (b * b < b_squared) {
        b = b + BigInt(1);
    }
 
    return b;
}

引用了 b, LMCAS::Polynomial< CoeffType >::degree(), hl_binomial(), hl_l2_norm_squared() , 以及 hl_mignotte_bound().

被这些函数引用 hl_compute_lift_height() , 以及 hl_mignotte_bound().

函数调用图:

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

hl_mod_inverse()

BigInt LMCAS::hl_mod_inverse ( const BigInt & a, const BigInt & m )

static

计算 BigInt 在模 m 下的乘法逆元.

使用扩展欧几里得算法求 a 在 Z/mZ 中的逆元. 要求 gcd(a, m) = 1.

参数

[in]	a	待求逆的整数
[in]	m	模数

返回

a 的模逆元,归约到 [0, m)

异常

std::domain_error

若 a 不可逆

扩展欧几里得:求 s 使得 a*s == 1 (mod m)

r0 应为 gcd(a, m) = 1

若 gcd 为 -1,调整符号

在文件 hensel_lift.cpp 第 267 行定义.

                                                               {
    /// 扩展欧几里得:求 s 使得 a*s == 1 (mod m)
    BigInt r0 = m, r1 = a % m;
    if (r1.is_negative()) r1 = r1 + m;
 
    BigInt s0(0), s1(1);
 
    while (!r1.is_zero()) {
        BigInt q = r0 / r1;
        BigInt r_new = r0 - q * r1;
        BigInt s_new = s0 - q * s1;
 
        r0 = r1;
        r1 = r_new;
        s0 = s1;
        s1 = s_new;
    }
 
    /// r0 应为 gcd(a, m) = 1
    if (r0 != BigInt(1) && r0 != BigInt(-1)) {
        throw std::domain_error("hl_mod_inverse: element not invertible");
    }
 
    /// 若 gcd 为 -1,调整符号
    if (r0.is_negative()) {
        s0 = s0.negate();
    }
 
    BigInt result = s0 % m;
    if (result.is_negative()) result = result + m;
    return result;
}

引用了 a , 以及 hl_mod_inverse().

被这些函数引用 hl_extended_gcd_poly(), hl_mod_inverse() , 以及 hl_poly_divmod().

函数调用图:

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

hl_multi_factor_lift()

std::vector< std::vector< BigInt > > LMCAS::hl_multi_factor_lift ( const std::vector< BigInt > & f, const std::vector< std::vector< BigInt > > & factors, int64_t prime, int target_k )

static

多因子 Hensel 提升:将 k 个模 p 因子同时提升到 mod p^target_k.

使用顺序剥离策略:

1. 将 f 分解为 g_1 和 h_1 = g_2*g₃*...*gₖ
2. 对 (g_1, h_1) 执行二因子提升
3. 递归对 h_1 继续剥离下一个因子

每步提升通过反复调用 hl_two_factor_lift 实现二次提升(mod p -> p^2 -> p^4 -> ...), 直到模数达到或超过 p^target_k.

参数

[in]	f	原始多项式系数向量(升幂排列)
[in]	factors	模 p 下的因子列表(各因子系数向量)
[in]	prime	素数 p
[in]	target_k	目标提升高度(提升到 mod p^target_k)

返回

提升后的因子列表(各因子系数在对称表示下)

前置条件

f == factors[0] * factors[1] * ... * factors[k-1] (mod p)

各因子两两互素 (mod p)

参见

Zassenhaus, H. "On Hensel factorization, I." Journal of Number Theory, 1(3), 1969.

单因子:直接归约到目标模数

计算目标模数 p^target_k

顺序剥离策略:逐个提升因子

当前待分解的多项式(初始为 f)

剩余因子列表

取出第一个因子 g

计算 h = 剩余因子的乘积 (mod p)

计算 Bezout 系数 s, t 使得 s*g + t*h == 1 (mod p)

构造初始提升状态

反复二次提升直到模数 >= target_mod

提取提升后的 g(已提升到 target_mod)

更新 remaining 为提升后的 h

更新 remaining_factors:去掉第一个,后续因子保持不变

最后一个因子就是 remaining

在文件 hensel_lift.cpp 第 597 行定义.

                  {
 
    if (factors.empty()) return {};
    if (factors.size() == 1) {
        /// 单因子:直接归约到目标模数
        BigInt target_mod(1);
        BigInt big_p(static_cast<std::int64_t>(prime));
        for (int i = 0; i < target_k; ++i) {
            target_mod = target_mod * big_p;
        }
        std::vector<BigInt> result = f;
        hl_reduce_coeffs(result, target_mod);
        return {result};
    }
 
    BigInt big_p(static_cast<std::int64_t>(prime));
    BigInt initial_mod(static_cast<std::int64_t>(prime));
 
    /// 计算目标模数 p^target_k
    BigInt target_mod(1);
    for (int i = 0; i < target_k; ++i) {
        target_mod = target_mod * big_p;
    }
 
    /// 顺序剥离策略:逐个提升因子
    std::vector<std::vector<BigInt>> lifted_factors;
    lifted_factors.reserve(factors.size());
 
    /// 当前待分解的多项式(初始为 f)
    std::vector<BigInt> remaining = f;
    hl_reduce_coeffs(remaining, target_mod);
 
    /// 剩余因子列表
    std::vector<std::vector<BigInt>> remaining_factors = factors;
 
    for (size_t i = 0; i < factors.size() - 1; ++i) {
        /// 取出第一个因子 g
        std::vector<BigInt> g = remaining_factors[0];
 
        /// 计算 h = 剩余因子的乘积 (mod p)
        std::vector<BigInt> h = remaining_factors[1];
        for (size_t j = 2; j < remaining_factors.size(); ++j) {
            h = hl_poly_mul_mod(h, remaining_factors[j], initial_mod);
        }
 
        /// 计算 Bezout 系数 s, t 使得 s*g + t*h == 1 (mod p)
        auto [s, t] = hl_extended_gcd_poly(g, h, initial_mod);
 
        /// 构造初始提升状态
        HenselLiftPair state{g, h, s, t, initial_mod};
 
        /// 反复二次提升直到模数 >= target_mod
        while (state.modulus < target_mod) {
            state = hl_two_factor_lift(remaining, state);
        }
 
        /// 提取提升后的 g(已提升到 target_mod)
        std::vector<BigInt> lifted_g = state.g;
        hl_reduce_coeffs(lifted_g, target_mod);
        lifted_factors.push_back(lifted_g);
 
        /// 更新 remaining 为提升后的 h
        remaining = state.h;
        hl_reduce_coeffs(remaining, target_mod);
 
        /// 更新 remaining_factors:去掉第一个,后续因子保持不变
        remaining_factors.erase(remaining_factors.begin());
    }
 
    /// 最后一个因子就是 remaining
    hl_reduce_coeffs(remaining, target_mod);
    lifted_factors.push_back(remaining);
 
    return lifted_factors;
}

引用了 LMCAS::HenselLiftPair::g, LMCAS::HenselLiftPair::h, hl_extended_gcd_poly(), hl_multi_factor_lift(), hl_poly_mul_mod(), hl_reduce_coeffs(), hl_two_factor_lift(), lifted_factors, LMCAS::HenselLiftPair::modulus, prime , 以及 t.

被这些函数引用 hensel_lift_checked() , 以及 hl_multi_factor_lift().

函数调用图:

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

hl_poly_add_mod()

std::vector< BigInt > LMCAS::hl_poly_add_mod ( const std::vector< BigInt > & a, const std::vector< BigInt > & b, const BigInt & m )

static

多项式加法(BigInt 系数),结果模 m 归约.

参数

[in]	a	第一个多项式系数向量
[in]	b	第二个多项式系数向量
[in]	m	模数

返回

和多项式的系数向量

在文件 hensel_lift.cpp 第 239 行定义.

                                                            {
    size_t n = std::max(a.size(), b.size());
    std::vector<BigInt> result(n, BigInt(0));
 
    for (size_t i = 0; i < n; ++i) {
        BigInt ai = (i < a.size()) ? a[i] : BigInt(0);
        BigInt bi = (i < b.size()) ? b[i] : BigInt(0);
        result[i] = ai + bi;
    }
 
    hl_reduce_coeffs(result, m);
    return result;
}

引用了 a, b, hl_poly_add_mod() , 以及 hl_reduce_coeffs().

被这些函数引用 hl_poly_add_mod() , 以及 hl_two_factor_lift().

函数调用图:

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

hl_poly_divmod()

std::pair< std::vector< BigInt >, std::vector< BigInt > > LMCAS::hl_poly_divmod ( const std::vector< BigInt > & a, const std::vector< BigInt > & b, const BigInt & m )

static

多项式带余除法(BigInt 系数),模 m 下运算.

计算 a(x) = q(x) * b(x) + r(x),其中 deg(r) < deg(b). 要求 b 的首项系数在 Z/mZ 中可逆. 所有系数归约到对称表示.

参数

[in]	a	被除数多项式系数向量
[in]	b	除数多项式系数向量
[in]	m	模数

返回

pair(商, 余数) 的系数向量

首项系数的逆元

余数截断到 deg < deg_b

在文件 hensel_lift.cpp 第 314 行定义.

                                {
    if (b.empty()) {
        throw std::runtime_error("hl_poly_divmod: division by zero polynomial");
    }
 
    int deg_a = static_cast<int>(a.size()) - 1;
    int deg_b = static_cast<int>(b.size()) - 1;
 
    if (deg_a < deg_b) {
        std::vector<BigInt> r = a;
        hl_reduce_coeffs(r, m);
        return {{}, r};
    }
 
    /// 首项系数的逆元
    BigInt lc_inv = hl_mod_inverse(b.back(), m);
 
    std::vector<BigInt> remainder = a;
    std::vector<BigInt> quotient(deg_a - deg_b + 1, BigInt(0));
 
    for (int i = deg_a; i >= deg_b; --i) {
        BigInt coeff = detail::symmetric_remainder(remainder[i], m);
        if (coeff.is_zero()) continue;
 
        BigInt factor = detail::symmetric_remainder(coeff * lc_inv, m);
        quotient[i - deg_b] = factor;
 
        for (int j = 0; j <= deg_b; ++j) {
            remainder[i - deg_b + j] = remainder[i - deg_b + j] - factor * b[j];
            remainder[i - deg_b + j] =
                detail::symmetric_remainder(remainder[i - deg_b + j], m);
        }
    }
 
    /// 余数截断到 deg < deg_b
    std::vector<BigInt> rem(remainder.begin(), remainder.begin() + deg_b);
    hl_reduce_coeffs(quotient, m);
    hl_reduce_coeffs(rem, m);
    return {quotient, rem};
}

引用了 a, b, hl_mod_inverse(), hl_poly_divmod(), hl_reduce_coeffs(), r , 以及 LMCAS::detail::symmetric_remainder().

被这些函数引用 hl_extended_gcd_poly(), hl_poly_divmod() , 以及 hl_two_factor_lift().

函数调用图:

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

hl_poly_mul_mod()

std::vector< BigInt > LMCAS::hl_poly_mul_mod ( const std::vector< BigInt > & a, const std::vector< BigInt > & b, const BigInt & m )

static

多项式乘法(BigInt 系数),结果模 m 归约.

计算两个系数向量表示的多项式之积,所有系数归约到对称表示 [-m/2, m/2).

参数

[in]	a	第一个多项式的系数向量
[in]	b	第二个多项式的系数向量
[in]	m	模数

返回

乘积多项式的系数向量

在文件 hensel_lift.cpp 第 185 行定义.

                                                            {
    if (a.empty() || b.empty()) return {};
 
    size_t n = a.size() + b.size() - 1;
    std::vector<BigInt> result(n, BigInt(0));
 
    for (size_t i = 0; i < a.size(); ++i) {
        if (a[i].is_zero()) continue;
        for (size_t j = 0; j < b.size(); ++j) {
            if (b[j].is_zero()) continue;
            result[i + j] = result[i + j] + a[i] * b[j];
        }
    }
 
    hl_reduce_coeffs(result, m);
    return result;
}

引用了 a, b, hl_poly_mul_mod() , 以及 hl_reduce_coeffs().

被这些函数引用 hl_extended_gcd_poly(), hl_multi_factor_lift(), hl_poly_mul_mod(), hl_two_factor_lift() , 以及 hl_validate_lift_inputs().

函数调用图:

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

hl_poly_sub_mod()

std::vector< BigInt > LMCAS::hl_poly_sub_mod ( const std::vector< BigInt > & a, const std::vector< BigInt > & b, const BigInt & m )

static

多项式减法(BigInt 系数),结果模 m 归约.

参数

[in]	a	被减数多项式系数向量
[in]	b	减数多项式系数向量
[in]	m	模数

返回

差多项式的系数向量

在文件 hensel_lift.cpp 第 214 行定义.

                                                            {
    size_t n = std::max(a.size(), b.size());
    std::vector<BigInt> result(n, BigInt(0));
 
    for (size_t i = 0; i < n; ++i) {
        BigInt ai = (i < a.size()) ? a[i] : BigInt(0);
        BigInt bi = (i < b.size()) ? b[i] : BigInt(0);
        result[i] = ai - bi;
    }
 
    hl_reduce_coeffs(result, m);
    return result;
}

引用了 a, b, hl_poly_sub_mod() , 以及 hl_reduce_coeffs().

被这些函数引用 hl_extended_gcd_poly(), hl_poly_sub_mod() , 以及 hl_two_factor_lift().

函数调用图:

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

hl_reduce_coeffs()

void LMCAS::hl_reduce_coeffs ( std::vector< BigInt > & poly, const BigInt & m )

static

对多项式系数向量执行模归约(对称表示).

将向量中每个系数归约到 [-m/2, m/2) 区间,并去除高次零系数.

参数

[in,out]	poly	系数向量(就地修改)
[in]	m	模数

去除高次零系数

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

                                                                       {
    for (auto& c : poly) {
        c = detail::symmetric_remainder(c, m);
    }
    /// 去除高次零系数
    while (!poly.empty() && poly.back().is_zero()) {
        poly.pop_back();
    }
}

引用了 c, hl_reduce_coeffs() , 以及 LMCAS::detail::symmetric_remainder().

被这些函数引用 hl_multi_factor_lift(), hl_poly_add_mod(), hl_poly_divmod(), hl_poly_mul_mod(), hl_poly_sub_mod(), hl_reduce_coeffs(), hl_two_factor_lift() , 以及 hl_validate_lift_inputs().

函数调用图:

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

hl_two_factor_lift()

HenselLiftPair LMCAS::hl_two_factor_lift	(	const std::vector< BigInt > &	f,
		const HenselLiftPair &	current )

执行一步二次 Hensel 提升:mod m -> mod m^2.

给定 f == g*h (mod m) 且 s*g + t*h == 1 (mod m), 计算 g', h', s', t' 使得 f == g'*h' (mod m^2) 且 s'*g' + t'*h' == 1 (mod m^2).

算法步骤:

1. 计算误差 e = f - g*h(所有系数应被 m 整除)
2. 计算修正项:(q, r) = divmod(s*e, h) over Z/m^2Z
   • h' = h + r (mod m^2)
   • g' = g + t*e + q*g (mod m^2)
3. 更新 Bezout 系数:
   • b = s*g' + t*h' - 1 (mod m^2)
   • (c, d) = divmod(s*b, h') over Z/m^2Z
   • s' = s - d (mod m^2)
   • t' = t - t*b - c*g' (mod m^2)

参数

[in]	f	原始多项式系数向量
[in]	current	当前提升状态(g, h, s, t, modulus=m)

返回

提升后的状态(g', h', s', t', modulus=m^2)

前置条件

f == g*h (mod m)

s*g + t*h == 1 (mod m)

deg(s) < deg(h), deg(t) < deg(g)

参见

Zassenhaus, H. "On Hensel factorization, I." Journal of Number Theory, 1(3), 1969.

新模数 m^2 = m * m

步骤 1:计算误差 e = f - g*h (mod m^2)

步骤 2:计算修正项 se = s * e (mod m^2)

(q, r) = divmod(se, h) over Z/m^2Z,其中 deg(r) < deg(h)

g' = g + t*e + q*g (mod m^2)

h' = h + r (mod m^2)

步骤 3:更新 Bezout 系数 b = s*g' + t*h' - 1 (mod m^2)

减去常数 1

(c, d) = divmod(s*b, h') over Z/m^2Z

s' = s - d (mod m^2)

t' = t - t*b - c*g' (mod m^2)

在文件 hensel_lift.cpp 第 450 行定义.

                                   {
 
    const auto& g = current.g;
    const auto& h = current.h;
    const auto& s = current.s;
    const auto& t = current.t;
    const BigInt& m = current.modulus;
 
    /// 新模数 m^2 = m * m
    BigInt m2 = m * m;
 
    /// 步骤 1:计算误差 e = f - g*h (mod m^2)
    std::vector<BigInt> gh = hl_poly_mul_mod(g, h, m2);
    std::vector<BigInt> e = hl_poly_sub_mod(f, gh, m2);
 
    /// 步骤 2:计算修正项
    /// se = s * e (mod m^2)
    std::vector<BigInt> se = hl_poly_mul_mod(s, e, m2);
 
    /// (q, r) = divmod(se, h) over Z/m^2Z,其中 deg(r) < deg(h)
    auto [q, r] = hl_poly_divmod(se, h, m2);
 
    /// g' = g + t*e + q*g (mod m^2)
    std::vector<BigInt> te = hl_poly_mul_mod(t, e, m2);
    std::vector<BigInt> qg = hl_poly_mul_mod(q, g, m2);
    std::vector<BigInt> g_new = hl_poly_add_mod(g, hl_poly_add_mod(te, qg, m2), m2);
    hl_reduce_coeffs(g_new, m2);
 
    /// h' = h + r (mod m^2)
    std::vector<BigInt> h_new = hl_poly_add_mod(h, r, m2);
    hl_reduce_coeffs(h_new, m2);
 
    /// 步骤 3:更新 Bezout 系数
    /// b = s*g' + t*h' - 1 (mod m^2)
    std::vector<BigInt> sg_new = hl_poly_mul_mod(s, g_new, m2);
    std::vector<BigInt> th_new = hl_poly_mul_mod(t, h_new, m2);
    std::vector<BigInt> sg_plus_th = hl_poly_add_mod(sg_new, th_new, m2);
 
    /// 减去常数 1
    std::vector<BigInt> one_poly = {BigInt(1)};
    std::vector<BigInt> b = hl_poly_sub_mod(sg_plus_th, one_poly, m2);
 
    /// (c, d) = divmod(s*b, h') over Z/m^2Z
    std::vector<BigInt> sb = hl_poly_mul_mod(s, b, m2);
    auto [c, d] = hl_poly_divmod(sb, h_new, m2);
 
    /// s' = s - d (mod m^2)
    std::vector<BigInt> s_new = hl_poly_sub_mod(s, d, m2);
    hl_reduce_coeffs(s_new, m2);
 
    /// t' = t - t*b - c*g' (mod m^2)
    std::vector<BigInt> tb = hl_poly_mul_mod(t, b, m2);
    std::vector<BigInt> cg_new = hl_poly_mul_mod(c, g_new, m2);
    std::vector<BigInt> t_new = hl_poly_sub_mod(t, hl_poly_add_mod(tb, cg_new, m2), m2);
    hl_reduce_coeffs(t_new, m2);
 
    return HenselLiftPair{g_new, h_new, s_new, t_new, m2};
}

引用了 b, c, e(), LMCAS::HenselLiftPair::g, LMCAS::HenselLiftPair::h, hl_poly_add_mod(), hl_poly_divmod(), hl_poly_mul_mod(), hl_poly_sub_mod(), hl_reduce_coeffs(), hl_two_factor_lift(), LMCAS::HenselLiftPair::modulus, r, LMCAS::HenselLiftPair::s, LMCAS::HenselLiftPair::t , 以及 t.

被这些函数引用 hl_multi_factor_lift() , 以及 hl_two_factor_lift().

函数调用图:

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

hl_validate_lift_inputs()

Result< void > LMCAS::hl_validate_lift_inputs ( const Polynomial< BigInt > & poly, const std::vector< std::vector< BigInt > > & factor_vecs, int64_t prime )

static

在文件 hensel_lift.cpp 第 377 行定义.

                   {
    constexpr const char* operation = "hensel_lift";
    if (!hl_is_prime(prime)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "Hensel lifting requires a prime modulus",
                                     operation);
    }
    if (poly.is_zero() || poly.degree() <= 0) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "Hensel lifting requires a non-constant polynomial",
                                     operation);
    }
    if (factor_vecs.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "Hensel lifting requires at least one mod-p factor",
                                     operation);
    }
    for (const auto& factor : factor_vecs) {
        if (factor.empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "Hensel lifting factor cannot be zero",
                                         operation);
        }
    }
 
    const BigInt modulus(static_cast<std::int64_t>(prime));
    std::vector<BigInt> product{BigInt(1)};
    for (const auto& factor : factor_vecs) {
        product = hl_poly_mul_mod(product, factor, modulus);
    }
    std::vector<BigInt> reduced_f = poly.coeffs;
    hl_reduce_coeffs(reduced_f, modulus);
    if (!hl_coeff_vectors_equal(product, reduced_f)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "mod-p factors do not multiply to the input polynomial",
                                     operation);
    }
    return Result<void>::success();
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< T >::failure(), hl_coeff_vectors_equal(), hl_is_prime(), hl_poly_mul_mod(), hl_reduce_coeffs(), hl_validate_lift_inputs(), InvalidArgument, LMCAS::Polynomial< CoeffType >::is_zero(), prime , 以及 LMCAS::Result< T >::success().

被这些函数引用 hensel_lift_checked() , 以及 hl_validate_lift_inputs().

函数调用图:

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

imag() [1/2]

ExprResult LMCAS::imag

(

const ExprPtr &

expression

)

在文件 expr_arithmetic.cpp 第 113 行定义.

                                           {
    ComputationContext context;
    return imag(expression, context);
}

引用了 context , 以及 imag.

imag() [2/2]

ExprResult LMCAS::imag	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 108 行定义.

                                                                        {
    return expr_from_complex_result(imag_part_checked(expression, context),
                                    kImagOperation);
}

引用了 context, LMCAS::expr_detail::expr_common::expr_from_complex_result(), imag, imag_part_checked() , 以及 LMCAS::expr_detail::expr_common::kImagOperation.

函数调用图:

imag_part_checked() [1/2]

ExpressionResult LMCAS::imag_part_checked

(

const std::shared_ptr< SymbolicExpr > &

expr

)

在文件 complex_analysis.cpp 第 565 行定义.

                                                                            {
    ComputationContext context;
    return imag_part_checked(expr, context);
}

引用了 context , 以及 imag_part_checked().

函数调用图:

imag_part_checked() [2/2]

ExpressionResult LMCAS::imag_part_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context )

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

                                                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "imag_part";
    auto input = validate_complex_expr_input(expr, context, operation);
    if (!input) return ExpressionResult::failure(input.error());
    if (has_function_of_explicit_complex(LMCAS::detail::node(expr))) {
        return ExpressionResult::failure(
            CasErrc::Inconclusive,
            "imaginary part of functions with complex arguments is outside the current support domain",
            operation);
    }
 
    std::shared_ptr<SymbolicExpr> re, im;
    split_real_imag(LMCAS::detail::node(expr), re, im, context);
    auto simplified = im ? detail::make_expression_ptr(detail::normalize_node(detail::node(im), transform_budget)) : nullptr;
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                          "imaginary part construction failed",
                                          operation);
    }
    return ExpressionResult::success(simplified);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "imag_part");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "imag_part");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "imag_part");
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), imag_part_checked(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 imag(), imag_part_checked() , 以及 imag_part_checked().

函数调用图:

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

imaginary_unit()

ExprResult LMCAS::imaginary_unit

(

)

在文件 expr_values.cpp 第 120 行定义.

                            {
    auto zero = integer(0);
    if (!zero) return ExprResult::failure(zero.error());
    auto one = integer(1);
    if (!one) return ExprResult::failure(one.error());
    return complex(zero.value(), one.value());
}

引用了 complex(), LMCAS::Result< ExprPtr >::failure(), imaginary_unit() , 以及 integer.

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

函数调用图:

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

implicit_diff()

std::shared_ptr< SymbolicExpr > LMCAS::implicit_diff	(	std::shared_ptr< SymbolicExpr >	expression,
		const std::string &	independent_variable,
		const std::string &	dependent_variable )

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

                                         {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expression || independent_variable.empty() || dependent_variable.empty()) {
        return nullptr;
    }
 
    auto numerator = SymbolicExpr::multiply(
        SymbolicExpr::number(-1),
        detail::make_expression_ptr(detail::differentiate_node(detail::node(expression), independent_variable, transform_budget)));
    auto denominator = detail::make_expression_ptr(detail::differentiate_node(detail::node(expression), dependent_variable, transform_budget));
    return SymbolicExpr::divide(numerator, denominator);
}

引用了 context, denominator, LMCAS::detail::differentiate_node(), implicit_diff(), LMCAS::detail::make_expression_ptr() , 以及 LMCAS::detail::node().

被这些函数引用 implicit_diff().

函数调用图:

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

infinity_sign()

int LMCAS::infinity_sign ( const SymbolicExpr & expression, ComputationContext & context )

inline

在文件 inference_engine_impl.hpp 第 33 行定义.

                                                                                      {
    const auto& node = detail::node(expression);
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return function->type() == FunctionNode::FuncType::Infinity ? 1 : 0;
    }
    auto product = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!product) {
        return 0;
    }
 
    bool has_infinity = false;
    int sign = 1;
    for (const auto& operand : product->operands()) {
        auto step = context.consume_steps(1, "inference.infinity");
        if (!step) throw step.error();
        if (auto function = std::dynamic_pointer_cast<const FunctionNode>(operand)) {
            has_infinity = has_infinity ||
                function->type() == FunctionNode::FuncType::Infinity;
        }
        if (auto number = std::dynamic_pointer_cast<const NumberNode>(operand)) {
            if (is_negative_infinity_coefficient(*number)) {
                sign = -sign;
            }
        }
    }
    return has_infinity ? sign : 0;
}

引用了 context, function(), LMCAS::FunctionNode::Infinity, infinity_sign(), is_negative_infinity_coefficient() , 以及 LMCAS::detail::node().

被这些函数引用 infinity_sign() , 以及 limit_expression_checked().

函数调用图:

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

inflection_curve_defined()

Result< bool > LMCAS::inflection_curve_defined ( const std::shared_ptr< SymbolicExpr > & f, const std::shared_ptr< SymbolicExpr > & f_prime, const std::shared_ptr< SymbolicExpr > & f_double_prime, const std::shared_ptr< SymbolicExpr > & point, const std::string & var, const FactsQuery & facts, const std::string & operation, ComputationContext & context )

static

在文件 calculus_curvature.cpp 第 173 行定义.

                                                                                          {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto value = detail::make_expression_ptr(detail::substitute_node(detail::node(f), var, detail::node(point), transform_budget));
    auto first = detail::make_expression_ptr(detail::substitute_node(detail::node(f_prime), var, detail::node(point), transform_budget));
    auto second = detail::make_expression_ptr(detail::substitute_node(detail::node(f_double_prime), var, detail::node(point), transform_budget));
    for (const auto& expression : {value, first, second}) {
        auto defined = detail::query_definedness(detail::node(expression), facts, Domain::Real, context);
        if (!defined) { return Result<bool>::failure(defined.error()); }
        if (defined.value() == Tribool::False) { return false; }
        auto real_value = detail::query_real_value(detail::node(expression), facts, context);
        if (!real_value) { return Result<bool>::failure(real_value.error()); }
        if (real_value.value() == Tribool::False) { return false; }
        if (defined.value() != Tribool::True || real_value.value() != Tribool::True) {
            return Result<bool>::failure(CasErrc::Inconclusive,
                "real curve domain at an inflection candidate is unproved",
                operation);
        }
    }
    return true;
} catch (const CasError& error) {
    return Result<bool>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<bool>::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return Result<bool>::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return Result<bool>::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 context, LMCAS::Result< T >::failure(), False, Inconclusive, inflection_curve_defined(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), point, LMCAS::detail::query_definedness(), LMCAS::detail::query_real_value(), Real, LMCAS::detail::substitute_node(), True , 以及 value.

被这些函数引用 classify_inflection_candidates() , 以及 inflection_curve_defined().

函数调用图:

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

inflection_points_checked() [1/2]

SymbolicExprVectorResult LMCAS::inflection_points_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var )

在文件 calculus_curvature.cpp 第 298 行定义.

{
    ComputationContext context;
    return inflection_points_checked(f, var, context);
}

引用了 context , 以及 inflection_points_checked().

函数调用图:

inflection_points_checked() [2/2]

SymbolicExprVectorResult LMCAS::inflection_points_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		ComputationContext &	context )

在文件 calculus_curvature.cpp 第 238 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "inflection_points";
    auto input = calculus_utils_validate_expr(f, var, context, operation);
    if (!input) {
        return SymbolicExprVectorResult::failure(input.error());
    }
 
    auto first = checked_derivative(f, var, context, operation.c_str());
    if (!first) {
        return SymbolicExprVectorResult::failure(first.error());
    }
    const auto& f_prime = first.value();
 
    auto second = checked_derivative(f_prime, var, context, operation.c_str());
    if (!second) {
        return SymbolicExprVectorResult::failure(second.error());
    }
    const auto& f_double_prime = second.value();
 
    auto equation = detail::make_expression_ptr(detail::normalize_node(detail::node(f_double_prime), transform_budget));
    if (!equation || !LMCAS::detail::node(equation)) { equation = f_double_prime; }
 
    auto solved = solve_equation(equation, var, context, SolveOptions{});
    if (!solved) {
        return SymbolicExprVectorResult::failure(solved.error());
    }
 
    const auto& solutions = solved.value();
    if (std::holds_alternative<EmptySolutions>(solutions)) {
        return SymbolicExprVectorResult::success({});
    }
    std::optional<detail::AssumptionFacts> assumed_facts;
    if (context.assumptions()) { assumed_facts.emplace(*context.assumptions()); }
    const FactsQuery& facts = assumed_facts
        ? static_cast<const FactsQuery&>(*assumed_facts) : detail::no_facts();
    if (const auto* finite = std::get_if<FiniteSolutions>(&solutions)) {
        return classify_inflection_candidates(
            *finite, f, f_prime, f_double_prime, var, facts, context, operation);
    }
 
 
    return SymbolicExprVectorResult::failure(
        CasErrc::Inconclusive,
        "inflection equation is outside the finite exact support domain",
        operation);
} catch (const CasError& error) {
    return SymbolicExprVectorResult::failure(error);
} catch (const std::bad_alloc&) {
    return SymbolicExprVectorResult::failure(CasErrc::ResourceLimit, "allocation failed", "inflection_points");
} catch (const std::length_error& error) {
    return SymbolicExprVectorResult::failure(CasErrc::ResourceLimit, error.what(), "inflection_points");
} catch (const std::exception& error) {
    return SymbolicExprVectorResult::failure(CasErrc::InternalInvariant, error.what(), "inflection_points");
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_validate_expr(), checked_derivative(), classify_inflection_candidates(), context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, inflection_points_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_equation(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 LMCAS::Result< T >::value().

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

函数调用图:

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

integer() [1/2]

ExprResult LMCAS::integer

(

const BigInt &

value

)

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

                                        {
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "integer allocation failed", kIntegerOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kIntegerOperation);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), integer, InternalInvariant, LMCAS::expr_detail::expr_common::kIntegerOperation, ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 value.

函数调用图:

integer() [2/2]

ExprResult LMCAS::integer

(

int

value

)

在文件 expr_values.cpp 第 60 行定义.

                              {
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "integer allocation failed", kIntegerOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kIntegerOperation);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), integer, InternalInvariant, LMCAS::expr_detail::expr_common::kIntegerOperation, ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 value.

函数调用图:

integers()

NumberDomainSet LMCAS::integers

(

)

在文件 expr_number_domains.cpp 第 357 行定义.

                           {
    return NumberDomainSet(NumberDomain::Integers);
}

引用了 Integers , 以及 integers().

被这些函数引用 integers().

函数调用图:

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

integrate_multiple_checked()

Result< SymbolicExpr > LMCAS::integrate_multiple_checked	(	const SymbolicExpr &	integrand,
		const std::vector< IntegrationStep > &	steps,
		Integrator &	integrator,
		ComputationContext &	context )

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

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (!validate_integration_steps(steps)) {
        return Result<SymbolicExpr>::failure(
            CasErrc::InvalidArgument, "invalid multiple integration steps",
            "integrate.multiple");
    }
    auto access = context.consume_steps(0, "integrate.multiple");
    if (!access) return Result<SymbolicExpr>::failure(access.error());
 
    auto current = LMCAS::detail::make_expression_ptr(integrand);
 
    for (const auto& step : steps) {
        auto step_access = context.consume_steps(1, "integrate.multiple");
        if (!step_access) {
            return Result<SymbolicExpr>::failure(step_access.error());
        }
        if (!current) {
            return Result<SymbolicExpr>::failure(
                CasErrc::InternalInvariant, "multiple integration lost its expression",
                "integrate.multiple");
        }
 
 
        const bool definite = static_cast<bool>(step.lower) && static_cast<bool>(step.upper);
 
        if (!definite) {
            auto result = integrator.integrate_checked(*current, step.variable, context);
            if (!result) return result;
            current = LMCAS::detail::make_expression_ptr(result.value());
        } else {
            auto result = integrator.integrate_def_checked(
                *current, step.variable, *step.lower, *step.upper, context);
            if (!result) return result;
            auto res_ptr = LMCAS::detail::make_expression_ptr(result.value());
            auto simp = detail::make_expression_ptr(detail::normalize_node(detail::node(res_ptr), transform_budget));
            current = simp ? simp : res_ptr;
        }
    }
    auto final_access = context.consume_steps(0, "integrate.multiple");
    if (!final_access) return Result<SymbolicExpr>::failure(final_access.error());
 
    return Result<SymbolicExpr>::success(*current);
} catch (const CasError& error) {
    return Result<SymbolicExpr>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<SymbolicExpr>::failure(CasErrc::ResourceLimit, "allocation failed", "integrate_multiple_checked");
} catch (const std::length_error& error) {
    return Result<SymbolicExpr>::failure(CasErrc::ResourceLimit, error.what(), "integrate_multiple_checked");
} catch (const std::exception& error) {
    return Result<SymbolicExpr>::failure(CasErrc::InternalInvariant, error.what(), "integrate_multiple_checked");
}

引用了 context, LMCAS::Result< T >::failure(), integrate_multiple_checked(), integrator, InternalInvariant, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), steps, LMCAS::Result< T >::success() , 以及 validate_integration_steps().

被这些函数引用 divergence_theorem(), greens_theorem(), integrate_multiple_checked(), stokes_theorem(), surface_integral_scalar(), surface_integral_vector() , 以及 vector_calculus_multiple_integral_strict().

函数调用图:

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

integrating_factor_from_antiderivative()

std::shared_ptr< SymbolicExpr > LMCAS::integrating_factor_from_antiderivative ( const std::shared_ptr< SymbolicExpr > & antiderivative, const std::string & variable, ComputationContext & context )

static

在文件 ode_first_order.cpp 第 35 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const auto logarithm_of_variable =
        [&variable](const std::shared_ptr<const SymbolicNode>& node) {
            const auto function =
                std::dynamic_pointer_cast<const FunctionNode>(node);
            if (!function ||
                function->type() != FunctionNode::FuncType::Ln ||
                function->arguments().size() != 1) {
                return false;
            }
            const auto argument = std::dynamic_pointer_cast<const VariableNode>(
                function->arguments().front());
            return argument && !argument->is_constant() && argument->name() == variable;
        };
 
    const auto& root = detail::node(antiderivative);
    if (logarithm_of_variable(root)) {
        return SymbolicExpr::variable(variable);
    }
    const auto product = std::dynamic_pointer_cast<const MultiplyNode>(root);
    if (product && product->operands().size() == 2) {
        for (std::size_t index = 0; index < 2; ++index) {
            if (logarithm_of_variable(product->operands()[index])) {
                auto exponent = detail::make_expression_ptr(
                    product->operands()[1 - index]);
                return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::power(
                    SymbolicExpr::variable(variable), exponent)), transform_budget));
            }
        }
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::exp(antiderivative)), transform_budget));
}

引用了 context, exponent, function(), integrating_factor_from_antiderivative(), LMCAS::FunctionNode::Ln, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 variable.

被这些函数引用 integrating_factor_from_antiderivative(), integrating_factor_from_ratio() , 以及 solve_bernoulli_ode_impl().

函数调用图:

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

integrating_factor_from_ratio()

ExpressionResult LMCAS::integrating_factor_from_ratio ( const std::shared_ptr< SymbolicExpr > & ratio, const std::string & variable, const std::string & excluded_variable, Integrator & integrator, ComputationContext & context )

static

在文件 ode_first_order.cpp 第 308 行定义.

                                                         {
    if (expression_depends_on_variable(
            LMCAS::detail::node(ratio), excluded_variable)) {
        return std::shared_ptr<SymbolicExpr>{};
    }
    auto integrated = integrator.integrate_checked(*ratio, variable, context);
    if (!integrated) { return ExpressionResult::failure(integrated.error()); }
    return integrating_factor_from_antiderivative(
        std::make_shared<SymbolicExpr>(std::move(integrated.value())),
        variable, context);
}

引用了 context, expression_depends_on_variable(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), integrating_factor_from_antiderivative(), integrating_factor_from_ratio(), integrator, LMCAS::detail::node() , 以及 variable.

被这些函数引用 find_integrating_factor_impl() , 以及 integrating_factor_from_ratio().

函数调用图:

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

integration_bounded_exponent()

std::optional< int > LMCAS::integration_bounded_exponent ( const NumberNode & number, int minimum_exponent, int maximum_exponent )

inline

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

                                                                          {
    const auto narrow = [minimum_exponent, maximum_exponent](const BigInt& exponent)
        -> std::optional<int> {
        if (exponent < BigInt(minimum_exponent) || exponent > BigInt(maximum_exponent)) {
            return std::nullopt;
        }
        const auto bounded_exponent = exponent.try_to_int64();
        if (!bounded_exponent) { return std::nullopt; }
        return static_cast<int>(*bounded_exponent);
    };
    const auto& value = number.value();
    if (const auto* exponent = std::get_if<BigInt>(&value)) { return narrow(*exponent); }
    if (const auto* exponent = std::get_if<Rational>(&value)) {
        if (!exponent->is_integer()) { return std::nullopt; }
        return narrow(exponent->to_bigint());
    }
    return std::nullopt;
}

引用了 exponent, integration_bounded_exponent(), LMCAS::NumberNode::value() , 以及 value.

被这些函数引用 integration_bounded_exponent(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_power(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power().

函数调用图:

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

interval() [1/2]

ExprResult LMCAS::interval	(	const ExprPtr &	lower,
		const ExprPtr &	upper,
		bool	lower_closed,
		bool	upper_closed,
		ComputationContext &	context )

在文件 value_facade.cpp 第 46 行定义.

                                                 {
    return make_interval(lower, upper, lower_closed, upper_closed, context);
}

引用了 context, interval(), lower, lower_closed, make_interval(), upper , 以及 upper_closed.

函数调用图:

interval() [2/2]

ExprResult LMCAS::interval	(	ExprPtr	lower,
		ExprPtr	upper,
		bool	lower_closed,
		bool	upper_closed )

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

                                                          {
    ComputationContext context;
    return interval(lower, upper, lower_closed, upper_closed, context);
}

引用了 context, interval(), lower, lower_closed, upper , 以及 upper_closed.

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::MixedRootCollection(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::RootRefinement(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::accept(), adaptive_simpson_numeric(), 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::anonymous_namespace{inequality_solver_polynomial.cpp}::check_interval_forest(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::checked_interval_views(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::checked_piecewise(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::clear_isolation_endpoints(), LMCAS::anonymous_namespace{interval_normalization.cpp}::collect_nonempty_intervals(), LMCAS::detail::anonymous_namespace{exact_algebraic.cpp}::common_root_in_enclosures(), LMCAS::IntervalNode::compare_same_type(), LMCAS::detail::definite::defined_on_interval(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_interval(), LMCAS::detail::evaluate_root_real(), LMCAS::anonymous_namespace{symbolic_set.cpp}::exact_interval_membership(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::find_interval_comma(), LMCAS::InferenceEngine::Impl::function_monotonicity(), LMCAS::detail::inequality_support::include_numeric_root(), LMCAS::detail::inequality_support::include_symbolic_root(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::initialize(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), interval(), interval(), interval_contains_checked(), interval_contains_checked(), interval_is_empty_checked(), interval_is_empty_checked(), interval_to_expr(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::isolate_grid_row(), isolate_roots(), LMCAS::detail::isolate_roots_with_context(), LMCAS::InferenceEngine::Impl::logarithm_monotonicity(), make_membership(), LMCAS::anonymous_namespace{interval_normalization.cpp}::merge_checked_intervals(), LMCAS::detail::mixed_numerical_path(), LMCAS::assumption_detail::parse_interval(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_interval_endpoint(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_interval_expression(), 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::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::process(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_bounds(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_sign_intervals(), LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked(), 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(), refine_root(), LMCAS::detail::refine_root_with_context(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::resample_endpoints(), LMCAS::detail::inequality_support::select_open_intervals(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_imaginary_axis(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::solve_exact_affine_inequality_impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::solve_mixed_equation(), LMCAS::anonymous_namespace{interval_normalization.cpp}::sort_checked_intervals(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::subdivide(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::sum_bounds(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::trim_interval_endpoint(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::validate_interval_endpoints(), validate_property_interval() , 以及 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds().

函数调用图:

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

interval_contains_checked() [1/2]

Result< bool > LMCAS::interval_contains_checked	(	const Interval &	interval,
		double	value )

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

                  {
    ComputationContext context;
    return interval_contains_checked(interval, value, context);
}

引用了 context, interval(), interval_contains_checked() , 以及 value.

函数调用图:

interval_contains_checked() [2/2]

Result< bool > LMCAS::interval_contains_checked	(	const Interval &	interval,
		double	value,
		ComputationContext &	context )

在文件 interval.cpp 第 122 行定义.

                                 {
    constexpr const char* operation = "interval_contains";
    auto point_step = context.consume_steps(1, operation);
    if (!point_step) {
        return Result<bool>::failure(point_step.error());
    }
    auto point = exact_double_rational(value, context, operation);
    if (!point) {
        return Result<bool>::failure(point.error());
    }
    const ComparableEndpoint point_key{
        0, std::move(point.value()), Rational(0), Rational(0)};
 
    auto lower = comparable_endpoint(interval.lower, context, operation);
    if (!lower) {
        return Result<bool>::failure(lower.error());
    }
    auto upper = comparable_endpoint(interval.upper, context, operation);
    if (!upper) {
        return Result<bool>::failure(upper.error());
    }
 
    auto lower_cmp = compare_comparable(point_key, lower.value(), context);
    if (!lower_cmp) {
        return Result<bool>::failure(lower_cmp.error());
    }
    if (lower_cmp.value() < 0 ||
        (lower_cmp.value() == 0 && interval.lower.is_open)) {
        return Result<bool>::success(false);
    }
    auto upper_cmp = compare_comparable(point_key, upper.value(), context);
    if (!upper_cmp) {
        return Result<bool>::failure(upper_cmp.error());
    }
    if (upper_cmp.value() > 0 ||
        (upper_cmp.value() == 0 && interval.upper.is_open)) {
        return Result<bool>::success(false);
    }
    return Result<bool>::success(true);
}

引用了 comparable_endpoint(), compare_comparable(), context, LMCAS::Result< T >::error(), exact_double_rational(), LMCAS::Result< T >::failure(), interval(), interval_contains_checked(), lower, point, LMCAS::Result< T >::success(), upper, LMCAS::Result< T >::value() , 以及 value.

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

函数调用图:

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

interval_covers_checked_impl()

Result< bool > LMCAS::interval_covers_checked_impl ( const Interval & outer, const Interval & inner, ComputationContext & context )

static

判断 outer 是否完全包含 inner。 包含条件为 outer.lower <= inner.lower 且 inner.upper <= outer.upper， 并结合端点的开闭属性判断边界。

在文件 property_intervals.cpp 第 68 行定义.

                                 {
    auto normalized_outer = IntervalUnion::from_intervals_checked({outer}, context);
    if (!normalized_outer) {
        return Result<bool>::failure(normalized_outer.error());
    }
    auto normalized_inner = IntervalUnion::from_intervals_checked({inner}, context);
    if (!normalized_inner) {
        return Result<bool>::failure(normalized_inner.error());
    }
    if (normalized_inner.value().is_empty()) return Result<bool>::success(true);
    if (normalized_outer.value().is_empty()) return Result<bool>::success(false);
 
    auto intersection = normalized_outer.value().intersect_checked(
        normalized_inner.value(), context);
    if (!intersection) {
        return Result<bool>::failure(intersection.error());
    }
    const auto& intersection_intervals = intersection.value().intervals();
    const auto& inner_intervals = normalized_inner.value().intervals();
    if (intersection_intervals.size() != inner_intervals.size()) {
        return Result<bool>::success(false);
    }
    for (std::size_t i = 0; i < inner_intervals.size(); ++i) {
        if (!intervals_equivalent(intersection_intervals[i], inner_intervals[i])) {
            return Result<bool>::success(false);
        }
    }
    return Result<bool>::success(true);
}

引用了 context, LMCAS::Result< T >::failure(), interval_covers_checked_impl(), intervals_equivalent() , 以及 LMCAS::Result< T >::success().

被这些函数引用 interval_covers_checked_impl().

函数调用图:

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

interval_is_empty_checked() [1/2]

Result< bool > LMCAS::interval_is_empty_checked

(

const Interval &

interval

)

在文件 interval.cpp 第 195 行定义.

                                                                 {
    ComputationContext context;
    return interval_is_empty_checked(interval, context);
}

引用了 context, interval() , 以及 interval_is_empty_checked().

函数调用图:

interval_is_empty_checked() [2/2]

Result< bool > LMCAS::interval_is_empty_checked	(	const Interval &	interval,
		ComputationContext &	context )

在文件 interval.cpp 第 173 行定义.

                                 {
    constexpr const char* operation = "interval_is_empty";
    auto lower = comparable_endpoint(interval.lower, context, operation);
    if (!lower) {
        return Result<bool>::failure(lower.error());
    }
    auto upper = comparable_endpoint(interval.upper, context, operation);
    if (!upper) {
        return Result<bool>::failure(upper.error());
    }
    auto comparison = compare_comparable(lower.value(), upper.value(), context);
    if (!comparison) {
        return Result<bool>::failure(comparison.error());
    }
    return Result<bool>::success(
        comparison.value() > 0 ||
        (comparison.value() == 0 &&
         (interval.lower.is_open || interval.upper.is_open)));
}

引用了 comparable_endpoint(), compare_comparable(), context, LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), interval(), interval_is_empty_checked(), lower, LMCAS::Result< T >::success(), upper , 以及 LMCAS::Result< T >::value().

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

函数调用图:

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

interval_to_expr()

std::shared_ptr< const SymbolicNode > LMCAS::interval_to_expr ( const Interval & interval, const std::shared_ptr< const SymbolicNode > & variable )

static

在文件 interval_serialization.cpp 第 316 行定义.

                                                                                 {
    std::shared_ptr<const SymbolicNode> lower;
    std::shared_ptr<const SymbolicNode> upper;
    if (!interval.lower.is_neg_infinity) {
        auto bound = interval.lower.value ? LMCAS::detail::node(interval.lower.value)
            : LMCAS::detail::make_node<NumberNode>(0.0);
        const auto op = interval.lower.is_open ? RelationalNode::Op::GT
                                               : RelationalNode::Op::GEQ;
        lower = LMCAS::detail::make_node<RelationalNode>(variable, bound, op);
    }
    if (!interval.upper.is_pos_infinity) {
        auto bound = interval.upper.value ? LMCAS::detail::node(interval.upper.value)
            : LMCAS::detail::make_node<NumberNode>(0.0);
        const auto op = interval.upper.is_open ? RelationalNode::Op::LT
                                               : RelationalNode::Op::LEQ;
        upper = LMCAS::detail::make_node<RelationalNode>(variable, bound, op);
    }
    if (lower && upper) {
        return LMCAS::detail::make_node<LogicalNode>(lower, upper, LogicalNode::Op::And);
    }
    return lower ? lower : upper;
}

引用了 LMCAS::LogicalNode::And, interval(), interval_to_expr(), lower, LMCAS::detail::make_node(), LMCAS::detail::node(), op, upper, LMCAS::Result< T >::value() , 以及 variable.

被这些函数引用 interval_to_expr().

函数调用图:

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

intervals_equivalent()

bool LMCAS::intervals_equivalent ( const Interval & left, const Interval & right )

static

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

                                                                              {
    return endpoints_equivalent(left.lower, right.lower) &&
           endpoints_equivalent(left.upper, right.upper);
}

引用了 endpoints_equivalent(), intervals_equivalent() , 以及 right.

被这些函数引用 interval_covers_checked_impl() , 以及 intervals_equivalent().

函数调用图:

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

intervals_overlap_checked_impl()

Result< bool > LMCAS::intervals_overlap_checked_impl ( const Interval & a, const Interval & b, ComputationContext & context )

static

判断两个区间是否存在已证明的交集。 端点排序采用受检区间运算；超出支持域时，交集判定仍为未决。

在文件 property_intervals.cpp 第 50 行定义.

                                 {
    auto left = IntervalUnion::from_intervals_checked({a}, context);
    if (!left) return Result<bool>::failure(left.error());
    auto right = IntervalUnion::from_intervals_checked({b}, context);
    if (!right) return Result<bool>::failure(right.error());
    auto intersection = left.value().intersect_checked(right.value(), context);
    if (!intersection) return Result<bool>::failure(intersection.error());
    return Result<bool>::success(!intersection.value().is_empty());
}

引用了 a, b, context, LMCAS::Result< T >::failure(), intervals_overlap_checked_impl(), right , 以及 LMCAS::Result< T >::success().

被这些函数引用 intervals_overlap_checked_impl().

函数调用图:

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

inverse_branch_derivative()

ExpressionResult LMCAS::inverse_branch_derivative ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::vector< std::shared_ptr< SymbolicExpr > > & candidates, const std::string & operation, ComputationContext & context )

static

在文件 calculus_inverse.cpp 第 231 行定义.

    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
        if (candidates.empty()) {
            return ExpressionResult::failure(
                CasErrc::DomainError,
                "inverse point is outside the proven range",
                operation);
        }
        if (candidates.size() != 1) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "inverse derivative requires a unique inverse branch",
                operation);
        }
 
        auto f_prime = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), var, transform_budget));
        if (!f_prime || !LMCAS::detail::node(f_prime)) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "inverse derivative could not construct the derivative",
                operation);
        }
 
        auto f_prime_at_x0 = detail::make_expression_ptr(detail::substitute_node(detail::node(f_prime), var, detail::node(candidates[0]), transform_budget));
        auto simplified_derivative = f_prime_at_x0 ? detail::make_expression_ptr(detail::normalize_node(detail::node(f_prime_at_x0), transform_budget)) : nullptr;
        if (!simplified_derivative || !LMCAS::detail::node(simplified_derivative)) {
            return ExpressionResult::failure(
                CasErrc::InternalInvariant,
                "inverse derivative substitution produced a null expression",
                operation);
        }
 
        if (simplified_derivative->is_zero()) {
            return ExpressionResult::failure(
                CasErrc::DomainError,
                "inverse derivative is undefined where f' is zero",
                operation);
        }
 
        auto result = SymbolicExpr::divide(SymbolicExpr::number(1), simplified_derivative);
        auto simplified = result ? detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget)) : nullptr;
        if (!simplified || !LMCAS::detail::node(simplified)) {
            return ExpressionResult::failure(
                CasErrc::InternalInvariant,
                "inverse derivative result construction failed",
                operation);
        }
        return ExpressionResult::success(simplified);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "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);
}

引用了 context, LMCAS::detail::differentiate_node(), DomainError, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, inverse_branch_derivative(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::substitute_node() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 inverse_branch_derivative() , 以及 inverse_derivative_checked().

函数调用图:

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

inverse_derivative_checked() [1/2]

ExpressionResult LMCAS::inverse_derivative_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	point )

在文件 calculus_inverse.cpp 第 360 行定义.

{
    ComputationContext context;
    return inverse_derivative_checked(f, var, point, context);
}

引用了 context, inverse_derivative_checked() , 以及 point.

函数调用图:

inverse_derivative_checked() [2/2]

ExpressionResult LMCAS::inverse_derivative_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	point,
		ComputationContext &	context )

在文件 calculus_inverse.cpp 第 319 行定义.

{
    const std::string operation = "inverse_derivative";
    auto input = calculus_utils_validate_expr_target(f, var, point, context, operation);
    if (!input) {
        return ExpressionResult::failure(input.error());
    }
    auto step = context.consume_steps(4, operation);
    if (!step) {
        return ExpressionResult::failure(step.error());
    }
 
    try {
        auto eq = SymbolicExpr::add(
            f, SymbolicExpr::multiply(SymbolicExpr::number(-1), point));
 
        std::vector<std::shared_ptr<SymbolicExpr>> candidates;
        auto inverse = inverse_function_checked(f, var, point, context);
        if (inverse) {
            candidates = inverse.value();
        } else {
            return ExpressionResult::failure(inverse.error());
        }
        auto verified = verified_real_inverse_candidates(candidates, eq, var, operation, context);
        if (!verified) {
            return ExpressionResult::failure(verified.error());
        }
        return inverse_branch_derivative(f, var, verified.value(), operation, context);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                           "inverse derivative allocation failed",
                                           operation);
    } catch (const std::exception& e) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                           e.what(), operation);
    }
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_validate_expr_target(), context, e(), eq(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, inverse_branch_derivative(), inverse_derivative_checked(), inverse_function_checked(), point, ResourceLimit , 以及 verified_real_inverse_candidates().

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

函数调用图:

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

inverse_fourier_transform_checked() [1/2]

TransformEngineResult LMCAS::inverse_fourier_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	F,
		const std::string &	omega,
		const std::string &	t )

在文件 transform_fourier.cpp 第 323 行定义.

                        {
    ComputationContext context;
    return inverse_fourier_transform_checked(F, omega, t, context);
}

引用了 context, inverse_fourier_transform_checked() , 以及 t.

函数调用图:

inverse_fourier_transform_checked() [2/2]

TransformEngineResult LMCAS::inverse_fourier_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	F,
		const std::string &	omega,
		const std::string &	t,
		ComputationContext &	context )

在文件 transform_fourier.cpp 第 271 行定义.

                                 {
    const std::string operation = "inverse_fourier_transform";
    auto valid = te_validate_expr_vars(F, omega, t, context, operation);
    if (!valid) return TransformEngineResult::failure(valid.error());
    auto step = context.consume_steps(8, operation);
    if (!step) return TransformEngineResult::failure(step.error());
    try {
        auto expression = inverse_fourier_transform_core(
            F, omega, t, context);
        auto final_access = context.consume_steps(0, operation);
        if (!final_access) {
            return TransformEngineResult::failure(final_access.error());
        }
        auto result = te_wrap_transform_result(expression, operation);
        if (!result) return result;
        AssumptionContext empty_assumptions;
        const auto& assumptions = context.assumptions() ? *context.assumptions() : empty_assumptions;
        std::vector<std::shared_ptr<SymbolicExpr>> conditions;
        auto round_trip = fourier_transform_core(
            expression, t, omega, context, assumptions, conditions);
        if (!round_trip || !conditions.empty() ||
            te_contains_transform(LMCAS::detail::node(round_trip))) {
            return TransformEngineResult::failure(
                CasErrc::Inconclusive,
                "inverse Fourier round trip is not proved", operation);
        }
        auto verified = check_equivalent(round_trip, F, context);
        if (!verified) return TransformEngineResult::failure(verified.error());
        if (!std::holds_alternative<ProvedZeroResidual>(verified.value())) {
            return TransformEngineResult::failure(
                CasErrc::Inconclusive,
                "inverse Fourier round trip is not proved", operation);
        }
        result.value().certificate =
            ExactRoundTripProof{SymbolicExpr::number(0)};
        return result;
    } catch (const CasError& error) {
        return TransformEngineResult::failure(error);
    } catch (const std::bad_alloc&) {
        return TransformEngineResult::failure(CasErrc::ResourceLimit,
                                              "transform allocation failed",
                                              operation);
    } catch (const std::exception& e) {
        return TransformEngineResult::failure(CasErrc::InternalInvariant,
                                              e.what(), operation);
    }
}

引用了 check_equivalent(), context, e(), LMCAS::Result< Verified< EvaluatedTransform > >::failure(), fourier_transform_core(), Inconclusive, InternalInvariant, inverse_fourier_transform_checked(), inverse_fourier_transform_core(), LMCAS::detail::node(), ResourceLimit, t, LMCAS::transform_detail::te_contains_transform(), LMCAS::transform_detail::te_validate_expr_vars() , 以及 LMCAS::transform_detail::te_wrap_transform_result().

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

函数调用图:

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

inverse_fourier_transform_core()

std::shared_ptr< SymbolicExpr > LMCAS::inverse_fourier_transform_core ( const std::shared_ptr< SymbolicExpr > & F, const std::string & omega, const std::string & t, ComputationContext & context )

static

在文件 transform_fourier.cpp 第 216 行定义.

                                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto step = context.consume_steps(1, "inverse_fourier_transform.recursive");
    if (!step) return nullptr;
    if (!F || !LMCAS::detail::node(F)) return nullptr;
    auto tv = SymbolicExpr::variable(t);
    if (!te_depends_on(F, omega)) {
        return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<TransformNode>(
            TransformNode::TransformType::InverseFourier, LMCAS::detail::node(F)->clone(), omega,
            SymbolicFactory::create_variable(t)));
    }
    auto add_node = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(F));
    if (add_node) {
        std::shared_ptr<SymbolicExpr> result;
        for (auto& op : add_node->operands()) {
            auto ift = inverse_fourier_transform_core(
                LMCAS::detail::make_expression_ptr(op), omega, t, context);
            if (!ift) {
                return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<TransformNode>(
                    TransformNode::TransformType::InverseFourier, LMCAS::detail::node(F)->clone(), omega,
                    SymbolicFactory::create_variable(t)));
            }
            result = result ? SymbolicExpr::add(result, ift) : ift;
        }
        return result;
    }
 
    auto canonical = te_abs_fourier(SymbolicExpr::number(1), omega, context);
    if (detail::normalize_node(detail::node(F), transform_budget)->equals(*detail::node(canonical))) {
        auto abs_t = detail::make_expression_ptr(detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Abs,
            std::vector<std::shared_ptr<const SymbolicNode>>{detail::node(tv)}));
        return SymbolicExpr::exp(SymbolicExpr::multiply(
            SymbolicExpr::number(-1), abs_t));
    }
 
    if (const auto rate = te_match_pure_gaussian(F, omega)) {
        auto pi = detail::make_expression_ptr(detail::make_node<VariableNode>("pi", true));
        auto coefficient = SymbolicExpr::divide(SymbolicExpr::number(1),
            SymbolicExpr::sqrt(SymbolicExpr::multiply(
                SymbolicExpr::number(Rational(4) * *rate), pi)));
        auto exponent = SymbolicExpr::multiply(
            SymbolicExpr::number(-Rational(1) / (Rational(4) * *rate)),
            SymbolicExpr::power(tv, SymbolicExpr::number(2)));
        return SymbolicExpr::multiply(
            coefficient, SymbolicExpr::exp(exponent));
    }
    return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<TransformNode>(
        TransformNode::TransformType::InverseFourier, LMCAS::detail::node(F)->clone(), omega,
        SymbolicFactory::create_variable(t)));
}

引用了 LMCAS::FunctionNode::Abs, context, LMCAS::SymbolicFactory::create_variable(), exponent, inverse_fourier_transform_core(), LMCAS::TransformNode::InverseFourier, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), op, pi(), t, te_abs_fourier(), LMCAS::transform_detail::te_depends_on() , 以及 LMCAS::transform_detail::te_match_pure_gaussian().

被这些函数引用 inverse_fourier_transform_checked() , 以及 inverse_fourier_transform_core().

函数调用图:

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

inverse_function_checked() [1/2]

SymbolicExprVectorResult LMCAS::inverse_function_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	y )

在文件 calculus_inverse.cpp 第 412 行定义.

{
    ComputationContext context;
    return inverse_function_checked(f, var, y, context);
}

引用了 context , 以及 inverse_function_checked().

函数调用图:

inverse_function_checked() [2/2]

SymbolicExprVectorResult LMCAS::inverse_function_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	y,
		ComputationContext &	context )

在文件 calculus_inverse.cpp 第 368 行定义.

{
    const std::string operation = "inverse_function";
    auto input = calculus_utils_validate_expr_target(f, var, y, context, operation);
    if (!input) {
        return SymbolicExprVectorResult::failure(input.error());
    }
    auto step = context.consume_steps(4, operation);
    if (!step) {
        return SymbolicExprVectorResult::failure(step.error());
    }
 
    try {
        auto eq = SymbolicExpr::eq(f, y);
 
        auto solved = solve_equation(eq, var, context, SolveOptions{});
        if (!solved) {
            return SymbolicExprVectorResult::failure(solved.error());
        }
 
        const auto& solutions = solved.value();
        if (std::holds_alternative<EmptySolutions>(solutions)) {
            return SymbolicExprVectorResult::success({});
        }
        if (const auto* finite = std::get_if<FiniteSolutions>(&solutions)) {
            return explicit_inverse_candidates(*finite, operation);
        }
 
        return SymbolicExprVectorResult::failure(
            CasErrc::Inconclusive,
            "inverse equation is outside the finite exact support domain",
            operation);
    } catch (const std::bad_alloc&) {
        return SymbolicExprVectorResult::failure(CasErrc::ResourceLimit,
                                                 "inverse function allocation failed",
                                                 operation);
    } catch (const std::exception& e) {
        return SymbolicExprVectorResult::failure(CasErrc::InternalInvariant,
                                                 e.what(), operation);
    }
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_validate_expr_target(), context, e(), eq(), explicit_inverse_candidates(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, InternalInvariant, inverse_function_checked(), ResourceLimit, solve_equation(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 inverse_derivative_checked(), inverse_function_checked() , 以及 inverse_function_checked().

函数调用图:

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

inverse_laplace_checked() [1/2]

TransformEngineResult LMCAS::inverse_laplace_checked	(	const std::shared_ptr< SymbolicExpr > &	F,
		const std::string &	s,
		const std::string &	t )

在文件 transform_inverse_laplace.cpp 第 222 行定义.

                        {
    ComputationContext context;
    return inverse_laplace_checked(F, s, t, context);
}

引用了 context, inverse_laplace_checked() , 以及 t.

函数调用图:

inverse_laplace_checked() [2/2]

TransformEngineResult LMCAS::inverse_laplace_checked	(	const std::shared_ptr< SymbolicExpr > &	F,
		const std::string &	s,
		const std::string &	t,
		ComputationContext &	context )

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

                                 {
    const std::string operation = "inverse_laplace";
    auto valid = te_validate_expr_vars(F, s, t, context, operation);
    if (!valid) return TransformEngineResult::failure(valid.error());
    auto step = context.consume_steps(8, operation);
    if (!step) return TransformEngineResult::failure(step.error());
    try {
        auto expression = inverse_laplace_core(F, s, t, context);
        auto final_access = context.consume_steps(0, operation);
        if (!final_access) {
            return TransformEngineResult::failure(final_access.error());
        }
        auto result = te_wrap_transform_result(expression, operation);
        if (!result) return result;
        auto round_trip = laplace_transform_core(
            expression, t, s, context);
        if (!round_trip ||
            te_contains_transform(LMCAS::detail::node(round_trip))) {
            return TransformEngineResult::failure(
                CasErrc::Inconclusive,
                "inverse Laplace round trip is not proved", operation);
        }
        auto verified = check_equivalent(round_trip, F, context);
        if (!verified) return TransformEngineResult::failure(verified.error());
        if (!std::holds_alternative<ProvedZeroResidual>(verified.value())) {
            return TransformEngineResult::failure(
                CasErrc::Inconclusive,
                "inverse Laplace round trip is not proved", operation);
        }
        result.value().certificate =
            ExactRoundTripProof{SymbolicExpr::number(0)};
        return result;
    } catch (const CasError& error) {
        return TransformEngineResult::failure(error);
    } catch (const std::bad_alloc&) {
        return TransformEngineResult::failure(CasErrc::ResourceLimit,
                                              "transform allocation failed",
                                              operation);
    } catch (const std::exception& e) {
        return TransformEngineResult::failure(CasErrc::InternalInvariant,
                                              e.what(), operation);
    }
}

引用了 check_equivalent(), context, e(), LMCAS::Result< Verified< EvaluatedTransform > >::failure(), Inconclusive, InternalInvariant, inverse_laplace_checked(), inverse_laplace_core(), LMCAS::transform_detail::laplace_transform_core(), LMCAS::detail::node(), ResourceLimit, t, LMCAS::transform_detail::te_contains_transform(), LMCAS::transform_detail::te_validate_expr_vars() , 以及 LMCAS::transform_detail::te_wrap_transform_result().

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

函数调用图:

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

inverse_laplace_core()

std::shared_ptr< SymbolicExpr > LMCAS::inverse_laplace_core ( const std::shared_ptr< SymbolicExpr > & F, const std::string & s, const std::string & t, ComputationContext & context )

static

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

                                                     {
    auto step = context.consume_steps(1, "inverse_laplace.recursive");
    if (!step) {
        return nullptr;
    }
    if (!F || !LMCAS::detail::node(F)) {
        return nullptr;
    }
    if (te_is_zero(F)) {
        return SymbolicExpr::number(0);
    }
    auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(F));
    if (add) {
        std::shared_ptr<SymbolicExpr> result;
        for (auto& op : add->operands()) {
            auto ilt = inverse_laplace_core(
                LMCAS::detail::make_expression_ptr(op), s, t, context);
            if (!ilt) {
                return te_unevaluated_inv_laplace(F, s, t);
            }
            result = result ? SymbolicExpr::add(result, ilt) : ilt;
        }
        return result;
    }
    auto [coeff, body] = te_split_coeff(F, s);
    if (!coeff->is_one()) {
        auto ilt_body = inverse_laplace_core(body, s, t, context);
        if (ilt_body) {
            return SymbolicExpr::multiply(coeff, ilt_body);
        }
    }
    auto pw_res = te_inv_power(F, s, t, context);
    if (pw_res) {
        return pw_res;
    }
    auto prod_res = te_inv_product(F, s, t, context);
    if (prod_res) {
        return prod_res;
    }
    return te_unevaluated_inv_laplace(F, s, t);
}

引用了 add(), context, inverse_laplace_core(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), op, t, te_inv_power(), te_inv_product(), LMCAS::transform_detail::te_is_zero(), LMCAS::transform_detail::te_split_coeff() , 以及 te_unevaluated_inv_laplace().

被这些函数引用 inverse_laplace_checked() , 以及 inverse_laplace_core().

函数调用图:

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

is_alternating_factor()

bool LMCAS::is_alternating_factor ( const std::shared_ptr< const SymbolicNode > & node, const std::string & n )

static

在文件 series_sequence_limits.cpp 第 15 行定义.

                                                                       {
    auto power = std::dynamic_pointer_cast<const PowerNode>(node);
    if (!power) {
        return false;
    }
    auto base = std::dynamic_pointer_cast<const NumberNode>(power->base());
    auto exponent = std::dynamic_pointer_cast<const VariableNode>(power->exponent());
    if (!base || !exponent || exponent->is_constant() || exponent->name() != n) {
        return false;
    }
    return base->is_negative_one();
}

引用了 exponent , 以及 is_alternating_factor().

被这些函数引用 is_alternating_factor() , 以及 series_extract_alternating().

函数调用图:

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

is_analytic_checked() [1/2]

ComplexBoolResult LMCAS::is_analytic_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z )

在文件 complex_analysis.cpp 第 663 行定义.

                                                          {
    ComputationContext context;
    return is_analytic_checked(f, z, context);
}

引用了 context , 以及 is_analytic_checked().

函数调用图:

is_analytic_checked() [2/2]

ComplexBoolResult LMCAS::is_analytic_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		ComputationContext &	context )

在文件 complex_analysis.cpp 第 627 行定义.

                                                                   {
    const std::string operation = "is_analytic";
    auto input = validate_complex_expr_input(f, context, operation);
    if (!input) return ComplexBoolResult::failure(input.error());
    if (z.empty()) {
        return ComplexBoolResult::failure(CasErrc::InvalidArgument,
                                          "complex variable name cannot be empty",
                                          operation);
    }
    try {
        if (has_z_dependent_function(LMCAS::detail::node(f), z)) {
            return ComplexBoolResult::failure(
                CasErrc::Inconclusive,
                "analyticity of functions depending on the complex variable is outside the current support domain",
                operation);
        }
        auto budget = context.consume_steps(24, operation);
        if (!budget) return ComplexBoolResult::failure(budget.error());
        return ComplexBoolResult::success(is_analytic_impl(f, z, context));
    } catch (const CasError& error) {
        return ComplexBoolResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ComplexBoolResult::failure(CasErrc::ResourceLimit,
                                          "allocation failed while checking analyticity",
                                          operation);
    } catch (const std::length_error& error) {
        return ComplexBoolResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& ex) {
        return ComplexBoolResult::failure(CasErrc::InternalInvariant,
                                          ex.what(),
                                          operation);
    }
}

引用了 context, LMCAS::Result< bool >::failure(), Inconclusive, InternalInvariant, InvalidArgument, is_analytic_checked(), is_analytic_impl(), LMCAS::detail::node(), ResourceLimit , 以及 LMCAS::Result< bool >::success().

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

函数调用图:

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

is_analytic_impl()

bool LMCAS::is_analytic_impl ( const std::shared_ptr< SymbolicExpr > & f, const std::string & z, ComputationContext & context )

static

将 z 替换为 (z_re + i·z_im)，分离 u、v，检验 Cauchy-Riemann。

CR1: ux - vy == 0 ; CR2: uy + vx == 0

在文件 complex_analysis.cpp 第 681 行定义.

                                                                                                                    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f) return false;
    /// 将 z 替换为 (z_re + i·z_im)，分离 u、v，检验 Cauchy-Riemann。
    std::string xr = z + "_re";
    std::string xi = z + "_im";
    auto zr = SymbolicExpr::variable(xr);
    auto zi = SymbolicExpr::variable(xi);
    auto i_unit = LMCAS::detail::make_expression_ptr(
        SymbolicFactory::create_complex(
            LMCAS::detail::node(SymbolicExpr::number(0)),
            LMCAS::detail::node(SymbolicExpr::number(1))));
    auto z_sub = SymbolicExpr::add(zr, SymbolicExpr::multiply(i_unit, zi));
 
    auto fz = detail::make_expression_ptr(detail::substitute_node(detail::node(f), z, detail::node(z_sub), transform_budget));
    if (!fz) return false;
    fz = detail::make_expression_ptr(detail::normalize_node(detail::node(fz), transform_budget));
 
    std::shared_ptr<SymbolicExpr> u, v;
    split_real_imag(LMCAS::detail::node(fz), u, v, context);
 
    auto ux = differentiate_if_dependent(u, xr, context);
    auto uy = differentiate_if_dependent(u, xi, context);
    auto vx = differentiate_if_dependent(v, xr, context);
    auto vy = differentiate_if_dependent(v, xi, context);
 
    /// CR1: ux - vy == 0 ; CR2: uy + vx == 0
    auto cr1 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(ux, SymbolicExpr::multiply(SymbolicExpr::number(-1), vy))), transform_budget));
    auto cr2 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(uy, vx)), transform_budget));
 
    return LMCAS::detail::node(cr1) && LMCAS::detail::node(cr1)->is_zero() && LMCAS::detail::node(cr2) && LMCAS::detail::node(cr2)->is_zero();
}

引用了 context, LMCAS::SymbolicFactory::create_complex(), differentiate_if_dependent(), is_analytic_impl(), LMCAS::SymbolicNode::is_zero(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::substitute_node(), u , 以及 v.

被这些函数引用 is_analytic_checked() , 以及 is_analytic_impl().

函数调用图:

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

is_bernoulli_ode()

bool LMCAS::is_bernoulli_ode	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y,
		std::shared_ptr< SymbolicExpr > &	P,
		std::shared_ptr< SymbolicExpr > &	Q,
		int &	n )

在文件 ode_classification.cpp 第 300 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    P.reset();
    Q.reset();
    n = 0;
    if (!rhs || !LMCAS::detail::node(rhs) ||
        !valid_classifier_variables(x, y)) {
        return false;
    }
    if (!expression_depends_on_variable(LMCAS::detail::node(rhs), y)) {
        return false;
    }
 
    std::vector<std::shared_ptr<const SymbolicNode>> terms;
    if (auto sum =
            std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(rhs))) {
        terms = sum->operands();
    } else {
        terms.push_back(LMCAS::detail::node(rhs));
    }
 
    std::map<int, std::shared_ptr<SymbolicExpr>> coefficients;
    if (!collect_bernoulli_coefficients(terms, y, coefficients, context)) {
        return false;
    }
    auto linear_coefficient = SymbolicExpr::number(0);
    std::shared_ptr<SymbolicExpr> nonlinear_coefficient;
    int nonlinear_exponent = 0;
    for (auto& [exponent, coefficient] : coefficients) {
        coefficient = detail::make_expression_ptr(detail::normalize_node(detail::node(coefficient), transform_budget));
        if (coefficient->is_zero()) {
            continue;
        }
        if (exponent == 1) {
            linear_coefficient = coefficient;
            continue;
        }
        if (exponent == 0 || nonlinear_coefficient) {
            return false;
        }
        nonlinear_exponent = exponent;
        nonlinear_coefficient = coefficient;
    }
 
    if (!nonlinear_coefficient ||
        nonlinear_exponent == 0 || nonlinear_exponent == 1) {
        return false;
    }
 
    P = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
        SymbolicExpr::number(-1), linear_coefficient)), transform_budget));
    Q = detail::make_expression_ptr(detail::normalize_node(detail::node(nonlinear_coefficient), transform_budget));
    n = nonlinear_exponent;
    return true;
}

引用了 collect_bernoulli_coefficients(), context, exponent, expression_depends_on_variable(), is_bernoulli_ode(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), rhs , 以及 valid_classifier_variables().

被这些函数引用 classify_first_order_ode() , 以及 is_bernoulli_ode().

函数调用图:

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

is_constant_coefficient()

bool LMCAS::is_constant_coefficient	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coeffs,
		const std::string &	x )

在文件 ode_classification.cpp 第 412 行定义.

{
    if (coeffs.empty() || x.empty()) {
        return false;
    }
    for (const auto& c : coeffs) {
        if (!c || !LMCAS::detail::node(c)) {
            return false;
        }
        if (expression_depends_on_variable(LMCAS::detail::node(c), x)) {
            return false;
        }
    }
    return true;
}

引用了 c, expression_depends_on_variable(), is_constant_coefficient() , 以及 LMCAS::detail::node().

被这些函数引用 classify_higher_order_ode() , 以及 is_constant_coefficient().

函数调用图:

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

is_euler_equation()

bool LMCAS::is_euler_equation	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coeffs,
		const std::string &	x,
		std::vector< double > &	euler_consts )

在文件 ode_classification.cpp 第 431 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    euler_consts.clear();
    if (coeffs.empty() || x.empty()) {
        return false;
    }
    if (!coeffs.front() || !LMCAS::detail::node(coeffs.front()) ||
        coeffs.front()->is_zero()) {
        return false;
    }
 
    const int highest_order = static_cast<int>(coeffs.size()) - 1;
    std::vector<double> extracted(coeffs.size(), 0.0);
    for (int index = 0; index <= highest_order; ++index) {
        const int derivative_order = highest_order - index;
        if (!coeffs[index] || !LMCAS::detail::node(coeffs[index])) {
            return false;
        }
        if (coeffs[index]->is_zero()) {
            continue;
        }
 
        std::shared_ptr<SymbolicExpr> ratio;
        if (derivative_order == 0) {
            ratio = detail::make_expression_ptr(detail::normalize_node(detail::node(coeffs[index]), transform_budget));
        } else {
            auto x_power = SymbolicExpr::power(
                SymbolicExpr::variable(x),
                SymbolicExpr::number(derivative_order));
            ratio = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
                coeffs[index], x_power)), transform_budget));
        }
        if (!ratio || !LMCAS::detail::node(ratio)) {
            return false;
        }
 
        if (expression_depends_on_variable(
                LMCAS::detail::node(ratio), x)) {
            return false;
        }
 
        const double value = try_eval_double(ratio);
        if (!std::isfinite(value)) {
            return false;
        }
        extracted[index] = value;
    }
 
    euler_consts = std::move(extracted);
    return true;
}

引用了 context, expression_depends_on_variable(), is_euler_equation(), LMCAS::SymbolicNode::is_zero(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), try_eval_double() , 以及 value.

被这些函数引用 classify_higher_order_ode() , 以及 is_euler_equation().

函数调用图:

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

is_even_integer_number()

bool LMCAS::is_even_integer_number

(

const NumberNode &

num

)

在文件 inference_engine_facts.cpp 第 313 行定义.

                                                   {
    if (!is_integer_number(num)) {
        return false;
    }
 
    if (std::holds_alternative<BigInt>(num.value())) {
        return std::get<BigInt>(num.value()).is_even();
    }
    return std::get<Rational>(num.value()).get_numerator().is_even();
}

引用了 is_even_integer_number(), is_integer_number() , 以及 LMCAS::polynomial_solver_detail::num().

被这些函数引用 LMCAS::InferenceEngine::Impl::even_power_sign(), LMCAS::InferenceEngine::Impl::integer_power_sign() , 以及 is_even_integer_number().

函数调用图:

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

is_exact_ode()

bool LMCAS::is_exact_ode	(	const std::shared_ptr< SymbolicExpr > &	M,
		const std::shared_ptr< SymbolicExpr > &	N,
		const std::string &	x,
		const std::string &	y )

恰当条件: ∂M/∂y = ∂N/∂x

计算差值并化简

在文件 ode_classification.cpp 第 366 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!M || !LMCAS::detail::node(M) ||
        !N || !LMCAS::detail::node(N) ||
        !valid_classifier_variables(x, y)) {
        return false;
    }
 
    /// 恰当条件: ∂M/∂y = ∂N/∂x
    auto dM_dy = detail::make_expression_ptr(detail::differentiate_node(detail::node(M), y, transform_budget));
    auto dN_dx = detail::make_expression_ptr(detail::differentiate_node(detail::node(N), x, transform_budget));
 
    if (!dM_dy || !dN_dx) {
        return false;
    }
 
    dM_dy = detail::make_expression_ptr(detail::normalize_node(detail::node(dM_dy), transform_budget));
    dN_dx = detail::make_expression_ptr(detail::normalize_node(detail::node(dN_dx), transform_budget));
    if (dM_dy->compare(dN_dx) == 0) {
        return true;
    }
 
    /// 计算差值并化简
    auto diff = SymbolicExpr::add(dM_dy,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dN_dx));
    diff = detail::make_expression_ptr(detail::normalize_node(detail::node(diff), transform_budget));
 
    if (diff->is_zero()) {
        return true;
    }
 
 
    auto verified = check_zero_residual(diff, context);
    return verified &&
        std::holds_alternative<ProvedZeroResidual>(verified.value());
 
}

引用了 check_zero_residual(), context, LMCAS::detail::differentiate_node(), is_exact_ode(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 valid_classifier_variables().

被这些函数引用 classify_first_order_ode() , 以及 is_exact_ode().

函数调用图:

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

is_good_prime()

bool LMCAS::is_good_prime ( int64_t p, const std::vector< BigInt > & leading_coeffs )

inline

判断素数 p 是否为"好素数"（不整除任何首项系数）

参数

p	待检测素数
leading_coeffs	首项系数列表

返回

若 p 不整除任何系数则返回 true

在文件 modular_arithmetic.hpp 第 473 行定义.

                                                                              {
    if (p < 2) {
        throw std::domain_error("prime modulus must be at least two");
    }
    const BigInt modulus(p);
    return std::none_of(leading_coeffs.begin(), leading_coeffs.end(),
        [&modulus](const BigInt& coefficient) {
            return (coefficient % modulus).is_zero();
        });
}

引用了 is_good_prime().

被这些函数引用 generate_good_primes() , 以及 is_good_prime().

函数调用图:

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

is_homogeneous_ode()

bool LMCAS::is_homogeneous_ode	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y )

齐次方程: f(tx, ty) = f(x, y) 对所有 t 成立 用 t=2 进行数值测试：f(2x, 2y) 应等于 f(x, y)

计算 f_scaled - rhs，若化简为零则齐次

在文件 ode_classification.cpp 第 147 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!rhs || !LMCAS::detail::node(rhs)) {
        return false;
    }
    if (!valid_classifier_variables(x, y)) {
        return false;
    }
 
    /// 齐次方程: f(tx, ty) = f(x, y) 对所有 t 成立
    /// 用 t=2 进行数值测试：f(2x, 2y) 应等于 f(x, y)
    auto t_val = SymbolicExpr::number(2);
    auto tx = SymbolicExpr::multiply(t_val, SymbolicExpr::variable(x));
    auto ty = SymbolicExpr::multiply(t_val, SymbolicExpr::variable(y));
 
    auto f_scaled = detail::make_expression_ptr(detail::substitute_node(detail::node(rhs), x, detail::node(tx), transform_budget));
    f_scaled = detail::make_expression_ptr(detail::substitute_node(detail::node(f_scaled), y, detail::node(ty), transform_budget));
    f_scaled = detail::make_expression_ptr(detail::normalize_node(detail::node(f_scaled), transform_budget));
 
    /// 计算 f_scaled - rhs，若化简为零则齐次
    auto diff = SymbolicExpr::add(f_scaled,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), rhs));
    diff = detail::make_expression_ptr(detail::normalize_node(detail::node(diff), transform_budget));
 
    if (diff->is_zero()) {
        return true;
    }
 
 
    auto verified = check_zero_residual(diff, context);
    return verified &&
        std::holds_alternative<ProvedZeroResidual>(verified.value());
}

引用了 check_zero_residual(), context, is_homogeneous_ode(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), rhs, LMCAS::detail::substitute_node() , 以及 valid_classifier_variables().

被这些函数引用 classify_first_order_ode() , 以及 is_homogeneous_ode().

函数调用图:

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

is_integer_number()

bool LMCAS::is_integer_number

(

const NumberNode &

num

)

在文件 inference_engine_facts.cpp 第 307 行定义.

                                              {
    if (std::holds_alternative<BigInt>(num.value())) {
        return true;
    }
    return std::get<Rational>(num.value()).is_integer();
}

引用了 is_integer_number() , 以及 LMCAS::polynomial_solver_detail::num().

被这些函数引用 LMCAS::InferenceEngine::Impl::integer_power_sign(), is_even_integer_number(), is_integer_number(), is_positive_integer_number(), LMCAS::InferenceEngine::Impl::natural_number(), LMCAS::InferenceEngine::Impl::nonzero_power_sign() , 以及 LMCAS::InferenceEngine::Impl::number_integer().

函数调用图:

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

is_linear_first_order()

bool LMCAS::is_linear_first_order	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y,
		std::shared_ptr< SymbolicExpr > &	P,
		std::shared_ptr< SymbolicExpr > &	Q )

方程形式: y' = rhs(x, y) 线性形式: y' + P(x)*y = Q(x) → y' = Q(x) - P(x)*y → rhs = Q(x) - P(x)*y 即 rhs 关于 y 是线性的: rhs = A(x) + B(x)*y，其中 Q = A, P = -B

若 rhs 不依赖 y，则 P=0, Q=rhs

对 rhs 关于 y 求导，若结果不依赖 y，则 rhs 关于 y 是线性的

rhs = A(x) + B(x)*y，其中 B(x) = ∂rhs/∂y 计算 A(x) = rhs|_{y=0}

验证 A 不依赖 y

B(x) = drhs_dy（已验证不依赖 y） 线性形式: y' = A(x) + B(x)*y → y' - B(x)*y = A(x) → y' + (-B(x))*y = A(x) 所以 P = -B(x), Q = A(x)

在文件 ode_classification.cpp 第 92 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    P.reset();
    Q.reset();
    if (!rhs || !LMCAS::detail::node(rhs) ||
        !valid_classifier_variables(x, y)) {
        return false;
    }
 
    /// 方程形式: y' = rhs(x, y)
    /// 线性形式: y' + P(x)*y = Q(x)  →  y' = Q(x) - P(x)*y  →  rhs = Q(x) - P(x)*y
    /// 即 rhs 关于 y 是线性的: rhs = A(x) + B(x)*y，其中 Q = A, P = -B
 
    /// 若 rhs 不依赖 y，则 P=0, Q=rhs
    if (!expression_depends_on_variable(LMCAS::detail::node(rhs), y)) {
        P = SymbolicExpr::number(0);
        Q = rhs;
        return true;
    }
 
    /// 对 rhs 关于 y 求导，若结果不依赖 y，则 rhs 关于 y 是线性的
    auto drhs_dy = detail::make_expression_ptr(detail::differentiate_node(detail::node(rhs), y, transform_budget));
    if (!drhs_dy || expression_depends_on_variable(LMCAS::detail::node(drhs_dy), y)) {
        return false;
    }
 
    /// rhs = A(x) + B(x)*y，其中 B(x) = ∂rhs/∂y
    /// 计算 A(x) = rhs|_{y=0}
    auto A = detail::make_expression_ptr(detail::substitute_node(detail::node(rhs), y, detail::node(SymbolicExpr::number(0)), transform_budget));
    if (!A) {
        return false;
    }
 
    /// 验证 A 不依赖 y
    if (expression_depends_on_variable(LMCAS::detail::node(A), y)) {
        return false;
    }
 
    /// B(x) = drhs_dy（已验证不依赖 y）
    /// 线性形式: y' = A(x) + B(x)*y  →  y' - B(x)*y = A(x)  →  y' + (-B(x))*y = A(x)
    /// 所以 P = -B(x), Q = A(x)
    P = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), drhs_dy)), transform_budget));
    Q = detail::make_expression_ptr(detail::normalize_node(detail::node(A), transform_budget));
    return true;
}

引用了 context, LMCAS::detail::differentiate_node(), expression_depends_on_variable(), is_linear_first_order(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), rhs, LMCAS::detail::substitute_node() , 以及 valid_classifier_variables().

被这些函数引用 classify_first_order_ode() , 以及 is_linear_first_order().

函数调用图:

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

is_negative_infinity_coefficient()

bool LMCAS::is_negative_infinity_coefficient ( const NumberNode & number )

inline

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

                                                                       {
    if (std::holds_alternative<BigInt>(number.value())) {
        return std::get<BigInt>(number.value()) < BigInt(0);
    }
    return std::get<Rational>(number.value()) < Rational(0);
}

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

被这些函数引用 infinity_sign() , 以及 is_negative_infinity_coefficient().

函数调用图:

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

is_nonreal_sqrt()

bool LMCAS::is_nonreal_sqrt ( const FunctionNode & function, ComputationContext & context )

static

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

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (function.type() != FunctionNode::FuncType::Sqrt ||
        function.arguments().size() != 1) {
        return false;
    }
    auto argument = detail::make_expression_ptr(detail::normalize_node(function.arguments()[0], transform_budget));
    auto number = argument
        ? std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(argument))
        : nullptr;
    return calculus_utils_is_negative_number(number);
}

引用了 calculus_utils_is_negative_number(), context, function(), is_nonreal_sqrt(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::FunctionNode::Sqrt.

被这些函数引用 calculus_utils_contains_nonreal_sqrt() , 以及 is_nonreal_sqrt().

函数调用图:

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

is_pi_variable()

bool LMCAS::is_pi_variable ( const VariableNode & variable )

static

在文件 normalization_utils.cpp 第 177 行定义.

                                                         {
    return variable.is_constant() &&
        (variable.name() == "pi" || variable.name() == "π");
}

引用了 is_pi_variable() , 以及 variable.

被这些函数引用 get_pi_coeff() , 以及 is_pi_variable().

函数调用图:

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

is_polynomial_after_substitution()

bool LMCAS::is_polynomial_after_substitution

(

const TransSubstitutionResult &

sub_result

)

在调用方计算上下文中执行混合超越方程求解.

参数

[in]	expr	待求解表达式(视为 = 0)
[in]	var	求解变量名
[in]	opts	求解选项
[in]	context	计算预算与取消状态

返回

受检的完整或未决结果

使用默认计算上下文执行受检混合超越方程求解.

判断表达式是否包含依赖指定变量的超越函数.

遍历 AST,检测 sin/cos/tan/exp/ln 节点的参数是否依赖 var. 若超越函数的参数不含 var(即为常数),则不计入.

参数

[in]	expr	待检测的符号表达式
[in]	var	目标变量名

返回

包含依赖 var 的超越函数时返回 true,否则返回 false

判断换元结果是否为关于换元变量的多项式.

检查 detect_trans_substitutions 的输出:若映射为空或换元后表达式 仍非多项式形式,则返回 false.

参数

[in]

sub_result

换元分析结果

返回

换元后为多项式时返回 true,否则返回 false

在文件 mixed_transcendental_classification.cpp 第 262 行定义.

{
    if (sub_result.mappings.empty()) {
        return false;
    }
    if (!sub_result.poly_expr || !LMCAS::detail::node(sub_result.poly_expr)) {
        return false;
    }
 
    const auto& root = LMCAS::detail::node(sub_result.poly_expr);
 
    for (const auto& m : sub_result.mappings) {
        if (expression_depends_on_variable(root, m.indeterminate) &&
            degree_in_var(root, m.indeterminate).is_negative()) {
            return false;
        }
    }
 
    return true;
}

引用了 expression_depends_on_variable(), is_polynomial_after_substitution(), LMCAS::TransSubstitutionResult::mappings, LMCAS::detail::node() , 以及 LMCAS::TransSubstitutionResult::poly_expr.

被这些函数引用 is_polynomial_after_substitution() , 以及 solve_finite_mixed().

函数调用图:

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

is_positive_integer_number()

bool LMCAS::is_positive_integer_number

(

const NumberNode &

num

)

在文件 inference_engine_facts.cpp 第 323 行定义.

                                                       {
    return is_integer_number(num) && num.is_positive();
}

引用了 is_integer_number(), is_positive_integer_number() , 以及 LMCAS::polynomial_solver_detail::num().

被这些函数引用 LMCAS::InferenceEngine::Impl::integral_power_domain(), is_positive_integer_number() , 以及 LMCAS::InferenceEngine::Impl::positive_integer_power_sign().

函数调用图:

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

is_representable_small_integer()

bool LMCAS::is_representable_small_integer ( double value )

static

将 double 值转为"干净"的数值表达式.

仅在精确保持 double 值时使用小整数或简单分数表示.

在文件 ode_linear.cpp 第 42 行定义.

                                                         {
    return std::isfinite(value) &&
        value >= static_cast<double>(std::numeric_limits<int>::min()) &&
        value <= static_cast<double>(std::numeric_limits<int>::max());
}

引用了 is_representable_small_integer() , 以及 value.

被这些函数引用 clean_number() , 以及 is_representable_small_integer().

函数调用图:

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

is_separable()

bool LMCAS::is_separable	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y )

若只依赖一个变量或都不依赖，则可分离

检查乘法形式 f(x)*g(y)

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

{
    if (!rhs || !LMCAS::detail::node(rhs)) {
        return false;
    }
    if (!valid_classifier_variables(x, y)) {
        return false;
    }
 
    bool has_x = expression_depends_on_variable(LMCAS::detail::node(rhs), x);
    bool has_y = expression_depends_on_variable(LMCAS::detail::node(rhs), y);
 
    /// 若只依赖一个变量或都不依赖，则可分离
    if (!has_x || !has_y) {
        return true;
    }
 
    /// 检查乘法形式 f(x)*g(y)
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(rhs));
    if (mul && separable_product(*mul, x, y)) {
        return true;
    }
    auto power = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(rhs));
    return power && separable_reciprocal(*power, x, y);
}

引用了 expression_depends_on_variable(), is_separable(), mul(), LMCAS::detail::node(), rhs, separable_product(), separable_reciprocal() , 以及 valid_classifier_variables().

被这些函数引用 classify_first_order_ode(), is_separable() , 以及 solve_separable_ode().

函数调用图:

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

is_variable_operand()

bool LMCAS::is_variable_operand ( const std::shared_ptr< const VariableNode > & node )

static

在文件 inference_engine_monotonicity.cpp 第 189 行定义.

                                                                               {
    return node && !node->is_constant();
}

引用了 is_variable_operand().

被这些函数引用 is_variable_operand().

函数调用图:

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

is_vertical_asymptote()

Result< bool > LMCAS::is_vertical_asymptote ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::shared_ptr< SymbolicExpr > & point, ComputationContext & context )

static

在文件 calculus_asymptotes.cpp 第 210 行定义.

{
    auto right = limit_checked(f, var, point, LimitDirection::FromAbove, context);
    if (!right && right.error().code != CasErrc::Inconclusive) {
        return Result<bool>::failure(right.error());
    }
    auto left = limit_checked(f, var, point, LimitDirection::FromBelow, context);
    if (!left && left.error().code != CasErrc::Inconclusive) {
        return Result<bool>::failure(left.error());
    }
    auto infinite = [](const LimitResult& value) {
        return value && (std::holds_alternative<PositiveInfinityLimit>(value.value().value) ||
                         std::holds_alternative<NegativeInfinityLimit>(value.value().value));
    };
    if (infinite(right) || infinite(left)) { return true; }
    if (!right) { return Result<bool>::failure(right.error()); }
    if (!left) { return Result<bool>::failure(left.error()); }
    return false;
}

引用了 context, LMCAS::Result< T >::failure(), FromAbove, FromBelow, Inconclusive, is_vertical_asymptote(), limit_checked(), point, right , 以及 value.

被这些函数引用 collect_vertical_asymptotes() , 以及 is_vertical_asymptote().

函数调用图:

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

is_wildcard()

bool LMCAS::is_wildcard ( const std::shared_ptr< const SymbolicNode > & node, const std::unordered_set< std::string > & wildcards, std::string & name_out )

static

在文件 matcher.cpp 第 52 行定义.

                                            {
    if (!node) return false;
 
    auto var = std::dynamic_pointer_cast<const VariableNode>(node);
    if (var && !var->is_constant()) {
        if (wildcards.count(var->name())) {
            name_out = var->name();
            return true;
        }
    }
    return false;
}

引用了 is_wildcard() , 以及 wildcards.

被这些函数引用 is_wildcard() , 以及 match_recursive().

函数调用图:

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

is_zero_dimensional()

bool LMCAS::is_zero_dimensional	(	const std::vector< FGLMPoly > &	basis,
		size_t	num_vars )

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

                                                                            {
    if (basis.empty()) return false;
    for (size_t variable = 0; variable < num_vars; ++variable) {
        bool found = false;
        for (const auto& polynomial : basis) {
            if (polynomial.is_zero()) continue;
            if (fglm_detail::is_pure_power(polynomial.terms.front().first,
                                           variable, num_vars)) {
                found = true;
                break;
            }
        }
        if (!found) return false;
    }
    return true;
}

引用了 basis, is_zero_dimensional() , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{fglm.cpp}::checked_dimension(), is_zero_dimensional() , 以及 LMCAS::anonymous_namespace{solver_groebner_system.cpp}::simplified_basis().

函数调用图:

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

is_zero_number()

bool LMCAS::is_zero_number

(

const NumberNode &

num

)

在文件 inference_engine_facts.cpp 第 326 行定义.

                                           {
    return num.is_zero();
}

引用了 is_zero_number() , 以及 LMCAS::polynomial_solver_detail::num().

被这些函数引用 LMCAS::InferenceEngine::Impl::integral_power_domain(), is_zero_number() , 以及 LMCAS::InferenceEngine::Impl::zero_power_sign().

函数调用图:

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

isolate_linear_coeff()

std::pair< SymbolicExpr, SymbolicExpr > LMCAS::isolate_linear_coeff ( const SymbolicExpr & expr, const std::string & var, ComputationContext & context )

static

在文件 solver_linear.cpp 第 257 行定义.

                                                                                                                                             {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    auto expr_ptr = to_ptr(expr);
    auto A_ptr = detail::make_expression_ptr(detail::differentiate_node(detail::node(expr_ptr), var, transform_budget));
 
    std::vector<std::shared_ptr<const SymbolicNode>> mops;
    mops.push_back(LMCAS::detail::node(A_ptr));
    mops.push_back(SymbolicFactory::create_variable(var));
    auto term_Ax = SymbolicFactory::create_multiply(mops);
 
    std::vector<std::shared_ptr<const SymbolicNode>> nops;
    nops.push_back(SymbolicFactory::create_number(BigInt(-1)));
    nops.push_back(term_Ax);
    auto neg_term = SymbolicFactory::create_multiply(nops);
 
    std::vector<std::shared_ptr<const SymbolicNode>> aops;
    aops.push_back(LMCAS::detail::node(expr));
    aops.push_back(neg_term);
    auto B_node = SymbolicFactory::create_add(aops);
 
    auto B_expr = LMCAS::detail::expression_from_node(B_node);
    auto B_simp = detail::make_expression_ptr(detail::normalize_node(detail::node(to_ptr(B_expr)), transform_budget));
 
    auto A_expr = LMCAS::detail::expression_from_node(LMCAS::detail::node(A_ptr));
    auto A_simp = detail::make_expression_ptr(detail::normalize_node(detail::node(to_ptr(A_expr)), transform_budget));
 
    return {LMCAS::detail::expression_from_node(LMCAS::detail::node(A_simp)),
            LMCAS::detail::expression_from_node(LMCAS::detail::node(B_simp))};
}

引用了 context, LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_variable(), LMCAS::detail::differentiate_node(), LMCAS::detail::expression_from_node(), isolate_linear_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::solver_detail::to_ptr().

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

函数调用图:

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

isolate_real_roots_checked() [1/2]

Result< std::vector< std::pair< Rational, Rational > > > LMCAS::isolate_real_roots_checked

(

const Polynomial< Rational > &

polynomial

)

在文件 newton_raphson.cpp 第 321 行定义.

                                                                   {
    ComputationContext context;
    return isolate_real_roots_checked(polynomial, context);
}

引用了 context , 以及 isolate_real_roots_checked().

函数调用图:

isolate_real_roots_checked() [2/2]

Result< std::vector< std::pair< Rational, Rational > > > LMCAS::isolate_real_roots_checked	(	const Polynomial< Rational > &	polynomial,
		ComputationContext &	context )

在文件 newton_raphson.cpp 第 313 行定义.

                                 {
    return detail::isolate_real_roots_exact(
        polynomial, context, "isolate_real_roots");
}

引用了 context, isolate_real_roots_checked() , 以及 LMCAS::detail::isolate_real_roots_exact().

被这些函数引用 LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::append_exact_factor_roots(), isolate_real_roots_checked(), isolate_real_roots_checked() , 以及 LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial().

函数调用图:

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

isolate_roots()

std::vector< IsolatedInterval > LMCAS::isolate_roots	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	var,
		const SearchInterval &	interval,
		const SolveOptions &	opts )

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

                              {
    ComputationContext context;
    detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                context.limits().max_ast_nodes, "isolate_roots");
    std::optional<CasError> failure;
    auto result = detail::isolate_roots_with_context(
        expr, derivative, var, interval, opts, budget, &failure, nullptr);
    if (failure) throw *failure;
    return result;
}

引用了 context, interval(), isolate_roots() , 以及 LMCAS::detail::isolate_roots_with_context().

被这些函数引用 isolate_roots().

函数调用图:

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

jacobian()

std::shared_ptr< SymbolicExpr > LMCAS::jacobian	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	functions,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_matrices.cpp 第 154 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "jacobian");
    return jacobian_impl(functions, vars, transform_budget);
}

引用了 context, jacobian(), LMCAS::vector_calculus_detail::jacobian_impl() , 以及 vars.

被这些函数引用 jacobian().

函数调用图:

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

jacobian_checked() [1/2]

VectorCalculusExprResult LMCAS::jacobian_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	functions,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_matrices.cpp 第 42 行定义.

{
    ComputationContext context;
    return jacobian_checked(functions, vars, context);
}

引用了 context, jacobian_checked() , 以及 vars.

函数调用图:

jacobian_checked() [2/2]

VectorCalculusExprResult LMCAS::jacobian_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	functions,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

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

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "jacobian");
    const std::string operation = "jacobian";
    auto valid = vector_calculus_validate_functions_vars(functions, vars,
                                                        context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
    auto step = context.consume_steps(functions.size() * vars.size(), operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
    try {
        return vector_calculus_wrap_expr(jacobian_impl(functions, vars, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "vector calculus allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, jacobian_checked(), LMCAS::vector_calculus_detail::jacobian_impl(), ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_functions_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_expr().

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

函数调用图:

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

jordan_form_checked() [1/2]

JordanDecompositionResult LMCAS::jordan_form_checked

(

const ExprPtr &

A

)

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

                                                                {
    ComputationContext context;
    return jordan_form_checked(A, context);
}

引用了 context , 以及 jordan_form_checked().

函数调用图:

jordan_form_checked() [2/2]

JordanDecompositionResult LMCAS::jordan_form_checked	(	const ExprPtr &	A,
		ComputationContext &	context )

在文件 matrix_decomposition_eigen.cpp 第 165 行定义.

                                 {
    const std::string operation = "jordan_form";
    auto matrix = validate_decomposition_matrix(A, true, context, operation);
    if (!matrix) { return JordanDecompositionResult::failure(matrix.error()); }
    auto budget = context.consume_steps(matrix.value()->rows() * matrix.value()->cols() * 48 + 32,
        operation);
    if (!budget) { return JordanDecompositionResult::failure(budget.error()); }
    try {
        if (auto diagonal = exact_diagonal_entries(matrix.value(), context)) {
            return certified_jordan(A, {rectangular_diagonal_expr(
                matrix.value()->rows(), matrix.value()->cols(), *diagonal),
                identity_matrix_expr(matrix.value()->rows())}, context);
        }
        auto exact = exact_rational_matrix(matrix.value(), context);
        if (exact && is_defective_upper_pair(*exact)) {
            auto zero = SymbolicExpr::number(0);
            auto one = SymbolicExpr::number(1);
            auto lambda = exact_number_expr((*exact)[0][0]);
            auto j = SymbolicExpr::matrix({{lambda, one}, {zero, lambda}});
            auto p = SymbolicExpr::matrix({{exact_number_expr((*exact)[0][1]), zero}, {zero, one}});
            return certified_jordan(A, {std::move(j), std::move(p)}, context);
        }
        return diagonalization_checked(A, context);
    } catch (const std::bad_alloc&) {
        return JordanDecompositionResult::failure(CasErrc::ResourceLimit,
            "allocation failed while calculating Jordan form", operation);
    } catch (const std::exception& ex) {
        return JordanDecompositionResult::failure(CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, LMCAS::detail::matrix_decomposition::exact_diagonal_entries(), LMCAS::detail::matrix_decomposition::exact_number_expr(), LMCAS::detail::matrix_decomposition::exact_rational_matrix(), LMCAS::Result< JordanDecomposition >::failure(), LMCAS::detail::matrix_decomposition::identity_matrix_expr(), InternalInvariant, jordan_form_checked(), LMCAS::detail::matrix_decomposition::rectangular_diagonal_expr(), ResourceLimit , 以及 LMCAS::detail::matrix_decomposition::validate_decomposition_matrix().

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

函数调用图:

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

kronecker()

std::shared_ptr< SymbolicExpr > LMCAS::kronecker	(	const std::shared_ptr< SymbolicExpr > &	A,
		const std::shared_ptr< SymbolicExpr > &	B )

在文件 matrix_decomposition.cpp 第 82 行定义.

                                          {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto a = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(A));
    auto b = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(B));
    if (!a || !b) {
        return nullptr;
    }
    size_t m = a->rows(), n = a->cols(), p = b->rows(), q = b->cols();
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> grid(m * p,
        std::vector<std::shared_ptr<SymbolicExpr>>(n * q));
    for (size_t i = 0; i < m; ++i)
        for (size_t j = 0; j < n; ++j) {
            auto aij = LMCAS::detail::make_expression_ptr(a->get(i, j));
            for (size_t k = 0; k < p; ++k)
                for (size_t l = 0; l < q; ++l) {
                    auto bkl = LMCAS::detail::make_expression_ptr(b->get(k, l));
                    grid[i * p + k][j * q + l] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(aij, bkl)), transform_budget));
                }
        }
    return SymbolicExpr::matrix(grid);
}

引用了 a, b, context, kronecker(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 kronecker().

函数调用图:

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

lagrange_basis_coefficients()

std::vector< Rational > LMCAS::lagrange_basis_coefficients ( const std::vector< Rational > & points, size_t i, const Rational & denom )

static

在文件 multivariate_factor.cpp 第 94 行定义.

                                                                        {
    const size_t n = points.size();
    std::vector<Rational> basis_coeffs = {Rational(1)};
    for (size_t j = 0; j < n; ++j) {
        if (j == i) { continue; }
        std::vector<Rational> nc(basis_coeffs.size() + 1, Rational(0));
        for (size_t k = 0; k < basis_coeffs.size(); ++k) {
            nc[k + 1] = nc[k + 1] + basis_coeffs[k];
            nc[k] = nc[k] - points[j] * basis_coeffs[k];
        }
        basis_coeffs = std::move(nc);
    }
    for (auto& c : basis_coeffs) c = c / denom;
    return basis_coeffs;
}

引用了 c , 以及 lagrange_basis_coefficients().

被这些函数引用 lagrange_basis_coefficients() , 以及 lagrange_interpolate().

函数调用图:

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

lagrange_gradient_strict()

VectorCalculusFieldResult LMCAS::lagrange_gradient_strict ( const std::shared_ptr< SymbolicExpr > & f, const std::vector< std::string > & vars, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_lagrange.cpp 第 25 行定义.

{
    VectorField gradient;
    gradient.reserve(vars.size());
    for (const auto& var : vars) {
        auto partial = vector_calculus_differentiate_strict(f, var, operation, transform_budget);
        if (!partial) {
            return VectorCalculusFieldResult::failure(partial.error());
        }
        gradient.push_back(std::move(partial.value()));
    }
    return VectorCalculusFieldResult::success(std::move(gradient));
}

引用了 LMCAS::Result< VectorField >::failure(), gradient(), lagrange_gradient_strict(), LMCAS::Result< VectorField >::success(), vars , 以及 LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict().

被这些函数引用 lagrange_gradient_strict() , 以及 lagrange_multipliers_strict().

函数调用图:

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

lagrange_interpolate()

MultiPoly LMCAS::lagrange_interpolate ( const std::vector< Rational > & points, const std::vector< MultiPoly > & values, const std::string & main_var, const std::vector< std::string > & all_vars )

static

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

{
    size_t n = points.size();
    if (n == 0) { return MultiPoly(Rational(0), all_vars); }
    int var_idx = -1;
    for (size_t i = 0; i < all_vars.size(); ++i) {
        if (all_vars[i] == main_var) { var_idx = static_cast<int>(i); break; }
    }
    MultiPoly result(Rational(0), all_vars);
    for (size_t i = 0; i < n; ++i) {
        if (values[i].is_zero()) { continue; }
        Rational denom(1);
        for (size_t j = 0; j < n; ++j) {
            if (j == i) { continue; }
            denom = denom * (points[i] - points[j]);
        }
        if (denom.is_zero()) { continue; }
        auto basis_coeffs = lagrange_basis_coefficients(points, i, denom);
        add_lagrange_value(result, values[i], basis_coeffs, all_vars, var_idx);
    }
    return result;
}

引用了 add_lagrange_value(), lagrange_basis_coefficients(), lagrange_interpolate() , 以及 main_var.

被这些函数引用 extended_gcd_interpolation(), lagrange_interpolate() , 以及 recursive_multivariate_gcd().

函数调用图:

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

lagrange_multiplier_names()

std::vector< std::string > LMCAS::lagrange_multiplier_names ( size_t count )

static

在文件 vector_calculus_lagrange.cpp 第 43 行定义.

{
    std::vector<std::string> names;
    names.reserve(count);
    for (size_t k = 0; k < count; ++k) {
        names.push_back("lambda_" + std::to_string(k + 1));
    }
    return names;
}

引用了 lagrange_multiplier_names().

被这些函数引用 lagrange_multiplier_names() , 以及 lagrange_multipliers_strict().

函数调用图:

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

lagrange_multipliers()

std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > LMCAS::lagrange_multipliers	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	constraints,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_lagrange.cpp 第 252 行定义.

{
    auto result = lagrange_multipliers_checked(f, constraints, vars);
    if (!result && result.error().code != CasErrc::Inconclusive &&
        result.error().code != CasErrc::UnsupportedExpression &&
        result.error().code != CasErrc::DomainError) {
        throw result.error();
    }
    return result ? std::move(result.value()) :
        std::vector<std::map<std::string, std::shared_ptr<SymbolicExpr>>>{};
}

引用了 DomainError, Inconclusive, lagrange_multipliers(), lagrange_multipliers_checked(), UnsupportedExpression , 以及 vars.

被这些函数引用 lagrange_multipliers().

函数调用图:

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

lagrange_multipliers_checked() [1/2]

LagrangeResult LMCAS::lagrange_multipliers_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	constraints,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_lagrange.cpp 第 244 行定义.

{
    ComputationContext context;
    return lagrange_multipliers_checked(f, constraints, vars, context);
}

引用了 context, lagrange_multipliers_checked() , 以及 vars.

函数调用图:

lagrange_multipliers_checked() [2/2]

LagrangeResult LMCAS::lagrange_multipliers_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	constraints,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

在文件 vector_calculus_lagrange.cpp 第 193 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "lagrange_multipliers");
    const std::string operation = "lagrange_multipliers";
    auto valid = vector_calculus_validate_expr_vars(f, vars, context, operation);
    if (!valid) {
        return LagrangeResult::failure(valid.error());
    }
    auto distinct = vector_calculus_validate_distinct_vars(vars, vars.size(), context, operation);
    if (!distinct) {
        return LagrangeResult::failure(distinct.error());
    }
    if (constraints.empty()) {
        return LagrangeResult::failure(CasErrc::InvalidArgument,
                                       "constraint list cannot be empty",
                                       operation);
    }
    for (const auto& constraint : constraints) {
        if (!constraint || !LMCAS::detail::node(constraint)) {
            return LagrangeResult::failure(CasErrc::InvalidArgument,
                                           "constraint expressions cannot be null",
                                           operation);
        }
    }
    auto step = context.consume_steps(vars.size() * constraints.size() * 6 +
                                      vars.size() * 6 + constraints.size() * 4 + 8,
                                      operation);
    if (!step) {
        return LagrangeResult::failure(step.error());
    }
 
    try {
        return lagrange_multipliers_strict(f, constraints, vars, context, operation, transform_budget);
    } catch (const CasError& error) {
        return LagrangeResult::failure(error);
    } catch (const std::bad_alloc&) {
        return LagrangeResult::failure(CasErrc::ResourceLimit,
                                       "Lagrange multiplier allocation failed",
                                       operation);
    } catch (const std::length_error& error) {
        return LagrangeResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return LagrangeResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > >::failure(), InternalInvariant, InvalidArgument, lagrange_multipliers_checked(), lagrange_multipliers_strict(), LMCAS::detail::node(), ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars().

被这些函数引用 lagrange_multipliers(), lagrange_multipliers_checked() , 以及 lagrange_multipliers_checked().

函数调用图:

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

lagrange_multipliers_strict()

LagrangeResult LMCAS::lagrange_multipliers_strict ( const std::shared_ptr< SymbolicExpr > & f, const std::vector< std::shared_ptr< SymbolicExpr > > & constraints, const std::vector< std::string > & vars, ComputationContext & context, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_lagrange.cpp 第 147 行定义.

{
    const size_t n = vars.size();
    const size_t m = constraints.size();
    auto gradient = lagrange_gradient_strict(f, vars, operation, transform_budget);
    if (!gradient) {
        return LagrangeResult::failure(gradient.error());
    }
    std::vector<VectorField> grad_constraints;
    grad_constraints.reserve(m);
    for (const auto& constraint : constraints) {
        auto partials = lagrange_gradient_strict(constraint, vars, operation, transform_budget);
        if (!partials) {
            return LagrangeResult::failure(partials.error());
        }
        grad_constraints.push_back(std::move(partials.value()));
    }
    auto lambda_names = lagrange_multiplier_names(m);
    VectorField equations;
    equations.reserve(n + m);
    for (size_t i = 0; i < n; ++i) {
        auto equation = lagrange_stationarity_equation(
            gradient.value(), grad_constraints, lambda_names, i);
        auto checked = vector_calculus_simplify_strict(equation, operation,
            "Lagrange stationarity equation is outside the supported domain", transform_budget);
        if (!checked) {
            return LagrangeResult::failure(checked.error());
        }
        equations.push_back(std::move(checked.value()));
    }
    for (const auto& constraint : constraints) equations.push_back(constraint);
    std::vector<std::string> all_vars;
    all_vars.reserve(n + m);
    all_vars.insert(all_vars.end(), vars.begin(), vars.end());
    all_vars.insert(all_vars.end(), lambda_names.begin(), lambda_names.end());
    auto solutions = solve_lagrange_strict(equations, all_vars, context, operation);
    if (!solutions) {
        return solutions;
    }
    return verify_lagrange_solutions(solutions.value(), equations, all_vars, vars, context, operation, transform_budget);
}

引用了 context, LMCAS::Result< std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > >::failure(), gradient(), lagrange_gradient_strict(), lagrange_multiplier_names(), lagrange_multipliers_strict(), lagrange_stationarity_equation(), solve_lagrange_strict(), vars, LMCAS::vector_calculus_detail::vector_calculus_simplify_strict() , 以及 verify_lagrange_solutions().

被这些函数引用 lagrange_multipliers_checked() , 以及 lagrange_multipliers_strict().

函数调用图:

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

lagrange_stationarity_equation()

std::shared_ptr< SymbolicExpr > LMCAS::lagrange_stationarity_equation ( const VectorField & gradient, const std::vector< VectorField > & constraints, const std::vector< std::string > & multipliers, size_t index )

static

在文件 vector_calculus_lagrange.cpp 第 53 行定义.

{
    auto equation = gradient[index];
    for (size_t k = 0; k < multipliers.size(); ++k) {
        auto multiplier = SymbolicExpr::variable(multipliers[k]);
        auto term = SymbolicExpr::multiply(multiplier, constraints[k][index]);
        equation = SymbolicExpr::add(equation,
            SymbolicExpr::multiply(SymbolicExpr::number(-1), term));
    }
    return equation;
}

引用了 gradient() , 以及 lagrange_stationarity_equation().

被这些函数引用 lagrange_multipliers_strict() , 以及 lagrange_stationarity_equation().

函数调用图:

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

lammp_gcd()

uint64_t LMCAS::lammp_gcd ( uint64_t a, uint64_t b )

inline

计算两个无符号整数的最大公约数（调用 LMMP）

参数

a	第一个无符号整数
b	第二个无符号整数

返回

gcd(a, b)

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

                                                  {
    if (a == 0) return b;
    if (b == 0) return a;
    return lmmp_gcd_11_(a, b);
}

引用了 a, b , 以及 lammp_gcd().

被这些函数引用 lammp_gcd().

函数调用图:

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

lammp_is_prime()

bool LMCAS::lammp_is_prime ( uint64_t n )

inline

判断无符号整数是否为素数

参数

n

待判断的整数

返回

是素数返回 true

在文件 modular_arithmetic.hpp 第 112 行定义.

                                       {
    return lmmp_is_prime_ulong_(n);
}

引用了 lammp_is_prime().

被这些函数引用 lammp_is_prime().

函数调用图:

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

lammp_next_prime()

uint64_t LMCAS::lammp_next_prime ( uint64_t n )

inline

求大于 n 的下一个素数

参数

n

起始值

返回

大于 n 的最小素数

在文件 modular_arithmetic.hpp 第 121 行定义.

                                             {
    return lmmp_next_prime_ulong_(n);
}

引用了 lammp_next_prime().

被这些函数引用 lammp_next_prime().

函数调用图:

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

laplace_transform_checked() [1/2]

TransformEngineResult LMCAS::laplace_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	t,
		const std::string &	s )

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

                        {
    ComputationContext context;
    return laplace_transform_checked(f, t, s, context);
}

引用了 context, laplace_transform_checked() , 以及 t.

函数调用图:

laplace_transform_checked() [2/2]

TransformEngineResult LMCAS::laplace_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	t,
		const std::string &	s,
		ComputationContext &	context )

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

                                 {
    const std::string operation = "laplace_transform";
    auto valid = te_validate_expr_vars(f, t, s, context, operation);
    if (!valid) return TransformEngineResult::failure(valid.error());
    auto step = context.consume_steps(8, operation);
    if (!step) return TransformEngineResult::failure(step.error());
    try {
        auto expression = laplace_transform_core(f, t, s, context);
        auto final_access = context.consume_steps(0, operation);
        if (!final_access) {
            return TransformEngineResult::failure(final_access.error());
        }
        auto result = te_wrap_transform_result(std::move(expression), operation);
        if (result) {
            result.value().value.roc = te_laplace_roc(f, t, s);
        }
        return result;
    } catch (const CasError& error) {
        return TransformEngineResult::failure(error);
    } catch (const std::bad_alloc&) {
        return TransformEngineResult::failure(CasErrc::ResourceLimit,
                                              "transform allocation failed",
                                              operation);
    } catch (const std::exception& e) {
        return TransformEngineResult::failure(CasErrc::InternalInvariant,
                                              e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< Verified< EvaluatedTransform > >::failure(), InternalInvariant, laplace_transform_checked(), LMCAS::transform_detail::laplace_transform_core(), ResourceLimit, t, te_laplace_roc(), LMCAS::transform_detail::te_validate_expr_vars() , 以及 LMCAS::transform_detail::te_wrap_transform_result().

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

函数调用图:

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

laplacian()

std::shared_ptr< SymbolicExpr > LMCAS::laplacian	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_differential.cpp 第 359 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "laplacian");
    return laplacian_impl(f, vars, transform_budget);
}

引用了 context, laplacian(), LMCAS::vector_calculus_detail::laplacian_impl() , 以及 vars.

被这些函数引用 laplacian().

函数调用图:

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

laplacian_checked() [1/2]

VectorCalculusExprResult LMCAS::laplacian_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_differential.cpp 第 287 行定义.

{
    ComputationContext context;
    return laplacian_checked(f, vars, context);
}

引用了 context, laplacian_checked() , 以及 vars.

函数调用图:

laplacian_checked() [2/2]

VectorCalculusExprResult LMCAS::laplacian_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		ComputationContext &	context )

在文件 vector_calculus_differential.cpp 第 256 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "laplacian");
    const std::string operation = "laplacian";
    auto valid = vector_calculus_validate_expr_vars(f, vars, context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
    auto step = context.consume_steps(vars.size() * 2, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
    try {
        return vector_calculus_wrap_expr(laplacian_impl(f, vars, transform_budget), operation);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "vector calculus allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, laplacian_checked(), LMCAS::vector_calculus_detail::laplacian_impl(), ResourceLimit, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_wrap_expr().

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

函数调用图:

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

laurent_series_checked() [1/2]

ExpressionResult LMCAS::laurent_series_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	center,
		int	order_neg,
		int	order_pos )

在文件 series_expansions.cpp 第 372 行定义.

{
    ComputationContext context;
    return laurent_series_checked(f, var, center, order_neg, order_pos, context);
}

引用了 context , 以及 laurent_series_checked().

函数调用图:

laurent_series_checked() [2/2]

ExpressionResult LMCAS::laurent_series_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	center,
		int	order_neg,
		int	order_pos,
		ComputationContext &	context )

在文件 series_expansions.cpp 第 338 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto full = laurent_series_full_checked(
        f, var, center, order_neg, order_pos, context);
    if (!full) {
        return ExpressionResult::failure(full.error());
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(f), transform_budget));
    auto supported_power = simplified
        ? supported_laurent_integer_power(
              LMCAS::detail::node(simplified), var)
        : std::nullopt;
    if (center->is_zero() && supported_power && *supported_power < 0) {
        return ExpressionResult::success(std::move(simplified));
    }
    return ExpressionResult::success(std::move(full.value().series));
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "laurent_series_checked");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "laurent_series_checked");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "laurent_series_checked");
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), laurent_series_checked(), laurent_series_full_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 supported_laurent_integer_power().

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

函数调用图:

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

laurent_series_full_checked() [1/2]

LaurentSeriesResult LMCAS::laurent_series_full_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	center,
		int	order_neg,
		int	order_pos )

在文件 series_expansions.cpp 第 477 行定义.

{
    ComputationContext context;
    return laurent_series_full_checked(f, var, center, order_neg, order_pos, context);
}

引用了 context , 以及 laurent_series_full_checked().

函数调用图:

laurent_series_full_checked() [2/2]

LaurentSeriesResult LMCAS::laurent_series_full_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	center,
		int	order_neg,
		int	order_pos,
		ComputationContext &	context )

在文件 series_expansions.cpp 第 411 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "laurent_series_full";
    auto input = validate_series_expr_point(f, center, var, context, operation);
    if (!input) {
        return LaurentSeriesResult::failure(input.error());
    }
    auto order_check = validate_laurent_orders(order_neg, order_pos, operation);
    if (!order_check) {
        return LaurentSeriesResult::failure(order_check.error());
    }
    auto budget = context.consume_steps(static_cast<std::size_t>(order_neg + order_pos + 1) * 16 + 16,
                                        operation);
    if (!budget) {
        return LaurentSeriesResult::failure(budget.error());
    }
    try {
        auto simplified_input = detail::make_expression_ptr(detail::normalize_node(detail::node(f), transform_budget));
        if (!simplified_input || !LMCAS::detail::node(simplified_input)) {
            return LaurentSeriesResult::failure(
                CasErrc::Inconclusive,
                "checked Laurent input could not be simplified in the supported domain",
                operation);
        }
        auto supported_power = supported_laurent_integer_power(
            LMCAS::detail::node(simplified_input), var);
        auto built = laurent_series_full_impl(
            f, var, center, order_neg, order_pos, context);
        if (!built) {
            return built;
        }
        auto result = std::move(built.value());
        auto valid = validate_laurent_result(result, supported_power, center, operation);
        if (!valid) {
            return LaurentSeriesResult::failure(valid.error());
        }
        return LaurentSeriesResult::success(std::move(result));
    } catch (const CasError& error) {
        return LaurentSeriesResult::failure(error);
    } catch (const std::bad_alloc&) {
        return LaurentSeriesResult::failure(CasErrc::ResourceLimit,
                                            "allocation failed while calculating Laurent series",
                                            operation);
    } catch (const std::length_error& error) { return LaurentSeriesResult::failure(CasErrc::ResourceLimit, error.what(), "laurent_series_full"); } catch (const std::exception& ex) {
        return LaurentSeriesResult::failure(CasErrc::InternalInvariant,
                                            ex.what(),
                                            operation);
    }
} catch (const CasError& error) {
    return LaurentSeriesResult::failure(error);
} catch (const std::bad_alloc&) {
    return LaurentSeriesResult::failure(CasErrc::ResourceLimit, "allocation failed", "laurent_series_full");
} catch (const std::length_error& error) {
    return LaurentSeriesResult::failure(CasErrc::ResourceLimit, error.what(), "laurent_series_full");
} catch (const std::exception& error) {
    return LaurentSeriesResult::failure(CasErrc::InternalInvariant, error.what(), "laurent_series_full");
}

引用了 context, LMCAS::Result< LaurentResult >::failure(), Inconclusive, InternalInvariant, laurent_series_full_checked(), laurent_series_full_impl(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), ResourceLimit, LMCAS::Result< LaurentResult >::success(), supported_laurent_integer_power(), validate_laurent_orders(), validate_laurent_result() , 以及 validate_series_expr_point().

被这些函数引用 laurent_series_checked(), laurent_series_full_checked() , 以及 laurent_series_full_checked().

函数调用图:

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

laurent_series_full_impl()

LaurentSeriesResult LMCAS::laurent_series_full_impl ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, const std::shared_ptr< SymbolicExpr > & center, int order_neg, int order_pos, ComputationContext & context )

static

对 regular(解析部分)做 Taylor 展开

Laurent = taylor / (x-c)^pole_order

留数 = Taylor 展开中 (x-c)^(pole_order-1) 的系数

a_{m-1} = (1/(m-1)!) lim_{x->c} d^{m-1}/dx^{m-1} [regular]

用极限求值,稳健处理 0/0 形式(如 z/(z(z+1)) 在 z=0).

在文件 series_expansions.cpp 第 569 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    LaurentResult res{nullptr, SingularityType::Removable, 0, SymbolicExpr::number(0)};
    if (!f || !center) {
        return res;
    }
 
    auto x = SymbolicExpr::variable(var);
    auto shift = SymbolicExpr::add(x, SymbolicExpr::multiply(SymbolicExpr::number(-1), center));
    if (!expression_depends_on_variable(detail::node(center), var)) {
        if (auto m = essential_exponent(f, shift, context)) {
            return essential_laurent(shift, *m, order_neg, context);
        }
    }
 
    std::shared_ptr<SymbolicExpr> regular = f;
    auto extracted = extract_laurent_regular_part(
        f, var, center, shift, regular, context);
    if (!extracted) {
        return LaurentSeriesResult::failure(extracted.error());
    }
    const int pole_order = extracted.value();
 
    /// 对 regular(解析部分)做 Taylor 展开
    int taylor_order = order_pos + pole_order + 1;
    if (taylor_order < 1) {
        taylor_order = 1;
    }
    auto taylor = regular->series(var, center, taylor_order);
    if (!taylor) {
        return res;
    }
 
    /// Laurent = taylor / (x-c)^pole_order
    std::shared_ptr<SymbolicExpr> laurent = taylor;
    if (pole_order > 0) {
        auto powm = SymbolicExpr::power(shift, SymbolicExpr::number(pole_order));
        laurent = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(taylor, powm)), transform_budget));
    }
 
    res.series = detail::make_expression_ptr(detail::normalize_node(detail::node(laurent), transform_budget));
    res.pole_order = pole_order;
    if (pole_order == 0) {
        res.singularity = SingularityType::Removable;
    } else {
        res.singularity = SingularityType::Pole;
    }
 
    /// 留数 = Taylor 展开中 (x-c)^(pole_order-1) 的系数
    if (pole_order >= 1) {
        /// a_{m-1} = (1/(m-1)!) lim_{x->c} d^{m-1}/dx^{m-1} [regular]
        auto deriv = regular;
        for (int i = 0; i < pole_order - 1; ++i) deriv = detail::make_expression_ptr(detail::differentiate_node(detail::node(deriv), var, transform_budget));
        /// 用极限求值,稳健处理 0/0 形式(如 z/(z(z+1)) 在 z=0).
        auto limited = limit_expression_checked(
            deriv, var, center, LimitDirection::Both, context);
        if (!limited) {
            return LaurentSeriesResult::failure(limited.error());
        }
        auto val = std::move(limited.value());
        if (!val) {
            val = detail::make_expression_ptr(detail::substitute_node(detail::node(deriv), var, detail::node(center), transform_budget));
        }
        auto fact = BigInt::factorial_checked(BigInt(pole_order - 1), context);
        if (!fact) {
            return LaurentSeriesResult::failure(fact.error());
        }
        res.residue = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(val, SymbolicExpr::number(fact.value()))), transform_budget));
    }
 
    return res;
} catch (const CasError& error) {
    return LaurentSeriesResult::failure(error);
} catch (const std::bad_alloc&) {
    return LaurentSeriesResult::failure(CasErrc::ResourceLimit, "allocation failed", "laurent_series_full_impl");
} catch (const std::length_error& error) {
    return LaurentSeriesResult::failure(CasErrc::ResourceLimit, error.what(), "laurent_series_full_impl");
} catch (const std::exception& error) {
    return LaurentSeriesResult::failure(CasErrc::InternalInvariant, error.what(), "laurent_series_full_impl");
}

引用了 Both, context, LMCAS::detail::differentiate_node(), essential_exponent(), essential_laurent(), expression_depends_on_variable(), extract_laurent_regular_part(), LMCAS::Result< LaurentResult >::failure(), laurent_series_full_impl(), limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), Pole, LMCAS::LaurentResult::pole_order, Removable, LMCAS::LaurentResult::residue, LMCAS::LaurentResult::series, LMCAS::LaurentResult::singularity , 以及 LMCAS::detail::substitute_node().

被这些函数引用 laurent_series_full_checked() , 以及 laurent_series_full_impl().

函数调用图:

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

lcm_monomial()

Monomial LMCAS::lcm_monomial ( const Monomial & a, const Monomial & b )

inline

计算两个单项式的最小公倍单项式

参数

a	第一个单项式
b	第二个单项式

返回

各分量取最大值构成的单项式

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

                                                                   {
    Monomial result(std::max(a.size(), b.size()), 0);
    for (size_t i = 0; i < a.size(); ++i)
        result[i] = std::max(result[i], a[i]);
    for (size_t i = 0; i < b.size(); ++i)
        result[i] = std::max(result[i], b[i]);
    return result;
}

引用了 a, b , 以及 lcm_monomial().

被这些函数引用 lcm_monomial().

函数调用图:

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

le()

ExprResult LMCAS::le	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

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

                                                      {
    return relation(lhs, rhs, RelationOp::LEQ);
}

引用了 le(), LEQ, relation() , 以及 rhs.

被这些函数引用 le().

函数调用图:

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

lie_derivative_checked() [1/2]

DifferentialGeometryExprResult LMCAS::lie_derivative_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	X,
		const std::vector< std::string > &	vars,
		int	order )

在文件 differential_geometry.cpp 第 678 行定义.

{
    ComputationContext context;
    return lie_derivative_checked(f, X, vars, order, context);
}

引用了 context, lie_derivative_checked(), order , 以及 vars.

函数调用图:

lie_derivative_checked() [2/2]

DifferentialGeometryExprResult LMCAS::lie_derivative_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	X,
		const std::vector< std::string > &	vars,
		int	order,
		ComputationContext &	context )

在文件 differential_geometry.cpp 第 637 行定义.

{
    const std::string operation = "lie_derivative";
    auto step = context.consume_steps(1, operation);
    if (!step) return DifferentialGeometryExprResult::failure(step.error());
    if (!f || !LMCAS::detail::node(f)) {
        return DifferentialGeometryExprResult::failure(CasErrc::InvalidArgument,
                                                       "scalar function cannot be null",
                                                       operation);
    }
    if (order < 0 || order > 64) {
        return DifferentialGeometryExprResult::failure(CasErrc::InvalidArgument,
                                                       "Lie derivative order must be between 0 and 64",
                                                       operation);
    }
    auto vector_check = validate_expr_vector(X, vars, "vector field", operation);
    if (!vector_check) return DifferentialGeometryExprResult::failure(vector_check.error());
    auto budget = context.consume_steps(static_cast<std::size_t>(order + 1) * vars.size() * 8 + 8,
                                        operation);
    if (!budget) return DifferentialGeometryExprResult::failure(budget.error());
    try {
        auto result = lie_derivative_impl(f, X, vars, order, context);
        return checked_geometry_expression(std::move(result), CasErrc::Inconclusive,
                                           "Lie derivative could not be constructed",
                                           operation);
    } catch (const std::bad_alloc&) {
        return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit,
                                                       "allocation failed while calculating Lie derivative",
                                                       operation);
    } catch (const std::exception& ex) {
        return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant,
                                                       ex.what(),
                                                       operation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, InvalidArgument, lie_derivative_checked(), lie_derivative_impl(), LMCAS::detail::node(), order, ResourceLimit , 以及 vars.

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

函数调用图:

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

lie_derivative_impl()

std::shared_ptr< SymbolicExpr > LMCAS::lie_derivative_impl ( const std::shared_ptr< SymbolicExpr > & f, const std::vector< std::shared_ptr< SymbolicExpr > > & X, const std::vector< std::string > & vars, int order, ComputationContext & context )

static

在文件 differential_geometry.cpp 第 688 行定义.

                                            {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f || X.size() != vars.size()) return SymbolicExpr::number(0);
    auto result = f;
    for (int it = 0; it < order; ++it) {
        auto acc = SymbolicExpr::number(0);
        for (size_t i = 0; i < vars.size(); ++i) {
            auto partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(result), vars[i], transform_budget));
            acc = SymbolicExpr::add(acc, SymbolicExpr::multiply(X[i], partial));
        }
        result = detail::make_expression_ptr(detail::normalize_node(detail::node(acc), transform_budget));
    }
    return result;
}

引用了 context, LMCAS::detail::differentiate_node(), lie_derivative_impl(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), order , 以及 vars.

被这些函数引用 lie_derivative_checked() , 以及 lie_derivative_impl().

函数调用图:

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

lifting_error_coefficient()

MultiPoly LMCAS::lifting_error_coefficient ( const MultiPoly & error, const std::string & lift_var, int lift_var_idx, const Rational & eval_point, int k, const std::vector< MultiPoly > & shift_powers, const std::vector< std::string > & vars )

static

逐次除以 (lift_var - eval_point)，再在 eval_point 处求值。 得到 error / (lift_var - eval_point)^k 的值， 等价于 error 的 k 阶导数在该点的值除以 k!。

在文件 multivariate_hensel.cpp 第 89 行定义.

                                      {
    MultiPoly error_k;
    if (eval_point.is_zero()) {
        std::vector<MultiPoly::Term> error_k_terms;
        for (const auto& term : error.terms()) {
            const Monomial& mono = term.first;
            int exp = (lift_var_idx >= 0 && static_cast<size_t>(lift_var_idx) < mono.size())
                      ? mono[lift_var_idx] : 0;
            if (exp == k) {
                Monomial reduced = mono;
                reduced[lift_var_idx] = 0;
                error_k_terms.emplace_back(std::move(reduced), term.second);
            }
        }
        if (error_k_terms.empty()) { return MultiPoly(Rational(0), vars); }
        error_k = MultiPoly(std::move(error_k_terms), vars);
    } else {
        /**
         * @brief 逐次除以 (lift_var - eval_point)，再在 eval_point 处求值。
         * 得到 error / (lift_var - eval_point)^k 的值，
         * 等价于 error 的 k 阶导数在该点的值除以 k!。
         */
        MultiPoly remainder = error;
        for (int j = 0; j < k; ++j) {
            MultiPoly eval_check = remainder.eval(lift_var, eval_point);
            if (!eval_check.is_zero()) {
                remainder = MultiPoly(Rational(0), vars);
                break;
            }
            try {
                remainder = remainder.exact_div(shift_powers[1]);
            } catch (const std::runtime_error&) {
                remainder = MultiPoly(Rational(0), vars);
                break;
            }
        }
        error_k = embed_hensel_terms(remainder.eval(lift_var, eval_point), vars);
        if (error_k.is_zero()) { return error_k; }
    }
    return error_k;
}

引用了 embed_hensel_terms(), exp(), lifting_error_coefficient() , 以及 vars.

被这些函数引用 apply_hensel_lift_steps() , 以及 lifting_error_coefficient().

函数调用图:

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

lifting_residual_is_zero()

bool LMCAS::lifting_residual_is_zero ( const MultiPoly & verify_error, int lift_var_idx, int k )

static

在文件 multivariate_hensel.cpp 第 153 行定义.

                                                              {
    if (verify_error.is_zero()) { return true; }
    bool residual_ok = true;
    for (const auto& term : verify_error.terms()) {
        const Monomial& mono = term.first;
        int exp = (lift_var_idx >= 0 &&
                   static_cast<size_t>(lift_var_idx) < mono.size())
                  ? mono[lift_var_idx] : 0;
        if (exp <= k) {
            residual_ok = false;
            break;
        }
    }
    return residual_ok;
}

引用了 exp() , 以及 lifting_residual_is_zero().

被这些函数引用 apply_hensel_lift_steps() , 以及 lifting_residual_is_zero().

函数调用图:

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

lifting_shift_powers()

std::vector< MultiPoly > LMCAS::lifting_shift_powers ( const std::vector< std::string > & vars, int lift_var_idx, const Rational & eval_point, int degree_bound )

static

< 零次幂 (lift_var - eval_point)^0 = 1。

在文件 multivariate_hensel.cpp 第 61 行定义.

                                                  {
    std::vector<MultiPoly> shift_powers;
    shift_powers.reserve(degree_bound + 1);
    shift_powers.push_back(MultiPoly(Rational(1), vars)); /**< 零次幂 (lift_var - eval_point)^0 = 1。 */
    if (lift_var_idx >= 0) {
        Monomial var_mono(vars.size(), 0);
        var_mono[lift_var_idx] = 1;
        std::vector<MultiPoly::Term> lin_terms;
        lin_terms.emplace_back(var_mono, Rational(1));
        if (!eval_point.is_zero()) {
            Monomial const_mono(vars.size(), 0);
            lin_terms.emplace_back(const_mono, -eval_point);
        }
        MultiPoly shift_lin(std::move(lin_terms), vars);
        shift_powers.push_back(shift_lin);
        for (int k = 2; k <= degree_bound; ++k) {
            shift_powers.push_back(shift_powers[k - 1] * shift_lin);
        }
    } else {
        for (int k = 1; k <= degree_bound; ++k) {
            shift_powers.push_back(MultiPoly(Rational(1), vars));
        }
    }
    return shift_powers;
}

引用了 lifting_shift_powers() , 以及 vars.

被这些函数引用 apply_hensel_lift_steps() , 以及 lifting_shift_powers().

函数调用图:

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

lim_inf_checked() [1/2]

ExpressionResult LMCAS::lim_inf_checked	(	const std::shared_ptr< SymbolicExpr > &	a_n,
		const std::string &	n )

在文件 series_sequence_limits.cpp 第 207 行定义.

                                                                {
    ComputationContext context;
    return lim_inf_checked(a_n, n, context);
}

引用了 context , 以及 lim_inf_checked().

函数调用图:

lim_inf_checked() [2/2]

ExpressionResult LMCAS::lim_inf_checked	(	const std::shared_ptr< SymbolicExpr > &	a_n,
		const std::string &	n,
		ComputationContext &	context )

在文件 series_sequence_limits.cpp 第 181 行定义.

                                 {
    constexpr const char* operation = "lim_inf";
    if (!a_n || !detail::node(a_n) || n.empty()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "lower limit requires a sequence term and index variable",
            operation);
    }
    auto budget = context.consume_steps(1, operation);
    if (!budget) {
        return ExpressionResult::failure(budget.error());
    }
    try {
        return sequence_extreme_limit(a_n, n, false, context);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while calculating lower limit", operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(
            CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, lim_inf_checked(), LMCAS::detail::node(), ResourceLimit , 以及 sequence_extreme_limit().

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

函数调用图:

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

lim_sup_checked() [1/2]

ExpressionResult LMCAS::lim_sup_checked	(	const std::shared_ptr< SymbolicExpr > &	a_n,
		const std::string &	n )

在文件 series_sequence_limits.cpp 第 175 行定义.

                                                                {
    ComputationContext context;
    return lim_sup_checked(a_n, n, context);
}

引用了 context , 以及 lim_sup_checked().

函数调用图:

lim_sup_checked() [2/2]

ExpressionResult LMCAS::lim_sup_checked	(	const std::shared_ptr< SymbolicExpr > &	a_n,
		const std::string &	n,
		ComputationContext &	context )

在文件 series_sequence_limits.cpp 第 149 行定义.

                                 {
    constexpr const char* operation = "lim_sup";
    if (!a_n || !detail::node(a_n) || n.empty()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "upper limit requires a sequence term and index variable",
            operation);
    }
    auto budget = context.consume_steps(1, operation);
    if (!budget) {
        return ExpressionResult::failure(budget.error());
    }
    try {
        return sequence_extreme_limit(a_n, n, true, context);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while calculating upper limit", operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(
            CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, lim_sup_checked(), LMCAS::detail::node(), ResourceLimit , 以及 sequence_extreme_limit().

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

函数调用图:

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

limit_checked() [1/2]

LimitResult LMCAS::limit_checked	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context,
		Domain	domain )

在文件 limit_result.cpp 第 633 行定义.

                                                                                                     {
    auto valid = validate_limit_input(expression, variable, point, direction, domain);
    if (!valid) { return LimitResult::failure(valid.error()); }
    auto step = context.consume_steps(1, "limit");
    if (!step) { return LimitResult::failure(step.error()); }
    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();
        return limit_at_checked_point(expression, variable, point, direction, context, facts, domain);
    } catch (const CasError& error) {
        return LimitResult::failure(error);
    } catch (const std::bad_alloc&) {
        return LimitResult::failure(CasErrc::ResourceLimit, "limit allocation failed", "limit");
    } catch (const std::exception& error) {
        return LimitResult::failure(CasErrc::InternalInvariant, error.what(), "limit");
    }
}

引用了 context, direction, domain, LMCAS::Result< Verified< LimitOutcome > >::failure(), InternalInvariant, limit_checked(), LMCAS::detail::no_facts(), point, ResourceLimit , 以及 variable.

被这些函数引用 LMCAS::detail::definite::boundary_value_checked(), classify_singular_point_checked(), continuity_at_checked(), is_vertical_asymptote(), limit_checked(), limit_checked(), limit_expression_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit() , 以及 LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit().

函数调用图:

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

limit_checked() [2/2]

LimitResult LMCAS::limit_checked	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		Domain	domain )

在文件 limit_result.cpp 第 652 行定义.

                                                                        {
    ComputationContext context;
    return limit_checked(expression, variable, point, direction, context, domain);
}

引用了 context, direction, domain, limit_checked(), point , 以及 variable.

函数调用图:

limit_expression_checked() [1/2]

LimitExpressionResult LMCAS::limit_expression_checked	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		ComputationContext &	context,
		Domain	domain )

在文件 limit_result.cpp 第 657 行定义.

                                                                                                     {
    auto result = limit_checked(expression, variable, point, direction, context, domain);
    if (!result) return LimitExpressionResult::failure(result.error());
    const auto& value = result.value().value;
    if (auto finite = std::get_if<FiniteLimit>(&value)) return LimitExpressionResult::success(finite->value);
    if (int sign = infinity_sign(value)) return LimitExpressionResult::success(SymbolicExpr::infinity(sign));
    return LimitExpressionResult::failure(CasErrc::Inconclusive, "limit does not exist", "limit");
}

引用了 context, direction, domain, LMCAS::Result< LimitExprPtr >::failure(), Inconclusive, infinity_sign(), limit_checked(), limit_expression_checked(), point, LMCAS::Result< LimitExprPtr >::success(), value , 以及 variable.

被这些函数引用 alternating_sequence_bound(), calculate_residue_impl(), collect_infinite_asymptotes(), collect_oblique_asymptote(), frobenius_coefficient_limit(), laurent_series_full_impl(), limit_expression_checked(), limit_expression_checked(), ratio_convergence_test(), sequence_extreme_limit(), singular_frobenius_solution() , 以及 validate_frobenius_regular_singular_domain().

函数调用图:

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

limit_expression_checked() [2/2]

LimitExpressionResult LMCAS::limit_expression_checked	(	const LimitExprPtr &	expression,
		const std::string &	variable,
		const LimitExprPtr &	point,
		LimitDirection	direction,
		Domain	domain )

在文件 limit_result.cpp 第 666 行定义.

                                                                        {
    ComputationContext context;
    return limit_expression_checked(expression, variable, point, direction, context, domain);
}

引用了 context, direction, domain, limit_expression_checked(), point , 以及 variable.

函数调用图:

line_from_two_points_checked() [1/2]

LineSymbolicResult LMCAS::line_from_two_points_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	p1,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p2 )

在文件 symbolic_geometry_line.cpp 第 239 行定义.

                                                      {
    ComputationContext context;
    return line_from_two_points_checked(p1, p2, context);
}

引用了 context, line_from_two_points_checked() , 以及 p2.

函数调用图:

line_from_two_points_checked() [2/2]

LineSymbolicResult LMCAS::line_from_two_points_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	p1,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p2,
		ComputationContext &	context )

在文件 symbolic_geometry_line.cpp 第 181 行定义.

                                 {
    const std::string operation = "line_from_two_points";
    try {
        auto valid = validate_same_dimension_vectors(p1, p2, context, operation);
        if (!valid) return LineSymbolicResult::failure(valid.error());
        if (p1.size() != 3) {
            return LineSymbolicResult::failure(
                CasErrc::InvalidArgument,
                "line construction requires 3-dimensional points",
                operation);
        }
        auto step = context.consume_steps(4, operation);
        if (!step) return LineSymbolicResult::failure(step.error());
 
        std::vector<double> p1_values;
        std::vector<double> p2_values;
        auto difference_scale = point_difference_scale_checked(
            p1, p2, context, operation, p1_values, p2_values);
        if (!difference_scale) {
            return LineSymbolicResult::failure(difference_scale.error());
        }
        const double point_scale = difference_scale.value();
 
        LineSymbolic line;
        line.point = p1;
        line.direction.reserve(3);
        for (size_t i = 0; i < p1.size(); ++i) {
            if (point_scale != 0.0) {
                line.direction.push_back(SymbolicExpr::number(
                    p2_values[i] / point_scale -
                    p1_values[i] / point_scale));
                continue;
            }
            auto component = SymbolicExpr::add(
                p2[i],
                SymbolicExpr::multiply(SymbolicExpr::number(-1), p1[i]));
            auto simplified = simplify_checked(
                component, operation,
                "line direction component is outside the supported domain", context);
            if (!simplified) return LineSymbolicResult::failure(simplified.error());
            line.direction.push_back(std::move(simplified.value()));
        }
        auto line_valid = validate_line_checked(line, context, operation);
        if (!line_valid) return LineSymbolicResult::failure(line_valid.error());
        return LineSymbolicResult::success(std::move(line));
    } catch (const std::bad_alloc&) {
        return LineSymbolicResult::failure(CasErrc::ResourceLimit,
                                           "vector geometry allocation failed",
                                           operation);
    } catch (const std::exception& e) {
        return LineSymbolicResult::failure(CasErrc::InternalInvariant,
                                           e.what(), operation);
    }
}

引用了 context, LMCAS::LineSymbolic::direction, e(), LMCAS::Result< LineSymbolic >::failure(), InternalInvariant, InvalidArgument, line_from_two_points_checked(), p2, LMCAS::LineSymbolic::point, ResourceLimit, LMCAS::geometry_detail::simplify_checked(), LMCAS::Result< LineSymbolic >::success(), LMCAS::geometry_detail::validate_line_checked() , 以及 LMCAS::geometry_detail::validate_same_dimension_vectors().

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

函数调用图:

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

line_plane_intersection_checked() [1/2]

VectorExprListResult LMCAS::line_plane_intersection_checked	(	const LineSymbolic &	line,
		const PlaneSymbolic &	plane )

在文件 symbolic_geometry_line_plane.cpp 第 294 行定义.

  {
    ComputationContext context;
    return line_plane_intersection_checked(line, plane, context);
}

引用了 context, line_plane_intersection_checked() , 以及 plane.

函数调用图:

line_plane_intersection_checked() [2/2]

VectorExprListResult LMCAS::line_plane_intersection_checked	(	const LineSymbolic &	line,
		const PlaneSymbolic &	plane,
		ComputationContext &	context )

在文件 symbolic_geometry_line_plane.cpp 第 218 行定义.

  {
    const std::string operation = "line_plane_intersection";
    try {
        auto valid = validate_intersection_inputs(line, plane, context, operation);
        if (!valid) {
            return VectorExprListResult::failure(valid.error());
        }
 
        std::vector<double> normal_values;
        std::vector<double> direction_values;
        auto normal_scale = numeric_vector_scale_checked(
            plane.normal, context, operation, &normal_values);
        if (!normal_scale) {
            return VectorExprListResult::failure(normal_scale.error());
        }
        auto direction_scale = numeric_vector_scale_checked(
            line.direction, context, operation, &direction_values);
        if (!direction_scale) {
            return VectorExprListResult::failure(direction_scale.error());
        }
        std::vector<double> point_values;
        auto point_scale = numeric_vector_scale_checked(
            line.point, context, operation, &point_values);
        if (!point_scale && interrupts_optional_numeric_evaluation(point_scale.error())) {
            return VectorExprListResult::failure(point_scale.error());
        }
        auto plane_offset = evaluate_numeric(*plane.d, NumericBindings{}, context);
        const bool numeric_plane_offset = finite_plane_offset(plane_offset);
        if (!plane_offset && interrupts_optional_numeric_evaluation(plane_offset.error())) {
            return VectorExprListResult::failure(plane_offset.error());
        }
 
        const bool scale_direction_products = direction_products_need_scaling(
            normal_scale.value(), direction_scale.value());
        const bool protect_point_dot =
            point_dot_needs_protection(normal_scale.value(), point_scale);
        const std::vector<std::shared_ptr<SymbolicExpr>>* effective_normal = &plane.normal;
        const std::vector<std::shared_ptr<SymbolicExpr>>* effective_direction = &line.direction;
        std::vector<std::shared_ptr<SymbolicExpr>> scaled_normal;
        std::vector<std::shared_ptr<SymbolicExpr>> scaled_direction;
        std::shared_ptr<SymbolicExpr> effective_d = plane.d;
        if (scale_direction_products || protect_point_dot) {
            scale_symbolic_components(
                normal_values, normal_scale.value(), protect_point_dot, scaled_normal);
            effective_normal = &scaled_normal;
            effective_d = scale_plane_offset(plane.d, normal_scale.value(), protect_point_dot);
        }
        if (scale_direction_products) {
            scale_symbolic_components(
                direction_values, direction_scale.value(), false, scaled_direction);
            effective_direction = &scaled_direction;
        }
 
        if (coordinate_update_needs_protection(point_scale, numeric_plane_offset)) {
            return protected_coordinate_intersection(
                normal_values, normal_scale.value(),
                direction_values, direction_scale.value(),
                point_values, point_scale.value(), plane_offset.value().value, operation);
        }
        return symbolic_line_plane_intersection(
            *effective_normal, *effective_direction, line.point, effective_d,
            context, operation);
    } catch (const std::bad_alloc&) {
        return VectorExprListResult::failure(CasErrc::ResourceLimit,
                                             "vector geometry allocation failed",
                                             operation);
    } catch (const std::exception& e) {
        return VectorExprListResult::failure(CasErrc::InternalInvariant,
                                             e.what(), operation);
    }
}

引用了 context, LMCAS::PlaneSymbolic::d, LMCAS::LineSymbolic::direction, e(), evaluate_numeric(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), InternalInvariant, line_plane_intersection_checked(), LMCAS::PlaneSymbolic::normal, LMCAS::geometry_detail::numeric_vector_scale_checked(), plane, LMCAS::LineSymbolic::point , 以及 ResourceLimit.

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

函数调用图:

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

linear2_root_basis()

std::shared_ptr< SymbolicExpr > LMCAS::linear2_root_basis ( const std::vector< ode_root_detail::CharRoot > & roots, const std::string & x )

static

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

                        {
    auto variable = SymbolicExpr::variable(x);
    auto solution = SymbolicExpr::number(0);
    int constant_index = 1;
    for (const auto& root : roots) {
        auto exponential = SymbolicExpr::exp(
            SymbolicExpr::multiply(
                SymbolicExpr::number(root.real_part), variable));
        if (root.is_complex) {
            auto argument = SymbolicExpr::multiply(
                SymbolicExpr::number(root.imag_part), variable);
            auto cosine_basis = SymbolicExpr::multiply(
                exponential, SymbolicExpr::cos(argument));
            auto sine_basis = SymbolicExpr::multiply(
                exponential, SymbolicExpr::sin(argument));
            auto cosine_term = SymbolicExpr::multiply(
                SymbolicExpr::variable(
                    "C" + std::to_string(constant_index++)),
                cosine_basis);
            auto sine_term = SymbolicExpr::multiply(
                SymbolicExpr::variable(
                    "C" + std::to_string(constant_index++)),
                sine_basis);
            solution = SymbolicExpr::add(
                solution, SymbolicExpr::add(cosine_term, sine_term));
            continue;
        }
        for (int power = 0; power < root.multiplicity; ++power) {
            auto basis = exponential;
            if (power > 0) {
                basis = SymbolicExpr::multiply(
                    SymbolicExpr::power(
                        variable, SymbolicExpr::number(power)),
                    exponential);
            }
            solution = SymbolicExpr::add(
                solution,
                SymbolicExpr::multiply(
                    SymbolicExpr::variable(
                        "C" + std::to_string(constant_index++)),
                    basis));
        }
    }
    return solution;
}

引用了 basis, linear2_root_basis(), roots() , 以及 variable.

被这些函数引用 linear2_root_basis() , 以及 solve_linear2_homogeneous().

函数调用图:

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

log() [1/2]

ExprResult LMCAS::log

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 129 行定义.

                                          {
    ComputationContext context;
    return log(expression, context);
}

引用了 context , 以及 log().

函数调用图:

log() [2/2]

ExprResult LMCAS::log	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 122 行定义.

                                                                       {
    auto valid = require_dimensionless(expression, "log");
    if (!valid) { return valid; }
    return make_unary_math_expr(expression, context, "log",
                                SymbolicExpr::ln);
}

引用了 context, log(), LMCAS::expr_detail::expr_common::make_unary_math_expr() , 以及 LMCAS::expr_detail::expr_common::require_dimensionless().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), log() , 以及 log().

函数调用图:

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

log10() [1/2]

ExprResult LMCAS::log10

(

const ExprPtr &

expression

)

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

                                            {
    ComputationContext context;
    return log10(expression, context);
}

引用了 context , 以及 log10().

函数调用图:

log10() [2/2]

ExprResult LMCAS::log10	(	const ExprPtr &	expression,
		ComputationContext &	context )

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

                                                                         {
    auto valid = require_dimensionless(expression, "log10");
    if (!valid) { return valid; }
    auto step = context.consume_steps(1, kMathOperation);
    if (!step) { return ExprResult::failure(step.error()); }
    if (!expression || !LMCAS::detail::node(expression)) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "log10 argument cannot be null",
                                  kMathOperation);
    }
    try {
        auto numerator = SymbolicExpr::ln(expression);
        auto denominator = SymbolicExpr::ln(SymbolicExpr::number(10));
        auto result = SymbolicExpr::divide(numerator, denominator);
        if (!result || !LMCAS::detail::node(result)) {
            return expression_failure(CasErrc::InternalInvariant,
                                      "log10 expression construction failed",
                                      kMathOperation);
        }
        return ExprResult::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "log10 expression allocation failed",
                                  kMathOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kMathOperation);
    }
}

引用了 context, denominator, LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::Result< ExprPtr >::failure(), InternalInvariant, InvalidArgument, LMCAS::expr_detail::expr_common::kMathOperation, log10(), LMCAS::detail::node(), LMCAS::expr_detail::expr_common::require_dimensionless(), ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), log10() , 以及 log10().

函数调用图:

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

log_differentiate()

std::shared_ptr< SymbolicExpr > LMCAS::log_differentiate	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var )

计算 ln(f)

对 ln(f) 求导 - 化简器会自动应用对数规则 (ln(a*b) = ln(a)+ln(b), ln(a^n) = n*ln(a))

结果 = f * d/dx[ln(f)]

在文件 calculus_utils.cpp 第 145 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f || !LMCAS::detail::node(f)) {
        return nullptr;
    }
 
    /// 计算 ln(f)
    auto ln_f = SymbolicExpr::ln(f);
 
    /// 对 ln(f) 求导 - 化简器会自动应用对数规则
    /// (ln(a*b) = ln(a)+ln(b), ln(a^n) = n*ln(a))
    auto ln_f_simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(ln_f), transform_budget));
    auto d_ln_f = detail::make_expression_ptr(detail::differentiate_node(detail::node(ln_f_simplified), var, transform_budget));
 
    /// 结果 = f * d/dx[ln(f)]
    auto result = SymbolicExpr::multiply(f, d_ln_f);
    return detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
}

引用了 context, LMCAS::detail::differentiate_node(), log_differentiate(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 log_differentiate().

函数调用图:

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

logical_and()

ExprResult LMCAS::logical_and	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

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

                                                               {
    return logical_expression(lhs, rhs, LogicalNode::Op::And, "LMCAS.logical_and");
}

引用了 LMCAS::LogicalNode::And, logical_and() , 以及 rhs.

被这些函数引用 logical_and().

函数调用图:

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

logical_not()

ExprResult LMCAS::logical_not

(

const ExprPtr &

expression

)

在文件 expr_facade.cpp 第 244 行定义.

                                                  {
    return logical_expression(expression, nullptr, LogicalNode::Op::Not,
                              "LMCAS.logical_not");
}

引用了 logical_not() , 以及 LMCAS::LogicalNode::Not.

被这些函数引用 logical_not() , 以及 membership().

函数调用图:

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

logical_or()

ExprResult LMCAS::logical_or	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_facade.cpp 第 240 行定义.

                                                              {
    return logical_expression(lhs, rhs, LogicalNode::Op::Or, "LMCAS.logical_or");
}

引用了 logical_or(), LMCAS::LogicalNode::Or , 以及 rhs.

被这些函数引用 logical_or().

函数调用图:

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

lookup_integral()

template<typename Transform>

std::shared_ptr< SymbolicExpr > LMCAS::lookup_integral	(	const std::vector< detail::IntegrationEntry > &	table,
		const SymbolicExpr &	matched,
		const std::string &	matched_variable,
		detail::RewriteBudget &	budget,
		Transform &&	transform )

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

                                                                                           {
    for (const auto& rule : table) {
        const auto* entry = &rule;
        budget.consume();
        MatchMap bindings;
        if (!Matcher::match(entry->pattern, matched, entry->wildcards, bindings)) { continue; }
        if (bindings.find("__Add_REST__") != bindings.end() ||
            bindings.find("__Mul_REST__") != bindings.end()) {
            continue;
        }
        const bool complete = std::all_of(entry->wildcards.begin(), entry->wildcards.end(),
            [&](const std::string& name) { return bindings.find(name) != bindings.end(); });
        if (!complete || (entry->condition && !entry->condition(bindings, matched_variable, budget.context()))) {
            continue;
        }
        auto instantiated = detail::make_expression_ptr(
            Matcher::replace(entry->result, bindings, false));
        budget.measure(detail::node(instantiated));
        if (contains_unevaluated_integral(detail::node(instantiated))) {
            continue;
        }
        auto candidate = transform(std::move(instantiated));
        if (!candidate) { continue; }
        return detail::make_expression_ptr(detail::normalize_node(detail::node(candidate), budget));
    }
    return nullptr;
}

引用了 bindings, LMCAS::detail::RewriteBudget::consume(), contains_unevaluated_integral(), LMCAS::detail::RewriteBudget::context(), lookup_integral(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), name, LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 lookup_integral().

函数调用图:

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

lt()

ExprResult LMCAS::lt	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

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

                                                      {
    return relation(lhs, rhs, RelationOp::LT);
}

引用了 LT, lt(), relation() , 以及 rhs.

被这些函数引用 lt() , 以及 LMCAS::groebner_detail::reduce().

函数调用图:

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

lu_decomposition_checked() [1/2]

LUDecompositionResult LMCAS::lu_decomposition_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

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

{
    ComputationContext context;
    return lu_decomposition_checked(A, context);
}

引用了 context , 以及 lu_decomposition_checked().

函数调用图:

lu_decomposition_checked() [2/2]

LUDecompositionResult LMCAS::lu_decomposition_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

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

{
    const std::string operation = "lu_decomposition";
    auto matrix = validate_decomposition_matrix(A, true, context, operation);
    if (!matrix) return LUDecompositionResult::failure(matrix.error());
    auto budget = context.consume_steps(matrix.value()->rows() * matrix.value()->cols() * 8 + 8,
                                        operation);
    if (!budget) return LUDecompositionResult::failure(budget.error());
    auto values = exact_rational_matrix(matrix.value(), context);
    if (!values) {
        return LUDecompositionResult::failure(
            CasErrc::Inconclusive,
            "exact PLU requires a rational matrix or proved symbolic pivots",
            operation);
    }
    try {
        const std::size_t n = values->size();
        auto U_values = *values;
        std::vector<std::vector<Rational>> L_values(
            n, std::vector<Rational>(n, Rational(0)));
        std::vector<std::vector<Rational>> P_values(
            n, std::vector<Rational>(n, Rational(0)));
        auto factored = factor_lu(L_values, U_values, P_values, operation);
        if (!factored) return LUDecompositionResult::failure(factored.error());
        return LUDecompositionResult::success(LUDecomposition{
            rational_rows_expression(P_values),
            rational_rows_expression(L_values),
            rational_rows_expression(U_values)});
    } catch (const std::bad_alloc&) {
        return LUDecompositionResult::failure(CasErrc::ResourceLimit,
                                             "allocation failed while calculating LU decomposition",
                                             operation);
    } catch (const std::exception& ex) {
        return LUDecompositionResult::failure(CasErrc::InternalInvariant,
                                             ex.what(),
                                             operation);
    }
}

引用了 context, LMCAS::detail::matrix_decomposition::exact_rational_matrix(), LMCAS::Result< LUDecomposition >::failure(), Inconclusive, InternalInvariant, lu_decomposition_checked(), ResourceLimit, LMCAS::Result< LUDecomposition >::success() , 以及 LMCAS::detail::matrix_decomposition::validate_decomposition_matrix().

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

函数调用图:

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

make_abs()

std::shared_ptr< SymbolicExpr > LMCAS::make_abs ( std::shared_ptr< SymbolicExpr > expr )

static

Wrap an expression in abs() to signal positive-branch preference.

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

                                                                              {
    return LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Abs,
            std::vector<std::shared_ptr<const SymbolicNode>>{LMCAS::detail::node(expr)}));
}

引用了 LMCAS::FunctionNode::Abs, make_abs(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node() , 以及 LMCAS::detail::node().

被这些函数引用 make_abs(), solve_linear1_ode(), solve_linear2_homogeneous() , 以及 solve_separable_ode().

函数调用图:

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

make_arctan()

std::shared_ptr< SymbolicExpr > LMCAS::make_arctan ( const std::shared_ptr< SymbolicExpr > & operand )

inline

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

                                                {
    return make_unary_function(FunctionNode::FuncType::ArcTan, operand);
}

引用了 LMCAS::FunctionNode::ArcTan, make_arctan() , 以及 make_unary_function().

被这些函数引用 make_arctan() , 以及 LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_negative_discriminant().

函数调用图:

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

make_complex()

ComplexSymbolic LMCAS::make_complex ( std::shared_ptr< SymbolicExpr > real, std::shared_ptr< SymbolicExpr > imag )

inline

构造符号复数

参数

real	实部表达式
imag	虚部表达式

返回

符号复数对象

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

  {
    return ComplexSymbolic{real, imag};
}

引用了 imag, make_complex() , 以及 real().

被这些函数引用 complex_add_checked(), complex_conj_checked(), complex_div_checked(), complex_exp_form_checked(), complex_locus_circle_checked(), complex_locus_perpendicular_bisector_checked(), complex_mul_checked(), complex_sub_checked() , 以及 make_complex().

函数调用图:

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

make_finite_set()

SymbolicSetResult LMCAS::make_finite_set	(	std::vector< std::shared_ptr< SymbolicExpr > >	elements,
		ComputationContext &	context )

在文件 symbolic_set.cpp 第 74 行定义.

                                 {
    auto step = consume(context);
    if (!step) return SymbolicSetResult::failure(step.error());
    std::vector<std::shared_ptr<const SymbolicNode>> nodes;
    nodes.reserve(elements.size());
    for (const auto& element : elements) {
        if (!element || !detail::node(element)) {
            return failure(CasErrc::InvalidArgument,
                           "finite set elements cannot be null");
        }
        nodes.push_back(detail::node(element));
    }
    return from_nodes(std::move(nodes));
}

引用了 context, element, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, make_finite_set() , 以及 LMCAS::detail::node().

被这些函数引用 finite_set() , 以及 make_finite_set().

函数调用图:

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

make_interval()

SymbolicSetResult LMCAS::make_interval	(	const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		bool	lower_closed,
		bool	upper_closed,
		ComputationContext &	context )

在文件 symbolic_set.cpp 第 91 行定义.

                                 {
    auto step = consume(context);
    if (!step) {
        return SymbolicSetResult::failure(step.error());
    }
    if (!lower || !upper || !detail::node(lower) || !detail::node(upper)) {
        return failure(CasErrc::InvalidArgument, "interval endpoints cannot be null");
    }
    Rational lower_value;
    Rational upper_value;
    if (exact_value(detail::node(lower), lower_value) &&
        exact_value(detail::node(upper), upper_value) &&
        upper_value < lower_value) {
        return failure(CasErrc::InvalidArgument,
                       "interval lower endpoint exceeds upper endpoint");
    }
    try {
        return SymbolicSetResult::success(detail::make_expression_ptr(
            detail::make_node<IntervalNode>(detail::node(lower), detail::node(upper),
                                            lower_closed, upper_closed)));
    } catch (const std::bad_alloc&) {
        return failure(CasErrc::ResourceLimit, "interval allocation failed");
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, lower, lower_closed, LMCAS::detail::make_expression_ptr(), make_interval(), LMCAS::detail::make_node(), LMCAS::detail::node(), ResourceLimit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), upper , 以及 upper_closed.

被这些函数引用 interval() , 以及 make_interval().

函数调用图:

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

make_membership()

SymbolicSetResult LMCAS::make_membership	(	const std::shared_ptr< SymbolicExpr > &	element,
		const std::shared_ptr< SymbolicExpr > &	set,
		ComputationContext &	context )

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

                                 {
    auto step = consume(context);
    if (!step) {
        return SymbolicSetResult::failure(step.error());
    }
    if (!element || !set || !detail::node(element) || !detail::node(set)) {
        return failure(CasErrc::InvalidArgument, "membership operands cannot be null");
    }
    if (auto finite = finite_set_node(*set)) {
        return SymbolicSetResult::success(SymbolicExpr::number(
            finite->contains(*detail::node(element)) ? 1 : 0));
    }
    if (auto interval = std::dynamic_pointer_cast<const IntervalNode>(detail::node(set))) {
        if (auto contained = exact_interval_membership(detail::node(element), *interval)) {
            return SymbolicSetResult::success(SymbolicExpr::number(*contained ? 1 : 0));
        }
    }
    return SymbolicSetResult::success(detail::make_expression_ptr(
        detail::make_node<MembershipNode>(detail::node(element), detail::node(set))));
}

引用了 context, element, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), interval(), InvalidArgument, LMCAS::detail::make_expression_ptr(), make_membership(), LMCAS::detail::make_node(), LMCAS::detail::node(), set , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 make_membership() , 以及 member().

函数调用图:

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

make_normalized_multiply_node()

std::shared_ptr< const SymbolicNode > LMCAS::make_normalized_multiply_node	(	const std::vector< std::shared_ptr< const SymbolicNode > > &	operands,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_utils.cpp 第 83 行定义.

                                 {
    std::size_t nodes = 0;
    if (budget) {
        for (const auto& op : ops) {
            nodes = budget->append_size(nodes, budget->measure(op));
        }
    }
    normalization_check_arithmetic<MultiplyNode>(budget, ops, nodes, ops.size() != 1);
    if (ops.empty()) {
        return LMCAS::detail::make_node<NumberNode>(BigInt(1));
    }
    if (ops.size() == 1) {
        return ops[0];
    }
    return LMCAS::detail::make_node<MultiplyNode>(ops);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::make_node(), make_normalized_multiply_node(), LMCAS::detail::RewriteBudget::measure(), normalization_check_arithmetic() , 以及 op.

被这些函数引用 check_negative_arg(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::NormalizationVisitor::extract_term_coefficient(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::finish(), LMCAS::anonymous_namespace{integration_linearity.cpp}::integration_exponential_argument(), make_normalized_multiply_node(), LMCAS::NormalizationVisitor::matrix_product_element(), normalization_imaginary_power(), LMCAS::NormalizationVisitor::normalize_function_parity(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_matrix_product(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::NormalizationVisitor::normalize_nested_power(), LMCAS::anonymous_namespace{normalization_trigonometric.cpp}::scaled_radical(), LMCAS::NormalizationVisitor::simplify_assumed_absolute(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::anonymous_namespace{normalization_arithmetic.cpp}::weighted_term().

函数调用图:

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

make_rootof_checked() [1/2]

RootOfConstructionResult LMCAS::make_rootof_checked	(	const std::shared_ptr< SymbolicExpr > &	polynomial,
		const std::string &	variable,
		std::size_t	index )

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

                     {
    ComputationContext context;
    return make_rootof_checked(polynomial, variable, index, context);
}

引用了 context, make_rootof_checked() , 以及 variable.

函数调用图:

make_rootof_checked() [2/2]

RootOfConstructionResult LMCAS::make_rootof_checked	(	const std::shared_ptr< SymbolicExpr > &	polynomial,
		const std::string &	variable,
		std::size_t	index,
		ComputationContext &	context )

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

                                 {
    constexpr const char* operation = "rootof.construct";
    if (!polynomial || !LMCAS::detail::node(polynomial) ||
        variable.empty()) {
        return RootOfConstructionResult::failure(
            CasErrc::InvalidArgument,
            "RootOf requires a polynomial and named variable", operation);
    }
    auto recognized = recognize_rational_polynomial(
        *polynomial, variable, context);
    if (!recognized) {
        return RootOfConstructionResult::failure(recognized.error());
    }
    if (!recognized.value()) {
        return RootOfConstructionResult::failure(
            CasErrc::Inconclusive,
            "RootOf coefficients must be exact rational constants",
            operation);
    }
    auto identity = detail::make_exact_root_id(
        std::move(*recognized.value()), index, context, operation);
    if (!identity) {
        return RootOfConstructionResult::failure(identity.error());
    }
    return RootOfConstructionResult::success(
        LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<RootOfNode>(
                std::move(identity.value()), variable)));
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InvalidArgument, LMCAS::detail::make_exact_root_id(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), make_rootof_checked(), LMCAS::detail::node(), recognize_rational_polynomial(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 variable.

被这些函数引用 LMCAS::expr_detail::ExprParser::apply_rootof(), LMCAS::detail::definite::definite_partition_checked(), exact_factor_roots(), make_rootof_checked(), make_rootof_checked() , 以及 solve_higher_exact_roots().

函数调用图:

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

make_rootof_solutions()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::make_rootof_solutions	(	const Polynomial< SymbolicPolyCoeff > &	poly,
		const std::string &	var )

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

                          {
    ComputationContext context;
    return detail::make_rootof_solutions_impl(poly, var, context);
}

引用了 context, make_rootof_solutions() , 以及 LMCAS::detail::make_rootof_solutions_impl().

被这些函数引用 make_rootof_solutions().

函数调用图:

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

make_unary_function()

std::shared_ptr< SymbolicExpr > LMCAS::make_unary_function ( FunctionNode::FuncType type, const std::shared_ptr< SymbolicExpr > & operand )

inline

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

                                                {
    return detail::make_expression_ptr(detail::make_node<FunctionNode>(
        type,
        std::vector<std::shared_ptr<const SymbolicNode>>{
            detail::node(operand)}));
}

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

被这些函数引用 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_hyperbolic_rules(), LMCAS::integration_table_detail::load_inverse_trig_rules(), LMCAS::integration_table_detail::load_scaled_radical_rules(), LMCAS::integration_table_detail::load_trig_derivatives_rules(), LMCAS::integration_table_detail::load_trig_primitives_rules(), make_arctan() , 以及 make_unary_function().

函数调用图:

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

match_commutative_recursive()

bool LMCAS::match_commutative_recursive ( const std::vector< std::shared_ptr< const SymbolicNode > > & p_ops, const std::vector< std::shared_ptr< const SymbolicNode > > & t_ops, std::vector< bool > & used_t, size_t p_index, const std::unordered_set< std::string > & wildcards, MatchMap & results )

static

在文件 matcher.cpp 第 18 行定义.

                                                           {
 
    if (p_index == p_ops.size()) {
        return true;
    }
 
    for (size_t j = 0; j < t_ops.size(); ++j) {
        if (!used_t[j]) {
 
            MatchMap saved_results = results;
 
            if (match_recursive(p_ops[p_index], t_ops[j], wildcards, results)) {
                used_t[j] = true;
                if (match_commutative_recursive(p_ops, t_ops, used_t, p_index + 1, wildcards, results)) {
                    return true;
                }
 
                used_t[j] = false;
                results = saved_results;
            } else {
 
                results = saved_results;
            }
        }
    }
 
    return false;
}

引用了 match_commutative_recursive(), match_recursive() , 以及 wildcards.

被这些函数引用 match_commutative_recursive() , 以及 match_operation().

函数调用图:

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

match_function()

bool LMCAS::match_function ( const FunctionNode & pattern, const FunctionNode & target, const std::unordered_set< std::string > & wildcards, MatchMap & results )

static

在文件 matcher.cpp 第 120 行定义.

                                                                                            {
    if (pattern.type() != target.type() || pattern.arguments().size() != target.arguments().size()) {
        return false;
    }
    for (size_t index = 0; index < pattern.arguments().size(); ++index) {
        if (!match_recursive(pattern.arguments()[index], target.arguments()[index], wildcards, results)) {
            return false;
        }
    }
    return true;
}

引用了 LMCAS::FunctionNode::arguments(), match_function(), match_recursive(), target, LMCAS::FunctionNode::type() , 以及 wildcards.

被这些函数引用 match_function() , 以及 match_recursive().

函数调用图:

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

match_operation()

template<typename Operation>

bool LMCAS::match_operation ( const Operation & pattern, const Operation & target, const std::unordered_set< std::string > & wildcards, const char * rest_key, MatchMap & results )

static

在文件 matcher.cpp 第 106 行定义.

                                                                     {
    if (pattern.operands().size() > target.operands().size()) {
        return false;
    }
    std::vector<bool> used(target.operands().size(), false);
    if (!match_commutative_recursive(pattern.operands(), target.operands(), used, 0, wildcards, results)) {
        return false;
    }
    record_remainder(target, used, rest_key, results);
    return true;
}

引用了 match_commutative_recursive(), match_operation(), record_remainder(), target , 以及 wildcards.

被这些函数引用 match_operation() , 以及 match_recursive().

函数调用图:

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

match_recursive()

bool LMCAS::match_recursive ( const std::shared_ptr< const SymbolicNode > & p_node, const std::shared_ptr< const SymbolicNode > & t_node, const std::unordered_set< std::string > & wildcards, MatchMap & results )

static

在文件 matcher.cpp 第 133 行定义.

                                                                                             {
    if (!pattern) {
        return !target;
    }
    if (!target) {
        return false;
    }
    std::string name;
    if (is_wildcard(pattern, wildcards, name)) {
        const auto existing = results.find(name);
        if (existing != results.end()) {
            return detail::node(existing->second)->equals(*target);
        }
        results.emplace(name, detail::expression_from_node(target));
        return true;
    }
    if (pattern->type_priority() != target->type_priority()) {
        return false;
    }
    if (pattern->is_number() || dynamic_cast<const VariableNode*>(pattern.get())) {
        return pattern->equals(*target);
    }
    if (const auto* add = dynamic_cast<const AddNode*>(pattern.get())) {
        return match_operation(*add, static_cast<const AddNode&>(*target), wildcards, "__Add_REST__", results);
    }
    if (const auto* multiply = dynamic_cast<const MultiplyNode*>(pattern.get())) {
        return match_operation(*multiply, static_cast<const MultiplyNode&>(*target), wildcards, "__Mul_REST__", results);
    }
    if (const auto* power = dynamic_cast<const PowerNode*>(pattern.get())) {
        const auto& other = static_cast<const PowerNode&>(*target);
        return match_recursive(power->base(), other.base(), wildcards, results) &&
               match_recursive(power->exponent(), other.exponent(), wildcards, results);
    }
    if (const auto* function = dynamic_cast<const FunctionNode*>(pattern.get())) {
        return match_function(*function, static_cast<const FunctionNode&>(*target), wildcards, results);
    }
    return pattern->equals(*target);
}

引用了 add(), LMCAS::SymbolicNode::equals(), LMCAS::detail::expression_from_node(), function(), is_wildcard(), match_function(), match_operation(), match_recursive(), name, LMCAS::detail::node(), target , 以及 wildcards.

被这些函数引用 match_commutative_recursive(), match_function() , 以及 match_recursive().

函数调用图:

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

matrix_characteristic_polynomial_checked() [1/2]

ExpressionResult LMCAS::matrix_characteristic_polynomial_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		const std::string &	variable )

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

                                                                     {
    ComputationContext context;
    return matrix_characteristic_polynomial_checked(A, variable, context);
}

引用了 context, matrix_characteristic_polynomial_checked() , 以及 variable.

函数调用图:

matrix_characteristic_polynomial_checked() [2/2]

ExpressionResult LMCAS::matrix_characteristic_polynomial_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		const std::string &	variable,
		ComputationContext &	context )

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

                                 {
    constexpr const char* operation = "matrix_characteristic_polynomial";
    auto matrix_result = require_square_matrix(A, context, operation);
    if (!matrix_result) return ExpressionResult::failure(matrix_result.error());
    if (variable.empty()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "characteristic polynomial variable cannot be empty", operation);
    }
    try {
        const auto& matrix = *matrix_result.value();
        std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> entries(
            matrix.rows(),
            std::vector<std::shared_ptr<SymbolicExpr>>(matrix.cols()));
        auto lambda = SymbolicExpr::variable(variable);
        for (std::size_t row = 0; row < matrix.rows(); ++row) {
            for (std::size_t column = 0; column < matrix.cols(); ++column) {
                auto value = detail::make_expression_ptr(
                    matrix.get(row, column));
                entries[row][column] = row == column
                    ? SymbolicExpr::add(
                          value,
                          SymbolicExpr::multiply(
                              lambda, SymbolicExpr::number(-1)))
                    : std::move(value);
            }
        }
        auto determinant = matrix_determinant_checked(
            SymbolicExpr::matrix(entries), context);
        if (!determinant) return ExpressionResult::failure(determinant.error());
        return ExpressionResult::success(
            std::move(determinant.value()));
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while constructing characteristic polynomial",
            operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(
            CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::make_expression_ptr(), matrix_characteristic_polynomial_checked(), matrix_determinant_checked(), LMCAS::detail::matrix_api::require_square_matrix(), ResourceLimit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), value , 以及 variable.

被这些函数引用 matrix_characteristic_polynomial_checked(), matrix_characteristic_polynomial_checked() , 以及 matrix_eigenvalues_checked().

函数调用图:

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

matrix_determinant_checked() [1/2]

ExpressionResult LMCAS::matrix_determinant_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

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

                                                                                  {
    ComputationContext context;
    return matrix_determinant_checked(A, context);
}

引用了 context , 以及 matrix_determinant_checked().

函数调用图:

matrix_determinant_checked() [2/2]

ExpressionResult LMCAS::matrix_determinant_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

在文件 symbolic_matrix.cpp 第 60 行定义.

                                 {
    const std::string operation = "matrix_determinant";
    auto matrix = require_square_matrix(A, context, operation);
    if (!matrix) return ExpressionResult::failure(matrix.error());
    auto determinant = detail::determinant_exact(
        exact_matrix_data(*matrix.value()), context, operation);
    if (!determinant) return ExpressionResult::failure(determinant.error());
    return ExpressionResult::success(std::move(determinant.value()));
}

引用了 context, LMCAS::detail::determinant_exact(), LMCAS::detail::matrix_api::exact_matrix_data(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), matrix_determinant_checked(), LMCAS::detail::matrix_api::require_square_matrix() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 matrix_characteristic_polynomial_checked(), matrix_determinant_checked() , 以及 matrix_determinant_checked().

函数调用图:

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

matrix_eigenvalues_checked() [1/2]

MatrixEigenvalueResult LMCAS::matrix_eigenvalues_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

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

                                          {
    ComputationContext context;
    return matrix_eigenvalues_checked(A, context);
}

引用了 context , 以及 matrix_eigenvalues_checked().

函数调用图:

matrix_eigenvalues_checked() [2/2]

MatrixEigenvalueResult LMCAS::matrix_eigenvalues_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

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

                                                                           {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "matrix_eigenvalues";
    auto matrix_result = require_square_matrix(A, context, operation);
    if (!matrix_result) {
        return MatrixEigenvalueResult::failure(matrix_result.error());
    }
    const auto& matrix = *matrix_result.value();
    bool triangular = true;
    for (std::size_t row = 0; row < matrix.rows() && triangular; ++row) {
        for (std::size_t column = 0; column < row; ++column) {
            auto value =
                detail::make_expression_ptr(detail::normalize_node(matrix.get(row, column), transform_budget));
            if (!detail::node(value)->is_zero()) {
                triangular = false;
                break;
            }
        }
    }
    if (triangular) {
        std::vector<std::shared_ptr<SymbolicExpr>> values;
        values.reserve(matrix.rows());
        for (std::size_t index = 0; index < matrix.rows(); ++index) {
            values.push_back(
                detail::make_expression_ptr(detail::normalize_node(matrix.get(index, index), transform_budget)));
        }
        return MatrixEigenvalueResult::success(std::move(values));
    }
 
    auto polynomial = matrix_characteristic_polynomial_checked(
        A, "lambda", context);
    if (!polynomial) {
        return MatrixEigenvalueResult::failure(polynomial.error());
    }
    auto roots = solve_finite_checked(
        polynomial.value(), "lambda", context, SolveOptions{});
    if (!roots) return MatrixEigenvalueResult::failure(roots.error());
    std::vector<std::shared_ptr<SymbolicExpr>> values;
    std::set<std::string> seen;
    for (auto& root : roots.value()) {
        const auto key = root->to_string();
        if (seen.insert(key).second) values.push_back(std::move(root));
    }
    if (values.empty()) {
        return MatrixEigenvalueResult::failure(
            CasErrc::Inconclusive,
            "eigenvalue solver produced no finite roots", operation);
    }
    return MatrixEigenvalueResult::success(std::move(values));
} catch (const CasError& error) {
    return MatrixEigenvalueResult::failure(error);
} catch (const std::bad_alloc&) {
    return MatrixEigenvalueResult::failure(CasErrc::ResourceLimit, "allocation failed", "matrix_eigenvalues");
} catch (const std::length_error& error) {
    return MatrixEigenvalueResult::failure(CasErrc::ResourceLimit, error.what(), "matrix_eigenvalues");
} catch (const std::exception& error) {
    return MatrixEigenvalueResult::failure(CasErrc::InternalInvariant, error.what(), "matrix_eigenvalues");
}

引用了 context, LMCAS::Result< T >::error(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, LMCAS::detail::make_expression_ptr(), matrix_characteristic_polynomial_checked(), matrix_eigenvalues_checked(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::matrix_api::require_square_matrix(), roots(), solve_finite_checked(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success(), LMCAS::Result< T >::value() , 以及 value.

被这些函数引用 classify_quadratic_form(), LMCAS::detail::matrix_eigenspaces_checked(), matrix_eigenvalues_checked(), matrix_eigenvalues_checked() , 以及 vector_calculus_classify_critical_point().

函数调用图:

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

matrix_eigenvectors_checked() [1/2]

MatrixEigenvectorResult LMCAS::matrix_eigenvectors_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

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

                                          {
    ComputationContext context;
    return matrix_eigenvectors_checked(A, context);
}

引用了 context , 以及 matrix_eigenvectors_checked().

函数调用图:

matrix_eigenvectors_checked() [2/2]

MatrixEigenvectorResult LMCAS::matrix_eigenvectors_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

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

                                                                       {
    auto spaces = detail::matrix_eigenspaces_checked(A, context);
    if (!spaces) return MatrixEigenvectorResult::failure(spaces.error());
    try {
        std::vector<std::vector<ExprPtr>> vectors;
        for (auto& space : spaces.value())
            for (auto& vector : space.second) vectors.push_back(std::move(vector));
        return MatrixEigenvectorResult::success(std::move(vectors));
    } catch (const std::bad_alloc&) {
        return MatrixEigenvectorResult::failure(CasErrc::ResourceLimit,
            "allocation failed while collecting eigenvectors", "matrix_eigenvectors");
    }
}

引用了 context, LMCAS::Result< std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > >::failure(), LMCAS::detail::matrix_eigenspaces_checked(), matrix_eigenvectors_checked(), ResourceLimit , 以及 LMCAS::Result< std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > >::success().

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

函数调用图:

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

matrix_exp()

ExprPtr LMCAS::matrix_exp

(

const ExprPtr &

A

)

在文件 matrix_decomposition_eigen.cpp 第 202 行定义.

                                     {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    auto decomposition = diagonalization_checked(A, context);
    if (!decomposition) return SymbolicExpr::exp(A);
    auto inverse = matrix_inverse_checked(decomposition.value().P, context);
    if (!inverse) return SymbolicExpr::exp(A);
    auto diagonal = std::dynamic_pointer_cast<const MatrixNode>(detail::node(decomposition.value().J));
    const auto n = diagonal->rows();
    std::vector<std::vector<ExprPtr>> values(n, std::vector<ExprPtr>(n, SymbolicExpr::number(0)));
    for (std::size_t i = 0; i < n; ++i)
        values[i][i] = SymbolicExpr::exp(detail::make_expression_ptr(diagonal->get(i, i)));
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(decomposition.value().P,
        SymbolicExpr::multiply(SymbolicExpr::matrix(values), inverse.value()))), transform_budget));
}

引用了 context, LMCAS::detail::make_expression_ptr(), matrix_exp(), matrix_inverse_checked(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 matrix_exp().

函数调用图:

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

matrix_inverse_checked() [1/2]

ExpressionResult LMCAS::matrix_inverse_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 symbolic_matrix.cpp 第 91 行定义.

                                                                              {
    ComputationContext context;
    return matrix_inverse_checked(A, context);
}

引用了 context , 以及 matrix_inverse_checked().

函数调用图:

matrix_inverse_checked() [2/2]

ExpressionResult LMCAS::matrix_inverse_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

在文件 symbolic_matrix.cpp 第 78 行定义.

                                 {
    const std::string operation = "matrix_inverse";
    auto matrix = require_square_matrix(A, context, operation);
    if (!matrix) return ExpressionResult::failure(matrix.error());
    auto inverse = detail::inverse_exact(
        exact_matrix_data(*matrix.value()), context, operation);
    if (!inverse) return ExpressionResult::failure(inverse.error());
    return ExpressionResult::success(
        exact_matrix_expression(inverse.value()));
}

引用了 context, LMCAS::detail::matrix_api::exact_matrix_data(), LMCAS::detail::matrix_api::exact_matrix_expression(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::inverse_exact(), matrix_inverse_checked(), LMCAS::detail::matrix_api::require_square_matrix() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 matrix_exp(), matrix_inverse_checked(), matrix_inverse_checked(), matrix_log() , 以及 metric_inverse_checked().

函数调用图:

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

matrix_log()

ExprPtr LMCAS::matrix_log

(

const ExprPtr &

A

)

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

                                     {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    auto decomposition = diagonalization_checked(A, context);
    if (!decomposition) return nullptr;
    auto inverse = matrix_inverse_checked(decomposition.value().P, context);
    if (!inverse) return nullptr;
    auto diagonal = std::dynamic_pointer_cast<const MatrixNode>(detail::node(decomposition.value().J));
    const auto n = diagonal->rows();
    AssumptionContext assumptions;
    detail::AssumptionFacts facts(assumptions);
    std::vector<std::vector<ExprPtr>> values(n, std::vector<ExprPtr>(n, SymbolicExpr::number(0)));
    for (std::size_t i = 0; i < n; ++i) {
        auto positive = detail::query_positive_value(diagonal->get(i, i), facts, context);
        if (!positive || positive.value() != Tribool::True) return nullptr;
        values[i][i] = SymbolicExpr::ln(detail::make_expression_ptr(diagonal->get(i, i)));
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(decomposition.value().P,
        SymbolicExpr::multiply(SymbolicExpr::matrix(values), inverse.value()))), transform_budget));
}

引用了 context, LMCAS::detail::make_expression_ptr(), matrix_inverse_checked(), matrix_log(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_positive_value() , 以及 True.

被这些函数引用 matrix_log().

函数调用图:

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

matrix_multiply_checked() [1/2]

ExpressionResult LMCAS::matrix_multiply_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		const std::shared_ptr< SymbolicExpr > &	B )

在文件 symbolic_matrix.cpp 第 53 行定义.

                                                                               {
    ComputationContext context;
    return matrix_multiply_checked(A, B, context);
}

引用了 context , 以及 matrix_multiply_checked().

函数调用图:

matrix_multiply_checked() [2/2]

ExpressionResult LMCAS::matrix_multiply_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		const std::shared_ptr< SymbolicExpr > &	B,
		ComputationContext &	context )

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

                                                                      {
    const std::string operation = "matrix_multiply";
    auto left = require_matrix(A, context, operation);
    if (!left) return ExpressionResult::failure(left.error());
    auto right = require_matrix(B, context, operation);
    if (!right) return ExpressionResult::failure(right.error());
    if (left.value()->cols() != right.value()->rows()) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument, "matrix dimensions are not compatible", operation);
    }
    try {
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                     context.limits().max_ast_nodes, "matrix_multiply");
        const auto count = normalization_check_count(
            &budget, left.value()->rows(), right.value()->cols());
        auto output_terms = context.require_expansion_terms(count, operation);
        if (!output_terms) { return ExpressionResult::failure(output_terms.error()); }
        auto inner_terms = context.require_expansion_terms(left.value()->cols(), operation);
        if (!inner_terms) { return ExpressionResult::failure(inner_terms.error()); }
        normalization_check_arithmetic<MultiplyNode>(&budget, 0, left.value(), right.value());
        auto product = detail::make_node<MultiplyNode>(
            std::vector<std::shared_ptr<const SymbolicNode>>{left.value(), right.value()});
        NormalizationVisitor visitor(budget, detail::no_facts(), Domain::Real);
        product->accept(visitor);
        auto result = visitor.get_result();
        budget.measure(result);
        if (!std::dynamic_pointer_cast<const MatrixNode>(result)) {
            return ExpressionResult::failure(CasErrc::InternalInvariant,
                "matrix multiplication did not produce an explicit matrix", operation);
        }
        return detail::make_expression_ptr(std::move(result));
    } catch (const CasError& error) {
        return ExpressionResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
            "allocation failed while multiplying matrices", operation);
    } catch (const std::exception& ex) {
        return ExpressionResult::failure(CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), matrix_multiply_checked(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::no_facts(), normalization_check_arithmetic(), normalization_check_count(), Real, LMCAS::detail::matrix_api::require_matrix(), ResourceLimit , 以及 right.

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

函数调用图:

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

matrix_norm()

std::shared_ptr< SymbolicExpr > LMCAS::matrix_norm	(	const std::shared_ptr< SymbolicExpr > &	A,
		const std::string &	type )

在文件 matrix_decomposition.cpp 第 106 行定义.

                           {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto mat = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(A));
    if (!mat) {
        return nullptr;
    }
    size_t m = mat->rows(), n = mat->cols();
 
    if (type == "frobenius") {
        auto sum = SymbolicExpr::number(0);
        for (size_t i = 0; i < m; ++i)
            for (size_t j = 0; j < n; ++j) {
                auto e = LMCAS::detail::make_expression_ptr(mat->get(i, j));
                sum = SymbolicExpr::add(sum, SymbolicExpr::multiply(e, e));
            }
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::sqrt(sum)), transform_budget));
    }
    if (type == "1") {
        return maximum_axis_sum(*mat, true, context);
    }
    if (type == "inf") {
        return maximum_axis_sum(*mat, false, context);
    }
    return nullptr;
}

引用了 context, e(), LMCAS::detail::make_expression_ptr(), matrix_norm(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 matrix_norm().

函数调用图:

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

matrix_nullspace_checked() [1/2]

MatrixNullspaceResult LMCAS::matrix_nullspace_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 symbolic_matrix_solve.cpp 第 17 行定义.

                                          {
    ComputationContext context;
    return matrix_nullspace_checked(A, context);
}

引用了 context , 以及 matrix_nullspace_checked().

函数调用图:

matrix_nullspace_checked() [2/2]

MatrixNullspaceResult LMCAS::matrix_nullspace_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

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

                                 {
    const std::string operation = "matrix_nullspace";
    auto matrix = require_matrix(A, context, operation);
    if (!matrix) return MatrixNullspaceResult::failure(matrix.error());
    auto nullspace = detail::nullspace_exact(
        exact_matrix_data(*matrix.value()), context, operation);
    if (!nullspace) return MatrixNullspaceResult::failure(nullspace.error());
    return MatrixNullspaceResult::success(std::move(nullspace.value()));
}

引用了 context, LMCAS::detail::matrix_api::exact_matrix_data(), LMCAS::Result< std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > >::failure(), matrix_nullspace_checked(), LMCAS::detail::nullspace_exact(), LMCAS::detail::matrix_api::require_matrix() , 以及 LMCAS::Result< std::vector< std::vector< std::shared_ptr< SymbolicExpr > > > >::success().

被这些函数引用 LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace(), matrix_nullspace_checked() , 以及 matrix_nullspace_checked().

函数调用图:

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

matrix_rank_checked() [1/2]

MatrixRankResult LMCAS::matrix_rank_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 symbolic_matrix.cpp 第 110 行定义.

                                          {
    ComputationContext context;
    return matrix_rank_checked(A, context);
}

引用了 context , 以及 matrix_rank_checked().

函数调用图:

matrix_rank_checked() [2/2]

MatrixRankResult LMCAS::matrix_rank_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

在文件 symbolic_matrix.cpp 第 97 行定义.

                                 {
    const std::string operation = "matrix_rank";
    auto matrix = require_matrix(A, context, operation);
    if (!matrix) return MatrixRankResult::failure(matrix.error());
    auto rank = detail::rank_exact(
        exact_matrix_data(*matrix.value()), matrix.value()->cols(),
        context, operation);
    if (!rank) return MatrixRankResult::failure(rank.error());
    return MatrixRankResult::success(rank.value());
}

引用了 LMCAS::detail::ExactMatrixData::cols, context, LMCAS::detail::matrix_api::exact_matrix_data(), LMCAS::Result< std::size_t >::failure(), matrix_rank_checked(), LMCAS::detail::rank_exact(), LMCAS::detail::matrix_api::require_matrix() , 以及 LMCAS::Result< std::size_t >::success().

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

函数调用图:

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

matrix_reflection_checked() [1/2]

ExpressionResult LMCAS::matrix_reflection_checked	(	double	angle,
		int	dim )

在文件 symbolic_matrix_transform.cpp 第 81 行定义.

                                                                  {
    ComputationContext context;
    return matrix_reflection_checked(angle, dim, context);
}

引用了 context, dim , 以及 matrix_reflection_checked().

函数调用图:

matrix_reflection_checked() [2/2]

ExpressionResult LMCAS::matrix_reflection_checked	(	double	angle,
		int	dim,
		ComputationContext &	context )

在文件 symbolic_matrix_transform.cpp 第 50 行定义.

                                                                        {
    const std::string operation = "matrix_reflection";
    auto step = context.consume_steps(1, operation);
    if (!step) return ExpressionResult::failure(step.error());
    if (dim == 2) {
        if (!std::isfinite(angle)) {
            return ExpressionResult::failure(CasErrc::InvalidArgument,
                "reflection angle must be finite", operation);
        }
        const double cosine = std::cos(angle);
        const double sine = std::sin(angle);
        try {
            auto c = SymbolicExpr::number(cosine * cosine - sine * sine);
            auto s = SymbolicExpr::number(2.0 * sine * cosine);
            return require_matrix_result(
                SymbolicExpr::matrix({{c, s}, {s, SymbolicExpr::multiply(SymbolicExpr::number(-1), c)}}),
                operation);
        } catch (const CasError& error) {
            return ExpressionResult::failure(error);
        } catch (const std::bad_alloc&) {
            return ExpressionResult::failure(CasErrc::ResourceLimit,
                "allocation failed while constructing reflection matrix", operation);
        } catch (const std::exception& error) {
            return ExpressionResult::failure(CasErrc::InternalInvariant,
                error.what(), operation);
        }
    }
    return unsupported_matrix_dimension(operation);
}

引用了 c, context, dim, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, matrix_reflection_checked(), LMCAS::detail::matrix_api::require_matrix_result() , 以及 ResourceLimit.

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

函数调用图:

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

matrix_rotation_checked() [1/2]

ExpressionResult LMCAS::matrix_rotation_checked	(	double	theta,
		int	dim )

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

                                                                {
    ComputationContext context;
    return matrix_rotation_checked(theta, dim, context);
}

引用了 context, dim , 以及 matrix_rotation_checked().

函数调用图:

matrix_rotation_checked() [2/2]

ExpressionResult LMCAS::matrix_rotation_checked	(	double	theta,
		int	dim,
		ComputationContext &	context )

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

                                                                      {
    const std::string operation = "matrix_rotation";
    auto step = context.consume_steps(1, operation);
    if (!step) return ExpressionResult::failure(step.error());
    if (dim != 2) return invalid_matrix_dimension(operation);
    if (!std::isfinite(theta)) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "rotation angle must be finite", operation);
    }
    auto c = SymbolicExpr::number(std::cos(theta));
    auto s = SymbolicExpr::number(std::sin(theta));
    return require_matrix_result(
        SymbolicExpr::matrix(
            {{c, SymbolicExpr::multiply(SymbolicExpr::number(-1), s)},
             {s, c}}),
        operation);
}

引用了 c, context, dim, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, matrix_rotation_checked() , 以及 LMCAS::detail::matrix_api::require_matrix_result().

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

函数调用图:

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

matrix_rref_checked() [1/2]

ExpressionResult LMCAS::matrix_rref_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 symbolic_matrix.cpp 第 129 行定义.

                                          {
    ComputationContext context;
    return matrix_rref_checked(A, context);
}

引用了 context , 以及 matrix_rref_checked().

函数调用图:

matrix_rref_checked() [2/2]

ExpressionResult LMCAS::matrix_rref_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

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

                                 {
    const std::string operation = "matrix_rref";
    auto matrix = require_matrix(A, context, operation);
    if (!matrix) return ExpressionResult::failure(matrix.error());
    auto rref = detail::rref_exact(
        exact_matrix_data(*matrix.value()), matrix.value()->cols(),
        context, operation);
    if (!rref) return ExpressionResult::failure(rref.error());
    return ExpressionResult::success(exact_matrix_expression(rref.value()));
}

引用了 LMCAS::detail::ExactMatrixData::cols, context, LMCAS::detail::matrix_api::exact_matrix_data(), LMCAS::detail::matrix_api::exact_matrix_expression(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), matrix_rref_checked(), LMCAS::detail::matrix_api::require_matrix(), LMCAS::detail::rref_exact() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

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

函数调用图:

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

matrix_scaling_checked() [1/2]

ExpressionResult LMCAS::matrix_scaling_checked	(	double	sx,
		double	sy,
		int	dim )

在文件 symbolic_matrix_transform.cpp 第 105 行定义.

                                                                       {
    ComputationContext context;
    return matrix_scaling_checked(sx, sy, dim, context);
}

引用了 context, dim, matrix_scaling_checked() , 以及 sy.

函数调用图:

matrix_scaling_checked() [2/2]

ExpressionResult LMCAS::matrix_scaling_checked	(	double	sx,
		double	sy,
		int	dim,
		ComputationContext &	context )

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

                                                                     {
    const std::string operation = "matrix_scaling";
    auto step = context.consume_steps(1, operation);
    if (!step) return ExpressionResult::failure(step.error());
    if (dim != 2) return invalid_matrix_dimension(operation);
    if (!std::isfinite(sx) || !std::isfinite(sy)) {
        return ExpressionResult::failure(
            CasErrc::InvalidArgument,
            "scaling factors must be finite", operation);
    }
    return require_matrix_result(
        SymbolicExpr::matrix(
            {{SymbolicExpr::number(sx), SymbolicExpr::number(0)},
             {SymbolicExpr::number(0), SymbolicExpr::number(sy)}}),
        operation);
}

引用了 context, dim, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, matrix_scaling_checked(), LMCAS::detail::matrix_api::require_matrix_result() , 以及 sy.

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

函数调用图:

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

matrix_solve_linear_checked() [1/2]

MatrixLinearSolveResult LMCAS::matrix_solve_linear_checked	(	const std::shared_ptr< SymbolicExpr > &	coefficients,
		const std::shared_ptr< SymbolicExpr > &	right_hand_side )

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

                                                        {
    ComputationContext context;
    return matrix_solve_linear_checked(
        coefficients, right_hand_side, context);
}

引用了 context , 以及 matrix_solve_linear_checked().

函数调用图:

matrix_solve_linear_checked() [2/2]

MatrixLinearSolveResult LMCAS::matrix_solve_linear_checked	(	const std::shared_ptr< SymbolicExpr > &	coefficients,
		const std::shared_ptr< SymbolicExpr > &	right_hand_side,
		ComputationContext &	context )

在文件 symbolic_matrix_solve.cpp 第 23 行定义.

                                 {
    const std::string operation = "matrix_solve_linear";
    auto matrix = require_matrix(coefficients, context, operation);
    if (!matrix) return MatrixLinearSolveResult::failure(matrix.error());
    auto rhs = require_matrix(right_hand_side, context, operation);
    if (!rhs) return MatrixLinearSolveResult::failure(rhs.error());
    if (rhs.value()->rows() != matrix.value()->rows() ||
        rhs.value()->cols() != 1) {
        return MatrixLinearSolveResult::failure(
            CasErrc::InvalidArgument,
            "right-hand side must be a matching column matrix", operation);
    }
 
    detail::ExactMatrixData augmented{
        matrix.value()->rows(), matrix.value()->cols() + 1, {}};
    augmented.entries.reserve(augmented.rows * augmented.cols);
    for (std::size_t row = 0; row < augmented.rows; ++row) {
        for (std::size_t column = 0;
             column < matrix.value()->cols(); ++column) {
            augmented.entries.push_back(
                LMCAS::detail::make_expression_ptr(
                    matrix.value()->get(row, column)));
        }
        augmented.entries.push_back(
            LMCAS::detail::make_expression_ptr(rhs.value()->get(row, 0)));
    }
    auto solved = detail::solve_linear_exact(
        std::move(augmented), matrix.value()->cols(), context, operation);
    if (!solved) return MatrixLinearSolveResult::failure(solved.error());
    if (auto* unique =
            std::get_if<detail::UniqueLinearSolution>(&solved.value())) {
        return MatrixLinearSolveResult::success(
            MatrixUniqueLinearSolution{std::move(unique->values)});
    }
    if (auto* parametric =
            std::get_if<detail::ParametricLinearSolution>(&solved.value())) {
        return MatrixLinearSolveResult::success(
            MatrixParametricLinearSolution{
                std::move(parametric->particular),
                std::move(parametric->nullspace_basis),
                std::move(parametric->free_columns)});
    }
    return MatrixLinearSolveResult::success(
        MatrixInconsistentLinearSolution{});
}

引用了 LMCAS::detail::ExactMatrixData::cols, context, LMCAS::detail::ExactMatrixData::entries, LMCAS::Result< MatrixLinearSolution >::failure(), InvalidArgument, LMCAS::detail::make_expression_ptr(), matrix_solve_linear_checked(), LMCAS::detail::matrix_api::require_matrix(), rhs, LMCAS::detail::ExactMatrixData::rows, LMCAS::detail::solve_linear_exact() , 以及 LMCAS::Result< MatrixLinearSolution >::success().

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

函数调用图:

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

matrix_trace()

std::shared_ptr< SymbolicExpr > LMCAS::matrix_trace

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 matrix_decomposition.cpp 第 68 行定义.

                                                                               {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto mat = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(A));
    if (!mat || mat->rows() != mat->cols()) {
        return nullptr;
    }
    auto sum = SymbolicExpr::number(0);
    for (size_t i = 0; i < mat->rows(); ++i) {
        sum = SymbolicExpr::add(sum, LMCAS::detail::make_expression_ptr(mat->get(i, i)));
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(sum), transform_budget));
}

引用了 context, LMCAS::detail::make_expression_ptr(), matrix_trace(), LMCAS::detail::node() , 以及 LMCAS::detail::normalize_node().

被这些函数引用 matrix_trace().

函数调用图:

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

member()

ExprResult LMCAS::member	(	const ExprPtr &	element,
		const ExprPtr &	set,
		ComputationContext &	context )

在文件 value_facade.cpp 第 52 行定义.

                                               {
    return make_membership(element, set, context);
}

引用了 context, element, make_membership(), member() , 以及 set.

被这些函数引用 LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_operands(), member(), membership(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::query_value() , 以及 LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::variations_at().

函数调用图:

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

membership()

ExprResult LMCAS::membership	(	const ExprPtr &	element,
		const ExprPtr &	set,
		bool	negated )

在文件 expr_facade.cpp 第 249 行定义.

                                                                                {
    ComputationContext context;
    auto result = member(element, set, context);
    if (!result || !negated) return result;
    return logical_not(result.value());
}

引用了 context, element, logical_not(), member(), membership(), negated , 以及 set.

被这些函数引用 LMCAS::MembershipNode::compare_same_type() , 以及 membership().

函数调用图:

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

metric_inverse_checked() [1/2]

DifferentialGeometryExprResult LMCAS::metric_inverse_checked

(

const std::shared_ptr< SymbolicExpr > &

g_ij

)

在文件 differential_geometry.cpp 第 362 行定义.

{
    ComputationContext context;
    return metric_inverse_checked(g_ij, context);
}

引用了 context , 以及 metric_inverse_checked().

函数调用图:

metric_inverse_checked() [2/2]

DifferentialGeometryExprResult LMCAS::metric_inverse_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		ComputationContext &	context )

在文件 differential_geometry.cpp 第 336 行定义.

{
    const std::string operation = "metric_inverse";
    auto metric = validate_metric_matrix(g_ij, nullptr, context, operation);
    if (!metric) return DifferentialGeometryExprResult::failure(metric.error());
    auto budget = context.consume_steps(12, operation);
    if (!budget) return DifferentialGeometryExprResult::failure(budget.error());
    try {
        auto result = matrix_inverse_checked(g_ij, context);
        if (!result) {
            return DifferentialGeometryExprResult::failure(result.error());
        }
        return DifferentialGeometryExprResult::success(result.value());
    } catch (const std::bad_alloc&) {
        return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit,
                                                       "allocation failed while inverting metric",
                                                       operation);
    } catch (const std::exception& ex) {
        return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant,
                                                       ex.what(),
                                                       operation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, matrix_inverse_checked(), metric_inverse_checked(), ResourceLimit , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 metric_inverse_checked(), metric_inverse_checked() , 以及 riemann_curvature_tensor_checked().

函数调用图:

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

mixed_product()

VectorCalculusExprResult LMCAS::mixed_product	(	const VectorField &	a,
		const VectorField &	b,
		const VectorField &	c )

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

                                                                          {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "mixed_product");
    return mixed_product_impl(a, b, c, transform_budget);
} catch (const CasError& error) {
    return VectorCalculusExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
        "vector calculus allocation failed", "mixed_product");
} catch (const std::length_error& error) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), "mixed_product");
} catch (const std::exception& error) {
    return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, error.what(), "mixed_product");
}

引用了 a, b, c, context, mixed_product() , 以及 mixed_product_impl().

被这些函数引用 mixed_product().

函数调用图:

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

mixed_product_impl()

VectorCalculusExprResult LMCAS::mixed_product_impl ( const VectorField & a, const VectorField & b, const VectorField & c, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_algebra.cpp 第 127 行定义.

{
    auto cross = cross_product_impl(b, c, transform_budget);
    if (!cross) return VectorCalculusExprResult::failure(cross.error());
    return dot_product_impl(a, cross.value(), transform_budget);
}

引用了 a, b, c, cross_product_impl(), dot_product_impl(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), mixed_product_impl() , 以及 LMCAS::Result< T >::value().

被这些函数引用 mixed_product() , 以及 mixed_product_impl().

函数调用图:

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

mul() [1/2]

ExprResult LMCAS::mul	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_arithmetic.cpp 第 35 行定义.

                                                       {
    ComputationContext context;
    return mul(lhs, rhs, context);
}

引用了 context, mul() , 以及 rhs.

函数调用图:

mul() [2/2]

ExprResult LMCAS::mul	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 29 行定义.

                                            {
    return quantity_multiply(lhs, rhs, context);
}

引用了 context, mul(), quantity_multiply() , 以及 rhs.

被这些函数引用 LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::coefficient(), LMCAS::solver_detail::collect_denominator_factors(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::collect_transcendental_subexprs(), 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::SymbolicFactory::create_multiply(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::degree_in_var(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::exact_rational_product(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::extract_exp_multiplier(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::extract_linear_coefficient(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::extract_sin_cos_powers(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::has_exp_k_var_terms(), LMCAS::InferenceEngine::Impl::has_negated_operand(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::is_poly_expr_node(), LMCAS::solver_detail::is_polynomial_node(), is_separable(), mul(), mul(), LMCAS::solver_detail::multiply_no_expand(), neg(), LMCAS::MultiplyNode::normalize_operands(), LMCAS::expr_detail::ExprParser::parse_multiplicative(), LMCAS::anonymous_namespace{query_conditions.cpp}::product_conditions(), LMCAS::InferenceEngine::Impl::product_relation_sign(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_rational(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::SubstNodeVisitor::replace(), LMCAS::anonymous_namespace{residual_verification.cpp}::residual_piecewise(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::rewrite_exp_as_u_power(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_split_inv_var(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), LMCAS::anonymous_namespace{query_conditions.cpp}::subtracted_operand(), LMCAS::InferenceEngine::Impl::subtrahend(), symbolic_node_to_multipoly(), te_extract_exp(), te_inv_product(), LMCAS::transform_detail::te_split_coeff(), tf_collect_transcendental(), tf_contains_transcendental(), tf_degree_in(), tf_detect_multiplicative_structure(), tf_extract_coeff_trig_squared(), tf_extract_exp_factor(), tf_is_negation_of(), tf_remove_exp_factor(), tf_simplify_pythagorean_node(), tf_substitute_expr(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_has_trig_of_var(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_is_rational_trig(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational().

函数调用图:

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

multi_crt()

std::pair< int64_t, int64_t > LMCAS::multi_crt ( const std::vector< int64_t > & residues, const std::vector< int64_t > & primes )

inline

多模数中国剩余定理

参数

residues	余数列表
primes	对应的模数列表（两两互素）

返回

pair(合并余数, 合并模数)

异常

std::invalid_argument

若输入为空或大小不匹配

在文件 modular_arithmetic.hpp 第 323 行定义.

                                                                                {
    if (residues.empty() || residues.size() != primes.size()) {
        throw std::invalid_argument("multi_crt(): residues and primes must be non-empty and same size");
    }
 
    int64_t modulus = primes[0];
    int64_t combined = ModInt(residues[0], modulus).value();
 
    for (size_t i = 1; i < residues.size(); ++i) {
        auto [x, m] = crt(combined, modulus, residues[i], primes[i]);
        combined = x;
        modulus = m;
    }
 
    return {combined, modulus};
}

引用了 LMCAS::ModInt::ModInt(), crt() , 以及 multi_crt().

被这些函数引用 multi_crt().

函数调用图:

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

multi_crt_checked() [1/2]

CrtResult LMCAS::multi_crt_checked ( const std::vector< int64_t > & residues, const std::vector< int64_t > & primes )

inline

在文件 modular_arithmetic.hpp 第 375 行定义.

                                                                     {
    ComputationContext context;
    return multi_crt_checked(residues, primes, context);
}

引用了 context , 以及 multi_crt_checked().

函数调用图:

multi_crt_checked() [2/2]

CrtResult LMCAS::multi_crt_checked ( const std::vector< int64_t > & residues, const std::vector< int64_t > & primes, ComputationContext & context )

inline

Checked CRT for a non-empty list of pairwise coprime positive moduli.

在文件 modular_arithmetic.hpp 第 344 行定义.

                                                                {
    constexpr const char* operation = "multi_crt";
    auto step = context.consume_steps(residues.size() + 1, operation);
    if (!step) return CrtResult::failure(step.error());
    if (residues.empty() || residues.size() != primes.size()) {
        return CrtResult::failure(
            CasErrc::InvalidArgument,
            "multi_crt residues and moduli must be non-empty and the same size",
            operation);
    }
    for (int64_t modulus : primes) {
        if (modulus <= 0) {
            return CrtResult::failure(CasErrc::InvalidArgument,
                                      "multi_crt moduli must be positive", operation);
        }
    }
 
    int64_t modulus = primes[0];
    int64_t combined = ModInt(residues[0], modulus).value();
    for (size_t i = 1; i < residues.size(); ++i) {
        auto merged = crt_checked(combined, modulus, residues[i], primes[i], context);
        if (!merged) return merged;
        combined = merged.value().first;
        modulus = merged.value().second;
    }
 
    return CrtResult::success({combined, modulus});
}

引用了 LMCAS::ModInt::ModInt(), context, crt_checked(), LMCAS::Result< std::pair< int64_t, int64_t > >::failure(), InvalidArgument, multi_crt_checked() , 以及 LMCAS::Result< std::pair< int64_t, int64_t > >::success().

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

函数调用图:

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

multiply_number_nodes()

std::shared_ptr< const NumberNode > LMCAS::multiply_number_nodes ( const std::shared_ptr< const NumberNode > & a, const std::shared_ptr< const NumberNode > & b )

static

在文件 solver_linear.cpp 第 60 行定义.

                                                                                                                                                 {
    if (std::holds_alternative<Rational>(a->value()) || std::holds_alternative<Rational>(b->value())) {
        Rational r1 = std::holds_alternative<Rational>(a->value()) ? std::get<Rational>(a->value()) : Rational(std::get<BigInt>(a->value()));
        Rational r2 = std::holds_alternative<Rational>(b->value()) ? std::get<Rational>(b->value()) : Rational(std::get<BigInt>(b->value()));
        return LMCAS::detail::make_node<NumberNode>(r1 * r2);
    }
 
    return LMCAS::detail::make_node<NumberNode>(std::get<BigInt>(a->value()) * std::get<BigInt>(b->value()));
}

引用了 a, b, LMCAS::detail::make_node(), multiply_number_nodes() , 以及 LMCAS::Result< T >::value().

被这些函数引用 LMCAS::solver_detail::multiply_no_expand() , 以及 multiply_number_nodes().

函数调用图:

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

multiply_numbers()

std::shared_ptr< const NumberNode > LMCAS::multiply_numbers	(	const std::shared_ptr< const NumberNode > &	a,
		const std::shared_ptr< const NumberNode > &	b )

两个数值节点相乘

参数

a	乘数节点
b	乘数节点

返回

积的数值节点

在文件 normalization_utils.cpp 第 167 行定义.

                                                                                                                                     {
     if (std::holds_alternative<Rational>(a->value()) || std::holds_alternative<Rational>(b->value())) {
         const Rational r1 = exact_number_as_rational(*a);
         const Rational r2 = exact_number_as_rational(*b);
         return LMCAS::detail::make_node<NumberNode>(r1 * r2);
     }
 
     return LMCAS::detail::make_node<NumberNode>(
         std::get<BigInt>(a->value()) * std::get<BigInt>(b->value()));
}

引用了 a, b, exact_number_as_rational(), LMCAS::detail::make_node(), multiply_numbers() , 以及 LMCAS::Result< T >::value().

被这些函数引用 LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::add_number(), multiply_numbers() , 以及 LMCAS::NormalizationVisitor::normalize_matrix_product().

函数调用图:

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

multipoly_to_symbolic()

std::shared_ptr< SymbolicExpr > LMCAS::multipoly_to_symbolic ( const LMCAS::MultiPoly & poly, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 126 行定义.

                                                                                                                  {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (poly.is_zero()) { return SymbolicExpr::number(0); }
 
    const auto& vars = poly.variables();
    const auto& terms = poly.terms();
 
    std::vector<std::shared_ptr<SymbolicExpr>> term_exprs;
    term_exprs.reserve(terms.size());
 
    for (const auto& [mono, coeff] : terms) {
        term_exprs.push_back(
            detail::multipoly_term_to_expression(mono, coeff, vars));
    }
 
    if (term_exprs.empty()) { return SymbolicExpr::number(0); }
    if (term_exprs.size() == 1) { return detail::make_expression_ptr(detail::normalize_node(detail::node(term_exprs[0]), transform_budget)); }
 
    auto result = term_exprs[0];
    for (size_t i = 1; i < term_exprs.size(); ++i) {
        result = SymbolicExpr::add(result, term_exprs[i]);
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::multipoly_term_to_expression(), multipoly_to_symbolic(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 vars.

被这些函数引用 multipoly_to_symbolic() , 以及 multivariate_factor_expression().

函数调用图:

这是这个函数的调用关系图:

multivariate_content()

MultiPoly LMCAS::multivariate_content	(	const MultiPoly &	poly,
		const std::string &	main_var )

若 main_var 不在变量列表中,或多项式在 main_var 上次数为 0,容度就是多项式本身

在文件 multivariate_factor.cpp 第 151 行定义.

{
    if (poly.is_zero()) { return MultiPoly(); }
    /// 若 main_var 不在变量列表中,或多项式在 main_var 上次数为 0,容度就是多项式本身
    const auto& vars = poly.variables();
    int var_idx = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == main_var) { var_idx = static_cast<int>(i); break; }
    }
    if (var_idx < 0) { return poly; }
    if (poly.degree(main_var) <= 0) { return poly; }
    auto coeffs = extract_coefficients(poly, main_var);
    if (coeffs.empty()) { return MultiPoly(); }
    auto it = coeffs.begin();
    MultiPoly content_gcd = it->second;
    ++it;
    for (; it != coeffs.end(); ++it) {
        if (it->second.is_zero()) { continue; }
        content_gcd = multivariate_gcd(content_gcd, it->second);
        if (content_gcd.is_constant()) {
            Rational nc = content_gcd.numeric_content();
            if (nc == Rational(1)) { return content_gcd; }
        }
    }
    if (!content_gcd.is_zero() && !content_gcd.terms().empty()) {
        if (content_gcd.terms()[0].second < Rational(0)) { content_gcd = content_gcd * Rational(-1); }
    }
    return content_gcd;
}

引用了 extract_coefficients(), main_var, multivariate_content(), multivariate_gcd() , 以及 vars.

被这些函数引用 multivariate_content() , 以及 multivariate_primitive_part().

函数调用图:

这是这个函数的调用关系图:

multivariate_diophantine()

std::vector< MultiPoly > LMCAS::multivariate_diophantine	(	const std::vector< MultiPoly > &	factors,
		const MultiPoly &	target,
		const std::string &	var,
		const Rational &	eval_point,
		int	degree_bound )

多元丢番图方程求解器

求解 s_1*f_1 + s_2*f_2 + ... + sᵣ*fᵣ == target (mod (var - eval_point)^degree_bound), 其中各 fᵢ 两两互素.用于 Hensel 提升过程中计算修正项.

算法:

1. 二因子情形(r=2):使用扩展 GCD 求 Bezout 系数
2. 一般情形(r>2):递归归约–令 g = f_2*...*fᵣ, 先解 s_1*f_1 + t*g == target,再递归解 s_2*f_2 + ... + sᵣ*fᵣ == t
3. 对每个解截断为关于 var 的次数 < degree_bound

参数

[in]	factors	互素因子列表 [f_1, ..., fᵣ]
[in]	target	目标多项式 c
[in]	var	变量名
[in]	eval_point	求值点
[in]	degree_bound	次数上界

返回

解多项式列表 [s_1, s_2, ..., sᵣ]

参见

Geddes, Czapor, Labahn. "Algorithms for Computer Algebra." Section15.5.

单因子情形:s_1 = target / f_1(精确除法后截断)

一般情形(r > 2):递归归约 令 g = f_2 * f₃ * ... * fᵣ

解二因子方程:s_1*f_1 + t*g == target

退化情形

s_1 已确定

递归解:s_2*f_2 + ... + sᵣ*fᵣ == t_poly * g 因为原方程为 s_1*f_1 + t*g = target, 我们需要 s_2*f_2 + ... + sᵣ*fᵣ = t*g = target - s_1*f_1

组装完整解

在文件 multivariate_hensel.cpp 第 529 行定义.

{
    int r = static_cast<int>(factors.size());
    if (r == 0) { return {}; }
    if (r == 1) {
        /// 单因子情形:s_1 = target / f_1(精确除法后截断)
        try {
            MultiPoly s1 = target.exact_div(factors[0]);
            s1 = truncate_mod_var(s1, var, degree_bound);
            return {s1};
        } catch (const std::runtime_error&) {
            return {};
        }
    }
 
    const auto& vars = factors[0].variables();
 
    if (r == 2) {
        return solve_diophantine_pair(factors, target, var, eval_point,
                                      degree_bound);
    }
 
    /// 一般情形(r > 2):递归归约
    /// 令 g = f_2 * f₃ * ... * fᵣ
    MultiPoly g = factors[1];
    for (int i = 2; i < r; ++i) {
        g = g * factors[i];
    }
 
    /// 解二因子方程:s_1*f_1 + t*g == target
    std::vector<MultiPoly> two_factors = {factors[0], g};
    std::vector<MultiPoly> two_solution = multivariate_diophantine(
        two_factors, target, var, eval_point, degree_bound);
 
    if (two_solution.size() != 2) {
        /// 退化情形
        std::vector<MultiPoly> result(r, MultiPoly(Rational(0), vars));
        return result;
    }
 
    /// s_1 已确定
    MultiPoly s1 = two_solution[0];
    MultiPoly t_poly = two_solution[1];
 
    /// 递归解:s_2*f_2 + ... + sᵣ*fᵣ == t_poly * g
    /// 因为原方程为 s_1*f_1 + t*g = target,
    /// 我们需要 s_2*f_2 + ... + sᵣ*fᵣ = t*g = target - s_1*f_1
    MultiPoly remaining_target = t_poly * g;
    remaining_target = truncate_mod_var(remaining_target, var, degree_bound);
 
    std::vector<MultiPoly> remaining_factors(factors.begin() + 1, factors.end());
    std::vector<MultiPoly> remaining_solution = multivariate_diophantine(
        remaining_factors, remaining_target, var, eval_point, degree_bound);
 
    /// 组装完整解
    std::vector<MultiPoly> result;
    result.push_back(std::move(s1));
    for (auto& sol : remaining_solution) {
        result.push_back(std::move(sol));
    }
 
    return result;
}

引用了 multivariate_diophantine(), r, solve_diophantine_pair(), target, truncate_mod_var() , 以及 vars.

被这些函数引用 apply_hensel_lift_steps() , 以及 multivariate_diophantine().

函数调用图:

这是这个函数的调用关系图:

multivariate_factor_expression()

std::shared_ptr< SymbolicExpr > LMCAS::multivariate_factor_expression ( const MultiFactorResult & result, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 381 行定义.

                                                                  {
    std::vector<std::shared_ptr<const SymbolicNode>> factor_nodes;
 
    if (!(result.constant == Rational(1))) {
        factor_nodes.push_back(
            LMCAS::detail::node(SymbolicExpr::number(result.constant)));
    }
 
    for (size_t i = 0; i < result.factors.size(); ++i) {
        auto factor_expr = multipoly_to_symbolic(result.factors[i], context);
        if (!factor_expr || factor_expr->is_zero()) { continue; }
 
        int mult = (i < result.multiplicities.size())
            ? result.multiplicities[i] : 1;
 
        if (mult == 1) {
            factor_nodes.push_back(LMCAS::detail::node(factor_expr));
        } else {
            auto pow_expr = SymbolicExpr::power(
                factor_expr, SymbolicExpr::number(mult));
            factor_nodes.push_back(LMCAS::detail::node(pow_expr));
        }
    }
 
    if (factor_nodes.size() > 1) {
        return LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<MultiplyNode>(std::move(factor_nodes)));
    } else if (factor_nodes.size() == 1) {
        return LMCAS::detail::make_expression_ptr(factor_nodes[0]);
    }
    return nullptr;
}

引用了 LMCAS::MultiFactorResult::constant, context, LMCAS::MultiFactorResult::factors, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::MultiFactorResult::multiplicities, multipoly_to_symbolic(), multivariate_factor_expression() , 以及 LMCAS::detail::node().

被这些函数引用 factor_multivariate_expression() , 以及 multivariate_factor_expression().

函数调用图:

这是这个函数的调用关系图:

multivariate_gcd()

MultiPoly LMCAS::multivariate_gcd	(	const MultiPoly &	a,
		const MultiPoly &	b )

在文件 multivariate_factor.cpp 第 364 行定义.

{
    if (a.is_zero()) { return b.is_zero() ? MultiPoly() : b.make_primitive(); }
    if (b.is_zero()) { return a.make_primitive(); }
    const auto& vars = a.variables().empty() ? b.variables() : a.variables();
    if (a.is_constant() && b.is_constant()) {
        Rational g = rational_gcd(a.numeric_content(), b.numeric_content());
        return MultiPoly(g, vars);
    }
    if (a.is_univariate() && b.is_univariate()) {
        return univariate_gcd(a, b, vars);
    }
    return recursive_multivariate_gcd(a, b, vars);
}

引用了 a, b, multivariate_gcd(), rational_gcd(), recursive_multivariate_gcd(), univariate_gcd() , 以及 vars.

被这些函数引用 collect_gcd_samples(), multivariate_content(), multivariate_gcd(), square_free_decompose(), symbolic_polynomial_gcd() , 以及 LMCAS::anonymous_namespace{symbolic_gcd.cpp}::verify_gcd_candidate().

函数调用图:

这是这个函数的调用关系图:

multivariate_hensel_lift()

std::vector< MultiPoly > LMCAS::multivariate_hensel_lift	(	const MultiPoly &	poly,
		const std::vector< Polynomial< Rational > > &	univariate_factors,
		const std::string &	lift_var,
		const Rational &	eval_point,
		int	degree_bound )

多元 Hensel 提升(单变量步)

将一元因子逐变量提升,从 f(x_1, a_2, ..., a_n) 的因子恢复到包含 lift_var 的因子. 每次引入一个辅助变量,计算修正项直到达到次数上界.

算法(参考 Geddes, Czapor, Labahn Section15.6):

1. 将一元因子嵌入到完整变量集中
2. 对 k = 1, ..., degree_bound: a. 计算当前因子乘积(截断到 lift_var 次数 <= k) b. 计算误差 E = poly - product(提取 lift_var 次数恰为 k 的部分) c. 若误差为零则继续 d. 用丢番图求解器分配误差到各因子 e. 将修正项加到各因子上 f. 验证:product of lifted factors == poly mod (lift_var - eval_point)^(k+1)
3. 返回提升后的因子

参数

[in]	poly	原始多元多项式
[in]	univariate_factors	一元分解得到的因子列表
[in]	lift_var	当前提升的变量名
[in]	eval_point	该变量的求值点
[in]	degree_bound	提升次数上界

返回

提升后的多元因子列表

参见

Geddes, Czapor, Labahn. "Algorithms for Computer Algebra." Section15.6.

确定主变量(一元因子的变量)和提升变量在完整变量集中的位置

lift_var 位于变量域之外时,返回嵌入后的原因子.

在文件 multivariate_hensel.cpp 第 237 行定义.

{
    int r = static_cast<int>(univariate_factors.size());
    if (r == 0) { return {}; }
    if (r == 1) {
        return {poly};
    }
    if (degree_bound <= 0) {
        return embed_without_lifting(univariate_factors, poly.variables());
    }
 
    const auto& vars = poly.variables();
 
    /// 确定主变量(一元因子的变量)和提升变量在完整变量集中的位置
    std::string main_var = univariate_factors[0].variable_name;
    int lift_var_idx = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == lift_var) { lift_var_idx = static_cast<int>(i); }
    }
 
    for (const auto& factor : univariate_factors) {
        if (factor.variable_name != main_var) {
            throw std::invalid_argument("Hensel lifting: univariate factor ring mismatch");
        }
    }
    auto factors = embed_without_lifting(univariate_factors, vars);
 
    /// lift_var 位于变量域之外时,返回嵌入后的原因子.
    if (lift_var_idx < 0) {
        return factors;
    }
 
    MultiPoly base_product(Rational(1), vars);
    for (const auto& factor : factors) { base_product = base_product * factor; }
    if (base_product.eval(lift_var, eval_point) != poly.eval(lift_var, eval_point)) {
        return {};
    }
 
    if (!apply_hensel_lift_steps(
            poly, factors, lift_var, lift_var_idx, eval_point, degree_bound, r)) {
        return {};
    }
 
    return factors;
}

引用了 apply_hensel_lift_steps(), embed_without_lifting(), main_var, multivariate_hensel_lift(), r , 以及 vars.

被这些函数引用 LMCAS::multivariate_checked_detail::factor_linear_hensel() , 以及 multivariate_hensel_lift().

函数调用图:

这是这个函数的调用关系图:

multivariate_primitive_part()

MultiPoly LMCAS::multivariate_primitive_part	(	const MultiPoly &	poly,
		const std::string &	main_var )

content 的变量集是去掉 main_var 后的辅助变量集, 需要将其嵌入到 poly 的完整变量集中才能正确执行 exact_div.

在文件 multivariate_factor.cpp 第 180 行定义.

{
    if (poly.is_zero()) { return poly; }
    MultiPoly content = multivariate_content(poly, main_var);
    if (content.is_zero()) { return MultiPoly(); }
    if (content.is_constant() && content.numeric_content() == Rational(1)) { return poly; }
 
    /// content 的变量集是去掉 main_var 后的辅助变量集,
    /// 需要将其嵌入到 poly 的完整变量集中才能正确执行 exact_div.
    const auto& full_vars = poly.variables();
    int var_idx = -1;
    for (size_t i = 0; i < full_vars.size(); ++i) {
        if (full_vars[i] == main_var) { var_idx = static_cast<int>(i); break; }
    }
 
    MultiPoly content_in_full_vars = content;
    if (var_idx >= 0 && content.variables().size() < full_vars.size()) {
        std::vector<MultiPoly::Term> new_terms;
        for (const auto& term : content.terms()) {
            Monomial full_mono = restore_main_exponent(
                term.first, full_vars.size(), var_idx, 0);
            new_terms.emplace_back(std::move(full_mono), term.second);
        }
        content_in_full_vars = MultiPoly(std::move(new_terms), full_vars);
    }
 
    return poly.exact_div(content_in_full_vars);
}

引用了 main_var, multivariate_content(), multivariate_primitive_part() , 以及 restore_main_exponent().

被这些函数引用 multivariate_primitive_part().

函数调用图:

这是这个函数的调用关系图:

ne()

ExprResult LMCAS::ne	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_facade.cpp 第 193 行定义.

                                                      {
    return relation(lhs, rhs, RelationOp::NEQ);
}

引用了 ne(), NEQ, relation() , 以及 rhs.

被这些函数引用 ne().

函数调用图:

这是这个函数的调用关系图:

neg() [1/2]

ExprResult LMCAS::neg

(

const ExprPtr &

expression

)

在文件 expr_arithmetic.cpp 第 57 行定义.

                                          {
    ComputationContext context;
    return neg(expression, context);
}

引用了 context , 以及 neg().

函数调用图:

neg() [2/2]

ExprResult LMCAS::neg	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 51 行定义.

                                                                       {
    auto minus_one = integer(-1);
    if (!minus_one) { return ExprResult::failure(minus_one.error()); }
    return mul(minus_one.value(), expression, context);
}

引用了 context, LMCAS::Result< ExprPtr >::failure(), integer, mul() , 以及 neg().

被这些函数引用 neg(), neg(), LMCAS::expr_detail::ExprParser::parse_unary() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_power().

函数调用图:

这是这个函数的调用关系图:

newton_raphson_checked() [1/4]

NumericRootResult LMCAS::newton_raphson_checked	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	variable,
		lmmc_real_t	initial,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 newton_raphson.cpp 第 414 行定义.

                                 {
    auto valid = invalid_root_options(options, kNewtonOperation);
    if (!valid) {
        return valid;
    }
    if (!function || !derivative || variable.empty() ||
        !std::isfinite(initial)) {
        return NumericRootResult::failure(
            CasErrc::InvalidArgument,
            "Newton function, derivative, variable, and finite initial value are required",
            kNewtonOperation);
    }
    return run_newton_backend(
        function, derivative, variable, initial, context, options, false, 0.0,
        0.0);
}

引用了 context, LMCAS::Result< std::optional< NumericRoot > >::failure(), function(), InvalidArgument, newton_raphson_checked(), options , 以及 variable.

函数调用图:

newton_raphson_checked() [2/4]

NumericRootResult LMCAS::newton_raphson_checked	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	variable,
		lmmc_real_t	initial,
		const SolveOptions &	options )

在文件 newton_raphson.cpp 第 437 行定义.

                                 {
    ComputationContext context;
    return newton_raphson_checked(
        function, derivative, variable, initial, context, options);
}

引用了 context, function(), newton_raphson_checked(), options , 以及 variable.

函数调用图:

newton_raphson_checked() [3/4]

NumericRootResult LMCAS::newton_raphson_checked	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	variable,
		lmmc_real_t	initial,
		lmmc_real_t	bracket_lower,
		lmmc_real_t	bracket_upper,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 newton_raphson.cpp 第 369 行定义.

                                 {
    auto valid = invalid_root_options(options, kNewtonOperation);
    if (!valid) {
        return valid;
    }
    if (!function || !derivative || variable.empty() ||
        !valid_newton_bracket(initial, bracket_lower, bracket_upper)) {
        return NumericRootResult::failure(
            CasErrc::InvalidArgument,
            "Newton function, derivative, variable, bracket, and initial value are invalid",
            kNewtonOperation);
    }
    auto newton = run_newton_backend(
        function, derivative, variable, initial, context, options, true,
        bracket_lower, bracket_upper);
    if (!newton || newton.value()) {
        return newton;
    }
    return run_bisection_backend(
        function, variable, bracket_lower, bracket_upper, context, options,
        kBisectionOperation);
}

引用了 context, LMCAS::Result< std::optional< NumericRoot > >::failure(), function(), InvalidArgument, newton_raphson_checked(), options, valid_newton_bracket() , 以及 variable.

被这些函数引用 newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_initial_guess() , 以及 LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial().

函数调用图:

这是这个函数的调用关系图:

newton_raphson_checked() [4/4]

NumericRootResult LMCAS::newton_raphson_checked	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	variable,
		lmmc_real_t	initial,
		lmmc_real_t	bracket_lower,
		lmmc_real_t	bracket_upper,
		const SolveOptions &	options )

在文件 newton_raphson.cpp 第 400 行定义.

                                 {
    ComputationContext context;
    return newton_raphson_checked(
        function, derivative, variable, initial, bracket_lower, bracket_upper,
        context, options);
}

引用了 context, function(), newton_raphson_checked(), options , 以及 variable.

函数调用图:

norm_subst_index()

std::shared_ptr< const SymbolicNode > LMCAS::norm_subst_index	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	index_var,
		const std::shared_ptr< const SymbolicNode > &	value,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_utils.cpp 第 101 行定义.

                                                                                 {
    normalization_check_children(budget, 0, node);
    return LMCAS::substitute_free(node, index_var, value, budget);
}

引用了 norm_subst_index(), normalization_check_children(), substitute_free() , 以及 value.

被这些函数引用 norm_subst_index(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::NormalizationVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normal_form()

FGLMPoly LMCAS::normal_form	(	const FGLMPoly &	f,
		const std::vector< FGLMPoly > &	basis,
		const MonomialOrder &	order )

在文件 fglm_polynomial.cpp 第 127 行定义.

                                                        {
    return f.reduce(basis, order);
}

引用了 basis, normal_form() , 以及 order.

被这些函数引用 fglm_convert() , 以及 normal_form().

函数调用图:

这是这个函数的调用关系图:

normalization_append()

void LMCAS::normalization_append	(	detail::RewriteBudget *	budget,
		std::size_t &	nodes,
		std::vector< std::shared_ptr< const SymbolicNode > > &	children,
		std::shared_ptr< const SymbolicNode >	child )

在文件 normalization_utils.cpp 第 7 行定义.

                                             {
    if (budget) {
        nodes = budget->append_size(nodes, budget->measure(child));
    }
    children.push_back(std::move(child));
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::RewriteBudget::measure() , 以及 normalization_append().

被这些函数引用 LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::add_base(), check_negative_arg(), LMCAS::NormalizationVisitor::collect_sum(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::NormalizationVisitor::extract_term_coefficient(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::finish(), LMCAS::NormalizationVisitor::fuse_matrix_product(), LMCAS::NormalizationVisitor::matrix_product_element(), LMCAS::NormalizationVisitor::merge_complex_terms(), normalization_append(), LMCAS::NormalizationVisitor::normalize_matrix_product(), LMCAS::NormalizationVisitor::normalize_matrix_sum(), LMCAS::anonymous_namespace{normalization_norms.cpp}::normalized_norm_argument(), LMCAS::NormalizationVisitor::scale_matrix(), 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::anonymous_namespace{normalization_arithmetic.cpp}::weighted_term().

函数调用图:

这是这个函数的调用关系图:

normalization_can_discard()

bool LMCAS::normalization_can_discard ( const std::shared_ptr< const SymbolicNode > & node, const FactsQuery & facts, Domain domain, ComputationContext & context )

inline

在文件 normalization_utils.hpp 第 16 行定义.

                                                {
    return (domain == Domain::Complex ||
            normalization_proved(detail::query_definedness(node, facts, Domain::Real, context))) &&
           normalization_proved(detail::query_definedness(node, facts, Domain::Complex, context));
}

引用了 Complex, context, domain, normalization_can_discard(), normalization_proved(), LMCAS::detail::query_definedness() , 以及 Real.

被这些函数引用 LMCAS::NormalizationVisitor::collect_sum(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::SymbolicFactory::create_power(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::factors_defined(), normalization_can_discard(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::ExpandVisitor::visit() , 以及 LMCAS::NormalizationVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normalization_check_arithmetic() [1/2]

template<class Parent>

std::size_t LMCAS::normalization_check_arithmetic	(	detail::RewriteBudget *	budget,
		const std::vector< std::shared_ptr< const SymbolicNode > > &	children,
		std::size_t	nodes,
		bool	wrapped = true )

在文件 normalization_utils.hpp 第 65 行定义.

                                        {
    if (!budget) {
        return 0;
    }
    budget->require_nodes(nodes);
    if (!wrapped) {
        return nodes;
    }
    for (const auto& child : children) {
        if (dynamic_cast<const Parent*>(child.get())) {
            --nodes;
        }
    }
    return budget->append_size(1, nodes);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), normalization_check_arithmetic() , 以及 LMCAS::detail::RewriteBudget::require_nodes().

函数调用图:

normalization_check_arithmetic() [2/2]

template<class Parent, class... Nodes>

std::size_t LMCAS::normalization_check_arithmetic	(	detail::RewriteBudget *	budget,
		std::size_t	extra_nodes,
		const std::shared_ptr< const Nodes > &...	children )

在文件 normalization_utils.hpp 第 48 行定义.

                                                                          {
    if (!budget) {
        return 0;
    }
    std::size_t nodes = extra_nodes, flattened = 0;
    const auto append = [&](const auto& child) {
        nodes = budget->append_size(nodes, budget->measure(child));
        if (dynamic_cast<const Parent*>(child.get())) {
            ++flattened;
        }
    };
    (append(children), ...);
    return budget->append_size(1, nodes - flattened);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::RewriteBudget::measure() , 以及 normalization_check_arithmetic().

被这些函数引用 LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::ComplexProduct::accumulate(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), LMCAS::anonymous_namespace{poly_utils.cpp}::coefficient_arithmetic(), LMCAS::NormalizationVisitor::collect_sum(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::NormalizationVisitor::distribute_product(), make_normalized_multiply_node(), matrix_multiply_checked(), LMCAS::NormalizationVisitor::matrix_product_element(), normalization_check_arithmetic(), normalization_check_arithmetic(), LMCAS::NormalizationVisitor::normalize_matrix_sum(), LMCAS::anonymous_namespace{normalization_norms.cpp}::normalized_norm_argument(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prepare_operands(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), LMCAS::NormalizationVisitor::scale_matrix(), LMCAS::ExpandVisitor::visit() , 以及 LMCAS::NormalizationVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normalization_check_children() [1/2]

template<class... Nodes>

void LMCAS::normalization_check_children	(	detail::RewriteBudget *	budget,
		std::size_t	roots,
		const std::shared_ptr< const Nodes > &...	children )

在文件 normalization_utils.hpp 第 27 行定义.

                                                                    {
    if (!budget) {
        return;
    }
    budget->require_nodes(roots);
    ((roots = budget->append_size(roots, budget->measure(children))), ...);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::RewriteBudget::measure(), normalization_check_children(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 roots().

被这些函数引用 LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::NormalizationVisitor::finish_squared_norm(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::function(), LMCAS::NormalizationVisitor::merge_complex_terms(), norm_subst_index(), normalization_check_children(), normalization_check_children(), LMCAS::NormalizationVisitor::normalize_function_parity(), LMCAS::NormalizationVisitor::normalize_logarithm(), 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_square_root(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::power(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::register_new_atom(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_exp_log.cpp}::rewrite_exp_log_function(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_radical(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_trig.cpp}::rewrite_trig_function(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), symbolic_power_to_poly(), symbolic_product_to_poly(), symbolic_to_poly_recursive(), 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().

函数调用图:

这是这个函数的调用关系图:

normalization_check_children() [2/2]

void LMCAS::normalization_check_children ( detail::RewriteBudget * budget, std::size_t roots, const std::vector< std::shared_ptr< const SymbolicNode > > & children )

inline

在文件 normalization_utils.hpp 第 36 行定义.

                                                                  {
    if (!budget) {
        return;
    }
    budget->require_nodes(roots);
    for (const auto& child : children) {
        roots = budget->append_size(roots, budget->measure(child));
    }
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::RewriteBudget::measure(), normalization_check_children(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 roots().

函数调用图:

normalization_check_count()

std::size_t LMCAS::normalization_check_count	(	detail::RewriteBudget *	budget,
		std::size_t	rows,
		std::size_t	cols = 1,
		bool	wrapped = true )

在文件 normalization_utils.cpp 第 16 行定义.

                                                  {
    if (budget) {
        const auto maximum = std::numeric_limits<std::size_t>::max();
        if (cols != 0 && rows > maximum / cols) {
            budget->append_size(maximum, 1);
        }
        budget->append_size(wrapped ? 1 : 0, rows * cols);
    }
    return rows * cols;
}

引用了 LMCAS::detail::RewriteBudget::append_size() , 以及 normalization_check_count().

被这些函数引用 LMCAS::NormalizationVisitor::distribute_power(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::NormalizationVisitor::extract_term_coefficient(), LMCAS::NormalizationVisitor::fuse_matrix_product(), matrix_multiply_checked(), LMCAS::NormalizationVisitor::matrix_product_element(), normalization_check_count(), LMCAS::NormalizationVisitor::normalize_matrix_sum(), LMCAS::NormalizationVisitor::scale_matrix(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::NormalizationVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normalization_exact_square_root()

std::shared_ptr< const NumberNode > LMCAS::normalization_exact_square_root

(

const NumberNode &

number

)

在文件 normalization_numeric_powers.cpp 第 103 行定义.

                                                                                          {
    if (const auto* integer = std::get_if<BigInt>(&number.value())) {
        if (*integer < BigInt(0)) {
            return nullptr;
        }
        const BigInt root = integer->sqrt();
        if (root * root == *integer) {
            return detail::make_node<NumberNode>(root);
        }
        return nullptr;
    }
    const auto* rational = std::get_if<Rational>(&number.value());
    if (!rational || *rational < Rational(0)) {
        return nullptr;
    }
    const BigInt numerator = rational->get_numerator().sqrt();
    const BigInt denominator = rational->get_denominator().sqrt();
    if (numerator * numerator != rational->get_numerator()) {
        return nullptr;
    }
    if (denominator * denominator != rational->get_denominator()) {
        return nullptr;
    }
    return detail::make_node<NumberNode>(Rational(numerator, denominator));
}

引用了 denominator, integer, LMCAS::detail::make_node(), normalization_exact_square_root(), rational() , 以及 LMCAS::NumberNode::value().

被这些函数引用 exact_radical_domain_excludes(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::half_numeric_power(), normalization_exact_square_root(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::numeric_square_root() , 以及 LMCAS::NormalizationVisitor::try_normalize_squared_norm().

函数调用图:

这是这个函数的调用关系图:

normalization_factor_less()

bool LMCAS::normalization_factor_less	(	const std::shared_ptr< const SymbolicNode > &	left,
		const std::shared_ptr< const SymbolicNode > &	right )

在文件 normalization_utils.cpp 第 29 行定义.

                                                                               {
    const BigInt a = get_node_degree_helper(left);
    const BigInt b = get_node_degree_helper(right);
    if (a != b) {
        return a > b;
    }
    return left->compare(*right) < 0;
}

引用了 a, b, get_node_degree_helper(), normalization_factor_less() , 以及 right.

被这些函数引用 LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::finish() , 以及 normalization_factor_less().

函数调用图:

这是这个函数的调用关系图:

normalization_imaginary_power()

std::shared_ptr< const SymbolicNode > LMCAS::normalization_imaginary_power	(	const BigInt &	exponent,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_numeric_powers.cpp 第 129 行定义.

                                                         {
    BigInt remainder = exponent % BigInt(4);
    if (remainder.is_negative()) remainder += BigInt(4);
    if (budget) { budget->require_nodes(3); }
    if (remainder.is_zero()) {
        return detail::make_node<NumberNode>(BigInt(1));
    }
    if (remainder == BigInt(2)) {
        return detail::make_node<NumberNode>(BigInt(-1));
    }
    auto imaginary = detail::make_node<PowerNode>(
        detail::make_node<NumberNode>(BigInt(-1)),
        detail::make_node<NumberNode>(Rational(1, 2)));
    if (remainder == BigInt(1)) {
        return imaginary;
    }
    return make_normalized_multiply_node(
        {detail::make_node<NumberNode>(BigInt(-1)), imaginary}, budget);
}

引用了 exponent, LMCAS::detail::make_node(), make_normalized_multiply_node(), normalization_imaginary_power() , 以及 LMCAS::detail::RewriteBudget::require_nodes().

被这些函数引用 normalization_imaginary_power(), normalization_numeric_power() , 以及 LMCAS::NormalizationVisitor::normalize_nested_imaginary_power().

函数调用图:

这是这个函数的调用关系图:

normalization_numeric_function()

std::shared_ptr< const SymbolicNode > LMCAS::normalization_numeric_function	(	FunctionNode::FuncType	type,
		const std::shared_ptr< const NumberNode > &	number,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_numeric_functions.cpp 第 55 行定义.

                                 {
    if (budget) { budget->require_nodes(1); }
    if (number_equals_integer(number, BigInt(0))) {
        if (auto value = function_at_zero(type)) {
            return value;
        }
    }
    if (type == FunctionNode::FuncType::Ln &&
        number_equals_integer(number, BigInt(1))) {
        return detail::make_node<NumberNode>(BigInt(0));
    }
    switch (type) {
        case FunctionNode::FuncType::Abs: return numeric_absolute(*number);
        case FunctionNode::FuncType::Sqrt: return numeric_square_root(number, budget);
        case FunctionNode::FuncType::LambertW: return numeric_lambert_w(number);
        default: return nullptr;
    }
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::FunctionNode::LambertW, LMCAS::FunctionNode::Ln, LMCAS::detail::make_node(), normalization_numeric_function(), LMCAS::detail::RewriteBudget::require_nodes(), LMCAS::FunctionNode::Sqrt , 以及 value.

被这些函数引用 normalization_numeric_function() , 以及 LMCAS::NormalizationVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normalization_numeric_power()

std::shared_ptr< const SymbolicNode > LMCAS::normalization_numeric_power	(	const std::shared_ptr< const NumberNode > &	base,
		const std::shared_ptr< const NumberNode > &	exponent,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_numeric_powers.cpp 第 150 行定义.

                                                                                  {
    if (budget) { budget->require_nodes(1); }
    BigInt integer;
    if (try_get_integer_value(exponent, integer)) {
        if (auto value = integer_numeric_power(base, integer)) {
            return value;
        }
    } else if (is_half_exponent(*exponent)) {
        if (auto value = half_numeric_power(*base, budget)) {
            return value;
        }
    }
    const auto* rational = std::get_if<Rational>(&exponent->value());
    if (!rational || !base->is_negative_one()) {
        return nullptr;
    }
    if (rational->get_denominator() != BigInt(2)) {
        return nullptr;
    }
    return normalization_imaginary_power(rational->get_numerator(), budget);
}

引用了 exponent, integer, normalization_imaginary_power(), normalization_numeric_power(), rational(), LMCAS::detail::RewriteBudget::require_nodes(), try_get_integer_value() , 以及 value.

被这些函数引用 normalization_numeric_power() , 以及 LMCAS::NormalizationVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normalization_pi_function()

std::shared_ptr< const SymbolicNode > LMCAS::normalization_pi_function	(	FunctionNode::FuncType	type,
		const Rational &	coefficient,
		detail::RewriteBudget *	budget = nullptr )

在文件 normalization_trigonometric.cpp 第 94 行定义.

                                                                                         {
    if (budget) { budget->require_nodes(1); }
    const BigInt& denominator = coefficient.get_denominator();
    const BigInt period = denominator * BigInt(2);
    BigInt numerator = coefficient.get_numerator() % period;
    if (numerator.is_negative()) numerator += period;
    if (denominator == BigInt(1)) {
        return integer_pi(type, numerator);
    }
    if (denominator == BigInt(2)) {
        return halves_pi(type, numerator);
    }
    if (denominator == BigInt(3)) {
        return thirds_pi(type, numerator, budget);
    }
    if (denominator == BigInt(4)) {
        return quarters_pi(type, numerator, budget);
    }
    if (denominator == BigInt(6)) {
        return sixths_pi(type, numerator, budget);
    }
    return nullptr;
}

引用了 denominator, normalization_pi_function() , 以及 LMCAS::detail::RewriteBudget::require_nodes().

被这些函数引用 normalization_pi_function() , 以及 LMCAS::NormalizationVisitor::normalize_unary_function().

函数调用图:

这是这个函数的调用关系图:

normalization_proved()

bool LMCAS::normalization_proved ( const Result< Tribool > & result )

inline

在文件 normalization_utils.hpp 第 12 行定义.

                                                                {
    if (!result) { throw result.error(); }
    return result.value() == Tribool::True;
}

引用了 LMCAS::Result< T >::error(), normalization_proved(), True , 以及 LMCAS::Result< T >::value().

被这些函数引用 LMCAS::NormalizationVisitor::can_combine_nested_power(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::SymbolicFactory::create_power(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), normalization_can_discard(), normalization_proved(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::NormalizationVisitor::normalize_natural_logarithm(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::NormalizationVisitor::simplify_assumed_absolute(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::integration_table_detail::u_is_real_var(), LMCAS::integration_table_detail::u_is_var_a_nonzero() , 以及 LMCAS::ExpandVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

normalize_gcd_candidate()

MultiPoly LMCAS::normalize_gcd_candidate ( MultiPoly candidate, const Rational & content )

static

在文件 multivariate_factor.cpp 第 301 行定义.

                                                                   {
    if (content != Rational(1)) { candidate = candidate * content; }
    if (!candidate.terms().empty() && candidate.terms()[0].second < Rational(0)) {
        candidate = candidate * Rational(-1);
    }
    return candidate;
}

引用了 normalize_gcd_candidate().

被这些函数引用 extended_gcd_interpolation(), normalize_gcd_candidate() , 以及 recursive_multivariate_gcd().

函数调用图:

这是这个函数的调用关系图:

normalize_intervals_checked() [1/2]

Result< std::vector< Interval > > LMCAS::normalize_intervals_checked

(

std::vector< Interval >

intervals

)

在文件 interval_normalization.cpp 第 119 行定义.

                                   {
    ComputationContext context;
    return normalize_intervals_checked(std::move(intervals), context);
}

引用了 context , 以及 normalize_intervals_checked().

函数调用图:

normalize_intervals_checked() [2/2]

Result< std::vector< Interval > > LMCAS::normalize_intervals_checked	(	std::vector< Interval >	intervals,
		ComputationContext &	context )

在文件 interval_normalization.cpp 第 109 行定义.

                                 {
    auto checked = collect_nonempty_intervals(std::move(intervals), context);
    if (!checked) return Result<std::vector<Interval>>::failure(checked.error());
    auto sorted = sort_checked_intervals(checked.value(), context);
    if (!sorted) return Result<std::vector<Interval>>::failure(sorted.error());
    return merge_checked_intervals(std::move(checked.value()), context);
}

引用了 context , 以及 normalize_intervals_checked().

被这些函数引用 LMCAS::anonymous_namespace{interval_set_operations.cpp}::checked_interval_views(), normalize_intervals_checked(), normalize_intervals_checked() , 以及 validate_property_interval().

函数调用图:

这是这个函数的调用关系图:

numeric_domain_excludes()

bool LMCAS::numeric_domain_excludes ( double value, Domain domain )

static

在文件 solver_assumptions.cpp 第 59 行定义.

                                                                 {
    if (domain == Domain::Integer || domain == Domain::Natural || domain == Domain::PositiveInt) {
        if (!is_integer_value(value)) {
            return true;
        }
    }
    if (domain == Domain::Natural || domain == Domain::PositiveInt) {
        if (value < 0.0) {
            return true;
        }
    }
    if (domain == Domain::PositiveInt) {
        int equal;
        lmmc_double_nearly_equal(value, 0.0, &equal);
        if (equal || value <= 0.0) {
            return true;
        }
    }
    return false;
}

引用了 domain, Integer, Natural, numeric_domain_excludes(), PositiveInt , 以及 value.

被这些函数引用 numeric_domain_excludes() , 以及 solution_is_excluded().

函数调用图:

这是这个函数的调用关系图:

numeric_sign_excludes()

bool LMCAS::numeric_sign_excludes ( double value, const AssumptionContext & ctx, const std::string & variable )

static

在文件 solver_assumptions.cpp 第 80 行定义.

                                                             {
    bool exclude = false;
    if (ctx.has_sign(variable, Sign::NonNegative) && value < 0.0) {
        exclude = true;
    }
    if (ctx.has_sign(variable, Sign::Positive)) {
        int equal;
        lmmc_double_nearly_equal(value, 0.0, &equal);
        if (equal || value <= 0.0) {
            exclude = true;
        }
    }
    if (ctx.has_sign(variable, Sign::Negative) && value >= 0.0) {
        exclude = true;
    }
    if (ctx.has_sign(variable, Sign::NonPositive) && value > 0.0) {
        exclude = true;
    }
    return exclude;
}

引用了 Negative, NonNegative, NonPositive, numeric_sign_excludes(), Positive, value , 以及 variable.

被这些函数引用 numeric_sign_excludes() , 以及 solution_is_excluded().

函数调用图:

这是这个函数的调用关系图:

numeric_token_value()

std::shared_ptr< SymbolicExpr > LMCAS::numeric_token_value ( const std::string & str, size_t start, size_t & pos, bool decimal )

static

在文件 interval_serialization.cpp 第 106 行定义.

                                                                   {
    const std::string token = str.substr(start, pos - start);
    if (!decimal) {
        return SymbolicExpr::number(BigInt(token));
    }
    return SymbolicExpr::number(Rational(token));
}

引用了 numeric_token_value().

被这些函数引用 numeric_token_value() , 以及 parse_numeric_value().

函数调用图:

这是这个函数的调用关系图:

operator<<() [1/2]

std::ostream & LMCAS::operator<<	(	std::ostream &	os,
		const Irrational &	value )

在文件 irrational_representation.cpp 第 82 行定义.

                                                                {
    return os << value.to_string();
}

引用了 operator<<() , 以及 value.

函数调用图:

operator<<() [2/2]

template<typename T>

std::ostream & LMCAS::operator<<	(	std::ostream &	os,
		const Polynomial< T > &	p )

多项式流输出运算符

模板参数

T

系数类型

参数

os	输出流
p	多项式

返回

输出流引用

在文件 polynomial.hpp 第 428 行定义.

                                                               {
    if (p.is_zero()) {
        return os << "0";
    }
    for (int i = p.degree(); i >= 0; --i) {
        T c = p.coeffs[i];
        if (c == T(0)) {
            continue;
        }
 
        if (i < p.degree()) {
            if (c > T(0)) {
                os << " + ";
            } else {
                os << " - ";
            }
        } else if (c < T(0)) {
            os << "-";
        }
 
        T abs_c = (c < T(0)) ? (c * T(-1)) : c;
        if (abs_c != T(1) || i == 0) {
            os << abs_c;
        }
 
        if (i > 0) {
            os << p.variable_name;
        }
        if (i > 1) {
            os << "^" << i;
        }
    }
    return os;
}

引用了 c, LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::is_zero(), operator<<() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 operator<<() , 以及 operator<<().

函数调用图:

这是这个函数的调用关系图:

ordinary_frobenius_solution()

FrobeniusSolutionResult LMCAS::ordinary_frobenius_solution ( const std::shared_ptr< SymbolicExpr > & p, const std::shared_ptr< SymbolicExpr > & q, const std::shared_ptr< SymbolicExpr > & x0, const std::string & x, const std::shared_ptr< SymbolicExpr > & x_minus_x0, FrobeniusSolution result, ComputationContext & context )

static

在文件 ode_frobenius.cpp 第 293 行定义.

                                                               {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto coefficients = ordinary_taylor_coefficients(p, q, x0, x, result.truncation_order, context);
    if (!coefficients) {
        return FrobeniusSolutionResult::failure(coefficients.error());
    }
    auto recurrence = ordinary_series_recurrence(coefficients.value(), result.truncation_order);
    if (!recurrence) {
        return FrobeniusSolutionResult::failure(recurrence.error());
    }
    result.series_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(assemble_frobenius_polynomial(
        recurrence.value(), x_minus_x0)), transform_budget));
    result.indicial_roots = {0.0};
    return result;
} catch (const CasError& error) {
    return FrobeniusSolutionResult::failure(error);
} catch (const std::bad_alloc&) {
    return FrobeniusSolutionResult::failure(CasErrc::ResourceLimit, "allocation failed", "ordinary_frobenius_solution");
} catch (const std::length_error& error) {
    return FrobeniusSolutionResult::failure(CasErrc::ResourceLimit, error.what(), "ordinary_frobenius_solution");
} catch (const std::exception& error) {
    return FrobeniusSolutionResult::failure(CasErrc::InternalInvariant, error.what(), "ordinary_frobenius_solution");
}

引用了 assemble_frobenius_polynomial(), context, LMCAS::Result< FrobeniusSolution >::failure(), LMCAS::FrobeniusSolution::indicial_roots, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), ordinary_frobenius_solution(), ordinary_series_recurrence(), ordinary_taylor_coefficients(), LMCAS::FrobeniusSolution::series_solution , 以及 LMCAS::FrobeniusSolution::truncation_order.

被这些函数引用 ordinary_frobenius_solution() , 以及 solve_frobenius_impl().

函数调用图:

这是这个函数的调用关系图:

ordinary_series_recurrence()

Result< std::vector< double > > LMCAS::ordinary_series_recurrence ( const OdeTaylorCoefficients & coefficients, int order )

static

在文件 ode_frobenius.cpp 第 96 行定义.

                                                          {
    const auto& p_coeffs = coefficients.p;
    const auto& q_coeffs = coefficients.q;
        std::vector<double> a(order + 1, 0.0);
        a[0] = 1.0;
        for (int n_idx = 0; n_idx + 2 <= order; ++n_idx) {
            double sum = 0.0;
            for (int k = 0; k <= n_idx; ++k) {
                sum += (k + 1) * a[k + 1] * p_coeffs[n_idx - k];
                sum += a[k] * q_coeffs[n_idx - k];
            }
            double denom = static_cast<double>((n_idx + 2) * (n_idx + 1));
            a[n_idx + 2] = -sum / denom;
            if (!std::isfinite(a[n_idx + 2])) {
                return Result<std::vector<double>>::failure(frobenius_arithmetic_failure());
            }
        }
 
    return a;
}

引用了 a, frobenius_arithmetic_failure(), order, ordinary_series_recurrence(), LMCAS::OdeTaylorCoefficients::p , 以及 LMCAS::OdeTaylorCoefficients::q.

被这些函数引用 ordinary_frobenius_solution() , 以及 ordinary_series_recurrence().

函数调用图:

这是这个函数的调用关系图:

ordinary_taylor_coefficients()

Result< OdeTaylorCoefficients > LMCAS::ordinary_taylor_coefficients ( const std::shared_ptr< SymbolicExpr > & p, const std::shared_ptr< SymbolicExpr > & q, const std::shared_ptr< SymbolicExpr > & x0, const std::string & x, int order, ComputationContext & context )

static

在文件 ode_frobenius.cpp 第 48 行定义.

                                                                    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
        std::vector<double> p_coeffs(order + 2, 0.0);
        std::vector<double> q_coeffs(order + 2, 0.0);
 
        auto p_current = p;
        auto q_current = q;
        double factorial = 1.0;
        for (int k = 0; k <= order + 1; ++k) {
            if (k > 0) {
                factorial *= k;
            }
            auto p_val_expr = detail::make_expression_ptr(detail::substitute_node(detail::node(p_current), x, detail::node(x0), transform_budget));
            auto q_val_expr = detail::make_expression_ptr(detail::substitute_node(detail::node(q_current), x, detail::node(x0), transform_budget));
            double pv = try_eval_double(p_val_expr);
            double qv = try_eval_double(q_val_expr);
            if (!std::isfinite(pv) || !std::isfinite(qv)) {
                return Result<OdeTaylorCoefficients>::failure(frobenius_unsupported_numeric());
            }
            p_coeffs[k] = pv / factorial;
            q_coeffs[k] = qv / factorial;
            p_current = detail::make_expression_ptr(detail::differentiate_node(detail::node(p_current), x, transform_budget));
            q_current = detail::make_expression_ptr(detail::differentiate_node(detail::node(q_current), x, transform_budget));
            if (!p_current) {
                p_current = SymbolicExpr::number(0);
            }
            if (!q_current) {
                q_current = SymbolicExpr::number(0);
            }
        }
 
    return OdeTaylorCoefficients{std::move(p_coeffs), std::move(q_coeffs)};
} catch (const CasError& error) {
    return Result<OdeTaylorCoefficients>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<OdeTaylorCoefficients>::failure(CasErrc::ResourceLimit, "allocation failed", "ordinary_taylor_coefficients");
} catch (const std::length_error& error) {
    return Result<OdeTaylorCoefficients>::failure(CasErrc::ResourceLimit, error.what(), "ordinary_taylor_coefficients");
} catch (const std::exception& error) {
    return Result<OdeTaylorCoefficients>::failure(CasErrc::InternalInvariant, error.what(), "ordinary_taylor_coefficients");
}

引用了 context, LMCAS::detail::differentiate_node(), LMCAS::Result< T >::failure(), frobenius_unsupported_numeric(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), order, ordinary_taylor_coefficients(), LMCAS::detail::substitute_node() , 以及 try_eval_double().

被这些函数引用 ordinary_frobenius_solution() , 以及 ordinary_taylor_coefficients().

函数调用图:

这是这个函数的调用关系图:

parametric_linear_solution()

std::map< std::string, std::shared_ptr< SymbolicExpr > > LMCAS::parametric_linear_solution ( const ParametricMatrix & A, const ParametricVector & b, const std::vector< size_t > & pivot_cols, const std::vector< size_t > & pivot_rows, const std::vector< std::string > & unknowns, ComputationContext & context )

static

在文件 parametric_solver.cpp 第 144 行定义.

                                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    size_t n = unknowns.size();
    std::map<std::string, std::shared_ptr<SymbolicExpr>> solution;
 
    std::set<size_t> pivot_col_set(pivot_cols.begin(), pivot_cols.end());
    for (size_t col = 0; col < n; ++col) {
        if (pivot_col_set.find(col) == pivot_col_set.end()) {
 
            solution[unknowns[col]] = SymbolicExpr::variable(unknowns[col]);
        }
    }
 
    for (size_t k = 0; k < pivot_cols.size(); ++k) {
        size_t col = pivot_cols[k];
        size_t row = pivot_rows[k];
 
        auto value = b[row];
 
        for (size_t j = col + 1; j < n; ++j) {
            if (pivot_col_set.find(j) != pivot_col_set.end()) {
                continue;
            }
            auto coeff = detail::make_expression_ptr(detail::normalize_node(detail::node(A[row][j]), transform_budget));
            if (!parametric_zero(coeff, context)) {
 
                auto term = SymbolicExpr::multiply(coeff, SymbolicExpr::variable(unknowns[j]));
                value = SymbolicExpr::add(value, SymbolicExpr::multiply(term, SymbolicExpr::number(-1)));
            }
        }
 
        auto pivot_val = A[row][col];
        value = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(value, pivot_val)), transform_budget));
 
        solution[unknowns[col]] = value;
    }
    return solution;
}

引用了 b, context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), parametric_linear_solution(), parametric_zero() , 以及 value.

被这些函数引用 parametric_linear_solution().

函数调用图:

这是这个函数的调用关系图:

parametric_nonzero_value()

Tribool LMCAS::parametric_nonzero_value ( const std::shared_ptr< SymbolicExpr > & expression, ComputationContext & context )

static

在文件 parametric_solver.cpp 第 81 行定义.

                                                                     {
    std::optional<detail::AssumptionFacts> assumptions;
    if (context.assumptions()) assumptions.emplace(*context.assumptions());
    const FactsQuery& facts = assumptions ? static_cast<const FactsQuery&>(*assumptions) : detail::no_facts();
    auto nonzero = detail::query_nonzero_value(detail::node(expression), facts, Domain::Complex, context);
    if (!nonzero) throw nonzero.error();
    return nonzero.value();
}

引用了 Complex, context, LMCAS::detail::no_facts(), LMCAS::detail::node(), parametric_nonzero_value() , 以及 LMCAS::detail::query_nonzero_value().

被这些函数引用 parametric_nonzero_value() , 以及 parametric_zero().

函数调用图:

这是这个函数的调用关系图:

parametric_residual_zero()

bool LMCAS::parametric_residual_zero ( const std::shared_ptr< SymbolicExpr > & expression, ComputationContext & context )

static

在文件 parametric_solver.cpp 第 72 行定义.

                                                                  {
    auto residual = check_zero_residual(expression, context);
    if (!residual) throw residual.error();
    if (std::holds_alternative<ProvedZeroResidual>(residual.value())) return true;
    throw CasError{CasErrc::Inconclusive,
        "parameter coefficient or constraint is undecided", "solve.parametric"};
}

引用了 check_zero_residual(), context, Inconclusive , 以及 parametric_residual_zero().

被这些函数引用 parametric_residual_zero() , 以及 parametric_zero().

函数调用图:

这是这个函数的调用关系图:

parametric_zero()

bool LMCAS::parametric_zero ( const std::shared_ptr< SymbolicExpr > & expression, ComputationContext & context )

static

在文件 parametric_solver.cpp 第 91 行定义.

                                                         {
    if (expression->is_zero()) return true;
    const auto nonzero = parametric_nonzero_value(expression, context);
    if (nonzero == Tribool::True) return false;
    if (nonzero == Tribool::False) return true;
    return parametric_residual_zero(expression, context);
}

引用了 context, False, parametric_nonzero_value(), parametric_residual_zero(), parametric_zero() , 以及 True.

被这些函数引用 find_parametric_pivot(), parametric_linear_solution() , 以及 parametric_zero().

函数调用图:

这是这个函数的调用关系图:

parse_approximate_atom()

std::shared_ptr< SymbolicExpr > LMCAS::parse_approximate_atom ( const std::string & str, size_t & pos )

static

< 消耗原子的结束分隔符，保留区间的分隔符。

在文件 interval_serialization.cpp 第 115 行定义.

                                       {
    const size_t start = pos;
    pos = skip_ws(str, pos + 7);
    const auto token_start = pos;
    while (pos < str.size() && str[pos] != ')' &&
           !std::isspace(static_cast<unsigned char>(str[pos]))) { ++pos; }
    const std::string_view token(str.data() + token_start, pos - token_start);
    pos = skip_ws(str, pos);
    if (pos == str.size() || str[pos] != ')') {
        pos = start;
        return nullptr;
    }
    ++pos; /**< 消耗原子的结束分隔符，保留区间的分隔符。 */
    auto value = detail::parse_finite_decimal(token);
    if (!value) {
        pos = start;
        return nullptr;
    }
    return SymbolicExpr::number(value.value());
}

引用了 parse_approximate_atom(), LMCAS::detail::parse_finite_decimal(), skip_ws() , 以及 value.

被这些函数引用 parse_approximate_atom() , 以及 parse_numeric_value().

函数调用图:

这是这个函数的调用关系图:

parse_endpoint_value()

bool LMCAS::parse_endpoint_value ( const std::string & str, size_t & pos, Endpoint & ep )

static

在文件 interval_serialization.cpp 第 170 行定义.

                                                                                  {
    pos = skip_ws(str, pos);
 
    if (starts_with_at(str, pos, "-\xe2\x88\x9e")) {
        ep.is_neg_infinity = true;
        ep.is_pos_infinity = false;
        ep.is_open = true;
        ep.value = nullptr;
        pos += 4;
        return true;
    }
 
    if (starts_with_at(str, pos, "+\xe2\x88\x9e")) {
        ep.is_pos_infinity = true;
        ep.is_neg_infinity = false;
        ep.is_open = true;
        ep.value = nullptr;
        pos += 4;
        return true;
    }
 
    auto val = parse_numeric_value(str, pos);
    if (!val) {
        return false;
    }
 
    ep.value = val;
    ep.is_neg_infinity = false;
    ep.is_pos_infinity = false;
 
    return true;
}

引用了 parse_endpoint_value(), parse_numeric_value(), skip_ws() , 以及 starts_with_at().

被这些函数引用 parse_endpoint_value(), parse_interval_lower() , 以及 parse_interval_upper().

函数调用图:

这是这个函数的调用关系图:

parse_expr() [1/2]

ExprResult LMCAS::parse_expr

(

const std::string &

source

)

在文件 expr_parsing.cpp 第 424 行定义.

                                               {
    ComputationContext context;
    return parse_expr(source, context);
}

引用了 context , 以及 parse_expr().

被这些函数引用 parse_expr(), parse_expr() , 以及 LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_general_expression().

函数调用图:

这是这个函数的调用关系图:

parse_expr() [2/2]

ExprResult LMCAS::parse_expr	(	const std::string &	source,
		ComputationContext &	context )

在文件 expr_parsing.cpp 第 429 行定义.

                                                   {
    auto input_budget =
        context.require_input_bytes(source.size(), kParseOperation);
    if (!input_budget) {
        return ExprResult::failure(input_budget.error());
    }
    try {
        return ExprParser(source).parse();
    } catch (const std::bad_alloc&) {
        return expr_detail::expr_common::expression_failure(CasErrc::ResourceLimit,
                                  "expression parse allocation failed",
                                  kParseOperation);
    } catch (const std::exception& error) {
        return expr_detail::expr_common::expression_failure(
            CasErrc::InternalInvariant, error.what(), kParseOperation);
    }
}

引用了 LMCAS::ExprParser::ExprParser(), context, LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::Result< ExprPtr >::failure(), InternalInvariant, kParseOperation, parse_expr() , 以及 ResourceLimit.

函数调用图:

parse_fraction()

std::shared_ptr< SymbolicExpr > LMCAS::parse_fraction ( const std::string & str, size_t start, size_t & pos )

static

在文件 interval_serialization.cpp 第 89 行定义.

                                                     {
    const size_t slash = pos++;
    const size_t denominator_start = pos;
    if (!consume_digits(str, pos)) {
        pos = start;
        return nullptr;
    }
    const BigInt numerator(str.substr(start, slash - start));
    const BigInt denominator(str.substr(denominator_start, pos - denominator_start));
    if (denominator.is_zero()) {
        pos = start;
        return nullptr;
    }
    return SymbolicExpr::number(Rational(numerator, denominator));
}

引用了 consume_digits(), denominator , 以及 parse_fraction().

被这些函数引用 parse_fraction() , 以及 parse_numeric_value().

函数调用图:

这是这个函数的调用关系图:

parse_interval_lower()

bool LMCAS::parse_interval_lower ( const std::string & str, size_t & pos, Endpoint & lower )

static

在文件 interval_serialization.cpp 第 203 行定义.

                                                        {
    pos = skip_ws(str, pos);
    if (pos >= str.size()) {
        return false;
    }
    const char bracket = str[pos];
    if (bracket != '(' && bracket != '[') {
        return false;
    }
    const bool open = bracket == '(';
    ++pos;
    if (!parse_endpoint_value(str, pos, lower)) {
        return false;
    }
    if (lower.is_pos_infinity || (lower.is_neg_infinity && !open)) {
        return false;
    }
    if (!lower.is_neg_infinity) lower.is_open = open;
    return true;
}

引用了 lower, parse_endpoint_value(), parse_interval_lower() , 以及 skip_ws().

被这些函数引用 parse_interval_lower() , 以及 parse_single_interval().

函数调用图:

这是这个函数的调用关系图:

parse_interval_upper()

bool LMCAS::parse_interval_upper ( const std::string & str, size_t & pos, Endpoint & upper )

static

在文件 interval_serialization.cpp 第 225 行定义.

                                                        {
    if (!parse_endpoint_value(str, pos, upper)) {
        return false;
    }
    pos = skip_ws(str, pos);
    if (pos >= str.size()) {
        return false;
    }
    const char bracket = str[pos];
    if (bracket != ')' && bracket != ']') {
        return false;
    }
    const bool open = bracket == ')';
    ++pos;
    if (upper.is_neg_infinity || (upper.is_pos_infinity && !open)) {
        return false;
    }
    if (!upper.is_pos_infinity) upper.is_open = open;
    return true;
}

引用了 parse_endpoint_value(), parse_interval_upper(), skip_ws() , 以及 upper.

被这些函数引用 parse_interval_upper() , 以及 parse_single_interval().

函数调用图:

这是这个函数的调用关系图:

parse_numeric_value()

std::shared_ptr< SymbolicExpr > LMCAS::parse_numeric_value ( const std::string & str, size_t & pos )

static

在文件 interval_serialization.cpp 第 137 行定义.

                                       {
    const size_t start = pos;
    if (starts_with_at(str, pos, "approx(")) {
        return parse_approximate_atom(str, pos);
    }
    consume_sign(str, pos);
    bool has_digit = consume_digits(str, pos);
    if (has_digit && pos < str.size() && str[pos] == '/') {
        return parse_fraction(str, start, pos);
    }
    bool decimal = false;
    if (pos < str.size() && str[pos] == '.') {
        decimal = true;
        ++pos;
        has_digit = consume_digits(str, pos) || has_digit;
    }
    if (!has_digit) {
        pos = start;
        return nullptr;
    }
    if (pos < str.size() && (str[pos] == 'e' || str[pos] == 'E')) {
        decimal = true;
        ++pos;
        consume_sign(str, pos);
        if (!consume_digits(str, pos)) {
            pos = start;
            return nullptr;
        }
    }
    return numeric_token_value(str, start, pos, decimal);
}

引用了 consume_digits(), consume_sign(), numeric_token_value(), parse_approximate_atom(), parse_fraction(), parse_numeric_value() , 以及 starts_with_at().

被这些函数引用 parse_endpoint_value() , 以及 parse_numeric_value().

函数调用图:

这是这个函数的调用关系图:

parse_single_interval()

bool LMCAS::parse_single_interval ( const std::string & str, size_t & pos, Interval & iv )

static

在文件 interval_serialization.cpp 第 247 行定义.

                                                     {
    Endpoint lower;
    if (!parse_interval_lower(str, pos, lower)) {
        return false;
    }
    pos = skip_ws(str, pos);
    if (pos >= str.size() || str[pos] != ',') {
        return false;
    }
    ++pos;
    Endpoint upper;
    if (!parse_interval_upper(str, pos, upper)) {
        return false;
    }
    iv.lower = std::move(lower);
    iv.upper = std::move(upper);
    return true;
}

引用了 lower, parse_interval_lower(), parse_interval_upper(), parse_single_interval(), skip_ws() , 以及 upper.

被这些函数引用 parse_single_interval().

函数调用图:

这是这个函数的调用关系图:

phi()

ExprResult LMCAS::phi

(

)

在文件 expr_values.cpp 第 116 行定义.

                 {
    return detail::constant_expression("phi");
}

引用了 LMCAS::detail::constant_expression() , 以及 phi().

被这些函数引用 LMCAS::expr_detail::ExprParser::parse_identifier_or_call() , 以及 phi().

函数调用图:

这是这个函数的调用关系图:

pi()

ExprResult LMCAS::pi

(

)

在文件 expr_values.cpp 第 108 行定义.

                {
    return detail::constant_expression("pi");
}

引用了 LMCAS::detail::constant_expression() , 以及 pi().

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_endpoint(), LMCAS::detail::anonymous_namespace{exact_constant_bounds.cpp}::atan_bounds(), collect_gcd_samples(), dihedral_angle_checked(), inverse_fourier_transform_core(), LMCAS::expr_detail::ExprParser::parse_identifier_or_call(), pi(), prepare_fourier_period(), solve_complex_nth_root_checked(), LMCAS::anonymous_namespace{differentiation_functions.cpp}::special_outer(), te_gaussian_fourier(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_principal_value() , 以及 LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl().

函数调用图:

这是这个函数的调用关系图:

plane_from_three_points_checked() [1/2]

PlaneSymbolicResult LMCAS::plane_from_three_points_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	p1,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p2,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p3 )

在文件 symbolic_geometry_plane.cpp 第 271 行定义.

                                                      {
    ComputationContext context;
    return plane_from_three_points_checked(p1, p2, p3, context);
}

引用了 context, p2 , 以及 plane_from_three_points_checked().

函数调用图:

plane_from_three_points_checked() [2/2]

PlaneSymbolicResult LMCAS::plane_from_three_points_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	p1,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p2,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p3,
		ComputationContext &	context )

在文件 symbolic_geometry_plane.cpp 第 215 行定义.

                                 {
    const std::string operation = "plane_from_three_points";
    try {
        auto v12 = validate_same_dimension_vectors(p1, p2, context, operation);
        if (!v12) {
            return PlaneSymbolicResult::failure(v12.error());
        }
        auto v13 = validate_same_dimension_vectors(p1, p3, context, operation);
        if (!v13) {
            return PlaneSymbolicResult::failure(v13.error());
        }
        if (p1.size() != 3) {
            return PlaneSymbolicResult::failure(
                CasErrc::InvalidArgument,
                "plane construction requires 3-dimensional points",
                operation);
        }
        auto step = context.consume_steps(8, operation);
        if (!step) {
            return PlaneSymbolicResult::failure(step.error());
        }
 
        std::vector<std::shared_ptr<SymbolicExpr>> v1, v2;
        auto edges = build_plane_edges(p1, p2, p3, v1, v2, context, operation);
        if (!edges) {
            return PlaneSymbolicResult::failure(edges.error());
        }
        auto numeric_edges = scale_plane_edges_for_cross(v1, v2, context, operation);
        if (!numeric_edges) {
            return PlaneSymbolicResult::failure(numeric_edges.error());
        }
 
        auto normal = vector_cross_checked(v1, v2, context);
        if (!normal) {
            return PlaneSymbolicResult::failure(normal.error());
        }
        auto nonzero = check_plane_normal_nonzero(
            normal.value(), numeric_edges.value(), context, operation);
        if (!nonzero) {
            return PlaneSymbolicResult::failure(nonzero.error());
        }
        return assemble_plane(std::move(normal.value()), p1, context, operation);
    } catch (const std::bad_alloc&) {
        return PlaneSymbolicResult::failure(CasErrc::ResourceLimit,
                                            "vector geometry allocation failed",
                                            operation);
    } catch (const std::exception& e) {
        return PlaneSymbolicResult::failure(CasErrc::InternalInvariant,
                                            e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< PlaneSymbolic >::failure(), InternalInvariant, InvalidArgument, p2, plane_from_three_points_checked(), ResourceLimit, LMCAS::geometry_detail::validate_same_dimension_vectors() , 以及 vector_cross_checked().

被这些函数引用 plane_from_three_points_checked() , 以及 plane_from_three_points_checked().

函数调用图:

这是这个函数的调用关系图:

plane_general()

PlaneSymbolic LMCAS::plane_general ( std::shared_ptr< SymbolicExpr > a, std::shared_ptr< SymbolicExpr > b, std::shared_ptr< SymbolicExpr > c, std::shared_ptr< SymbolicExpr > d )

inline

由一般方程系数构造平面 ax + by + cz = d。

参数

a	x 方向法向量分量
b	y 方向法向量分量
c	z 方向法向量分量
d	常数项

返回

构造的 PlaneSymbolic 对象

在文件 symbolic_geometry_line_plane.hpp 第 30 行定义.

  {
    return PlaneSymbolic{{a, b, c}, d};
}

引用了 a, b, c , 以及 plane_general().

被这些函数引用 plane_general().

函数调用图:

这是这个函数的调用关系图:

point_plane_distance_checked() [1/2]

ExpressionResult LMCAS::point_plane_distance_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	point,
		const PlaneSymbolic &	plane )

在文件 symbolic_geometry_line_plane.cpp 第 366 行定义.

  {
    ComputationContext context;
    return point_plane_distance_checked(point, plane, context);
}

引用了 context, plane, point , 以及 point_plane_distance_checked().

函数调用图:

point_plane_distance_checked() [2/2]

ExpressionResult LMCAS::point_plane_distance_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	point,
		const PlaneSymbolic &	plane,
		ComputationContext &	context )

在文件 symbolic_geometry_line_plane.cpp 第 303 行定义.

  {
    const std::string operation = "point_plane_distance";
    try {
        auto plane_valid = validate_plane_checked(plane, context, operation);
        if (!plane_valid) return ExpressionResult::failure(plane_valid.error());
        if (point.size() != 3) {
            return ExpressionResult::failure(
                CasErrc::InvalidArgument,
                "point-plane distance requires a 3-dimensional point",
                operation);
        }
        auto point_valid = validate_symbolic_vector(point, "point", operation);
        if (!point_valid) return ExpressionResult::failure(point_valid.error());
        auto step = context.consume_steps(4, operation);
        if (!step) return ExpressionResult::failure(step.error());
 
        std::vector<double> normal_values;
        auto normal_scale = numeric_vector_scale_checked(
            plane.normal, context, operation, &normal_values);
        if (!normal_scale) {
            return ExpressionResult::failure(normal_scale.error());
        }
        auto point_scale = numeric_vector_scale_checked(
            point, context, operation);
        if (!point_scale && interrupts_optional_numeric_evaluation(point_scale.error())) {
            return ExpressionResult::failure(point_scale.error());
        }
 
        const double safe_low =
            std::sqrt(std::numeric_limits<double>::min());
        const double safe_high =
            std::sqrt(std::numeric_limits<double>::max() / 3.0);
        const bool protect_point_dot =
            point_dot_needs_protection(normal_scale.value(), point_scale);
        const std::vector<std::shared_ptr<SymbolicExpr>>* effective_normal =
            &plane.normal;
        std::vector<std::shared_ptr<SymbolicExpr>> scaled_normal;
        std::shared_ptr<SymbolicExpr> effective_d = plane.d;
        if (normal_scale.value() < safe_low ||
            normal_scale.value() > safe_high ||
            protect_point_dot) {
            scale_symbolic_components(
                normal_values, normal_scale.value(), protect_point_dot, scaled_normal);
            effective_normal = &scaled_normal;
            effective_d = scale_plane_offset(plane.d, normal_scale.value(), protect_point_dot);
        }
 
        return symbolic_point_plane_distance(
            point, *effective_normal, effective_d, context, operation);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                         "vector geometry allocation failed",
                                         operation);
    } catch (const std::exception& e) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                         e.what(), operation);
    }
}

引用了 context, LMCAS::PlaneSymbolic::d, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, InvalidArgument, LMCAS::PlaneSymbolic::normal, LMCAS::geometry_detail::numeric_vector_scale_checked(), plane, point, point_plane_distance_checked(), ResourceLimit, LMCAS::geometry_detail::validate_plane_checked() , 以及 LMCAS::geometry_detail::validate_symbolic_vector().

被这些函数引用 point_plane_distance_checked() , 以及 point_plane_distance_checked().

函数调用图:

这是这个函数的调用关系图:

polynomial_logic()

ExprPtr LMCAS::polynomial_logic ( const ExprPtr & left, const ExprPtr & right, LogicalNode::Op op )

static

在文件 solve_visitor.cpp 第 67 行定义.

                                                                 {
    return detail::make_expression_ptr(
        detail::make_node<LogicalNode>(
            detail::node(left), detail::node(right), op));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), op, polynomial_logic() , 以及 right.

被这些函数引用 conditional_linear_polynomial() , 以及 polynomial_logic().

函数调用图:

这是这个函数的调用关系图:

polynomial_product_fits()

template<typename T>

bool LMCAS::polynomial_product_fits	(	const Polynomial< T > &	left,
		const Polynomial< T > &	right )

在文件 poly_utils.cpp 第 116 行定义.

                                                                                    {
    if (left.is_zero() || right.is_zero()) return true;
    const auto max_terms = static_cast<std::size_t>(std::numeric_limits<int>::max());
    return left.coeffs.size() <= max_terms &&
        right.coeffs.size() - 1 <= max_terms - left.coeffs.size();
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, LMCAS::Polynomial< CoeffType >::is_zero(), polynomial_product_fits() , 以及 right.

被这些函数引用 polynomial_product_fits(), symbolic_power_to_poly() , 以及 symbolic_product_to_poly().

函数调用图:

这是这个函数的调用关系图:

polynomial_relation()

ExprPtr LMCAS::polynomial_relation ( const ExprPtr & left, const ExprPtr & right, RelationOp op )

static

在文件 solve_visitor.cpp 第 60 行定义.

                                                              {
    return detail::make_expression_ptr(
        detail::make_node<RelationalNode>(
            detail::node(left), detail::node(right), op));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), op, polynomial_relation() , 以及 right.

被这些函数引用 conditional_linear_polynomial(), polynomial_relation() , 以及 solve_symbolic_quadratic().

函数调用图:

这是这个函数的调用关系图:

positive_divisors()

std::vector< BigInt > LMCAS::positive_divisors ( const BigInt & n )

static

在文件 rational_polynomial.cpp 第 7 行定义.

                                                            {
    std::vector<BigInt> divs;
    if (n.is_zero()) {
 
        return divs;
    }
    BigInt abs_n = n.abs();
 
    BigInt i(1);
 
    while (i * i <= abs_n) {
        BigInt rem = abs_n % i;
        if (rem.is_zero()) {
            divs.push_back(i);
            BigInt counterpart = abs_n / i;
            if (counterpart != i) {
                divs.push_back(counterpart);
            }
        }
        i = i + BigInt(1);
    }
 
    std::sort(divs.begin(), divs.end());
    return divs;
}

引用了 positive_divisors().

被这些函数引用 positive_divisors() , 以及 rational_root_candidate().

函数调用图:

这是这个函数的调用关系图:

pow() [1/2]

ExprResult LMCAS::pow	(	const ExprPtr &	base,
		const ExprPtr &	exponent )

在文件 expr_elementary.cpp 第 33 行定义.

                                                             {
    ComputationContext context;
    return pow(base, exponent, context);
}

引用了 context, exponent , 以及 pow().

函数调用图:

pow() [2/2]

ExprResult LMCAS::pow	(	const ExprPtr &	base,
		const ExprPtr &	exponent,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 27 行定义.

                                            {
    return quantity_power(base, exponent, context);
}

引用了 context, exponent, pow() , 以及 quantity_power().

被这些函数引用 LMCAS::solver_detail::collect_denominator_factors(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::collect_transcendental_subexprs(), 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::anonymous_namespace{mixed_transcendental_classification.cpp}::degree_in_var(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::has_exp_k_var_terms(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::is_poly_expr_node(), LMCAS::solver_detail::is_polynomial_node(), LMCAS::solver_detail::multiply_no_expand(), LMCAS::expr_detail::ExprParser::parse_power(), pow(), pow(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::SubstNodeVisitor::replace(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::rewrite_exp_as_u_power(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::structural(), symbolic_node_to_multipoly(), tf_collect_transcendental(), tf_contains_transcendental(), tf_is_trig_squared(), tf_simplify_pythagorean_node() , 以及 tf_substitute_expr().

函数调用图:

这是这个函数的调用关系图:

power_series_add()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::power_series_add	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b )

在文件 series_engine.cpp 第 164 行定义.

                                                     {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    size_t len = std::max(a.size(), b.size());
    std::vector<std::shared_ptr<SymbolicExpr>> result(len);
    for (size_t i = 0; i < len; ++i) {
        auto ai = (i < a.size() && a[i]) ? a[i] : SymbolicExpr::number(0);
        auto bi = (i < b.size() && b[i]) ? b[i] : SymbolicExpr::number(0);
        result[i] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(ai, bi)), transform_budget));
    }
    return result;
}

引用了 a, b, context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 power_series_add().

被这些函数引用 power_series_add().

函数调用图:

这是这个函数的调用关系图:

power_series_compose_checked() [1/2]

PowerSeriesResult LMCAS::power_series_compose_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	g,
		int	order )

在文件 series_engine.cpp 第 326 行定义.

                                                                {
    ComputationContext context;
    return power_series_compose_checked(f, g, order, context);
}

引用了 context, order , 以及 power_series_compose_checked().

函数调用图:

power_series_compose_checked() [2/2]

PowerSeriesResult LMCAS::power_series_compose_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	f,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	g,
		int	order,
		ComputationContext &	context )

在文件 series_engine.cpp 第 270 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "power_series_compose";
    auto order_check = validate_power_series_order(order, context, operation);
    if (!order_check) {
        return PowerSeriesResult::failure(order_check.error());
    }
    auto f_check = validate_power_series_coefficients(f, operation, "outer series");
    if (!f_check) {
        return PowerSeriesResult::failure(f_check.error());
    }
    auto g_check = validate_power_series_coefficients(g, operation, "inner series");
    if (!g_check) {
        return PowerSeriesResult::failure(g_check.error());
    }
 
    size_t n = static_cast<size_t>(order);
    if (!g.empty() && !g[0]->is_zero()) {
        return PowerSeriesResult::failure(
            CasErrc::DomainError,
            "power series composition around zero requires g(0) = 0",
            operation);
    }
    std::vector<std::shared_ptr<SymbolicExpr>> result(n, SymbolicExpr::number(0));
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> gp(n);
    auto powers = composition_inner_powers(g, gp, order, context, operation);
    if (!powers) {
        return PowerSeriesResult::failure(powers.error());
    }
    for (size_t k = 0; k < std::min(f.size(), n); ++k) {
        auto step = context.consume_steps(1, operation);
        if (!step) {
            return PowerSeriesResult::failure(step.error());
        }
        auto fk = f[k] ? f[k] : SymbolicExpr::number(0);
        if (fk->is_zero()) {
            continue;
        }
        for (size_t i = 0; i < n && i < gp[k].size(); ++i)
            result[i] = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(result[i], SymbolicExpr::multiply(fk, gp[k][i]))), transform_budget));
    }
    return PowerSeriesResult::success(std::move(result));
} catch (const CasError& error) {
    return PowerSeriesResult::failure(error);
} catch (const std::bad_alloc&) {
    return PowerSeriesResult::failure(CasErrc::ResourceLimit, "allocation failed", "power_series_compose");
} catch (const std::length_error& error) {
    return PowerSeriesResult::failure(CasErrc::ResourceLimit, error.what(), "power_series_compose");
} catch (const std::exception& error) {
    return PowerSeriesResult::failure(CasErrc::InternalInvariant, error.what(), "power_series_compose");
}

引用了 composition_inner_powers(), context, DomainError, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), order, power_series_compose_checked(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 validate_power_series_coefficients().

被这些函数引用 power_series_compose_checked() , 以及 power_series_compose_checked().

函数调用图:

这是这个函数的调用关系图:

power_series_multiply_checked() [1/2]

PowerSeriesResult LMCAS::power_series_multiply_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b,
		int	order )

在文件 series_engine.cpp 第 235 行定义.

                                                                {
    ComputationContext context;
    return power_series_multiply_checked(a, b, order, context);
}

引用了 a, b, context, order , 以及 power_series_multiply_checked().

函数调用图:

power_series_multiply_checked() [2/2]

PowerSeriesResult LMCAS::power_series_multiply_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b,
		int	order,
		ComputationContext &	context )

在文件 series_engine.cpp 第 180 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "power_series_multiply";
    auto order_check = validate_power_series_order(order, context, operation);
    if (!order_check) {
        return PowerSeriesResult::failure(order_check.error());
    }
    auto a_check = validate_power_series_coefficients(a, operation, "left series");
    if (!a_check) {
        return PowerSeriesResult::failure(a_check.error());
    }
    auto b_check = validate_power_series_coefficients(b, operation, "right series");
    if (!b_check) {
        return PowerSeriesResult::failure(b_check.error());
    }
 
    size_t n = static_cast<size_t>(order);
    std::vector<std::shared_ptr<SymbolicExpr>> result(n, SymbolicExpr::number(0));
    for (size_t k = 0; k < n; ++k) {
        auto step = context.consume_steps(1, operation);
        if (!step) {
            return PowerSeriesResult::failure(step.error());
        }
        std::vector<std::shared_ptr<const SymbolicNode>> terms;
        for (size_t j = 0; j <= k; ++j) {
            if (j >= a.size() || (k-j) >= b.size()) {
                continue;
            }
            auto aj = a[j] ? a[j] : SymbolicExpr::number(0);
            auto bkj = b[k-j] ? b[k-j] : SymbolicExpr::number(0);
            terms.push_back(LMCAS::detail::node(SymbolicExpr::multiply(aj, bkj)));
        }
        if (terms.empty()) {
            result[k] = SymbolicExpr::number(0);
        } else if (terms.size() == 1) {
            result[k] = detail::make_expression_ptr(detail::normalize_node(terms[0], transform_budget));
        } else {
            result[k] = detail::make_expression_ptr(detail::normalize_node(LMCAS::detail::make_node<AddNode>(terms), transform_budget));
        }
    }
    return PowerSeriesResult::success(std::move(result));
} catch (const CasError& error) {
    return PowerSeriesResult::failure(error);
} catch (const std::bad_alloc&) {
    return PowerSeriesResult::failure(CasErrc::ResourceLimit, "allocation failed", "power_series_multiply");
} catch (const std::length_error& error) {
    return PowerSeriesResult::failure(CasErrc::ResourceLimit, error.what(), "power_series_multiply");
} catch (const std::exception& error) {
    return PowerSeriesResult::failure(CasErrc::InternalInvariant, error.what(), "power_series_multiply");
}

引用了 a, b, context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), order, power_series_multiply_checked(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 validate_power_series_coefficients().

被这些函数引用 composition_inner_powers(), power_series_multiply_checked() , 以及 power_series_multiply_checked().

函数调用图:

这是这个函数的调用关系图:

power_term_convergence()

std::optional< ConvergenceInfo > LMCAS::power_term_convergence ( const std::shared_ptr< const SymbolicNode > & node, const std::string & index_var )

static

在文件 series_convergence.cpp 第 283 行定义.

                                {
    auto power = std::dynamic_pointer_cast<const PowerNode>(node);
    if (!power) {
        return std::nullopt;
    }
    auto base_var = std::dynamic_pointer_cast<const VariableNode>(power->base());
    auto exponent = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
    if (!base_var || base_var->is_constant() || base_var->name() != index_var || !exponent) {
        return std::nullopt;
    }
 
    bool below_negative_one = false;
    bool at_or_above_negative_one = false;
    if (const auto* integer = std::get_if<BigInt>(&exponent->value())) {
        below_negative_one = *integer < BigInt(-1);
        at_or_above_negative_one = !below_negative_one;
    } else if (const auto* rational = std::get_if<Rational>(&exponent->value())) {
        below_negative_one = *rational < Rational(-1);
        at_or_above_negative_one = !below_negative_one;
    }
    if (below_negative_one) {
        return ConvergenceInfo{
            ConvergenceResult::Convergent, "p-series"};
    }
    if (at_or_above_negative_one) {
        return ConvergenceInfo{
            ConvergenceResult::Divergent, "p-series"};
    }
    return std::nullopt;
}

引用了 Convergent, Divergent, exponent, integer, power_term_convergence() , 以及 rational().

被这些函数引用 convergence_test_impl() , 以及 power_term_convergence().

函数调用图:

这是这个函数的调用关系图:

prepare_fourier_period()

Result< FourierPeriod > LMCAS::prepare_fourier_period ( const std::shared_ptr< SymbolicExpr > & period, const std::string & var, ComputationContext & context )

static

在文件 series_expansions.cpp 第 203 行定义.

                                 {
    auto T = period;
    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 positive_period = detail::query_positive_value(detail::node(T), facts, context);
    if (!positive_period) { return Result<FourierPeriod>::failure(positive_period.error()); }
    if (expression_depends_on_variable(detail::node(T), var) ||
        positive_period.value() != Tribool::True) {
        return Result<FourierPeriod>::failure(
            positive_period.value() == Tribool::False ? CasErrc::InvalidArgument : CasErrc::Inconclusive,
            "Fourier period must be a proved positive constant", "fourier_series");
    }
    auto pi = LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<VariableNode>("pi", true));
    auto two = SymbolicExpr::number(2);
    auto L = SymbolicExpr::divide(T, two);
    auto half_lo = SymbolicExpr::multiply(SymbolicExpr::number(-1), L);
    auto half_hi = L;
    auto w = SymbolicExpr::divide(SymbolicExpr::multiply(two, pi), T);
    return FourierPeriod{std::move(two), std::move(L), std::move(half_lo),
        std::move(half_hi), std::move(w)};
}

引用了 context, expression_depends_on_variable(), LMCAS::Result< T >::failure(), False, Inconclusive, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::no_facts(), LMCAS::detail::node(), pi(), prepare_fourier_period(), LMCAS::detail::query_positive_value() , 以及 True.

被这些函数引用 fourier_series_checked() , 以及 prepare_fourier_period().

函数调用图:

这是这个函数的调用关系图:

product_without_factor()

std::shared_ptr< SymbolicExpr > LMCAS::product_without_factor ( const MultiplyNode & product, size_t omitted )

static

在文件 series_sequence_limits.cpp 第 29 行定义.

                                                 {
    std::vector<std::shared_ptr<const SymbolicNode>> rest;
    for (size_t j = 0; j < product.operands().size(); ++j) {
        if (j != omitted) {
            rest.push_back(product.operands()[j]);
        }
    }
    if (rest.empty()) {
        return SymbolicExpr::number(1);
    }
    if (rest.size() == 1) {
        return detail::make_expression_ptr(rest[0]);
    }
    return detail::make_expression_ptr(detail::make_node<MultiplyNode>(rest));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::MultiplyNode::operands() , 以及 product_without_factor().

被这些函数引用 product_without_factor() , 以及 series_extract_alternating().

函数调用图:

这是这个函数的调用关系图:

project_finite_expr_set()

ExprSetResult LMCAS::project_finite_expr_set ( const ExprPtr & original, const std::string & variable, ComputationContext & context, const SolveOptions & options )

static

在文件 expr_solving.cpp 第 33 行定义.

                                                                     {
    auto solved = solve_set(original, variable, context, options);
    if (!solved) {
        return ExprSetResult::failure(solved.error());
    }
 
    const auto& solution_set = solved.value();
    if (std::holds_alternative<EmptySolutions>(solution_set)) {
        return expr_set({});
    }
    const auto* finite = std::get_if<FiniteSolutions>(&solution_set);
    if (!finite) {
        return expr_set_failure(
            CasErrc::Inconclusive,
            "solution set is not a finite enumerable set<Expr>",
            kSolveExprSetOperation);
    }
 
    std::vector<ExprPtr> elements;
    elements.reserve(finite->values.size());
    for (const auto& solution : finite->values) {
        if (!solution.conditions.empty()) {
            return expr_set_failure(CasErrc::Inconclusive,
                                    "conditional finite solutions cannot be lowered to set<Expr>",
                                    kSolveExprSetOperation);
        }
        elements.push_back(solution.value);
    }
    return expr_set(std::move(elements));
}

引用了 context, expr_set(), expr_set_failure(), LMCAS::Result< ExprSet >::failure(), Inconclusive, kSolveExprSetOperation, options, project_finite_expr_set(), solve_set() , 以及 variable.

被这些函数引用 project_finite_expr_set(), roots() , 以及 solve_expr_set().

函数调用图:

这是这个函数的调用关系图:

qr_decomposition_checked() [1/2]

QRDecompositionResult LMCAS::qr_decomposition_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 matrix_decomposition_qr.cpp 第 141 行定义.

{
    ComputationContext context;
    return qr_decomposition_checked(A, context);
}

引用了 context , 以及 qr_decomposition_checked().

函数调用图:

qr_decomposition_checked() [2/2]

QRDecompositionResult LMCAS::qr_decomposition_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

在文件 matrix_decomposition_qr.cpp 第 103 行定义.

{
    const std::string operation = "qr_decomposition";
    auto matrix = validate_decomposition_matrix(A, false, context, operation);
    if (!matrix) return QRDecompositionResult::failure(matrix.error());
    auto budget = context.consume_steps(matrix.value()->rows() * matrix.value()->cols() * 12 + 8,
                                        operation);
    if (!budget) return QRDecompositionResult::failure(budget.error());
    auto full_rank = prove_exact_full_column_rank_qr_support(
        matrix.value(), context, operation);
    if (!full_rank) return QRDecompositionResult::failure(full_rank.error());
    try {
        std::shared_ptr<SymbolicExpr> Q;
        std::shared_ptr<SymbolicExpr> R;
        if (!qr_decomposition_impl(A, Q, R)) {
            return QRDecompositionResult::failure(
                CasErrc::Inconclusive,
                "QR decomposition could not be constructed in the supported symbolic domain",
                operation);
        }
        auto q_check = validate_decomposition_output(Q, "Q", operation);
        if (!q_check) return QRDecompositionResult::failure(q_check.error());
        auto r_check = validate_decomposition_output(R, "R", operation);
        if (!r_check) return QRDecompositionResult::failure(r_check.error());
        return QRDecompositionResult::success(QRDecomposition{Q, R});
    } catch (const std::bad_alloc&) {
        return QRDecompositionResult::failure(CasErrc::ResourceLimit,
                                             "allocation failed while calculating QR decomposition",
                                             operation);
    } catch (const std::exception& ex) {
        return QRDecompositionResult::failure(CasErrc::InternalInvariant,
                                             ex.what(),
                                             operation);
    }
}

引用了 context, LMCAS::Result< QRDecomposition >::failure(), Inconclusive, InternalInvariant, qr_decomposition_checked(), ResourceLimit, LMCAS::Result< QRDecomposition >::success(), LMCAS::detail::matrix_decomposition::validate_decomposition_matrix() , 以及 LMCAS::detail::matrix_decomposition::validate_decomposition_output().

被这些函数引用 qr_decomposition_checked() , 以及 qr_decomposition_checked().

函数调用图:

这是这个函数的调用关系图:

quadratic_form_matrix()

std::shared_ptr< SymbolicExpr > LMCAS::quadratic_form_matrix	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::vector< std::string > &	vars )

在文件 matrix_quadratic_form.cpp 第 120 行定义.

                                      {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expr || !valid_variables(vars)) {
        return nullptr;
    }
 
    try {
        auto expanded = detail::make_expression_ptr(detail::expand_node(detail::node(expr), transform_budget));
        if (!expanded) {
            return nullptr;
        }
        auto variables = make_variables(vars);
        auto matrix = quadratic_coefficients(expanded, vars, context);
        if (!matrix ||
            !reconstructs_expression(expanded, *matrix, variables, context)) {
            return nullptr;
        }
        return SymbolicExpr::matrix(*matrix);
    } catch (const CasError& error) {
        if (error.code != CasErrc::UnsupportedExpression) throw;
        return nullptr;
    }
}

引用了 LMCAS::CasError::code, context, LMCAS::detail::expand_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), quadratic_form_matrix(), UnsupportedExpression , 以及 vars.

被这些函数引用 quadratic_form_matrix().

函数调用图:

这是这个函数的调用关系图:

quadrature_gaussian_numeric() [1/2]

Result< QuadratureEstimate > LMCAS::quadrature_gaussian_numeric	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		int	order )

在文件 numerical_integration.cpp 第 234 行定义.

               {
    constexpr const char* operation = "quadrature_gaussian";
    auto valid = validate_quadrature_args(
        function, variable, lower, upper, operation);
    if (!valid) return Result<QuadratureEstimate>::failure(valid.error());
    if (order < 1 || order > 20) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::InvalidArgument,
            "Gaussian quadrature order must be in [1, 20]",
            operation);
    }
    auto interval = evaluate_interval(lower, upper, context, operation);
    if (!interval) return Result<QuadratureEstimate>::failure(interval.error());
    if (interval.value().lower == interval.value().upper) {
        return Result<QuadratureEstimate>::success(zero_quadrature_result());
    }
    const int comparison_order = order == 20 ? 19 : order + 1;
    auto budget = context.consume_steps(
        static_cast<std::size_t>(order + comparison_order + 2), operation);
    if (!budget) return Result<QuadratureEstimate>::failure(budget.error());
 
    detail::ensure_lmmc_lifecycle();
    QuadratureCallback callback{
        &function, &variable, &context, operation, std::nullopt};
    double value = 0.0;
    auto status = lmmc_quad_gauss_legendre(
        evaluate_quadrature_callback, &callback,
        interval.value().lower, interval.value().upper,
        static_cast<std::size_t>(order), &value);
    if (callback.error) return Result<QuadratureEstimate>::failure(*callback.error);
    if (status != LMMC_STATUS_OK) {
        return quadrature_failure<QuadratureEstimate>(status, operation);
    }
 
    double comparison_value = 0.0;
    status = lmmc_quad_gauss_legendre(
        evaluate_quadrature_callback, &callback,
        interval.value().lower, interval.value().upper,
        static_cast<std::size_t>(comparison_order), &comparison_value);
    if (callback.error) return Result<QuadratureEstimate>::failure(*callback.error);
    if (status != LMMC_STATUS_OK) {
        return quadrature_failure<QuadratureEstimate>(status, operation);
    }
    return estimated_quadrature_result(
        value, std::abs(comparison_value - value),
        interval.value().sign, operation);
}

引用了 LMCAS::expr_detail::expr_common::comparison_value(), context, LMCAS::detail::ensure_lmmc_lifecycle(), LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), function(), interval(), InvalidArgument, lower, order, quadrature_gaussian_numeric(), LMCAS::Result< T >::success(), upper, LMCAS::Result< T >::value(), value , 以及 variable.

被这些函数引用 quadrature_gaussian_numeric() , 以及 quadrature_gaussian_numeric().

函数调用图:

这是这个函数的调用关系图:

quadrature_gaussian_numeric() [2/2]

Result< QuadratureEstimate > LMCAS::quadrature_gaussian_numeric	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		int	order )

在文件 numerical_integration.cpp 第 288 行定义.

               {
    ComputationContext context;
    return quadrature_gaussian_numeric(
        function, variable, lower, upper, context, order);
}

引用了 context, function(), lower, order, quadrature_gaussian_numeric(), upper , 以及 variable.

函数调用图:

quadrature_simpson_numeric() [1/2]

Result< QuadratureEstimate > LMCAS::quadrature_simpson_numeric	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		int	subdivisions )

在文件 numerical_integration.cpp 第 158 行定义.

                      {
    constexpr const char* operation = "quadrature_simpson";
    auto valid = validate_quadrature_args(
        function, variable, lower, upper, operation);
    if (!valid) return Result<QuadratureEstimate>::failure(valid.error());
    if (subdivisions <= 0 || subdivisions % 2 != 0) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::InvalidArgument,
            "Simpson subinterval count must be positive and even",
            operation);
    }
    if (subdivisions > std::numeric_limits<int>::max() / 2) {
        return Result<QuadratureEstimate>::failure(
            CasErrc::ResourceLimit,
            "Simpson refinement count overflows",
            operation);
    }
    auto interval = evaluate_interval(lower, upper, context, operation);
    if (!interval) return Result<QuadratureEstimate>::failure(interval.error());
    if (interval.value().lower == interval.value().upper) {
        return Result<QuadratureEstimate>::success(zero_quadrature_result());
    }
    const auto refined_subdivisions =
        static_cast<std::size_t>(subdivisions) * 2;
    const auto samples =
        static_cast<std::size_t>(subdivisions) + 1 +
        refined_subdivisions + 1;
    auto budget = context.consume_steps(samples, operation);
    if (!budget) return Result<QuadratureEstimate>::failure(budget.error());
 
    detail::ensure_lmmc_lifecycle();
    QuadratureCallback callback{
        &function, &variable, &context, operation, std::nullopt};
    double value = 0.0;
    auto status = lmmc_quad_simpson(
        evaluate_quadrature_callback, &callback,
        interval.value().lower, interval.value().upper,
        static_cast<std::size_t>(subdivisions), &value);
    if (callback.error) return Result<QuadratureEstimate>::failure(*callback.error);
    if (status != LMMC_STATUS_OK) {
        return quadrature_failure<QuadratureEstimate>(status, operation);
    }
 
    double refined_value = 0.0;
    status = lmmc_quad_simpson(
        evaluate_quadrature_callback, &callback,
        interval.value().lower, interval.value().upper,
        refined_subdivisions, &refined_value);
    if (callback.error) return Result<QuadratureEstimate>::failure(*callback.error);
    if (status != LMMC_STATUS_OK) {
        return quadrature_failure<QuadratureEstimate>(status, operation);
    }
    const double correction = (refined_value - value) / 15.0;
    const double extrapolated_value = refined_value + correction;
    return estimated_quadrature_result(
        extrapolated_value, std::abs(correction),
        interval.value().sign, operation);
}

引用了 context, LMCAS::detail::ensure_lmmc_lifecycle(), LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), function(), interval(), InvalidArgument, lower, quadrature_simpson_numeric(), ResourceLimit, LMCAS::Result< T >::success(), upper, LMCAS::Result< T >::value(), value , 以及 variable.

被这些函数引用 quadrature_simpson_numeric() , 以及 quadrature_simpson_numeric().

函数调用图:

这是这个函数的调用关系图:

quadrature_simpson_numeric() [2/2]

Result< QuadratureEstimate > LMCAS::quadrature_simpson_numeric	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		int	subdivisions )

在文件 numerical_integration.cpp 第 223 行定义.

                      {
    ComputationContext context;
    return quadrature_simpson_numeric(
        function, variable, lower, upper, context, subdivisions);
}

引用了 context, function(), lower, quadrature_simpson_numeric(), upper , 以及 variable.

函数调用图:

quantity_add()

QuantityResult LMCAS::quantity_add	(	const std::shared_ptr< SymbolicExpr > &	lhs,
		const std::shared_ptr< SymbolicExpr > &	rhs,
		ComputationContext &	context )

在文件 quantity.cpp 第 211 行定义.

                                                         {
    auto checked = checked_binary(lhs, rhs, context, "quantity.add");
    if (!checked) return QuantityResult::failure(checked.error());
    const auto left = view(lhs);
    const auto right = view(rhs);
    if (left.dimension != right.dimension) {
        return failure(CasErrc::DimensionMismatch,
                       "addition requires operands with equal dimensions");
    }
    const Rational factor = right.scale / left.scale;
    auto right_value = SymbolicFactory::create_multiply(
        {right.value, rational_node(factor)});
    return make_quantity(SymbolicFactory::create_add({left.value, right_value}),
                         left.dimension, left.scale, left.display);
}

引用了 context, LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), DimensionMismatch, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), quantity_add(), rhs , 以及 right.

被这些函数引用 add() , 以及 quantity_add().

函数调用图:

这是这个函数的调用关系图:

quantity_divide()

QuantityResult LMCAS::quantity_divide	(	const std::shared_ptr< SymbolicExpr > &	lhs,
		const std::shared_ptr< SymbolicExpr > &	rhs,
		ComputationContext &	context )

在文件 quantity.cpp 第 261 行定义.

                                                            {
    auto checked = checked_binary(lhs, rhs, context, "quantity.divide");
    if (!checked) return QuantityResult::failure(checked.error());
    const auto left = view(lhs);
    const auto right = view(rhs);
    auto inverse = SymbolicFactory::create_power(right.value,
                                                  SymbolicFactory::create_number(BigInt(-1)));
    const std::string display = right.display.empty() ? left.display
        : left.display.empty() ? "1/" + right.display : left.display + "/" + right.display;
    return make_quantity(SymbolicFactory::create_multiply({left.value, inverse}),
                         left.dimension.divided_by(right.dimension),
                         left.scale / right.scale, display);
}

引用了 context, LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_power(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), quantity_divide(), rhs , 以及 right.

被这些函数引用 div() , 以及 quantity_divide().

函数调用图:

这是这个函数的调用关系图:

quantity_multiply()

QuantityResult LMCAS::quantity_multiply	(	const std::shared_ptr< SymbolicExpr > &	lhs,
		const std::shared_ptr< SymbolicExpr > &	rhs,
		ComputationContext &	context )

在文件 quantity.cpp 第 247 行定义.

                                                              {
    auto checked = checked_binary(lhs, rhs, context, "quantity.multiply");
    if (!checked) return QuantityResult::failure(checked.error());
    const auto left = view(lhs);
    const auto right = view(rhs);
    const auto dimension = left.dimension.multiplied_by(right.dimension);
    const std::string display = left.display.empty() ? right.display
        : right.display.empty() ? left.display : left.display + "*" + right.display;
    return make_quantity(SymbolicFactory::create_multiply({left.value, right.value}),
                         dimension, left.scale * right.scale, display);
}

引用了 context, LMCAS::SymbolicFactory::create_multiply(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), quantity_multiply(), rhs , 以及 right.

被这些函数引用 mul() , 以及 quantity_multiply().

函数调用图:

这是这个函数的调用关系图:

quantity_power()

QuantityResult LMCAS::quantity_power	(	const std::shared_ptr< SymbolicExpr > &	base,
		const std::shared_ptr< SymbolicExpr > &	exponent,
		ComputationContext &	context )

在文件 quantity.cpp 第 277 行定义.

                                                           {
    auto checked = checked_binary(base, exponent, context, "quantity.power");
    if (!checked) return QuantityResult::failure(checked.error());
    const auto exponent_view = view(exponent);
    if (!exponent_view.dimension.is_dimensionless()) {
        return failure(CasErrc::DimensionMismatch,
                       "a quantity exponent must be dimensionless");
    }
    const auto base_view = view(base);
    auto base_value = scaled_value(base_view);
    if (base_view.dimension.is_dimensionless()) {
        return make_quantity(
            SymbolicFactory::create_power(base_value, exponent_view.value),
            DimensionSignature{}, Rational(1), {});
    }
    auto power = exact_rational(exponent_view.value);
    if (!power) return QuantityResult::failure(power.error());
    auto dimension = base_view.dimension.raised_to(power.value());
    return make_quantity(
        SymbolicFactory::create_power(base_value, exponent_view.value),
        dimension, Rational(1), dimension.to_string());
}

引用了 context, LMCAS::SymbolicFactory::create_power(), DimensionMismatch, exponent, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure() , 以及 quantity_power().

被这些函数引用 pow(), quantity_power() , 以及 sqrt().

函数调用图:

这是这个函数的调用关系图:

quantity_subtract()

QuantityResult LMCAS::quantity_subtract	(	const std::shared_ptr< SymbolicExpr > &	lhs,
		const std::shared_ptr< SymbolicExpr > &	rhs,
		ComputationContext &	context )

在文件 quantity.cpp 第 229 行定义.

                                                              {
    auto checked = checked_binary(lhs, rhs, context, "quantity.subtract");
    if (!checked) return QuantityResult::failure(checked.error());
    const auto left = view(lhs);
    const auto right = view(rhs);
    if (left.dimension != right.dimension) {
        return failure(CasErrc::DimensionMismatch,
                       "subtraction requires operands with equal dimensions");
    }
    const Rational factor = Rational(-1) * right.scale / left.scale;
    auto right_value = SymbolicFactory::create_multiply(
        {right.value, rational_node(factor)});
    return make_quantity(SymbolicFactory::create_add({left.value, right_value}),
                         left.dimension, left.scale, left.display);
}

引用了 context, LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), DimensionMismatch, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), quantity_subtract(), rhs , 以及 right.

被这些函数引用 quantity_subtract() , 以及 sub().

函数调用图:

这是这个函数的调用关系图:

quotient_dimension()

int LMCAS::quotient_dimension	(	const std::vector< FGLMPoly > &	basis,
		size_t	num_vars,
		int	max_degree )

在文件 fglm_dimension.cpp 第 81 行定义.

                                       {
    if (basis.empty()) return -1;
    auto leading = fglm_detail::leading_monomials(basis);
    int count = 0;
    const int limit = 1000;
    for (int degree = 0; degree <= max_degree && count <= limit; ++degree) {
        std::vector<Monomial> monomials;
        Monomial current(num_vars, 0);
        fglm_detail::generate_degree(current, 0, degree, monomials);
        bool any_standard = false;
        for (const auto& monomial : monomials) {
            if (!fglm_detail::is_standard(monomial, leading)) continue;
            any_standard = true;
            if (++count > limit) return count;
        }
        if (!monomials.empty() && !any_standard && degree > 0) break;
    }
    return count;
}

引用了 basis, LMCAS::fglm_detail::generate_degree(), LMCAS::fglm_detail::is_standard(), LMCAS::fglm_detail::leading_monomials() , 以及 quotient_dimension().

被这些函数引用 LMCAS::anonymous_namespace{fglm.cpp}::checked_dimension() , 以及 quotient_dimension().

函数调用图:

这是这个函数的调用关系图:

ratio_convergence_test()

ConvergenceInfoResult LMCAS::ratio_convergence_test ( const std::shared_ptr< SymbolicExpr > & general_term, const std::string & index_var, ComputationContext & context )

static

在文件 series_convergence.cpp 第 350 行定义.

                                                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto n = SymbolicExpr::variable(index_var);
    auto n1 = SymbolicExpr::add(n, SymbolicExpr::number(1));
    auto inf = SymbolicExpr::infinity();
    auto a_n1 = detail::make_expression_ptr(detail::substitute_node(detail::node(general_term), index_var, detail::node(n1), transform_budget));
    if (a_n1) {
        a_n1 = detail::make_expression_ptr(detail::normalize_node(detail::node(a_n1), transform_budget));
        auto ratio = SymbolicExpr::divide(a_n1, general_term);
        if (ratio) {
            ratio = detail::make_expression_ptr(detail::normalize_node(detail::node(ratio), transform_budget));
            auto abs_r = LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<FunctionNode>(
                FunctionNode::FuncType::Abs, std::vector<std::shared_ptr<const SymbolicNode>>{LMCAS::detail::node(ratio)}));
            abs_r = detail::make_expression_ptr(detail::normalize_node(detail::node(abs_r), transform_budget));
            auto limited = limit_expression_checked(
                abs_r, index_var, inf, LimitDirection::Both, context);
            if (!limited) {
                return ConvergenceInfoResult::failure(limited.error());
            }
            auto lim = std::move(limited.value());
            return classify_ratio_limit(lim, context);
        }
    }
    return ConvergenceInfo{ConvergenceResult::Inconclusive, ""};
} catch (const CasError& error) {
    return ConvergenceInfoResult::failure(error);
} catch (const std::bad_alloc&) {
    return ConvergenceInfoResult::failure(CasErrc::ResourceLimit, "allocation failed", "ratio_convergence_test");
} catch (const std::length_error& error) {
    return ConvergenceInfoResult::failure(CasErrc::ResourceLimit, error.what(), "ratio_convergence_test");
} catch (const std::exception& error) {
    return ConvergenceInfoResult::failure(CasErrc::InternalInvariant, error.what(), "ratio_convergence_test");
}

引用了 LMCAS::FunctionNode::Abs, Both, classify_ratio_limit(), context, LMCAS::Result< ConvergenceInfo >::failure(), Inconclusive, limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), ratio_convergence_test() , 以及 LMCAS::detail::substitute_node().

被这些函数引用 convergence_test_impl() , 以及 ratio_convergence_test().

函数调用图:

这是这个函数的调用关系图:

rational()

ExprResult LMCAS::rational

(

const Rational &

value

)

在文件 expr_values.cpp 第 82 行定义.

                                           {
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "rational allocation failed", kRationalOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kRationalOperation);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), InternalInvariant, LMCAS::expr_detail::expr_common::kRationalOperation, rational(), ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 value.

被这些函数引用 LMCAS::expr_detail::ExprParser::apply_rootof(), bernoulli_integer_exponent(), LMCAS::detail::definite::boundary_checked(), LMCAS::anonymous_namespace{complex_analysis.cpp}::bounded_complex_power(), LMCAS::NormalizationVisitor::can_combine_nested_power(), classify_ratio_limit(), LMCAS::detail::definite::collect_predicate_roots(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::combine_surd_product(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::compare_algebraic_to_rational(), LMCAS::anonymous_namespace{symbolic_number_order.cpp}::compare_exact_nodes(), LMCAS::anonymous_namespace{symbolic_number_order.cpp}::compare_exact_to_rational(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_number(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_exponent(), exact_number_as_rational(), LMCAS::detail::exact_rational_value(), exact_small_integer_node(), LMCAS::detail::anonymous_namespace{numeric_evaluation_power.cpp}::exponent_parity(), geometric_term_convergence(), get_pi_coeff(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_builder.cpp}::integer_exponent(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::is_half_exponent(), normalization_exact_square_root(), normalization_numeric_power(), LMCAS::NormalizationVisitor::normalize_nested_imaginary_power(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::numeric_absolute(), LMCAS::expr_detail::ExprParser::parse_number(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::polynomial_exponent(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::polynomial_exponent(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::positive_denominator_exponent(), LMCAS::anonymous_namespace{normalization_signs.cpp}::positive_negative_number(), LMCAS::detail::NumericEvaluator::power(), power_term_convergence(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign(), rational(), LMCAS::detail::definite::rational_divergence_checked(), LMCAS::detail::definite::rational_pole_divergence(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::reciprocal_exact_number(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_power(), LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_number_sign(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::small_exact_power(), sqrt(), LMCAS::detail::NumericEvaluator::square_root(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::square_root_is_imaginary(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::squared_profile(), try_get_integer_value() , 以及 LMCAS::detail::RewriteBudget::Measurement::visit().

函数调用图:

这是这个函数的调用关系图:

rational_gcd()

Rational LMCAS::rational_gcd ( const Rational & a, const Rational & b )

static

在文件 multivariate_factor.cpp 第 70 行定义.

{
    if (a.is_zero()) { return b.abs(); }
    if (b.is_zero()) { return a.abs(); }
    BigInt num_gcd = BigInt::gcd(a.get_numerator().abs(), b.get_numerator().abs());
    BigInt den_gcd = BigInt::gcd(a.get_denominator(), b.get_denominator());
    BigInt den_lcm = a.get_denominator() * b.get_denominator() / den_gcd;
    return Rational(num_gcd, den_lcm);
}

引用了 a, b , 以及 rational_gcd().

被这些函数引用 multivariate_gcd(), rational_gcd(), recursive_multivariate_gcd() , 以及 univariate_gcd().

函数调用图:

这是这个函数的调用关系图:

rational_reconstruction_checked() [1/2]

RationalReconstructionResult LMCAS::rational_reconstruction_checked ( int64_t x, int64_t m )

inline

在文件 modular_arithmetic.hpp 第 452 行定义.

                                                                                          {
    ComputationContext context;
    return rational_reconstruction_checked(x, m, context);
}

引用了 context , 以及 rational_reconstruction_checked().

函数调用图:

rational_reconstruction_checked() [2/2]

RationalReconstructionResult LMCAS::rational_reconstruction_checked ( int64_t x, int64_t m, ComputationContext & context )

inline

Checked rational reconstruction.

Returns Inconclusive when no supported coprime numerator/denominator can be reconstructed.

在文件 modular_arithmetic.hpp 第 386 行定义.

                                 {
    constexpr const char* operation = "rational_reconstruction";
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return RationalReconstructionResult::failure(step.error());
    }
    if (m <= 0) {
        return RationalReconstructionResult::failure(
            CasErrc::InvalidArgument,
            "rational reconstruction modulus must be positive",
            operation);
    }
 
    x %= m;
    if (x < 0) {
        x += m;
    }
    int64_t bound = static_cast<int64_t>(
        std::floor(std::sqrt(static_cast<double>(m) / 2.0)));
    if (bound == 0) {
        bound = 1;
    }
    int64_t r0 = m;
    int64_t r1 = x;
    int64_t s0 = 0;
    int64_t s1 = 1;
    while (r1 > bound) {
        step = context.consume_steps(1, operation);
        if (!step) {
            return RationalReconstructionResult::failure(step.error());
        }
        const int64_t quotient = r0 / r1;
        const int64_t next_r = r0 - quotient * r1;
        const int64_t next_s = s0 - quotient * s1;
        r0 = r1;
        r1 = next_r;
        s0 = s1;
        s1 = next_s;
    }
    int64_t numerator = r1;
    int64_t denominator = s1;
    if (denominator < 0) {
        numerator = -numerator;
        denominator = -denominator;
    }
    int64_t unused_s = 0;
    int64_t unused_t = 0;
    const bool outside_bound =
        std::abs(numerator) >= bound || denominator == 0 ||
        denominator >= bound;
    const bool not_coprime = !outside_bound &&
        extended_gcd(std::abs(numerator), denominator,
                     unused_s, unused_t) != 1;
    if (outside_bound || not_coprime) {
        return RationalReconstructionResult::failure(
            CasErrc::Inconclusive,
            "no rational reconstruction exists in the supported bound",
            operation);
    }
    return RationalReconstructionResult::success(
        {numerator, denominator});
}

引用了 context, denominator, extended_gcd(), LMCAS::Result< std::pair< int64_t, int64_t > >::failure(), Inconclusive, InvalidArgument, rational_reconstruction_checked() , 以及 LMCAS::Result< std::pair< int64_t, int64_t > >::success().

被这些函数引用 rational_reconstruction_checked(), rational_reconstruction_checked() , 以及 zc_rational_reconstruction().

函数调用图:

这是这个函数的调用关系图:

rational_root_candidate()

std::optional< Rational > LMCAS::rational_root_candidate ( const Polynomial< Rational > & current )

static

在文件 rational_polynomial.cpp 第 33 行定义.

                                         {
    BigInt denominator_lcm(1);
    for (const auto& coefficient : current.coeffs) {
        denominator_lcm = BigInt::lcm(
            denominator_lcm, coefficient.get_denominator());
    }
    const Rational scale(denominator_lcm);
    const auto numerators = positive_divisors(
        (current.coeffs[0] * scale).get_numerator());
    const auto denominators = positive_divisors(
        (current.lead_coeff() * scale).get_numerator());
    for (const auto& numerator : numerators) {
        for (const auto& denominator : denominators) {
            Rational positive(numerator, denominator);
            if (current.eval(positive) == Rational(0)) return positive;
            Rational negative(-numerator, denominator);
            if (current.eval(negative) == Rational(0)) return negative;
        }
    }
    return std::nullopt;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, denominator, LMCAS::Polynomial< CoeffType >::eval(), LMCAS::Polynomial< CoeffType >::lead_coeff(), positive_divisors() , 以及 rational_root_candidate().

被这些函数引用 find_rational_roots() , 以及 rational_root_candidate().

函数调用图:

这是这个函数的调用关系图:

rational_root_factors()

std::vector< std::shared_ptr< const SymbolicNode > > LMCAS::rational_root_factors ( const std::vector< Rational > & roots, const Rational & leading, const std::shared_ptr< SymbolicExpr > & x_node, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 238 行定义.

                                                                            {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<std::shared_ptr<const SymbolicNode>> factors;
 
    if (!(leading == Rational(1))) {
        factors.push_back(LMCAS::detail::node(SymbolicExpr::number(leading)));
    }
 
    for (const auto& r : roots) {
        std::shared_ptr<SymbolicExpr> linear_factor;
        if (r == Rational(0)) {
            linear_factor = x_node;
        } else {
            auto neg_r = SymbolicExpr::number(Rational(0) - r);
            linear_factor = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(x_node, neg_r)), transform_budget));
        }
        factors.push_back(LMCAS::detail::node(linear_factor));
    }
    return factors;
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), r, rational_root_factors() , 以及 roots().

被这些函数引用 rational_root_factors() , 以及 reconstruct_rational_roots().

函数调用图:

这是这个函数的调用关系图:

rational_root_product()

Polynomial< Rational > LMCAS::rational_root_product ( const std::vector< Rational > & roots, const Rational & leading, const std::string & var )

static

在文件 symbolic_factor.cpp 第 263 行定义.

                          {
    LMCAS::Polynomial<Rational> factored_product({leading}, var);
    for (const auto& r : roots) {
        LMCAS::Polynomial<Rational> lin({Rational(0) - r, Rational(1)}, var);
        factored_product = factored_product * lin;
    }
    return factored_product;
}

引用了 r, rational_root_product() , 以及 roots().

被这些函数引用 rational_root_product() , 以及 reconstruct_rational_roots().

函数调用图:

这是这个函数的调用关系图:

rational_to_symbolic_poly()

Polynomial< SymbolicPolyCoeff > LMCAS::rational_to_symbolic_poly ( const Polynomial< Rational > & rat_poly )

static

在文件 solve_polynomial.cpp 第 44 行定义.

{
    std::vector<SymbolicPolyCoeff> sym_coeffs;
    sym_coeffs.reserve(rat_poly.coeffs.size());
    for (const auto& c : rat_poly.coeffs) {
        sym_coeffs.push_back(SymbolicPolyCoeff(SymbolicExpr::number(c)));
    }
    return Polynomial<SymbolicPolyCoeff>(sym_coeffs, rat_poly.variable_name);
}

引用了 LMCAS::Polynomial< CoeffType >::Polynomial(), LMCAS::SymbolicPolyCoeff::SymbolicPolyCoeff(), c, LMCAS::Polynomial< CoeffType >::coeffs, rational_to_symbolic_poly() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 append_factor_solutions(), rational_to_symbolic_poly() , 以及 LMCAS::polynomial_solver_detail::solve_by_factoring_impl().

函数调用图:

这是这个函数的调用关系图:

rationals()

NumberDomainSet LMCAS::rationals

(

)

在文件 expr_number_domains.cpp 第 361 行定义.

                            {
    return NumberDomainSet(NumberDomain::Rationals);
}

引用了 Rationals , 以及 rationals().

被这些函数引用 rationals().

函数调用图:

这是这个函数的调用关系图:

real() [1/2]

ExprResult LMCAS::real

(

const ExprPtr &

expression

)

在文件 expr_arithmetic.cpp 第 103 行定义.

                                           {
    ComputationContext context;
    return real(expression, context);
}

引用了 context , 以及 real().

函数调用图:

real() [2/2]

ExprResult LMCAS::real	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 98 行定义.

                                                                        {
    return expr_from_complex_result(real_part_checked(expression, context),
                                    kRealOperation);
}

引用了 context, LMCAS::expr_detail::expr_common::expr_from_complex_result(), LMCAS::expr_detail::expr_common::kRealOperation, real() , 以及 real_part_checked().

被这些函数引用 LMCAS::ode_root_detail::Complex::Complex(), abs(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::affine_period(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::approx_complex(), calculus_utils_extract_real_candidate(), LMCAS::equivalence_detail::canonicalize_complex_product(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::checked_complex(), classify_inflection_candidates(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_root(), complex(), complex_div_checked(), complex_exp_form_checked(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::complex_facts(), complex_mul_checked(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::compound_node(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::construct_roots(), LMCAS::detail::complex_root::coordinate_projections(), LMCAS::detail::complex_root::count_rectangle_roots(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::count_sheared_edges(), LMCAS::SymbolicFactory::create_complex(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::declared_period(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_complex(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::edge_image(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::edge_is_clear(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_components(), LMCAS::detail::evaluate_root_complex(), LMCAS::equivalence_detail::exact_integer_node(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::InferenceEngine::Impl::exponential_domain(), LMCAS::InferenceEngine::Impl::exponential_sign(), LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::function_bounds(), 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(), make_complex(), LMCAS::NormalizationVisitor::merge_complex_terms(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalized_root(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::prepare_projection_grid(), LMCAS::InferenceEngine::Impl::product_sign(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_coefficients(), LMCAS::InferenceEngine::Impl::quotient_sign(), real(), real(), LMCAS::detail::definite::real_assumptions(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::real_to_complex(), LMCAS::detail::refine_complex_isolation(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_absolute(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), LMCAS::equivalence_detail::rewritten_complex(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::root_facts(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::shear_is_valid(), 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(), te_accept_decay(), LMCAS::InferenceEngine::Impl::trigonometric_sign(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::RealPrimitiveCandidate::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::RewriteVisitor::visit().

函数调用图:

这是这个函数的调用关系图:

real_part_checked() [1/2]

ExpressionResult LMCAS::real_part_checked

(

const std::shared_ptr< SymbolicExpr > &

expr

)

在文件 complex_analysis.cpp 第 526 行定义.

                                                                            {
    ComputationContext context;
    return real_part_checked(expr, context);
}

引用了 context , 以及 real_part_checked().

函数调用图:

real_part_checked() [2/2]

ExpressionResult LMCAS::real_part_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		ComputationContext &	context )

在文件 complex_analysis.cpp 第 493 行定义.

                                                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "real_part";
    auto input = validate_complex_expr_input(expr, context, operation);
    if (!input) return ExpressionResult::failure(input.error());
    if (has_function_of_explicit_complex(LMCAS::detail::node(expr))) {
        return ExpressionResult::failure(
            CasErrc::Inconclusive,
            "real part of functions with complex arguments is outside the current support domain",
            operation);
    }
 
    std::shared_ptr<SymbolicExpr> re, im;
    split_real_imag(LMCAS::detail::node(expr), re, im, context);
    auto simplified = re ? detail::make_expression_ptr(detail::normalize_node(detail::node(re), transform_budget)) : nullptr;
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                          "real part construction failed",
                                          operation);
    }
    return ExpressionResult::success(simplified);
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "real_part");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "real_part");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "real_part");
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), real_part_checked() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 real(), real_part_checked() , 以及 real_part_checked().

函数调用图:

这是这个函数的调用关系图:

reals()

NumberDomainSet LMCAS::reals

(

)

在文件 expr_number_domains.cpp 第 365 行定义.

                        {
    return NumberDomainSet(NumberDomain::Reals);
}

引用了 Reals , 以及 reals().

被这些函数引用 reals().

函数调用图:

这是这个函数的调用关系图:

recognize_rational_polynomial()

Result< OptionalRationalPolynomial > LMCAS::recognize_rational_polynomial	(	const SymbolicExpr &	expression,
		const std::string &	variable,
		ComputationContext &	context )

在文件 rational_polynomial_recognition.cpp 第 171 行定义.

                                 {
    if (!LMCAS::detail::node(expression)) {
        return Result<OptionalRationalPolynomial>::failure(
            CasErrc::InvalidArgument, "expression cannot be null", kOperation);
    }
    if (variable.empty()) {
        return Result<OptionalRationalPolynomial>::failure(
            CasErrc::InvalidArgument, "polynomial variable cannot be empty", kOperation);
    }
    return recognize_node(LMCAS::detail::node(expression), variable, context);
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), recognize_rational_polynomial() , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{residual_verification.cpp}::classify_residual(), dispatch_equation(), make_rootof_checked(), LMCAS::detail::make_rootof_solutions_impl(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_exact_root_residual(), LMCAS::equivalence_detail::prove_rational_polynomial_equivalence(), LMCAS::detail::definite::rational_checked(), recognize_rational_polynomial(), recognize_regular_laurent(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_match_exp_neg_quad(), solve_numeric_checked() , 以及 LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_quadratic_coefficients().

函数调用图:

这是这个函数的调用关系图:

recognize_regular_laurent()

Result< int > LMCAS::recognize_regular_laurent ( const std::shared_ptr< SymbolicExpr > & f, const std::string & var, ComputationContext & context )

static

在文件 series_expansions.cpp 第 494 行定义.

                                 {
    constexpr const char* operation = "laurent_series_full";
    auto fn = std::dynamic_pointer_cast<const FunctionNode>(detail::node(f));
    if (fn && fn->arguments().size() == 1 && regular_laurent_type(fn->type())) {
        auto argument = detail::make_expression_ptr(fn->arguments()[0]);
        auto polynomial = recognize_rational_polynomial(*argument, var, context);
        if (!polynomial) {
            return Result<int>::failure(polynomial.error());
        }
        if (polynomial.value()) {
            return 0;
        }
    }
    return Result<int>::failure(CasErrc::Inconclusive,
                                "Laurent singularity could not be proved", operation);
}

引用了 context, LMCAS::Result< T >::failure(), Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), recognize_rational_polynomial(), recognize_regular_laurent() , 以及 regular_laurent_type().

被这些函数引用 extract_laurent_regular_part() , 以及 recognize_regular_laurent().

函数调用图:

这是这个函数的调用关系图:

reconstruct_rational_root_factors()

std::optional< ExpressionResult > LMCAS::reconstruct_rational_root_factors ( const Polynomial< Rational > & polynomial, const std::vector< Rational > & roots, const std::string & var, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 452 行定义.

                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto reconstruction =
        reconstruct_rational_roots(polynomial, roots, var, context);
    auto& factors = reconstruction.factors;
    auto& quotient = reconstruction.quotient;
    const auto& remainder = reconstruction.remainder;
    if (remainder.is_zero() && quotient.degree() >= 1) {
        auto q_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(LMCAS::poly_to_symbolic(quotient)), transform_budget));
        factors.push_back(LMCAS::detail::node(q_expr));
    } else if (remainder.is_zero() && !quotient.is_zero() && quotient.degree() == 0) {
        if (!(quotient.coeffs[0] == Rational(1))) {
            factors.push_back(
                LMCAS::detail::node(SymbolicExpr::number(quotient.coeffs[0])));
        }
    }
    if (factors.size() > 1) {
        return LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<MultiplyNode>(factors));
    }
    return std::nullopt;
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), reconstruct_rational_root_factors(), reconstruct_rational_roots() , 以及 roots().

被这些函数引用 factor_variable_rational_roots() , 以及 reconstruct_rational_root_factors().

函数调用图:

这是这个函数的调用关系图:

reconstruct_rational_roots()

RationalRootReconstruction LMCAS::reconstruct_rational_roots ( const Polynomial< Rational > & polynomial, const std::vector< Rational > & roots, const std::string & variable, ComputationContext & context )

static

在文件 symbolic_factor.cpp 第 280 行定义.

                                                                                              {
    auto symbol =
        detail::make_expression_ptr(detail::make_node<VariableNode>(variable));
    const auto leading = polynomial.lead_coeff();
    auto factors = rational_root_factors(roots, leading, symbol, context);
    auto product = rational_root_product(roots, leading, variable);
    auto [quotient, remainder] = polynomial.div_mod(product);
    return {
        std::move(factors), std::move(quotient), std::move(remainder)};
}

引用了 context, LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::lead_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), rational_root_factors(), rational_root_product(), reconstruct_rational_roots(), roots() , 以及 variable.

被这些函数引用 factor_rational_univariate(), reconstruct_rational_root_factors() , 以及 reconstruct_rational_roots().

函数调用图:

这是这个函数的调用关系图:

record_remainder()

template<typename Operation>

void LMCAS::record_remainder ( const Operation & target, const std::vector< bool > & used, const char * key, MatchMap & results )

static

在文件 matcher.cpp 第 78 行定义.

                                                                 {
    std::vector<std::shared_ptr<const SymbolicNode>> rest;
    for (size_t index = 0; index < used.size(); ++index) {
        if (!used[index]) {
            rest.push_back(target.operands()[index]);
        }
    }
    if (rest.empty()) {
        return;
    }
    auto remainder = rest.size() == 1 ? rest.front() : combine_operands<Operation>(std::move(rest));
    const auto found = results.find(key);
    if (found == results.end()) {
        results.emplace(key, detail::expression_from_node(remainder));
        return;
    }
    std::vector<std::shared_ptr<const SymbolicNode>> operands;
    if (const auto* existing = dynamic_cast<const Operation*>(detail::node(found->second).get())) {
        operands.insert(operands.end(), existing->operands().begin(), existing->operands().end());
    } else {
        operands.push_back(detail::node(found->second));
    }
    operands.push_back(remainder);
    found->second = detail::expression_from_node(combine_operands<Operation>(std::move(operands)));
}

引用了 combine_operands(), LMCAS::detail::expression_from_node(), LMCAS::detail::node(), record_remainder() , 以及 target.

被这些函数引用 match_operation() , 以及 record_remainder().

函数调用图:

这是这个函数的调用关系图:

recursive_multivariate_gcd()

MultiPoly LMCAS::recursive_multivariate_gcd ( const MultiPoly & a, const MultiPoly & b, const std::vector< std::string > & vars )

static

在文件 multivariate_factor.cpp 第 329 行定义.

                                      {
    std::string main_var = choose_main_variable(a, b);
    Rational nc_a = a.numeric_content();
    Rational nc_b = b.numeric_content();
    Rational nc_gcd = rational_gcd(nc_a, nc_b);
    MultiPoly a_prim = a.make_primitive();
    MultiPoly b_prim = b.make_primitive();
    int deg_a = a_prim.degree(main_var);
    int deg_b = b_prim.degree(main_var);
    int degree_bound = std::min(deg_a, deg_b);
    int num_points = degree_bound + 1;
    auto eval_pts = gcd_evaluation_points(num_points + 10);
    GcdSamples samples;
    collect_gcd_samples(a_prim, b_prim, main_var, eval_pts, num_points, samples);
    const auto& used_pts = samples.points;
    const auto& gcd_vals = samples.values;
    const int target_deg = samples.target_degree;
    if (target_deg <= 0 || used_pts.empty()) { return MultiPoly(nc_gcd, vars); }
    if (used_pts.size() == 1 && degree_bound == 0) {
        MultiPoly r = lagrange_interpolate(used_pts, gcd_vals, main_var, vars);
        if (nc_gcd != Rational(1)) { r = r * nc_gcd; }
        return r;
    }
    MultiPoly cand = lagrange_interpolate(used_pts, gcd_vals, main_var, vars);
    if (cand.is_zero()) { return MultiPoly(nc_gcd, vars); }
    cand = cand.make_primitive();
    if (divides_poly(a_prim, cand) && divides_poly(b_prim, cand)) {
        return normalize_gcd_candidate(std::move(cand), nc_gcd);
    }
    return extended_gcd_interpolation(a_prim, b_prim, main_var, vars,
                                      degree_bound, nc_gcd);
}

引用了 a, b, choose_main_variable(), collect_gcd_samples(), divides_poly(), extended_gcd_interpolation(), gcd_evaluation_points(), lagrange_interpolate(), main_var, normalize_gcd_candidate(), LMCAS::GcdSamples::points, r, rational_gcd(), recursive_multivariate_gcd(), LMCAS::GcdSamples::target_degree, LMCAS::GcdSamples::values , 以及 vars.

被这些函数引用 multivariate_gcd() , 以及 recursive_multivariate_gcd().

函数调用图:

这是这个函数的调用关系图:

refine_root()

std::optional< NumericRoot > LMCAS::refine_root	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	var,
		const IsolatedInterval &	interval,
		const SolveOptions &	opts )

在文件 mixed_transcendental_refinement.cpp 第 220 行定义.

                              {
    ComputationContext context;
    detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                context.limits().max_ast_nodes, "refine_root");
    std::optional<CasError> failure;
    auto result = detail::refine_root_with_context(
        expr, derivative, var, interval, opts, budget, &failure, nullptr);
    if (failure) throw *failure;
    return result;
}

引用了 context, interval(), refine_root() , 以及 LMCAS::detail::refine_root_with_context().

被这些函数引用 refine_root().

函数调用图:

这是这个函数的调用关系图:

regular_laurent_type()

bool LMCAS::regular_laurent_type ( FunctionNode::FuncType type )

static

在文件 series_expansions.cpp 第 488 行定义.

                                                            {
    return type == FunctionNode::FuncType::Sin ||
           type == FunctionNode::FuncType::Cos ||
           type == FunctionNode::FuncType::Exp;
}

引用了 LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, regular_laurent_type() , 以及 LMCAS::FunctionNode::Sin.

被这些函数引用 recognize_regular_laurent() , 以及 regular_laurent_type().

函数调用图:

这是这个函数的调用关系图:

relation()

ExprResult LMCAS::relation	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		RelationOp	op )

在文件 expr_facade.cpp 第 174 行定义.

                                                                           {
    constexpr const char* operation = "LMCAS.relation";
    if (!lhs || !rhs) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "relation operands cannot be null", operation);
    }
    try {
        return ExprResult::success(LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<RelationalNode>(
                LMCAS::detail::node(lhs), LMCAS::detail::node(rhs), op)));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "relation allocation failed", operation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant,
                                  error.what(), operation);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), InternalInvariant, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), op, relation(), ResourceLimit, rhs , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 LMCAS::detail::AssumptionFacts::collect_names(), LMCAS::detail::definite::collect_predicate_roots(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_condition(), LMCAS::detail::transcendental::conditional_preimage(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equation_residual(), LMCAS::anonymous_namespace{assumption_conditionals.cpp}::evaluate_zero_comparison(), ge(), gt(), le(), lt(), ne(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::parse_conditional_relation(), LMCAS::assumption_detail::AssumptionParser::parse_relation(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::predicate_truth(), relation(), relation_op(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::relational_predicate_truth(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::solve_condition_truth(), solve_equation() , 以及 solve_transcendental().

函数调用图:

这是这个函数的调用关系图:

relation_op()

std::optional< RelationOp > LMCAS::relation_op ( const ExprPtr & expression )

noexcept

在文件 expr_values.cpp 第 23 行定义.

                                                                        {
    const auto* relation =
        dynamic_cast<const RelationalNode*>(detail::node(expression).get());
    if (!relation) return std::nullopt;
    return relation->op();
}

引用了 LMCAS::detail::node(), relation() , 以及 relation_op().

被这些函数引用 relation_op().

函数调用图:

这是这个函数的调用关系图:

residue_checked() [1/2]

ExpressionResult LMCAS::residue_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	order )

在文件 complex_analysis.cpp 第 725 行定义.

               {
    return calculate_residue_checked(f, z, z0, order);
}

引用了 calculate_residue_checked(), order , 以及 residue_checked().

函数调用图:

residue_checked() [2/2]

ExpressionResult LMCAS::residue_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	z,
		const std::shared_ptr< SymbolicExpr > &	z0,
		int	order,
		ComputationContext &	context )

在文件 complex_analysis.cpp 第 716 行定义.

                                 {
    return calculate_residue_checked(f, z, z0, order, context);
}

引用了 calculate_residue_checked(), context, order , 以及 residue_checked().

被这些函数引用 residue_checked() , 以及 residue_checked().

函数调用图:

这是这个函数的调用关系图:

restore_main_exponent()

Monomial LMCAS::restore_main_exponent ( const Monomial & reduced, size_t variable_count, int variable_index, int exponent )

static

在文件 multivariate_factor.cpp 第 79 行定义.

                                                             {
    Monomial full(variable_count, 0);
    size_t reduced_index = 0;
    for (size_t i = 0; i < variable_count; ++i) {
        if (static_cast<int>(i) == variable_index) {
            full[i] = exponent;
        } else {
            if (reduced_index < reduced.size()) { full[i] = reduced[reduced_index]; }
            ++reduced_index;
        }
    }
    return full;
}

引用了 exponent , 以及 restore_main_exponent().

被这些函数引用 add_lagrange_value(), multivariate_primitive_part() , 以及 restore_main_exponent().

函数调用图:

这是这个函数的调用关系图:

riemann_curvature_tensor_checked() [1/2]

DifferentialGeometryExprResult LMCAS::riemann_curvature_tensor_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		const std::vector< std::string > &	coords,
		int	rho,
		int	sigma,
		int	mu,
		int	nu )

在文件 differential_geometry.cpp 第 627 行定义.

{
    ComputationContext context;
    return riemann_curvature_tensor_checked(g_ij, coords, rho, sigma, mu, nu, context);
}

引用了 context , 以及 riemann_curvature_tensor_checked().

函数调用图:

riemann_curvature_tensor_checked() [2/2]

DifferentialGeometryExprResult LMCAS::riemann_curvature_tensor_checked	(	const std::shared_ptr< SymbolicExpr > &	g_ij,
		const std::vector< std::string > &	coords,
		int	rho,
		int	sigma,
		int	mu,
		int	nu,
		ComputationContext &	context )

在文件 differential_geometry.cpp 第 574 行定义.

{
    const std::string operation = "riemann_curvature_tensor";
    auto metric = validate_metric_matrix(g_ij, &coords, context, operation);
    if (!metric) {
        return DifferentialGeometryExprResult::failure(metric.error());
    }
    const std::size_t dim = metric.value()->rows();
    auto rho_check = validate_index(rho, dim, "rho", operation);
    if (!rho_check) {
        return DifferentialGeometryExprResult::failure(rho_check.error());
    }
    auto sigma_check = validate_index(sigma, dim, "sigma", operation);
    if (!sigma_check) {
        return DifferentialGeometryExprResult::failure(sigma_check.error());
    }
    auto mu_check = validate_index(mu, dim, "mu", operation);
    if (!mu_check) {
        return DifferentialGeometryExprResult::failure(mu_check.error());
    }
    auto nu_check = validate_index(nu, dim, "nu", operation);
    if (!nu_check) {
        return DifferentialGeometryExprResult::failure(nu_check.error());
    }
    auto budget = context.consume_steps(dim * 80 + 40, operation);
    if (!budget) {
        return DifferentialGeometryExprResult::failure(budget.error());
    }
    try {
        auto inverse_metric = metric_inverse_checked(g_ij, context);
        if (!inverse_metric) {
            return DifferentialGeometryExprResult::failure(inverse_metric.error());
        }
        auto result = riemann_curvature_tensor_with_inverse(
            g_ij, inverse_metric.value(), coords, rho, sigma, mu, nu, context);
        return checked_geometry_expression(std::move(result), CasErrc::Inconclusive,
                                           "Riemann curvature component could not be constructed",
                                           operation);
    } catch (const std::bad_alloc&) {
        return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit,
                                                       "allocation failed while calculating Riemann curvature",
                                                       operation);
    } catch (const std::exception& ex) {
        return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant,
                                                       ex.what(),
                                                       operation);
    }
}

引用了 context, dim, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, metric_inverse_checked(), ResourceLimit, riemann_curvature_tensor_checked(), riemann_curvature_tensor_with_inverse() , 以及 LMCAS::Result< T >::value().

被这些函数引用 riemann_curvature_tensor_checked() , 以及 riemann_curvature_tensor_checked().

函数调用图:

这是这个函数的调用关系图:

riemann_curvature_tensor_with_inverse()

std::shared_ptr< SymbolicExpr > LMCAS::riemann_curvature_tensor_with_inverse ( const std::shared_ptr< SymbolicExpr > & g_ij, const std::shared_ptr< SymbolicExpr > & g_up_ij, const std::vector< std::string > & coords, int rho, int sigma, int mu, int nu, ComputationContext & context )

static

在文件 differential_geometry.cpp 第 534 行定义.

                                                                     {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto gamma_rho_nu_sigma =
        christoffel_second_kind_impl(g_ij, g_up_ij, coords, rho, nu, sigma, context);
    auto gamma_rho_mu_sigma =
        christoffel_second_kind_impl(g_ij, g_up_ij, coords, rho, mu, sigma, context);
 
    auto term1 = detail::make_expression_ptr(detail::differentiate_node(detail::node(gamma_rho_nu_sigma), coords[mu], transform_budget));
    auto term2 = detail::make_expression_ptr(detail::differentiate_node(detail::node(gamma_rho_mu_sigma), coords[nu], transform_budget));
    auto result = SymbolicExpr::add(
        term1,
        SymbolicExpr::multiply(term2, SymbolicExpr::number(-1)));
 
    for (std::size_t lambda = 0; lambda < coords.size(); ++lambda) {
        auto gamma_rho_mu_lambda =
            christoffel_second_kind_impl(g_ij, g_up_ij, coords, rho, mu, lambda, context);
        auto gamma_lambda_nu_sigma =
            christoffel_second_kind_impl(g_ij, g_up_ij, coords, lambda, nu, sigma, context);
        auto gamma_rho_nu_lambda =
            christoffel_second_kind_impl(g_ij, g_up_ij, coords, rho, nu, lambda, context);
        auto gamma_lambda_mu_sigma =
            christoffel_second_kind_impl(g_ij, g_up_ij, coords, lambda, mu, sigma, context);
        auto product_difference = SymbolicExpr::add(
            SymbolicExpr::multiply(
                gamma_rho_mu_lambda, gamma_lambda_nu_sigma),
            SymbolicExpr::multiply(
                SymbolicExpr::multiply(
                    gamma_rho_nu_lambda, gamma_lambda_mu_sigma),
                SymbolicExpr::number(-1)));
        result = SymbolicExpr::add(result, product_difference);
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
}

引用了 christoffel_second_kind_impl(), context, LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 riemann_curvature_tensor_with_inverse().

被这些函数引用 riemann_curvature_tensor_checked() , 以及 riemann_curvature_tensor_with_inverse().

函数调用图:

这是这个函数的调用关系图:

root_less_than()

bool LMCAS::detail::inequality_support::root_less_than	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

在文件 inequality_solver_ordering.cpp 第 99 行定义.

                                                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!a || !b) {
        return false;
    }
    auto va = try_checked_numeric_constant(*a, context);
    auto vb = try_checked_numeric_constant(*b, context);
    if (va && vb) {
        return *va < *vb;
    }
    auto diff = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(a, SymbolicExpr::multiply(b, SymbolicExpr::number(-1)))), transform_budget));
    if (auto vd = try_checked_numeric_constant(*diff, context)) {
        return *vd < 0;
    }
    return root_expression_sign(diff, context) < 0;
}

rootof_evaluate_checked() [1/2]

RootOfEvaluationResult LMCAS::rootof_evaluate_checked

(

const std::shared_ptr< SymbolicExpr > &

rootof_expr

)

在文件 root_of_identity.cpp 第 168 行定义.

                                                    {
    ComputationContext context;
    return rootof_evaluate_checked(rootof_expr, context);
}

引用了 context , 以及 rootof_evaluate_checked().

函数调用图:

rootof_evaluate_checked() [2/2]

RootOfEvaluationResult LMCAS::rootof_evaluate_checked	(	const std::shared_ptr< SymbolicExpr > &	rootof_expr,
		ComputationContext &	context )

在文件 root_of_identity.cpp 第 152 行定义.

{
    constexpr const char* operation = "rootof_evaluate";
    auto request = parse_rootof_request(rootof_expr, context, operation);
    if (!request) return RootOfEvaluationResult::failure(request.error());
    auto evaluated = detail::evaluate_root_real(
        request.value()->exact_id(),
        detail::NumericEvaluationOptions{}, context);
    if (!evaluated) {
        return RootOfEvaluationResult::failure(evaluated.error());
    }
    return RootOfEvaluationResult::success(evaluated.value().value);
}

引用了 context, LMCAS::detail::evaluate_root_real(), LMCAS::Result< lmmc_real_t >::failure(), rootof_evaluate_checked() , 以及 LMCAS::Result< lmmc_real_t >::success().

被这些函数引用 LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root(), LMCAS::detail::NumericEvaluator::root(), rootof_evaluate_checked() , 以及 rootof_evaluate_checked().

函数调用图:

这是这个函数的调用关系图:

rootof_evaluate_complex_checked() [1/2]

RootOfComplexEvaluationResult LMCAS::rootof_evaluate_complex_checked

(

const std::shared_ptr< SymbolicExpr > &

rootof_expr

)

在文件 root_of_identity.cpp 第 187 行定义.

                                                    {
    ComputationContext context;
    return rootof_evaluate_complex_checked(rootof_expr, context);
}

引用了 context , 以及 rootof_evaluate_complex_checked().

函数调用图:

rootof_evaluate_complex_checked() [2/2]

RootOfComplexEvaluationResult LMCAS::rootof_evaluate_complex_checked	(	const std::shared_ptr< SymbolicExpr > &	rootof_expr,
		ComputationContext &	context )

在文件 root_of_identity.cpp 第 174 行定义.

                                 {
    constexpr const char* operation = "rootof_evaluate_complex";
    auto request = parse_rootof_request(rootof_expr, context, operation);
    if (!request) {
        return RootOfComplexEvaluationResult::failure(request.error());
    }
    return detail::evaluate_root_complex(
        request.value()->exact_id(),
        detail::NumericEvaluationOptions{}, context);
}

引用了 context, LMCAS::detail::evaluate_root_complex(), LMCAS::Result< ApproxComplex >::failure() , 以及 rootof_evaluate_complex_checked().

被这些函数引用 LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root(), rootof_evaluate_complex_checked() , 以及 rootof_evaluate_complex_checked().

函数调用图:

这是这个函数的调用关系图:

rootof_simplify()

std::shared_ptr< SymbolicExpr > LMCAS::rootof_simplify

(

const std::shared_ptr< SymbolicExpr > &

rootof_expr

)

在文件 root_of_utils.cpp 第 71 行定义.

{
    ComputationContext context;
    if (!rootof_expr || !LMCAS::detail::node(rootof_expr)) return rootof_expr;
 
    auto root = std::dynamic_pointer_cast<const RootOfNode>(
        LMCAS::detail::node(rootof_expr));
    if (!root) return rootof_expr;
 
    const std::string& var = root->variable();
    const int k = static_cast<int>(root->index());
    std::vector<SymbolicPolyCoeff> coefficients;
    coefficients.reserve(root->exact_id().polynomial.coeffs.size());
    for (const auto& coefficient : root->exact_id().polynomial.coeffs) {
        coefficients.emplace_back(SymbolicExpr::number(coefficient));
    }
    Polynomial<SymbolicPolyCoeff> sym_poly(coefficients, var);
 
    int degree = sym_poly.degree();
    if (degree <= 0) return rootof_expr;
 
    if (k < 0 || k >= degree) {
        return rootof_expr;
    }
 
    if (degree == 1) {
        auto roots = solve_closed_form_from_poly(sym_poly, var, context);
        return roots.size() == 1 ? roots.front() : rootof_expr;
    }
    if (degree == 2) {
        auto roots = solve_closed_form_from_poly(sym_poly, var, context);
        if (roots.size() != 2) return rootof_expr;
        return roots[static_cast<std::size_t>(1 - k)];
    }
 
    return rootof_expr;
}

引用了 context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::detail::node(), rootof_simplify(), roots() , 以及 solve_closed_form_from_poly().

被这些函数引用 LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::apply_root_representation_policy(), asymptote_candidates(), calculus_utils_extract_real_candidate(), explicit_inverse_candidates() , 以及 rootof_simplify().

函数调用图:

这是这个函数的调用关系图:

roots() [1/2]

ExprSetResult LMCAS::roots	(	const ExprPtr &	expression,
		const std::string &	variable,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 80 行定义.

                                                 {
    return project_finite_expr_set(expression, variable, context, options);
}

引用了 context, options, project_finite_expr_set(), roots() , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::append_exact_factor_roots(), LMCAS::detail::inequality_support::append_verified_roots(), build_euler_solution(), build_homogeneous_solution(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), LMCAS::ExpandVisitor::check_child_count(), LMCAS::ode_root_detail::anonymous_namespace{ode_characteristic_roots.cpp}::classify_characteristic_roots(), collect_exact_solutions(), LMCAS::detail::definite::collect_predicate_roots(), deduplicate_roots(), LMCAS::detail::definite::definite_partition_checked(), deflate_rational_root(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::edge_is_clear(), exact_factor_roots(), LMCAS::polynomial_solver_detail::exact_polynomial_roots(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::exact_polynomial_sign_intervals(), factor_rational_univariate(), factor_variable_rational_roots(), LMCAS::ode_root_detail::find_characteristic_roots(), find_rational_roots(), LMCAS::detail::inequality_support::find_roots_with_multiplicity(), LMCAS::detail::isolate_exact_root(), LMCAS::detail::isolate_exact_roots(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::isolate_grid_row(), LMCAS::detail::complex_root::isolate_nonreal_roots(), linear2_root_basis(), matrix_eigenvalues_checked(), LMCAS::detail::mixed_numerical_path(), normalization_check_children(), normalization_check_children(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::order_isolations(), LMCAS::detail::definite::ordered_partition_roots(), LMCAS::detail::definite::polynomial_sign_checked(), LMCAS::ode_root_detail::anonymous_namespace{ode_characteristic_roots.cpp}::quadratic_characteristic_roots(), LMCAS::detail::definite::rational_divergence_checked(), rational_root_factors(), rational_root_product(), LMCAS::anonymous_namespace{integration_rational_factorization.cpp}::rd_factor_piece(), LMCAS::anonymous_namespace{integration_rational_factorization.cpp}::rd_factor_quadratic(), reconstruct_rational_root_factors(), reconstruct_rational_roots(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::remember_isolations(), rootof_simplify(), roots(), roots(), LMCAS::detail::definite::roots_checked(), LMCAS::detail::inequality_support::select_open_intervals(), singular_frobenius_solution(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::solve(), solve_complex_nth_root_checked(), solve_complex_quadratic_checked(), solve_euler_ode_impl(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::solve_exact_polynomial_inequality_impl(), solve_exact_polynomial_set(), solve_higher_order_ode_impl(), solve_linear2_homogeneous(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::solve_real_quadratic() , 以及 LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::sort_exact_inequality_roots().

函数调用图:

这是这个函数的调用关系图:

roots() [2/2]

ExprSetResult LMCAS::roots	(	const ExprPtr &	expression,
		const std::string &	variable,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 87 行定义.

                                                 {
    ComputationContext context;
    return roots(expression, variable, context, options);
}

引用了 context, options, roots() , 以及 variable.

函数调用图:

roots_equal()

bool LMCAS::detail::inequality_support::roots_equal	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

在文件 inequality_solver_ordering.cpp 第 118 行定义.

                                                                                    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!a || !b) {
        return false;
    }
    auto numeric_a = try_checked_numeric_constant(*a, context);
    auto numeric_b = try_checked_numeric_constant(*b, context);
    if (numeric_a && numeric_b) {
        return *numeric_a == *numeric_b;
    }
    auto difference = SymbolicExpr::add(
        a,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), b));
    auto simplified = difference ? detail::make_expression_ptr(detail::normalize_node(detail::node(difference), transform_budget)) : nullptr;
    return simplified && simplified->is_zero();
}

round() [1/2]

ExprResult LMCAS::round

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 194 行定义.

                                            {
    ComputationContext context;
    return round(expression, context);
}

引用了 context , 以及 round().

函数调用图:

round() [2/2]

ExprResult LMCAS::round	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 189 行定义.

                                                                         {
    return make_unary_function_expr(expression, context, "round",
                                    FunctionNode::FuncType::Round);
}

引用了 context, LMCAS::expr_detail::expr_common::make_unary_function_expr(), LMCAS::FunctionNode::Round , 以及 round().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::refine_projection_interval(), LMCAS::Irrational::EnclosureRound::refine_sign(), round(), round() , 以及 LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_projection_intervals().

函数调用图:

这是这个函数的调用关系图:

scalar_project()

VectorCalculusExprResult LMCAS::scalar_project	(	const VectorField &	a,
		const VectorField &	b )

在文件 vector_calculus_algebra.cpp 第 185 行定义.

                                                                                        {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "scalar_project");
    return scalar_project_impl(a, b, transform_budget);
} catch (const CasError& error) {
    return VectorCalculusExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
        "vector calculus allocation failed", "scalar_project");
} catch (const std::length_error& error) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), "scalar_project");
} catch (const std::exception& error) {
    return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, error.what(), "scalar_project");
}

引用了 a, b, context, scalar_project() , 以及 scalar_project_impl().

被这些函数引用 scalar_project().

函数调用图:

这是这个函数的调用关系图:

scalar_project_impl()

VectorCalculusExprResult LMCAS::scalar_project_impl ( const VectorField & a, const VectorField & b, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_algebra.cpp 第 84 行定义.

{
    auto bb_result = dot_product_impl(b, b, transform_budget);
    if (!bb_result) return bb_result;
    auto bb = bb_result.value();
    if (LMCAS::detail::node(bb) && LMCAS::detail::node(bb)->is_zero()) {
        return VectorCalculusExprResult::success(nullptr);
    }
    auto ab_result = dot_product_impl(a, b, transform_budget);
    if (!ab_result) return ab_result;
    return VectorCalculusExprResult::success(
        detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(ab_result.value(), SymbolicExpr::sqrt(bb))), transform_budget)));
}

引用了 a, b, dot_product_impl(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), scalar_project_impl() , 以及 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success().

被这些函数引用 scalar_project() , 以及 scalar_project_impl().

函数调用图:

这是这个函数的调用关系图:

scale_integral_field()

detail::SymbolicNodePtr LMCAS::scale_integral_field ( const detail::SymbolicNodePtr & value, const detail::SymbolicNodePtr & coefficient, detail::RewriteBudget & budget )

static

在文件 integration_linearity.cpp 第 47 行定义.

                                 {
    detail::RewriteScope scope(&budget);
    if (const auto* piecewise = dynamic_cast<const PiecewiseNode*>(value.get())) {
        std::vector<PiecewiseNode::Branch> branches;
        branches.reserve(piecewise->branches().size());
        for (const auto& branch : piecewise->branches()) {
            branches.push_back({scale_integral_field(branch.expression, coefficient, budget),
                branch.condition});
        }
        auto fallback = piecewise->default_expr()
            ? scale_integral_field(piecewise->default_expr(), coefficient, budget) : nullptr;
        auto result = detail::make_node<PiecewiseNode>(std::move(branches), fallback);
        budget.measure(result);
        return result;
    }
    return detail::normalize_node(
        SymbolicFactory::create_multiply({coefficient, value}, &budget), budget);
}

引用了 LMCAS::SymbolicFactory::create_multiply(), LMCAS::detail::make_node(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::normalize_node(), scale_integral_field() , 以及 value.

被这些函数引用 scale_integral_field().

函数调用图:

这是这个函数的调用关系图:

separable_product()

bool LMCAS::separable_product ( const MultiplyNode & product, const std::string & x, const std::string & y )

static

在文件 ode_classification.cpp 第 34 行定义.

                                                                         {
    for (const auto& factor : product.operands()) {
        bool fx = expression_depends_on_variable(factor, x);
        bool fy = expression_depends_on_variable(factor, y);
        if (fx && fy) {
            return false;
        }
    }
    return true;
}

引用了 expression_depends_on_variable(), LMCAS::MultiplyNode::operands() , 以及 separable_product().

被这些函数引用 is_separable() , 以及 separable_product().

函数调用图:

这是这个函数的调用关系图:

separable_reciprocal()

bool LMCAS::separable_reciprocal ( const PowerNode & power, const std::string & x, const std::string & y )

static

在文件 ode_classification.cpp 第 46 行定义.

                                                                    {
    auto exponent = std::dynamic_pointer_cast<const NumberNode>(power.exponent());
    if (!exponent) {
        return false;
    }
    double value = try_eval_double(LMCAS::detail::make_expression_ptr(power.exponent()));
    int equal;
    lmmc_double_nearly_equal_tol(value, -1.0, 1e-12, 1e-12, &equal);
    if (!equal) {
        return false;
    }
    bool base_x = expression_depends_on_variable(power.base(), x);
    bool base_y = expression_depends_on_variable(power.base(), y);
    return (base_x && !base_y) || (!base_x && base_y);
}

引用了 LMCAS::PowerNode::base(), e(), exponent, LMCAS::PowerNode::exponent(), expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), separable_reciprocal(), try_eval_double() , 以及 value.

被这些函数引用 is_separable() , 以及 separable_reciprocal().

函数调用图:

这是这个函数的调用关系图:

sequence_extreme_limit()

ExpressionResult LMCAS::sequence_extreme_limit ( const std::shared_ptr< SymbolicExpr > & a_n, const std::string & n, bool upper, ComputationContext & context )

static

在文件 series_sequence_limits.cpp 第 120 行定义.

                                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::shared_ptr<SymbolicExpr> remainder;
    if (series_extract_alternating(detail::node(a_n), n, remainder)) {
        return alternating_sequence_bound(remainder, n, upper, context);
    }
    auto limited = limit_expression_checked(
        a_n, n, SymbolicExpr::infinity(),
        LimitDirection::Both, context);
    if (!limited) {
        return limited;
    }
    auto limit = std::move(limited.value());
    auto simplified = limit ? detail::make_expression_ptr(detail::normalize_node(detail::node(limit), transform_budget)) : nullptr;
    return ExpressionResult::success(
        simplified ? std::move(simplified) : std::move(limit));
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "sequence_extreme_limit");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "sequence_extreme_limit");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "sequence_extreme_limit");
}

引用了 alternating_sequence_bound(), Both, context, limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), sequence_extreme_limit(), series_extract_alternating(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 upper.

被这些函数引用 lim_inf_checked(), lim_sup_checked() , 以及 sequence_extreme_limit().

函数调用图:

这是这个函数的调用关系图:

series_abs()

std::shared_ptr< SymbolicExpr > LMCAS::series_abs ( const std::shared_ptr< SymbolicExpr > & expr, ComputationContext & context )

static

在文件 series_sequence_limits.cpp 第 67 行定义.

                                                                                                                    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expr) {
        return nullptr;
    }
    return detail::make_expression_ptr(detail::normalize_node(LMCAS::detail::make_node<FunctionNode>(FunctionNode::FuncType::Abs,
        std::vector<std::shared_ptr<const SymbolicNode>>{LMCAS::detail::node(expr)}), transform_budget));
}

引用了 LMCAS::FunctionNode::Abs, context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 series_abs().

被这些函数引用 alternating_sequence_bound() , 以及 series_abs().

函数调用图:

这是这个函数的调用关系图:

series_extract_alternating()

bool LMCAS::series_extract_alternating ( const std::shared_ptr< const SymbolicNode > & node, const std::string & n, std::shared_ptr< SymbolicExpr > & remainder )

static

在文件 series_sequence_limits.cpp 第 46 行定义.

                                                                {
    if (is_alternating_factor(node, n)) {
        remainder = SymbolicExpr::number(1);
        return true;
    }
    auto product = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!product) {
        return false;
    }
    for (size_t i = 0; i < product->operands().size(); ++i) {
        if (is_alternating_factor(product->operands()[i], n)) {
            remainder = product_without_factor(*product, i);
            return true;
        }
    }
    return false;
}

引用了 is_alternating_factor(), product_without_factor() , 以及 series_extract_alternating().

被这些函数引用 sequence_extreme_limit() , 以及 series_extract_alternating().

函数调用图:

这是这个函数的调用关系图:

series_get_double()

double LMCAS::detail::series_support::series_get_double

(

const std::shared_ptr< SymbolicExpr > &

expression

)

在文件 series_convergence.cpp 第 33 行定义.

                                                                  {
    if (!expr || !LMCAS::detail::node(expr)) {
        return 0.0;
    }
    auto num = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(expr));
    if (!num) {
        return 0.0;
    }
    return series_number_value(*num);
}

series_index_variable()

bool LMCAS::series_index_variable ( const std::shared_ptr< const VariableNode > & variable, const std::string & index_var )

static

在文件 series_convergence.cpp 第 72 行定义.

                                                              {
    return variable && !variable->is_constant() && variable->name() == index_var;
}

引用了 series_index_variable() , 以及 variable.

被这些函数引用 coefficient_power_radius() , 以及 series_index_variable().

函数调用图:

这是这个函数的调用关系图:

series_is_infinity() [1/2]

bool LMCAS::detail::series_support::series_is_infinity

(

const std::shared_ptr< SymbolicExpr > &

expression

)

在文件 series_convergence.cpp 第 44 行定义.

                                                                 {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr));
    if (func && func->type() == FunctionNode::FuncType::Infinity) {
        return true;
    }
    if (series_is_number(expr)) {
        return std::isinf(series_get_double(expr));
    }
    return false;
}

被这些函数引用 alternating_sequence_bound().

这是这个函数的调用关系图:

series_is_infinity() [2/2]

bool LMCAS::detail::series_support::series_is_infinity

(

const std::shared_ptr< SymbolicExpr > &

expression

)

在文件 series_convergence.cpp 第 44 行定义.

                                                                 {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    auto func = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(expr));
    if (func && func->type() == FunctionNode::FuncType::Infinity) {
        return true;
    }
    if (series_is_number(expr)) {
        return std::isinf(series_get_double(expr));
    }
    return false;
}

series_is_number()

bool LMCAS::detail::series_support::series_is_number

(

const std::shared_ptr< SymbolicExpr > &

expression

)

在文件 series_convergence.cpp 第 26 行定义.

                                                               {
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    return expr->is_number();
}

series_negate()

std::shared_ptr< SymbolicExpr > LMCAS::series_negate ( const std::shared_ptr< SymbolicExpr > & expr, ComputationContext & context )

static

在文件 series_sequence_limits.cpp 第 78 行定义.

                                                                                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!expr) {
        return nullptr;
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(SymbolicExpr::number(-1), expr)), transform_budget));
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 series_negate().

被这些函数引用 alternating_sequence_bound() , 以及 series_negate().

函数调用图:

这是这个函数的调用关系图:

series_number_value()

double LMCAS::detail::series_support::series_number_value

(

const NumberNode &

number

)

在文件 series_convergence.cpp 第 19 行定义.

                                                     {
    if (std::holds_alternative<BigInt>(number.value())) {
        return std::get<BigInt>(number.value()).to_double();
    }
    return std::get<Rational>(number.value()).to_double();
}

set_eqv_budget()

Result< void > LMCAS::set_eqv_budget	(	EqvOptions &	options,
		std::size_t	steps,
		std::size_t	depth,
		std::size_t	growth )

在文件 equivalence_options.cpp 第 65 行定义.

                                              {
    EqvOptions candidate = options;
    candidate.budget.max_rewrite_steps = steps;
    candidate.budget.max_rewrite_depth = depth;
    candidate.budget.max_node_growth_factor = growth;
    auto valid = equivalence_detail::validate_eqv_options(candidate);
    if (!valid) {
        return valid;
    }
    options = candidate;
    return Result<void>::success();
}

引用了 LMCAS::EqvOptions::budget, depth, growth, LMCAS::EqvBudget::max_node_growth_factor, LMCAS::EqvBudget::max_rewrite_depth, LMCAS::EqvBudget::max_rewrite_steps, options, set_eqv_budget(), steps, LMCAS::Result< T >::success() , 以及 LMCAS::equivalence_detail::validate_eqv_options().

被这些函数引用 set_eqv_budget().

函数调用图:

这是这个函数的调用关系图:

set_eqv_profile()

Result< void > LMCAS::set_eqv_profile	(	EqvOptions &	options,
		const std::string &	name )

在文件 equivalence_options.cpp 第 55 行定义.

                                                    {
    auto profile = eqv_profile_from_name(name);
    if (!profile) {
        return Result<void>::failure(profile.error());
    }
    options.profile = profile.value();
    return Result<void>::success();
}

引用了 eqv_profile_from_name(), LMCAS::Result< T >::failure(), name, options, set_eqv_profile() , 以及 LMCAS::Result< T >::success().

被这些函数引用 __attribute__() , 以及 set_eqv_profile().

函数调用图:

这是这个函数的调用关系图:

simplify() [1/2]

ExprResult LMCAS::simplify

(

const ExprPtr &

expression

)

在文件 expr_transform.cpp 第 22 行定义.

                                               {
    ComputationContext context;
    return simplify(expression, context);
}

引用了 context , 以及 simplify().

函数调用图:

simplify() [2/2]

ExprResult LMCAS::simplify	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_transform.cpp 第 18 行定义.

                                                                            {
    return detail::simplify_expression(expression, context);
}

引用了 context, simplify() , 以及 LMCAS::detail::simplify_expression().

被这些函数引用 LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_exponent(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_general_expression(), simplify() , 以及 simplify().

函数调用图:

这是这个函数的调用关系图:

simplify_finite_limit()

bool LMCAS::simplify_finite_limit ( std::shared_ptr< SymbolicExpr > & value, ComputationContext & context )

static

在文件 calculus_asymptotes.cpp 第 317 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (value) {
        value = detail::make_expression_ptr(detail::normalize_node(detail::node(value), transform_budget));
    }
    return value && !calculus_utils_is_infinity(value);
}

引用了 LMCAS::calculus_utils_detail::calculus_utils_is_infinity(), context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), simplify_finite_limit() , 以及 value.

被这些函数引用 collect_infinite_asymptotes() , 以及 simplify_finite_limit().

函数调用图:

这是这个函数的调用关系图:

simplify_pythagorean_sum()

std::shared_ptr< const SymbolicNode > LMCAS::simplify_pythagorean_sum ( const AddNode & sum, const std::string & var )

static

在文件 transcendental_pythagorean.cpp 第 141 行定义.

                                              {
    std::vector<std::shared_ptr<const SymbolicNode>> operands;
    operands.reserve(sum.operands().size());
    for (const auto& operand : sum.operands()) {
        operands.push_back(tf_simplify_pythagorean_node(operand, var));
    }
    std::vector<bool> consumed(operands.size(), false);
    std::vector<std::shared_ptr<const SymbolicNode>> result;
    for (std::size_t i = 0; i < operands.size(); ++i) {
        if (consumed[i]) {
            continue;
        }
        TrigSquare square;
        if (!tf_extract_coeff_trig_squared(
                operands[i], square.coefficient, square.type, square.argument)) {
            result.push_back(operands[i]);
            continue;
        }
        const auto partner = find_complementary_square(operands, consumed, i + 1, square);
        if (partner == operands.size()) {
            result.push_back(operands[i]);
            continue;
        }
        consumed[i] = true;
        consumed[partner] = true;
        if (square.coefficient) {
            result.push_back(square.coefficient);
        } else {
            result.push_back(LMCAS::detail::make_node<NumberNode>(BigInt(1)));
        }
    }
    if (result.empty()) {
        return LMCAS::detail::make_node<NumberNode>(BigInt(0));
    }
    if (result.size() == 1) {
        return result[0];
    }
    return LMCAS::detail::make_node<AddNode>(std::move(result));
}

引用了 LMCAS::TrigSquare::argument, LMCAS::TrigSquare::coefficient, find_complementary_square(), LMCAS::detail::make_node(), LMCAS::AddNode::operands(), simplify_pythagorean_sum(), tf_extract_coeff_trig_squared(), tf_simplify_pythagorean_node() , 以及 LMCAS::TrigSquare::type.

被这些函数引用 simplify_pythagorean_sum() , 以及 tf_simplify_pythagorean_node().

函数调用图:

这是这个函数的调用关系图:

sin() [1/2]

ExprResult LMCAS::sin

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 45 行定义.

                                          {
    ComputationContext context;
    return sin(expression, context);
}

引用了 context , 以及 sin().

函数调用图:

sin() [2/2]

ExprResult LMCAS::sin	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 38 行定义.

                                                                       {
    auto valid = require_dimensionless(expression, "sin");
    if (!valid) { return valid; }
    return make_unary_math_expr(expression, context, "sin",
                                SymbolicExpr::sin);
}

引用了 context, LMCAS::expr_detail::expr_common::make_unary_math_expr(), LMCAS::expr_detail::expr_common::require_dimensionless() , 以及 sin().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), sin() , 以及 sin().

函数调用图:

这是这个函数的调用关系图:

singular_frobenius_solution()

FrobeniusSolutionResult LMCAS::singular_frobenius_solution ( const std::shared_ptr< SymbolicExpr > & p, const std::shared_ptr< SymbolicExpr > & q, const std::shared_ptr< SymbolicExpr > & x0, const std::string & x, const std::shared_ptr< SymbolicExpr > & x_minus_x0, FrobeniusSolution result, ComputationContext & context )

static

在原定义域内确认去心极限有限后约分，提取可去奇点解析延拓的 Taylor 系数。

注解

原乘积未经约分的导数仍含缺失点，不能直接用于系数计算。

在文件 ode_frobenius.cpp 第 324 行定义.

                                                               {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto xp_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(x_minus_x0, p)), transform_budget));
    auto x2q_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
        SymbolicExpr::power(x_minus_x0, SymbolicExpr::number(2)), q)), transform_budget));
 
    auto P0_result = limit_expression_checked(
        xp_expr, x, x0, LimitDirection::Both, context);
    if (!P0_result) {
        return FrobeniusSolutionResult::failure(P0_result.error());
    }
    auto Q0_result = limit_expression_checked(
        x2q_expr, x, x0, LimitDirection::Both, context);
    if (!Q0_result) {
        return FrobeniusSolutionResult::failure(Q0_result.error());
    }
    auto P0_expr = std::move(P0_result.value());
    auto Q0_expr = std::move(Q0_result.value());
 
    double P0 = P0_expr
        ? try_eval_double(P0_expr)
        : std::numeric_limits<double>::quiet_NaN();
    double Q0 = Q0_expr
        ? try_eval_double(Q0_expr)
        : std::numeric_limits<double>::quiet_NaN();
    if (!std::isfinite(P0) || !std::isfinite(Q0)) {
        return FrobeniusSolutionResult::failure(frobenius_unsupported_numeric());
    }
    /**
     * @brief 在原定义域内确认去心极限有限后约分，提取可去奇点解析延拓的 Taylor 系数。
     * @note 原乘积未经约分的导数仍含缺失点，不能直接用于系数计算。
     */
    xp_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(xp_expr->cancel()), transform_budget));
    x2q_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(x2q_expr->cancel()), transform_budget));
 
    auto roots = frobenius_indicial_roots(P0, Q0);
    if (!roots) {
        return FrobeniusSolutionResult::failure(roots.error());
    }
    const double r1 = roots.value().first;
    result.indicial_roots = {r1, roots.value().second};
    auto coefficients = singular_taylor_coefficients(
        xp_expr, x2q_expr, x0, x, result.truncation_order, P0, Q0, context);
    if (!coefficients) {
        return FrobeniusSolutionResult::failure(coefficients.error());
    }
    auto recurrence = singular_series_recurrence(
        coefficients.value(), P0, Q0, r1, result.truncation_order);
    if (!recurrence) {
        return FrobeniusSolutionResult::failure(recurrence.error());
    }
    auto power_prefix = SymbolicExpr::power(x_minus_x0, SymbolicExpr::number(r1));
    auto series_part = assemble_frobenius_polynomial(recurrence.value(), x_minus_x0);
    result.series_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(power_prefix, series_part)), transform_budget));
    return result;
} catch (const CasError& error) {
    return FrobeniusSolutionResult::failure(error);
} catch (const std::bad_alloc&) {
    return FrobeniusSolutionResult::failure(CasErrc::ResourceLimit, "allocation failed", "singular_frobenius_solution");
} catch (const std::length_error& error) {
    return FrobeniusSolutionResult::failure(CasErrc::ResourceLimit, error.what(), "singular_frobenius_solution");
} catch (const std::exception& error) {
    return FrobeniusSolutionResult::failure(CasErrc::InternalInvariant, error.what(), "singular_frobenius_solution");
}

引用了 assemble_frobenius_polynomial(), Both, context, LMCAS::Result< T >::error(), LMCAS::Result< FrobeniusSolution >::failure(), frobenius_indicial_roots(), frobenius_unsupported_numeric(), LMCAS::FrobeniusSolution::indicial_roots, limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), roots(), LMCAS::FrobeniusSolution::series_solution, singular_frobenius_solution(), singular_series_recurrence(), singular_taylor_coefficients(), LMCAS::FrobeniusSolution::truncation_order, try_eval_double() , 以及 LMCAS::Result< T >::value().

被这些函数引用 singular_frobenius_solution() , 以及 solve_frobenius_impl().

函数调用图:

这是这个函数的调用关系图:

singular_series_recurrence()

Result< std::vector< double > > LMCAS::singular_series_recurrence ( const OdeTaylorCoefficients & coefficients, double P0, double Q0, double r1, int order )

static

递推 a_n = -1/F(r1+n) * ∑_{k=0}^{n-1} [(r1+k)·p_{n-k} + q_{n-k}]·a_k。

注解

F(s) = s(s-1) + P₀·s + Q₀。

在文件 ode_frobenius.cpp 第 249 行定义.

                                                {
    const auto& pn_coeffs = coefficients.p;
    const auto& qn_coeffs = coefficients.q;
    /**
     * @brief 递推 a_n = -1/F(r1+n) * ∑_{k=0}^{n-1} [(r1+k)·p_{n-k} + q_{n-k}]·a_k。
     * @note F(s) = s(s-1) + P₀·s + Q₀。
     */
    auto indicial_poly = [&](double s) -> double {
        return s * (s - 1.0) + P0 * s + Q0;
    };
 
    std::vector<double> a(order + 1, 0.0);
    a[0] = 1.0;
 
    for (int n_idx = 1; n_idx <= order; ++n_idx) {
        double F_val = indicial_poly(r1 + n_idx);
        if (!std::isfinite(F_val)) {
            return Result<std::vector<double>>::failure(frobenius_arithmetic_failure());
        }
        if (std::abs(F_val) < 1e-15) {
            a[n_idx] = 0.0;
            continue;
        }
        double sum = 0.0;
        for (int k = 0; k < n_idx; ++k) {
            int idx = n_idx - k;
            if (idx > order) {
                continue;
            }
            double p_term = (idx < static_cast<int>(pn_coeffs.size())) ? pn_coeffs[idx] : 0.0;
            double q_term = (idx < static_cast<int>(qn_coeffs.size())) ? qn_coeffs[idx] : 0.0;
            sum += ((r1 + k) * p_term + q_term) * a[k];
        }
        a[n_idx] = -sum / F_val;
        if (!std::isfinite(a[n_idx])) {
            return Result<std::vector<double>>::failure(frobenius_arithmetic_failure());
        }
    }
 
    return a;
}

引用了 a, e(), frobenius_arithmetic_failure(), order, LMCAS::OdeTaylorCoefficients::p, LMCAS::OdeTaylorCoefficients::q , 以及 singular_series_recurrence().

被这些函数引用 singular_frobenius_solution() , 以及 singular_series_recurrence().

函数调用图:

这是这个函数的调用关系图:

singular_taylor_coefficients()

Result< OdeTaylorCoefficients > LMCAS::singular_taylor_coefficients ( const std::shared_ptr< SymbolicExpr > & xp_expr, const std::shared_ptr< SymbolicExpr > & x2q_expr, const std::shared_ptr< SymbolicExpr > & x0, const std::string & x, int order, double P0, double Q0, ComputationContext & context )

static

在文件 ode_frobenius.cpp 第 183 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<double> pn_coeffs(order + 1, 0.0);
    std::vector<double> qn_coeffs(order + 1, 0.0);
 
    auto xp_current = xp_expr;
    auto x2q_current = x2q_expr;
    double fact = 1.0;
    for (int k = 0; k <= order; ++k) {
        if (k > 0) {
            fact *= k;
        }
        double pv, qv;
        if (k == 0) {
            pv = P0;
            qv = Q0;
        } else {
            auto pv_expr = detail::make_expression_ptr(detail::substitute_node(detail::node(xp_current), x, detail::node(x0), transform_budget));
            auto qv_expr = detail::make_expression_ptr(detail::substitute_node(detail::node(x2q_current), x, detail::node(x0), transform_budget));
            pv = try_eval_double(pv_expr);
            qv = try_eval_double(qv_expr);
 
            auto p_limit = frobenius_coefficient_limit(xp_current, x, x0, pv, context);
            if (!p_limit) {
                return Result<OdeTaylorCoefficients>::failure(p_limit.error());
            }
            pv = p_limit.value();
            auto q_limit = frobenius_coefficient_limit(x2q_current, x, x0, qv, context);
            if (!q_limit) {
                return Result<OdeTaylorCoefficients>::failure(q_limit.error());
            }
            qv = q_limit.value();
        }
        if (!std::isfinite(pv) || !std::isfinite(qv)) {
            return Result<OdeTaylorCoefficients>::failure(frobenius_unsupported_numeric());
        }
        pn_coeffs[k] = pv / fact;
        qn_coeffs[k] = qv / fact;
 
        xp_current = detail::make_expression_ptr(detail::differentiate_node(detail::node(xp_current), x, transform_budget));
        x2q_current = detail::make_expression_ptr(detail::differentiate_node(detail::node(x2q_current), x, transform_budget));
        if (!xp_current) {
            xp_current = SymbolicExpr::number(0);
        }
        if (!x2q_current) {
            x2q_current = SymbolicExpr::number(0);
        }
    }
 
    return OdeTaylorCoefficients{std::move(pn_coeffs), std::move(qn_coeffs)};
} catch (const CasError& error) {
    return Result<OdeTaylorCoefficients>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<OdeTaylorCoefficients>::failure(CasErrc::ResourceLimit, "allocation failed", "singular_taylor_coefficients");
} catch (const std::length_error& error) {
    return Result<OdeTaylorCoefficients>::failure(CasErrc::ResourceLimit, error.what(), "singular_taylor_coefficients");
} catch (const std::exception& error) {
    return Result<OdeTaylorCoefficients>::failure(CasErrc::InternalInvariant, error.what(), "singular_taylor_coefficients");
}

引用了 context, LMCAS::detail::differentiate_node(), LMCAS::Result< T >::failure(), frobenius_coefficient_limit(), frobenius_unsupported_numeric(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), order, singular_taylor_coefficients(), LMCAS::detail::substitute_node() , 以及 try_eval_double().

被这些函数引用 singular_frobenius_solution() , 以及 singular_taylor_coefficients().

函数调用图:

这是这个函数的调用关系图:

skew_lines_distance_checked() [1/2]

ExpressionResult LMCAS::skew_lines_distance_checked	(	const LineSymbolic &	l1,
		const LineSymbolic &	l2 )

在文件 symbolic_geometry_line.cpp 第 172 行定义.

  {
    ComputationContext context;
    return skew_lines_distance_checked(l1, l2, context);
}

引用了 context, l2 , 以及 skew_lines_distance_checked().

函数调用图:

skew_lines_distance_checked() [2/2]

ExpressionResult LMCAS::skew_lines_distance_checked	(	const LineSymbolic &	l1,
		const LineSymbolic &	l2,
		ComputationContext &	context )

在文件 symbolic_geometry_line.cpp 第 93 行定义.

  {
    const std::string operation = "skew_lines_distance";
    try {
        auto l1_valid = validate_line_checked(l1, context, operation);
        if (!l1_valid) {
            return ExpressionResult::failure(l1_valid.error());
        }
        auto l2_valid = validate_line_checked(l2, context, operation);
        if (!l2_valid) {
            return ExpressionResult::failure(l2_valid.error());
        }
        auto step = context.consume_steps(8, operation);
        if (!step) {
            return ExpressionResult::failure(step.error());
        }
 
        std::vector<double> direction1_values;
        std::vector<double> direction2_values;
        auto scale1 = numeric_vector_scale_checked(
            l1.direction, context, operation, &direction1_values);
        if (!scale1) {
            return ExpressionResult::failure(scale1.error());
        }
        auto scale2 = numeric_vector_scale_checked(
            l2.direction, context, operation, &direction2_values);
        if (!scale2) {
            return ExpressionResult::failure(scale2.error());
        }
 
        std::vector<std::shared_ptr<SymbolicExpr>> direction1;
        std::vector<std::shared_ptr<SymbolicExpr>> direction2;
        direction1.reserve(3);
        direction2.reserve(3);
        for (size_t i = 0; i < 3; ++i) {
            direction1.push_back(SymbolicExpr::number(
                direction1_values[i] / scale1.value()));
            direction2.push_back(SymbolicExpr::number(
                direction2_values[i] / scale2.value()));
        }
 
        std::vector<double> point1_values;
        std::vector<double> point2_values;
        auto difference_scale = point_difference_scale_checked(
            l1.point, l2.point, context, operation, point1_values, point2_values);
        if (!difference_scale) {
            return ExpressionResult::failure(difference_scale.error());
        }
        const double point_scale = difference_scale.value();
 
        std::vector<std::shared_ptr<SymbolicExpr>> a2_minus_a1;
        a2_minus_a1.reserve(3);
        for (size_t i = 0; i < l1.point.size(); ++i) {
            if (point_scale != 0.0) {
                a2_minus_a1.push_back(SymbolicExpr::number(
                    point2_values[i] / point_scale -
                    point1_values[i] / point_scale));
                continue;
            }
            a2_minus_a1.push_back(SymbolicExpr::add(
                l2.point[i],
                SymbolicExpr::multiply(
                    SymbolicExpr::number(-1), l1.point[i])));
        }
        return skew_distance_from_directions(
            direction1, direction2, a2_minus_a1, point_scale, context, operation);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                         "vector geometry allocation failed",
                                         operation);
    } catch (const std::exception& e) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                         e.what(), operation);
    }
}

引用了 context, LMCAS::LineSymbolic::direction, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, l2, LMCAS::geometry_detail::numeric_vector_scale_checked(), LMCAS::LineSymbolic::point, ResourceLimit, skew_lines_distance_checked() , 以及 LMCAS::geometry_detail::validate_line_checked().

被这些函数引用 skew_lines_distance_checked() , 以及 skew_lines_distance_checked().

函数调用图:

这是这个函数的调用关系图:

skip_ws()

size_t LMCAS::skip_ws ( const std::string & str, size_t pos )

static

在文件 interval_serialization.cpp 第 69 行定义.

                                                        {
    while (pos < str.size() && std::isspace(static_cast<unsigned char>(str[pos]))) {
        ++pos;
    }
    return pos;
}

引用了 skip_ws().

被这些函数引用 parse_approximate_atom(), parse_endpoint_value(), parse_interval_lower(), parse_interval_upper(), parse_single_interval() , 以及 skip_ws().

函数调用图:

这是这个函数的调用关系图:

solution_is_excluded()

Result< bool > LMCAS::solution_is_excluded ( const std::shared_ptr< SymbolicExpr > & solution, Domain domain, const AssumptionContext & ctx, const std::string & variable, ComputationContext & context )

static

在文件 solver_assumptions.cpp 第 185 行定义.

                                                                     {
    if (domain_requires_real(domain)) {
        if (const auto* root = dynamic_cast<const RootOfNode*>(detail::node(solution).get())) {
            auto isolated = detail::isolate_exact_root(
                root->exact_id(), context, "solve_with_assumptions");
            if (!isolated) return Result<bool>::failure(isolated.error());
            if (std::holds_alternative<detail::ComplexIsolation>(isolated.value())) {
                return true;
            }
        } else if (solver_detail::contains_imaginary(solution)) {
            return true;
        }
    }
    if (exact_radical_domain_excludes(detail::node(solution).get(), domain)) {
        return true;
    }
    double value = 0.0;
    if (!try_get_numeric_value(solution, value)) {
        return false;
    }
    if (numeric_domain_excludes(value, domain)) {
        return true;
    }
    return numeric_sign_excludes(value, ctx, variable);
}

引用了 LMCAS::solver_detail::contains_imaginary(), context, domain, domain_requires_real(), exact_radical_domain_excludes(), LMCAS::Result< T >::failure(), LMCAS::detail::isolate_exact_root(), LMCAS::detail::node(), numeric_domain_excludes(), numeric_sign_excludes(), solution_is_excluded(), value , 以及 variable.

被这些函数引用 solution_is_excluded() , 以及 solve_with_assumptions_impl().

函数调用图:

这是这个函数的调用关系图:

solve() [1/2]

ExprSetResult LMCAS::solve	(	const ExprPtr &	equation,
		const std::string &	variable,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 94 行定义.

                                                 {
    return solve_expr_set(equation, variable, context, options);
}

引用了 context, options, solve(), solve_expr_set() , 以及 variable.

被这些函数引用 solve() , 以及 solve().

函数调用图:

这是这个函数的调用关系图:

solve() [2/2]

ExprSetResult LMCAS::solve	(	const ExprPtr &	equation,
		const std::string &	variable,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 101 行定义.

                                                 {
    ComputationContext context;
    return solve(equation, variable, context, options);
}

引用了 context, options, solve() , 以及 variable.

函数调用图:

solve_bernoulli_ode_checked() [1/2]

ODESolutionResult LMCAS::solve_bernoulli_ode_checked	(	const std::shared_ptr< SymbolicExpr > &	P,
		const std::shared_ptr< SymbolicExpr > &	Q,
		int	n,
		const std::string &	x,
		const std::string &	y )

在文件 ode_first_order.cpp 第 238 行定义.

{
    ComputationContext context;
    return solve_bernoulli_ode_checked(P, Q, n, x, y, context);
}

引用了 context , 以及 solve_bernoulli_ode_checked().

函数调用图:

solve_bernoulli_ode_checked() [2/2]

ODESolutionResult LMCAS::solve_bernoulli_ode_checked	(	const std::shared_ptr< SymbolicExpr > &	P,
		const std::shared_ptr< SymbolicExpr > &	Q,
		int	n,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context )

在文件 ode_first_order.cpp 第 196 行定义.

{
    const std::string operation = "solve_bernoulli_ode";
    auto valid = validate_ode_pair_var_pair(P, Q, x, y, context, operation);
    if (!valid) {
        return ODESolutionResult::failure(valid.error());
    }
    if (n == 0 || n == 1) {
        return ODESolutionResult::failure(CasErrc::InvalidArgument,
                                          "Bernoulli exponent must not be 0 or 1",
                                          operation);
    }
    auto step = context.consume_steps(14, operation);
    if (!step) {
        return ODESolutionResult::failure(step.error());
    }
 
    try {
        auto solved = solve_bernoulli_ode_impl(P, Q, n, x, y, context);
        if (!solved) { return solved; }
        return wrap_ode_solution(std::move(solved.value()), ODEType::Bernoulli, operation);
    } catch (const CasError& error) {
        return ODESolutionResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ODESolutionResult::failure(CasErrc::ResourceLimit,
                                          "Bernoulli ODE allocation failed",
                                          operation);
    } catch (const std::length_error& error) {
        return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return ODESolutionResult::failure(CasErrc::InternalInvariant,
                                          e.what(),
                                          operation);
    }
}

引用了 Bernoulli, context, e(), LMCAS::Result< ODESolution >::failure(), InternalInvariant, InvalidArgument, ResourceLimit, solve_bernoulli_ode_checked(), solve_bernoulli_ode_impl(), validate_ode_pair_var_pair() , 以及 wrap_ode_solution().

被这些函数引用 solve_bernoulli_ode_checked() , 以及 solve_bernoulli_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_bernoulli_ode_impl()

ODESolutionResult LMCAS::solve_bernoulli_ode_impl ( const std::shared_ptr< SymbolicExpr > & P, const std::shared_ptr< SymbolicExpr > & Q, int n, const std::string & x, const std::string & , ComputationContext & context )

static

Bernoulli 方程: y' + P(x)*y = Q(x)*y^n (n != 0, 1) 令 v = y^(1-n),则 v' = (1-n)*y^(-n)*y' 从原方程: y' = -P(x)*y + Q(x)*y^n 两边乘以 (1-n)*y^(-n): (1-n)*y^(-n)*y' = (1-n)*(-P(x)*y^(1-n) + Q(x)) v' = (1-n)*(-P(x)*v + Q(x)) v' + (1-n)*P(x)*v = (1-n)*Q(x) 这是关于 v 的一阶线性 ODE

线性 ODE 的系数: P_linear = (1-n)*P(x), Q_linear = (1-n)*Q(x)

用积分因子法求解线性 ODE: v' + P_linear*v = Q_linear 积分因子 mu = exp(integralP_linear dx)

回代: v = y^(1-n),所以 y = v^(1/(1-n)) y^(1-n) = v_solution y = v_solution^(1/(1-n))

在文件 ode_first_order.cpp 第 249 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    ODESolution result;
    result.method_used = ODEType::Bernoulli;
    result.constants = {"C"};
 
    /// Bernoulli 方程: y' + P(x)*y = Q(x)*y^n  (n != 0, 1)
    /// 令 v = y^(1-n),则 v' = (1-n)*y^(-n)*y'
    /// 从原方程: y' = -P(x)*y + Q(x)*y^n
    /// 两边乘以 (1-n)*y^(-n):
    ///   (1-n)*y^(-n)*y' = (1-n)*(-P(x)*y^(1-n) + Q(x))
    ///   v' = (1-n)*(-P(x)*v + Q(x))
    ///   v' + (1-n)*P(x)*v = (1-n)*Q(x)
    /// 这是关于 v 的一阶线性 ODE
 
    int one_minus_n = 1 - n;
    auto coeff = SymbolicExpr::number(one_minus_n);
 
    /// 线性 ODE 的系数: P_linear = (1-n)*P(x), Q_linear = (1-n)*Q(x)
    auto P_linear = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(coeff, P)->cancel()), transform_budget));
    auto Q_linear = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(coeff, Q)->cancel()), transform_budget));
 
    /// 用积分因子法求解线性 ODE: v' + P_linear*v = Q_linear
    /// 积分因子 mu = exp(integralP_linear dx)
    Integrator integrator;
    auto integrated_p = integrator.integrate_checked(*P_linear, x, context);
    if (!integrated_p) { return ODESolutionResult::failure(integrated_p.error()); }
    auto intP = std::make_shared<SymbolicExpr>(std::move(integrated_p.value()));
    auto mu = integrating_factor_from_antiderivative(intP, x, context);
    auto Q_mu = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(Q_linear, mu)->cancel()), transform_budget));
    auto integrated_q = integrator.integrate_checked(*Q_mu, x, context);
    if (!integrated_q) { return ODESolutionResult::failure(integrated_q.error()); }
    auto int_Q_mu = std::make_shared<SymbolicExpr>(std::move(integrated_q.value()));
 
    auto C_const = SymbolicExpr::variable("C");
    auto numerator = SymbolicExpr::add(int_Q_mu, C_const);
    auto v_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(numerator, mu)), transform_budget));
 
    /// 回代: v = y^(1-n),所以 y = v^(1/(1-n))
    /// y^(1-n) = v_solution
    /// y = v_solution^(1/(1-n))
    auto exponent = SymbolicExpr::divide(
        SymbolicExpr::number(1),
        SymbolicExpr::number(one_minus_n));
    auto y_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::power(v_solution, exponent)), transform_budget));
 
    result.general_solution = y_solution;
    return ODESolutionResult::success(std::move(result));
}

引用了 Bernoulli, LMCAS::ODESolution::constants, context, exponent, LMCAS::Result< ODESolution >::failure(), LMCAS::ODESolution::general_solution, integrating_factor_from_antiderivative(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_bernoulli_ode_impl() , 以及 LMCAS::Result< ODESolution >::success().

被这些函数引用 solve_bernoulli_ode_checked() , 以及 solve_bernoulli_ode_impl().

函数调用图:

这是这个函数的调用关系图:

solve_biquadratic()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_biquadratic	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::string &	variable )

在文件 solve_polynomial_quadratic.cpp 第 86 行定义.

                               {
    ComputationContext context;
    return solve_biquadratic_impl(a, b, c, variable, context);
}

引用了 a, b, c, context, solve_biquadratic(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl() , 以及 variable.

被这些函数引用 solve_biquadratic().

函数调用图:

这是这个函数的调用关系图:

solve_by_factoring()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_by_factoring	(	const Polynomial< SymbolicPolyCoeff > &	poly,
		const std::string &	variable )

在文件 solve_polynomial.cpp 第 124 行定义.

                                                                          {
    ComputationContext context;
    return solve_by_factoring_impl(poly, variable, context);
}

引用了 context, solve_by_factoring(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl() , 以及 variable.

被这些函数引用 solve_by_factoring().

函数调用图:

这是这个函数的调用关系图:

solve_closed_form_from_poly()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_closed_form_from_poly ( const Polynomial< SymbolicPolyCoeff > & poly, const std::string & var, ComputationContext & context )

static

在文件 root_of_utils.cpp 第 14 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    int deg = poly.degree();
    if (deg <= 0) return {};
 
    auto get_coeff = [&](int d) -> std::shared_ptr<SymbolicExpr> {
        if (d < 0 || d > deg) return SymbolicExpr::number(0);
        return poly.coeffs[d].val ? poly.coeffs[d].val : SymbolicExpr::number(0);
    };
 
    if (deg == 1) {
 
        auto a = get_coeff(1);
        auto b = get_coeff(0);
        auto neg_b = SymbolicExpr::multiply(b, SymbolicExpr::number(-1));
        return { detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(neg_b, a)), transform_budget)) };
    } else if (deg == 2) {
        auto a = get_coeff(2);
        auto b = get_coeff(1);
        auto c = get_coeff(0);
 
        auto b2 = SymbolicExpr::power(b, SymbolicExpr::number(2));
        auto four_ac = SymbolicExpr::multiply(SymbolicExpr::number(4), SymbolicExpr::multiply(a, c));
        auto delta = SymbolicExpr::add(b2, SymbolicExpr::multiply(four_ac, SymbolicExpr::number(-1)));
        auto sqrt_delta = SymbolicExpr::sqrt(delta);
        auto neg_b = SymbolicExpr::multiply(b, SymbolicExpr::number(-1));
        auto two_a = SymbolicExpr::multiply(SymbolicExpr::number(2), a);
 
        auto x1 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(SymbolicExpr::add(neg_b, sqrt_delta), two_a)), transform_budget));
        auto x2 = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(SymbolicExpr::add(neg_b, SymbolicExpr::multiply(sqrt_delta, SymbolicExpr::number(-1))), two_a)), transform_budget));
        return { x1, x2 };
    } else if (deg == 3) {
        auto a = get_coeff(3);
        auto b = get_coeff(2);
        auto c = get_coeff(1);
        auto d = get_coeff(0);
        return solve_cubic(a, b, c, d, var);
    } else if (deg == 4) {
        auto a = get_coeff(4);
        auto b = get_coeff(3);
        auto c = get_coeff(2);
        auto d = get_coeff(1);
        auto e = get_coeff(0);
        return solve_quartic(a, b, c, d, e, var);
    }
 
    return {};
}

引用了 a, b, c, LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), e(), get_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_closed_form_from_poly(), solve_cubic() , 以及 solve_quartic().

被这些函数引用 rootof_simplify() , 以及 solve_closed_form_from_poly().

函数调用图:

这是这个函数的调用关系图:

solve_closed_form_poly()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_closed_form_poly ( const Polynomial< SymbolicPolyCoeff > & poly, const std::string & var, ComputationContext & context )

static

在文件 solve_polynomial.cpp 第 14 行定义.

{
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    int deg = poly.degree();
    if (deg <= 0) return {};
 
    auto get_coeff = [&](int d) -> std::shared_ptr<SymbolicExpr> {
        if (d < 0 || d > deg) return SymbolicExpr::number(0);
        return poly.coeffs[d].val ? poly.coeffs[d].val : SymbolicExpr::number(0);
    };
 
    if (deg == 1) {
        auto a = get_coeff(1);
        auto b = get_coeff(0);
        auto neg_b = SymbolicExpr::multiply(b, SymbolicExpr::number(-1));
        return { detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(neg_b, a)), transform_budget)) };
    } else if (deg == 2) {
        return solve_quadratic_internal(get_coeff(2), get_coeff(1), get_coeff(0), context);
    } else if (deg == 3) {
        return solve_cubic_impl(get_coeff(3), get_coeff(2), get_coeff(1), get_coeff(0), var, context);
    } else if (deg == 4) {
        return solve_quartic_impl(get_coeff(4), get_coeff(3), get_coeff(2), get_coeff(1), get_coeff(0), var, context);
    }
 
    return {};
}

引用了 a, b, LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), get_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_closed_form_poly(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), LMCAS::polynomial_solver_detail::solve_quadratic_internal() , 以及 LMCAS::polynomial_solver_detail::solve_quartic_impl().

被这些函数引用 append_factor_solutions(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl() , 以及 solve_closed_form_poly().

函数调用图:

这是这个函数的调用关系图:

solve_complex_nth_root_checked() [1/2]

ComplexRootsResult LMCAS::solve_complex_nth_root_checked	(	std::shared_ptr< SymbolicExpr >	c,
		int	n )

在文件 symbolic_complex.cpp 第 291 行定义.

                                                                                        {
    ComputationContext context;
    return solve_complex_nth_root_checked(std::move(c), n, context);
}

引用了 c, context , 以及 solve_complex_nth_root_checked().

函数调用图:

solve_complex_nth_root_checked() [2/2]

ComplexRootsResult LMCAS::solve_complex_nth_root_checked	(	std::shared_ptr< SymbolicExpr >	c,
		int	n,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 244 行定义.

                                                                               {
    auto vc = validate_expr(c, "c", context, kComplexNthRootOperation);
    if (!vc) return ComplexRootsResult::failure(vc.error());
    if (n <= 0) {
        return ComplexRootsResult::failure(
            CasErrc::InvalidArgument, "root degree must be positive", kComplexNthRootOperation);
    }
    auto budget = context.consume_steps(static_cast<std::size_t>(n) * 8 + 8,
                                        kComplexNthRootOperation);
    if (!budget) return ComplexRootsResult::failure(budget.error());
 
    const auto number = std::dynamic_pointer_cast<const NumberNode>(detail::node(c));
    if (!number) {
        return ComplexRootsResult::failure(
            CasErrc::Inconclusive,
            "checked complex nth roots require a real numeric input",
            kComplexNthRootOperation);
    }
 
    return checked_construct<std::vector<ComplexSymbolic>>(
        [&]() -> ComplexRootsResult {
            const Rational value = std::holds_alternative<BigInt>(number->value())
                ? Rational(std::get<BigInt>(number->value()))
                : std::get<Rational>(number->value());
            auto radius = SymbolicExpr::power(
                SymbolicExpr::number(value < Rational(0) ? -value : value),
                SymbolicExpr::number(Rational(1, n)));
            auto pi = detail::make_expression_ptr(
                detail::make_node<VariableNode>("pi", true));
            std::vector<ComplexSymbolic> roots;
            roots.reserve(static_cast<std::size_t>(n));
            for (int k = 0; k < n; ++k) {
                auto angle = SymbolicExpr::multiply(
                    SymbolicExpr::number(
                        Rational(BigInt(2) * BigInt(k) +
                            BigInt(value < Rational(0) ? 1 : 0), BigInt(n))),
                    pi);
                auto root = complex_exp_form_checked(radius, angle, context);
                if (!root) {
                    return ComplexRootsResult::failure(root.error());
                }
                roots.push_back(std::move(root.value()));
            }
            return roots;
        }, kComplexNthRootOperation);
}

引用了 c, complex_exp_form_checked(), context, LMCAS::Result< std::vector< ComplexSymbolic > >::failure(), Inconclusive, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), pi(), roots(), solve_complex_nth_root_checked() , 以及 value.

被这些函数引用 solve_complex_nth_root_checked() , 以及 solve_complex_nth_root_checked().

函数调用图:

这是这个函数的调用关系图:

solve_complex_quadratic_checked() [1/2]

ComplexRootsResult LMCAS::solve_complex_quadratic_checked	(	std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b,
		std::shared_ptr< SymbolicExpr >	c )

在文件 symbolic_complex.cpp 第 309 行定义.

                                   {
    ComputationContext context;
    return solve_complex_quadratic_checked(
        std::move(a), std::move(b), std::move(c), context);
}

引用了 a, b, c, context , 以及 solve_complex_quadratic_checked().

函数调用图:

solve_complex_quadratic_checked() [2/2]

ComplexRootsResult LMCAS::solve_complex_quadratic_checked	(	std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b,
		std::shared_ptr< SymbolicExpr >	c,
		ComputationContext &	context )

在文件 symbolic_complex.cpp 第 296 行定义.

                                                                {
    auto roots = detail::real_quadratic_roots_checked(a, b, c, context);
    if (!roots) return ComplexRootsResult::failure(roots.error());
    return checked_construct<std::vector<ComplexSymbolic>>(
        [&]() -> ComplexRootsResult {
            return std::vector<ComplexSymbolic>{
                {std::move(roots.value()[0].real), std::move(roots.value()[0].imag)},
                {std::move(roots.value()[1].real), std::move(roots.value()[1].imag)}};
        }, kComplexQuadraticOperation);
}

引用了 a, b, c, context, LMCAS::Result< T >::error(), LMCAS::Result< std::vector< ComplexSymbolic > >::failure(), LMCAS::detail::real_quadratic_roots_checked(), roots(), solve_complex_quadratic_checked() , 以及 LMCAS::Result< T >::value().

被这些函数引用 solve_complex_quadratic_checked() , 以及 solve_complex_quadratic_checked().

函数调用图:

这是这个函数的调用关系图:

solve_constant_inequality()

IntervalUnion LMCAS::solve_constant_inequality ( const Polynomial< SymbolicPolyCoeff > & poly, InequalityType type, ComputationContext & context )

static

在文件 inequality_solver.cpp 第 163 行定义.

                                 {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto lc = poly.lead_coeff().val;
    if (!lc) {
        return IntervalUnion::empty();
    }
    int sign = exact_numeric_sign(lc, context);
    if (sign == 0 && !lc->is_zero()) {
        auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(lc), transform_budget));
        if (!simplified || !simplified->is_zero()) {
            return IntervalUnion::empty();
        }
    }
 
    bool satisfies = false;
    switch (type) {
        case InequalityType::GreaterThan: satisfies = (sign > 0); break;
        case InequalityType::GreaterEqual: satisfies = (sign >= 0); break;
        case InequalityType::LessThan: satisfies = (sign < 0); break;
        case InequalityType::LessEqual: satisfies = (sign <= 0); break;
        default:
            return IntervalUnion::empty();
    }
    return satisfies ? IntervalUnion::entire_line() : IntervalUnion::empty();
}

引用了 context, LMCAS::detail::inequality_support::exact_numeric_sign(), GreaterEqual, GreaterThan, LMCAS::Polynomial< CoeffType >::lead_coeff(), LessEqual, LessThan, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 solve_constant_inequality().

被这些函数引用 solve_constant_inequality().

函数调用图:

这是这个函数的调用关系图:

solve_cubic()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_cubic	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::shared_ptr< SymbolicExpr > &	d,
		const std::string &	variable )

在文件 solve_polynomial_cubic.cpp 第 211 行定义.

                               {
    ComputationContext context;
    return solve_cubic_impl(a, b, c, d, variable, context);
}

引用了 a, b, c, context, solve_cubic(), LMCAS::polynomial_solver_detail::solve_cubic_impl() , 以及 variable.

被这些函数引用 solve_closed_form_from_poly() , 以及 solve_cubic().

函数调用图:

这是这个函数的调用关系图:

solve_degenerate_cubic()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_degenerate_cubic ( const std::shared_ptr< SymbolicExpr > & b, const std::shared_ptr< SymbolicExpr > & c, const std::shared_ptr< SymbolicExpr > & d, ComputationContext & context )

static

在文件 solve_polynomial_cubic.cpp 第 18 行定义.

                                                                       {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!detail::make_expression_ptr(detail::normalize_node(detail::node(b), transform_budget))->get_number_value_is_zero()) {
        return solve_quadratic_internal(b, c, d, context);
    }
    if (!detail::make_expression_ptr(detail::normalize_node(detail::node(c), transform_budget))->get_number_value_is_zero()) {
        return {detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(negate(d), c)), transform_budget))};
    }
    auto constant = detail::make_expression_ptr(detail::normalize_node(detail::node(d), transform_budget));
    if (constant->get_number_value_is_zero()) {
        throw std::invalid_argument(
            "solve_cubic: identically zero equation has no finite root list");
    }
    if (is_purely_numeric(constant)) return {};
    throw std::invalid_argument(
        "solve_cubic: equation is independent of the requested variable");
}

引用了 b, c, context, LMCAS::polynomial_solver_detail::is_purely_numeric(), LMCAS::detail::make_expression_ptr(), LMCAS::polynomial_solver_detail::negate(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_degenerate_cubic() , 以及 LMCAS::polynomial_solver_detail::solve_quadratic_internal().

被这些函数引用 LMCAS::polynomial_solver_detail::solve_cubic_impl() , 以及 solve_degenerate_cubic().

函数调用图:

这是这个函数的调用关系图:

solve_diophantine_pair()

std::vector< MultiPoly > LMCAS::solve_diophantine_pair ( const std::vector< MultiPoly > & factors, const MultiPoly & target, const std::string & var, const Rational & eval_point, int degree_bound )

static

用 target/gcd 缩放 Bézout 系数，兼容 gcd 非 1 的情形。 互素因子的 gcd 为 1；s_1 = s*(target/gcd)，s_2 = t*(target/gcd)。

按 f_2、f_1 约化系数并保持 s_1*f_1 + s_2*f_2 = target。 次数约束为 deg(s_1) < deg(f_2)、deg(s_2) < deg(f_1)。

在文件 multivariate_hensel.cpp 第 451 行定义.

                                                                        {
    const auto& vars = factors[0].variables();
    Polynomial<Rational> f1_uni, f2_uni;
    if (!diophantine_univariate_factors(factors, var, eval_point,
                                       f1_uni, f2_uni)) {
        return {MultiPoly(Rational(0), vars), MultiPoly(Rational(0), vars)};
    }
    Polynomial<Rational> s_coeff, t_coeff;
    Polynomial<Rational> g = extended_gcd_poly(f1_uni, f2_uni, s_coeff, t_coeff);
 
    Polynomial<Rational> target_uni;
    if (!diophantine_target(target, var, eval_point,
                            f1_uni.variable_name, target_uni)) {
        return {MultiPoly(Rational(0), vars), MultiPoly(Rational(0), vars)};
    }
 
 
    /**
     * @brief 用 target/gcd 缩放 Bézout 系数，兼容 gcd 非 1 的情形。
     * 互素因子的 gcd 为 1；s_1 = s*(target/gcd)，s_2 = t*(target/gcd)。
     */
    Polynomial<Rational> scale;
    if (g.is_zero() || g.degree() < 0) {
        return {MultiPoly(Rational(0), vars), MultiPoly(Rational(0), vars)};
    }
 
    auto [quotient, remainder] = target_uni.div_mod(g);
    if (!remainder.is_zero()) {
        return {MultiPoly(Rational(0), vars), MultiPoly(Rational(0), vars)};
    }
 
    Polynomial<Rational> s1_uni = s_coeff * quotient;
    Polynomial<Rational> s2_uni = t_coeff * quotient;
 
    /**
     * @brief 按 f_2、f_1 约化系数并保持 s_1*f_1 + s_2*f_2 = target。
     * 次数约束为 deg(s_1) < deg(f_2)、deg(s_2) < deg(f_1)。
     */
    if (!f2_uni.is_zero() && s1_uni.degree() >= f2_uni.degree()) {
        auto [q1, r1] = s1_uni.div_mod(f2_uni);
        s1_uni = r1;
        s2_uni = s2_uni + q1 * f1_uni;
    }
    if (!(s1_uni * f1_uni + s2_uni * f2_uni == target_uni)) { return {}; }
 
    std::string uni_var = f1_uni.variable_name;
    MultiPoly s1_mp = embed_hensel_terms(
        MultiPoly::from_univariate(s1_uni, uni_var), vars);
    MultiPoly s2_mp = embed_hensel_terms(
        MultiPoly::from_univariate(s2_uni, uni_var), vars);
    s1_mp = truncate_mod_var(s1_mp, var, degree_bound);
    s2_mp = truncate_mod_var(s2_mp, var, degree_bound);
 
    return {s1_mp, s2_mp};
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), diophantine_target(), diophantine_univariate_factors(), LMCAS::Polynomial< CoeffType >::div_mod(), embed_hensel_terms(), extended_gcd_poly(), LMCAS::Polynomial< CoeffType >::is_zero(), solve_diophantine_pair(), target, truncate_mod_var(), LMCAS::Polynomial< CoeffType >::variable_name , 以及 vars.

被这些函数引用 multivariate_diophantine() , 以及 solve_diophantine_pair().

函数调用图:

这是这个函数的调用关系图:

solve_equation() [1/2]

LMCAS::SolveResult LMCAS::solve_equation	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	opts )

在文件 solve_visitor.cpp 第 456 行定义.

                                  {
    constexpr const char* operation = "solve_equation";
    if (!expr || !LMCAS::detail::node(expr)) {
        return SolveResult::failure(
            CasErrc::InvalidArgument, "equation expression cannot be null", operation);
    }
    if (var.empty()) {
        return SolveResult::failure(
            CasErrc::InvalidArgument, "solve variable cannot be empty", operation);
    }
 
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return SolveResult::failure(step.error());
    }
 
    std::shared_ptr<SymbolicExpr> f_expr = expr;
    if (auto relation = std::dynamic_pointer_cast<const RelationalNode>(LMCAS::detail::node(expr))) {
        if (relation->op() != RelationalNode::Op::EQ) {
            return SolveResult::failure(
                CasErrc::InvalidArgument,
                "solve_equation accepts equations, not inequalities",
                operation);
        }
        auto left = LMCAS::detail::make_expression_ptr(relation->left());
        auto right = LMCAS::detail::make_expression_ptr(relation->right());
        f_expr = SymbolicExpr::add(
            left, SymbolicExpr::multiply(SymbolicExpr::number(-1), right));
    }
 
    return dispatch_equation(expr, f_expr, var, context, opts);
}
catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit,
        "equation solve allocation failed", "solve_equation");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve_equation");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve_equation");
}

引用了 context, dispatch_equation(), LMCAS::Result< SolutionSet >::failure(), InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), relation(), right , 以及 solve_equation().

被这些函数引用 asymptote_candidates(), inflection_points_checked(), inverse_function_checked(), solve_equation(), solve_equation(), solve_finite_checked(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_polynomial_factor(), solve_product_factor(), solve_set(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution() , 以及 solve_transcendental().

函数调用图:

这是这个函数的调用关系图:

solve_equation() [2/2]

LMCAS::SolveResult LMCAS::solve_equation	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts )

在文件 solve_visitor.cpp 第 503 行定义.

                              {
    ComputationContext context;
    return solve_equation(expr, var, context, opts);
}

引用了 context , 以及 solve_equation().

函数调用图:

solve_euler_ode_checked() [1/2]

ODESolutionResult LMCAS::solve_euler_ode_checked	(	const std::vector< double > &	euler_coeffs,
		const std::shared_ptr< SymbolicExpr > &	forcing,
		const std::string &	x,
		const std::string &	y )

在文件 ode_linear.cpp 第 441 行定义.

{
    ComputationContext context;
    return solve_euler_ode_checked(euler_coeffs, forcing, x, y, context);
}

引用了 context , 以及 solve_euler_ode_checked().

函数调用图:

solve_euler_ode_checked() [2/2]

ODESolutionResult LMCAS::solve_euler_ode_checked	(	const std::vector< double > &	euler_coeffs,
		const std::shared_ptr< SymbolicExpr > &	forcing,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context )

在文件 ode_linear.cpp 第 369 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "solve_euler_ode";
    auto variables = validate_ode_variables(x, y, context, operation);
    if (!variables) {
        return ODESolutionResult::failure(variables.error());
    }
 
    auto coeff_check = validate_numeric_ode_coefficients(euler_coeffs, 3, 4, operation);
    if (!coeff_check) {
        return ODESolutionResult::failure(coeff_check.error());
    }
 
    auto budget = context.consume_steps(euler_coeffs.size() * 20 + 20, operation);
    if (!budget) {
        return ODESolutionResult::failure(budget.error());
    }
 
    const bool nonzero_forcing = has_nonzero_forcing(forcing);
    if (nonzero_forcing && unsupported_euler_forcing(forcing, euler_coeffs)) {
        return ODESolutionResult::failure(
            CasErrc::Inconclusive,
            "non-homogeneous Euler ODE currently requires a constant forcing and nonzero y coefficient",
            operation);
    }
 
    try {
        auto solution_result = solve_euler_ode_impl(
            euler_coeffs, nullptr, x, y, context);
        if (!solution_result) {
            return ODESolutionResult::failure(solution_result.error());
        }
        auto solution = std::move(solution_result.value());
        if (nonzero_forcing && solution.general_solution) {
            auto particular = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
                forcing,
                SymbolicExpr::number(euler_coeffs.back()))), transform_budget));
            solution.general_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(
                solution.general_solution, particular)), transform_budget));
        }
        return wrap_ode_solution(
            std::move(solution),
            ODEType::Euler,
            operation);
    } catch (const std::bad_alloc&) {
        return ODESolutionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while solving Euler ODE",
            operation);
    } catch (const std::length_error& error) { return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), "solve_euler_ode"); } catch (const std::exception& ex) {
        return ODESolutionResult::failure(
            CasErrc::InternalInvariant,
            ex.what(),
            operation);
    }
} catch (const CasError& error) {
    return ODESolutionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ODESolutionResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_euler_ode");
} catch (const std::length_error& error) {
    return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), "solve_euler_ode");
} catch (const std::exception& error) {
    return ODESolutionResult::failure(CasErrc::InternalInvariant, error.what(), "solve_euler_ode");
}

引用了 context, Euler, LMCAS::Result< ODESolution >::failure(), has_nonzero_forcing(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), ResourceLimit, solve_euler_ode_checked(), solve_euler_ode_impl(), unsupported_euler_forcing(), validate_numeric_ode_coefficients(), validate_ode_variables() , 以及 wrap_ode_solution().

被这些函数引用 solve_euler_ode_checked() , 以及 solve_euler_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_euler_ode_impl()

Result< ODESolution > LMCAS::solve_euler_ode_impl ( const std::vector< double > & euler_coeffs, const std::shared_ptr< SymbolicExpr > & forcing, const std::string & x, const std::string & , ComputationContext & context )

static

在文件 ode_linear.cpp 第 451 行定义.

    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "solve_euler_ode";
    ODESolution result;
    result.method_used = ODEType::Euler;
 
    if ((euler_coeffs.size() != 3 && euler_coeffs.size() != 4) ||
        has_nonzero_forcing(forcing)) {
        return Result<ODESolution>::failure(
            CasErrc::Inconclusive,
            "Euler ODE is outside the implemented support domain",
            operation);
    }
 
    std::vector<double> characteristic;
    if (euler_coeffs.size() == 3) {
        const double a = euler_coeffs[0];
        const double b = euler_coeffs[1];
        const double c = euler_coeffs[2];
        characteristic = {a, b - a, c};
    } else {
        const double a = euler_coeffs[0];
        const double b = euler_coeffs[1];
        const double c = euler_coeffs[2];
        const double d = euler_coeffs[3];
        characteristic = {a, b - 3.0 * a, 2.0 * a - b + c, d};
    }
 
    auto roots = find_characteristic_roots(characteristic, operation);
    if (!roots) {
        return Result<ODESolution>::failure(roots.error());
    }
    result.general_solution =
        build_euler_solution(roots.value(), x, result.constants);
    if (result.general_solution) {
        result.general_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(result.general_solution), transform_budget));
    }
    return Result<ODESolution>::success(std::move(result));
} catch (const CasError& error) {
    return Result<ODESolution>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<ODESolution>::failure(CasErrc::ResourceLimit, "allocation failed", "solve_euler_ode");
} catch (const std::length_error& error) {
    return Result<ODESolution>::failure(CasErrc::ResourceLimit, error.what(), "solve_euler_ode");
} catch (const std::exception& error) {
    return Result<ODESolution>::failure(CasErrc::InternalInvariant, error.what(), "solve_euler_ode");
}

引用了 a, b, build_euler_solution(), c, LMCAS::ODESolution::constants, context, LMCAS::Result< T >::error(), Euler, LMCAS::Result< T >::failure(), LMCAS::ode_root_detail::find_characteristic_roots(), LMCAS::ODESolution::general_solution, has_nonzero_forcing(), Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::detail::normalize_node(), roots(), solve_euler_ode_impl(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 solve_euler_ode_checked() , 以及 solve_euler_ode_impl().

函数调用图:

这是这个函数的调用关系图:

solve_exact_affine_inequality()

Result< IntervalUnion > LMCAS::detail::inequality_support::solve_exact_affine_inequality	(	const Polynomial< Rational > &	polynomial,
		InequalityType	type,
		ComputationContext &	context )

在文件 inequality_solver_polynomial.cpp 第 463 行定义.

                                 {
    return solve_exact_affine_inequality_impl(polynomial, type, context);
}

solve_exact_factor()

SolveVectorResult LMCAS::solve_exact_factor ( Polynomial< Rational > remainder, const std::string & var, ComputationContext & context )

static

在文件 solve_visitor.cpp 第 371 行定义.

                                                       {
    std::vector<ExprPtr> factor_roots;
    const bool bounded_candidates =
        polynomial_solver_detail::bounded_rational_root_search(remainder);
    if (bounded_candidates) {
        for (const auto& root : find_rational_roots(remainder)) {
            Polynomial<Rational> divisor({-root, Rational(1)}, var);
            auto division = remainder.div_mod(divisor);
            if (!division.second.is_zero()) { continue; }
            factor_roots.push_back(SymbolicExpr::number(root));
            remainder = std::move(division.first);
        }
    }
    if (remainder.degree() == 1) {
        factor_roots.push_back(SymbolicExpr::number(-remainder.coeffs[0] / remainder.coeffs[1]));
    } else if (remainder.degree() == 2) {
        auto quadratic = detail::real_quadratic_roots_checked(
            SymbolicExpr::number(remainder.coeffs[2]),
            SymbolicExpr::number(remainder.coeffs[1]),
            SymbolicExpr::number(remainder.coeffs[0]), context);
        if (!quadratic) { return SolveVectorResult::failure(quadratic.error()); }
        for (const auto& root : quadratic.value()) {
            factor_roots.push_back(detail::make_expression_ptr(
                SymbolicFactory::create_complex(detail::node(root.real), detail::node(root.imag))));
        }
    } else if (remainder.degree() > 2) {
        auto represented_roots = solve_higher_exact_roots(remainder, var, context);
        if (!represented_roots) { return SolveVectorResult::failure(represented_roots.error()); }
        factor_roots.insert(factor_roots.end(), represented_roots.value().begin(), represented_roots.value().end());
    }
    return factor_roots;
}

引用了 LMCAS::polynomial_solver_detail::bounded_rational_root_search(), LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::SymbolicFactory::create_complex(), LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), find_rational_roots(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::real_quadratic_roots_checked(), solve_exact_factor() , 以及 solve_higher_exact_roots().

被这些函数引用 solve_exact_factor() , 以及 solve_exact_polynomial_set().

函数调用图:

这是这个函数的调用关系图:

solve_exact_ode_checked() [1/2]

ODESolutionResult LMCAS::solve_exact_ode_checked	(	const std::shared_ptr< SymbolicExpr > &	M,
		const std::shared_ptr< SymbolicExpr > &	N,
		const std::string &	x,
		const std::string &	y )

在文件 ode_first_order.cpp 第 416 行定义.

{
    ComputationContext context;
    return solve_exact_ode_checked(M, N, x, y, context);
}

引用了 context , 以及 solve_exact_ode_checked().

函数调用图:

solve_exact_ode_checked() [2/2]

ODESolutionResult LMCAS::solve_exact_ode_checked	(	const std::shared_ptr< SymbolicExpr > &	M,
		const std::shared_ptr< SymbolicExpr > &	N,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context )

在文件 ode_first_order.cpp 第 380 行定义.

{
    const std::string operation = "solve_exact_ode";
    auto valid = validate_ode_pair_var_pair(M, N, x, y, context, operation);
    if (!valid) {
        return ODESolutionResult::failure(valid.error());
    }
    auto step = context.consume_steps(18, operation);
    if (!step) {
        return ODESolutionResult::failure(step.error());
    }
 
    try {
        auto solved = solve_exact_ode_impl(M, N, x, y, context);
        if (!solved) { return solved; }
        return wrap_ode_solution(std::move(solved.value()), ODEType::Exact, operation);
    } catch (const CasError& error) {
        return ODESolutionResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ODESolutionResult::failure(CasErrc::ResourceLimit,
                                          "exact ODE allocation failed",
                                          operation);
    } catch (const std::length_error& error) {
        return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return ODESolutionResult::failure(CasErrc::InternalInvariant,
                                          e.what(),
                                          operation);
    }
}

引用了 context, e(), Exact, LMCAS::Result< ODESolution >::failure(), InternalInvariant, ResourceLimit, solve_exact_ode_checked(), solve_exact_ode_impl(), validate_ode_pair_var_pair() , 以及 wrap_ode_solution().

被这些函数引用 solve_exact_ode_checked() , 以及 solve_exact_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_exact_ode_impl()

ODESolutionResult LMCAS::solve_exact_ode_impl ( const std::shared_ptr< SymbolicExpr > & M, const std::shared_ptr< SymbolicExpr > & N, const std::string & x, const std::string & y, ComputationContext & context )

static

恰当方程: partialF/partialx = M, partialF/partialy = N F(x,y) = integral M dx + g(y) 对 F 关于 y 求导: partialF/partialy = partial/partialy(integral M dx) + g'(y) = N 所以 g'(y) = N - partial/partialy(integral M dx)

步骤 1: 计算 integral M dx(将 y 视为常数)

步骤 2: 对 F_partial 关于 y 求导

步骤 3: g'(y) = N - dF_dy

步骤 4: g(y) = integral g'(y) dy

步骤 5: F(x,y) = F_partial + g(y)

解为 F(x,y) = C

在文件 ode_first_order.cpp 第 426 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    ODESolution result;
    result.method_used = ODEType::Exact;
    result.constants = {"C"};
 
    auto M_eff = M;
    auto N_eff = N;
 
    auto factor = find_integrating_factor_impl(M, N, x, y, context);
    if (!factor) { return ODESolutionResult::failure(factor.error()); }
    if (!factor.value()) {
        return ODESolutionResult::success(std::move(result));
    }
    auto mu = std::move(factor.value());
    if (!mu->is_one()) {
        M_eff = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(mu, M)), transform_budget));
        N_eff = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(mu, N)), transform_budget));
    }
 
    /// 恰当方程: partialF/partialx = M, partialF/partialy = N
    /// F(x,y) = integral M dx + g(y)
    /// 对 F 关于 y 求导: partialF/partialy = partial/partialy(integral M dx) + g'(y) = N
    /// 所以 g'(y) = N - partial/partialy(integral M dx)
 
    /// 步骤 1: 计算 integral M dx(将 y 视为常数)
    Integrator integrator;
    auto integrated_m = integrator.integrate_checked(*M_eff, x, context);
    if (!integrated_m) { return ODESolutionResult::failure(integrated_m.error()); }
    auto F_partial = std::make_shared<SymbolicExpr>(std::move(integrated_m.value()));
 
    /// 步骤 2: 对 F_partial 关于 y 求导
    auto dF_dy = detail::make_expression_ptr(detail::differentiate_node(detail::node(F_partial), y, transform_budget));
    dF_dy = detail::make_expression_ptr(detail::normalize_node(detail::node(dF_dy), transform_budget));
 
    /// 步骤 3: g'(y) = N - dF_dy
    auto g_prime = SymbolicExpr::add(N_eff,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dF_dy));
    g_prime = detail::make_expression_ptr(detail::normalize_node(detail::node(g_prime), transform_budget));
 
    /// 步骤 4: g(y) = integral g'(y) dy
    auto integrated_g = integrator.integrate_checked(*g_prime, y, context);
    if (!integrated_g) { return ODESolutionResult::failure(integrated_g.error()); }
    auto g_y = std::make_shared<SymbolicExpr>(std::move(integrated_g.value()));
 
    /// 步骤 5: F(x,y) = F_partial + g(y)
    auto F_total = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(F_partial, g_y)), transform_budget));
 
    /// 解为 F(x,y) = C
    result.general_solution = F_total;
    return ODESolutionResult::success(std::move(result));
}

引用了 LMCAS::ODESolution::constants, context, LMCAS::detail::differentiate_node(), Exact, LMCAS::Result< ODESolution >::failure(), find_integrating_factor_impl(), LMCAS::ODESolution::general_solution, integrator, LMCAS::detail::make_expression_ptr(), LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::detail::normalize_node(), solve_exact_ode_impl() , 以及 LMCAS::Result< ODESolution >::success().

被这些函数引用 solve_exact_ode_checked() , 以及 solve_exact_ode_impl().

函数调用图:

这是这个函数的调用关系图:

solve_exact_polynomial_inequality()

Result< IntervalUnion > LMCAS::detail::inequality_support::solve_exact_polynomial_inequality	(	const Polynomial< Rational > &	polynomial,
		InequalityType	type,
		ComputationContext &	context )

在文件 inequality_solver_polynomial.cpp 第 470 行定义.

                                 {
    return solve_exact_polynomial_inequality_impl(polynomial, type, context);
}

solve_exact_polynomial_set()

SolveResult LMCAS::solve_exact_polynomial_set ( const Polynomial< Rational > & exact, const std::string & var, ComputationContext & context )

static

在文件 solve_visitor.cpp 第 405 行定义.

                                                                         {
    if (exact.is_zero()) { return SolutionSet{UniversalSolutions{}}; }
    if (exact.degree() == 0) { return SolutionSet{EmptySolutions{}}; }
    std::vector<ExprPtr> roots;
    for (auto& factor : square_free_factorization(exact)) {
        auto step = context.consume_steps(1, "solve.exact");
        if (!step) { return SolveResult::failure(step.error()); }
        auto solved = solve_exact_factor(factor.first, var, context);
        if (!solved) { return SolveResult::failure(solved.error()); }
        const auto& factor_roots = solved.value();
        if (factor_roots.size() != static_cast<std::size_t>(factor.first.degree()))
            { return SolveResult::failure(CasErrc::InternalInvariant,
                "square-free factor root count mismatch", "solve.exact"); }
        for (int copy = 0; copy < factor.second; ++copy)
            { roots.insert(roots.end(), factor_roots.begin(), factor_roots.end()); }
    }
    if (roots.size() != static_cast<std::size_t>(exact.degree()))
        { return SolveResult::failure(CasErrc::InternalInvariant,
            "polynomial root multiplicities do not cover its degree", "solve.exact"); }
    return collect_exact_solutions(std::move(roots), context);
}

引用了 collect_exact_solutions(), context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< SolutionSet >::failure(), InternalInvariant, LMCAS::Polynomial< CoeffType >::is_zero(), roots(), solve_exact_factor(), solve_exact_polynomial_set() , 以及 square_free_factorization().

被这些函数引用 dispatch_equation() , 以及 solve_exact_polynomial_set().

函数调用图:

这是这个函数的调用关系图:

solve_expr_set() [1/2]

ExprSetResult LMCAS::solve_expr_set	(	const ExprPtr &	equation,
		const std::string &	variable,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 67 行定义.

                                                          {
    return project_finite_expr_set(equation, variable, context, options);
}

引用了 context, options, project_finite_expr_set(), solve_expr_set() , 以及 variable.

被这些函数引用 solve(), solve_expr_set() , 以及 solve_expr_set().

函数调用图:

这是这个函数的调用关系图:

solve_expr_set() [2/2]

ExprSetResult LMCAS::solve_expr_set	(	const ExprPtr &	equation,
		const std::string &	variable,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 73 行定义.

                                                          {
    ComputationContext context;
    return solve_expr_set(equation, variable, context, options);
}

引用了 context, options, solve_expr_set() , 以及 variable.

函数调用图:

solve_finite_checked() [1/2]

LMCAS::FiniteSolveResult LMCAS::solve_finite_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	opts )

在文件 solve_visitor.cpp 第 622 行定义.

                                  {
    constexpr const char* operation = "solve_finite_projection";
    auto solved = solve_equation(expr, var, context, opts);
    if (!solved) {
        return SolveVectorResult::failure(solved.error());
    }
    auto solution_set = std::move(solved.value());
    if (std::holds_alternative<EmptySolutions>(solution_set)) {
        return SolveVectorResult::success({});
    }
    auto* finite = std::get_if<FiniteSolutions>(&solution_set);
    if (!finite) {
        return SolveVectorResult::failure(
            CasErrc::Inconclusive,
            "solution set is not finitely enumerable", operation);
    }
    std::size_t value_count = 0;
    for (const auto& solution : finite->values) {
        if (!solution.conditions.empty()) {
            return SolveVectorResult::failure(CasErrc::Inconclusive,
                "Conditional roots cannot be projected to an unconditional vector", operation);
        }
        value_count += solution.multiplicity;
    }
    std::vector<std::shared_ptr<SymbolicExpr>> values;
    values.reserve(value_count);
    for (const auto& solution : finite->values) {
        for (std::size_t copy = 0; copy < solution.multiplicity; ++copy) {
            values.push_back(solution.value);
        }
    }
    return SolveVectorResult::success(std::move(values));
}
catch (const CasError& error) {
    return SolveVectorResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveVectorResult::failure(CasErrc::ResourceLimit,
        "finite solution projection allocation failed", "solve_finite_projection");
} catch (const std::length_error& error) {
    return SolveVectorResult::failure(CasErrc::ResourceLimit, error.what(), "solve_finite_projection");
} catch (const std::exception& error) {
    return SolveVectorResult::failure(CasErrc::InternalInvariant, error.what(), "solve_finite_projection");
}

引用了 context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, solve_equation(), solve_finite_checked() , 以及 LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success().

被这些函数引用 factor_symbolic_quadratic(), matrix_eigenvalues_checked(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::solve(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::solve(), solve_finite_checked(), solve_finite_checked(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::solve_single_equation() , 以及 solve_with_assumptions_impl().

函数调用图:

这是这个函数的调用关系图:

solve_finite_checked() [2/2]

LMCAS::FiniteSolveResult LMCAS::solve_finite_checked	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable,
		const SolveOptions &	options )

在文件 solve_visitor.cpp 第 670 行定义.

                                 {
    ComputationContext context;
    return solve_finite_checked(
        expression, variable, context, options);
}

引用了 context, options, solve_finite_checked() , 以及 variable.

函数调用图:

solve_finite_mixed()

std::optional< SolveVectorResult > LMCAS::solve_finite_mixed ( const std::shared_ptr< SymbolicExpr > & f_expr, const std::string & var, ComputationContext & context, const SolveOptions & opts )

static

在文件 solve_visitor.cpp 第 512 行定义.

                                                           {
    constexpr const char* operation = "solve_dispatch_vector";
    if (!contains_transcendental_of_var(f_expr, var)) {
        return std::nullopt;
    }
    auto substitution = detect_trans_substitutions(f_expr, var);
    if (!substitution.mappings.empty() && is_polynomial_after_substitution(substitution)) {
        return std::nullopt;
    }
    if (!opts.allow_numeric) {
        return SolveVectorResult::failure(
            CasErrc::Inconclusive,
            "mixed transcendental equation is outside the finite-vector support domain",
            operation);
    }
    auto mixed = solve_mixed_transcendental_checked(f_expr, var, opts, context);
    if (!mixed) {
        return SolveVectorResult::failure(mixed.error());
    }
    if (mixed.value().completeness == Completeness::Complete) {
        return SolveVectorResult::success(std::move(mixed.value().value));
    }
    return SolveVectorResult::failure(
        CasErrc::Inconclusive,
        mixed.value().reason.empty() ? "mixed transcendental search is incomplete" : mixed.value().reason,
        operation);
}

引用了 LMCAS::SolveOptions::allow_numeric, Complete, contains_transcendental_of_var(), context, detect_trans_substitutions(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, is_polynomial_after_substitution(), solve_finite_mixed(), solve_mixed_transcendental_checked() , 以及 LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success().

被这些函数引用 solve_finite_mixed() , 以及 solve_set_core().

函数调用图:

这是这个函数的调用关系图:

solve_frobenius_checked() [1/2]

FrobeniusSolutionResult LMCAS::solve_frobenius_checked	(	const std::shared_ptr< SymbolicExpr > &	p,
		const std::shared_ptr< SymbolicExpr > &	q,
		const std::shared_ptr< SymbolicExpr > &	x0,
		const std::string &	x,
		int	order )

在文件 ode_frobenius.cpp 第 618 行定义.

{
    ComputationContext context;
    return solve_frobenius_checked(p, q, x0, x, order, context);
}

引用了 context, order , 以及 solve_frobenius_checked().

函数调用图:

solve_frobenius_checked() [2/2]

FrobeniusSolutionResult LMCAS::solve_frobenius_checked	(	const std::shared_ptr< SymbolicExpr > &	p,
		const std::shared_ptr< SymbolicExpr > &	q,
		const std::shared_ptr< SymbolicExpr > &	x0,
		const std::string &	x,
		int	order,
		ComputationContext &	context )

在文件 ode_frobenius.cpp 第 538 行定义.

{
    const std::string operation = "solve_frobenius";
    auto valid = validate_ode_two_expr_point(p, q, x0, x, context, operation);
    if (!valid) {
        return FrobeniusSolutionResult::failure(valid.error());
    }
    if (order < 0 || order > 64) {
        return FrobeniusSolutionResult::failure(
            CasErrc::InvalidArgument,
            "Frobenius truncation order must be between 0 and 64",
            operation);
    }
    auto budget = context.consume_steps(static_cast<std::size_t>(order + 1) * 24 + 24,
                                        operation);
    if (!budget) {
        return FrobeniusSolutionResult::failure(budget.error());
    }
 
    try {
        auto classified =
            classify_singular_point_checked(p, q, x0, x, context);
        if (!classified) {
            return FrobeniusSolutionResult::failure(classified.error());
        }
        const auto point_type = classified.value();
        if (point_type == ODESingularityType::IrregularSingular) {
            return FrobeniusSolutionResult::failure(
                CasErrc::Inconclusive,
                "Frobenius checked API does not support irregular singular points",
                operation);
        }
        if (point_type == ODESingularityType::RegularSingular) {
            auto regular_domain = validate_frobenius_regular_singular_domain(
                p, q, x0, x, context, operation);
            if (!regular_domain) {
                return FrobeniusSolutionResult::failure(regular_domain.error());
            }
        }
 
        auto solved =
            solve_frobenius_impl(
                p, q, x0, x, order, point_type, context);
        if (!solved) {
            return solved;
        }
        auto solution = std::move(solved.value());
        if (!solution.series_solution ||
            !LMCAS::detail::node(solution.series_solution)) {
            return FrobeniusSolutionResult::failure(
                CasErrc::Inconclusive,
                "Frobenius solver produced no series in the supported domain",
                operation);
        }
        if (solution.point_type != point_type) {
            return FrobeniusSolutionResult::failure(
                CasErrc::InternalInvariant,
                "Frobenius solver reported an unexpected singularity type",
                operation);
        }
        return FrobeniusSolutionResult::success(std::move(solution));
    } catch (const std::bad_alloc&) {
        return FrobeniusSolutionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while solving Frobenius series",
            operation);
    } catch (const std::exception& ex) {
        return FrobeniusSolutionResult::failure(
            CasErrc::InternalInvariant,
            ex.what(),
            operation);
    }
}

引用了 classify_singular_point_checked(), context, LMCAS::Result< FrobeniusSolution >::failure(), Inconclusive, InternalInvariant, InvalidArgument, IrregularSingular, LMCAS::detail::node(), order, RegularSingular, ResourceLimit, solve_frobenius_checked(), solve_frobenius_impl(), LMCAS::Result< FrobeniusSolution >::success(), validate_frobenius_regular_singular_domain() , 以及 validate_ode_two_expr_point().

被这些函数引用 solve_frobenius_checked() , 以及 solve_frobenius_checked().

函数调用图:

这是这个函数的调用关系图:

solve_frobenius_impl()

FrobeniusSolutionResult LMCAS::solve_frobenius_impl ( const std::shared_ptr< SymbolicExpr > & p, const std::shared_ptr< SymbolicExpr > & q, const std::shared_ptr< SymbolicExpr > & x0, const std::string & x, int order, ODESingularityType point_type, ComputationContext & context )

static

在文件 ode_frobenius.cpp 第 629 行定义.

{
    FrobeniusSolution result;
    result.truncation_order = order;
    result.point_type = point_type;
    auto x_var = SymbolicExpr::variable(x);
    auto x_minus_x0 = SymbolicExpr::add(x_var,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), x0));
 
    if (result.point_type == ODESingularityType::IrregularSingular) {
        result.series_solution = nullptr;
        return result;
    }
 
    if (result.point_type == ODESingularityType::Ordinary) {
        return ordinary_frobenius_solution(p, q, x0, x, x_minus_x0, std::move(result), context);
    }
    return singular_frobenius_solution(
        p, q, x0, x, x_minus_x0, std::move(result), context);
}

引用了 context, IrregularSingular, order, Ordinary, ordinary_frobenius_solution(), LMCAS::FrobeniusSolution::point_type, LMCAS::FrobeniusSolution::series_solution, singular_frobenius_solution(), solve_frobenius_impl() , 以及 LMCAS::FrobeniusSolution::truncation_order.

被这些函数引用 solve_frobenius_checked() , 以及 solve_frobenius_impl().

函数调用图:

这是这个函数的调用关系图:

solve_higher_exact_roots()

SolveVectorResult LMCAS::solve_higher_exact_roots ( const Polynomial< Rational > & remainder, const std::string & var, ComputationContext & context )

static

在文件 solve_visitor.cpp 第 351 行定义.

                                                       {
    if (remainder.degree() == 4 &&
        remainder.coeffs[3] == Rational(0) &&
        remainder.coeffs[1] == Rational(0)) {
        return polynomial_solver_detail::solve_biquadratic_impl(
            SymbolicExpr::number(remainder.coeffs[4]),
            SymbolicExpr::number(remainder.coeffs[2]),
            SymbolicExpr::number(remainder.coeffs[0]), var, context);
    }
    auto expression = poly_to_symbolic(remainder);
    std::vector<ExprPtr> represented_roots;
    for (int index = 0; index < remainder.degree(); ++index) {
        auto root = make_rootof_checked(expression, var, static_cast<std::size_t>(index), context);
        if (!root) { return SolveVectorResult::failure(root.error()); }
        represented_roots.push_back(std::move(root.value()));
    }
    return represented_roots;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), make_rootof_checked(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl() , 以及 solve_higher_exact_roots().

被这些函数引用 solve_exact_factor() , 以及 solve_higher_exact_roots().

函数调用图:

这是这个函数的调用关系图:

solve_higher_order_ode_checked() [1/2]

ODESolutionResult LMCAS::solve_higher_order_ode_checked	(	const std::vector< double > &	coeffs,
		const std::shared_ptr< SymbolicExpr > &	forcing,
		const std::string &	x,
		const std::string &	y )

在文件 ode_linear.cpp 第 313 行定义.

{
    ComputationContext context;
    return solve_higher_order_ode_checked(coeffs, forcing, x, y, context);
}

引用了 context , 以及 solve_higher_order_ode_checked().

函数调用图:

solve_higher_order_ode_checked() [2/2]

ODESolutionResult LMCAS::solve_higher_order_ode_checked	(	const std::vector< double > &	coeffs,
		const std::shared_ptr< SymbolicExpr > &	forcing,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context )

在文件 ode_linear.cpp 第 233 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "solve_higher_order_ode";
    auto variables = validate_ode_variables(x, y, context, operation);
    if (!variables) {
        return ODESolutionResult::failure(variables.error());
    }
 
    auto coeff_check = validate_numeric_ode_coefficients(coeffs, 2, 7, operation);
    if (!coeff_check) {
        return ODESolutionResult::failure(coeff_check.error());
    }
    for (double coefficient : coeffs) {
        if (!std::isfinite(coefficient / coeffs.front())) {
            return ODESolutionResult::failure(
                CasErrc::NumericFailure,
                "normalizing the characteristic polynomial exceeds the finite numeric domain",
                operation);
        }
    }
 
    auto budget = context.consume_steps(coeffs.size() * 20 + 20, operation);
    if (!budget) {
        return ODESolutionResult::failure(budget.error());
    }
 
    const bool nonzero_forcing = has_nonzero_forcing(forcing);
    if (nonzero_forcing &&
        (!forcing->is_number() || coeffs.back() == 0.0)) {
        return ODESolutionResult::failure(
            CasErrc::Inconclusive,
            "non-homogeneous constant-coefficient ODE currently requires a constant forcing and nonzero y coefficient",
            operation);
    }
 
    try {
        auto solution_result = solve_higher_order_ode_impl(
            coeffs, nullptr, x, y, context);
        if (!solution_result) {
            return ODESolutionResult::failure(solution_result.error());
        }
        auto solution = std::move(solution_result.value());
        if (nonzero_forcing && solution.general_solution) {
            auto particular = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
                forcing, SymbolicExpr::number(coeffs.back()))), transform_budget));
            solution.general_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(
                solution.general_solution, particular)), transform_budget));
        }
        return wrap_ode_solution(
            std::move(solution),
            ODEType::HigherOrder_ConstCoeff,
            operation);
    } catch (const std::bad_alloc&) {
        return ODESolutionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while solving higher-order ODE",
            operation);
    } catch (const std::length_error& error) { return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), "solve_higher_order_ode"); } catch (const std::exception& ex) {
        return ODESolutionResult::failure(
            CasErrc::InternalInvariant,
            ex.what(),
            operation);
    }
} catch (const CasError& error) {
    return ODESolutionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ODESolutionResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_higher_order_ode");
} catch (const std::length_error& error) {
    return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), "solve_higher_order_ode");
} catch (const std::exception& error) {
    return ODESolutionResult::failure(CasErrc::InternalInvariant, error.what(), "solve_higher_order_ode");
}

引用了 context, LMCAS::Result< ODESolution >::failure(), has_nonzero_forcing(), HigherOrder_ConstCoeff, Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), NumericFailure, ResourceLimit, solve_higher_order_ode_checked(), solve_higher_order_ode_impl(), validate_numeric_ode_coefficients(), validate_ode_variables() , 以及 wrap_ode_solution().

被这些函数引用 solve_higher_order_ode_checked() , 以及 solve_higher_order_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_higher_order_ode_impl()

Result< ODESolution > LMCAS::solve_higher_order_ode_impl ( const std::vector< double > & coeffs, const std::shared_ptr< SymbolicExpr > & forcing, const std::string & x, const std::string & , ComputationContext & context )

static

在文件 ode_linear.cpp 第 323 行定义.

    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "solve_higher_order_ode";
    ODESolution result;
    result.method_used = ODEType::HigherOrder_ConstCoeff;
 
    if (coeffs.size() < 2 || has_nonzero_forcing(forcing)) {
        return Result<ODESolution>::failure(
            CasErrc::Inconclusive,
            "higher-order ODE is outside the implemented support domain",
            operation);
    }
 
    auto roots = find_characteristic_roots(coeffs, operation);
    if (!roots) {
        return Result<ODESolution>::failure(roots.error());
    }
    result.general_solution =
        build_homogeneous_solution(roots.value(), x, result.constants);
    if (result.general_solution) {
        result.general_solution = detail::make_expression_ptr(detail::normalize_node(detail::node(result.general_solution), transform_budget));
    }
    return Result<ODESolution>::success(std::move(result));
} catch (const CasError& error) {
    return Result<ODESolution>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<ODESolution>::failure(CasErrc::ResourceLimit, "allocation failed", "solve_higher_order_ode");
} catch (const std::length_error& error) {
    return Result<ODESolution>::failure(CasErrc::ResourceLimit, error.what(), "solve_higher_order_ode");
} catch (const std::exception& error) {
    return Result<ODESolution>::failure(CasErrc::InternalInvariant, error.what(), "solve_higher_order_ode");
}

引用了 build_homogeneous_solution(), LMCAS::ODESolution::constants, context, LMCAS::Result< T >::error(), LMCAS::Result< T >::failure(), LMCAS::ode_root_detail::find_characteristic_roots(), LMCAS::ODESolution::general_solution, has_nonzero_forcing(), HigherOrder_ConstCoeff, Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::detail::normalize_node(), roots(), solve_higher_order_ode_impl(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 solve_higher_order_ode_checked() , 以及 solve_higher_order_ode_impl().

函数调用图:

这是这个函数的调用关系图:

solve_homogeneous_ode_checked() [1/2]

ODESolutionResult LMCAS::solve_homogeneous_ode_checked	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y )

在文件 ode_first_order.cpp 第 110 行定义.

{
    ComputationContext context;
    return solve_homogeneous_ode_checked(rhs, x, y, context);
}

引用了 context, rhs , 以及 solve_homogeneous_ode_checked().

函数调用图:

solve_homogeneous_ode_checked() [2/2]

ODESolutionResult LMCAS::solve_homogeneous_ode_checked	(	const std::shared_ptr< SymbolicExpr > &	rhs,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context )

在文件 ode_first_order.cpp 第 75 行定义.

{
    const std::string operation = "solve_homogeneous_ode";
    auto valid = validate_ode_expr_var_pair(rhs, x, y, context, operation);
    if (!valid) {
        return ODESolutionResult::failure(valid.error());
    }
    auto step = context.consume_steps(12, operation);
    if (!step) {
        return ODESolutionResult::failure(step.error());
    }
 
    try {
        auto solved = solve_homogeneous_ode_impl(rhs, x, y, context);
        if (!solved) { return solved; }
        return wrap_ode_solution(std::move(solved.value()), ODEType::Homogeneous, operation);
    } catch (const CasError& error) {
        return ODESolutionResult::failure(error);
    } catch (const std::bad_alloc&) {
        return ODESolutionResult::failure(CasErrc::ResourceLimit,
                                          "homogeneous ODE allocation failed",
                                          operation);
    } catch (const std::length_error& error) {
        return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return ODESolutionResult::failure(CasErrc::InternalInvariant,
                                          e.what(),
                                          operation);
    }
}

引用了 context, e(), LMCAS::Result< ODESolution >::failure(), Homogeneous, InternalInvariant, ResourceLimit, rhs, solve_homogeneous_ode_checked(), solve_homogeneous_ode_impl(), validate_ode_expr_var_pair() , 以及 wrap_ode_solution().

被这些函数引用 solve_homogeneous_ode_checked() , 以及 solve_homogeneous_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_homogeneous_ode_impl()

ODESolutionResult LMCAS::solve_homogeneous_ode_impl ( const std::shared_ptr< SymbolicExpr > & rhs, const std::string & x, const std::string & y, ComputationContext & context )

static

齐次方程 y' = f(y/x) 令 v = y/x,则 y = v*x,y' = v + x*v' 代入: v + x*v' = f(v) 即: x*v' = f(v) - v 分离变量: dv/(f(v) - v) = dx/x

将 rhs 中的 y 替换为 v*x,得到 f 关于 v 和 x 的表达式 由于齐次性,f(x, vx) = f(1, v)(令 t=1/x 缩放) 所以直接用 x=1, y=v 代入得到 f(v)

f(v) = rhs(1, v):将 x=1, y=v 代入

分离变量方程: dv/(f(v) - v) = dx/x 积分: integral dv/(f(v) - v) = integral dx/x = ln|x| + C

右端: ln(x)

解为: lhs_integral = ln(x) + C 即: lhs_integral - ln(x) = C 回代 v = y/x

返回隐式解形式: F(x,y) = C

在文件 ode_first_order.cpp 第 119 行定义.

{
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    ODESolution result;
    result.method_used = ODEType::Homogeneous;
    result.constants = {"C"};
 
    /// 齐次方程 y' = f(y/x)
    /// 令 v = y/x,则 y = v*x,y' = v + x*v'
    /// 代入: v + x*v' = f(v)
    /// 即: x*v' = f(v) - v
    /// 分离变量: dv/(f(v) - v) = dx/x
 
    /// 将 rhs 中的 y 替换为 v*x,得到 f 关于 v 和 x 的表达式
    /// 由于齐次性,f(x, vx) = f(1, v)(令 t=1/x 缩放)
    /// 所以直接用 x=1, y=v 代入得到 f(v)
    std::string v_name = "v";
    auto v_var = SymbolicExpr::variable(v_name);
    auto x_var = SymbolicExpr::variable(x);
 
    /// f(v) = rhs(1, v):将 x=1, y=v 代入
    auto f_v = detail::make_expression_ptr(detail::substitute_node(detail::node(rhs), x, detail::node(SymbolicExpr::number(1)), transform_budget));
    f_v = detail::make_expression_ptr(detail::substitute_node(detail::node(f_v), y, detail::node(v_var), transform_budget));
    f_v = detail::make_expression_ptr(detail::normalize_node(detail::node(f_v), transform_budget));
 
    /// 分离变量方程: dv/(f(v) - v) = dx/x
    /// 积分: integral dv/(f(v) - v) = integral dx/x = ln|x| + C
    auto f_minus_v = detail::make_expression_ptr(detail::normalize_node(detail::node(detail::make_expression_ptr(detail::expand_node(detail::node(SymbolicExpr::add(f_v,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), v_var))), transform_budget))
        ->cancel()), transform_budget));
 
    auto v_replacement = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
        SymbolicExpr::variable(y), x_var)), transform_budget));
    if (f_minus_v->is_zero()) {
        result.general_solution = v_replacement;
        return ODESolutionResult::success(std::move(result));
    }
 
    std::shared_ptr<SymbolicExpr> integrand;
    const auto reciprocal =
        std::dynamic_pointer_cast<const PowerNode>(detail::node(f_minus_v));
    const auto minus_one = SymbolicExpr::number(-1);
    if (reciprocal &&
        reciprocal->exponent()->compare(*detail::node(minus_one)) == 0) {
        integrand = detail::make_expression_ptr(reciprocal->base());
    } else {
        integrand = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
            SymbolicExpr::number(1), f_minus_v)), transform_budget));
    }
    Integrator integrator;
    auto integrated = integrator.integrate_checked(*integrand, v_name, context);
    if (!integrated) { return ODESolutionResult::failure(integrated.error()); }
    auto lhs_integral = std::make_shared<SymbolicExpr>(std::move(integrated.value()));
 
    /// 右端: ln(x)
    auto rhs_integral = SymbolicExpr::ln(x_var);
 
    /// 解为: lhs_integral = ln(x) + C
    /// 即: lhs_integral - ln(x) = C
    /// 回代 v = y/x
 
    auto solution = detail::make_expression_ptr(detail::substitute_node(detail::node(lhs_integral), v_name, detail::node(v_replacement), transform_budget));
    solution = SymbolicExpr::add(solution,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), rhs_integral));
    solution = detail::make_expression_ptr(detail::normalize_node(detail::node(solution), transform_budget));
 
    /// 返回隐式解形式: F(x,y) = C
    result.general_solution = solution;
    return ODESolutionResult::success(std::move(result));
}

引用了 LMCAS::ODESolution::constants, context, LMCAS::detail::expand_node(), LMCAS::Result< ODESolution >::failure(), LMCAS::ODESolution::general_solution, Homogeneous, integrator, LMCAS::detail::make_expression_ptr(), LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::detail::normalize_node(), rhs, solve_homogeneous_ode_impl(), LMCAS::detail::substitute_node() , 以及 LMCAS::Result< ODESolution >::success().

被这些函数引用 solve_homogeneous_ode_checked() , 以及 solve_homogeneous_ode_impl().

函数调用图:

这是这个函数的调用关系图:

solve_lagrange_strict()

LagrangeResult LMCAS::solve_lagrange_strict ( const VectorField & equations, const std::vector< std::string > & all_vars, ComputationContext & context, const std::string & operation )

static

在文件 vector_calculus_lagrange.cpp 第 67 行定义.

{
    std::vector<std::map<std::string, std::shared_ptr<SymbolicExpr>>> full_solutions;
    std::vector<SymbolicExpr> poly_eqs;
    poly_eqs.reserve(equations.size());
    for (const auto& eq : equations) {
        if (!eq || !LMCAS::detail::node(eq)) {
            return LagrangeResult::failure(
                CasErrc::Inconclusive,
                "Lagrange equation construction failed in the supported domain",
                operation);
        }
        poly_eqs.push_back(*eq);
    }
 
    auto checked_solutions =
        Solver::solve_polynomial_system_checked(poly_eqs, all_vars, context);
    if (!checked_solutions) return LagrangeResult::failure(checked_solutions.error());
    const auto& poly_solutions = checked_solutions.value();
    for (const auto& sol : poly_solutions) {
        std::map<std::string, std::shared_ptr<SymbolicExpr>> pt;
        for (const auto& [name, val] : sol) {
            pt[name] = LMCAS::detail::make_expression_ptr(val);
        }
        full_solutions.push_back(std::move(pt));
    }
 
    return LagrangeResult::success(std::move(full_solutions));
}

引用了 context, eq(), LMCAS::Result< std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > >::failure(), Inconclusive, LMCAS::detail::make_expression_ptr(), name, LMCAS::detail::node(), solve_lagrange_strict() , 以及 LMCAS::Result< std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > >::success().

被这些函数引用 lagrange_multipliers_strict() , 以及 solve_lagrange_strict().

函数调用图:

这是这个函数的调用关系图:

solve_linear1_ode()

ExprPtr LMCAS::solve_linear1_ode	(	ExprPtr	Px,
		ExprPtr	Qx,
		const std::string &	x,
		const std::string &	y,
		const AssumptionContext *	ctx )

在文件 symbolic_ode.cpp 第 131 行定义.

                                                                           {
    ComputationContext context;
    Integrator integrator;
    auto integrated_p = integrator.integrate_checked(*Px, x, context);
    if (!integrated_p) { throw integrated_p.error(); }
    auto intP = std::make_shared<SymbolicExpr>(std::move(integrated_p.value()));
    auto mu = SymbolicExpr::exp(intP);
 
    auto Qmu = SymbolicExpr::multiply(Qx, mu);
    auto integrated_q = integrator.integrate_checked(*Qmu, x, context);
    if (!integrated_q) { throw integrated_q.error(); }
    auto intQmu = std::make_shared<SymbolicExpr>(std::move(integrated_q.value()));
 
    auto C = SymbolicExpr::variable("C");
    auto num = SymbolicExpr::add(intQmu, C);
    auto result = SymbolicExpr::divide(num, mu);
 
    // When the dependent variable is known Positive, prefer positive branch.
    auto positive = dep_var_is_positive(y, ctx, context);
    if (!positive) { throw positive.error(); }
    if (positive.value()) {
        result = make_abs(result);
    }
 
    return result;
}

引用了 context, dep_var_is_positive(), integrator, make_abs(), LMCAS::polynomial_solver_detail::num() , 以及 solve_linear1_ode().

被这些函数引用 solve_linear1_ode().

函数调用图:

这是这个函数的调用关系图:

solve_linear2_homogeneous()

Result< std::shared_ptr< SymbolicExpr > > LMCAS::solve_linear2_homogeneous ( double a, double b, double c, const std::string & x, const std::string & y, const AssumptionContext * ctx, ComputationContext & context )

static

在文件 symbolic_ode.cpp 第 211 行定义.

    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!std::isfinite(a) || !std::isfinite(b) || !std::isfinite(c)) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::InvalidArgument,
            "solve_linear2_ode: coefficients must be finite",
            kSolveLinear2OdeOperation);
    }
    ExprPtr solution;
    if (a == 0.0) {
        if (b == 0.0) {
            return Result<std::shared_ptr<SymbolicExpr>>::failure(
                CasErrc::InvalidArgument,
                "solve_linear2_ode: leading and first-derivative coefficients are both zero",
                kSolveLinear2OdeOperation);
        }
        const double normalized_c = c / b;
        if (!std::isfinite(normalized_c)) {
            return Result<std::shared_ptr<SymbolicExpr>>::failure(
                CasErrc::NumericFailure,
                "solve_linear2_ode: degenerate coefficient normalization is non-finite",
                kSolveLinear2OdeOperation);
        }
        // 常系数退化方程以特征根 -c/b 构造指数基，沿用数值系数的求解语义。
        solution = SymbolicExpr::multiply(SymbolicExpr::variable("C"),
            SymbolicExpr::exp(SymbolicExpr::multiply(
                SymbolicExpr::number(-normalized_c), SymbolicExpr::variable(x))));
    } else {
        auto roots = ode_root_detail::find_characteristic_roots(
            {a, b, c}, kSolveLinear2OdeOperation);
        if (!roots) {
            return Result<std::shared_ptr<SymbolicExpr>>::failure(roots.error());
        }
        solution = linear2_root_basis(roots.value(), x);
    }
    solution = detail::make_expression_ptr(detail::normalize_node(detail::node(solution), transform_budget));
    auto positive = dep_var_is_positive(y, ctx, context);
    if (!positive) { return ExpressionResult::failure(positive.error()); }
    if (positive.value()) {
        solution = make_abs(solution);
    }
    return Result<std::shared_ptr<SymbolicExpr>>::success(
        std::move(solution));
} catch (const CasError& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(CasErrc::ResourceLimit, "allocation failed", "solve_linear2_homogeneous");
} catch (const std::length_error& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(CasErrc::ResourceLimit, error.what(), "solve_linear2_homogeneous");
} catch (const std::exception& error) {
    return Result<std::shared_ptr<SymbolicExpr>>::failure(CasErrc::InternalInvariant, error.what(), "solve_linear2_homogeneous");
}

引用了 a, b, c, context, dep_var_is_positive(), LMCAS::Result< T >::error(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::ode_root_detail::find_characteristic_roots(), InvalidArgument, linear2_root_basis(), make_abs(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), NumericFailure, roots(), solve_linear2_homogeneous() , 以及 LMCAS::Result< T >::value().

被这些函数引用 solve_linear2_homogeneous(), solve_linear2_ode() , 以及 solve_linear2_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_linear2_ode()

std::shared_ptr< SymbolicExpr > LMCAS::solve_linear2_ode	(	double	a,
		double	b,
		double	c,
		std::shared_ptr< SymbolicExpr >	fx,
		const std::string &	x,
		const std::string &	y,
		const AssumptionContext *	ctx )

在文件 symbolic_ode.cpp 第 271 行定义.

  {
    ComputationContext context;
    if (!fx || !LMCAS::detail::node(fx)) {
        throw std::invalid_argument(
            "solve_linear2_ode: forcing expression must not be null");
    }
    if (!fx->is_zero()) {
        throw std::logic_error(
            "solve_linear2_ode: non-homogeneous case is outside the current support domain");
    }
    auto solution = solve_linear2_homogeneous(a, b, c, x, y, ctx, context);
    if (!solution) {
        if (solution.error().code == CasErrc::InvalidArgument) {
            throw std::invalid_argument(solution.error().message);
        }
        if (solution.error().code == CasErrc::NumericFailure) {
            throw std::overflow_error(solution.error().message);
        }
        throw std::logic_error(solution.error().message);
    }
    return std::move(solution.value());
}

引用了 a, b, c, context, InvalidArgument, LMCAS::detail::node(), NumericFailure, solve_linear2_homogeneous() , 以及 solve_linear2_ode().

被这些函数引用 solve_linear2_ode().

函数调用图:

这是这个函数的调用关系图:

solve_linear2_ode_checked() [1/2]

Result< std::shared_ptr< SymbolicExpr > > LMCAS::solve_linear2_ode_checked	(	double	a,
		double	b,
		double	c,
		std::shared_ptr< SymbolicExpr >	fx,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context,
		const AssumptionContext *	ctx )

在文件 symbolic_ode.cpp 第 300 行定义.

  {
    auto step = context.consume_steps(1, kSolveLinear2OdeOperation);
    if (!step) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(step.error());
    }
 
    if (!fx || !LMCAS::detail::node(fx)) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::InvalidArgument,
            "forcing expression must not be null",
            kSolveLinear2OdeOperation);
    }
    if (x.empty() || y.empty()) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::InvalidArgument,
            "ODE variables must not be empty",
            kSolveLinear2OdeOperation);
    }
 
    try {
        if (!fx->is_zero()) {
            return Result<std::shared_ptr<SymbolicExpr>>::failure(
                CasErrc::Inconclusive,
                "non-homogeneous second-order constant-coefficient ODEs are outside the current support domain",
                kSolveLinear2OdeOperation);
        }
 
        return solve_linear2_homogeneous(a, b, c, x, y, ctx, context);
    } catch (const std::invalid_argument& ex) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::InvalidArgument, ex.what(), kSolveLinear2OdeOperation);
    } catch (const std::bad_alloc&) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::ResourceLimit,
            "ODE solving allocation failed",
            kSolveLinear2OdeOperation);
    } catch (const std::logic_error& ex) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::Inconclusive, ex.what(), kSolveLinear2OdeOperation);
    } catch (const std::exception& ex) {
        return Result<std::shared_ptr<SymbolicExpr>>::failure(
            CasErrc::InternalInvariant, ex.what(), kSolveLinear2OdeOperation);
    }
}

引用了 a, b, c, context, Inconclusive, InternalInvariant, InvalidArgument, LMCAS::detail::node(), ResourceLimit, solve_linear2_homogeneous() , 以及 solve_linear2_ode_checked().

被这些函数引用 solve_linear2_ode_checked() , 以及 solve_linear2_ode_checked().

函数调用图:

这是这个函数的调用关系图:

solve_linear2_ode_checked() [2/2]

Result< std::shared_ptr< SymbolicExpr > > LMCAS::solve_linear2_ode_checked	(	double	a,
		double	b,
		double	c,
		std::shared_ptr< SymbolicExpr >	fx,
		const std::string &	x,
		const std::string &	y,
		const AssumptionContext *	ctx )

在文件 symbolic_ode.cpp 第 352 行定义.

  {
    ComputationContext context;
    return solve_linear2_ode_checked(a, b, c, std::move(fx), x, y, context, ctx);
}

引用了 a, b, c, context , 以及 solve_linear2_ode_checked().

函数调用图:

solve_mixed_transcendental_checked() [1/2]

MixedTranscendentalResult LMCAS::solve_mixed_transcendental_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts )

在文件 solve_mixed_transcendental.cpp 第 515 行定义.

                                                    {
    ComputationContext context;
    return solve_mixed_transcendental_checked(expr, var, opts, context);
}

引用了 context , 以及 solve_mixed_transcendental_checked().

函数调用图:

solve_mixed_transcendental_checked() [2/2]

MixedTranscendentalResult LMCAS::solve_mixed_transcendental_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts,
		ComputationContext &	context )

在文件 solve_mixed_transcendental.cpp 第 494 行定义.

                                                           {
    auto invalid = validate_mixed_input(expr, var, opts);
    if (invalid) {
        return MixedTranscendentalResult::failure(std::move(*invalid));
    }
    try {
        return solve_mixed_equation(expr, var, opts, context);
    } catch (const CasError& error) {
        return MixedTranscendentalResult::failure(error);
    } catch (const std::bad_alloc&) {
        return MixedTranscendentalResult::failure(
            CasErrc::ResourceLimit, "混合求解分配失败", mixed_operation);
    } catch (const std::length_error& error) {
        return MixedTranscendentalResult::failure(CasErrc::ResourceLimit, error.what(), mixed_operation);
    } catch (const std::exception& error) {
        return MixedTranscendentalResult::failure(CasErrc::InternalInvariant, error.what(), mixed_operation);
    }
}

引用了 context, LMCAS::Result< MathResult< std::vector< std::shared_ptr< SymbolicExpr > > > >::failure(), InternalInvariant, ResourceLimit , 以及 solve_mixed_transcendental_checked().

被这些函数引用 solve_finite_mixed(), solve_mixed_transcendental_checked() , 以及 solve_mixed_transcendental_checked().

函数调用图:

这是这个函数的调用关系图:

solve_numeric_checked() [1/2]

NumericRootsResult LMCAS::solve_numeric_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	opts )

在文件 newton_raphson.cpp 第 458 行定义.

{
    constexpr const char* operation = "solve_numeric";
    auto options = invalid_root_options(opts, operation);
    if (!options) {
        return NumericRootsResult::failure(options.error());
    }
    if (!expr) {
        return NumericRootsResult::failure(CasErrc::InvalidArgument,
                                           "expression cannot be null",
                                           operation);
    }
    if (var.empty()) {
        return NumericRootsResult::failure(CasErrc::InvalidArgument,
                                           "solve variable cannot be empty",
                                           operation);
    }
    if (opts.max_roots < -1) {
        return NumericRootsResult::failure(CasErrc::InvalidArgument,
                                           "maximum root count must be -1 or non-negative",
                                           operation);
    }
    if (opts.max_roots == 0) {
        return NumericRootsResult::success({});
    }
 
    auto initial_step = context.consume_steps(1, operation);
    if (!initial_step) {
        return NumericRootsResult::failure(initial_step.error());
    }
 
    auto recognized_poly = recognize_rational_polynomial(*expr, var, context);
    if (!recognized_poly) {
        return NumericRootsResult::failure(recognized_poly.error());
    }
 
    if (recognized_poly.value() && !recognized_poly.value()->is_zero() &&
        recognized_poly.value()->degree() >= 1) {
        return solve_isolated_polynomial(
            expr, var, *recognized_poly.value(), context, opts);
    }
    return solve_initial_guess(expr, var, context, opts);
}

引用了 context, LMCAS::Result< std::vector< NumericRoot > >::failure(), InvalidArgument, LMCAS::SolveOptions::max_roots, options, recognize_rational_polynomial(), solve_numeric_checked() , 以及 LMCAS::Result< std::vector< NumericRoot > >::success().

函数调用图:

solve_numeric_checked() [2/2]

NumericRootsResult LMCAS::solve_numeric_checked	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const SolveOptions &	opts )

在文件 newton_raphson.cpp 第 449 行定义.

{
    ComputationContext context;
    return solve_numeric_checked(expr, var, context, opts);
}

引用了 context , 以及 solve_numeric_checked().

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::polish_value(), solve_numeric_checked() , 以及 solve_numeric_checked().

函数调用图:

这是这个函数的调用关系图:

solve_product_factor()

SolveResult LMCAS::solve_product_factor ( const detail::SymbolicNodePtr & node, const std::string & variable, ComputationContext & context, const SolveOptions & options, std::size_t & multiplicity )

static

在文件 solve_visitor.cpp 第 225 行定义.

                             {
    auto factor = detail::make_expression_ptr(node);
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        BigInt exponent;
        if (try_get_integer_value(
                std::dynamic_pointer_cast<const NumberNode>(power->exponent()), exponent)) {
            if (exponent <= BigInt(0)) { return SolutionSet{EmptySolutions{}}; }
            if (exponent > BigInt(static_cast<std::int64_t>(std::numeric_limits<int>::max()))) {
                return SolveResult::failure(CasErrc::ResourceLimit, "root multiplicity overflow", "solve.product");
            }
            multiplicity = static_cast<std::size_t>(*exponent.try_to_int64());
            factor = detail::make_expression_ptr(power->base());
        }
    }
    return solve_equation(factor, variable, context, options);
}

引用了 context, exponent, LMCAS::Result< SolutionSet >::failure(), LMCAS::detail::make_expression_ptr(), options, ResourceLimit, solve_equation(), solve_product_factor(), try_get_integer_value() , 以及 variable.

被这些函数引用 solve_product_factor() , 以及 solve_product_set().

函数调用图:

这是这个函数的调用关系图:

solve_product_set()

std::optional< SolveResult > LMCAS::solve_product_set ( const ExprPtr & expression, const std::string & variable, ComputationContext & context, const SolveOptions & options )

static

在文件 solve_visitor.cpp 第 290 行定义.

                                                                                         {
    auto product = std::dynamic_pointer_cast<const MultiplyNode>(detail::node(expression));
    if (!product) { return std::nullopt; }
    std::vector<FiniteSolution> finite;
    std::vector<ParametricSolution> families;
    const auto original_names = detail::all_variable_names(detail::node(expression));
    for (const auto& node : product->operands()) {
        std::size_t multiplicity = 1;
        auto solved = solve_product_factor(node, variable, context, options, multiplicity);
        if (!solved) {
            if (solved.error().code == CasErrc::Inconclusive) { return conditional_equation(expression, variable); }
            return SolveResult::failure(solved.error());
        }
        if (std::holds_alternative<EmptySolutions>(solved.value())) { continue; }
        if (std::holds_alternative<UniversalSolutions>(solved.value())) { return conditional_equation(expression, variable); }
        if (auto values = std::get_if<FiniteSolutions>(&solved.value())) {
            auto appended = append_product_roots(*values, multiplicity, finite);
            if (!appended) { return SolveResult::failure(appended.error()); }
        } else if (auto values = std::get_if<ParametricSolutions>(&solved.value())) {
            append_product_families(*values, original_names, families);
        } else { return conditional_equation(expression, variable); }
    }
    if (!finite.empty() && !families.empty()) { return conditional_equation(expression, variable); }
    if (!families.empty()) { return SolveResult::success(SolutionSet{ParametricSolutions{std::move(families)}}); }
    if (!finite.empty()) { return SolveResult::success(SolutionSet{FiniteSolutions{std::move(finite)}}); }
    return SolveResult::success(SolutionSet{EmptySolutions{}});
}

引用了 LMCAS::detail::all_variable_names(), append_product_families(), append_product_roots(), conditional_equation(), context, LMCAS::Result< SolutionSet >::failure(), Inconclusive, LMCAS::detail::node(), options, solve_product_factor(), solve_product_set(), LMCAS::Result< SolutionSet >::success() , 以及 variable.

被这些函数引用 dispatch_equation() , 以及 solve_product_set().

函数调用图:

这是这个函数的调用关系图:

solve_quartic()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::solve_quartic	(	const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		const std::shared_ptr< SymbolicExpr > &	c,
		const std::shared_ptr< SymbolicExpr > &	d,
		const std::shared_ptr< SymbolicExpr > &	e,
		const std::string &	variable )

在文件 solve_polynomial_quartic.cpp 第 48 行定义.

                               {
    ComputationContext context;
    return solve_quartic_impl(a, b, c, d, e, variable, context);
}

引用了 a, b, c, context, e(), solve_quartic(), LMCAS::polynomial_solver_detail::solve_quartic_impl() , 以及 variable.

被这些函数引用 solve_closed_form_from_poly() , 以及 solve_quartic().

函数调用图:

这是这个函数的调用关系图:

solve_separable_ode()

ExprPtr LMCAS::solve_separable_ode	(	ExprPtr	rhs,
		const std::string &	x,
		const std::string &	y,
		const AssumptionContext *	ctx )

在文件 symbolic_ode.cpp 第 73 行定义.

                                                                             {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (!is_separable(rhs, x, y)) {
        return nullptr;
    }
 
    std::shared_ptr<SymbolicExpr> f;
    std::shared_ptr<SymbolicExpr> g;
    const auto& root = detail::node(rhs);
    if (!expression_depends_on_variable(root, y)) {
        f = rhs;
        g = SymbolicExpr::number(1);
    } else if (!expression_depends_on_variable(root, x)) {
        f = SymbolicExpr::number(1);
        g = rhs;
    } else {
        // The shared classifier guarantees a product of uncoupled factors here.
        const auto& product = static_cast<const MultiplyNode&>(*root);
        std::vector<std::shared_ptr<const SymbolicNode>> x_factors;
        std::vector<std::shared_ptr<const SymbolicNode>> y_factors;
        for (const auto& factor : product.operands()) {
            auto& factors = expression_depends_on_variable(factor, y) ? y_factors : x_factors;
            factors.push_back(factor);
        }
        f = detail::make_expression_ptr(detail::make_node<MultiplyNode>(std::move(x_factors)));
        g = detail::make_expression_ptr(detail::make_node<MultiplyNode>(std::move(y_factors)));
    }
 
    auto inv_y = detail::make_expression_ptr(detail::normalize_node(reciprocal_on_regular_region(detail::node(g)), transform_budget));
    Integrator integrator;
    auto integrated_y = integrator.integrate_checked(*inv_y, y, context);
    if (!integrated_y) { throw integrated_y.error(); }
    auto int_y = std::make_shared<SymbolicExpr>(std::move(integrated_y.value()));
    auto normalized_f = detail::make_expression_ptr(
        detail::normalize_node(detail::node(f), transform_budget));
    auto integrated_x = integrator.integrate_checked(*normalized_f, x, context);
    if (!integrated_x) { throw integrated_x.error(); }
    auto int_x = std::make_shared<SymbolicExpr>(std::move(integrated_x.value()));
    auto result = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(
        int_y, SymbolicExpr::multiply(SymbolicExpr::number(-1), int_x))), transform_budget));
 
    // Preserve the existing positive-context branch marker.
    auto positive = dep_var_is_positive(y, ctx, context);
    if (!positive) { throw positive.error(); }
    if (positive.value()) {
        result = make_abs(result);
    }
 
    return result;
}

引用了 context, dep_var_is_positive(), expression_depends_on_variable(), integrator, is_separable(), make_abs(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), rhs , 以及 solve_separable_ode().

被这些函数引用 solve_separable_ode().

函数调用图:

这是这个函数的调用关系图:

solve_set() [1/2]

SolveResult LMCAS::solve_set	(	const ExprPtr &	equation,
		const std::string &	variable,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 10 行定义.

                                                   {
    if (!equation) {
        return SolveResult::failure(CasErrc::InvalidArgument,
                                    "equation cannot be null", "LMCAS.solve_set");
    }
    if (variable.empty()) {
        return SolveResult::failure(CasErrc::InvalidArgument,
                                    "solve variable cannot be empty",
                                    "LMCAS.solve_set");
    }
    return solve_equation(equation, variable, context, options);
}

引用了 context, LMCAS::Result< SolutionSet >::failure(), InvalidArgument, options, solve_equation(), solve_set() , 以及 variable.

被这些函数引用 project_finite_expr_set(), solve_set() , 以及 solve_set().

函数调用图:

这是这个函数的调用关系图:

solve_set() [2/2]

SolveResult LMCAS::solve_set	(	const ExprPtr &	equation,
		const std::string &	variable,
		const SolveOptions &	options )

在文件 expr_solving.cpp 第 26 行定义.

                                                   {
    ComputationContext context;
    return solve_set(equation, variable, context, options);
}

引用了 context, options, solve_set() , 以及 variable.

函数调用图:

solve_set_core()

SolveResult LMCAS::solve_set_core ( const std::shared_ptr< SymbolicExpr > & expr, const std::string & var, ComputationContext & context, const SolveOptions & opts )

static

在文件 solve_visitor.cpp 第 555 行定义.

                                  {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "solve_dispatch_set";
    if (!expr || !LMCAS::detail::node(expr)) {
        return SolveResult::failure(CasErrc::InvalidArgument,
                                          "expression cannot be null",
                                          operation);
    }
    if (var.empty()) {
        return SolveResult::failure(CasErrc::InvalidArgument,
                                          "solve variable cannot be empty",
                                          operation);
    }
 
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(expr), transform_budget));
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return SolveResult::failure(CasErrc::InvalidArgument,
                                          "expression simplification failed",
                                          operation);
    }
 
    std::shared_ptr<SymbolicExpr> f_expr = simplified;
    if (auto rel = std::dynamic_pointer_cast<const RelationalNode>(LMCAS::detail::node(simplified))) {
        if (rel->op() == RelationalNode::Op::EQ) {
            auto left = LMCAS::detail::make_expression_ptr(rel->left());
            auto right = LMCAS::detail::make_expression_ptr(rel->right());
            f_expr = SymbolicExpr::add(
                left, SymbolicExpr::multiply(right, SymbolicExpr::number(-1)));
        }
    }
 
    auto polynomial = symbolic_to_poly<SymbolicPolyCoeff>(f_expr, var);
    if (polynomial) {
        return solve_symbolic_polynomial_set(polynomial.value(), expr, var, context);
    }
    if (polynomial.error().code != CasErrc::UnsupportedExpression) {
        return SolveResult::failure(polynomial.error());
    }
 
    auto transcendental = solve_transcendental(f_expr, var, context, opts);
    if (transcendental) return transcendental;
    if (transcendental.error().code != CasErrc::Inconclusive) {
        return SolveResult::failure(transcendental.error());
    }
 
    if (auto mixed = solve_finite_mixed(f_expr, var, context, opts)) {
        return finite_values_to_set(std::move(*mixed));
    }
 
 
    return SolveResult::failure(CasErrc::Inconclusive,
        "expression is outside the supported finite exact solve domain", operation);
} catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_dispatch_set");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve_dispatch_set");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve_dispatch_set");
}

引用了 context, LMCAS::Result< SolutionSet >::failure(), finite_values_to_set(), Inconclusive, InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), right, solve_finite_mixed(), solve_set_core(), solve_symbolic_polynomial_set(), solve_transcendental() , 以及 UnsupportedExpression.

被这些函数引用 dispatch_equation() , 以及 solve_set_core().

函数调用图:

这是这个函数的调用关系图:

solve_symbolic_polynomial_set()

SolveResult LMCAS::solve_symbolic_polynomial_set ( const Polynomial< SymbolicPolyCoeff > & polynomial, const ExprPtr & original, const std::string & variable, ComputationContext & context )

static

在文件 solve_visitor.cpp 第 167 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    std::optional<detail::AssumptionFacts> adapter;
    if (context.assumptions()) {
        adapter.emplace(*context.assumptions());
    }
    const FactsQuery& facts = adapter
        ? static_cast<const FactsQuery&>(*adapter)
        : detail::no_facts();
    int degree = polynomial.degree();
    while (degree >= 0) {
        auto leading = detail::make_expression_ptr(detail::normalize_node(detail::node(get_coeff(polynomial, degree)), transform_budget));
        auto nonzero = detail::query_nonzero_value(
            detail::node(leading), facts, Domain::Complex, context);
        if (!nonzero) {
            return SolveResult::failure(nonzero.error());
        }
        if (nonzero.value() == Tribool::False) {
            --degree;
            continue;
        }
        if (nonzero.value() == Tribool::Unknown || degree >= 3) {
            return degree == 1
                ? conditional_linear_polynomial(
                    polynomial, leading, variable)
                : conditional_equation(original, variable);
        }
        if (degree == 0) {
            return SolutionSet{EmptySolutions{}};
        }
        if (degree == 2) {
            return solve_symbolic_quadratic(
                polynomial, leading, facts, context);
        }
        auto value = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
            SymbolicExpr::multiply(
                SymbolicExpr::number(-1),
                get_coeff(polynomial, 0)),
            leading)), transform_budget));
        return SolutionSet{FiniteSolutions{{
            FiniteSolution{value, 1, {}}}}};
    }
    return SolutionSet{UniversalSolutions{}};
} catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_symbolic_polynomial_set");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve_symbolic_polynomial_set");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve_symbolic_polynomial_set");
}

引用了 Complex, conditional_equation(), conditional_linear_polynomial(), context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< SolutionSet >::failure(), False, get_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::no_facts(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::query_nonzero_value(), solve_symbolic_polynomial_set(), solve_symbolic_quadratic(), Unknown, value , 以及 variable.

被这些函数引用 dispatch_equation(), solve_set_core() , 以及 solve_symbolic_polynomial_set().

函数调用图:

这是这个函数的调用关系图:

solve_symbolic_quadratic()

SolveResult LMCAS::solve_symbolic_quadratic ( const Polynomial< SymbolicPolyCoeff > & polynomial, const ExprPtr & leading, const FactsQuery & facts, ComputationContext & context )

static

在文件 solve_visitor.cpp 第 98 行定义.

                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto linear = get_coeff(polynomial, 1);
    auto constant = get_coeff(polynomial, 0);
    auto discriminant = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(
        SymbolicExpr::power(linear, SymbolicExpr::number(2)),
        SymbolicExpr::multiply(
            SymbolicExpr::number(-4),
            SymbolicExpr::multiply(leading, constant)))), transform_budget));
    auto nonzero = detail::query_nonzero_value(
        detail::node(discriminant), facts, Domain::Complex, context);
    if (!nonzero) {
        return SolveResult::failure(nonzero.error());
    }
 
    auto radical = detail::make_expression_ptr(
        detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Sqrt,
            std::vector<std::shared_ptr<const SymbolicNode>>{
                detail::node(discriminant)}));
    auto negative_linear =
        SymbolicExpr::multiply(SymbolicExpr::number(-1), linear);
    auto denominator =
        SymbolicExpr::multiply(SymbolicExpr::number(2), leading);
    auto positive = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
        SymbolicExpr::add(negative_linear, radical),
        denominator)), transform_budget));
    auto negative = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
        SymbolicExpr::add(
            negative_linear,
            SymbolicExpr::multiply(
                SymbolicExpr::number(-1), radical)),
        denominator)), transform_budget));
    auto repeated =
        detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(negative_linear, denominator)), transform_budget));
 
    if (nonzero.value() == Tribool::False) {
        return SolutionSet{FiniteSolutions{{
            FiniteSolution{repeated, 2, {}}}}};
    }
    if (nonzero.value() == Tribool::True) {
        return SolutionSet{FiniteSolutions{{
            FiniteSolution{positive, 1, {}},
            FiniteSolution{negative, 1, {}}}}};
    }
 
    auto zero = SymbolicExpr::number(0);
    auto distinct =
        polynomial_relation(discriminant, zero, RelationOp::NEQ);
    auto coincident =
        polynomial_relation(discriminant, zero, RelationOp::EQ);
    return SolutionSet{FiniteSolutions{{
        FiniteSolution{positive, 1, {distinct}},
        FiniteSolution{negative, 1, {distinct}},
        FiniteSolution{positive, 2, {coincident}}}}};
} catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_symbolic_quadratic");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve_symbolic_quadratic");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve_symbolic_quadratic");
}

引用了 Complex, context, denominator, EQ, LMCAS::Result< SolutionSet >::failure(), False, get_coeff(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), NEQ, LMCAS::detail::node(), LMCAS::detail::normalize_node(), polynomial_relation(), LMCAS::detail::query_nonzero_value(), solve_symbolic_quadratic(), LMCAS::FunctionNode::Sqrt , 以及 True.

被这些函数引用 solve_symbolic_polynomial_set() , 以及 solve_symbolic_quadratic().

函数调用图:

这是这个函数的调用关系图:

solve_transcendental() [1/2]

SolveResult LMCAS::solve_transcendental	(	const ExprPtr &	expr,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	options )

在文件 solve_transcendental.cpp 第 329 行定义.

                                                                  {
    if (!expr || !detail::node(expr) || var.empty()) {
        return SolveResult::failure(CasErrc::InvalidArgument,
            "Expression and variable must not be empty", "solve.transcendental");
    }
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                            context.limits().max_ast_nodes,
                                            "solve.transcendental");
    auto equation = expr;
    if (auto relation = std::dynamic_pointer_cast<const RelationalNode>(detail::node(expr))) {
        if (relation->op() != RelationalNode::Op::EQ) {
            return SolveResult::failure(CasErrc::InvalidArgument,
                "Expected an equality", "solve.transcendental");
        }
        equation = SymbolicExpr::add(detail::make_expression_ptr(relation->left()),
            SymbolicExpr::multiply(SymbolicExpr::number(-1),
                detail::make_expression_ptr(relation->right())));
    }
    equation = detail::make_expression_ptr(detail::normalize_node(detail::node(equation), transform_budget));
    auto solved = std::dynamic_pointer_cast<const MultiplyNode>(detail::node(equation)) ?
        solve_equation(equation, var, context, options) :
        solve_transcendental_impl(expr, equation, var, context, options, 0);
    if (!solved) return solved;
    auto coalesced = coalesce_periodic_families(solved.value(), context);
    if (!coalesced) return SolveResult::failure(coalesced.error());
    return detail::finalize_solution_set(expr, var, std::move(solved).value(), context, Domain::Real, options);
}
catch (const CasError& error) {
    return SolveResult::failure(error);
} catch (const std::bad_alloc&) {
    return SolveResult::failure(CasErrc::ResourceLimit,
        "transcendental solve allocation failed", "solve.transcendental");
} catch (const std::length_error& error) {
    return SolveResult::failure(CasErrc::ResourceLimit, error.what(), "solve.transcendental");
} catch (const std::exception& error) {
    return SolveResult::failure(CasErrc::InternalInvariant, error.what(), "solve.transcendental");
}

引用了 context, LMCAS::Result< SolutionSet >::failure(), LMCAS::detail::finalize_solution_set(), InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), options, Real, relation(), solve_equation(), solve_transcendental() , 以及 value.

被这些函数引用 solve_set_core(), solve_transcendental(), solve_transcendental() , 以及 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_transcendental_factor().

函数调用图:

这是这个函数的调用关系图:

solve_transcendental() [2/2]

SolveResult LMCAS::solve_transcendental	(	const ExprPtr &	expr,
		const std::string &	var,
		const SolveOptions &	options )

在文件 solve_transcendental.cpp 第 369 行定义.

                                                                            {
    ComputationContext context;
    return solve_transcendental(expr, var, context, options);
}

引用了 context, options , 以及 solve_transcendental().

函数调用图:

solve_variation_of_parameters_checked() [1/2]

ODESolutionResult LMCAS::solve_variation_of_parameters_checked	(	const std::shared_ptr< SymbolicExpr > &	y1,
		const std::shared_ptr< SymbolicExpr > &	y2,
		const std::shared_ptr< SymbolicExpr > &	g,
		const std::string &	x )

在文件 ode_advanced.cpp 第 72 行定义.

{
    ComputationContext context;
    return solve_variation_of_parameters_checked(y1, y2, g, x, context);
}

引用了 context , 以及 solve_variation_of_parameters_checked().

函数调用图:

solve_variation_of_parameters_checked() [2/2]

ODESolutionResult LMCAS::solve_variation_of_parameters_checked	(	const std::shared_ptr< SymbolicExpr > &	y1,
		const std::shared_ptr< SymbolicExpr > &	y2,
		const std::shared_ptr< SymbolicExpr > &	g,
		const std::string &	x,
		ComputationContext &	context )

在文件 ode_advanced.cpp 第 31 行定义.

{
    const std::string operation = "solve_variation_of_parameters";
    auto valid = validate_ode_three_expr_one_var(y1, y2, g, x, context, operation);
    if (!valid) {
        return ODESolutionResult::failure(valid.error());
    }
 
    auto budget = context.consume_steps(24, operation);
    if (!budget) {
        return ODESolutionResult::failure(budget.error());
    }
 
    try {
        auto solved = solve_variation_of_parameters_core(
            y1, y2, g, x, context);
        if (!solved) {
            return solved;
        }
        return wrap_ode_solution(
            std::move(solved.value()),
            ODEType::HigherOrder_ConstCoeff,
            operation);
    } catch (const std::bad_alloc&) {
        return ODESolutionResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while applying variation of parameters",
            operation);
    } catch (const std::exception& ex) {
        return ODESolutionResult::failure(
            CasErrc::InternalInvariant,
            ex.what(),
            operation);
    }
}

引用了 context, LMCAS::Result< ODESolution >::failure(), HigherOrder_ConstCoeff, InternalInvariant, ResourceLimit, solve_variation_of_parameters_checked(), solve_variation_of_parameters_core(), validate_ode_three_expr_one_var() , 以及 wrap_ode_solution().

被这些函数引用 solve_variation_of_parameters_checked() , 以及 solve_variation_of_parameters_checked().

函数调用图:

这是这个函数的调用关系图:

solve_variation_of_parameters_core()

ODESolutionResult LMCAS::solve_variation_of_parameters_core ( const std::shared_ptr< SymbolicExpr > & y1, const std::shared_ptr< SymbolicExpr > & y2, const std::shared_ptr< SymbolicExpr > & g, const std::string & x, ComputationContext & context )

static

计算 y₁' 和 y₂'

计算 Wronskian: W = y₁·y₂' - y₂·y₁'

计算 u₁' = -y₂·g(x)/W

计算 u₂' = y₁·g(x)/W

特解: y_p = u₁·y₁ + u₂·y₂

在文件 ode_advanced.cpp 第 82 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    /// 计算 y₁' 和 y₂'
    auto y1_prime = detail::make_expression_ptr(detail::differentiate_node(detail::node(y1), x, transform_budget));
    auto y2_prime = detail::make_expression_ptr(detail::differentiate_node(detail::node(y2), x, transform_budget));
 
    /// 计算 Wronskian: W = y₁·y₂' - y₂·y₁'
    auto term1 = SymbolicExpr::multiply(y1, y2_prime);
    auto term2 = SymbolicExpr::multiply(y2, y1_prime);
    auto W = SymbolicExpr::add(term1,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), term2));
    W = detail::make_expression_ptr(detail::normalize_node(detail::node(W), transform_budget));
    EqvOptions trig_options;
    trig_options.profile = EqvProfile::TrigBasic;
    auto unit_wronskian = check_equivalent(
        W, SymbolicExpr::number(1), context, trig_options);
    if (!unit_wronskian) {
        return ODESolutionResult::failure(unit_wronskian.error());
    }
    if (std::holds_alternative<ProvedZeroResidual>(
            unit_wronskian.value())) {
        W = SymbolicExpr::number(1);
    }
 
    if (W->is_zero()) {
        return ODESolution{};
    }
 
    /// 计算 u₁' = -y₂·g(x)/W
    auto u1_prime = SymbolicExpr::divide(
        SymbolicExpr::multiply(SymbolicExpr::number(-1),
            SymbolicExpr::multiply(y2, g)),
        W);
    u1_prime = detail::make_expression_ptr(detail::normalize_node(detail::node(u1_prime), transform_budget));
 
    /// 计算 u₂' = y₁·g(x)/W
    auto u2_prime = SymbolicExpr::divide(
        SymbolicExpr::multiply(y1, g),
        W);
    u2_prime = detail::make_expression_ptr(detail::normalize_node(detail::node(u2_prime), transform_budget));
 
    Integrator integrator;
    auto u1_value =
        integrator.integrate_checked(*u1_prime, x, context);
    if (!u1_value) {
        return ODESolutionResult::failure(u1_value.error());
    }
    auto u2_value =
        integrator.integrate_checked(*u2_prime, x, context);
    if (!u2_value) {
        return ODESolutionResult::failure(u2_value.error());
    }
    auto u1 = std::make_shared<SymbolicExpr>(
        std::move(u1_value.value()));
    auto u2 = std::make_shared<SymbolicExpr>(
        std::move(u2_value.value()));
 
    /// 特解: y_p = u₁·y₁ + u₂·y₂
    auto y_p = SymbolicExpr::add(
        SymbolicExpr::multiply(u1, y1),
        SymbolicExpr::multiply(u2, y2));
    y_p = detail::make_expression_ptr(detail::normalize_node(detail::node(y_p), transform_budget));
 
    ODESolution result{};
    result.method_used = ODEType::HigherOrder_ConstCoeff;
    result.general_solution = std::move(y_p);
    return result;
} catch (const CasError& error) {
    return ODESolutionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ODESolutionResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_variation_of_parameters_core");
} catch (const std::length_error& error) {
    return ODESolutionResult::failure(CasErrc::ResourceLimit, error.what(), "solve_variation_of_parameters_core");
} catch (const std::exception& error) {
    return ODESolutionResult::failure(CasErrc::InternalInvariant, error.what(), "solve_variation_of_parameters_core");
}

引用了 check_equivalent(), context, LMCAS::detail::differentiate_node(), LMCAS::Result< ODESolution >::failure(), LMCAS::ODESolution::general_solution, HigherOrder_ConstCoeff, integrator, LMCAS::detail::make_expression_ptr(), LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::EqvOptions::profile, solve_variation_of_parameters_core() , 以及 TrigBasic.

被这些函数引用 solve_variation_of_parameters_checked() , 以及 solve_variation_of_parameters_core().

函数调用图:

这是这个函数的调用关系图:

solve_with_assumptions_checked() [1/2]

AssumptionSolveResult LMCAS::solve_with_assumptions_checked	(	const std::shared_ptr< SymbolicExpr > &	equation,
		const std::string &	variable,
		const AssumptionContext *	assumptions )

在文件 solver_assumptions.cpp 第 294 行定义.

{
    ComputationContext context;
    return solve_with_assumptions_checked(
        equation, variable, assumptions, context);
}

引用了 context, solve_with_assumptions_checked() , 以及 variable.

函数调用图:

solve_with_assumptions_checked() [2/2]

AssumptionSolveResult LMCAS::solve_with_assumptions_checked	(	const std::shared_ptr< SymbolicExpr > &	equation,
		const std::string &	variable,
		const AssumptionContext *	assumptions,
		ComputationContext &	context )

在文件 solver_assumptions.cpp 第 260 行定义.

{
    constexpr const char* operation = "solve_with_assumptions";
    if (!equation || variable.empty()) {
        return AssumptionSolveResult::failure(
            CasErrc::InvalidArgument,
            "assumption-aware solve requires an equation and variable",
            operation);
    }
    auto budget = context.consume_steps(1, operation);
    if (!budget) {
        return AssumptionSolveResult::failure(budget.error());
    }
    try {
        return solve_with_assumptions_impl(
            equation, variable, assumptions, context);
    } catch (const CasError& error) {
        return AssumptionSolveResult::failure(error);
    } catch (const std::bad_alloc&) {
        return AssumptionSolveResult::failure(
            CasErrc::ResourceLimit,
            "allocation failed while solving with assumptions",
            operation);
    } catch (const std::length_error& error) {
        return AssumptionSolveResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& ex) {
        return AssumptionSolveResult::failure(CasErrc::InternalInvariant, ex.what(), operation);
    }
}

引用了 context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), InternalInvariant, InvalidArgument, ResourceLimit, solve_with_assumptions_checked(), solve_with_assumptions_impl() , 以及 variable.

被这些函数引用 solve_with_assumptions_checked() , 以及 solve_with_assumptions_checked().

函数调用图:

这是这个函数的调用关系图:

solve_with_assumptions_impl()

AssumptionSolveResult LMCAS::solve_with_assumptions_impl ( const std::shared_ptr< SymbolicExpr > & equation, const std::string & variable, const AssumptionContext * ctx, ComputationContext & context )

static

在文件 solver_assumptions.cpp 第 214 行定义.

{
    auto solved = solve_finite_checked(
        std::const_pointer_cast<SymbolicExpr>(equation), variable, context);
    if (!solved) {
        return AssumptionSolveResult::failure(solved.error());
    }
    auto all_solutions = std::move(solved.value());
 
    if (!ctx) {
        return all_solutions;
    }
 
    Domain domain = ctx->get_domain(variable);
 
    std::vector<std::shared_ptr<SymbolicExpr>> filtered;
    filtered.reserve(all_solutions.size());
 
    bool has_sign_constraint = ctx->has_sign(variable, Sign::NonNegative) ||
                               ctx->has_sign(variable, Sign::Positive) ||
                               ctx->has_sign(variable, Sign::Negative) ||
                               ctx->has_sign(variable, Sign::NonPositive);
 
    if (domain == Domain::Complex && !has_sign_constraint) {
        return all_solutions;
    }
 
    for (const auto& sol : all_solutions) {
        if (!sol) {
            continue;
        }
 
        auto excluded = solution_is_excluded(sol, domain, *ctx, variable, context);
        if (!excluded) return AssumptionSolveResult::failure(excluded.error());
        if (!excluded.value()) {
            filtered.push_back(sol);
        }
    }
 
    return filtered;
}

引用了 Complex, context, domain, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Negative, NonNegative, NonPositive, Positive, solution_is_excluded(), solve_finite_checked(), solve_with_assumptions_impl() , 以及 variable.

被这些函数引用 solve_with_assumptions_checked() , 以及 solve_with_assumptions_impl().

函数调用图:

这是这个函数的调用关系图:

sqrt() [1/2]

ExprResult LMCAS::sqrt

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 22 行定义.

                                           {
    ComputationContext context;
    return sqrt(expression, context);
}

引用了 context , 以及 sqrt().

函数调用图:

sqrt() [2/2]

ExprResult LMCAS::sqrt	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 16 行定义.

                                                                        {
    auto exponent = rational(Rational(1, 2));
    if (!exponent) { return exponent; }
    return quantity_power(expression, exponent.value(), context);
}

引用了 context, exponent, quantity_power(), rational() , 以及 sqrt().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), sqrt() , 以及 sqrt().

函数调用图:

这是这个函数的调用关系图:

square_free_decompose()

SquareFreeDecomp LMCAS::square_free_decompose	(	const MultiPoly &	poly,
		const std::string &	main_var )

多元无平方因子分解(Yun 算法的多元推广)

通过计算 gcd(f, partialf/partialx_main) 检测重因子,将多项式分解为 f = f_1 * f_2^2 * f₃^3 * ... 的形式,其中每个 fᵢ 无平方.

参数

[in]	poly	输入多元多项式
[in]	main_var	主变量名

返回

无平方因子分解结果,components[i] 的重数为 i+1

零多项式或常数多项式:直接返回

若 main_var 不在变量列表中或次数为 0,多项式无重因子

步骤 1:计算 f' = partialf/partialmain_var

步骤 2:计算 g = gcd(f, f');特征 0 下 f' 为零时,f 直接作为单个无平方因子.

步骤 3:若 g 为常数,f 已无平方

步骤 4:Yun 算法迭代提取无平方分量 w = f / g, y = f' / g, z = y - w'

w 是最后一个分量

过滤掉常数为 1 的平凡分量(保留结构但不影响语义) 注意:components[i] 的重数为 i+1

在文件 multivariate_factor.cpp 第 429 行定义.

{
    /// 零多项式或常数多项式:直接返回
    if (poly.is_zero() || poly.is_constant()) {
        return SquareFreeDecomp{{poly}};
    }
 
    /// 若 main_var 不在变量列表中或次数为 0,多项式无重因子
    const auto& vars = poly.variables();
    int var_idx = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == main_var) { var_idx = static_cast<int>(i); break; }
    }
    if (var_idx < 0 || poly.degree(main_var) <= 0) {
        return SquareFreeDecomp{{poly}};
    }
 
    /// 步骤 1:计算 f' = partialf/partialmain_var
    MultiPoly f_prime = formal_derivative(poly, main_var);
 
    /// 步骤 2:计算 g = gcd(f, f');特征 0 下 f' 为零时,f 直接作为单个无平方因子.
    if (f_prime.is_zero()) {
        return SquareFreeDecomp{{poly}};
    }
 
    MultiPoly g = multivariate_gcd(poly, f_prime);
 
    /// 步骤 3:若 g 为常数,f 已无平方
    if (g.is_constant()) {
        return SquareFreeDecomp{{poly}};
    }
 
    /// 步骤 4:Yun 算法迭代提取无平方分量
    /// w = f / g, y = f' / g, z = y - w'
    MultiPoly w = poly.exact_div(g);
    MultiPoly y = f_prime.exact_div(g);
    MultiPoly w_prime = formal_derivative(w, main_var);
    MultiPoly z = y - w_prime;
 
    std::vector<MultiPoly> components;
 
    while (!z.is_zero()) {
        MultiPoly component_i = multivariate_gcd(w, z);
        w = w.exact_div(component_i);
        y = z.exact_div(component_i);
        w_prime = formal_derivative(w, main_var);
        z = y - w_prime;
        components.push_back(std::move(component_i));
    }
 
    /// w 是最后一个分量
    components.push_back(std::move(w));
 
    /// 过滤掉常数为 1 的平凡分量(保留结构但不影响语义)
    /// 注意:components[i] 的重数为 i+1
    return SquareFreeDecomp{std::move(components)};
}

引用了 formal_derivative(), main_var, multivariate_gcd(), square_free_decompose() , 以及 vars.

被这些函数引用 square_free_decompose().

函数调用图:

这是这个函数的调用关系图:

square_free_factorization()

std::vector< std::pair< Polynomial< Rational >, int > > LMCAS::square_free_factorization

(

const Polynomial< Rational > &

poly

)

在文件 rational_square_free.cpp 第 6 行定义.

                                      {
 
    std::vector<std::pair<Polynomial<Rational>, int>> factors;
 
    if (poly.is_zero() || poly.degree() <= 0) {
        return factors;
    }
 
    Polynomial<Rational> f = poly.make_monic();
 
    if (f.degree() == 1) {
        factors.push_back({f, 1});
        return factors;
    }
 
    Polynomial<Rational> f_prime = f.differentiate();
    Polynomial<Rational> g = Polynomial<Rational>::gcd(f, f_prime);
 
    if (g.degree() <= 0) {
        factors.push_back({f, 1});
        return factors;
    }
 
    auto [w, w_rem] = f.div_mod(g);
 
    int multiplicity = 1;
 
    while (w.degree() > 0) {
 
        Polynomial<Rational> y = Polynomial<Rational>::gcd(g, w);
 
        auto [z, z_rem] = w.div_mod(y);
 
        if (z.degree() > 0) {
 
            factors.push_back({z.make_monic(), multiplicity});
        }
 
        auto [g_next, g_rem] = g.div_mod(y);
        g = g_next;
        w = y;
        multiplicity++;
    }
 
    if (g.degree() > 0) {
        factors.push_back({g.make_monic(), multiplicity});
    }
 
    return factors;
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::differentiate(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::make_monic() , 以及 square_free_factorization().

被这些函数引用 LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), LMCAS::polynomial_solver_detail::exact_polynomial_roots(), LMCAS::detail::factor_denominator(), LMCAS::detail::inequality_support::find_roots_with_multiplicity(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::solve_exact_polynomial_inequality_impl(), solve_exact_polynomial_set() , 以及 square_free_factorization().

函数调用图:

这是这个函数的调用关系图:

starts_with_at()

bool LMCAS::starts_with_at ( const std::string & str, size_t pos, const std::string & prefix )

static

在文件 interval_serialization.cpp 第 62 行定义.

                                                                                      {
    if (pos + prefix.size() > str.size()) {
        return false;
    }
    return str.compare(pos, prefix.size(), prefix) == 0;
}

引用了 starts_with_at().

被这些函数引用 parse_endpoint_value(), parse_numeric_value() , 以及 starts_with_at().

函数调用图:

这是这个函数的调用关系图:

stokes_theorem()

std::shared_ptr< SymbolicExpr > LMCAS::stokes_theorem	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	u_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	v_bounds )

计算旋度 ∇×F

计算 r_u × r_v（曲面法向量）

将 (∇×F) 中的坐标变量替换为参数化表达式，然后计算 (∇×F)·(r_u × r_v)

将 (∇×F)ᵢ 中的坐标变量替换为参数化表达式

(∇×F)ᵢ(r(u,v)) · (r_u × r_v)ᵢ

在文件 vector_calculus_integral_api.cpp 第 365 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (F.size() != 3) {
        throw std::invalid_argument("stokes_theorem: F must have 3 components");
    }
    if (vars.size() != 3) {
        throw std::invalid_argument("stokes_theorem: vars must have exactly 3 elements");
    }
    if (parametrization.size() != 3) {
        throw std::invalid_argument(
            "stokes_theorem: parametrization must have 3 components");
    }
    if (!u_bounds.first || !u_bounds.second ||
        !v_bounds.first || !v_bounds.second) {
        throw std::invalid_argument("stokes_theorem: bounds must not be null");
    }
 
    /// 计算旋度 ∇×F
    auto curl_F = curl_impl(F, vars, transform_budget);
 
    /// 计算 r_u × r_v（曲面法向量）
    auto cross = vector_calculus_cross_product_partials(parametrization, u, v, transform_budget);
 
    /// 将 (∇×F) 中的坐标变量替换为参数化表达式，然后计算 (∇×F)·(r_u × r_v)
    std::shared_ptr<SymbolicExpr> dot_product = nullptr;
 
    for (size_t i = 0; i < 3; ++i) {
        if (!curl_F[i]) {
            continue;
        }
 
        /// 将 (∇×F)ᵢ 中的坐标变量替换为参数化表达式
        auto curl_i_composed = curl_F[i];
        for (size_t j = 0; j < 3; ++j) {
            curl_i_composed = detail::make_expression_ptr(detail::substitute_node(detail::node(curl_i_composed), vars[j], detail::node(parametrization[j]), transform_budget));
        }
        curl_i_composed = detail::make_expression_ptr(detail::normalize_node(detail::node(curl_i_composed), transform_budget));
 
        /// (∇×F)ᵢ(r(u,v)) · (r_u × r_v)ᵢ
        auto term = SymbolicExpr::multiply(curl_i_composed, cross[i]);
        term = detail::make_expression_ptr(detail::normalize_node(detail::node(term), transform_budget));
 
        if (!dot_product) {
            dot_product = term;
        } else {
            dot_product = SymbolicExpr::add(dot_product, term);
            dot_product = detail::make_expression_ptr(detail::normalize_node(detail::node(dot_product), transform_budget));
        }
    }
 
    if (!dot_product) {
        return SymbolicExpr::number(0);
    }
 
    Integrator integrator;
 
    std::vector<IntegrationStep> steps = {
        {v, v_bounds.first, v_bounds.second},
        {u, u_bounds.first, u_bounds.second},
    };
    auto result = integrate_multiple_checked(*dot_product, steps, integrator, context);
    if (!result) throw result.error();
    return LMCAS::detail::make_expression_ptr(result.value());
}

引用了 context, LMCAS::vector_calculus_detail::curl_impl(), dot_product(), integrate_multiple_checked(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), parametrization, steps, stokes_theorem(), LMCAS::detail::substitute_node(), u, u_bounds, v, v_bounds, vars , 以及 LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials().

被这些函数引用 stokes_theorem().

函数调用图:

这是这个函数的调用关系图:

stokes_theorem_checked() [1/2]

VectorCalculusExprResult LMCAS::stokes_theorem_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	u_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	v_bounds )

在文件 vector_calculus_integral_api.cpp 第 352 行定义.

{
    ComputationContext context;
    return stokes_theorem_checked(F, vars, parametrization, u, v,
                                  u_bounds, v_bounds, context);
}

引用了 context, parametrization, stokes_theorem_checked(), u, u_bounds, v, v_bounds , 以及 vars.

函数调用图:

stokes_theorem_checked() [2/2]

VectorCalculusExprResult LMCAS::stokes_theorem_checked	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	u_bounds,
		const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	v_bounds,
		ComputationContext &	context )

在文件 vector_calculus_integral_api.cpp 第 306 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "stokes_theorem");
    const std::string operation = "stokes_theorem";
    auto field_valid = vector_calculus_validate_field_vars(F, vars, context, operation);
    if (!field_valid) {
        return VectorCalculusExprResult::failure(field_valid.error());
    }
    auto vars_valid = vector_calculus_validate_distinct_vars(vars, 3, context, operation);
    if (!vars_valid) {
        return VectorCalculusExprResult::failure(vars_valid.error());
    }
    auto param_valid = vector_calculus_validate_surface_parametrization(
        parametrization, u, v, u_bounds.first, u_bounds.second,
        v_bounds.first, v_bounds.second, context, operation);
    if (!param_valid) {
        return VectorCalculusExprResult::failure(param_valid.error());
    }
    auto step = context.consume_steps(18, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return stokes_theorem_strict(F, vars, parametrization, u, v, u_bounds, v_bounds, context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "Stokes theorem allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, parametrization, ResourceLimit, stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), u, u_bounds, v, v_bounds, vars, LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars(), LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars() , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_surface_parametrization().

被这些函数引用 stokes_theorem_checked() , 以及 stokes_theorem_checked().

函数调用图:

这是这个函数的调用关系图:

strip_to_base_value()

ExprResult LMCAS::strip_to_base_value	(	const ExprPtr &	quantity,
		ComputationContext &	context )

在文件 value_facade.cpp 第 31 行定义.

                                                            {
    return strip_unit(quantity, UnitStripMode::BaseValue, context);
}

引用了 BaseValue, context, strip_to_base_value() , 以及 strip_unit().

被这些函数引用 strip_to_base_value().

函数调用图:

这是这个函数的调用关系图:

strip_to_display_value()

ExprResult LMCAS::strip_to_display_value	(	const ExprPtr &	quantity,
		ComputationContext &	context )

在文件 value_facade.cpp 第 36 行定义.

                                                               {
    return strip_unit(quantity, UnitStripMode::DisplayValue, context);
}

引用了 context, DisplayValue, strip_to_display_value() , 以及 strip_unit().

被这些函数引用 strip_to_display_value().

函数调用图:

这是这个函数的调用关系图:

strip_unit()

QuantityResult LMCAS::strip_unit	(	const std::shared_ptr< SymbolicExpr > &	expression,
		UnitStripMode	mode,
		ComputationContext &	context )

在文件 quantity.cpp 第 181 行定义.

                                                       {
    auto step = context.consume_steps(1, kOperation);
    if (!step) return QuantityResult::failure(step.error());
    if (!expression || !detail::node(expression)) {
        return failure(CasErrc::InvalidArgument,
                       "unit stripping requires an expression");
    }
    auto quantity = std::dynamic_pointer_cast<const QuantityNode>(
        detail::node(expression));
    if (!quantity) return QuantityResult::success(expression);
    auto value = mode == UnitStripMode::BaseValue
        ? SymbolicFactory::create_multiply(
              {quantity->value(), rational_node(quantity->scale_to_base())})
        : quantity->value();
    return QuantityResult::success(detail::make_expression_ptr(std::move(value)));
}

引用了 BaseValue, context, LMCAS::SymbolicFactory::create_multiply(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InvalidArgument, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), strip_unit(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 value.

被这些函数引用 LMCAS::expr_detail::expr_common::comparison_value(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prepare_operands(), strip_to_base_value(), strip_to_display_value() , 以及 strip_unit().

函数调用图:

这是这个函数的调用关系图:

structurally_equal()

bool LMCAS::structurally_equal	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs )

在文件 equivalence_engine.cpp 第 189 行定义.

                                                                          {
    const auto& left = detail::node(lhs);
    const auto& right = detail::node(rhs);
    if (!left || !right) return left == right;
    return left->equals(*right);
}

引用了 LMCAS::detail::node(), rhs, right , 以及 structurally_equal().

被这些函数引用 LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_checked_operands(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands() , 以及 structurally_equal().

函数调用图:

这是这个函数的调用关系图:

sub() [1/2]

ExprResult LMCAS::sub	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs )

在文件 expr_arithmetic.cpp 第 68 行定义.

                                                       {
    ComputationContext context;
    return sub(lhs, rhs, context);
}

引用了 context, rhs , 以及 sub().

函数调用图:

sub() [2/2]

ExprResult LMCAS::sub	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		ComputationContext &	context )

在文件 expr_arithmetic.cpp 第 62 行定义.

                                            {
    return quantity_subtract(lhs, rhs, context);
}

引用了 context, quantity_subtract(), rhs , 以及 sub().

被这些函数引用 LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_binomial_power(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_common_monomial(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_difference_of_squares(), LMCAS::expr_detail::ExprParser::parse_additive(), sub(), sub() , 以及 symbolic_cubic_roots().

函数调用图:

这是这个函数的调用关系图:

substitute() [1/6]

ExprResult LMCAS::substitute	(	const ExprPtr &	expression,
		const Binding &	replacement )

在文件 expr_transform.cpp 第 116 行定义.

                                                  {
    ComputationContext context;
    return substitute(expression, replacement, context);
}

引用了 context , 以及 substitute().

函数调用图:

substitute() [2/6]

ExprResult LMCAS::substitute	(	const ExprPtr &	expression,
		const Binding &	replacement,
		ComputationContext &	context )

在文件 expr_transform.cpp 第 106 行定义.

                                                   {
    auto checked = binding(replacement.symbol, replacement.value);
    if (!checked) return ExprResult::failure(checked.error());
    const auto variable = std::dynamic_pointer_cast<const VariableNode>(
        LMCAS::detail::node(checked.value().symbol));
    return substitute(expression, variable->name(), checked.value().value, context);
}

引用了 binding, context, LMCAS::Result< ExprPtr >::failure(), LMCAS::detail::node(), substitute() , 以及 variable.

函数调用图:

substitute() [3/6]

ExprResult LMCAS::substitute	(	const ExprPtr &	expression,
		const std::string &	variable,
		const ExprPtr &	value )

在文件 expr_transform.cpp 第 77 行定义.

                                            {
    ComputationContext context;
    return substitute(expression, variable, value, context);
}

引用了 context, substitute(), value , 以及 variable.

函数调用图:

substitute() [4/6]

ExprResult LMCAS::substitute	(	const ExprPtr &	expression,
		const std::string &	variable,
		const ExprPtr &	value,
		ComputationContext &	context )

在文件 expr_transform.cpp 第 53 行定义.

                                                   {
    auto step = context.consume_steps(1, kSubstituteOperation);
    if (!step) return ExprResult::failure(step.error());
    if (!expression) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "expression cannot be null",
                                  kSubstituteOperation);
    }
    if (variable.empty()) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "substitution variable cannot be empty",
                                  kSubstituteOperation);
    }
    if (!value) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "substitution value cannot be null",
                                  kSubstituteOperation);
    }
    return detail::substitute_expression(expression, variable, value, context);
}

引用了 context, LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::Result< ExprPtr >::failure(), InvalidArgument, LMCAS::expr_detail::expr_common::kSubstituteOperation, substitute(), LMCAS::detail::substitute_expression(), value , 以及 variable.

被这些函数引用 substitute(), substitute(), substitute(), substitute(), substitute() , 以及 substitute().

函数调用图:

这是这个函数的调用关系图:

substitute() [5/6]

ExprResult LMCAS::substitute	(	const ExprPtr &	expression,
		const std::vector< Binding > &	replacements )

在文件 expr_transform.cpp 第 128 行定义.

                                                              {
    ComputationContext context;
    return substitute(expression, replacements, context);
}

引用了 context , 以及 substitute().

函数调用图:

substitute() [6/6]

ExprResult LMCAS::substitute	(	const ExprPtr &	expression,
		const std::vector< Binding > &	replacements,
		ComputationContext &	context )

在文件 expr_transform.cpp 第 122 行定义.

                                                   {
    return detail::substitute_expression(expression, replacements, context);
}

引用了 context, substitute() , 以及 LMCAS::detail::substitute_expression().

函数调用图:

substitute_free()

detail::SymbolicNodePtr LMCAS::substitute_free	(	const detail::SymbolicNodePtr &	expression,
		const std::string &	variable,
		const detail::SymbolicNodePtr &	replacement,
		detail::RewriteBudget *	budget )

在文件 expression_analysis.cpp 第 336 行定义.

                                                                           {
    if (!expression) return nullptr;
    if (variable.empty()) throw std::invalid_argument("substitution variable cannot be empty");
    if (!replacement) throw std::invalid_argument("substitution replacement cannot be null");
 
    auto replacement_free = free_variables(replacement, budget);
    auto occupied = all_names(expression, budget);
    auto replacement_names = all_names(replacement, budget);
    occupied.insert(replacement_names.begin(), replacement_names.end());
    occupied.insert(variable);
 
    FreeSubstitution substitution(variable, replacement,
                                  std::move(replacement_free),
                                  std::move(occupied), budget);
    return substitution.rewrite(expression);
}

引用了 free_variables(), substitute_free() , 以及 variable.

被这些函数引用 LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), norm_subst_index(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexContinuityPoint::positive(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::rewrite_scoped(), substitute_free(), LMCAS::detail::substitute_node() , 以及 LMCAS::detail::substitute_raw().

函数调用图:

这是这个函数的调用关系图:

substitute_negative_variable()

std::shared_ptr< const SymbolicNode > LMCAS::substitute_negative_variable ( const VariableNode & node, const std::string & var, const std::string & t_var )

static

在文件 limit_visitor_asymptotic.cpp 第 422 行定义.

                                                                            {
    if (!node.is_constant() && node.name() == var) {
        std::vector<std::shared_ptr<const SymbolicNode>> ops = {
            LMCAS::detail::make_node<NumberNode>(BigInt(-1)),
            LMCAS::detail::make_node<VariableNode>(t_var)
        };
        return LMCAS::detail::make_node<MultiplyNode>(ops);
    }
    return node.clone();
}

引用了 LMCAS::detail::make_node() , 以及 substitute_negative_variable().

被这些函数引用 substitute_negative_variable().

函数调用图:

这是这个函数的调用关系图:

substitute_raw()

ExprPtr LMCAS::detail::substitute_raw	(	const ExprPtr &	expression,
		const std::string &	variable,
		const ExprPtr &	value )

在文件 solve_solution_finalization.cpp 第 10 行定义.

                                                     {
    return detail::make_expression_ptr(substitute_free(
        detail::node(expression), variable, detail::node(value)));
}

被这些函数引用 append_product_families().

这是这个函数的调用关系图:

supported_laurent_integer_power() [1/2]

std::optional< int > LMCAS::detail::series_support::supported_laurent_integer_power	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable )

在文件 series_engine.cpp 第 105 行定义.

{
    if (!node) {
        return std::nullopt;
    }
    if (std::dynamic_pointer_cast<const NumberNode>(node)) {
        return 0;
    }
    if (auto variable = std::dynamic_pointer_cast<const VariableNode>(node)) {
        return !variable->is_constant() && variable->name() == var
            ? std::optional<int>(1) : std::nullopt;
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return laurent_power_of_power(*power, var);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        BigInt total_power(0);
        for (const auto& operand : multiply->operands()) {
            if (std::dynamic_pointer_cast<const NumberNode>(operand)) {
                continue;
            }
            auto power = supported_laurent_integer_power(operand, var);
            if (!power) {
                return std::nullopt;
            }
            total_power += BigInt(*power);
        }
        if (total_power < BigInt(std::numeric_limits<int>::min()) ||
            total_power > BigInt(std::numeric_limits<int>::max())) {
            return std::nullopt;
        }
        return static_cast<int>(*total_power.try_to_int64());
    }
    return std::nullopt;
 
 
}

被这些函数引用 convergence_test_impl(), laurent_series_checked() , 以及 laurent_series_full_checked().

这是这个函数的调用关系图:

supported_laurent_integer_power() [2/2]

std::optional< int > LMCAS::detail::series_support::supported_laurent_integer_power	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable )

在文件 series_engine.cpp 第 105 行定义.

{
    if (!node) {
        return std::nullopt;
    }
    if (std::dynamic_pointer_cast<const NumberNode>(node)) {
        return 0;
    }
    if (auto variable = std::dynamic_pointer_cast<const VariableNode>(node)) {
        return !variable->is_constant() && variable->name() == var
            ? std::optional<int>(1) : std::nullopt;
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return laurent_power_of_power(*power, var);
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        BigInt total_power(0);
        for (const auto& operand : multiply->operands()) {
            if (std::dynamic_pointer_cast<const NumberNode>(operand)) {
                continue;
            }
            auto power = supported_laurent_integer_power(operand, var);
            if (!power) {
                return std::nullopt;
            }
            total_power += BigInt(*power);
        }
        if (total_power < BigInt(std::numeric_limits<int>::min()) ||
            total_power > BigInt(std::numeric_limits<int>::max())) {
            return std::nullopt;
        }
        return static_cast<int>(*total_power.try_to_int64());
    }
    return std::nullopt;
 
 
}

surface_area_revolution_x_checked() [1/2]

ExpressionResult LMCAS::surface_area_revolution_x_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

在文件 calculus_revolution.cpp 第 123 行定义.

{
    ComputationContext context;
    return surface_area_revolution_x_checked(f, var, a, b, context);
}

引用了 a, b, context , 以及 surface_area_revolution_x_checked().

函数调用图:

surface_area_revolution_x_checked() [2/2]

ExpressionResult LMCAS::surface_area_revolution_x_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

在文件 calculus_revolution.cpp 第 47 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "surface_area_revolution_x";
    auto input = calculus_utils_validate_expr_bounds(f, var, a, b, context, operation);
    if (!input) {
        return ExpressionResult::failure(input.error());
    }
    auto step = context.consume_steps(8, operation);
    if (!step) {
        return ExpressionResult::failure(step.error());
    }
 
    try {
        auto f_prime = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), var, transform_budget));
        if (!f_prime || !LMCAS::detail::node(f_prime)) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "surface derivative is outside the supported domain",
                operation);
        }
 
        auto f_prime_sq = SymbolicExpr::power(f_prime, SymbolicExpr::number(2));
        auto one_plus_fp_sq = SymbolicExpr::add(SymbolicExpr::number(1), f_prime_sq);
        auto arc_factor = SymbolicExpr::sqrt(one_plus_fp_sq);
        auto abs_f = calculus_utils_make_abs(f);
        if (!abs_f || !LMCAS::detail::node(abs_f)) {
            return ExpressionResult::failure(
                CasErrc::InternalInvariant,
                "absolute value node construction failed",
                operation);
        }
        auto integrand = SymbolicExpr::multiply(abs_f, arc_factor);
 
        auto integral = calculus_utils_try_symbolic_definite(
            integrand, var, a, b, context);
        if (!integral) {
            return integral;
        }
        if (!integral.value() ||
            !LMCAS::detail::node(integral.value())) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "surface area integral could not be evaluated exactly",
                operation);
        }
 
        auto two_pi = SymbolicExpr::multiply(
            SymbolicExpr::number(2), LMCAS::detail::make_expression_ptr(
                LMCAS::detail::make_node<VariableNode>("pi", true)));
        auto result = SymbolicExpr::multiply(
            two_pi, std::move(integral.value()));
        auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
        return ExpressionResult::success(simplified ? simplified : result);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                           "surface area allocation failed",
                                           operation);
    } catch (const std::length_error& error) { return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "surface_area_revolution_x"); } catch (const std::exception& e) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                           e.what(), operation);
    }
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "surface_area_revolution_x");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "surface_area_revolution_x");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "surface_area_revolution_x");
}

引用了 a, b, LMCAS::calculus_utils_detail::calculus_utils_make_abs(), calculus_utils_try_symbolic_definite(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_bounds(), context, LMCAS::detail::differentiate_node(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), ResourceLimit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 surface_area_revolution_x_checked().

被这些函数引用 surface_area_revolution_x_checked() , 以及 surface_area_revolution_x_checked().

函数调用图:

这是这个函数的调用关系图:

surface_area_revolution_y_checked() [1/2]

ExpressionResult LMCAS::surface_area_revolution_y_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b )

在文件 calculus_revolution.cpp 第 209 行定义.

{
    ComputationContext context;
    return surface_area_revolution_y_checked(f, var, a, b, context);
}

引用了 a, b, context , 以及 surface_area_revolution_y_checked().

函数调用图:

surface_area_revolution_y_checked() [2/2]

ExpressionResult LMCAS::surface_area_revolution_y_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::string &	var,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context )

在文件 calculus_revolution.cpp 第 132 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    const std::string operation = "surface_area_revolution_y";
    auto input = calculus_utils_validate_expr_bounds(f, var, a, b, context, operation);
    if (!input) {
        return ExpressionResult::failure(input.error());
    }
    auto step = context.consume_steps(8, operation);
    if (!step) {
        return ExpressionResult::failure(step.error());
    }
 
    try {
        auto f_prime = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), var, transform_budget));
        if (!f_prime || !LMCAS::detail::node(f_prime)) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "surface derivative is outside the supported domain",
                operation);
        }
 
        auto f_prime_sq = SymbolicExpr::power(f_prime, SymbolicExpr::number(2));
        auto one_plus_fp_sq = SymbolicExpr::add(SymbolicExpr::number(1), f_prime_sq);
        auto arc_factor = SymbolicExpr::sqrt(one_plus_fp_sq);
        auto var_expr = SymbolicExpr::variable(var);
        auto abs_var = calculus_utils_make_abs(var_expr);
        if (!abs_var || !LMCAS::detail::node(abs_var)) {
            return ExpressionResult::failure(
                CasErrc::InternalInvariant,
                "absolute value node construction failed",
                operation);
        }
        auto integrand = SymbolicExpr::multiply(abs_var, arc_factor);
 
        auto integral = calculus_utils_try_symbolic_definite(
            integrand, var, a, b, context);
        if (!integral) {
            return integral;
        }
        if (!integral.value() ||
            !LMCAS::detail::node(integral.value())) {
            return ExpressionResult::failure(
                CasErrc::Inconclusive,
                "surface area integral could not be evaluated exactly",
                operation);
        }
 
        auto two_pi = SymbolicExpr::multiply(
            SymbolicExpr::number(2), LMCAS::detail::make_expression_ptr(
                LMCAS::detail::make_node<VariableNode>("pi", true)));
        auto result = SymbolicExpr::multiply(
            two_pi, std::move(integral.value()));
        auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
        return ExpressionResult::success(simplified ? simplified : result);
    } catch (const std::bad_alloc&) {
        return ExpressionResult::failure(CasErrc::ResourceLimit,
                                           "surface area allocation failed",
                                           operation);
    } catch (const std::length_error& error) { return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "surface_area_revolution_y"); } catch (const std::exception& e) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
                                           e.what(), operation);
    }
} catch (const CasError& error) {
    return ExpressionResult::failure(error);
} catch (const std::bad_alloc&) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, "allocation failed", "surface_area_revolution_y");
} catch (const std::length_error& error) {
    return ExpressionResult::failure(CasErrc::ResourceLimit, error.what(), "surface_area_revolution_y");
} catch (const std::exception& error) {
    return ExpressionResult::failure(CasErrc::InternalInvariant, error.what(), "surface_area_revolution_y");
}

引用了 a, b, LMCAS::calculus_utils_detail::calculus_utils_make_abs(), calculus_utils_try_symbolic_definite(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_bounds(), context, LMCAS::detail::differentiate_node(), e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), ResourceLimit, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 surface_area_revolution_y_checked().

被这些函数引用 surface_area_revolution_y_checked() , 以及 surface_area_revolution_y_checked().

函数调用图:

这是这个函数的调用关系图:

surface_integral_scalar()

std::shared_ptr< SymbolicExpr > LMCAS::surface_integral_scalar	(	const std::shared_ptr< SymbolicExpr > &	f,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::shared_ptr< SymbolicExpr > &	u_lower,
		const std::shared_ptr< SymbolicExpr > &	u_upper,
		const std::shared_ptr< SymbolicExpr > &	v_lower,
		const std::shared_ptr< SymbolicExpr > &	v_upper )

在文件 vector_calculus_surfaces.cpp 第 88 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!f) {
        throw std::invalid_argument("surface_integral_scalar: f must not be null");
    }
    if (parametrization.size() != 3) {
        throw std::invalid_argument(
            "surface_integral_scalar: parametrization must have 3 components");
    }
    if (!u_lower || !u_upper || !v_lower || !v_upper) {
        throw std::invalid_argument("surface_integral_scalar: bounds must not be null");
    }
 
    std::vector<std::string> coord_vars = {"x", "y", "z"};
 
    auto f_composed = f;
    for (size_t i = 0; i < 3; ++i) {
        f_composed = detail::make_expression_ptr(detail::substitute_node(detail::node(f_composed), coord_vars[i], detail::node(parametrization[i]), transform_budget));
    }
    f_composed = detail::make_expression_ptr(detail::normalize_node(detail::node(f_composed), transform_budget));
 
    auto cross = vector_calculus_cross_product_partials(parametrization, u, v, transform_budget);
 
    std::shared_ptr<SymbolicExpr> mag_sq = nullptr;
    for (size_t i = 0; i < 3; ++i) {
        auto sq = SymbolicExpr::power(cross[i], SymbolicExpr::number(2));
        sq = detail::make_expression_ptr(detail::normalize_node(detail::node(sq), transform_budget));
        if (!mag_sq) {
            mag_sq = sq;
        } else {
            mag_sq = SymbolicExpr::add(mag_sq, sq);
            mag_sq = detail::make_expression_ptr(detail::normalize_node(detail::node(mag_sq), transform_budget));
        }
    }
 
    auto magnitude = SymbolicExpr::sqrt(mag_sq);
    magnitude = detail::make_expression_ptr(detail::normalize_node(detail::node(magnitude), transform_budget));
 
    auto integrand = SymbolicExpr::multiply(f_composed, magnitude);
    integrand = detail::make_expression_ptr(detail::normalize_node(detail::node(integrand), transform_budget));
 
    Integrator integrator;
 
    std::vector<IntegrationStep> steps = {
        {v, v_lower, v_upper},
        {u, u_lower, u_upper},
    };
    auto result = integrate_multiple_checked(*integrand, steps, integrator, context);
    if (!result) throw result.error();
    return LMCAS::detail::make_expression_ptr(result.value());
}

引用了 context, integrate_multiple_checked(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), parametrization, steps, LMCAS::detail::substitute_node(), surface_integral_scalar(), u, u_lower, u_upper, v, v_lower, v_upper , 以及 LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials().

被这些函数引用 surface_integral_scalar().

函数调用图:

这是这个函数的调用关系图:

surface_integral_scalar_checked() [1/2]

VectorCalculusExprResult LMCAS::surface_integral_scalar_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::shared_ptr< SymbolicExpr > &	u_lower,
		const std::shared_ptr< SymbolicExpr > &	u_upper,
		const std::shared_ptr< SymbolicExpr > &	v_lower,
		const std::shared_ptr< SymbolicExpr > &	v_upper )

在文件 vector_calculus_surfaces.cpp 第 77 行定义.

{
    ComputationContext context;
    return surface_integral_scalar_checked(
        f, parametrization, u, v, u_lower, u_upper, v_lower, v_upper, context);
}

引用了 context, parametrization, surface_integral_scalar_checked(), u, u_lower, u_upper, v, v_lower , 以及 v_upper.

函数调用图:

surface_integral_scalar_checked() [2/2]

VectorCalculusExprResult LMCAS::surface_integral_scalar_checked	(	const std::shared_ptr< SymbolicExpr > &	f,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::shared_ptr< SymbolicExpr > &	u_lower,
		const std::shared_ptr< SymbolicExpr > &	u_upper,
		const std::shared_ptr< SymbolicExpr > &	v_lower,
		const std::shared_ptr< SymbolicExpr > &	v_upper,
		ComputationContext &	context )

在文件 vector_calculus_surfaces.cpp 第 39 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "surface_integral_scalar");
    const std::string operation = "surface_integral_scalar";
    auto valid = vector_calculus_validate_surface_scalar_inputs(
        f, parametrization, u, v, u_lower, u_upper, v_lower, v_upper,
        context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
 
    auto step = context.consume_steps(parametrization.size() * 6 + 8, operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return surface_integral_scalar_strict(f, parametrization, u, v, u_lower, u_upper, v_lower, v_upper,
        context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "surface integral allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, parametrization, ResourceLimit, surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), u, u_lower, u_upper, v, v_lower, v_upper , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_surface_scalar_inputs().

被这些函数引用 surface_integral_scalar_checked() , 以及 surface_integral_scalar_checked().

函数调用图:

这是这个函数的调用关系图:

surface_integral_vector()

std::shared_ptr< SymbolicExpr > LMCAS::surface_integral_vector	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::shared_ptr< SymbolicExpr > &	u_lower,
		const std::shared_ptr< SymbolicExpr > &	u_upper,
		const std::shared_ptr< SymbolicExpr > &	v_lower,
		const std::shared_ptr< SymbolicExpr > &	v_upper )

在文件 vector_calculus_surfaces.cpp 第 199 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (F.size() != 3) {
        throw std::invalid_argument(
            "surface_integral_vector: F must have 3 components");
    }
    if (parametrization.size() != 3) {
        throw std::invalid_argument(
            "surface_integral_vector: parametrization must have 3 components");
    }
    if (!u_lower || !u_upper || !v_lower || !v_upper) {
        throw std::invalid_argument("surface_integral_vector: bounds must not be null");
    }
 
    std::vector<std::string> coord_vars = {"x", "y", "z"};
 
    auto cross = vector_calculus_cross_product_partials(parametrization, u, v, transform_budget);
 
    std::shared_ptr<SymbolicExpr> dot_product = nullptr;
    for (size_t i = 0; i < 3; ++i) {
        if (!F[i]) {
            continue;
        }
 
        auto Fi_composed = F[i];
        for (size_t j = 0; j < 3; ++j) {
            Fi_composed = detail::make_expression_ptr(detail::substitute_node(detail::node(Fi_composed), coord_vars[j], detail::node(parametrization[j]), transform_budget));
        }
        Fi_composed = detail::make_expression_ptr(detail::normalize_node(detail::node(Fi_composed), transform_budget));
 
        auto term = SymbolicExpr::multiply(Fi_composed, cross[i]);
        term = detail::make_expression_ptr(detail::normalize_node(detail::node(term), transform_budget));
 
        if (!dot_product) {
            dot_product = term;
        } else {
            dot_product = SymbolicExpr::add(dot_product, term);
            dot_product = detail::make_expression_ptr(detail::normalize_node(detail::node(dot_product), transform_budget));
        }
    }
 
    if (!dot_product) {
        return SymbolicExpr::number(0);
    }
 
    Integrator integrator;
 
    std::vector<IntegrationStep> steps = {
        {v, v_lower, v_upper},
        {u, u_lower, u_upper},
    };
    auto result = integrate_multiple_checked(*dot_product, steps, integrator, context);
    if (!result) throw result.error();
    return LMCAS::detail::make_expression_ptr(result.value());
}

引用了 context, dot_product(), integrate_multiple_checked(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), parametrization, steps, LMCAS::detail::substitute_node(), surface_integral_vector(), u, u_lower, u_upper, v, v_lower, v_upper , 以及 LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials().

被这些函数引用 surface_integral_vector().

函数调用图:

这是这个函数的调用关系图:

surface_integral_vector_checked() [1/2]

VectorCalculusExprResult LMCAS::surface_integral_vector_checked	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::shared_ptr< SymbolicExpr > &	u_lower,
		const std::shared_ptr< SymbolicExpr > &	u_upper,
		const std::shared_ptr< SymbolicExpr > &	v_lower,
		const std::shared_ptr< SymbolicExpr > &	v_upper )

在文件 vector_calculus_surfaces.cpp 第 188 行定义.

{
    ComputationContext context;
    return surface_integral_vector_checked(
        F, parametrization, u, v, u_lower, u_upper, v_lower, v_upper, context);
}

引用了 context, parametrization, surface_integral_vector_checked(), u, u_lower, u_upper, v, v_lower , 以及 v_upper.

函数调用图:

surface_integral_vector_checked() [2/2]

VectorCalculusExprResult LMCAS::surface_integral_vector_checked	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		const std::shared_ptr< SymbolicExpr > &	u_lower,
		const std::shared_ptr< SymbolicExpr > &	u_upper,
		const std::shared_ptr< SymbolicExpr > &	v_lower,
		const std::shared_ptr< SymbolicExpr > &	v_upper,
		ComputationContext &	context )

在文件 vector_calculus_surfaces.cpp 第 148 行定义.

{
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "surface_integral_vector");
    const std::string operation = "surface_integral_vector";
    auto valid = vector_calculus_validate_surface_vector_inputs(
        F, parametrization, u, v, u_lower, u_upper, v_lower, v_upper,
        context, operation);
    if (!valid) {
        return VectorCalculusExprResult::failure(valid.error());
    }
 
    auto step = context.consume_steps(F.size() * parametrization.size() +
                                      parametrization.size() * 6 + 8,
                                      operation);
    if (!step) {
        return VectorCalculusExprResult::failure(step.error());
    }
 
    try {
        return surface_integral_vector_strict(F, parametrization, u, v, u_lower, u_upper, v_lower, v_upper,
        context, operation, transform_budget);
    } catch (const CasError& error) {
        return VectorCalculusExprResult::failure(error);
    } catch (const std::bad_alloc&) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
                                                 "surface integral allocation failed",
                                                 operation);
    } catch (const std::length_error& error) {
        return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
    } catch (const std::exception& e) {
        return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, parametrization, ResourceLimit, surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), u, u_lower, u_upper, v, v_lower, v_upper , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_surface_vector_inputs().

被这些函数引用 surface_integral_vector_checked() , 以及 surface_integral_vector_checked().

函数调用图:

这是这个函数的调用关系图:

surface_normal_checked() [1/2]

VectorExprListResult LMCAS::surface_normal_checked	(	const SurfaceSymbolic &	surf,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	point )

在文件 symbolic_geometry_surface.cpp 第 181 行定义.

                                                         {
    ComputationContext context;
    return surface_normal_checked(surf, point, context);
}

引用了 context, point , 以及 surface_normal_checked().

函数调用图:

surface_normal_checked() [2/2]

VectorExprListResult LMCAS::surface_normal_checked	(	const SurfaceSymbolic &	surf,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	point,
		ComputationContext &	context )

在文件 symbolic_geometry_surface.cpp 第 147 行定义.

                                 {
    const std::string operation = "surface_normal";
    auto valid = validate_surface_point(surf, point, context, operation);
    if (!valid) return VectorExprListResult::failure(valid.error());
    auto step = context.consume_steps(surf.vars.size() * 4 + 4, operation);
    if (!step) return VectorExprListResult::failure(step.error());
 
    auto gradient = surface_gradient_at_point_checked(surf, point, operation, context);
    if (!gradient) return gradient;
    std::vector<double> gradient_values;
    auto scaled = surface_gradient_scale_checked(
        gradient.value(), context, operation, gradient_values,
        "surface normal is undefined at a singular point");
    if (!scaled) return VectorExprListResult::failure(scaled.error());
 
    double scaled_norm_sq = 0.0;
    for (double component : gradient_values) {
        const double ratio = component / scaled.value();
        scaled_norm_sq += ratio * ratio;
    }
    const double scaled_norm = std::sqrt(scaled_norm_sq);
 
    std::vector<std::shared_ptr<SymbolicExpr>> result;
    result.reserve(gradient_values.size());
    for (double component : gradient_values) {
        result.push_back(SymbolicExpr::number(
            (component / scaled.value()) / scaled_norm));
    }
    return VectorExprListResult::success(std::move(result));
}

引用了 context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), gradient(), point, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success(), surface_normal_checked(), LMCAS::geometry_detail::validate_surface_point() , 以及 LMCAS::SurfaceSymbolic::vars.

被这些函数引用 surface_normal_checked() , 以及 surface_normal_checked().

函数调用图:

这是这个函数的调用关系图:

svd_decomposition_checked() [1/2]

SVDDecompositionResult LMCAS::svd_decomposition_checked

(

const std::shared_ptr< SymbolicExpr > &

A

)

在文件 matrix_decomposition_svd.cpp 第 46 行定义.

{
    ComputationContext context;
    return svd_decomposition_checked(A, context);
}

引用了 context , 以及 svd_decomposition_checked().

函数调用图:

svd_decomposition_checked() [2/2]

SVDDecompositionResult LMCAS::svd_decomposition_checked	(	const std::shared_ptr< SymbolicExpr > &	A,
		ComputationContext &	context )

在文件 matrix_decomposition_svd.cpp 第 8 行定义.

{
    const std::string operation = "svd_decomposition";
    auto matrix = validate_decomposition_matrix(A, false, context, operation);
    if (!matrix) return SVDDecompositionResult::failure(matrix.error());
    auto budget = context.consume_steps(matrix.value()->rows() * matrix.value()->cols() * 32 + 32,
                                        operation);
    if (!budget) return SVDDecompositionResult::failure(budget.error());
    auto diagonal = exact_rectangular_diagonal_entries(matrix.value(), context);
    if (diagonal) {
        std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> signs(
            matrix.value()->rows(),
            std::vector<std::shared_ptr<SymbolicExpr>>(
                matrix.value()->rows(), SymbolicExpr::number(0)));
        std::vector<Rational> magnitudes = *diagonal;
        for (std::size_t row = 0; row < matrix.value()->rows(); ++row) {
            signs[row][row] = SymbolicExpr::number(1);
        }
        for (std::size_t index = 0; index < magnitudes.size(); ++index) {
            if (magnitudes[index] < Rational(0)) {
                signs[index][index] = SymbolicExpr::number(-1);
                magnitudes[index] = Rational(0) - magnitudes[index];
            }
        }
        auto U = SymbolicExpr::matrix(signs);
        auto S = rectangular_diagonal_expr(
            matrix.value()->rows(), matrix.value()->cols(), magnitudes);
        auto V = identity_matrix_expr(matrix.value()->cols());
        return SVDDecompositionResult::success(SVDDecomposition{U, S, V});
    }
    return SVDDecompositionResult::failure(
        CasErrc::Inconclusive,
        "exact non-diagonal SVD requires a complete proved singular basis",
        operation);
}

引用了 context, LMCAS::detail::matrix_decomposition::exact_rectangular_diagonal_entries(), LMCAS::Result< SVDDecomposition >::failure(), LMCAS::detail::matrix_decomposition::identity_matrix_expr(), Inconclusive, LMCAS::detail::matrix_decomposition::rectangular_diagonal_expr(), LMCAS::Result< SVDDecomposition >::success(), svd_decomposition_checked() , 以及 LMCAS::detail::matrix_decomposition::validate_decomposition_matrix().

被这些函数引用 svd_decomposition_checked() , 以及 svd_decomposition_checked().

函数调用图:

这是这个函数的调用关系图:

sym()

ExprResult LMCAS::sym

(

const std::string &

name

)

在文件 expr_values.cpp 第 30 行定义.

                                      {
    if (name.empty()) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "symbol name cannot be empty", kSymOperation);
    }
    if (is_reserved_symbol_name(name)) {
        if (detail::is_imaginary_unit_name(name)) {
            return expression_failure(CasErrc::InvalidArgument,
                                      "imaginary unit symbol is reserved",
                                      kSymOperation);
        }
        return expression_failure(CasErrc::InvalidArgument,
                                  "reserved mathematical constants cannot be shadowed",
                                  kSymOperation);
    }
    try {
        auto expression = SymbolicExpr::variable(name);
        if (!expression) {
            return expression_failure(CasErrc::InternalInvariant,
                                      "symbol factory returned null", kSymOperation);
        }
        return ExprResult::success(std::move(expression));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "symbol allocation failed", kSymOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kSymOperation);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), InternalInvariant, InvalidArgument, LMCAS::detail::is_imaginary_unit_name(), LMCAS::expr_detail::expr_common::is_reserved_symbol_name(), LMCAS::expr_detail::expr_common::kSymOperation, name, ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 sym().

被这些函数引用 LMCAS::AssumptionDecl::make_domain(), LMCAS::AssumptionDecl::make_sign(), LMCAS::assumption_detail::AssumptionParser::parse_continuity(), LMCAS::assumption_detail::AssumptionParser::parse_definiteness(), LMCAS::assumption_detail::AssumptionParser::parse_domain(), LMCAS::assumption_detail::AssumptionParser::parse_finiteness(), LMCAS::expr_detail::ExprParser::parse_identifier_or_call(), LMCAS::assumption_detail::AssumptionParser::parse_monotonicity(), LMCAS::assumption_detail::AssumptionParser::parse_parity(), LMCAS::assumption_detail::AssumptionParser::parse_periodic(), LMCAS::assumption_detail::AssumptionParser::parse_sign(), LMCAS::assumption_detail::AssumptionParser::parse_transcendental(), LMCAS::anonymous_namespace{assumption_serialization.cpp}::serialize_symbol_intervals(), LMCAS::anonymous_namespace{assumption_serialization.cpp}::serialize_symbol_properties() , 以及 sym().

函数调用图:

这是这个函数的调用关系图:

sym_rational()

std::shared_ptr< SymbolicExpr > LMCAS::sym_rational ( const BigInt & numerator, const BigInt & denominator )

inline

在文件 integration_support.hpp 第 70 行定义.

                                                        {
    return SymbolicExpr::number(Rational(numerator, denominator));
}

引用了 denominator , 以及 sym_rational().

被这些函数引用 LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_sec_power(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_tan_power(), 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_trig_rules(), LMCAS::integration_table_detail::load_trig_squares_rules() , 以及 sym_rational().

函数调用图:

这是这个函数的调用关系图:

sym_sub()

std::shared_ptr< SymbolicExpr > LMCAS::sym_sub ( const SymbolicExpr & lhs, const SymbolicExpr & rhs )

inline

在文件 integration_support.hpp 第 62 行定义.

                             {
    auto negated_rhs = SymbolicExpr::multiply(
        SymbolicExpr::number(-1), detail::make_expression_ptr(rhs));
    return SymbolicExpr::add(detail::make_expression_ptr(lhs), negated_rhs);
}

引用了 LMCAS::detail::make_expression_ptr(), rhs , 以及 sym_sub().

被这些函数引用 LMCAS::detail::definite::collect_predicate_roots(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::integration_table_detail::load_logarithmic_rules(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::relational_predicate_truth() , 以及 sym_sub().

函数调用图:

这是这个函数的调用关系图:

symbol_name()

std::optional< std::string_view > LMCAS::symbol_name ( const ExprPtr & expression )

noexcept

在文件 expr_values.cpp 第 16 行定义.

                                                                            {
    const auto* variable =
        dynamic_cast<const VariableNode*>(detail::node(expression).get());
    if (!variable || variable->is_constant()) return std::nullopt;
    return variable->name();
}

引用了 LMCAS::detail::node(), symbol_name() , 以及 variable.

被这些函数引用 symbol_name().

函数调用图:

这是这个函数的调用关系图:

symbolic_cubic_roots()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::symbolic_cubic_roots ( const std::shared_ptr< SymbolicExpr > & a, const std::shared_ptr< SymbolicExpr > & b, const std::shared_ptr< SymbolicExpr > & c, const std::shared_ptr< SymbolicExpr > & d, ComputationContext & context )

static

在文件 solve_polynomial_cubic.cpp 第 39 行定义.

                                                                                                             {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto a2 = SymbolicExpr::power(a, num(2));
    auto a3 = SymbolicExpr::power(a, num(3));
    auto b2 = SymbolicExpr::power(b, num(2));
    auto b3 = SymbolicExpr::power(b, num(3));
    auto three_ac = SymbolicExpr::multiply(
        num(3), SymbolicExpr::multiply(a, c));
    auto p_num = sub(three_ac, b2);
    auto p_den = SymbolicExpr::multiply(num(3), a2);
    auto p = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(p_num, p_den)), transform_budget));
    auto two_b3 = SymbolicExpr::multiply(num(2), b3);
    auto nine_abc = SymbolicExpr::multiply(
        num(9), SymbolicExpr::multiply(
            a, SymbolicExpr::multiply(b, c)));
    auto twentyseven_a2d = SymbolicExpr::multiply(
        num(27), SymbolicExpr::multiply(a2, d));
    auto q_num = SymbolicExpr::add(
        sub(two_b3, nine_abc), twentyseven_a2d);
    auto q_den = SymbolicExpr::multiply(num(27), a3);
    auto q = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(q_num, q_den)), transform_budget));
    auto shift = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(
        b, SymbolicExpr::multiply(num(3), a))), transform_budget));
 
 
    auto q_half = SymbolicExpr::divide(q, num(2));
    auto p_third = SymbolicExpr::divide(p, num(3));
    auto D_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(
        SymbolicExpr::power(q_half, num(2)),
        SymbolicExpr::power(p_third, num(3)))), transform_budget));
 
    auto neg_q_half = detail::make_expression_ptr(detail::normalize_node(detail::node(negate(q_half)), transform_budget));
    auto sqrt_D = SymbolicExpr::sqrt(D_expr);
 
    auto u = detail::make_expression_ptr(detail::normalize_node(detail::node(cbrt_expr(SymbolicExpr::add(neg_q_half, sqrt_D))), transform_budget));
    auto v = detail::make_expression_ptr(detail::normalize_node(detail::node(cbrt_expr(sub(neg_q_half, sqrt_D))), transform_budget));
 
    auto t1 = SymbolicExpr::add(u, v);
    auto x1 = detail::make_expression_ptr(detail::normalize_node(detail::node(sub(t1, shift)), transform_budget));
 
    auto neg_half_sum = SymbolicExpr::divide(negate(SymbolicExpr::add(u, v)), num(2));
    auto diff_uv = sub(u, v);
    auto sqrt3_half = SymbolicExpr::divide(SymbolicExpr::sqrt(num(3)), num(2));
    auto imag_coeff = SymbolicExpr::multiply(sqrt3_half, diff_uv);
 
    auto i_unit = SymbolicExpr::sqrt(num(-1));
    auto x2 = detail::make_expression_ptr(detail::normalize_node(detail::node(sub(SymbolicExpr::add(neg_half_sum, SymbolicExpr::multiply(i_unit, imag_coeff)), shift)), transform_budget));
    auto x3 = detail::make_expression_ptr(detail::normalize_node(detail::node(sub(sub(neg_half_sum, SymbolicExpr::multiply(i_unit, imag_coeff)), shift)), transform_budget));
 
    return {x1, x2, x3};
}

引用了 a, b, c, cbrt_expr(), context, LMCAS::detail::make_expression_ptr(), LMCAS::polynomial_solver_detail::negate(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::polynomial_solver_detail::num(), sub(), symbolic_cubic_roots(), u , 以及 v.

被这些函数引用 LMCAS::polynomial_solver_detail::solve_cubic_impl() , 以及 symbolic_cubic_roots().

函数调用图:

这是这个函数的调用关系图:

symbolic_hessian()

std::shared_ptr< SymbolicExpr > LMCAS::symbolic_hessian ( const std::vector< double > & numeric_H, size_t n, double tol )

static

在文件 vector_calculus_extrema.cpp 第 95 行定义.

{
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> grid(n,
        std::vector<std::shared_ptr<SymbolicExpr>>(n));
    for (size_t i = 0; i < n; ++i) {
        for (size_t j = 0; j < n; ++j) {
            double val = numeric_H[i * n + j];
            const double rounded = std::round(val);
            const bool representable_integer =
                std::isfinite(val) &&
                rounded >=
                    static_cast<double>(std::numeric_limits<int>::min()) &&
                rounded <=
                    static_cast<double>(std::numeric_limits<int>::max()) &&
                std::abs(val - rounded) < tol;
            if (representable_integer) {
                grid[i][j] =
                    SymbolicExpr::number(static_cast<int>(rounded));
            } else {
                grid[i][j] = SymbolicExpr::number(val);
            }
        }
    }
    return SymbolicExpr::matrix(grid);
}

引用了 symbolic_hessian().

被这些函数引用 symbolic_hessian() , 以及 vector_calculus_classify_critical_point().

函数调用图:

这是这个函数的调用关系图:

symbolic_node_to_multipoly()

LMCAS::MultiPoly LMCAS::symbolic_node_to_multipoly ( const std::shared_ptr< const SymbolicNode > & node, const std::vector< std::string > & vars )

static

在文件 symbolic_factor.cpp 第 73 行定义.

{
    if (!node) { return LMCAS::MultiPoly(Rational(0), vars); }
 
    if (auto num = std::dynamic_pointer_cast<const NumberNode>(node)) {
        return LMCAS::MultiPoly(exact_number_as_rational(*num), vars);
    }
 
    if (auto var_node = std::dynamic_pointer_cast<const VariableNode>(node)) {
        LMCAS::Monomial mono(vars.size(), 0);
        for (size_t i = 0; i < vars.size(); ++i) {
            if (vars[i] == var_node->name()) {
                mono[i] = 1;
                break;
            }
        }
        std::vector<LMCAS::MultiPoly::Term> terms;
        terms.push_back({mono, Rational(1)});
        return LMCAS::MultiPoly(std::move(terms), vars);
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        LMCAS::MultiPoly result(Rational(0), vars);
        for (const auto& op : add->operands()) {
            result = result + symbolic_node_to_multipoly(op, vars);
        }
        return result;
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        LMCAS::MultiPoly result(Rational(1), vars);
        for (const auto& op : mul->operands()) {
            result = result * symbolic_node_to_multipoly(op, vars);
        }
        return result;
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto base_poly = symbolic_node_to_multipoly(pow->base(), vars);
        const int exp_val = polynomial_exponent(pow->exponent()).value();
        if (exp_val == 0) { return LMCAS::MultiPoly(Rational(1), vars); }
        LMCAS::MultiPoly result(Rational(1), vars);
        for (int i = 0; i < exp_val; ++i) {
            result = result * base_poly;
        }
        return result;
    }
 
    return LMCAS::MultiPoly(Rational(0), vars);
}

引用了 add(), exact_number_as_rational(), mul(), LMCAS::polynomial_solver_detail::num(), op, pow(), symbolic_node_to_multipoly() , 以及 vars.

被这些函数引用 factor_multivariate_expression() , 以及 symbolic_node_to_multipoly().

函数调用图:

这是这个函数的调用关系图:

symbolic_poly_to_expr()

std::shared_ptr< SymbolicExpr > LMCAS::symbolic_poly_to_expr ( const Polynomial< SymbolicPolyCoeff > & poly, ComputationContext & context )

static

在文件 root_of_identity.cpp 第 62 行定义.

                                                                            {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (poly.is_zero()) return SymbolicExpr::number(0);
 
    std::vector<std::shared_ptr<SymbolicExpr>> terms;
    for (int i = poly.degree(); i >= 0; --i) {
        const auto& coeff = poly.coeffs[i];
 
        auto coeff_expr = coeff.val;
        if (coeff_expr) {
            if (auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(coeff_expr), transform_budget))) {
                coeff_expr = simplified;
            }
            if (LMCAS::detail::node(coeff_expr) && coeff_expr->is_zero()) {
                continue;
            }
        }
        terms.push_back(symbolic_root_term(coeff_expr, poly.variable_name, i));
    }
 
    if (terms.empty()) return SymbolicExpr::number(0);
    if (terms.size() == 1) return terms[0];
 
    auto result = terms[0];
    for (size_t i = 1; i < terms.size(); ++i) {
        result = SymbolicExpr::add(result, terms[i]);
    }
    return result;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::SymbolicNode::is_zero(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), symbolic_poly_to_expr(), symbolic_root_term() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 LMCAS::detail::make_rootof_solutions_impl() , 以及 symbolic_poly_to_expr().

函数调用图:

这是这个函数的调用关系图:

symbolic_polynomial_content()

Result< Rational > LMCAS::symbolic_polynomial_content	(	const SymbolicExpr &	expression,
		ComputationContext &	context )

在文件 symbolic_gcd.cpp 第 401 行定义.

                                 {
    try {
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                     context.limits().max_ast_nodes, kOperation);
        budget.measure(detail::node(expression));
        std::set<std::string> variable_set;
        auto variables_result = collect_polynomial_variables(
            detail::node(expression), variable_set, context);
        if (!variables_result) {
            return Result<Rational>::failure(variables_result.error());
        }
        std::vector<std::string> variables(
            variable_set.begin(), variable_set.end());
        auto polynomial = node_to_multivariate_polynomial(
            detail::node(expression), variables, context);
        if (!polynomial) {
            return Result<Rational>::failure(polynomial.error());
        }
        return Result<Rational>::success(polynomial.value().numeric_content());
    } catch (const CasError& error) {
        return Result<Rational>::failure(error);
    } catch (const std::length_error& error) {
        return Result<Rational>::failure(CasErrc::ResourceLimit, error.what(), kOperation);
    } catch (const std::bad_alloc&) {
        return Result<Rational>::failure(
            CasErrc::ResourceLimit, "polynomial content allocation failed",
            kOperation);
    } catch (const std::exception& error) {
        return Result<Rational>::failure(
            CasErrc::InternalInvariant, error.what(), kOperation);
    }
}

引用了 context, LMCAS::Result< T >::failure(), InternalInvariant, LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), ResourceLimit, LMCAS::Result< T >::success() , 以及 symbolic_polynomial_content().

被这些函数引用 factor_numeric_content() , 以及 symbolic_polynomial_content().

函数调用图:

这是这个函数的调用关系图:

symbolic_polynomial_gcd()

SymbolicGcdResult LMCAS::symbolic_polynomial_gcd	(	const SymbolicExpr &	lhs,
		const SymbolicExpr &	rhs,
		ComputationContext &	context )

在文件 symbolic_gcd.cpp 第 351 行定义.

                                 {
    try {
        detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                     context.limits().max_ast_nodes, kOperation);
        budget.measure(detail::node(lhs));
        budget.measure(detail::node(rhs));
        std::set<std::string> variable_set;
        auto lhs_variables = collect_polynomial_variables(
            detail::node(lhs), variable_set, context);
        if (!lhs_variables) { return SymbolicGcdResult::failure(lhs_variables.error()); }
        auto rhs_variables = collect_polynomial_variables(
            detail::node(rhs), variable_set, context);
        if (!rhs_variables) { return SymbolicGcdResult::failure(rhs_variables.error()); }
        std::vector<std::string> variables(variable_set.begin(), variable_set.end());
 
        auto lhs_polynomial = node_to_multivariate_polynomial(
            detail::node(lhs), variables, context);
        if (!lhs_polynomial) { return SymbolicGcdResult::failure(lhs_polynomial.error()); }
        auto rhs_polynomial = node_to_multivariate_polynomial(
            detail::node(rhs), variables, context);
        if (!rhs_polynomial) { return SymbolicGcdResult::failure(rhs_polynomial.error()); }
 
        auto step = context.consume_steps(
            static_cast<std::size_t>(lhs_polynomial.value().num_terms() +
                                     rhs_polynomial.value().num_terms()) + 1,
            kOperation);
        if (!step) { return SymbolicGcdResult::failure(step.error()); }
 
        MultiPoly gcd = make_monic(multivariate_gcd(
            lhs_polynomial.value(), rhs_polynomial.value()));
        auto verified = verify_gcd_candidate(
            lhs_polynomial.value(), rhs_polynomial.value(), gcd);
        if (!verified) { return SymbolicGcdResult::failure(verified.error()); }
        return multivariate_polynomial_to_expression(gcd, budget);
    } catch (const CasError& error) {
        return SymbolicGcdResult::failure(error);
    } catch (const std::length_error& error) {
        return SymbolicGcdResult::failure(CasErrc::ResourceLimit, error.what(), kOperation);
    } catch (const std::bad_alloc&) {
        return SymbolicGcdResult::failure(
            CasErrc::ResourceLimit, "symbolic GCD allocation failed", kOperation);
    } catch (const std::exception& error) {
        return SymbolicGcdResult::failure(
            CasErrc::InternalInvariant, error.what(), kOperation);
    }
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), InternalInvariant, LMCAS::detail::RewriteBudget::measure(), multivariate_gcd(), LMCAS::detail::node(), ResourceLimit, rhs , 以及 symbolic_polynomial_gcd().

被这些函数引用 factor_common_polynomial() , 以及 symbolic_polynomial_gcd().

函数调用图:

这是这个函数的调用关系图:

symbolic_power_to_poly()

template<typename T>

Result< Polynomial< T > > LMCAS::symbolic_power_to_poly	(	const PowerNode &	power,
		const std::string &	variable,
		ComputationContext *	context,
		detail::RewriteBudget *	budget )

在文件 poly_utils.cpp 第 288 行定义.

                                                              {
    detail::RewriteScope scope(budget);
    BigInt exponent;
    if (!try_get_integer_value(
            std::dynamic_pointer_cast<const NumberNode>(power.exponent()), exponent) ||
        exponent.is_negative()) {
        return Result<Polynomial<T>>::failure(CasErrc::UnsupportedExpression,
            "Polynomial powers require nonnegative integer exponents", "polynomial.convert");
    }
    const auto bounded_exponent = exponent.try_to_int64();
    if (!bounded_exponent || *bounded_exponent >= 1000) {
        return Result<Polynomial<T>>::failure(CasErrc::ResourceLimit,
            "Polynomial power expansion limit exceeded", "polynomial.convert");
    }
    const int exponent_value = static_cast<int>(*bounded_exponent);
 
    Polynomial<T> result(variable);
    if (budget) {
        checked_coefficient_count(1, *budget);
        normalization_check_children(budget, 1);
    }
    result.coeffs.emplace_back(1);
    if (exponent_value == 0) {
        auto defined = check_zero_power_base(power.base(), *context);
        if (!defined) { return Result<Polynomial<T>>::failure(defined.error()); }
        return result;
    }
    const auto base = symbolic_to_poly_recursive<T>(power.base(), variable, context, budget);
    if (!base) { return Result<Polynomial<T>>::failure(base.error()); }
    auto count = check_power_coefficient_count(base.value().coeffs.size(), exponent_value, budget);
    if (!count) { return Result<Polynomial<T>>::failure(count.error()); }
    for (int index = 0; index < exponent_value; ++index) {
        if constexpr (std::is_same_v<T, SymbolicPolyCoeff>) {
            if (budget) {
                result = multiply_checked_coefficients(result, base.value(), *budget);
                continue;
            }
        }
        if (!polynomial_product_fits(result, base.value())) {
            return Result<Polynomial<T>>::failure(CasErrc::ResourceLimit,
                "Polynomial coefficient storage limit exceeded", "polynomial.convert");
        }
        result = result * base.value();
    }
    return result;
}

引用了 LMCAS::PowerNode::base(), LMCAS::Polynomial< CoeffType >::coeffs, context, exponent, LMCAS::PowerNode::exponent(), normalization_check_children(), polynomial_product_fits(), ResourceLimit, symbolic_power_to_poly(), symbolic_to_poly_recursive(), try_get_integer_value(), UnsupportedExpression , 以及 variable.

被这些函数引用 symbolic_power_to_poly() , 以及 symbolic_to_poly_recursive().

函数调用图:

这是这个函数的调用关系图:

symbolic_product()

std::shared_ptr< SymbolicExpr > LMCAS::symbolic_product	(	const std::shared_ptr< SymbolicExpr > &	body,
		const std::string &	index,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper )

在文件 series_engine.cpp 第 384 行定义.

                                                                                        {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!body || !lower || !upper) {
        return nullptr;
    }
    BigInt lv, uv;
    if (try_get_integer_value(
            std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(lower)), lv) &&
        try_get_integer_value(
            std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(upper)), uv)) {
        if (uv < lv) {
            return SymbolicExpr::number(1);
        }
        const BigInt span = uv - lv;
        if (span < BigInt(50)) {
            const auto iterations = *span.try_to_uint64() + 1;
            auto result = SymbolicExpr::number(1);
            BigInt k = lv;
            const BigInt increment(1);
            for (std::uint64_t iteration = 0; iteration < iterations; ++iteration, k += increment) {
                auto val = SymbolicExpr::number(k);
                auto term = detail::make_expression_ptr(detail::substitute_node(detail::node(body), index, detail::node(val), transform_budget));
                if (term) { term = detail::make_expression_ptr(detail::normalize_node(detail::node(term), transform_budget)); result = SymbolicExpr::multiply(result, term); }
            }
            return detail::make_expression_ptr(detail::normalize_node(detail::node(result), transform_budget));
        }
    }
    return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<ProductNode>(LMCAS::detail::node(body), index, LMCAS::detail::node(lower), LMCAS::detail::node(upper)));
}

引用了 context, lower, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::substitute_node(), symbolic_product(), try_get_integer_value() , 以及 upper.

被这些函数引用 symbolic_product().

函数调用图:

这是这个函数的调用关系图:

symbolic_product_to_poly()

template<typename T>

Result< Polynomial< T > > LMCAS::symbolic_product_to_poly	(	const MultiplyNode &	multiply,
		const std::string &	variable,
		ComputationContext *	context,
		detail::RewriteBudget *	budget )

在文件 poly_utils.cpp 第 358 行定义.

                                                              {
    detail::RewriteScope scope(budget);
    Polynomial<T> result(variable);
    if (budget) {
        checked_coefficient_count(1, *budget);
        normalization_check_children(budget, 1);
    }
    result.coeffs.emplace_back(1);
    for (const auto& operand : multiply.operands()) {
        auto child = symbolic_to_poly_recursive<T>(operand, variable, context, budget);
        if (!child) { return Result<Polynomial<T>>::failure(child.error()); }
        if constexpr (std::is_same_v<T, SymbolicPolyCoeff>) {
            if (budget) {
                result = multiply_checked_coefficients(result, child.value(), *budget);
                continue;
            }
        }
        if (!polynomial_product_fits(result, child.value())) {
            return Result<Polynomial<T>>::failure(CasErrc::ResourceLimit,
                "Polynomial coefficient storage limit exceeded", "polynomial.convert");
        }
        result = result * child.value();
    }
    return result;
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, context, normalization_check_children(), polynomial_product_fits(), ResourceLimit, symbolic_product_to_poly(), symbolic_to_poly_recursive() , 以及 variable.

被这些函数引用 symbolic_product_to_poly() , 以及 symbolic_to_poly_recursive().

函数调用图:

这是这个函数的调用关系图:

symbolic_root_term()

std::shared_ptr< SymbolicExpr > LMCAS::symbolic_root_term ( const std::shared_ptr< SymbolicExpr > & coefficient, const std::string & variable, int degree )

static

在文件 root_of_identity.cpp 第 51 行定义.

                                           {
    if (degree == 0) return coefficient;
    auto symbol = SymbolicExpr::variable(variable);
    auto power = degree == 1
        ? symbol : SymbolicExpr::power(symbol, SymbolicExpr::number(degree));
    return coefficient->is_one()
        ? power : SymbolicExpr::multiply(coefficient, power);
}

引用了 symbolic_root_term() , 以及 variable.

被这些函数引用 symbolic_poly_to_expr() , 以及 symbolic_root_term().

函数调用图:

这是这个函数的调用关系图:

symbolic_sum()

std::shared_ptr< SymbolicExpr > LMCAS::symbolic_sum	(	const std::shared_ptr< SymbolicExpr > &	body,
		const std::string &	index,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper )

在文件 series_engine.cpp 第 335 行定义.

                                                                                        {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    if (!body || !lower || !upper) {
        return nullptr;
    }
    BigInt lv, uv;
    if (try_get_integer_value(
            std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(lower)), lv) &&
        try_get_integer_value(
            std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(upper)), uv)) {
        if (uv < lv) {
            return SymbolicExpr::number(0);
        }
        const BigInt span = uv - lv;
        if (span < BigInt(100)) {
            const auto iterations = *span.try_to_uint64() + 1;
            std::vector<std::shared_ptr<const SymbolicNode>> terms;
            BigInt k = lv;
            const BigInt increment(1);
            for (std::uint64_t iteration = 0; iteration < iterations; ++iteration, k += increment) {
                auto val = SymbolicExpr::number(k);
                auto term = detail::make_expression_ptr(detail::substitute_node(detail::node(body), index, detail::node(val), transform_budget));
                if (term) { term = detail::make_expression_ptr(detail::normalize_node(detail::node(term), transform_budget)); terms.push_back(LMCAS::detail::node(term)); }
            }
            if (terms.empty()) {
                return SymbolicExpr::number(0);
            }
            if (terms.size() == 1) {
                return detail::make_expression_ptr(detail::normalize_node(terms[0], transform_budget));
            }
            return detail::make_expression_ptr(detail::normalize_node(LMCAS::detail::make_node<AddNode>(terms), transform_budget));
        }
    }
    auto k_var = SymbolicExpr::variable(index);
    if (body->to_string() == k_var->to_string()) {
        auto u = upper; auto l = lower;
        auto u1 = SymbolicExpr::add(u, SymbolicExpr::number(1));
        auto su = SymbolicExpr::divide(SymbolicExpr::multiply(u, u1), SymbolicExpr::number(2));
        auto lm1 = SymbolicExpr::add(l, SymbolicExpr::number(-1));
        auto sl = SymbolicExpr::divide(SymbolicExpr::multiply(lm1, l), SymbolicExpr::number(2));
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::add(su, SymbolicExpr::multiply(SymbolicExpr::number(-1), sl))), transform_budget));
    }
    return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<SummationNode>(LMCAS::detail::node(body), index, LMCAS::detail::node(lower), LMCAS::detail::node(upper)));
}

引用了 context, lower, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::substitute_node(), symbolic_sum(), try_get_integer_value(), u , 以及 upper.

被这些函数引用 symbolic_sum().

函数调用图:

这是这个函数的调用关系图:

symbolic_sum_to_poly()

template<typename T>

Result< Polynomial< T > > LMCAS::symbolic_sum_to_poly	(	const AddNode &	add,
		const std::string &	variable,
		ComputationContext *	context,
		detail::RewriteBudget *	budget )

在文件 poly_utils.cpp 第 338 行定义.

                                                              {
    detail::RewriteScope scope(budget);
    Polynomial<T> result(variable);
    for (const auto& operand : add.operands()) {
        auto child = symbolic_to_poly_recursive<T>(operand, variable, context, budget);
        if (!child) { return Result<Polynomial<T>>::failure(child.error()); }
        if constexpr (std::is_same_v<T, SymbolicPolyCoeff>) {
            if (budget) {
                result = add_checked_coefficients(result, child.value(), *budget);
                continue;
            }
        }
        result = result + child.value();
    }
    return result;
}

引用了 add(), context, symbolic_sum_to_poly(), symbolic_to_poly_recursive() , 以及 variable.

被这些函数引用 symbolic_sum_to_poly() , 以及 symbolic_to_poly_recursive().

函数调用图:

这是这个函数的调用关系图:

symbolic_to_poly_recursive()

template<typename T>

Result< Polynomial< T > > LMCAS::symbolic_to_poly_recursive	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable,
		ComputationContext *	context,
		detail::RewriteBudget *	budget )

在文件 poly_utils.cpp 第 387 行定义.

                                                                                         {
    detail::RewriteScope scope(budget);
    if (!node) {
        return Result<Polynomial<T>>::failure(CasErrc::InvalidArgument,
            "Expression node must not be null", "polynomial.convert");
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        BigInt exponent;
        if (try_get_integer_value(
                std::dynamic_pointer_cast<const NumberNode>(power->exponent()), exponent) &&
            exponent.is_zero()) {
            return symbolic_power_to_poly<T>(*power, variable, context, budget);
        }
    }
    if (!expression_depends_on_variable(node, variable, budget)) {
        return constant_to_poly<T>(node, variable, budget);
    }
 
    if (auto symbol = std::dynamic_pointer_cast<const VariableNode>(node)) {
        if (!symbol->is_constant() && symbol->name() == variable) {
            if constexpr (std::is_same_v<T, SymbolicPolyCoeff>) {
                if (budget) {
                    checked_coefficient_count(2, *budget);
                    normalization_check_children(budget, 2);
                    Polynomial<T> result(variable);
                    result.coeffs.reserve(2);
                    result.coeffs.emplace_back(0);
                    result.coeffs.emplace_back(1);
                    return result;
                }
            }
            return Polynomial<T>({T(0), T(1)}, variable);
        }
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return symbolic_sum_to_poly<T>(*add, variable, context, budget);
    }
 
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return symbolic_product_to_poly<T>(*multiply, variable, context, budget);
    }
 
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return symbolic_power_to_poly<T>(*power, variable, context, budget);
    }
 
    return Result<Polynomial<T>>::failure(CasErrc::UnsupportedExpression,
        "Expression is not a polynomial in the requested variable", "polynomial.convert");
}

引用了 LMCAS::Polynomial< CoeffType >::Polynomial(), add(), LMCAS::Polynomial< CoeffType >::coeffs, context, exponent, expression_depends_on_variable(), InvalidArgument, normalization_check_children(), symbolic_power_to_poly(), symbolic_product_to_poly(), symbolic_sum_to_poly(), symbolic_to_poly_recursive(), try_get_integer_value(), UnsupportedExpression , 以及 variable.

被这些函数引用 __attribute__(), symbolic_power_to_poly(), symbolic_product_to_poly(), symbolic_sum_to_poly(), LMCAS::detail::symbolic_to_poly_checked() , 以及 symbolic_to_poly_recursive().

函数调用图:

这是这个函数的调用关系图:

tan() [1/2]

ExprResult LMCAS::tan

(

const ExprPtr &

expression

)

在文件 expr_elementary.cpp 第 69 行定义.

                                          {
    ComputationContext context;
    return tan(expression, context);
}

引用了 context , 以及 tan().

函数调用图:

tan() [2/2]

ExprResult LMCAS::tan	(	const ExprPtr &	expression,
		ComputationContext &	context )

在文件 expr_elementary.cpp 第 62 行定义.

                                                                       {
    auto valid = require_dimensionless(expression, "tan");
    if (!valid) { return valid; }
    return make_unary_math_expr(expression, context, "tan",
                                SymbolicExpr::tan);
}

引用了 context, LMCAS::expr_detail::expr_common::make_unary_math_expr(), LMCAS::expr_detail::expr_common::require_dimensionless() , 以及 tan().

被这些函数引用 LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), tan(), tan() , 以及 LMCAS::anonymous_namespace{differentiation_functions.cpp}::trigonometric_outer().

函数调用图:

这是这个函数的调用关系图:

tangent_plane_checked() [1/2]

PlaneSymbolicResult LMCAS::tangent_plane_checked	(	const SurfaceSymbolic &	surf,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	point )

在文件 symbolic_geometry_surface.cpp 第 250 行定义.

                                                         {
    ComputationContext context;
    return tangent_plane_checked(surf, point, context);
}

引用了 context, point , 以及 tangent_plane_checked().

函数调用图:

tangent_plane_checked() [2/2]

PlaneSymbolicResult LMCAS::tangent_plane_checked	(	const SurfaceSymbolic &	surf,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	point,
		ComputationContext &	context )

在文件 symbolic_geometry_surface.cpp 第 189 行定义.

                                 {
    const std::string operation = "tangent_plane";
    auto valid = validate_surface_point(surf, point, context, operation);
    if (!valid) {
        return PlaneSymbolicResult::failure(valid.error());
    }
    auto step = context.consume_steps(surf.vars.size() * 4 + 4, operation);
    if (!step) {
        return PlaneSymbolicResult::failure(step.error());
    }
 
    auto gradient = surface_gradient_at_point_checked(surf, point, operation, context);
    if (!gradient) {
        return PlaneSymbolicResult::failure(gradient.error());
    }
    std::vector<double> gradient_values;
    auto scaled = surface_gradient_scale_checked(
        gradient.value(), context, operation, gradient_values,
        "tangent plane is undefined at a singular point");
    if (!scaled) {
        return PlaneSymbolicResult::failure(scaled.error());
    }
 
    std::vector<double> point_values;
    auto point_scale = numeric_vector_scale_checked(
        point, context, operation, &point_values);
    if (!point_scale &&
        (point_scale.error().code == CasErrc::Cancelled ||
         point_scale.error().code == CasErrc::ResourceLimit)) {
        return PlaneSymbolicResult::failure(point_scale.error());
    }
    if (point_scale && point_scale.value() != 0.0 &&
        scaled.value() >
            std::numeric_limits<double>::max() /
                point_scale.value() /
                static_cast<double>(point.size())) {
        return scaled_tangent_plane(
            gradient_values, scaled.value(), point_values,
            point_scale.value(), operation);
    }
 
    auto dot = vector_dot_checked(gradient.value(), point, context);
    if (!dot) {
        return PlaneSymbolicResult::failure(dot.error());
    }
    auto d = simplify_checked(
        dot.value(), operation,
        "tangent plane constant is outside the supported domain", context);
    if (!d) {
        return PlaneSymbolicResult::failure(d.error());
    }
 
    PlaneSymbolic plane;
    plane.normal = std::move(gradient.value());
    plane.d = std::move(d.value());
    return PlaneSymbolicResult::success(std::move(plane));
}

引用了 Cancelled, context, LMCAS::PlaneSymbolic::d, LMCAS::Result< PlaneSymbolic >::failure(), gradient(), LMCAS::PlaneSymbolic::normal, LMCAS::geometry_detail::numeric_vector_scale_checked(), plane, point, ResourceLimit, LMCAS::geometry_detail::simplify_checked(), LMCAS::Result< PlaneSymbolic >::success(), tangent_plane_checked(), LMCAS::geometry_detail::validate_surface_point(), LMCAS::SurfaceSymbolic::vars , 以及 vector_dot_checked().

被这些函数引用 tangent_plane_checked() , 以及 tangent_plane_checked().

函数调用图:

这是这个函数的调用关系图:

te_abs_decay()

std::shared_ptr< SymbolicExpr > LMCAS::te_abs_decay ( const std::shared_ptr< SymbolicExpr > & f, const std::string & t, ComputationContext & context )

static

在文件 transform_fourier.cpp 第 30 行定义.

                                                                                           {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto function = std::dynamic_pointer_cast<const FunctionNode>(detail::node(f));
    if (!function || function->type() != FunctionNode::FuncType::Exp ||
        function->arguments().size() != 1) return nullptr;
    auto argument = detail::make_expression_ptr(function->arguments()[0]);
    auto parts = te_split_coeff(argument, t);
    if (!te_is_abs_variable(detail::node(parts.second), t)) return nullptr;
    return detail::make_expression_ptr(detail::normalize_node(SymbolicFactory::create_multiply({
        SymbolicFactory::create_number(BigInt(-1)), detail::node(parts.first)}), transform_budget));
}

引用了 context, LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::FunctionNode::Exp, function(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), t, te_abs_decay(), te_is_abs_variable() , 以及 LMCAS::transform_detail::te_split_coeff().

被这些函数引用 fourier_transform_core() , 以及 te_abs_decay().

函数调用图:

这是这个函数的调用关系图:

te_abs_fourier()

std::shared_ptr< SymbolicExpr > LMCAS::te_abs_fourier ( const std::shared_ptr< SymbolicExpr > & rate, const std::string & omega, ComputationContext & context )

static

在文件 transform_fourier.cpp 第 89 行定义.

                                                                                                  {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto two = SymbolicFactory::create_number(BigInt(2));
    auto denominator = SymbolicFactory::create_add({
        SymbolicFactory::create_power(detail::node(rate), two),
        SymbolicFactory::create_power(SymbolicFactory::create_variable(omega), two)});
    auto reciprocal = SymbolicFactory::create_power(
        denominator, SymbolicFactory::create_number(BigInt(-1)));
    return detail::make_expression_ptr(detail::normalize_node(SymbolicFactory::create_multiply({
        two, detail::node(rate), reciprocal}), transform_budget));
}

引用了 context, LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_power(), LMCAS::SymbolicFactory::create_variable(), denominator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 te_abs_fourier().

被这些函数引用 fourier_transform_core(), inverse_fourier_transform_core() , 以及 te_abs_fourier().

函数调用图:

这是这个函数的调用关系图:

te_accept_decay()

bool LMCAS::te_accept_decay ( const std::shared_ptr< SymbolicExpr > & rate, const AssumptionContext & assumptions, std::vector< std::shared_ptr< SymbolicExpr > > & conditions, ComputationContext & context )

static

在文件 transform_fourier.cpp 第 58 行定义.

                                                         {
    InferenceEngine inference(assumptions);
    auto real = inference.query_real_checked(*rate, context);
    if (!real) {
        if (real.error().code == CasErrc::DomainError) return false;
        throw real.error();
    }
    if (real.value() != Tribool::True) {
        return false;
    }
    auto positive = inference.query_positive_checked(*rate, context);
    if (!positive) {
        throw positive.error();
    }
    if (positive.value() == Tribool::True) {
        return true;
    }
    auto nonpositive = inference.query_nonpositive_checked(*rate, context);
    if (!nonpositive) {
        throw nonpositive.error();
    }
    if (positive.value() == Tribool::False || nonpositive.value() == Tribool::True) {
        return false;
    }
    conditions.push_back(te_decay_condition(rate));
    return true;
}

引用了 LMCAS::CasError::code, context, DomainError, LMCAS::Result< T >::error(), False, real(), te_accept_decay(), te_decay_condition(), True , 以及 LMCAS::Result< T >::value().

被这些函数引用 fourier_transform_core() , 以及 te_accept_decay().

函数调用图:

这是这个函数的调用关系图:

te_convolve_core()

TransformEngineResult LMCAS::te_convolve_core ( const std::shared_ptr< SymbolicExpr > & f, const std::shared_ptr< SymbolicExpr > & g, const std::string & variable, ComputationContext & context )

static

在文件 transform_convolution.cpp 第 63 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    constexpr const char* operation = "convolve";
    auto step = context.consume_steps(1, operation);
    if (!step) return TransformEngineResult::failure(step.error());
 
    if (te_is_zero(f) || te_is_zero(g)) {
        return te_wrap_transform_result(SymbolicExpr::number(0), operation);
    }
 
    auto left_sum = std::dynamic_pointer_cast<const AddNode>(detail::node(f));
    if (left_sum) {
        return te_convolve_sum(*left_sum, g, true, variable, context);
    }
    auto right_sum = std::dynamic_pointer_cast<const AddNode>(detail::node(g));
    if (right_sum) {
        return te_convolve_sum(*right_sum, f, false, variable, context);
    }
 
    auto left_parts = te_split_coeff(f, variable);
    if (te_depends_on(left_parts.second, variable) &&
        left_parts.second->to_string() != f->to_string()) {
        auto inner =
            te_convolve_core(left_parts.second, g, variable, context);
        if (!inner) return inner;
        auto scaled = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            left_parts.first, inner.value().value.expression)), transform_budget));
        return te_wrap_transform_result(scaled, operation);
    }
    auto right_parts = te_split_coeff(g, variable);
    if (te_depends_on(right_parts.second, variable) &&
        right_parts.second->to_string() != g->to_string()) {
        auto inner =
            te_convolve_core(f, right_parts.second, variable, context);
        if (!inner) return inner;
        auto scaled = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            right_parts.first, inner.value().value.expression)), transform_budget));
        return te_wrap_transform_result(scaled, operation);
    }
 
    const auto left = te_match_scaled_gaussian(f, variable);
    const auto right = te_match_scaled_gaussian(g, variable);
    if (!left || !right) {
        return TransformEngineResult::failure(
            CasErrc::Inconclusive,
            "当前双边卷积规则不支持该表达式对", operation);
    }
 
    const Rational rate_sum = left->rate + right->rate;
    const Rational output_rate = left->rate * right->rate / rate_sum;
    auto scale = SymbolicExpr::multiply(
        SymbolicExpr::multiply(left->coefficient, right->coefficient),
        SymbolicExpr::sqrt(SymbolicExpr::divide(
            LMCAS::detail::make_expression_ptr(
                LMCAS::detail::make_node<VariableNode>("pi", true)),
            SymbolicExpr::number(rate_sum))));
    auto square = SymbolicExpr::power(
        SymbolicExpr::variable(variable), SymbolicExpr::number(2));
    auto exponent = SymbolicExpr::multiply(
        SymbolicExpr::number(-output_rate), square);
    auto gaussian = SymbolicExpr::exp(exponent);
    return te_wrap_transform_result(
        detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(scale, gaussian)), transform_budget)), operation);
} catch (const CasError& error) {
    return TransformEngineResult::failure(error);
} catch (const std::bad_alloc&) {
    return TransformEngineResult::failure(CasErrc::ResourceLimit, "allocation failed", "convolve");
} catch (const std::length_error& error) {
    return TransformEngineResult::failure(CasErrc::ResourceLimit, error.what(), "convolve");
} catch (const std::exception& error) {
    return TransformEngineResult::failure(CasErrc::InternalInvariant, error.what(), "convolve");
}

引用了 context, exponent, LMCAS::Result< Verified< EvaluatedTransform > >::failure(), Inconclusive, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), right, te_convolve_core(), te_convolve_sum(), LMCAS::transform_detail::te_depends_on(), LMCAS::transform_detail::te_is_zero(), LMCAS::transform_detail::te_match_scaled_gaussian(), LMCAS::transform_detail::te_split_coeff(), LMCAS::transform_detail::te_wrap_transform_result() , 以及 variable.

被这些函数引用 convolve_checked(), te_convolve_core() , 以及 te_convolve_sum().

函数调用图:

这是这个函数的调用关系图:

te_convolve_sum()

TransformEngineResult LMCAS::te_convolve_sum ( const AddNode & addition, const std::shared_ptr< SymbolicExpr > & other, bool sum_is_left, const std::string & variable, ComputationContext & context )

static

在文件 transform_convolution.cpp 第 36 行定义.

                                                                                  {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::shared_ptr<SymbolicExpr> accumulated;
    for (const auto& operand : addition.operands()) {
        auto term = detail::make_expression_ptr(operand);
        auto transformed = sum_is_left
            ? te_convolve_core(term, other, variable, context)
            : te_convolve_core(other, term, variable, context);
        if (!transformed) return transformed;
        auto expression = transformed.value().value.expression;
        accumulated = accumulated ? SymbolicExpr::add(accumulated, expression) : expression;
    }
    return te_wrap_transform_result(
        accumulated ? detail::make_expression_ptr(detail::normalize_node(detail::node(accumulated), transform_budget)) : SymbolicExpr::number(0), "convolve");
} catch (const CasError& error) {
    return TransformEngineResult::failure(error);
} catch (const std::bad_alloc&) {
    return TransformEngineResult::failure(CasErrc::ResourceLimit, "allocation failed", "te_convolve_sum");
} catch (const std::length_error& error) {
    return TransformEngineResult::failure(CasErrc::ResourceLimit, error.what(), "te_convolve_sum");
} catch (const std::exception& error) {
    return TransformEngineResult::failure(CasErrc::InternalInvariant, error.what(), "te_convolve_sum");
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::AddNode::operands(), te_convolve_core(), te_convolve_sum(), LMCAS::transform_detail::te_wrap_transform_result() , 以及 variable.

被这些函数引用 te_convolve_core() , 以及 te_convolve_sum().

函数调用图:

这是这个函数的调用关系图:

te_decay_condition()

std::shared_ptr< SymbolicExpr > LMCAS::te_decay_condition ( const std::shared_ptr< SymbolicExpr > & rate )

static

在文件 transform_fourier.cpp 第 45 行定义.

                                             {
    auto product = std::dynamic_pointer_cast<const MultiplyNode>(detail::node(rate));
    if (!product) return te_gt_condition(rate, SymbolicExpr::number(0));
    std::vector<std::shared_ptr<const SymbolicNode>> factors;
    for (const auto& factor : product->operands()) {
        auto number = std::dynamic_pointer_cast<const NumberNode>(factor);
        if (!number || !number->is_positive()) factors.push_back(factor);
    }
    auto lhs = detail::make_expression_ptr(SymbolicFactory::create_multiply(std::move(factors)));
    return te_gt_condition(lhs, SymbolicExpr::number(0));
}

引用了 LMCAS::SymbolicFactory::create_multiply(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), te_decay_condition() , 以及 LMCAS::transform_detail::te_gt_condition().

被这些函数引用 te_accept_decay() , 以及 te_decay_condition().

函数调用图:

这是这个函数的调用关系图:

te_extract_exp()

bool LMCAS::te_extract_exp ( const std::shared_ptr< SymbolicExpr > & e, const std::string & t, std::shared_ptr< SymbolicExpr > & a_out, std::shared_ptr< SymbolicExpr > & rem_out )

static

在文件 transform_laplace.cpp 第 49 行定义.

                                                                                                     {
    if (!e || !LMCAS::detail::node(e)) {
        return false;
    }
    auto fn = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(e));
    if (fn && fn->type() == FunctionNode::FuncType::Exp && !fn->arguments().empty()) {
        a_out = te_linear_coefficient(fn->arguments()[0], t);
        if (a_out) {
            rem_out = detail::make_expression_ptr(SymbolicFactory::create_number(BigInt(1)));
            return true;
        }
    }
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(e));
    if (mul) {
        for (size_t i = 0; i < mul->operands().size(); ++i) {
            auto fac = LMCAS::detail::make_expression_ptr(mul->operands()[i]);
            std::shared_ptr<SymbolicExpr> at, rt;
            if (te_extract_exp(fac, t, at, rt)) {
                std::vector<std::shared_ptr<const SymbolicNode>> rest = mul->operands();
                rest.erase(rest.begin() + static_cast<std::ptrdiff_t>(i));
                rem_out = detail::make_expression_ptr(
                    SymbolicFactory::create_multiply(std::move(rest)));
                a_out = at; return true;
            }
        }
    }
    return false;
}

引用了 LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), e(), LMCAS::FunctionNode::Exp, LMCAS::detail::make_expression_ptr(), mul(), LMCAS::detail::node(), t, te_extract_exp() , 以及 LMCAS::transform_detail::te_linear_coefficient().

被这些函数引用 LMCAS::transform_detail::laplace_transform_core(), te_extract_exp(), te_laplace_lookup() , 以及 te_laplace_roc().

函数调用图:

这是这个函数的调用关系图:

te_fourier_sum()

std::shared_ptr< SymbolicExpr > LMCAS::te_fourier_sum ( const AddNode & addition, const std::string & t, const std::string & omega, ComputationContext & context, const AssumptionContext & assumptions, std::vector< std::shared_ptr< SymbolicExpr > > & conditions )

static

在文件 transform_fourier.cpp 第 121 行定义.

                                                        {
    std::shared_ptr<SymbolicExpr> result;
    for (const auto& operand : addition.operands()) {
        auto transformed = fourier_transform_core(detail::make_expression_ptr(operand),
            t, omega, context, assumptions, conditions);
        if (!transformed) return nullptr;
        result = result ? SymbolicExpr::add(result, transformed) : transformed;
    }
    return result;
}

引用了 context, fourier_transform_core(), LMCAS::detail::make_expression_ptr(), LMCAS::AddNode::operands(), t , 以及 te_fourier_sum().

被这些函数引用 fourier_transform_core() , 以及 te_fourier_sum().

函数调用图:

这是这个函数的调用关系图:

te_fourier_unevaluated()

std::shared_ptr< SymbolicExpr > LMCAS::te_fourier_unevaluated ( const std::shared_ptr< SymbolicExpr > & f, const std::string & t, const std::string & omega )

static

在文件 transform_fourier.cpp 第 14 行定义.

                            {
    return detail::make_expression_ptr(detail::make_node<TransformNode>(
        TransformNode::TransformType::Fourier, detail::node(f)->clone(), t,
        SymbolicFactory::create_variable(omega)));
}

引用了 LMCAS::SymbolicFactory::create_variable(), LMCAS::TransformNode::Fourier, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), t , 以及 te_fourier_unevaluated().

被这些函数引用 fourier_transform_core() , 以及 te_fourier_unevaluated().

函数调用图:

这是这个函数的调用关系图:

te_gaussian_fourier()

std::shared_ptr< SymbolicExpr > LMCAS::te_gaussian_fourier ( const Rational & rate, const std::string & omega )

static

在文件 transform_fourier.cpp 第 104 行定义.

                                                  {
    auto pi = detail::make_expression_ptr(detail::make_node<VariableNode>("pi", true));
    auto coefficient = SymbolicExpr::sqrt(
        SymbolicExpr::divide(pi, SymbolicExpr::number(rate)));
    auto exponent = SymbolicExpr::multiply(SymbolicExpr::number(-Rational(1) / (Rational(4) * rate)),
        SymbolicExpr::power(SymbolicExpr::variable(omega), SymbolicExpr::number(2)));
    return SymbolicExpr::multiply(coefficient, SymbolicExpr::exp(exponent));
}

引用了 exponent, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), pi() , 以及 te_gaussian_fourier().

被这些函数引用 fourier_transform_core() , 以及 te_gaussian_fourier().

函数调用图:

这是这个函数的调用关系图:

te_inv_power()

std::shared_ptr< SymbolicExpr > LMCAS::te_inv_power ( const std::shared_ptr< SymbolicExpr > & F, const std::string & s, const std::string & t, ComputationContext & context )

static

在文件 transform_inverse_laplace.cpp 第 33 行定义.

                                                     {
    if (!F || !LMCAS::detail::node(F)) {
        return nullptr;
    }
    auto tv = SymbolicExpr::variable(t);
    auto pw = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(F));
    if (!pw) {
        return nullptr;
    }
    BigInt exponent;
    if (!try_get_integer_value(std::dynamic_pointer_cast<const NumberNode>(pw->exponent()), exponent) ||
        !exponent.is_negative()) {
        return nullptr;
    }
    const BigInt n = -exponent;
    auto make_exp = [&](const std::shared_ptr<SymbolicExpr>& a) {
        auto arg = SymbolicExpr::multiply(a, tv);
        return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Exp,
            std::vector<std::shared_ptr<const SymbolicNode>>{LMCAS::detail::node(arg)}));
    };
    auto bv = std::dynamic_pointer_cast<const VariableNode>(pw->base());
    if (bv && !bv->is_constant() && bv->name() == s) {
        if (n == BigInt(1)) {
            return SymbolicExpr::number(1);
        }
        return SymbolicExpr::divide(SymbolicExpr::power(tv, SymbolicExpr::number(n - BigInt(1))),
            SymbolicExpr::number(te_factorial(n - BigInt(1), context)));
    }
    auto pole = te_inverse_pole(pw->base(), s);
        if (pole) {
            if (n == BigInt(1)) {
                if (te_is_zero(pole)) {
                    return SymbolicExpr::number(1);
                }
                return make_exp(pole);
            }
            auto tp = SymbolicExpr::power(tv, SymbolicExpr::number(n - BigInt(1)));
            auto fv = SymbolicExpr::number(te_factorial(n - BigInt(1), context));
            if (te_is_zero(pole)) {
                return SymbolicExpr::divide(tp, fv);
            }
            return SymbolicExpr::divide(SymbolicExpr::multiply(tp, make_exp(pole)), fv);
        }
    return nullptr;
}

引用了 a, context, LMCAS::FunctionNode::Exp, exponent, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), t, LMCAS::transform_detail::te_factorial(), te_inv_power(), te_inverse_pole(), LMCAS::transform_detail::te_is_zero() , 以及 try_get_integer_value().

被这些函数引用 inverse_laplace_core(), te_inv_power() , 以及 te_inv_product().

函数调用图:

这是这个函数的调用关系图:

te_inv_product()

std::shared_ptr< SymbolicExpr > LMCAS::te_inv_product ( const std::shared_ptr< SymbolicExpr > & F, const std::string & s, const std::string & t, ComputationContext & context )

static

在文件 transform_inverse_laplace.cpp 第 91 行定义.

                                                     {
    if (!F || !LMCAS::detail::node(F)) {
        return nullptr;
    }
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(F));
    if (!mul || mul->operands().size() < 2) {
        return nullptr;
    }
    std::vector<std::shared_ptr<const SymbolicNode>> num_parts;
    std::shared_ptr<const SymbolicNode> den_part = nullptr;
    for (const auto& op : mul->operands()) {
        if (!den_part && te_is_denominator_factor(op, s)) {
            den_part = op;
            continue;
        }
        num_parts.push_back(op);
    }
    if (!den_part) {
        return nullptr;
    }
    std::shared_ptr<SymbolicExpr> num_expr;
    if (num_parts.empty()) {
        num_expr = SymbolicExpr::number(1);
    } else if (num_parts.size() == 1) {
        num_expr = LMCAS::detail::make_expression_ptr(num_parts[0]);
    } else {
        num_expr = LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<MultiplyNode>(num_parts));
    }
    if (!te_depends_on(num_expr, s)) {
        auto inv = te_inv_power(LMCAS::detail::make_expression_ptr(den_part), s, t, context);
        if (inv) {
            return SymbolicExpr::multiply(num_expr, inv);
        }
    }
    return nullptr;
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), mul(), LMCAS::detail::node(), op, t, LMCAS::transform_detail::te_depends_on(), te_inv_power(), te_inv_product() , 以及 te_is_denominator_factor().

被这些函数引用 inverse_laplace_core() , 以及 te_inv_product().

函数调用图:

这是这个函数的调用关系图:

te_inverse_pole()

std::shared_ptr< SymbolicExpr > LMCAS::te_inverse_pole ( const std::shared_ptr< const SymbolicNode > & base, const std::string & variable )

static

在文件 transform_inverse_laplace.cpp 第 24 行定义.

                                                                              {
    auto addition = std::dynamic_pointer_cast<const AddNode>(base);
    if (!addition || addition->operands().size() != 2) return nullptr;
    auto pole = te_inverse_pole_term(*addition, 0, variable);
    if (pole) return pole;
    return te_inverse_pole_term(*addition, 1, variable);
}

引用了 te_inverse_pole(), te_inverse_pole_term() , 以及 variable.

被这些函数引用 te_inv_power() , 以及 te_inverse_pole().

函数调用图:

这是这个函数的调用关系图:

te_inverse_pole_term()

std::shared_ptr< SymbolicExpr > LMCAS::te_inverse_pole_term ( const AddNode & addition, std::size_t i, const std::string & variable )

static

在文件 transform_inverse_laplace.cpp 第 16 行定义.

                                                                     {
    auto symbol = std::dynamic_pointer_cast<const VariableNode>(addition.operands()[i]);
    if (!symbol || symbol->is_constant() || symbol->name() != variable) return nullptr;
    return detail::make_expression_ptr(SymbolicFactory::create_multiply({
        SymbolicFactory::create_number(BigInt(-1)), addition.operands()[1 - i]}));
}

引用了 LMCAS::SymbolicFactory::create_multiply(), LMCAS::SymbolicFactory::create_number(), LMCAS::detail::make_expression_ptr(), LMCAS::AddNode::operands(), te_inverse_pole_term() , 以及 variable.

被这些函数引用 te_inverse_pole() , 以及 te_inverse_pole_term().

函数调用图:

这是这个函数的调用关系图:

te_is_abs_variable()

bool LMCAS::te_is_abs_variable ( const std::shared_ptr< const SymbolicNode > & node, const std::string & variable )

static

在文件 transform_fourier.cpp 第 22 行定义.

                                                          {
    auto function = std::dynamic_pointer_cast<const FunctionNode>(node);
    if (!function || function->type() != FunctionNode::FuncType::Abs ||
        function->arguments().size() != 1) return false;
    auto argument = std::dynamic_pointer_cast<const VariableNode>(function->arguments()[0]);
    return argument && !argument->is_constant() && argument->name() == variable;
}

引用了 LMCAS::FunctionNode::Abs, function(), te_is_abs_variable() , 以及 variable.

被这些函数引用 te_abs_decay() , 以及 te_is_abs_variable().

函数调用图:

这是这个函数的调用关系图:

te_is_denominator_factor()

bool LMCAS::te_is_denominator_factor ( const std::shared_ptr< const SymbolicNode > & expression, const std::string & variable )

static

在文件 transform_inverse_laplace.cpp 第 81 行定义.

                               {
    const auto power = std::dynamic_pointer_cast<const PowerNode>(expression);
    if (!power) return false;
    const auto exponent = te_number_value(power->exponent());
    return exponent && *exponent < Rational(0) &&
        expression_depends_on_variable(power->base(), variable);
}

引用了 exponent, expression_depends_on_variable(), te_is_denominator_factor(), LMCAS::transform_detail::te_number_value() , 以及 variable.

被这些函数引用 te_inv_product() , 以及 te_is_denominator_factor().

函数调用图:

这是这个函数的调用关系图:

te_is_hyp()

bool LMCAS::te_is_hyp ( const std::shared_ptr< SymbolicExpr > & e, const std::string & v, bool & is_sinh, std::shared_ptr< SymbolicExpr > & freq )

static

在文件 transform_laplace.cpp 第 32 行定义.

                                                                        {
    if (!e || !LMCAS::detail::node(e)) {
        return false;
    }
    auto fn = std::dynamic_pointer_cast<const FunctionNode>(LMCAS::detail::node(e));
    if (!fn || fn->arguments().empty()) {
        return false;
    }
    if (fn->type() != FunctionNode::FuncType::Sinh && fn->type() != FunctionNode::FuncType::Cosh) {
        return false;
    }
    is_sinh = (fn->type() == FunctionNode::FuncType::Sinh);
    freq = te_linear_coefficient(fn->arguments()[0], v);
    return freq != nullptr;
}

引用了 LMCAS::FunctionNode::Cosh, e(), LMCAS::detail::node(), LMCAS::FunctionNode::Sinh, te_is_hyp(), LMCAS::transform_detail::te_linear_coefficient() , 以及 v.

被这些函数引用 te_is_hyp() , 以及 te_laplace_lookup().

函数调用图:

这是这个函数的调用关系图:

te_is_power_of_var()

bool LMCAS::te_is_power_of_var ( const std::shared_ptr< SymbolicExpr > & e, const std::string & v, BigInt & n )

static

在文件 transform_laplace.cpp 第 15 行定义.

                                                                                                    {
    if (!e || !LMCAS::detail::node(e)) {
        return false;
    }
    auto vn = std::dynamic_pointer_cast<const VariableNode>(LMCAS::detail::node(e));
    if (vn && !vn->is_constant() && vn->name() == v) { n = BigInt(1); return true; }
    auto pw = std::dynamic_pointer_cast<const PowerNode>(LMCAS::detail::node(e));
    if (!pw) {
        return false;
    }
    auto bv = std::dynamic_pointer_cast<const VariableNode>(pw->base());
    if (!bv || bv->is_constant() || bv->name() != v) {
        return false;
    }
    return try_get_integer_value(std::dynamic_pointer_cast<const NumberNode>(pw->exponent()), n) &&
           !n.is_negative();
}

引用了 e(), LMCAS::detail::node(), te_is_power_of_var(), try_get_integer_value() , 以及 v.

被这些函数引用 te_is_power_of_var(), te_laplace_lookup() , 以及 te_laplace_roc().

函数调用图:

这是这个函数的调用关系图:

te_laplace_lookup()

std::shared_ptr< SymbolicExpr > LMCAS::te_laplace_lookup ( const std::shared_ptr< SymbolicExpr > & f, const std::string & t, const std::string & s, ComputationContext & context )

static

在文件 transform_laplace.cpp 第 79 行定义.

                                                     {
    if (!f || !LMCAS::detail::node(f)) return nullptr;
    auto sv = SymbolicExpr::variable(s);
    if (!te_depends_on(f, t)) return SymbolicExpr::divide(f, sv);
    BigInt n;
    if (te_is_power_of_var(f, t, n)) {
        return SymbolicExpr::divide(SymbolicExpr::number(te_factorial(n, context)),
            SymbolicExpr::power(sv, SymbolicExpr::number(n + BigInt(1))));
    }
    bool is_sin = false; std::shared_ptr<SymbolicExpr> freq;
    if (te_is_trig(f, t, is_sin, freq)) {
        auto den = SymbolicExpr::add(SymbolicExpr::power(sv, SymbolicExpr::number(2)), SymbolicExpr::power(freq, SymbolicExpr::number(2)));
        return is_sin ? SymbolicExpr::divide(freq, den) : SymbolicExpr::divide(sv, den);
    }
    bool is_sinh = false; std::shared_ptr<SymbolicExpr> hf;
    if (te_is_hyp(f, t, is_sinh, hf)) {
        auto den = SymbolicExpr::add(SymbolicExpr::power(sv, SymbolicExpr::number(2)), SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::power(hf, SymbolicExpr::number(2))));
        return is_sinh ? SymbolicExpr::divide(hf, den) : SymbolicExpr::divide(sv, den);
    }
    std::shared_ptr<SymbolicExpr> a, rem;
    if (te_extract_exp(f, t, a, rem) && !te_depends_on(rem, t))
        return SymbolicExpr::divide(rem, SymbolicExpr::add(sv, SymbolicExpr::multiply(SymbolicExpr::number(-1), a)));
    return nullptr;
}

引用了 a, context, LMCAS::detail::node(), t, LMCAS::transform_detail::te_depends_on(), te_extract_exp(), LMCAS::transform_detail::te_factorial(), te_is_hyp(), te_is_power_of_var(), LMCAS::transform_detail::te_is_trig() , 以及 te_laplace_lookup().

被这些函数引用 LMCAS::transform_detail::laplace_transform_core() , 以及 te_laplace_lookup().

函数调用图:

这是这个函数的调用关系图:

te_laplace_roc()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::te_laplace_roc ( const std::shared_ptr< SymbolicExpr > & f, const std::string & t, const std::string & s )

static

在文件 transform_laplace.cpp 第 106 行定义.

                        {
    if (!f || !LMCAS::detail::node(f)) return {};
    auto sv = SymbolicExpr::variable(s);
    if (!te_depends_on(f, t)) {
        auto condition = te_gt_condition(sv, SymbolicExpr::number(0));
        return condition ? std::vector<std::shared_ptr<SymbolicExpr>>{condition}
                         : std::vector<std::shared_ptr<SymbolicExpr>>{};
    }
    BigInt n;
    if (te_is_power_of_var(f, t, n)) {
        auto condition = te_gt_condition(sv, SymbolicExpr::number(0));
        return condition ? std::vector<std::shared_ptr<SymbolicExpr>>{condition}
                         : std::vector<std::shared_ptr<SymbolicExpr>>{};
    }
    bool is_sin = false;
    std::shared_ptr<SymbolicExpr> freq;
    if (te_is_trig(f, t, is_sin, freq)) {
        auto condition = te_gt_condition(sv, SymbolicExpr::number(0));
        return condition ? std::vector<std::shared_ptr<SymbolicExpr>>{condition}
                         : std::vector<std::shared_ptr<SymbolicExpr>>{};
    }
    std::shared_ptr<SymbolicExpr> a;
    std::shared_ptr<SymbolicExpr> rem;
    if (te_extract_exp(f, t, a, rem) && !te_depends_on(rem, t)) {
        auto condition = te_gt_condition(sv, a);
        return condition ? std::vector<std::shared_ptr<SymbolicExpr>>{condition}
                         : std::vector<std::shared_ptr<SymbolicExpr>>{};
    }
    return {};
}

引用了 a, LMCAS::detail::node(), t, LMCAS::transform_detail::te_depends_on(), te_extract_exp(), LMCAS::transform_detail::te_gt_condition(), te_is_power_of_var(), LMCAS::transform_detail::te_is_trig() , 以及 te_laplace_roc().

被这些函数引用 laplace_transform_checked() , 以及 te_laplace_roc().

函数调用图:

这是这个函数的调用关系图:

te_laplace_sum()

std::shared_ptr< SymbolicExpr > LMCAS::te_laplace_sum ( const std::shared_ptr< SymbolicExpr > & f, const AddNode & addition, const std::string & t, const std::string & s, ComputationContext & context )

static

在文件 transform_laplace.cpp 第 140 行定义.

                                                                         {
    std::shared_ptr<SymbolicExpr> result;
    for (const auto& operand : addition.operands()) {
        auto transformed = laplace_transform_core(
            detail::make_expression_ptr(operand), t, s, context);
        if (!transformed) return te_unevaluated_laplace(f, t, s);
        result = result ? SymbolicExpr::add(result, transformed) : transformed;
    }
    return result;
}

引用了 context, LMCAS::transform_detail::laplace_transform_core(), LMCAS::detail::make_expression_ptr(), LMCAS::AddNode::operands(), t, te_laplace_sum() , 以及 te_unevaluated_laplace().

被这些函数引用 LMCAS::transform_detail::laplace_transform_core() , 以及 te_laplace_sum().

函数调用图:

这是这个函数的调用关系图:

te_unevaluated_inv_laplace()

std::shared_ptr< SymbolicExpr > LMCAS::te_unevaluated_inv_laplace ( const std::shared_ptr< SymbolicExpr > & F, const std::string & s, const std::string & t )

static

在文件 transform_inverse_laplace.cpp 第 10 行定义.

                                                                                  {
    return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<TransformNode>(
        TransformNode::TransformType::InverseLaplace, LMCAS::detail::node(F)->clone(), s,
        SymbolicFactory::create_variable(t)));
}

引用了 LMCAS::SymbolicFactory::create_variable(), LMCAS::TransformNode::InverseLaplace, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), t , 以及 te_unevaluated_inv_laplace().

被这些函数引用 inverse_laplace_core() , 以及 te_unevaluated_inv_laplace().

函数调用图:

这是这个函数的调用关系图:

te_unevaluated_laplace()

std::shared_ptr< SymbolicExpr > LMCAS::te_unevaluated_laplace ( const std::shared_ptr< SymbolicExpr > & f, const std::string & t, const std::string & s )

static

在文件 transform_laplace.cpp 第 9 行定义.

                                                                                  {
    return LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<TransformNode>(
        TransformNode::TransformType::Laplace, LMCAS::detail::node(f)->clone(), t,
        SymbolicFactory::create_variable(s)));
}

引用了 LMCAS::SymbolicFactory::create_variable(), LMCAS::TransformNode::Laplace, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), t , 以及 te_unevaluated_laplace().

被这些函数引用 LMCAS::transform_detail::laplace_transform_core(), te_laplace_sum() , 以及 te_unevaluated_laplace().

函数调用图:

这是这个函数的调用关系图:

te_validate_convolution_inputs()

Result< void > LMCAS::te_validate_convolution_inputs ( const std::shared_ptr< SymbolicExpr > & f, const std::shared_ptr< SymbolicExpr > & g, const std::string & var, ComputationContext & context, const std::string & operation )

static

在文件 transform_convolution.cpp 第 11 行定义.

                                {
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!f || !LMCAS::detail::node(f) || !g || !LMCAS::detail::node(g)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "convolution expressions cannot be null",
                                     operation);
    }
    if (var.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "convolution variable name cannot be empty",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 te_validate_convolution_inputs().

被这些函数引用 convolve_checked() , 以及 te_validate_convolution_inputs().

函数调用图:

这是这个函数的调用关系图:

tf_back_substitute()

std::shared_ptr< SymbolicExpr > LMCAS::tf_back_substitute	(	const std::shared_ptr< SymbolicExpr > &	factor_expr,
		const std::vector< TransSubstitution > &	mappings,
		ComputationContext &	context )

将因子表达式中的不定元变量替换回原始超越子表达式.

对换元后的因子执行逆操作:遍历映射列表,将每个不定元(u0, u1, ...) 替换为其对应的原始超越表达式(如 sin(x),cos(x) 等). 逐一执行自由变量代入，复用调用者的变换预算。

参数

[in]	factor_expr	以不定元表示的因子表达式
[in]	mappings	换元映射列表(indeterminate -> trans_expr)

返回

替换后的符号表达式,以原始变量和超越函数表示

仅当表达式依赖该不定元时才执行替换

在文件 transcendental_rewrite.cpp 第 29 行定义.

                                                                               {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (!factor_expr || !LMCAS::detail::node(factor_expr)) {
        return factor_expr;
    }
    if (mappings.empty()) {
        return factor_expr;
    }
 
    auto result = factor_expr;
 
    for (const auto& m : mappings) {
        if (!m.trans_expr || m.indeterminate.empty()) {
            continue;
        }
 
        /// 仅当表达式依赖该不定元时才执行替换
        if (expression_depends_on_variable(LMCAS::detail::node(result), m.indeterminate)) {
            result = detail::make_expression_ptr(detail::substitute_node(detail::node(result), m.indeterminate, detail::node(m.trans_expr), transform_budget));
        }
    }
 
    return result;
}

引用了 context, expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::substitute_node() , 以及 tf_back_substitute().

被这些函数引用 tf_back_substitute() , 以及 tf_restore_factors().

函数调用图:

这是这个函数的调用关系图:

tf_build_polynomial()

Result< TfPolyBuildResult > LMCAS::tf_build_polynomial	(	const std::shared_ptr< SymbolicExpr > &	poly_expr,
		const std::vector< std::string > &	indeterminates,
		const std::string &	original_var )

在文件 transcendental_polynomial.cpp 第 166 行定义.

                                   {
    ComputationContext context;
    return tf_build_polynomial_impl(poly_expr, indeterminates, original_var, context);
}

引用了 context, tf_build_polynomial() , 以及 tf_build_polynomial_impl().

被这些函数引用 tf_build_polynomial().

函数调用图:

这是这个函数的调用关系图:

tf_build_polynomial_impl()

Result< TfPolyBuildResult > LMCAS::tf_build_polynomial_impl	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::vector< std::string > &	indeterminates,
		const std::string &	original_variable,
		ComputationContext &	context )

在文件 transcendental_polynomial.cpp 第 174 行定义.

                                                                    {
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                            context.limits().max_ast_nodes,
                                            "tf_build_polynomial");
    TfPolyBuildResult result;
    result.success = false;
 
    if (!poly_expr || !LMCAS::detail::node(poly_expr) || original_var.empty()) {
        return Result<TfPolyBuildResult>::failure(CasErrc::InvalidArgument,
            "expression and variable must be nonempty", "tf_build_polynomial");
    }
 
    auto before = tf_polynomial_variables(poly_expr, indeterminates, original_var);
    if (!before.empty() && !tf_validate_polynomial(poly_expr, before)) return result;
    auto expanded = detail::make_expression_ptr(detail::expand_node(detail::node(poly_expr), transform_budget));
    if (!expanded || !LMCAS::detail::node(expanded)) {
        expanded = poly_expr;
    }
    auto all_variables = tf_polynomial_variables(expanded, indeterminates, original_var);
    if (all_variables.empty()) {
        auto c = extract_coeff_value<Rational>(expanded);
        if (!c) {
            if (c.error().code == CasErrc::UnsupportedExpression) return result;
            return Result<TfPolyBuildResult>::failure(c.error());
        }
        result.poly = Polynomial<Rational>({std::move(c.value())}, "x");
        result.main_variable = "x";
        result.success = true;
        return result;
    }
 
    if (!tf_validate_polynomial(expanded, all_variables)) {
        return result;
    }
    int max_degree = -1;
    tf_select_main_variable(result, expanded, all_variables, max_degree);
    if (result.main_variable.empty() || max_degree < 0) return result;
    return tf_convert_main_variable(std::move(result), expanded, all_variables);
}
catch (const CasError& error) { return Result<TfPolyBuildResult>::failure(error); } catch (const std::bad_alloc&) {
    return Result<TfPolyBuildResult>::failure(CasErrc::ResourceLimit,
        "allocation failed while constructing polynomial", "tf_build_polynomial");
} catch (const std::length_error& error) { return Result<TfPolyBuildResult>::failure(CasErrc::ResourceLimit, error.what(), "tf_build_polynomial"); } catch (const std::exception& ex) {
    return Result<TfPolyBuildResult>::failure(CasErrc::InternalInvariant,
        ex.what(), "tf_build_polynomial");
}

引用了 c, context, LMCAS::detail::expand_node(), extract_coeff_value(), LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::TfPolyBuildResult::main_variable, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::TfPolyBuildResult::poly, LMCAS::TfPolyBuildResult::success, tf_build_polynomial_impl(), tf_convert_main_variable(), tf_polynomial_variables(), tf_select_main_variable(), tf_validate_polynomial() , 以及 UnsupportedExpression.

被这些函数引用 tf_build_polynomial(), tf_build_polynomial_impl() , 以及 tf_factor_substitution().

函数调用图:

这是这个函数的调用关系图:

tf_collect_transcendental()

void LMCAS::tf_collect_transcendental ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var, std::vector< std::shared_ptr< const SymbolicNode > > & candidates )

static

按先序收集依赖 var 的超越函数子表达式。

嵌套函数按外层优先收集，如 sin(exp(x)) 先于 exp(x)。

参数

[in]	node	当前 AST 节点
[in]	var	目标变量名
[out]	candidates	收集到的超越子表达式列表

在文件 transcendental_substitution.cpp 第 39 行定义.

                                                              {
 
    if (!node) return;
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (func->arguments().size() == 1 &&
            tf_is_transcendental_type(func->type()) &&
            expression_depends_on_variable(func->arguments()[0], var)) {
            candidates.push_back(node);
        }
        for (auto& arg : func->arguments()) {
            tf_collect_transcendental(arg, var, candidates);
        }
        return;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        for (auto& op : add->operands()) {
            tf_collect_transcendental(op, var, candidates);
        }
        return;
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (auto& op : mul->operands()) {
            tf_collect_transcendental(op, var, candidates);
        }
        return;
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        tf_collect_transcendental(pow->base(), var, candidates);
        tf_collect_transcendental(pow->exponent(), var, candidates);
        return;
    }
 
}

引用了 add(), expression_depends_on_variable(), mul(), op, pow(), tf_collect_transcendental() , 以及 tf_is_transcendental_type().

被这些函数引用 detect_trans_substitutions() , 以及 tf_collect_transcendental().

函数调用图:

这是这个函数的调用关系图:

tf_contains_transcendental()

bool LMCAS::tf_contains_transcendental	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable )

在文件 transcendental_rewrite.cpp 第 492 行定义.

                          {
 
    if (!node) {
        return false;
    }
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        if (func->arguments().size() == 1 &&
            tf_is_transcendental_type(func->type()) &&
            expression_depends_on_variable(func->arguments()[0], var)) {
            return true;
        }
        return any_transcendental(func->arguments(), var);
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return any_transcendental(add->operands(), var);
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return any_transcendental(mul->operands(), var);
    }
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return tf_contains_transcendental(pow->base(), var) ||
               tf_contains_transcendental(pow->exponent(), var);
    }
 
    return false;
}

引用了 add(), any_transcendental(), expression_depends_on_variable(), mul(), pow(), tf_contains_transcendental() , 以及 tf_is_transcendental_type().

被这些函数引用 any_transcendental(), factor_transcendental() , 以及 tf_contains_transcendental().

函数调用图:

这是这个函数的调用关系图:

tf_convert_main_variable()

Result< TfPolyBuildResult > LMCAS::tf_convert_main_variable ( TfPolyBuildResult result, const std::shared_ptr< SymbolicExpr > & expanded, const std::vector< std::string > & all_variables )

static

在文件 transcendental_polynomial.cpp 第 133 行定义.

                                               {
    const auto main_var = result.main_variable;
    auto converted = symbolic_to_poly<Rational>(expanded, main_var);
    if (converted) {
        result.poly = std::move(converted.value());
        result.success = true;
        return result;
    }
    if (converted.error().code != CasErrc::UnsupportedExpression) {
        return Result<TfPolyBuildResult>::failure(converted.error());
    }
    for (const auto& var : all_variables) {
        if (var == main_var) continue;
        auto trial = symbolic_to_poly<Rational>(expanded, var);
        if (!trial) {
            if (trial.error().code == CasErrc::UnsupportedExpression) continue;
            return Result<TfPolyBuildResult>::failure(trial.error());
        }
        result.main_variable = var;
        result.poly = std::move(trial.value());
        result.param_variables.clear();
        for (const auto& other : all_variables) {
            if (other != var) result.param_variables.push_back(other);
        }
        result.success = true;
        return result;
    }
    result.success = false;
    return result;
}

引用了 LMCAS::Result< T >::failure(), main_var, LMCAS::TfPolyBuildResult::main_variable, LMCAS::TfPolyBuildResult::param_variables, LMCAS::TfPolyBuildResult::poly, LMCAS::TfPolyBuildResult::success, tf_convert_main_variable() , 以及 UnsupportedExpression.

被这些函数引用 tf_build_polynomial_impl() , 以及 tf_convert_main_variable().

函数调用图:

这是这个函数的调用关系图:

tf_deduplicate()

void LMCAS::tf_deduplicate ( std::vector< std::shared_ptr< const SymbolicNode > > & candidates )

static

按结构哈希和 equals 比较去重，保留首次出现的顺序。

参数

[in,out]

candidates

候选列表,去重后仅保留唯一项

在文件 transcendental_substitution.cpp 第 86 行定义.

                                                                                     {
    NodeSet seen;
    std::vector<std::shared_ptr<const SymbolicNode>> unique;
 
    for (auto& node : candidates) {
        if (seen.find(node) == seen.end()) {
            seen.insert(node);
            unique.push_back(node);
        }
    }
 
    candidates = std::move(unique);
}

引用了 tf_deduplicate().

被这些函数引用 detect_trans_substitutions() , 以及 tf_deduplicate().

函数调用图:

这是这个函数的调用关系图:

tf_degree_in()

int LMCAS::tf_degree_in	(	const std::shared_ptr< const SymbolicNode > &	node,
		const std::string &	variable )

在文件 transcendental_polynomial.cpp 第 40 行定义.

                                                                                      {
    if (!node) return 0;
 
    if (!expression_depends_on_variable(node, var)) return 0;
 
    if (auto v = std::dynamic_pointer_cast<const VariableNode>(node)) {
        return (!v->is_constant() && v->name() == var) ? 1 : 0;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        int max_deg = 0;
        for (const auto& op : add->operands()) {
            int d = tf_degree_in(op, var);
            if (d < 0) return -1;
            max_deg = std::max(max_deg, d);
        }
        return max_deg;
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        int total_deg = 0;
        for (const auto& op : mul->operands()) {
            int d = tf_degree_in(op, var);
            if (d < 0) return -1;
            if (d > std::numeric_limits<int>::max() - total_deg) return -1;
            total_deg += d;
        }
        return total_deg;
    }
 
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return tf_power_degree(*power, var);
    }
    if (std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return -1;
    }
 
    return 0;
}

引用了 add(), expression_depends_on_variable(), mul(), op, tf_degree_in(), tf_power_degree() , 以及 v.

被这些函数引用 tf_degree_in(), tf_is_linear_irreducible(), tf_power_degree(), tf_select_main_variable() , 以及 tf_validate_polynomial().

函数调用图:

这是这个函数的调用关系图:

tf_detect_constraints()

void LMCAS::tf_detect_constraints ( TransSubstitutionResult & result )

static

在文件 transcendental_substitution.cpp 第 239 行定义.

                                                                   {
    const auto& mappings = result.mappings;
    for (size_t i = 0; i < mappings.size(); ++i) {
        auto first = std::dynamic_pointer_cast<const FunctionNode>(
            detail::node(mappings[i].trans_expr));
        if (!first || first->arguments().size() != 1) continue;
        for (size_t j = i + 1; j < mappings.size(); ++j) {
            auto second = std::dynamic_pointer_cast<const FunctionNode>(
                detail::node(mappings[j].trans_expr));
            if (!second || second->arguments().size() != 1) continue;
            auto constraint = tf_pair_constraint(mappings[i], mappings[j], *first, *second);
            if (constraint) result.constraints.push_back(std::move(constraint));
        }
    }
}

引用了 LMCAS::TransSubstitutionResult::constraints, LMCAS::TransSubstitutionResult::mappings, LMCAS::detail::node(), tf_detect_constraints() , 以及 tf_pair_constraint().

被这些函数引用 detect_trans_substitutions() , 以及 tf_detect_constraints().

函数调用图:

这是这个函数的调用关系图:

tf_detect_exponential_separation()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::tf_detect_exponential_separation	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context )

检测加法表达式中的公共指数因子并执行分离.

对于 AddNode 形式的表达式,检查所有加法项是否共享相同的 exp(f(x)) 因子. 若是,则提取公因子:expr = exp(f(x)) * (t1' + t2' + ... + tn'), 其中 ti' = ti / exp(f(x)).

典型用例:

• exp(x)*x + exp(x) -> [exp(x), x+1]
• exp(x)*x^2 + 2*exp(x)*x + exp(x) -> [exp(x), x^2+2x+1]

参数

[in]	expr	待检测的符号表达式
[in]	var	目标变量名

返回

因子列表 [exp(f(x)), remaining_sum];若无公共 exp 因子则返回空向量

从第一个加法项中提取 exp 因子作为候选公因子

验证所有加法项均含有相同的 exp 因子

所有项共享相同的 exp(f(x)),执行分离 构造剩余和:对每个项移除 exp 因子

构造结果

化简剩余和

在文件 transcendental_rewrite.cpp 第 409 行定义.

                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (!expr || !LMCAS::detail::node(expr)) {
        return {};
    }
 
    auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(expr));
    if (!add || add->operands().size() < 2) {
        return {};
    }
 
    /// 从第一个加法项中提取 exp 因子作为候选公因子
    std::shared_ptr<const SymbolicNode> common_exp = tf_extract_exp_factor(add->operands()[0], var);
    if (!common_exp) {
        return {};
    }
 
    /// 验证所有加法项均含有相同的 exp 因子
    for (size_t i = 1; i < add->operands().size(); ++i) {
        std::shared_ptr<const SymbolicNode> term_exp = tf_extract_exp_factor(add->operands()[i], var);
        if (!term_exp || !term_exp->equals(*common_exp)) {
            return {};
        }
    }
 
    /// 所有项共享相同的 exp(f(x)),执行分离
    /// 构造剩余和:对每个项移除 exp 因子
    std::vector<std::shared_ptr<const SymbolicNode>> remainder_terms;
    remainder_terms.reserve(add->operands().size());
 
    for (const auto& op : add->operands()) {
        auto remainder = tf_remove_exp_factor(op, common_exp);
        remainder_terms.push_back(remainder);
    }
 
    /// 构造结果
    auto exp_factor_expr = LMCAS::detail::make_expression_ptr(common_exp);
 
    std::shared_ptr<SymbolicExpr> sum_expr;
    if (remainder_terms.size() == 1) {
        sum_expr = LMCAS::detail::make_expression_ptr(remainder_terms[0]);
    } else {
        sum_expr = LMCAS::detail::make_expression_ptr(
            LMCAS::detail::make_node<AddNode>(std::move(remainder_terms)));
    }
 
    /// 化简剩余和
    auto simplified_sum = detail::make_expression_ptr(detail::normalize_node(detail::node(sum_expr), transform_budget));
    if (simplified_sum && LMCAS::detail::node(simplified_sum)) {
        sum_expr = simplified_sum;
    }
 
    return {exp_factor_expr, sum_expr};
}

引用了 add(), context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), op, tf_detect_exponential_separation(), tf_extract_exp_factor() , 以及 tf_remove_exp_factor().

被这些函数引用 factor_transcendental() , 以及 tf_detect_exponential_separation().

函数调用图:

这是这个函数的调用关系图:

tf_detect_multiplicative_structure()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::tf_detect_multiplicative_structure

(

const std::shared_ptr< SymbolicExpr > &

expr

)

检测表达式是否已为独立子表达式的乘积形式.

MultiplyNode 的各操作数直接形成独立因子,沿乘法结构完成分解; 数值常数单独累积,并在值异于 1 时形成常数因子.

参数

[in]

expr

待检测的符号表达式

返回

因子列表;若表达式非乘积形式则返回空向量(表示无快速路径)

数值常数单独累积

浮点数值:作为独立因子保留

非数值操作数作为独立因子

仅当存在至少两个非常数因子(或一个非常数因子加一个非 1 常数)时才视为有效乘积分解

插入累积常数因子(若非 1)

在文件 transcendental_rewrite.cpp 第 236 行定义.

                                             {
 
    if (!expr || !LMCAS::detail::node(expr)) {
        return {};
    }
 
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(expr));
    if (!mul || mul->operands().size() < 2) {
        return {};
    }
 
    std::vector<std::shared_ptr<SymbolicExpr>> factors;
    Rational constant_acc(1);
 
    for (const auto& op : mul->operands()) {
        if (!op) {
            continue;
        }
 
        /// 数值常数单独累积
        if (op->is_number()) {
            auto num = std::dynamic_pointer_cast<const NumberNode>(op);
            if (num) {
                if (std::holds_alternative<BigInt>(num->value())) {
                    constant_acc = constant_acc * Rational(std::get<BigInt>(num->value()));
                } else if (std::holds_alternative<Rational>(num->value())) {
                    constant_acc = constant_acc * std::get<Rational>(num->value());
                } else {
                    /// 浮点数值:作为独立因子保留
                    factors.push_back(LMCAS::detail::make_expression_ptr(op));
                }
            }
            continue;
        }
 
        /// 非数值操作数作为独立因子
        factors.push_back(LMCAS::detail::make_expression_ptr(op));
    }
 
    /// 仅当存在至少两个非常数因子(或一个非常数因子加一个非 1 常数)时才视为有效乘积分解
    if (factors.size() < 2 && (factors.empty() || constant_acc == Rational(1))) {
        return {};
    }
 
    /// 插入累积常数因子(若非 1)
    if (constant_acc != Rational(1)) {
        auto const_expr = SymbolicExpr::number(constant_acc);
        factors.insert(factors.begin(), const_expr);
    }
 
    return factors;
}

引用了 LMCAS::detail::make_expression_ptr(), mul(), LMCAS::detail::node(), LMCAS::polynomial_solver_detail::num(), op , 以及 tf_detect_multiplicative_structure().

被这些函数引用 factor_transcendental() , 以及 tf_detect_multiplicative_structure().

函数调用图:

这是这个函数的调用关系图:

tf_extract_coeff_trig_squared()

bool LMCAS::tf_extract_coeff_trig_squared ( const std::shared_ptr< const SymbolicNode > & node, std::shared_ptr< const SymbolicNode > & coeff, FunctionNode::FuncType & func_type, std::shared_ptr< const SymbolicNode > & argument )

static

从 a*sin^2(f) 或 a*cos^2(f) 提取系数和三角平方项。

注解

单独的三角平方项系数为 1。

参数

[in]	node	待分析的加法操作数节点
[out]	coeff	输出系数节点(nullptr 表示系数为 1)
[out]	func_type	输出函数类型(Sin 或 Cos)
[out]	argument	输出函数参数节点

返回

匹配成功返回 true

< 表示系数为 1。

在文件 transcendental_pythagorean.cpp 第 65 行定义.

                                                 {
 
    if (tf_is_trig_squared(node, func_type, argument)) {
        coeff = nullptr;  /**< 表示系数为 1。 */
        return true;
    }
 
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!mul || mul->operands().size() < 2) {
        return false;
    }
 
    for (size_t i = 0; i < mul->operands().size(); ++i) {
        if (tf_is_trig_squared(mul->operands()[i], func_type, argument)) {
            std::vector<std::shared_ptr<const SymbolicNode>> coeff_ops;
            for (size_t j = 0; j < mul->operands().size(); ++j) {
                if (j != i) {
                    coeff_ops.push_back(mul->operands()[j]);
                }
            }
 
            if (coeff_ops.size() == 1) {
                coeff = coeff_ops[0];
            } else {
                coeff = LMCAS::detail::make_node<MultiplyNode>(std::move(coeff_ops));
            }
            return true;
        }
    }
 
    return false;
}

引用了 LMCAS::detail::make_node(), mul(), tf_extract_coeff_trig_squared() , 以及 tf_is_trig_squared().

被这些函数引用 complementary_square(), simplify_pythagorean_sum() , 以及 tf_extract_coeff_trig_squared().

函数调用图:

这是这个函数的调用关系图:

tf_extract_exp_factor()

std::shared_ptr< const SymbolicNode > LMCAS::tf_extract_exp_factor ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var )

static

从乘积项中提取指数函数因子.

若节点本身为 exp(f(x)) 形式,直接返回该节点. 若节点为 MultiplyNode,遍历其操作数寻找 exp(f(x)) 因子. 仅提取第一个匹配的指数函数因子.

参数

[in]	node	待检测的 AST 节点
[in]	var	目标变量名

返回

找到的 exp 因子节点;未找到返回 nullptr

直接为 exp(f(x)) 形式

乘积形式:遍历操作数寻找 exp 因子

在文件 transcendental_rewrite.cpp 第 315 行定义.

                          {
 
    if (!node) {
        return nullptr;
    }
 
    /// 直接为 exp(f(x)) 形式
    if (tf_is_variable_exponential(node, var)) {
        return node;
    }
 
    /// 乘积形式:遍历操作数寻找 exp 因子
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        for (const auto& op : mul->operands()) {
            if (tf_is_variable_exponential(op, var)) {
                return op;
            }
        }
    }
 
    return nullptr;
}

引用了 mul(), op, tf_extract_exp_factor() , 以及 tf_is_variable_exponential().

被这些函数引用 tf_detect_exponential_separation() , 以及 tf_extract_exp_factor().

函数调用图:

这是这个函数的调用关系图:

tf_factor_substitution()

Result< std::vector< std::shared_ptr< SymbolicExpr > > > LMCAS::tf_factor_substitution ( const TransSubstitutionResult & sub_result, const std::string & var, const std::shared_ptr< SymbolicExpr > & pyth_simplified, ComputationContext & context )

static

在文件 transcendental_factor.cpp 第 54 行定义.

                                 {
    using FactorsResult = Result<std::vector<std::shared_ptr<SymbolicExpr>>>;
    std::vector<std::string> indeterminates;
    indeterminates.reserve(sub_result.mappings.size());
    for (const auto& m : sub_result.mappings) {
        indeterminates.push_back(m.indeterminate);
    }
    auto built = tf_build_polynomial_impl(
        sub_result.poly_expr, indeterminates, var, context);
    if (!built) { return FactorsResult::failure(built.error()); }
    const auto& poly_result = built.value();
    if (!poly_result.success) {
        return FactorsResult::success({pyth_simplified});
    }
    if (poly_result.poly.degree() <= 1) {
        return FactorsResult::success({pyth_simplified});
    }
    auto factored =
        factor_univariate_bridge_checked(poly_result.poly, context);
    if (!factored) {
        return FactorsResult::failure(factored.error());
    }
    const auto& factorization = factored.value();
    if (factorization.completeness != Completeness::Complete ||
        factorization.value.size() <= 1) {
        return FactorsResult::success({pyth_simplified});
    }
    return tf_restore_factors(
        factorization.value, sub_result, pyth_simplified, context);
}

引用了 Complete, context, factor_univariate_bridge_checked(), LMCAS::TransSubstitutionResult::mappings, LMCAS::TransSubstitutionResult::poly_expr, tf_build_polynomial_impl(), tf_factor_substitution() , 以及 tf_restore_factors().

被这些函数引用 factor_transcendental() , 以及 tf_factor_substitution().

函数调用图:

这是这个函数的调用关系图:

tf_is_linear_irreducible()

bool LMCAS::tf_is_linear_irreducible	(	const TransSubstitutionResult &	sub_result,
		const std::string &	var )

判断换元后的表达式是否对所有不定元和原始变量均为线性.

换元表达式对每个不定元(u0, u1, ...)及原始变量的次数均小于等于 1 时, 该表达式在超越多项式环中为整体元素. 例如 a*sin(x) + b*x + c 映射为 a*u0 + b*x + c,对 u0 与 x 均为线性.

参数

[in]	sub_result	换元结果(含 poly_expr 和 mappings)
[in]	var	原始目标变量名

返回

表达式对所有变量均为线性返回 true

检查每个不定元的次数是否 <= 1

检查原始变量的次数是否 <= 1

在文件 transcendental_rewrite.cpp 第 194 行定义.

                          {
 
    if (!sub_result.poly_expr || !LMCAS::detail::node(sub_result.poly_expr)) {
        return false;
    }
    if (sub_result.mappings.empty()) {
        return false;
    }
 
    const auto& root = LMCAS::detail::node(sub_result.poly_expr);
 
    /// 检查每个不定元的次数是否 <= 1
    for (const auto& m : sub_result.mappings) {
        int deg = tf_degree_in(root, m.indeterminate);
        if (deg < 0 || deg > 1) {
            return false;
        }
    }
 
    /// 检查原始变量的次数是否 <= 1
    if (expression_depends_on_variable(root, var)) {
        int deg = tf_degree_in(root, var);
        if (deg < 0 || deg > 1) {
            return false;
        }
    }
 
    return true;
}

引用了 expression_depends_on_variable(), LMCAS::TransSubstitutionResult::mappings, LMCAS::detail::node(), LMCAS::TransSubstitutionResult::poly_expr, tf_degree_in() , 以及 tf_is_linear_irreducible().

被这些函数引用 factor_transcendental() , 以及 tf_is_linear_irreducible().

函数调用图:

这是这个函数的调用关系图:

tf_is_negation_of()

bool LMCAS::tf_is_negation_of ( const std::shared_ptr< const SymbolicNode > & node, const std::shared_ptr< const SymbolicNode > & arg )

static

匹配 (-1)*arg 或 arg*(-1) 的二因子乘积结构。

参数

[in]	node	待检测节点
[in]	arg	参考参数节点

返回

若 node 表示 -arg 则返回 true

在文件 transcendental_substitution.cpp 第 121 行定义.

                                                                            {
    if (!node || !arg) {
        return false;
    }
 
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node);
    if (!mul || mul->operands().size() != 2) {
        return false;
    }
 
    for (int i = 0; i < 2; ++i) {
        auto num_node = std::dynamic_pointer_cast<const NumberNode>(mul->operands()[i]);
        if (!num_node) {
            continue;
        }
 
        if (num_node->is_negative_one()) {
            int other_idx = 1 - i;
            return tf_nodes_equal(mul->operands()[other_idx], arg);
        }
    }
 
    return false;
}

引用了 mul(), tf_is_negation_of() , 以及 tf_nodes_equal().

被这些函数引用 tf_is_negation_of() , 以及 tf_pair_constraint().

函数调用图:

这是这个函数的调用关系图:

tf_is_sine_cosine_pair()

bool LMCAS::tf_is_sine_cosine_pair ( FunctionNode::FuncType first, FunctionNode::FuncType second )

static

在文件 transcendental_substitution.cpp 第 206 行定义.

                                                                                            {
    if (first == FunctionNode::FuncType::Sin) {
        return second == FunctionNode::FuncType::Cos;
    }
    return first == FunctionNode::FuncType::Cos && second == FunctionNode::FuncType::Sin;
}

引用了 LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Sin , 以及 tf_is_sine_cosine_pair().

被这些函数引用 tf_is_sine_cosine_pair() , 以及 tf_pair_constraint().

函数调用图:

这是这个函数的调用关系图:

tf_is_transcendental_type()

bool LMCAS::tf_is_transcendental_type

(

FunctionNode::FuncType

ft

)

判断函数类型是否支持超越函数换元。

参数

[in]

ft

函数类型枚举

返回

属于 Sin/Cos/Exp/Ln/Tan 之一返回 true

在文件 transcendental_substitution.cpp 第 21 行定义.

                                                        {
    return ft == FunctionNode::FuncType::Sin ||
           ft == FunctionNode::FuncType::Cos ||
           ft == FunctionNode::FuncType::Exp ||
           ft == FunctionNode::FuncType::Ln  ||
           ft == FunctionNode::FuncType::Tan;
}

引用了 LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Exp, LMCAS::FunctionNode::Ln, LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Tan , 以及 tf_is_transcendental_type().

被这些函数引用 tf_collect_transcendental(), tf_contains_transcendental() , 以及 tf_is_transcendental_type().

函数调用图:

这是这个函数的调用关系图:

tf_is_trig_squared()

bool LMCAS::tf_is_trig_squared ( const std::shared_ptr< const SymbolicNode > & node, FunctionNode::FuncType & func_type, std::shared_ptr< const SymbolicNode > & argument )

static

匹配 sin^2(f) 或 cos^2(f)，提取函数类型和参数。

注解

对应 PowerNode(FunctionNode(Sin/Cos, [f]), NumberNode(2))。

参数

[in]	node	待检测的 AST 节点
[out]	func_type	输出函数类型(Sin 或 Cos)
[out]	argument	输出函数参数节点

返回

匹配成功返回 true

在文件 transcendental_pythagorean.cpp 第 17 行定义.

                                                 {
 
    auto pow = std::dynamic_pointer_cast<const PowerNode>(node);
    if (!pow) {
        return false;
    }
 
    auto exp_num = std::dynamic_pointer_cast<const NumberNode>(pow->exponent());
    if (!exp_num) {
        return false;
    }
 
    const bool is_two = std::holds_alternative<BigInt>(exp_num->value())
        ? std::get<BigInt>(exp_num->value()) == BigInt(2)
        : std::get<Rational>(exp_num->value()) == Rational(2);
    if (!is_two) {
        return false;
    }
 
    auto func = std::dynamic_pointer_cast<const FunctionNode>(pow->base());
    if (!func || func->arguments().size() != 1) {
        return false;
    }
 
    if (func->type() != FunctionNode::FuncType::Sin &&
        func->type() != FunctionNode::FuncType::Cos) {
        return false;
    }
 
    func_type = func->type();
    argument = func->arguments()[0];
    return true;
}

引用了 LMCAS::FunctionNode::Cos, pow(), LMCAS::FunctionNode::Sin , 以及 tf_is_trig_squared().

被这些函数引用 tf_extract_coeff_trig_squared() , 以及 tf_is_trig_squared().

函数调用图:

这是这个函数的调用关系图:

tf_is_variable_exponential()

bool LMCAS::tf_is_variable_exponential ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var )

static

在文件 transcendental_rewrite.cpp 第 290 行定义.

                                                                         {
    auto function = std::dynamic_pointer_cast<const FunctionNode>(node);
    if (!function) {
        return false;
    }
    if (function->type() != FunctionNode::FuncType::Exp ||
        function->arguments().size() != 1) {
        return false;
    }
    return expression_depends_on_variable(function->arguments()[0], var);
}

引用了 LMCAS::FunctionNode::Exp, expression_depends_on_variable(), function() , 以及 tf_is_variable_exponential().

被这些函数引用 tf_extract_exp_factor() , 以及 tf_is_variable_exponential().

函数调用图:

这是这个函数的调用关系图:

tf_nodes_equal()

bool LMCAS::tf_nodes_equal ( const std::shared_ptr< const SymbolicNode > & a, const std::shared_ptr< const SymbolicNode > & b )

static

判断两个 AST 节点是否结构相等。

参数

[in]	a	第一个节点
[in]	b	第二个节点

返回

结构相等返回 true

在文件 transcendental_substitution.cpp 第 107 行定义.

                                                                       {
    if (!a || !b) return a == b;
    return a->equals(*b);
}

引用了 a, b , 以及 tf_nodes_equal().

被这些函数引用 tf_is_negation_of(), tf_nodes_equal() , 以及 tf_pair_constraint().

函数调用图:

这是这个函数的调用关系图:

tf_pair_constraint()

std::shared_ptr< SymbolicExpr > LMCAS::tf_pair_constraint ( const TransSubstitution & left, const TransSubstitution & right, const FunctionNode & first, const FunctionNode & second )

static

在文件 transcendental_substitution.cpp 第 213 行定义.

                                                           {
    const auto first_type = first.type();
    const auto second_type = second.type();
    const bool sin_cos = tf_is_sine_cosine_pair(first_type, second_type);
    if (sin_cos && tf_nodes_equal(first.arguments()[0], second.arguments()[0])) {
        auto ui = SymbolicExpr::variable(left.indeterminate);
        auto uj = SymbolicExpr::variable(right.indeterminate);
        auto two = SymbolicExpr::number(2);
        auto sum = SymbolicExpr::add(SymbolicExpr::power(ui, two), SymbolicExpr::power(uj, two));
        return SymbolicExpr::add(sum, SymbolicExpr::number(-1));
    }
    if (first_type != FunctionNode::FuncType::Exp ||
        second_type != FunctionNode::FuncType::Exp) {
        return nullptr;
    }
    if (!tf_is_negation_of(second.arguments()[0], first.arguments()[0]) &&
        !tf_is_negation_of(first.arguments()[0], second.arguments()[0])) {
        return nullptr;
    }
    auto ui = SymbolicExpr::variable(left.indeterminate);
    auto uj = SymbolicExpr::variable(right.indeterminate);
    return SymbolicExpr::add(SymbolicExpr::multiply(ui, uj), SymbolicExpr::number(-1));
}

引用了 LMCAS::FunctionNode::arguments(), LMCAS::FunctionNode::Exp, LMCAS::TransSubstitution::indeterminate, right, tf_is_negation_of(), tf_is_sine_cosine_pair(), tf_nodes_equal(), tf_pair_constraint() , 以及 LMCAS::FunctionNode::type().

被这些函数引用 tf_detect_constraints() , 以及 tf_pair_constraint().

函数调用图:

这是这个函数的调用关系图:

tf_polynomial_variables()

std::vector< std::string > LMCAS::tf_polynomial_variables ( const std::shared_ptr< SymbolicExpr > & expression, const std::vector< std::string > & indeterminates, const std::string & original_var )

static

在文件 transcendental_polynomial.cpp 第 103 行定义.

                                                                               {
    std::vector<std::string> variables;
    for (const auto& variable : indeterminates) {
        if (expression_depends_on_variable(detail::node(expression), variable)) {
            variables.push_back(variable);
        }
    }
    if (expression_depends_on_variable(detail::node(expression), original_var)) {
        variables.push_back(original_var);
    }
    return variables;
}

引用了 expression_depends_on_variable(), LMCAS::detail::node(), tf_polynomial_variables() , 以及 variable.

被这些函数引用 tf_build_polynomial_impl() , 以及 tf_polynomial_variables().

函数调用图:

这是这个函数的调用关系图:

tf_power_degree()

int LMCAS::tf_power_degree ( const PowerNode & power, const std::string & var )

static

在文件 transcendental_polynomial.cpp 第 17 行定义.

                                                                         {
    auto exp_num = std::dynamic_pointer_cast<const NumberNode>(power.exponent());
    if (!exp_num) return -1;
 
    BigInt exponent(-1);
    if (std::holds_alternative<BigInt>(exp_num->value())) {
        exponent = std::get<BigInt>(exp_num->value());
    } else {
        const auto& r = std::get<Rational>(exp_num->value());
        if (r.is_integer()) exponent = r.to_bigint();
    }
 
    if (exponent.is_negative() || exponent > BigInt(std::numeric_limits<int>::max())) {
        return -1;
    }
    const int e_val = static_cast<int>(exponent.try_to_int64().value());
 
    int base_deg = tf_degree_in(power.base(), var);
    if (base_deg < 0 ||
        (e_val != 0 && base_deg > std::numeric_limits<int>::max() / e_val)) return -1;
    return base_deg * e_val;
}

引用了 LMCAS::PowerNode::base(), exponent, LMCAS::PowerNode::exponent(), r, tf_degree_in(), tf_power_degree() , 以及 value.

被这些函数引用 tf_degree_in() , 以及 tf_power_degree().

函数调用图:

这是这个函数的调用关系图:

tf_remove_exp_factor()

std::shared_ptr< const SymbolicNode > LMCAS::tf_remove_exp_factor ( const std::shared_ptr< const SymbolicNode > & node, const std::shared_ptr< const SymbolicNode > & exp_factor )

static

从乘积项中移除指定的指数函数因子,返回剩余部分.

若节点本身即为该 exp 因子,返回数值 1. 若节点为 MultiplyNode,移除匹配的 exp 操作数后重建乘积.

参数

[in]	node	原始乘积项节点
[in]	exp_factor	待移除的 exp 因子节点

返回

移除 exp 因子后的剩余节点

节点本身即为 exp 因子

乘积形式:移除匹配的操作数

在文件 transcendental_rewrite.cpp 第 351 行定义.

                                                         {
 
    if (!node || !exp_factor) {
        return node;
    }
 
    /// 节点本身即为 exp 因子
    if (node->equals(*exp_factor)) {
        return LMCAS::detail::make_node<NumberNode>(BigInt(1));
    }
 
    /// 乘积形式:移除匹配的操作数
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> remaining_ops;
        bool removed = false;
 
        for (const auto& op : mul->operands()) {
            if (!removed && op->equals(*exp_factor)) {
                removed = true;
                continue;
            }
            remaining_ops.push_back(op);
        }
 
        if (!removed) {
            return node;
        }
 
        if (remaining_ops.empty()) {
            return LMCAS::detail::make_node<NumberNode>(BigInt(1));
        }
        if (remaining_ops.size() == 1) {
            return remaining_ops[0];
        }
        return LMCAS::detail::make_node<MultiplyNode>(std::move(remaining_ops));
    }
 
    return node;
}

引用了 LMCAS::SymbolicNode::equals(), LMCAS::detail::make_node(), mul(), op , 以及 tf_remove_exp_factor().

被这些函数引用 tf_detect_exponential_separation() , 以及 tf_remove_exp_factor().

函数调用图:

这是这个函数的调用关系图:

tf_restore_factors()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::tf_restore_factors ( const std::vector< Polynomial< Rational > > & true_factors, const TransSubstitutionResult & sub_result, const std::shared_ptr< SymbolicExpr > & pyth_simplified, ComputationContext & context )

static

— Phase 6: 逆换元 —

将多项式因子转回符号表达式

逆换元:将不定元替换回原始超越表达式

若逆换元后因子数 <= 1,分解无效

— Phase 6.2: 化简与常数提取 —

若化简后仅剩一个非常数因子,分解无效

在文件 transcendental_factor.cpp 第 14 行定义.

                                                                                     {
    /// --- Phase 6: 逆换元 ---
    std::vector<std::shared_ptr<SymbolicExpr>> symbolic_factors;
    symbolic_factors.reserve(true_factors.size());
 
    for (const auto& poly_factor : true_factors) {
        /// 将多项式因子转回符号表达式
        auto sym_factor = poly_to_symbolic(poly_factor);
        if (!sym_factor) continue;
 
        /// 逆换元:将不定元替换回原始超越表达式
        auto back_sub = tf_back_substitute(sym_factor, sub_result.mappings, context);
        if (back_sub) {
            symbolic_factors.push_back(back_sub);
        }
    }
 
    /// 若逆换元后因子数 <= 1,分解无效
    if (symbolic_factors.size() <= 1) {
        return {pyth_simplified};
    }
 
    /// --- Phase 6.2: 化简与常数提取 ---
    auto final_factors = tf_simplify_factors_impl(symbolic_factors, context);
 
    /// 若化简后仅剩一个非常数因子,分解无效
    size_t non_const_count = 0;
    for (const auto& f : final_factors) {
        if (f && !f->is_number()) non_const_count++;
    }
    if (non_const_count <= 1 && final_factors.size() <= 1) {
        return {pyth_simplified};
    }
 
    return final_factors;
}

引用了 context, LMCAS::TransSubstitutionResult::mappings, tf_back_substitute(), tf_restore_factors() , 以及 tf_simplify_factors_impl().

被这些函数引用 tf_factor_substitution() , 以及 tf_restore_factors().

函数调用图:

这是这个函数的调用关系图:

tf_select_main_variable()

void LMCAS::tf_select_main_variable ( TfPolyBuildResult & result, const std::shared_ptr< SymbolicExpr > & expanded, const std::vector< std::string > & variables, int & max_degree )

static

在文件 transcendental_polynomial.cpp 第 118 行定义.

                                                            {
    for (const auto& variable : variables) {
        const int degree = tf_degree_in(detail::node(expanded), variable);
        if (degree > max_degree) {
            max_degree = degree;
            result.main_variable = variable;
        }
    }
    for (const auto& variable : variables) {
        if (variable != result.main_variable) result.param_variables.push_back(variable);
    }
}

引用了 LMCAS::TfPolyBuildResult::main_variable, LMCAS::detail::node(), LMCAS::TfPolyBuildResult::param_variables, tf_degree_in(), tf_select_main_variable() , 以及 variable.

被这些函数引用 tf_build_polynomial_impl() , 以及 tf_select_main_variable().

函数调用图:

这是这个函数的调用关系图:

tf_simplify_factors()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::tf_simplify_factors

(

std::vector< std::shared_ptr< SymbolicExpr > > &

factors

)

化简逆换元后的因子，合并数值因子及乘积的数值前导系数。 保留非常数部分，将非 1 的常数积置于结果首位。

参数

[in,out]

factors

就地化简的因子列表

返回

化简并提取常数后的因子列表

在文件 transcendental_rewrite.cpp 第 167 行定义.

                                                     {
    ComputationContext context;
    return tf_simplify_factors_impl(factors, context);
}

引用了 context, tf_simplify_factors() , 以及 tf_simplify_factors_impl().

被这些函数引用 tf_simplify_factors().

函数调用图:

这是这个函数的调用关系图:

tf_simplify_factors_impl()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::tf_simplify_factors_impl	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	factors,
		ComputationContext &	context )

在文件 transcendental_rewrite.cpp 第 173 行定义.

                                                                                        {
    detail::RewriteBudget budget(context, context.limits().max_recursion_depth,
                                 context.limits().max_ast_nodes, "factor_transcendental");
    FactorSimplification simplification;
    return simplification.run(factors, budget);
}

引用了 context , 以及 tf_simplify_factors_impl().

被这些函数引用 tf_restore_factors(), tf_simplify_factors() , 以及 tf_simplify_factors_impl().

函数调用图:

这是这个函数的调用关系图:

tf_simplify_pythagorean()

std::shared_ptr< SymbolicExpr > LMCAS::tf_simplify_pythagorean	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var )

在因式分解前用 sin^2(f) + cos^2(f) = 1 化简表达式。

参数

[in]	expr	待化简的符号表达式
[in]	var	目标变量名

返回

化简后的表达式;若无可化简模式则返回原表达式

在文件 transcendental_pythagorean.cpp 第 238 行定义.

                          {
 
    if (!expr || !LMCAS::detail::node(expr)) {
        return expr;
    }
 
    auto simplified_root = tf_simplify_pythagorean_node(LMCAS::detail::node(expr), var);
 
    if (!simplified_root) {
        return expr;
    }
    if (simplified_root->equals(*LMCAS::detail::node(expr))) {
        return expr;
    }
 
    return LMCAS::detail::make_expression_ptr(simplified_root);
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), tf_simplify_pythagorean() , 以及 tf_simplify_pythagorean_node().

被这些函数引用 factor_transcendental() , 以及 tf_simplify_pythagorean().

函数调用图:

这是这个函数的调用关系图:

tf_simplify_pythagorean_node()

std::shared_ptr< const SymbolicNode > LMCAS::tf_simplify_pythagorean_node ( const std::shared_ptr< const SymbolicNode > & node, const std::string & var )

static

递归化简 a*sin^2(f) + a*cos^2(f) 为 a，系数为 1 时结果为 1。

注解

在加法节点中配对，要求参数 f 与系数 a 分别结构相等。

参数

[in]	node	当前 AST 节点
[in]	var	目标变量名(用于限定化简范围)

返回

化简后的节点;若无可化简的模式则返回原节点

在文件 transcendental_pythagorean.cpp 第 191 行定义.

                          {
 
    if (!node) {
        return node;
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return simplify_pythagorean_sum(*add, var);
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
        new_ops.reserve(mul->operands().size());
        for (const auto& op : mul->operands()) {
            new_ops.push_back(tf_simplify_pythagorean_node(op, var));
        }
        return LMCAS::detail::make_node<MultiplyNode>(std::move(new_ops));
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto new_base = tf_simplify_pythagorean_node(pow->base(), var);
        auto new_exp = tf_simplify_pythagorean_node(pow->exponent(), var);
        return LMCAS::detail::make_node<PowerNode>(std::move(new_base), std::move(new_exp));
    }
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_args;
        new_args.reserve(func->arguments().size());
        for (const auto& arg : func->arguments()) {
            new_args.push_back(tf_simplify_pythagorean_node(arg, var));
        }
        return LMCAS::detail::make_node<FunctionNode>(func->type(), std::move(new_args));
    }
 
    return node;
}

引用了 add(), LMCAS::detail::make_node(), mul(), op, pow(), simplify_pythagorean_sum() , 以及 tf_simplify_pythagorean_node().

被这些函数引用 simplify_pythagorean_sum(), tf_simplify_pythagorean() , 以及 tf_simplify_pythagorean_node().

函数调用图:

这是这个函数的调用关系图:

tf_square_free()

TfSquareFreeResult LMCAS::tf_square_free

(

const Polynomial< Rational > &

poly

)

计算多项式的无平方因子部分，用于 Berlekamp 模分解预处理。

令 f' = derivative(f)、g = gcd(f,f')；g 为常数时 f 已无重因子， 否则取 f/g，并将结果首一化。

参数

[in]

poly

输入的有理系数多项式

返回

无平方因子预处理结果

在文件 rational_square_free.cpp 第 67 行定义.

                                                                    {
    TfSquareFreeResult result;
    if (poly.degree() <= 0) {
        result.square_free = poly;
        result.repeated_factor = Polynomial<Rational>(Rational(1), poly.variable_name);
        result.had_repeated_factors = false;
        return result;
    }
    if (poly.degree() == 1) {
        result.square_free = poly;
        result.repeated_factor = Polynomial<Rational>(Rational(1), poly.variable_name);
        result.had_repeated_factors = false;
        return result;
    }
 
    Polynomial<Rational> deriv = poly.differentiate();
 
    Polynomial<Rational> g = Polynomial<Rational>::gcd(poly, deriv);
 
    if (g.degree() <= 0) {
        result.square_free = poly.make_monic();
        result.repeated_factor = Polynomial<Rational>(Rational(1), poly.variable_name);
        result.had_repeated_factors = false;
        return result;
    }
 
    auto [quotient, remainder] = poly.div_mod(g);
    result.square_free = quotient.make_monic();
    result.repeated_factor = g.make_monic();
    result.had_repeated_factors = true;
    return result;
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::differentiate(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::TfSquareFreeResult::had_repeated_factors, LMCAS::Polynomial< CoeffType >::make_monic(), LMCAS::TfSquareFreeResult::repeated_factor, LMCAS::TfSquareFreeResult::square_free, tf_square_free() , 以及 LMCAS::Polynomial< CoeffType >::variable_name.

被这些函数引用 LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_factor() , 以及 tf_square_free().

函数调用图:

这是这个函数的调用关系图:

tf_substitute_expr()

std::shared_ptr< const SymbolicNode > LMCAS::tf_substitute_expr ( const std::shared_ptr< const SymbolicNode > & node, const std::vector< TransSubstitution > & mappings )

static

按映射顺序将超越子表达式替换为不定元，递归重建未匹配节点。

外层映射优先：sin(exp(x)) 整体替换为 u0，exp(x) 保留在 u0 的定义中。

参数

[in]	node	当前 AST 节点
[in]	mappings	换元映射列表(按分配顺序)

返回

替换后的新节点

在文件 transcendental_substitution.cpp 第 157 行定义.

                                                  {
 
    if (!node) return nullptr;
 
    for (const auto& m : mappings) {
        if (m.trans_expr && LMCAS::detail::node(m.trans_expr) &&
            node->equals(*LMCAS::detail::node(m.trans_expr))) {
            return LMCAS::detail::make_node<VariableNode>(m.indeterminate);
        }
    }
 
    if (auto func = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_args;
        new_args.reserve(func->arguments().size());
        for (const auto& arg : func->arguments()) {
            new_args.push_back(tf_substitute_expr(arg, mappings));
        }
        return LMCAS::detail::make_node<FunctionNode>(func->type(), std::move(new_args));
    }
 
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
        new_ops.reserve(add->operands().size());
        for (const auto& op : add->operands()) {
            new_ops.push_back(tf_substitute_expr(op, mappings));
        }
        return LMCAS::detail::make_node<AddNode>(std::move(new_ops));
    }
 
    if (auto mul = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        std::vector<std::shared_ptr<const SymbolicNode>> new_ops;
        new_ops.reserve(mul->operands().size());
        for (const auto& op : mul->operands()) {
            new_ops.push_back(tf_substitute_expr(op, mappings));
        }
        return LMCAS::detail::make_node<MultiplyNode>(std::move(new_ops));
    }
 
    if (auto pow = std::dynamic_pointer_cast<const PowerNode>(node)) {
        auto new_base = tf_substitute_expr(pow->base(), mappings);
        auto new_exp = tf_substitute_expr(pow->exponent(), mappings);
        return LMCAS::detail::make_node<PowerNode>(std::move(new_base), std::move(new_exp));
    }
 
    return node;
}

引用了 add(), LMCAS::SymbolicNode::equals(), LMCAS::detail::make_node(), mul(), LMCAS::detail::node(), op, pow() , 以及 tf_substitute_expr().

被这些函数引用 detect_trans_substitutions() , 以及 tf_substitute_expr().

函数调用图:

这是这个函数的调用关系图:

tf_validate_polynomial()

bool LMCAS::tf_validate_polynomial ( const std::shared_ptr< SymbolicExpr > & poly_expr, const std::vector< std::string > & all_variables )

static

判断换元式是否为候选变量的多项式。 各候选变量的次数须可确定为非负整数，且超越函数不得依赖不定元或原始变量。

参数

[in]	poly_expr	换元后的表达式。
[in]	all_variables	所有候选变量名，包括不定元和原始变量。

返回

有效多项式返回 true。

在文件 transcendental_polynomial.cpp 第 88 行定义.

                                               {
 
    if (!poly_expr || !LMCAS::detail::node(poly_expr)) return false;
 
    for (const auto& var : all_variables) {
        if (expression_depends_on_variable(LMCAS::detail::node(poly_expr), var)) {
            int deg = tf_degree_in(LMCAS::detail::node(poly_expr), var);
            if (deg < 0) return false;
        }
    }
    return true;
}

引用了 expression_depends_on_variable(), LMCAS::detail::node(), tf_degree_in() , 以及 tf_validate_polynomial().

被这些函数引用 tf_build_polynomial_impl() , 以及 tf_validate_polynomial().

函数调用图:

这是这个函数的调用关系图:

total_degree()

int LMCAS::total_degree ( const Monomial & m )

inline

计算单项式的全次数

参数

m

单项式

返回

各分量指数之和

在文件 monomial_order.hpp 第 30 行定义.

                                           {
    return std::accumulate(m.begin(), m.end(), 0);
}

引用了 total_degree().

被这些函数引用 LMCAS::MonomialOrder::compare_deglex(), LMCAS::MonomialOrder::compare_grevlex(), LMCAS::detail::multipoly_term_factors(), LMCAS::fglm_detail::MonomialEnumerator::next() , 以及 total_degree().

函数调用图:

这是这个函数的调用关系图:

total_differential()

std::vector< std::pair< std::shared_ptr< SymbolicExpr >, std::string > > LMCAS::total_differential	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars )

在文件 calculus_utils.cpp 第 182 行定义.

{
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<std::pair<std::shared_ptr<SymbolicExpr>, std::string>> result;
    if (!f || !LMCAS::detail::node(f)) {
        return result;
    }
 
    result.reserve(vars.size());
    for (const auto& v : vars) {
        auto partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), v, transform_budget));
        result.emplace_back(partial, v);
    }
    return result;
}

引用了 context, LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), total_differential(), v , 以及 vars.

被这些函数引用 total_differential().

函数调用图:

这是这个函数的调用关系图:

truncate_mod_var()

MultiPoly LMCAS::truncate_mod_var ( const MultiPoly & poly, const std::string & var, int degree_bound )

static

将 MultiPoly 截断为关于指定变量次数 < degree_bound 的部分

保留所有项中指定变量指数严格小于 degree_bound 的项.

参数

[in]	poly	输入多项式
[in]	var	变量名
[in]	degree_bound	次数上界(保留 < degree_bound 的项)

返回

截断后的多项式

若变量不在列表中,多项式不含该变量,无需截断

在文件 multivariate_hensel.cpp 第 354 行定义.

{
    if (poly.is_zero()) { return poly; }
 
    const auto& vars = poly.variables();
    int var_idx = -1;
    for (size_t i = 0; i < vars.size(); ++i) {
        if (vars[i] == var) { var_idx = static_cast<int>(i); break; }
    }
    /// 若变量不在列表中,多项式不含该变量,无需截断
    if (var_idx < 0) { return poly; }
 
    std::vector<MultiPoly::Term> result_terms;
    for (const auto& term : poly.terms()) {
        const Monomial& mono = term.first;
        int exp = (static_cast<size_t>(var_idx) < mono.size()) ? mono[var_idx] : 0;
        if (exp < degree_bound) {
            result_terms.push_back(term);
        }
    }
 
    if (result_terms.empty()) { return MultiPoly(Rational(0), vars); }
    return MultiPoly(std::move(result_terms), vars);
}

引用了 exp(), truncate_mod_var() , 以及 vars.

被这些函数引用 apply_hensel_lift_steps(), multivariate_diophantine(), solve_diophantine_pair(), truncate_mod_var() , 以及 truncated_factor_product().

函数调用图:

这是这个函数的调用关系图:

truncated_factor_product()

MultiPoly LMCAS::truncated_factor_product ( const std::vector< MultiPoly > & factors, const std::string & variable, int degree_bound )

static

在文件 multivariate_hensel.cpp 第 170 行定义.

                                                 {
    MultiPoly product = factors[0];
    for (size_t i = 1; i < factors.size(); ++i) {
        product = product * factors[i];
        product = truncate_mod_var(product, variable, degree_bound);
    }
    return product;
}

引用了 truncate_mod_var(), truncated_factor_product() , 以及 variable.

被这些函数引用 apply_hensel_lift_steps() , 以及 truncated_factor_product().

函数调用图:

这是这个函数的调用关系图:

try_eval_double()

double LMCAS::try_eval_double

(

const std::shared_ptr< SymbolicExpr > &

expr

)

尝试将表达式求值为 double。

返回

若表达式为纯数值返回其值，否则返回 NaN。

在文件 ode_support.cpp 第 24 行定义.

                                                                {
    if (!expr || !LMCAS::detail::node(expr)) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    if (expr->is_number()) {
        auto node = std::dynamic_pointer_cast<const NumberNode>(LMCAS::detail::node(expr));
        if (!node) {
            return std::numeric_limits<double>::quiet_NaN();
        }
        if (std::holds_alternative<BigInt>(node->value())) {
            return std::get<BigInt>(node->value()).to_double();
        }
        return std::get<Rational>(node->value()).to_double();
    }
    return std::numeric_limits<double>::quiet_NaN();
}

引用了 LMCAS::detail::node() , 以及 try_eval_double().

被这些函数引用 classify_higher_order_ode(), classify_singular_point_checked(), frobenius_coefficient_limit(), is_euler_equation(), ordinary_taylor_coefficients(), separable_reciprocal(), singular_frobenius_solution(), singular_taylor_coefficients(), try_eval_double() , 以及 validate_frobenius_regular_singular_domain().

函数调用图:

这是这个函数的调用关系图:

try_get_integer_value()

bool LMCAS::try_get_integer_value	(	const std::shared_ptr< const NumberNode > &	node,
		BigInt &	value )

在文件 normalization_utils.cpp 第 39 行定义.

                                                                {
    if (!node) {
        return false;
    }
    if (const auto* integer = std::get_if<BigInt>(&node->value())) {
        value = *integer;
        return true;
    }
    const auto& rational = std::get<Rational>(node->value());
    if (rational.get_denominator() != BigInt(1)) {
        return false;
    }
    value = rational.get_numerator();
    return true;
}

引用了 integer, rational(), try_get_integer_value() , 以及 value.

被这些函数引用 LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_power(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::degree_in_var(), get_node_degree_helper(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::integer_power(), LMCAS::detail::series_support::integer_value_from_node(), LMCAS::anonymous_namespace{integration_linearity.cpp}::integration_exponential_argument(), LMCAS::NormalizationVisitor::is_positive_integer_number(), normalization_numeric_power(), LMCAS::NormalizationVisitor::normalize_nested_imaginary_power(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::number_equals_integer(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::power(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::power_bounds(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::power_candidate(), LMCAS::anonymous_namespace{limit_result.cpp}::power_continuous_structure(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::product_exp_multiplier(), LMCAS::anonymous_namespace{symbolic_ode.cpp}::reciprocal_on_regular_region(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::InferenceEngine::Impl::small_positive_exponent(), solve_product_factor(), symbolic_power_to_poly(), symbolic_product(), symbolic_sum(), symbolic_to_poly_recursive(), te_inv_power(), te_is_power_of_var(), try_get_integer_value(), LMCAS::ExpandVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit() , 以及 zt_polynomial_pattern().

函数调用图:

这是这个函数的调用关系图:

univariate_gcd()

MultiPoly LMCAS::univariate_gcd ( const MultiPoly & a, const MultiPoly & b, const std::vector< std::string > & vars )

static

在文件 multivariate_factor.cpp 第 230 行定义.

                                                                   {
    std::string a_var = active_univariate_variable(a);
    std::string b_var = active_univariate_variable(b);
    if (a_var.empty() && b_var.empty()) {
        return MultiPoly(rational_gcd(a.numeric_content(), b.numeric_content()), vars);
    }
    if (a_var.empty() || b_var.empty()) {
        return MultiPoly(rational_gcd(a.numeric_content(), b.numeric_content()), vars);
    }
    if (a_var == b_var) {
        Rational nc_gcd = rational_gcd(a.numeric_content(), b.numeric_content());
        Polynomial<Rational> pa = a.to_univariate();
        Polynomial<Rational> pb = b.to_univariate();
        Polynomial<Rational> g = Polynomial<Rational>::gcd(pa, pb);
        if (g.is_zero()) { return MultiPoly(nc_gcd, vars); }
        MultiPoly result = MultiPoly::from_univariate(g, a_var);
        result = result * nc_gcd;
        if (vars.size() > 1) {
            result = embed_univariate_gcd(result, a_var, vars);
        }
        if (!result.terms().empty() && result.terms()[0].second < Rational(0)) { result = result * Rational(-1); }
        return result;
    }
    return MultiPoly(rational_gcd(a.numeric_content(), b.numeric_content()), vars);
}

引用了 a, active_univariate_variable(), b, embed_univariate_gcd(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::Polynomial< CoeffType >::is_zero(), rational_gcd(), univariate_gcd() , 以及 vars.

被这些函数引用 multivariate_gcd() , 以及 univariate_gcd().

函数调用图:

这是这个函数的调用关系图:

unsupported_euler_forcing()

bool LMCAS::unsupported_euler_forcing ( const std::shared_ptr< SymbolicExpr > & forcing, const std::vector< double > & coefficients )

static

在文件 ode_linear.cpp 第 363 行定义.

                                           {
    return !forcing->is_number() || coefficients.back() == 0.0;
}

引用了 unsupported_euler_forcing().

被这些函数引用 solve_euler_ode_checked() , 以及 unsupported_euler_forcing().

函数调用图:

这是这个函数的调用关系图:

valid_classifier_variables()

bool LMCAS::valid_classifier_variables ( const std::string & x, const std::string & y )

static

在文件 ode_classification.cpp 第 26 行定义.

{
    return !x.empty() && !y.empty() && x != y;
}

引用了 valid_classifier_variables().

被这些函数引用 is_bernoulli_ode(), is_exact_ode(), is_homogeneous_ode(), is_linear_first_order(), is_separable() , 以及 valid_classifier_variables().

函数调用图:

这是这个函数的调用关系图:

valid_newton_bracket()

bool LMCAS::valid_newton_bracket ( lmmc_real_t initial, lmmc_real_t lower, lmmc_real_t upper )

static

在文件 newton_raphson.cpp 第 360 行定义.

                                                               {
    if (!std::isfinite(initial) || !std::isfinite(lower) ||
        !std::isfinite(upper)) {
        return false;
    }
    return lower <= upper && initial >= lower && initial <= upper;
}

引用了 lower, upper , 以及 valid_newton_bracket().

被这些函数引用 newton_raphson_checked() , 以及 valid_newton_bracket().

函数调用图:

这是这个函数的调用关系图:

validate_frobenius_regular_singular_domain()

Result< void > LMCAS::validate_frobenius_regular_singular_domain ( const std::shared_ptr< SymbolicExpr > & p, const std::shared_ptr< SymbolicExpr > & q, const std::shared_ptr< SymbolicExpr > & x0, const std::string & x, ComputationContext & context, const std::string & operation )

static

在文件 ode_frobenius.cpp 第 474 行定义.

    {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto x_var = SymbolicExpr::variable(x);
    auto x_minus_x0 = SymbolicExpr::add(x_var,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), x0));
    auto xp_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(x_minus_x0, p)), transform_budget));
    auto x2q_expr = detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
        SymbolicExpr::power(x_minus_x0, SymbolicExpr::number(2)), q)), transform_budget));
 
    auto P0_result = limit_expression_checked(
        xp_expr, x, x0, LimitDirection::Both, context);
    if (!P0_result) {
        return Result<void>::failure(P0_result.error());
    }
    auto Q0_result = limit_expression_checked(
        x2q_expr, x, x0, LimitDirection::Both, context);
    if (!Q0_result) {
        return Result<void>::failure(Q0_result.error());
    }
    const auto& P0_expr = P0_result.value();
    const auto& Q0_expr = Q0_result.value();
    double P0 = P0_expr
        ? try_eval_double(P0_expr)
        : std::numeric_limits<double>::quiet_NaN();
    double Q0 = Q0_expr
        ? try_eval_double(Q0_expr)
        : std::numeric_limits<double>::quiet_NaN();
    if (!std::isfinite(P0) || !std::isfinite(Q0)) {
        return Result<void>::failure(
            CasErrc::Inconclusive,
            "Frobenius regular-singular coefficients are outside the checked numeric support domain",
            operation);
    }
 
    double discriminant = (P0 - 1.0) * (P0 - 1.0) - 4.0 * Q0;
    int zero_discriminant;
    lmmc_double_nearly_equal_tol(discriminant, 0.0, 1e-12, 1e-12,
                                 &zero_discriminant);
    if (discriminant < 0.0 && !zero_discriminant) {
        return Result<void>::failure(
            CasErrc::Inconclusive,
            "Frobenius checked API currently supports real indicial roots only",
            operation);
    }
 
    return Result<void>::success();
} catch (const CasError& error) {
    return Result<void>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<void>::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return Result<void>::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return Result<void>::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 Both, context, e(), LMCAS::Result< T >::failure(), Inconclusive, limit_expression_checked(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< T >::success(), try_eval_double() , 以及 validate_frobenius_regular_singular_domain().

被这些函数引用 solve_frobenius_checked() , 以及 validate_frobenius_regular_singular_domain().

函数调用图:

这是这个函数的调用关系图:

validate_integration_steps()

bool LMCAS::validate_integration_steps ( const std::vector< IntegrationStep > & steps )

static

在文件 multiple_integral.cpp 第 7 行定义.

                                                                                {
    if (steps.empty()) return false;
 
    for (size_t i = 0; i < steps.size(); ++i) {
        const auto& s = steps[i];
        if (s.variable.empty()) return false;
 
        // Bounds must be either both null (indefinite) or both set (definite).
        const bool has_lower = static_cast<bool>(s.lower);
        const bool has_upper = static_cast<bool>(s.upper);
        if (has_lower != has_upper) return false;
 
        // Reject duplicate variables.
        for (size_t j = 0; j < i; ++j) {
            if (steps[j].variable == s.variable) return false;
        }
    }
    return true;
}

引用了 steps, validate_integration_steps() , 以及 variable.

被这些函数引用 integrate_multiple_checked() , 以及 validate_integration_steps().

函数调用图:

这是这个函数的调用关系图:

validate_laurent_orders()

Result< void > LMCAS::validate_laurent_orders	(	int	order_neg,
		int	order_pos,
		const std::string &	operation )

在文件 series_expansions.cpp 第 73 行定义.

{
    if (order_neg < 0 || order_pos < 0 || order_neg > 64 || order_pos > 64) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "Laurent truncation orders must be between 0 and 64",
                                     operation);
    }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::Result< T >::success() , 以及 validate_laurent_orders().

被这些函数引用 laurent_series_full_checked() , 以及 validate_laurent_orders().

函数调用图:

这是这个函数的调用关系图:

validate_laurent_result()

Result< void > LMCAS::validate_laurent_result ( const LaurentResult & result, const std::optional< int > & supported_power, const std::shared_ptr< SymbolicExpr > & center, const std::string & operation )

static

在文件 series_expansions.cpp 第 383 行定义.

                                                                           {
        if (!result.series || !LMCAS::detail::node(result.series)) {
            return Result<void>::failure(
                CasErrc::Inconclusive,
                "Laurent series could not be constructed in the supported domain",
                operation);
        }
        if (!result.residue || !LMCAS::detail::node(result.residue)) {
            return Result<void>::failure(
                CasErrc::InternalInvariant,
                "Laurent series produced a null residue expression",
                operation);
        }
        if (supported_power && center->is_zero()) {
            BigInt expected_pole_order =
                *supported_power < 0 ? -BigInt(*supported_power) : BigInt(0);
            if (BigInt(result.pole_order) != expected_pole_order) {
                return Result<void>::failure(
                    CasErrc::Inconclusive,
                    "Laurent pole order could not be verified",
                    operation);
            }
        }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::node(), LMCAS::LaurentResult::pole_order, LMCAS::LaurentResult::residue, LMCAS::LaurentResult::series, LMCAS::Result< T >::success() , 以及 validate_laurent_result().

被这些函数引用 laurent_series_full_checked() , 以及 validate_laurent_result().

函数调用图:

这是这个函数的调用关系图:

validate_numeric_ode_coefficients()

Result< void > LMCAS::validate_numeric_ode_coefficients	(	const std::vector< double > &	coefficients,
		std::size_t	minimum_size,
		std::size_t	maximum_size,
		const std::string &	operation )

在文件 ode_support.cpp 第 142 行定义.

{
    if (coeffs.size() < min_size || coeffs.size() > max_size) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE coefficient list has unsupported size",
                                     operation);
    }
    if (!std::isfinite(coeffs.front()) || coeffs.front() == 0.0) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE leading coefficient must be finite and nonzero",
                                     operation);
    }
    for (double coeff : coeffs) {
        if (!std::isfinite(coeff)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "ODE coefficients must be finite",
                                         operation);
        }
    }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::Result< T >::success() , 以及 validate_numeric_ode_coefficients().

被这些函数引用 solve_euler_ode_checked(), solve_higher_order_ode_checked() , 以及 validate_numeric_ode_coefficients().

函数调用图:

这是这个函数的调用关系图:

validate_ode_expr_var_pair()

Result< void > LMCAS::validate_ode_expr_var_pair	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context,
		const std::string &	operation )

在文件 ode_support.cpp 第 41 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (!expr || !LMCAS::detail::node(expr)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE expression cannot be null",
                                     operation);
    }
    if (x.empty() || y.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE variable names cannot be empty",
                                     operation);
    }
    if (x == y) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE independent and dependent variables must be distinct",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 validate_ode_expr_var_pair().

被这些函数引用 solve_homogeneous_ode_checked() , 以及 validate_ode_expr_var_pair().

函数调用图:

这是这个函数的调用关系图:

validate_ode_pair_var_pair()

Result< void > LMCAS::validate_ode_pair_var_pair	(	const std::shared_ptr< SymbolicExpr > &	first,
		const std::shared_ptr< SymbolicExpr > &	second,
		const std::string &	x,
		const std::string &	y,
		ComputationContext &	context,
		const std::string &	operation )

在文件 ode_support.cpp 第 70 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (!first || !LMCAS::detail::node(first) || !second || !LMCAS::detail::node(second)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE expressions cannot be null",
                                     operation);
    }
    if (x.empty() || y.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE variable names cannot be empty",
                                     operation);
    }
    if (x == y) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE independent and dependent variables must be distinct",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 validate_ode_pair_var_pair().

被这些函数引用 solve_bernoulli_ode_checked(), solve_exact_ode_checked() , 以及 validate_ode_pair_var_pair().

函数调用图:

这是这个函数的调用关系图:

validate_ode_three_expr_one_var()

Result< void > LMCAS::validate_ode_three_expr_one_var	(	const std::shared_ptr< SymbolicExpr > &	first,
		const std::shared_ptr< SymbolicExpr > &	second,
		const std::shared_ptr< SymbolicExpr > &	third,
		const std::string &	x,
		ComputationContext &	context,
		const std::string &	operation )

在文件 ode_support.cpp 第 168 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (!first || !LMCAS::detail::node(first) || !second || !LMCAS::detail::node(second) ||
        !third || !LMCAS::detail::node(third)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE expressions cannot be null",
                                     operation);
    }
    if (x.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE variable name cannot be empty",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 validate_ode_three_expr_one_var().

被这些函数引用 solve_variation_of_parameters_checked() , 以及 validate_ode_three_expr_one_var().

函数调用图:

这是这个函数的调用关系图:

validate_ode_two_expr_point()

Result< void > LMCAS::validate_ode_two_expr_point	(	const std::shared_ptr< SymbolicExpr > &	p,
		const std::shared_ptr< SymbolicExpr > &	q,
		const std::shared_ptr< SymbolicExpr > &	x0,
		const std::string &	x,
		ComputationContext &	context,
		const std::string &	operation )

在文件 ode_support.cpp 第 194 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (!p || !LMCAS::detail::node(p) || !q || !LMCAS::detail::node(q) || !x0 || !LMCAS::detail::node(x0)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "Frobenius inputs cannot be null",
                                     operation);
    }
    if (x.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE variable name cannot be empty",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 validate_ode_two_expr_point().

被这些函数引用 classify_singular_point_checked(), solve_frobenius_checked() , 以及 validate_ode_two_expr_point().

函数调用图:

这是这个函数的调用关系图:

validate_ode_variables()

Result< void > LMCAS::validate_ode_variables	(	const std::string &	x,
		const std::string &	y,
		ComputationContext &	context,
		const std::string &	operation )

在文件 ode_support.cpp 第 119 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (x.empty() || y.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE variable names cannot be empty",
                                     operation);
    }
    if (x == y) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "ODE independent and dependent variables must be distinct",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::Result< T >::success() , 以及 validate_ode_variables().

被这些函数引用 solve_euler_ode_checked(), solve_higher_order_ode_checked() , 以及 validate_ode_variables().

函数调用图:

这是这个函数的调用关系图:

validate_power_series_coefficients() [1/2]

Result< void > LMCAS::detail::series_support::validate_power_series_coefficients	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coefficients,
		const std::string &	operation,
		const std::string &	name )

在文件 series_engine.cpp 第 145 行定义.

{
    for (size_t i = 0; i < coeffs.size(); ++i) {
        if (!coeffs[i] || !LMCAS::detail::node(coeffs[i])) {
            return Result<void>::failure(
                CasErrc::InvalidArgument,
                name + " contains a null coefficient at index " + std::to_string(i),
                operation);
        }
    }
    return Result<void>::success();
}

被这些函数引用 convergence_radius_checked(), power_series_compose_checked() , 以及 power_series_multiply_checked().

这是这个函数的调用关系图:

validate_power_series_coefficients() [2/2]

Result< void > LMCAS::detail::series_support::validate_power_series_coefficients	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	coefficients,
		const std::string &	operation,
		const std::string &	name )

在文件 series_engine.cpp 第 145 行定义.

{
    for (size_t i = 0; i < coeffs.size(); ++i) {
        if (!coeffs[i] || !LMCAS::detail::node(coeffs[i])) {
            return Result<void>::failure(
                CasErrc::InvalidArgument,
                name + " contains a null coefficient at index " + std::to_string(i),
                operation);
        }
    }
    return Result<void>::success();
}

validate_property_interval()

PropertyStoreResult LMCAS::validate_property_interval	(	const Interval &	interval,
		ComputationContext &	context,
		const std::string &	operation )

在文件 property_intervals.cpp 第 9 行定义.

                                                                           {
    auto normalized = normalize_intervals_checked({interval}, context);
    if (!normalized) {
        return PropertyStoreResult::failure(
            normalized.error().code, normalized.error().message, operation);
    }
    if (normalized.value().empty()) {
        return PropertyStoreResult::failure(
            CasErrc::InvalidArgument,
            "property declaration interval must not be empty",
            operation);
    }
    return PropertyStoreResult::success();
}

引用了 context, LMCAS::Result< void >::failure(), interval(), InvalidArgument, normalize_intervals_checked(), LMCAS::Result< void >::success() , 以及 validate_property_interval().

被这些函数引用 validate_property_interval().

函数调用图:

这是这个函数的调用关系图:

validate_series_expr_point()

Result< void > LMCAS::validate_series_expr_point	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::shared_ptr< SymbolicExpr > &	center,
		const std::string &	var,
		ComputationContext &	context,
		const std::string &	operation )

在文件 series_expansions.cpp 第 53 行定义.

{
    auto var_check = validate_series_variable(var, context, operation);
    if (!var_check) {
        return var_check;
    }
    if (!expr || !LMCAS::detail::node(expr) || !center || !LMCAS::detail::node(center)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "series expression and center cannot be null",
                                     operation);
    }
    return Result<void>::success();
}

引用了 context, LMCAS::Result< T >::failure(), InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success(), validate_series_expr_point() , 以及 validate_series_variable().

被这些函数引用 laurent_series_full_checked() , 以及 validate_series_expr_point().

函数调用图:

这是这个函数的调用关系图:

validate_series_variable() [1/2]

Result< void > LMCAS::detail::series_support::validate_series_variable	(	const std::string &	variable,
		ComputationContext &	context,
		const std::string &	operation )

在文件 series_engine.cpp 第 53 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (var.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "series variable name cannot be empty",
                                     operation);
    }
    return Result<void>::success();
}

被这些函数引用 convergence_radius_checked(), convergence_test_checked() , 以及 validate_series_expr_point().

这是这个函数的调用关系图:

validate_series_variable() [2/2]

Result< void > LMCAS::detail::series_support::validate_series_variable	(	const std::string &	variable,
		ComputationContext &	context,
		const std::string &	operation )

在文件 series_engine.cpp 第 53 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (var.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "series variable name cannot be empty",
                                     operation);
    }
    return Result<void>::success();
}

vector_angle_checked() [1/2]

VectorAngleResult LMCAS::vector_angle_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b )

在文件 symbolic_geometry_vector.cpp 第 218 行定义.

  {
    ComputationContext context;
    return vector_angle_checked(a, b, context);
}

引用了 a, b, context , 以及 vector_angle_checked().

函数调用图:

vector_angle_checked() [2/2]

VectorAngleResult LMCAS::vector_angle_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b,
		ComputationContext &	context )

在文件 symbolic_geometry_vector.cpp 第 155 行定义.

  {
    const std::string operation = "vector_angle";
    auto input = validate_same_dimension_vectors(a, b, context, operation);
    if (!input) return VectorAngleResult::failure(input.error());
    double scale_a = 0.0;
    double scale_b = 0.0;
    double norm_a_scaled = 0.0;
    double norm_b_scaled = 0.0;
    double dot_scaled = 0.0;
    double dot_correction = 0.0;
    for (size_t i = 0; i < a.size(); ++i) {
        auto step = context.consume_steps(1, operation);
        if (!step) return VectorAngleResult::failure(step.error());
        auto na_result = symbolic_vector_finite_numeric(a[i], context, operation);
        if (!na_result) return VectorAngleResult::failure(na_result.error());
        auto nb_result = symbolic_vector_finite_numeric(b[i], context, operation);
        if (!nb_result) return VectorAngleResult::failure(nb_result.error());
        const double na = na_result.value();
        const double nb = nb_result.value();
        const double abs_a = std::abs(na);
        const double abs_b = std::abs(nb);
 
        rescale_angle_component(
            abs_a, scale_a, norm_a_scaled, dot_scaled, dot_correction);
        rescale_angle_component(
            abs_b, scale_b, norm_b_scaled, dot_scaled, dot_correction);
        if (scale_a != 0.0) {
            const double normalized = na / scale_a;
            norm_a_scaled += normalized * normalized;
        }
        if (scale_b != 0.0) {
            const double normalized = nb / scale_b;
            norm_b_scaled += normalized * normalized;
        }
        if (scale_a != 0.0 && scale_b != 0.0) {
            accumulate_angle_product(
                na / scale_a, nb / scale_b, dot_scaled, dot_correction);
        }
    }
    if (scale_a == 0.0 || scale_b == 0.0) {
        return VectorAngleResult::failure(
            CasErrc::DomainError,
            "angle is undefined for zero-length vectors",
            operation);
    }
    const double denominator =
        std::sqrt(norm_a_scaled) * std::sqrt(norm_b_scaled);
    double cosv = dot_scaled / denominator;
    if (!std::isfinite(cosv)) {
        return VectorAngleResult::failure(
            CasErrc::NumericFailure,
            "vector angle normalization produced a non-finite result",
            operation);
    }
    if (cosv > 1.0) cosv = 1.0;
    else if (cosv < -1.0) cosv = -1.0;
    return VectorAngleResult::success(std::acos(cosv));
}

引用了 a, b, context, denominator, DomainError, LMCAS::Result< double >::failure(), NumericFailure, LMCAS::Result< double >::success(), LMCAS::geometry_detail::validate_same_dimension_vectors() , 以及 vector_angle_checked().

被这些函数引用 dihedral_angle_checked(), vector_angle_checked() , 以及 vector_angle_checked().

函数调用图:

这是这个函数的调用关系图:

vector_angle_symbolic()

VectorCalculusExprResult LMCAS::vector_angle_symbolic	(	const VectorField &	a,
		const VectorField &	b )

在文件 vector_calculus_algebra.cpp 第 201 行定义.

                                                                                               {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "vector_angle_symbolic");
    return vector_angle_symbolic_impl(a, b, transform_budget);
} catch (const CasError& error) {
    return VectorCalculusExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit,
        "vector calculus allocation failed", "vector_angle_symbolic");
} catch (const std::length_error& error) {
    return VectorCalculusExprResult::failure(CasErrc::ResourceLimit, error.what(), "vector_angle_symbolic");
} catch (const std::exception& error) {
    return VectorCalculusExprResult::failure(CasErrc::InternalInvariant, error.what(), "vector_angle_symbolic");
}

引用了 a, b, context, vector_angle_symbolic() , 以及 vector_angle_symbolic_impl().

被这些函数引用 vector_angle_symbolic().

函数调用图:

这是这个函数的调用关系图:

vector_angle_symbolic_impl()

VectorCalculusExprResult LMCAS::vector_angle_symbolic_impl ( const VectorField & a, const VectorField & b, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_algebra.cpp 第 98 行定义.

{
    auto aa_result = dot_product_impl(a, a, transform_budget);
    if (!aa_result) {
        return aa_result;
    }
    auto bb_result = dot_product_impl(b, b, transform_budget);
    if (!bb_result) {
        return bb_result;
    }
    auto aa = aa_result.value();
    auto bb = bb_result.value();
    if ((LMCAS::detail::node(aa) && LMCAS::detail::node(aa)->is_zero()) ||
        (LMCAS::detail::node(bb) && LMCAS::detail::node(bb)->is_zero())) {
        return VectorCalculusExprResult::success(nullptr);
    }
    auto ab_result = dot_product_impl(a, b, transform_budget);
    if (!ab_result) {
        return ab_result;
    }
    auto denom = SymbolicExpr::multiply(SymbolicExpr::sqrt(aa), SymbolicExpr::sqrt(bb));
    auto cos_theta = SymbolicExpr::divide(ab_result.value(), denom);
    auto arccos_node = LMCAS::detail::make_node<FunctionNode>(
        FunctionNode::FuncType::ArcCos,
        std::vector<std::shared_ptr<const SymbolicNode>>{LMCAS::detail::node(cos_theta)});
    return VectorCalculusExprResult::success(
        detail::make_expression_ptr(detail::normalize_node(detail::node(LMCAS::detail::make_expression_ptr(arccos_node)), transform_budget)));
}

引用了 a, LMCAS::FunctionNode::ArcCos, b, dot_product_impl(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 vector_angle_symbolic_impl().

被这些函数引用 vector_angle_symbolic() , 以及 vector_angle_symbolic_impl().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_classify_critical_point()

CriticalPointClassification LMCAS::vector_calculus_classify_critical_point ( const std::vector< double > & numeric_H, size_t n, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_extrema.cpp 第 166 行定义.

{
    const double tol = 1e-10;
    if (n == 1) {
        const double value = numeric_H[0];
        if (std::abs(value) < tol) {
            return CriticalPointClassification::Degenerate;
        }
        if (value > 0) {
            return CriticalPointClassification::LocalMinimum;
        }
        return CriticalPointClassification::LocalMaximum;
    }
    if (n == 2) {
        return classify_hessian_pair(numeric_H, tol);
    }
    auto matrix = symbolic_hessian(numeric_H, n, tol);
    auto eigenvalues = matrix_eigenvalues_checked(matrix, context);
    if (!eigenvalues) {
        if (eigenvalues.error().code != CasErrc::Inconclusive &&
            eigenvalues.error().code != CasErrc::UnsupportedExpression) {
            throw eigenvalues.error();
        }
        return CriticalPointClassification::Inconclusive;
    }
    return classify_hessian_eigenvalues(eigenvalues.value(), tol, context, transform_budget);
}

引用了 classify_hessian_eigenvalues(), classify_hessian_pair(), context, Degenerate, e(), Inconclusive, LocalMaximum, LocalMinimum, matrix_eigenvalues_checked(), symbolic_hessian(), UnsupportedExpression, value , 以及 vector_calculus_classify_critical_point().

被这些函数引用 find_extrema_impl() , 以及 vector_calculus_classify_critical_point().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_constant_integrand()

VectorCalculusExprResult LMCAS::vector_calculus_constant_integrand ( const std::shared_ptr< SymbolicExpr > & integrand, const std::string & variable, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 486 行定义.

                                           {
    auto candidate = detail::make_expression_ptr(detail::substitute_node(detail::node(integrand), variable, detail::node(SymbolicExpr::number(0)), transform_budget));
    candidate = candidate ? detail::make_expression_ptr(detail::normalize_node(detail::node(candidate), transform_budget)) : nullptr;
    if (!candidate || expression_depends_on_variable(detail::node(candidate), variable)) {
        return VectorCalculusExprResult::success(integrand);
    }
 
    EqvOptions trig_options;
    trig_options.profile = EqvProfile::TrigBasic;
    auto identity = check_equivalent(
        integrand, candidate, context, trig_options);
    if (!identity) {
        return VectorCalculusExprResult::failure(identity.error());
    }
    if (!std::holds_alternative<ProvedZeroResidual>(
            identity.value())) {
        return VectorCalculusExprResult::success(integrand);
    }
    return VectorCalculusExprResult::success(std::move(candidate));
}

引用了 check_equivalent(), context, expression_depends_on_variable(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::EqvOptions::profile, LMCAS::detail::substitute_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), TrigBasic, variable , 以及 vector_calculus_constant_integrand().

被这些函数引用 LMCAS::vector_calculus_detail::greens_theorem_area_strict() , 以及 vector_calculus_constant_integrand().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_cross_product_partials_strict()

Result< VectorField > LMCAS::vector_calculus_cross_product_partials_strict ( const VectorField & parametrization, const std::string & u, const std::string & v, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 242 行定义.

{
    VectorField r_u;
    VectorField r_v;
    r_u.reserve(3);
    r_v.reserve(3);
    for (size_t i = 0; i < 3; ++i) {
        auto du = vector_calculus_differentiate_strict(parametrization[i], u, operation, transform_budget);
        if (!du) return Result<VectorField>::failure(du.error());
        auto dv = vector_calculus_differentiate_strict(parametrization[i], v, operation, transform_budget);
        if (!dv) return Result<VectorField>::failure(dv.error());
        r_u.push_back(std::move(du.value()));
        r_v.push_back(std::move(dv.value()));
    }
 
    VectorField cross;
    cross.reserve(3);
    for (std::size_t index = 0; index < 3; ++index) {
        auto component = vector_calculus_cross_component(
            r_u, r_v, index);
        auto checked = vector_calculus_simplify_strict(component, operation,
        "surface normal construction is outside the supported domain", transform_budget);
        if (!checked) {
            return Result<VectorField>::failure(checked.error());
        }
        cross.push_back(std::move(checked.value()));
    }
    return Result<VectorField>::success(std::move(cross));
}

引用了 LMCAS::Result< T >::failure(), parametrization, LMCAS::Result< T >::success(), u, v, LMCAS::vector_calculus_detail::vector_calculus_cross_component(), vector_calculus_cross_product_partials_strict(), LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_simplify_strict().

被这些函数引用 LMCAS::vector_calculus_detail::stokes_theorem_strict(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), LMCAS::vector_calculus_detail::surface_integral_vector_strict() , 以及 vector_calculus_cross_product_partials_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_curl_strict()

Result< VectorField > LMCAS::vector_calculus_curl_strict ( const VectorField & F, const std::vector< std::string > & vars, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 571 行定义.

{
    auto dFz_dy = vector_calculus_differentiate_strict(F[2], vars[1], operation, transform_budget);
    if (!dFz_dy) {
        return Result<VectorField>::failure(dFz_dy.error());
    }
    auto dFy_dz = vector_calculus_differentiate_strict(F[1], vars[2], operation, transform_budget);
    if (!dFy_dz) {
        return Result<VectorField>::failure(dFy_dz.error());
    }
    auto dFx_dz = vector_calculus_differentiate_strict(F[0], vars[2], operation, transform_budget);
    if (!dFx_dz) {
        return Result<VectorField>::failure(dFx_dz.error());
    }
    auto dFz_dx = vector_calculus_differentiate_strict(F[2], vars[0], operation, transform_budget);
    if (!dFz_dx) {
        return Result<VectorField>::failure(dFz_dx.error());
    }
    auto dFy_dx = vector_calculus_differentiate_strict(F[1], vars[0], operation, transform_budget);
    if (!dFy_dx) {
        return Result<VectorField>::failure(dFy_dx.error());
    }
    auto dFx_dy = vector_calculus_differentiate_strict(F[0], vars[1], operation, transform_budget);
    if (!dFx_dy) {
        return Result<VectorField>::failure(dFx_dy.error());
    }
 
    auto cx = SymbolicExpr::add(
        dFz_dy.value(),
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dFy_dz.value()));
    auto cx_checked = vector_calculus_simplify_strict(cx, operation, "curl construction is outside the supported domain", transform_budget);
    if (!cx_checked) {
        return Result<VectorField>::failure(cx_checked.error());
    }
 
    auto cy = SymbolicExpr::add(
        dFx_dz.value(),
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dFz_dx.value()));
    auto cy_checked = vector_calculus_simplify_strict(cy, operation, "curl construction is outside the supported domain", transform_budget);
    if (!cy_checked) {
        return Result<VectorField>::failure(cy_checked.error());
    }
 
    auto cz = SymbolicExpr::add(
        dFy_dx.value(),
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dFx_dy.value()));
    auto cz_checked = vector_calculus_simplify_strict(cz, operation, "curl construction is outside the supported domain", transform_budget);
    if (!cz_checked) {
        return Result<VectorField>::failure(cz_checked.error());
    }
 
    return Result<VectorField>::success(
        VectorField{std::move(cx_checked.value()),
                    std::move(cy_checked.value()),
                    std::move(cz_checked.value())});
}

引用了 LMCAS::Result< T >::failure(), LMCAS::Result< T >::success(), vars, vector_calculus_curl_strict(), LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_simplify_strict().

被这些函数引用 LMCAS::vector_calculus_detail::stokes_theorem_strict() , 以及 vector_calculus_curl_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_definite_integral_strict()

VectorCalculusExprResult LMCAS::vector_calculus_definite_integral_strict ( const std::shared_ptr< SymbolicExpr > & integrand, const std::string & var, const std::shared_ptr< SymbolicExpr > & a, const std::shared_ptr< SymbolicExpr > & b, ComputationContext & context, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 204 行定义.

{
    auto result = vector_calculus_try_definite(integrand, var, a, b, context, transform_budget);
    if (!result) return result;
    if (!result.value() || !LMCAS::detail::node(result.value())) {
        return vector_calculus_inconclusive(
            operation,
            "integral could not be evaluated exactly in the supported domain");
    }
    return result;
}

引用了 a, b, context, LMCAS::detail::node(), vector_calculus_definite_integral_strict(), vector_calculus_inconclusive() , 以及 vector_calculus_try_definite().

被这些函数引用 LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), LMCAS::vector_calculus_detail::greens_theorem_area_strict() , 以及 vector_calculus_definite_integral_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_evaluate_hessian_at_point()

bool LMCAS::vector_calculus_evaluate_hessian_at_point ( const std::shared_ptr< SymbolicExpr > & H, const std::vector< std::string > & , const std::map< std::string, std::shared_ptr< SymbolicExpr > > & pt, size_t n, std::vector< double > & numeric_H, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

代入临界点坐标

在文件 vector_calculus_extrema.cpp 第 32 行定义.

{
    auto mat_node = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(H));
    if (!mat_node || mat_node->rows() != n || mat_node->cols() != n) {
        return false;
    }
 
    numeric_H.resize(n * n);
    for (size_t i = 0; i < n; ++i) {
        for (size_t j = 0; j < n; ++j) {
            auto elem_node = mat_node->get(i, j);
            if (!elem_node) {
                numeric_H[i * n + j] = 0.0;
                continue;
            }
            auto elem = LMCAS::detail::make_expression_ptr(elem_node);
            /// 代入临界点坐标
            for (const auto& [var_name, val] : pt) {
                elem = detail::make_expression_ptr(detail::substitute_node(detail::node(elem), var_name, detail::node(val), transform_budget));
                if (!elem) {
                    return false;
                }
            }
            elem = detail::make_expression_ptr(detail::normalize_node(detail::node(elem), transform_budget));
            if (!elem) {
                return false;
            }
 
            if (!vector_calculus_checked_finite_numeric(
                    elem, numeric_H[i * n + j], context)) {
                return false;
            }
        }
    }
    return true;
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::substitute_node(), LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric() , 以及 vector_calculus_evaluate_hessian_at_point().

被这些函数引用 find_extrema_impl() , 以及 vector_calculus_evaluate_hessian_at_point().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_inconclusive()

VectorCalculusExprResult LMCAS::vector_calculus_inconclusive ( const std::string & operation, const std::string & message )

static

在文件 vector_calculus_integrals.cpp 第 130 行定义.

{
    return VectorCalculusExprResult::failure(CasErrc::Inconclusive,
                                             message, operation);
}

引用了 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), Inconclusive , 以及 vector_calculus_inconclusive().

被这些函数引用 vector_calculus_definite_integral_strict(), LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict(), vector_calculus_inconclusive(), vector_calculus_multiple_integral_strict(), LMCAS::vector_calculus_detail::vector_calculus_simplify_strict() , 以及 vector_calculus_substitute_coords_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_magnitude_squared()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_magnitude_squared ( const VectorField & v, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_directional.cpp 第 10 行定义.

{
    std::shared_ptr<SymbolicExpr> sum = nullptr;
    for (const auto& comp : v) {
        if (!comp) {
            continue;
        }
        auto sq = SymbolicExpr::power(comp, SymbolicExpr::number(2));
        sq = detail::make_expression_ptr(detail::normalize_node(detail::node(sq), transform_budget));
        if (!sum) {
            sum = sq;
        } else {
            sum = SymbolicExpr::add(sum, sq);
            sum = detail::make_expression_ptr(detail::normalize_node(detail::node(sum), transform_budget));
        }
    }
    if (!sum) {
        return SymbolicExpr::number(0);
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(sum), transform_budget));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), v , 以及 vector_calculus_magnitude_squared().

被这些函数引用 directional_derivative_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl() , 以及 vector_calculus_magnitude_squared().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_multiple_integral_strict()

VectorCalculusExprResult LMCAS::vector_calculus_multiple_integral_strict ( const std::shared_ptr< SymbolicExpr > & integrand, const std::vector< IntegrationStep > & steps, ComputationContext & context, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 223 行定义.

{
    if (!integrand || !LMCAS::detail::node(integrand)) {
        return vector_calculus_inconclusive(
            operation, "integrand construction is outside the supported domain");
    }
    Integrator integrator;
    auto integrated = integrate_multiple_checked(*integrand, steps, integrator, context);
    if (!integrated) return VectorCalculusExprResult::failure(integrated.error());
    auto result = LMCAS::detail::make_expression_ptr(integrated.value());
    return vector_calculus_simplify_strict(result, operation,
    "integral result simplification is outside the supported domain", transform_budget);
}

引用了 context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), integrate_multiple_checked(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), steps, vector_calculus_inconclusive(), vector_calculus_multiple_integral_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_simplify_strict().

被这些函数引用 LMCAS::vector_calculus_detail::divergence_theorem_strict(), LMCAS::vector_calculus_detail::greens_theorem_strict(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), LMCAS::vector_calculus_detail::surface_integral_vector_strict() , 以及 vector_calculus_multiple_integral_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_numerical_definite()

VectorCalculusExprResult LMCAS::vector_calculus_numerical_definite ( const std::shared_ptr< SymbolicExpr > & integrand, const std::string & var, const std::shared_ptr< SymbolicExpr > & a, const std::shared_ptr< SymbolicExpr > & b, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 59 行定义.

{
    double a_val = 0.0;
    double b_val = 0.0;
    if (!vector_calculus_checked_finite_numeric(a, a_val, context) ||
        !vector_calculus_checked_finite_numeric(b, b_val, context)) {
        return std::shared_ptr<SymbolicExpr>{};
    }
 
    int n = 1000;
    double h = (b_val - a_val) / n;
    if (!std::isfinite(h)) return std::shared_ptr<SymbolicExpr>{};
    double sum = 0.0;
 
    for (int i = 0; i <= n; ++i) {
        auto step_result =
            context.consume_steps(1, "vector_calculus.numeric_integral");
        if (!step_result) {
            return VectorCalculusExprResult::failure(step_result.error());
        }
        double xi = a_val + i * h;
        if (!std::isfinite(xi)) return std::shared_ptr<SymbolicExpr>{};
        auto xi_expr = SymbolicExpr::number(xi);
        auto fi = detail::make_expression_ptr(detail::substitute_node(detail::node(integrand), var, detail::node(xi_expr), transform_budget));
        double fi_val = 0.0;
        if (!vector_calculus_checked_finite_numeric(fi, fi_val, context)) {
            return std::shared_ptr<SymbolicExpr>{};
        }
 
        double weight = 1.0;
        if (i == 0 || i == n) {
            weight = 1.0;
        } else if (i % 2 == 1) {
            weight = 4.0;
        } else {
            weight = 2.0;
        }
        sum += weight * fi_val;
        if (!std::isfinite(sum)) return std::shared_ptr<SymbolicExpr>{};
    }
    sum *= h / 3.0;
    if (!std::isfinite(sum)) return std::shared_ptr<SymbolicExpr>{};
 
    return SymbolicExpr::number(sum);
}

引用了 a, b, context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::substitute_node(), LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric() , 以及 vector_calculus_numerical_definite().

被这些函数引用 LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback() , 以及 vector_calculus_numerical_definite().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_single_dir_deriv()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_single_dir_deriv ( const std::shared_ptr< SymbolicExpr > & f, const std::vector< std::string > & vars, const VectorField & unit_dir, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_directional.cpp 第 34 行定义.

{
    std::shared_ptr<SymbolicExpr> sum = nullptr;
    for (size_t i = 0; i < vars.size(); ++i) {
        auto partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), vars[i], transform_budget));
        if (!partial) {
            continue;
        }
        partial = detail::make_expression_ptr(detail::normalize_node(detail::node(partial), transform_budget));
        auto term = SymbolicExpr::multiply(partial, unit_dir[i]);
        term = detail::make_expression_ptr(detail::normalize_node(detail::node(term), transform_budget));
        if (!sum) {
            sum = term;
        } else {
            sum = SymbolicExpr::add(sum, term);
            sum = detail::make_expression_ptr(detail::normalize_node(detail::node(sum), transform_budget));
        }
    }
    if (!sum) {
        return SymbolicExpr::number(0);
    }
    return detail::make_expression_ptr(detail::normalize_node(detail::node(sum), transform_budget));
}

引用了 LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), vars , 以及 vector_calculus_single_dir_deriv().

被这些函数引用 LMCAS::vector_calculus_detail::directional_derivative_impl() , 以及 vector_calculus_single_dir_deriv().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_substitute_coords_strict()

VectorCalculusExprResult LMCAS::vector_calculus_substitute_coords_strict ( const std::shared_ptr< SymbolicExpr > & expr, const std::vector< std::string > & coord_vars, const VectorField & values, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 177 行定义.

{
    if (!expr || !LMCAS::detail::node(expr) || coord_vars.size() != values.size()) {
        return vector_calculus_inconclusive(
            operation, "coordinate substitution is outside the supported domain");
    }
    auto substituted = expr;
    for (size_t i = 0; i < coord_vars.size(); ++i) {
        if (!values[i] || !LMCAS::detail::node(values[i])) {
            return vector_calculus_inconclusive(
                operation, "coordinate substitution is outside the supported domain");
        }
        substituted = detail::make_expression_ptr(detail::substitute_node(detail::node(substituted), coord_vars[i], detail::node(values[i]), transform_budget));
        if (!substituted || !LMCAS::detail::node(substituted)) {
            return vector_calculus_inconclusive(
                operation, "coordinate substitution is outside the supported domain");
        }
    }
    return vector_calculus_simplify_strict(substituted, operation,
    "coordinate substitution is outside the supported domain", transform_budget);
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::substitute_node(), vector_calculus_inconclusive(), LMCAS::vector_calculus_detail::vector_calculus_simplify_strict() , 以及 vector_calculus_substitute_coords_strict().

被这些函数引用 LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), vector_calculus_substitute_coords_strict() , 以及 vector_calculus_surface_dot_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_surface_dot_strict()

VectorCalculusExprResult LMCAS::vector_calculus_surface_dot_strict ( const VectorField & field, const std::vector< std::string > & coordinates, const VectorField & parametrization, const VectorField & normal, const std::string & message, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 402 行定义.

                                           {
    std::shared_ptr<SymbolicExpr> dot_product;
    for (std::size_t i = 0; i < 3; ++i) {
        auto composed = vector_calculus_substitute_coords_strict(field[i], coordinates, parametrization, operation, transform_budget);
        if (!composed) {
            return composed;
        }
        auto term = SymbolicExpr::multiply(
            composed.value(), normal[i]);
        auto term_checked = vector_calculus_simplify_strict(term, operation, message, transform_budget);
        if (!term_checked) {
            return term_checked;
        }
        dot_product = dot_product
            ? SymbolicExpr::add(dot_product, term_checked.value())
            : term_checked.value();
        auto dot_checked = vector_calculus_simplify_strict(dot_product, operation, message, transform_budget);
        if (!dot_checked) {
            return dot_checked;
        }
        dot_product = std::move(dot_checked.value());
    }
    return VectorCalculusExprResult::success(std::move(dot_product));
}

引用了 dot_product(), parametrization, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), LMCAS::Result< T >::value(), LMCAS::vector_calculus_detail::vector_calculus_simplify_strict(), vector_calculus_substitute_coords_strict() , 以及 vector_calculus_surface_dot_strict().

被这些函数引用 LMCAS::vector_calculus_detail::stokes_theorem_strict(), LMCAS::vector_calculus_detail::surface_integral_vector_strict() , 以及 vector_calculus_surface_dot_strict().

函数调用图:

这是这个函数的调用关系图:

vector_calculus_try_definite()

VectorCalculusExprResult LMCAS::vector_calculus_try_definite ( const std::shared_ptr< SymbolicExpr > & integrand, const std::string & var, const std::shared_ptr< SymbolicExpr > & a, const std::shared_ptr< SymbolicExpr > & b, ComputationContext & context, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_integrals.cpp 第 31 行定义.

{
    Integrator integrator;
    auto integrated = integrator.integrate_def_checked(
        *integrand, var, *a, *b, context);
    if (!integrated) {
        return VectorCalculusExprResult::failure(integrated.error());
    }
    SymbolicExpr result = std::move(integrated.value());
 
    if (contains_unevaluated_integral(LMCAS::detail::node(result))) {
        return std::shared_ptr<SymbolicExpr>{};
    }
    auto res = LMCAS::detail::make_expression_ptr(result);
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(res), transform_budget));
    if (simplified &&
        contains_unevaluated_integral(LMCAS::detail::node(simplified))) {
        return std::shared_ptr<SymbolicExpr>{};
    }
    return simplified ? simplified : res;
}

引用了 a, b, contains_unevaluated_integral(), context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), integrator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 vector_calculus_try_definite().

被这些函数引用 vector_calculus_definite_integral_strict(), LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback() , 以及 vector_calculus_try_definite().

函数调用图:

这是这个函数的调用关系图:

vector_cross()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::vector_cross	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b )

在文件 symbolic_geometry_vector.cpp 第 111 行定义.

  {
    auto checked = vector_cross_checked(a, b);
    if (!checked) {
        throw std::invalid_argument("vector_cross: " + checked.error().message);
    }
    return checked.value();
}

引用了 a, b, vector_cross() , 以及 vector_cross_checked().

被这些函数引用 vector_cross().

函数调用图:

这是这个函数的调用关系图:

vector_cross_checked() [1/2]

VectorExprListResult LMCAS::vector_cross_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b )

在文件 symbolic_geometry_vector.cpp 第 146 行定义.

  {
    ComputationContext context;
    return vector_cross_checked(a, b, context);
}

引用了 a, b, context , 以及 vector_cross_checked().

函数调用图:

vector_cross_checked() [2/2]

VectorExprListResult LMCAS::vector_cross_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b,
		ComputationContext &	context )

在文件 symbolic_geometry_vector.cpp 第 122 行定义.

  {
    const std::string operation = "vector_cross";
    auto step = context.consume_steps(1, operation);
    if (!step) return VectorExprListResult::failure(step.error());
    if (a.size() != 3 || b.size() != 3) {
        return VectorExprListResult::failure(
            CasErrc::InvalidArgument,
            "cross product requires 3-dimensional vectors",
            operation);
    }
    auto a_check = validate_symbolic_vector(a, "left vector", operation);
    if (!a_check) return VectorExprListResult::failure(a_check.error());
    auto b_check = validate_symbolic_vector(b, "right vector", operation);
    if (!b_check) return VectorExprListResult::failure(b_check.error());
    auto x = SymbolicExpr::add(SymbolicExpr::multiply(a[1], b[2]), SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::multiply(a[2], b[1])));
    auto y = SymbolicExpr::add(SymbolicExpr::multiply(a[2], b[0]), SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::multiply(a[0], b[2])));
    auto z = SymbolicExpr::add(SymbolicExpr::multiply(a[0], b[1]), SymbolicExpr::multiply(SymbolicExpr::number(-1), SymbolicExpr::multiply(a[1], b[0])));
    return VectorExprListResult::success({x, y, z});
}

引用了 a, b, context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), InvalidArgument, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success(), LMCAS::geometry_detail::validate_symbolic_vector() , 以及 vector_cross_checked().

被这些函数引用 plane_from_three_points_checked(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::skew_distance_from_directions(), vector_cross(), vector_cross_checked() , 以及 vector_cross_checked().

函数调用图:

这是这个函数的调用关系图:

vector_dot()

std::shared_ptr< SymbolicExpr > LMCAS::vector_dot	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b )

在文件 symbolic_geometry_vector.cpp 第 74 行定义.

  {
    auto checked = vector_dot_checked(a, b);
    if (!checked) {
        throw std::invalid_argument("vector_dot: " + checked.error().message);
    }
    return checked.value();
}

引用了 a, b, vector_dot() , 以及 vector_dot_checked().

被这些函数引用 vector_dot().

函数调用图:

这是这个函数的调用关系图:

vector_dot_checked() [1/2]

ExpressionResult LMCAS::vector_dot_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b )

在文件 symbolic_geometry_vector.cpp 第 103 行定义.

  {
    ComputationContext context;
    return vector_dot_checked(a, b, context);
}

引用了 a, b, context , 以及 vector_dot_checked().

函数调用图:

vector_dot_checked() [2/2]

ExpressionResult LMCAS::vector_dot_checked	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	a,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	b,
		ComputationContext &	context )

在文件 symbolic_geometry_vector.cpp 第 85 行定义.

  {
    const std::string operation = "vector_dot";
    auto input = validate_same_dimension_vectors(a, b, context, operation);
    if (!input) return ExpressionResult::failure(input.error());
    std::vector<std::shared_ptr<const SymbolicNode>> sum_terms;
    for (size_t i = 0; i < a.size(); ++i) {
        auto step = context.consume_steps(1, operation);
        if (!step) return ExpressionResult::failure(step.error());
        sum_terms.push_back(LMCAS::detail::node(SymbolicExpr::multiply(a[i], b[i])));
    }
    return ExpressionResult::success(
        LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<AddNode>(sum_terms)));
}

引用了 a, b, context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success(), LMCAS::geometry_detail::validate_same_dimension_vectors() , 以及 vector_dot_checked().

被这些函数引用 LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::assemble_plane(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::check_plane_normal_nonzero(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::skew_distance_from_directions(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_point_plane_distance(), tangent_plane_checked(), vector_dot(), vector_dot_checked() , 以及 vector_dot_checked().

函数调用图:

这是这个函数的调用关系图:

vector_project()

VectorCalculusFieldResult LMCAS::vector_project	(	const VectorField &	a,
		const VectorField &	b )

在文件 vector_calculus_algebra.cpp 第 169 行定义.

                                                                                         {
    ComputationContext context;
    detail::RewriteBudget transform_budget(context, context.limits().max_recursion_depth,
                                          context.limits().max_ast_nodes, "vector_project");
    return vector_project_impl(a, b, transform_budget);
} catch (const CasError& error) {
    return VectorCalculusFieldResult::failure(error);
} catch (const std::bad_alloc&) {
    return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit,
        "vector calculus allocation failed", "vector_project");
} catch (const std::length_error& error) {
    return VectorCalculusFieldResult::failure(CasErrc::ResourceLimit, error.what(), "vector_project");
} catch (const std::exception& error) {
    return VectorCalculusFieldResult::failure(CasErrc::InternalInvariant, error.what(), "vector_project");
}

引用了 a, b, context, vector_project() , 以及 vector_project_impl().

被这些函数引用 vector_project().

函数调用图:

这是这个函数的调用关系图:

vector_project_impl()

VectorCalculusFieldResult LMCAS::vector_project_impl ( const VectorField & a, const VectorField & b, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_algebra.cpp 第 57 行定义.

{
    if (a.size() != b.size()) {
        return VectorCalculusFieldResult::failure(
            CasErrc::DimensionMismatch,
            "vectors must have the same dimension",
            "vector_project");
    }
    auto bb_result = dot_product_impl(b, b, transform_budget);
    if (!bb_result) return VectorCalculusFieldResult::failure(bb_result.error());
    auto bb = bb_result.value();
    if (LMCAS::detail::node(bb) && LMCAS::detail::node(bb)->is_zero()) {
        return VectorCalculusFieldResult::success(
            VectorField(a.size(), SymbolicExpr::number(0)));
    }
    auto ab_result = dot_product_impl(a, b, transform_budget);
    if (!ab_result) return VectorCalculusFieldResult::failure(ab_result.error());
    auto ab = ab_result.value();
    auto coeff = SymbolicExpr::divide(ab, bb);
    VectorField result;
    result.reserve(b.size());
    for (const auto& comp : b) {
        result.push_back(detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(coeff, comp)), transform_budget)));
    }
    return VectorCalculusFieldResult::success(std::move(result));
}

引用了 a, b, DimensionMismatch, dot_product_impl(), LMCAS::Result< VectorField >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< VectorField >::success() , 以及 vector_project_impl().

被这些函数引用 vector_project() , 以及 vector_project_impl().

函数调用图:

这是这个函数的调用关系图:

verified_quadratic_boundaries()

Result< QuadraticBoundaries > LMCAS::verified_quadratic_boundaries ( const Polynomial< Rational > & polynomial, const Rational & rational_part, const Rational & denominator, const Rational & discriminant, detail::RewriteBudget & budget )

static

在文件 inequality_solver_polynomial.cpp 第 131 行定义.

                                 {
    auto& context = budget.context();
    auto sqrt_discriminant = detail::make_expression_ptr(detail::normalize_node(detail::node(
        SymbolicExpr::sqrt(SymbolicExpr::number(discriminant))), budget));
    const Rational first_radical_coefficient = Rational(-1) / denominator;
    const Rational second_radical_coefficient = Rational(1) / denominator;
    auto first_formula = detail::make_expression_ptr(detail::normalize_node(detail::node(
        SymbolicExpr::add(SymbolicExpr::number(rational_part),
            SymbolicExpr::multiply(SymbolicExpr::number(first_radical_coefficient),
                                   sqrt_discriminant))), budget));
    auto second_formula = detail::make_expression_ptr(detail::normalize_node(detail::node(
        SymbolicExpr::add(SymbolicExpr::number(rational_part),
            SymbolicExpr::multiply(SymbolicExpr::number(second_radical_coefficient),
                                   sqrt_discriminant))), budget));
    budget.append_size(budget.measure(detail::node(first_formula)),
                       budget.measure(detail::node(second_formula)));
    auto first_verified = verify_quadratic_boundary(
        polynomial, first_formula, rational_part,
        first_radical_coefficient, discriminant, context);
    if (!first_verified) {
        return Result<QuadraticBoundaries>::failure(first_verified.error());
    }
    auto second_verified = verify_quadratic_boundary(
        polynomial, second_formula, rational_part,
        second_radical_coefficient, discriminant, context);
    if (!second_verified) {
        return Result<QuadraticBoundaries>::failure(second_verified.error());
    }
    return Result<QuadraticBoundaries>::success(
        {std::move(first_formula), std::move(second_formula)});
}

引用了 LMCAS::detail::RewriteBudget::append_size(), context, LMCAS::detail::RewriteBudget::context(), denominator, LMCAS::Result< T >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< T >::success() , 以及 verified_quadratic_boundaries().

被这些函数引用 verified_quadratic_boundaries().

函数调用图:

这是这个函数的调用关系图:

verified_real_inverse_candidates()

SymbolicExprVectorResult LMCAS::verified_real_inverse_candidates ( const std::vector< std::shared_ptr< SymbolicExpr > > & candidates, const std::shared_ptr< SymbolicExpr > & equation, const std::string & var, const std::string & operation, ComputationContext & context )

static

在文件 calculus_inverse.cpp 第 185 行定义.

    {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<std::shared_ptr<SymbolicExpr>> real_candidates;
    real_candidates.reserve(candidates.size());
    for (const auto& candidate : candidates) {
        std::shared_ptr<SymbolicExpr> real_candidate;
        auto status = calculus_utils_extract_real_candidate(candidate, real_candidate, context);
        if (status == CalculusRealCandidateStatus::Inconclusive) {
            return SymbolicExprVectorResult::failure(
                CasErrc::Inconclusive,
                "inverse derivative candidate reality could not be proven", operation);
        }
        if (status == CalculusRealCandidateStatus::NonReal) {
            continue;
        }
        auto residual = detail::make_expression_ptr(detail::substitute_node(detail::node(equation), var, detail::node(real_candidate), transform_budget));
        auto simplified = residual ? detail::make_expression_ptr(detail::normalize_node(detail::node(residual), transform_budget)) : nullptr;
        if (!simplified || !LMCAS::detail::node(simplified)) {
            return SymbolicExprVectorResult::failure(
                CasErrc::InternalInvariant,
                "inverse derivative candidate verification produced a null residual", operation);
        }
        if (!simplified->is_zero()) {
            continue;
        }
        if (!contains_inverse_candidate(real_candidates, real_candidate)) {
            real_candidates.push_back(real_candidate);
        }
    }
    return SymbolicExprVectorResult::success(std::move(real_candidates));
} catch (const CasError& error) {
    return SymbolicExprVectorResult::failure(error);
} catch (const std::bad_alloc&) {
    return SymbolicExprVectorResult::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return SymbolicExprVectorResult::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return SymbolicExprVectorResult::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 calculus_utils_extract_real_candidate(), contains_inverse_candidate(), context, LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::failure(), Inconclusive, InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), NonReal, LMCAS::detail::normalize_node(), LMCAS::detail::substitute_node(), LMCAS::Result< std::vector< std::shared_ptr< SymbolicExpr > > >::success() , 以及 verified_real_inverse_candidates().

被这些函数引用 inverse_derivative_checked() , 以及 verified_real_inverse_candidates().

函数调用图:

这是这个函数的调用关系图:

verify_lagrange_solutions()

LagrangeResult LMCAS::verify_lagrange_solutions ( const std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > & full_solutions, const VectorField & equations, const std::vector< std::string > & all_vars, const std::vector< std::string > & vars, ComputationContext & context, const std::string & operation, detail::RewriteBudget & transform_budget )

static

在文件 vector_calculus_lagrange.cpp 第 99 行定义.

{
    std::vector<std::map<std::string, std::shared_ptr<SymbolicExpr>>> verified;
    std::set<std::string> var_set(vars.begin(), vars.end());
    for (const auto& full_solution : full_solutions) {
        if (!vector_calculus_point_has_vars(full_solution, all_vars)) {
            return LagrangeResult::failure(
                CasErrc::Inconclusive,
                "Lagrange candidate omits one or more variables or multipliers",
                operation);
        }
        for (const auto& eq : equations) {
            auto residual = eq;
            for (const auto& [variable, value] : full_solution)
                residual = detail::make_expression_ptr(detail::substitute_node(detail::node(residual), variable, detail::node(value), transform_budget));
            auto proof = check_zero_residual(residual, context);
            if (!proof) return LagrangeResult::failure(proof.error());
            if (!std::holds_alternative<ProvedZeroResidual>(proof.value())) {
                return LagrangeResult::failure(
                    CasErrc::Inconclusive,
                    "Lagrange candidate does not verify against the full stationarity system",
                    operation);
            }
        }
 
        std::map<std::string, std::shared_ptr<SymbolicExpr>> filtered;
        for (const auto& [name, val] : full_solution) {
            if (var_set.count(name)) {
                filtered[name] = val;
            }
        }
        if (!vector_calculus_point_has_vars(filtered, vars)) {
            return LagrangeResult::failure(
                CasErrc::Inconclusive,
                "Lagrange candidate omits one or more variables",
                operation);
        }
        verified.push_back(std::move(filtered));
    }
 
    return LagrangeResult::success(std::move(verified));
}

引用了 check_zero_residual(), context, eq(), LMCAS::Result< std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > >::failure(), Inconclusive, LMCAS::detail::make_expression_ptr(), name, LMCAS::detail::node(), LMCAS::detail::substitute_node(), LMCAS::Result< std::vector< std::map< std::string, std::shared_ptr< SymbolicExpr > > > >::success(), value, variable, vars, LMCAS::vector_calculus_detail::vector_calculus_point_has_vars() , 以及 verify_lagrange_solutions().

被这些函数引用 lagrange_multipliers_strict() , 以及 verify_lagrange_solutions().

函数调用图:

这是这个函数的调用关系图:

volume_of_revolution_x_checked() [1/2]

ExpressionResult LMCAS::volume_of_revolution_x_checked	(	std::shared_ptr< SymbolicExpr >	fx,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b )

在文件 symbolic_geometry.cpp 第 242 行定义.

  {
    ComputationContext context;
    return volume_of_revolution_x_checked(std::move(fx), std::move(a), std::move(b),
                                          context);
}

引用了 a, b, context , 以及 volume_of_revolution_x_checked().

函数调用图:

volume_of_revolution_x_checked() [2/2]

ExpressionResult LMCAS::volume_of_revolution_x_checked	(	std::shared_ptr< SymbolicExpr >	fx,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b,
		ComputationContext &	context )

在文件 symbolic_geometry.cpp 第 231 行定义.

  {
    return volume_of_revolution_checked_impl(
        std::move(fx), std::move(a), std::move(b), "x",
        context, "volume_of_revolution_x");
}

引用了 a, b, context , 以及 volume_of_revolution_x_checked().

被这些函数引用 volume_of_revolution_x_checked() , 以及 volume_of_revolution_x_checked().

函数调用图:

这是这个函数的调用关系图:

volume_of_revolution_y_checked() [1/2]

ExpressionResult LMCAS::volume_of_revolution_y_checked	(	std::shared_ptr< SymbolicExpr >	fy,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b )

在文件 symbolic_geometry.cpp 第 285 行定义.

  {
    ComputationContext context;
    return volume_of_revolution_y_checked(std::move(fy), std::move(a), std::move(b),
                                          context);
}

引用了 a, b, context , 以及 volume_of_revolution_y_checked().

函数调用图:

volume_of_revolution_y_checked() [2/2]

ExpressionResult LMCAS::volume_of_revolution_y_checked	(	std::shared_ptr< SymbolicExpr >	fy,
		std::shared_ptr< SymbolicExpr >	a,
		std::shared_ptr< SymbolicExpr >	b,
		ComputationContext &	context )

在文件 symbolic_geometry.cpp 第 274 行定义.

  {
    return volume_of_revolution_checked_impl(
        std::move(fy), std::move(a), std::move(b), "y",
        context, "volume_of_revolution_y");
}

引用了 a, b, context , 以及 volume_of_revolution_y_checked().

被这些函数引用 volume_of_revolution_y_checked() , 以及 volume_of_revolution_y_checked().

函数调用图:

这是这个函数的调用关系图:

wildcard()

SymbolicExpr LMCAS::wildcard

(

const std::string &

name

)

在文件 matcher.cpp 第 9 行定义.

                                             {
    return LMCAS::detail::expression_from_node(SymbolicFactory::create_variable(name));
}

引用了 LMCAS::SymbolicFactory::create_variable(), LMCAS::detail::expression_from_node(), name , 以及 wildcard().

被这些函数引用 expr_match(), 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() , 以及 wildcard().

函数调用图:

这是这个函数的调用关系图:

with_assumptions() [1/3]

template<typename F>

auto LMCAS::with_assumptions	(	AssumptionContext &	ctx,
		const std::vector< AssumptionDecl > &	decls,
		F &&	callable ) -> std::enable_if_t< std::is_void_v< decltype(callable())>, AssumptionVoidResult >

在文件 assumption_context.hpp 第 514 行定义.

{
    ctx.push();
    try {
        for (const auto& decl : decls) {
            auto applied = apply_assumption_decl_checked(ctx, decl);
            if (!applied) {
                auto popped = ctx.pop();
                if (!popped) return AssumptionVoidResult::failure(popped.error());
                return AssumptionVoidResult::failure(applied.error());
            }
        }
        callable();
        auto popped = ctx.pop();
        if (!popped) return AssumptionVoidResult::failure(popped.error());
        return AssumptionVoidResult::success();
    } catch (const CasError& error) {
        auto popped = ctx.pop();
        if (!popped) return AssumptionVoidResult::failure(popped.error());
        return AssumptionVoidResult::failure(error);
    } catch (const std::bad_alloc&) {
        auto popped = ctx.pop();
        if (!popped) return AssumptionVoidResult::failure(popped.error());
        return AssumptionVoidResult::failure(
            CasErrc::ResourceLimit, "with_assumptions allocation failed", "with_assumptions");
    } catch (const std::exception& ex) {
        auto popped = ctx.pop();
        if (!popped) return AssumptionVoidResult::failure(popped.error());
        return AssumptionVoidResult::failure(
            CasErrc::InternalInvariant, ex.what(), "with_assumptions");
    } catch (...) {
        auto popped = ctx.pop();
        if (!popped) return AssumptionVoidResult::failure(popped.error());
        throw;
    }
}

引用了 apply_assumption_decl_checked(), LMCAS::Result< void >::failure(), InternalInvariant, ResourceLimit, LMCAS::Result< void >::success() , 以及 with_assumptions().

函数调用图:

with_assumptions() [2/3]

template<typename F>

auto LMCAS::with_assumptions	(	AssumptionContext &	ctx,
		const std::vector< AssumptionDecl > &	decls,
		F &&	callable ) -> std::enable_if_t<!std::is_void_v< decltype(callable())>, Result< decltype(callable())> >

Execute a callable within a temporary assumption scope.

Declaration and callable failures are returned as CasError. The temporary scope is removed before every return.

在文件 assumption_context.hpp 第 472 行定义.

{
    using ReturnT = decltype(callable());
    ctx.push();
    try {
        for (const auto& decl : decls) {
            auto applied = apply_assumption_decl_checked(ctx, decl);
            if (!applied) {
                auto popped = ctx.pop();
                if (!popped) return Result<ReturnT>::failure(popped.error());
                return Result<ReturnT>::failure(applied.error());
            }
        }
        auto result = callable();
        auto popped = ctx.pop();
        if (!popped) return Result<ReturnT>::failure(popped.error());
        return Result<ReturnT>::success(std::move(result));
    } catch (const CasError& error) {
        auto popped = ctx.pop();
        if (!popped) return Result<ReturnT>::failure(popped.error());
        return Result<ReturnT>::failure(error);
    } catch (const std::bad_alloc&) {
        auto popped = ctx.pop();
        if (!popped) return Result<ReturnT>::failure(popped.error());
        return Result<ReturnT>::failure(
            CasErrc::ResourceLimit, "with_assumptions allocation failed", "with_assumptions");
    } catch (const std::exception& ex) {
        auto popped = ctx.pop();
        if (!popped) return Result<ReturnT>::failure(popped.error());
        return Result<ReturnT>::failure(
            CasErrc::InternalInvariant, ex.what(), "with_assumptions");
    } catch (...) {
        auto popped = ctx.pop();
        if (!popped) return Result<ReturnT>::failure(popped.error());
        throw;
    }
}

引用了 apply_assumption_decl_checked(), LMCAS::Result< T >::failure(), InternalInvariant, ResourceLimit, LMCAS::Result< T >::success() , 以及 with_assumptions().

被这些函数引用 with_assumptions(), with_assumptions() , 以及 with_assumptions().

函数调用图:

这是这个函数的调用关系图:

with_assumptions() [3/3]

template<typename F>

auto LMCAS::with_assumptions	(	AssumptionContext &	ctx,
		std::initializer_list< AssumptionDecl >	decls,
		F &&	callable ) -> decltype(with_assumptions( ctx, std::vector< AssumptionDecl >(decls), std::forward< F >(callable)))

在文件 assumption_context.hpp 第 555 行定义.

{
    return with_assumptions(
        ctx, std::vector<AssumptionDecl>(decls), std::forward<F>(callable));
}

引用了 with_assumptions().

函数调用图:

with_unit()

ExprResult LMCAS::with_unit	(	const ExprPtr &	value,
		const std::string &	unit,
		ComputationContext &	context )

在文件 value_facade.cpp 第 7 行定义.

                                                  {
    return attach_unit(value, unit, context);
}

引用了 attach_unit(), context, unit, value , 以及 with_unit().

被这些函数引用 with_unit().

函数调用图:

这是这个函数的调用关系图:

with_unit_definition()

ExprResult LMCAS::with_unit_definition	(	const ExprPtr &	value,
		std::string	display_unit,
		UnitDefinition	definition,
		ComputationContext &	context )

在文件 value_facade.cpp 第 12 行定义.

                                                             {
    return attach_unit(value, std::move(display_unit), std::move(definition), context);
}

引用了 attach_unit(), context, definition, display_unit, value , 以及 with_unit_definition().

被这些函数引用 with_unit_definition().

函数调用图:

这是这个函数的调用关系图:

wrap_ode_solution()

ODESolutionResult LMCAS::wrap_ode_solution	(	ODESolution	solution,
		ODEType	expected_method,
		const std::string &	operation )

在文件 ode_support.cpp 第 100 行定义.

{
    if (!solution.general_solution || !LMCAS::detail::node(solution.general_solution)) {
        return ODESolutionResult::failure(
            CasErrc::Inconclusive,
            "ODE solver produced no solution in the supported domain",
            operation);
    }
    if (solution.method_used != expected_method) {
        return ODESolutionResult::failure(
            CasErrc::InternalInvariant,
            "ODE solver reported an unexpected method",
            operation);
    }
    return ODESolutionResult::success(std::move(solution));
}

引用了 LMCAS::Result< ODESolution >::failure(), LMCAS::ODESolution::general_solution, Inconclusive, InternalInvariant, LMCAS::ODESolution::method_used, LMCAS::detail::node(), LMCAS::Result< ODESolution >::success() , 以及 wrap_ode_solution().

被这些函数引用 solve_bernoulli_ode_checked(), solve_euler_ode_checked(), solve_exact_ode_checked(), solve_higher_order_ode_checked(), solve_homogeneous_ode_checked(), solve_variation_of_parameters_checked() , 以及 wrap_ode_solution().

函数调用图:

这是这个函数的调用关系图:

z_transform_checked() [1/2]

TransformEngineResult LMCAS::z_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	f_n,
		const std::string &	n,
		const std::string &	z )

在文件 transform_z.cpp 第 276 行定义.

                        {
    ComputationContext context;
    return z_transform_checked(f_n, n, z, context);
}

引用了 context , 以及 z_transform_checked().

函数调用图:

z_transform_checked() [2/2]

TransformEngineResult LMCAS::z_transform_checked	(	const std::shared_ptr< SymbolicExpr > &	f_n,
		const std::string &	n,
		const std::string &	z,
		ComputationContext &	context )

在文件 transform_z.cpp 第 245 行定义.

                                 {
    const std::string operation = "z_transform";
    auto valid = te_validate_expr_vars(f_n, n, z, context, operation);
    if (!valid) return TransformEngineResult::failure(valid.error());
    auto step = context.consume_steps(8, operation);
    if (!step) return TransformEngineResult::failure(step.error());
    try {
        auto expression = z_transform_core(f_n, n, z, context);
        auto final_access = context.consume_steps(0, operation);
        if (!final_access) {
            return TransformEngineResult::failure(final_access.error());
        }
        auto result = te_wrap_transform_result(std::move(expression), operation);
        if (result) {
            result.value().value.roc = zt_roc(f_n, n, z);
        }
        return result;
    } catch (const std::bad_alloc&) {
        return TransformEngineResult::failure(CasErrc::ResourceLimit,
                                              "transform allocation failed",
                                              operation);
    } catch (const std::exception& e) {
        return TransformEngineResult::failure(CasErrc::InternalInvariant,
                                              e.what(), operation);
    }
}

引用了 context, e(), LMCAS::Result< Verified< EvaluatedTransform > >::failure(), InternalInvariant, ResourceLimit, LMCAS::transform_detail::te_validate_expr_vars(), LMCAS::transform_detail::te_wrap_transform_result(), z_transform_checked(), z_transform_core() , 以及 zt_roc().

被这些函数引用 z_transform_checked() , 以及 z_transform_checked().

函数调用图:

这是这个函数的调用关系图:

z_transform_core()

std::shared_ptr< SymbolicExpr > LMCAS::z_transform_core ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::string & z, ComputationContext & context )

static

在文件 transform_z.cpp 第 205 行定义.

                                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto step = context.consume_steps(1, "z_transform.recursive");
    if (!step) {
        return nullptr;
    }
    if (!f || !detail::node(f)) {
        return nullptr;
    }
    auto zv = SymbolicExpr::variable(z);
    auto addition = std::dynamic_pointer_cast<const AddNode>(detail::node(f));
    if (addition) {
        return zt_sum(f, *addition, n, z, context);
    }
    auto [coefficient, body] = te_split_coeff(f, n);
    if (!coefficient->is_one()) {
        auto transformed = z_transform_core(body, n, z, context);
        if (transformed) {
            return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(coefficient, transformed)), transform_budget));
        }
    }
    if (!te_depends_on(f, n)) {
        auto denominator = SymbolicExpr::add(zv, SymbolicExpr::number(-1));
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(f, SymbolicExpr::divide(zv, denominator))), transform_budget));
    }
    auto polynomial = zt_polynomial(f, n, zv, z, context);
    if (polynomial) {
        return polynomial;
    }
    auto exponential = zt_exponential(f, n, zv, context);
    if (exponential) {
        return exponential;
    }
    auto trig = zt_trigonometric(f, n, zv, context);
    return trig ? trig : zt_unevaluated(f, n, z);
}

引用了 context, denominator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::transform_detail::te_depends_on(), LMCAS::transform_detail::te_split_coeff(), z_transform_core(), zt_exponential(), zt_polynomial(), zt_sum(), zt_trigonometric() , 以及 zt_unevaluated().

被这些函数引用 z_transform_checked(), z_transform_core() , 以及 zt_sum().

函数调用图:

这是这个函数的调用关系图:

zassenhaus_combine_checked() [1/2]

ZassenhausResult LMCAS::zassenhaus_combine_checked	(	const Polynomial< Rational > &	poly,
		const std::vector< Polynomial< BigInt > > &	lifted_factors,
		const BigInt &	reconstruction_modulus )

在文件 zassenhaus_combine.cpp 第 472 行定义.

                                          {
    ComputationContext context;
    return zassenhaus_combine_checked(
        poly, lifted_factors, reconstruction_modulus, context);
}

引用了 context, lifted_factors, reconstruction_modulus , 以及 zassenhaus_combine_checked().

函数调用图:

zassenhaus_combine_checked() [2/2]

ZassenhausResult LMCAS::zassenhaus_combine_checked	(	const Polynomial< Rational > &	poly,
		const std::vector< Polynomial< BigInt > > &	lifted_factors,
		const BigInt &	reconstruction_modulus,
		ComputationContext &	context )

在文件 zassenhaus_combine.cpp 第 455 行定义.

                                 {
    try {
        return zassenhaus_combine_impl(
            poly, lifted_factors, reconstruction_modulus, context);
    } catch (const std::bad_alloc&) {
        return ZassenhausResult::failure(
            CasErrc::ResourceLimit, "allocation failed", "zassenhaus_combine");
    } catch (const std::exception& error) {
        return ZassenhausResult::failure(
            CasErrc::InternalInvariant, error.what(), "zassenhaus_combine");
    }
}

引用了 context, LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::failure(), InternalInvariant, lifted_factors, reconstruction_modulus, ResourceLimit, zassenhaus_combine_checked() , 以及 zassenhaus_combine_impl().

被这些函数引用 LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_and_combine(), zassenhaus_combine_checked() , 以及 zassenhaus_combine_checked().

函数调用图:

这是这个函数的调用关系图:

zassenhaus_combine_impl()

ZassenhausResult LMCAS::zassenhaus_combine_impl ( const Polynomial< Rational > & poly, const std::vector< Polynomial< BigInt > > & lifted_factors, const BigInt & reconstruction_modulus, ComputationContext & context )

static

在文件 zassenhaus_combine.cpp 第 419 行定义.

                                 {
    if (reconstruction_modulus.is_zero() ||
        reconstruction_modulus.is_negative()) {
        return ZassenhausResult::failure(
            CasErrc::InvalidArgument,
            "reconstruction modulus must be positive",
            "zassenhaus_combine");
    }
    if (poly.is_zero()) {
        if (!lifted_factors.empty()) {
            return ZassenhausResult::failure(
                CasErrc::InvalidArgument,
                "zero polynomial requires an empty lifted-factor list",
                "zassenhaus_combine");
        }
        return ZassenhausResult::success(
            MathResult<std::vector<Polynomial<Rational>>>{{},
                Completeness::Complete, {}});
    }
    if (lifted_factors.empty()) {
        return zc_finalize(poly, {}, poly.make_monic(),
                           Completeness::Inconclusive,
                           "no lifted factors were provided");
    }
 
    auto validation = zc_validate_lifted_product(
        poly, lifted_factors, reconstruction_modulus, context);
    if (!validation) return ZassenhausResult::failure(validation.error());
 
    return zc_enumerate(poly, lifted_factors, reconstruction_modulus, context);
}

引用了 Complete, context, LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::failure(), Inconclusive, InvalidArgument, LMCAS::Polynomial< CoeffType >::is_zero(), lifted_factors, LMCAS::Polynomial< CoeffType >::make_monic(), reconstruction_modulus, LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::success(), zassenhaus_combine_impl(), zc_enumerate(), zc_finalize() , 以及 zc_validate_lifted_product().

被这些函数引用 zassenhaus_combine_checked() , 以及 zassenhaus_combine_impl().

函数调用图:

这是这个函数的调用关系图:

zc_bigint_to_rational_poly()

Polynomial< Rational > LMCAS::zc_bigint_to_rational_poly ( const std::vector< BigInt > & coeffs, const std::string & var )

static

将 BigInt 系数向量转换为有理系数多项式.

每个 BigInt 系数直接转换为 Rational(分母为 1).

参数

[in]	coeffs	BigInt 系数向量
[in]	var	变量名

返回

有理系数多项式

在文件 zassenhaus_combine.cpp 第 69 行定义.

                          {
 
    std::vector<Rational> rat_coeffs;
    rat_coeffs.reserve(coeffs.size());
    for (const auto& c : coeffs) {
        rat_coeffs.emplace_back(c);
    }
    return Polynomial<Rational>(rat_coeffs, var);
}

引用了 c , 以及 zc_bigint_to_rational_poly().

被这些函数引用 zc_bigint_to_rational_poly() , 以及 zc_reconstruct_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_divides_exactly()

bool LMCAS::zc_divides_exactly ( const Polynomial< Rational > & f, const Polynomial< Rational > & candidate )

static

检验候选因子是否整除原多项式(精确有理除法).

执行多项式带余除法 f / candidate,若余数为零则整除.

参数

[in]	f	原多项式
[in]	candidate	候选因子

返回

整除返回 true

在文件 zassenhaus_combine.cpp 第 219 行定义.

                                           {
 
    if (candidate.is_zero()) return false;
    if (candidate.degree() > f.degree()) return false;
    if (candidate.degree() == 0) return true;
 
    auto [quotient, remainder] = f.div_mod(candidate);
    return remainder.is_zero();
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::Polynomial< CoeffType >::is_zero() , 以及 zc_divides_exactly().

被这些函数引用 zc_divides_exactly() , 以及 zc_try_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_enumerate()

ZassenhausResult LMCAS::zc_enumerate ( const Polynomial< Rational > & poly, const std::vector< Polynomial< BigInt > > & lifted_factors, const BigInt & modulus, ComputationContext & context )

static

在文件 zassenhaus_combine.cpp 第 403 行定义.

                                                        {
    ZcFactorSearch search{lifted_factors, modulus, context, poly.make_monic(),
                         {}, std::vector<size_t>(lifted_factors.size())};
    for (size_t i = 0; i < search.active.size(); ++i) search.active[i] = i;
    while (search.active.size() > 1 && search.remaining.degree() > 1) {
        auto found = zc_find_factor(search);
        if (!found) return ZassenhausResult::failure(found.error());
        if (!found.value()) break;
    }
    return zc_finalize(poly, std::move(search.factors), std::move(search.remaining),
                       Completeness::Complete, {});
}

引用了 LMCAS::ZcFactorSearch::active, Complete, context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::ZcFactorSearch::factors, LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::failure(), lifted_factors, LMCAS::Polynomial< CoeffType >::make_monic(), LMCAS::ZcFactorSearch::remaining, zc_enumerate(), zc_finalize() , 以及 zc_find_factor().

被这些函数引用 zassenhaus_combine_impl() , 以及 zc_enumerate().

函数调用图:

这是这个函数的调用关系图:

zc_finalize()

ZassenhausResult LMCAS::zc_finalize ( const Polynomial< Rational > & original, std::vector< Polynomial< Rational > > factors, Polynomial< Rational > remaining, Completeness completeness, std::string reason )

static

在文件 zassenhaus_combine.cpp 第 316 行定义.

                      {
    if (!remaining.is_zero() && remaining.degree() > 0) {
        factors.push_back(remaining.make_monic());
    }
 
    if (!original.is_zero()) {
        Polynomial<Rational> product({Rational(1)}, original.variable_name);
        for (const auto& factor : factors) product = product * factor;
        if (!(product == original.make_monic())) {
            return ZassenhausResult::failure(
                CasErrc::InternalInvariant,
                "accepted Zassenhaus factors do not reconstruct the polynomial",
                "zassenhaus_combine");
        }
    } else if (!factors.empty()) {
        return ZassenhausResult::failure(
            CasErrc::InternalInvariant,
            "zero polynomial cannot have a nonempty monic factorization",
            "zassenhaus_combine");
    }
 
    return ZassenhausResult::success(
        MathResult<std::vector<Polynomial<Rational>>>{
            std::move(factors), completeness, std::move(reason)});
}

引用了 LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::failure(), InternalInvariant, LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::make_monic(), LMCAS::Result< MathResult< std::vector< Polynomial< Rational > > > >::success(), LMCAS::Polynomial< CoeffType >::variable_name , 以及 zc_finalize().

被这些函数引用 zassenhaus_combine_impl(), zc_enumerate() , 以及 zc_finalize().

函数调用图:

这是这个函数的调用关系图:

zc_find_factor()

Result< bool > LMCAS::zc_find_factor ( ZcFactorSearch & search )

static

在文件 zassenhaus_combine.cpp 第 391 行定义.

                                                           {
    for (size_t width = 1; width <= search.active.size() / 2; ++width) {
        std::vector<size_t> positions(width);
        for (size_t i = 0; i < width; ++i) positions[i] = i;
        do {
            auto candidate = zc_try_candidate(search, positions);
            if (!candidate || candidate.value()) return candidate;
        } while (zc_next_combination(positions, search.active.size()));
    }
    return Result<bool>::success(false);
}

引用了 LMCAS::ZcFactorSearch::active, LMCAS::Result< T >::success(), zc_find_factor(), zc_next_combination() , 以及 zc_try_candidate().

被这些函数引用 zc_enumerate() , 以及 zc_find_factor().

函数调用图:

这是这个函数的调用关系图:

zc_make_primitive()

Polynomial< Rational > LMCAS::zc_make_primitive ( const Polynomial< Rational > & poly )

static

使候选多项式首一化(首项系数归一).

参数

[in]

poly

输入多项式

返回

首一多项式

在文件 zassenhaus_combine.cpp 第 238 行定义.

                                                                                {
    if (poly.is_zero()) return poly;
    return poly.make_monic();
}

引用了 LMCAS::Polynomial< CoeffType >::is_zero(), LMCAS::Polynomial< CoeffType >::make_monic() , 以及 zc_make_primitive().

被这些函数引用 zc_make_primitive() , 以及 zc_try_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_next_combination()

bool LMCAS::zc_next_combination ( std::vector< size_t > & positions, size_t count )

static

在文件 zassenhaus_combine.cpp 第 243 行定义.

                                                                            {
    const size_t width = positions.size();
    for (size_t cursor = width; cursor > 0; --cursor) {
        const size_t i = cursor - 1;
        if (positions[i] < count - width + i) {
            ++positions[i];
            for (size_t j = i + 1; j < width; ++j) {
                positions[j] = positions[j - 1] + 1;
            }
            return true;
        }
    }
    return false;
}

引用了 zc_next_combination().

被这些函数引用 zc_find_factor() , 以及 zc_next_combination().

函数调用图:

这是这个函数的调用关系图:

zc_rational_reconstruction()

bool LMCAS::zc_rational_reconstruction ( const BigInt & a, const BigInt & m, BigInt & num, BigInt & den )

static

对 BigInt 系数执行有理数重构.

给定整数 a 和模数 m,使用扩展欧几里得算法寻找有理数 p/q 满足:

• a == p/q (mod m)
• |p| <= floor(sqrt(m/2)), |q| <= floor(sqrt(m/2))

当模数超出 int64_t 范围时使用 BigInt 算术;否则委托给 modular_arithmetic.hpp 中的 int64_t 版本以获得更好性能.

参数

[in]	a	待重构的整数系数(已归约到对称表示)
[in]	m	模数(正整数,通常为 p^k)
[out]	num	输出分子
[out]	den	输出分母

返回

满足界约束且 gcd=1 时返回 true;false 表示重构未决

对于可精确表示的小模数,委托给 int64_t 版本

BigInt 版本的有理重构 将 a 归约到 [0, m)

计算界 bound = floor(sqrt(m/2))

扩展欧几里得算法

确保分母为正

验证界约束

验证 gcd(|p|, q) == 1

在文件 zassenhaus_combine.cpp 第 98 行定义.

                 {
 
    if (m.is_zero() || m.is_negative()) return false;
 
    /// 对于可精确表示的小模数,委托给 int64_t 版本
    const auto a_small = a.try_to_int64();
    const auto m_small = m.try_to_int64();
    if (a_small && m_small) {
        const int64_t a_val = *a_small;
        const int64_t m_val = *m_small;
 
        auto reconstructed =
            LMCAS::rational_reconstruction_checked(a_val, m_val);
        if (!reconstructed) return false;
        const auto [p, q] = reconstructed.value();
        num = BigInt(static_cast<std::int64_t>(p));
        den = BigInt(static_cast<std::int64_t>(q));
        return true;
    }
 
    /// BigInt 版本的有理重构
    /// 将 a 归约到 [0, m)
    BigInt a_mod = a % m;
    if (a_mod.is_negative()) {
        a_mod = a_mod + m;
    }
 
    /// 计算界 bound = floor(sqrt(m/2))
    BigInt half_m = m / BigInt(2);
    BigInt bound = half_m.sqrt();
    if (bound.is_zero()) bound = BigInt(1);
 
    /// 扩展欧几里得算法
    BigInt r0 = m, r1 = a_mod;
    BigInt s0 = BigInt(0), s1 = BigInt(1);
 
    while (r1 > bound) {
        BigInt q = r0 / r1;
        BigInt r_new = r0 - q * r1;
        BigInt s_new = s0 - q * s1;
 
        r0 = r1;
        r1 = r_new;
        s0 = s1;
        s1 = s_new;
    }
 
    BigInt p = r1;
    BigInt q_val = s1;
 
    /// 确保分母为正
    if (q_val.is_negative()) {
        p = -p;
        q_val = -q_val;
    }
 
    /// 验证界约束
    if (p.abs() > bound || q_val.is_zero() || q_val > bound) {
        return false;
    }
 
    /// 验证 gcd(|p|, q) == 1
    BigInt g = BigInt::gcd(p.abs(), q_val);
    if (g != BigInt(1)) {
        return false;
    }
 
    num = p;
    den = q_val;
    return true;
}

引用了 a, LMCAS::polynomial_solver_detail::num(), rational_reconstruction_checked() , 以及 zc_rational_reconstruction().

被这些函数引用 zc_rational_reconstruction() , 以及 zc_reconstruct_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_reconstruct_candidate()

Polynomial< Rational > LMCAS::zc_reconstruct_candidate ( const std::vector< BigInt > & product_coeffs, const BigInt & mod, const std::string & var )

static

对子集乘积的所有系数执行有理重构,构造有理系数多项式.

对 product_coeffs 中的每个 BigInt 系数调用 zc_rational_reconstruction, 若所有系数均成功重构,则返回对应的有理系数多项式. 若任一系数重构失败,则回退到整数系数直接转换.

参数

[in]	product_coeffs	子集乘积的 BigInt 系数向量(对称表示)
[in]	mod	模数 p^k
[in]	var	变量名

返回

有理系数多项式(通过有理重构或整数直接转换)

尝试对每个系数执行有理重构

任一系数重构失败,回退到整数系数

在文件 zassenhaus_combine.cpp 第 187 行定义.

                          {
 
    std::vector<Rational> rat_coeffs;
    rat_coeffs.reserve(product_coeffs.size());
 
    /// 尝试对每个系数执行有理重构
    for (const auto& c : product_coeffs) {
        BigInt num, den;
        if (zc_rational_reconstruction(c, mod, num, den)) {
            rat_coeffs.emplace_back(num, den);
        } else {
            /// 任一系数重构失败,回退到整数系数
            return zc_bigint_to_rational_poly(product_coeffs, var);
        }
    }
 
    return Polynomial<Rational>(rat_coeffs, var);
}

引用了 c, LMCAS::polynomial_solver_detail::num(), zc_bigint_to_rational_poly(), zc_rational_reconstruction() , 以及 zc_reconstruct_candidate().

被这些函数引用 zc_reconstruct_candidate() , 以及 zc_try_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_select_indices()

std::vector< size_t > LMCAS::zc_select_indices ( const std::vector< size_t > & active, const std::vector< size_t > & positions )

static

在文件 zassenhaus_combine.cpp 第 258 行定义.

                                        {
    std::vector<size_t> indices;
    indices.reserve(positions.size());
    for (size_t position : positions) indices.push_back(active[position]);
    return indices;
}

引用了 zc_select_indices().

被这些函数引用 zc_select_indices() , 以及 zc_try_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_subset_product()

Result< std::vector< BigInt > > LMCAS::zc_subset_product ( const std::vector< Polynomial< BigInt > > & lifted_factors, const std::vector< size_t > & indices, const BigInt & mod, ComputationContext & context )

static

在模 m 下乘以按字典序枚举的提升因子子集.

在文件 zassenhaus_combine.cpp 第 22 行定义.

                                 {
    std::vector<BigInt> product = {BigInt(1)};
 
    for (size_t index : indices) {
        auto step = context.consume_steps(1, "zassenhaus_combine");
        if (!step) {
            return Result<std::vector<BigInt>>::failure(step.error());
        }
        if (index >= lifted_factors.size() ||
            lifted_factors[index].coeffs.empty()) {
            return Result<std::vector<BigInt>>::failure(
                CasErrc::InvalidArgument, "invalid lifted-factor index or zero factor",
                "zassenhaus_combine");
        }
        const auto& factor_coeffs = lifted_factors[index].coeffs;
        std::vector<BigInt> next(product.size() + factor_coeffs.size() - 1,
                                 BigInt(0));
        for (size_t i = 0; i < product.size(); ++i) {
            if (product[i].is_zero()) continue;
            for (size_t j = 0; j < factor_coeffs.size(); ++j) {
                if (factor_coeffs[j].is_zero()) continue;
                next[i + j] = next[i + j] + product[i] * factor_coeffs[j];
            }
        }
        for (auto& coefficient : next) {
            coefficient = detail::symmetric_remainder(coefficient, mod);
        }
        while (!next.empty() && next.back().is_zero()) next.pop_back();
        product = std::move(next);
    }
    return Result<std::vector<BigInt>>::success(std::move(product));
}

引用了 context, InvalidArgument, lifted_factors, LMCAS::detail::symmetric_remainder() , 以及 zc_subset_product().

被这些函数引用 zc_subset_product(), zc_try_candidate() , 以及 zc_validate_lifted_product().

函数调用图:

这是这个函数的调用关系图:

zc_try_candidate()

Result< bool > LMCAS::zc_try_candidate ( ZcFactorSearch & search, const std::vector< size_t > & positions )

static

在文件 zassenhaus_combine.cpp 第 356 行定义.

                                                                {
    auto step = search.context.consume_steps(1, "zassenhaus_combine");
    if (!step) {
        return Result<bool>::failure(step.error());
    }
    auto indices = zc_select_indices(search.active, positions);
    auto product = zc_subset_product(
        search.lifted, indices, search.modulus, search.context);
    if (!product) {
        return Result<bool>::failure(product.error());
    }
    if (product.value().empty()) return Result<bool>::success(false);
    auto candidate = zc_make_primitive(zc_reconstruct_candidate(
        product.value(), search.modulus, search.remaining.variable_name));
    if (candidate.is_zero() || candidate.degree() <= 0 ||
        candidate.degree() >= search.remaining.degree() ||
        !zc_divides_exactly(search.remaining, candidate)) {
        return Result<bool>::success(false);
    }
    auto [quotient, remainder] = search.remaining.div_mod(candidate);
    if (!remainder.is_zero()) {
        return Result<bool>::failure(
            CasErrc::InternalInvariant, "exact divisor produced a nonzero remainder",
            "zassenhaus_combine");
    }
    search.factors.push_back(candidate);
    search.remaining = std::move(quotient);
    for (size_t cursor = positions.size(); cursor > 0; --cursor) {
        search.active.erase(search.active.begin() +
            static_cast<std::ptrdiff_t>(positions[cursor - 1]));
    }
    return Result<bool>::success(true);
}

引用了 LMCAS::ZcFactorSearch::active, LMCAS::ComputationContext::consume_steps(), LMCAS::ZcFactorSearch::context, LMCAS::Polynomial< CoeffType >::degree(), LMCAS::Polynomial< CoeffType >::div_mod(), LMCAS::ZcFactorSearch::factors, LMCAS::Result< T >::failure(), InternalInvariant, LMCAS::ZcFactorSearch::lifted, LMCAS::ZcFactorSearch::modulus, LMCAS::ZcFactorSearch::remaining, LMCAS::Result< T >::success(), LMCAS::Polynomial< CoeffType >::variable_name, zc_divides_exactly(), zc_make_primitive(), zc_reconstruct_candidate(), zc_select_indices(), zc_subset_product() , 以及 zc_try_candidate().

被这些函数引用 zc_find_factor() , 以及 zc_try_candidate().

函数调用图:

这是这个函数的调用关系图:

zc_validate_lifted_product()

Result< void > LMCAS::zc_validate_lifted_product ( const Polynomial< Rational > & poly, const std::vector< Polynomial< BigInt > > & lifted_factors, const BigInt & modulus, ComputationContext & context )

static

在文件 zassenhaus_combine.cpp 第 267 行定义.

                                 {
    if (lifted_factors.empty()) {
        return Result<void>::success();
    }
 
    std::vector<size_t> all_indices(lifted_factors.size());
    for (size_t i = 0; i < all_indices.size(); ++i) {
        all_indices[i] = i;
    }
    auto product_result =
        zc_subset_product(lifted_factors, all_indices, modulus, context);
    if (!product_result) {
        return Result<void>::failure(product_result.error());
    }
    auto product = std::move(product_result.value());
 
    BigInt denominator_lcm(1);
    for (const Rational& coefficient : poly.coeffs) {
        denominator_lcm =
            BigInt::lcm(denominator_lcm, coefficient.get_denominator());
    }
    std::vector<BigInt> expected;
    expected.reserve(poly.coeffs.size());
    for (const Rational& coefficient : poly.coeffs) {
        BigInt integer_coefficient =
            coefficient.get_numerator() *
            (denominator_lcm / coefficient.get_denominator());
        expected.push_back(
            detail::symmetric_remainder(integer_coefficient, modulus));
    }
    while (!expected.empty() && expected.back().is_zero()) {
        expected.pop_back();
    }
    while (!product.empty() && product.back().is_zero()) {
        product.pop_back();
    }
    if (!(product == expected)) {
        return Result<void>::failure(
            CasErrc::InvalidArgument,
            "lifted factors are not congruent to the normalized polynomial",
            "zassenhaus_combine");
    }
    return Result<void>::success();
}

引用了 LMCAS::Polynomial< CoeffType >::coeffs, context, LMCAS::Result< T >::failure(), InvalidArgument, lifted_factors, LMCAS::Result< T >::success(), LMCAS::detail::symmetric_remainder(), zc_subset_product() , 以及 zc_validate_lifted_product().

被这些函数引用 zassenhaus_combine_impl() , 以及 zc_validate_lifted_product().

函数调用图:

这是这个函数的调用关系图:

zero_remainder()

bool LMCAS::zero_remainder ( const detail::SymbolicNodePtr & value, detail::RewriteBudget & budget )

static

在文件 integration_linearity.cpp 第 68 行定义.

                                                                                            {
    detail::RewriteScope scope(&budget);
    if (value->is_zero()) { return true; }
    const auto* piecewise = dynamic_cast<const PiecewiseNode*>(value.get());
    if (!piecewise) { return false; }
    for (const auto& branch : piecewise->branches()) {
        if (!zero_remainder(branch.expression, budget)) { return false; }
    }
    return !piecewise->default_expr() || zero_remainder(piecewise->default_expr(), budget);
}

引用了 LMCAS::PiecewiseNode::default_expr(), value , 以及 zero_remainder().

被这些函数引用 zero_remainder().

函数调用图:

这是这个函数的调用关系图:

zt_abs_expr()

std::shared_ptr< SymbolicExpr > LMCAS::zt_abs_expr ( const std::shared_ptr< SymbolicExpr > & expr )

static

在文件 transform_z.cpp 第 74 行定义.

                                                                                        {
    if (!expr || !LMCAS::detail::node(expr)) return nullptr;
    return LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<FunctionNode>(
            FunctionNode::FuncType::Abs,
            std::vector<std::shared_ptr<const SymbolicNode>>{LMCAS::detail::node(expr)}));
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node() , 以及 zt_abs_expr().

被这些函数引用 zt_abs_expr(), zt_base_roc() , 以及 zt_unit_roc().

函数调用图:

这是这个函数的调用关系图:

zt_base_roc()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::zt_base_roc ( const std::shared_ptr< SymbolicExpr > & base, const std::string & z )

static

在文件 transform_z.cpp 第 89 行定义.

                        {
    auto condition = te_gt_condition(zt_abs_expr(SymbolicExpr::variable(z)),
                                     zt_abs_expr(base));
    return condition ? std::vector<std::shared_ptr<SymbolicExpr>>{condition}
                     : std::vector<std::shared_ptr<SymbolicExpr>>{};
}

引用了 LMCAS::transform_detail::te_gt_condition(), zt_abs_expr() , 以及 zt_base_roc().

被这些函数引用 zt_base_roc() , 以及 zt_lookup_roc().

函数调用图:

这是这个函数的调用关系图:

zt_exponential()

std::shared_ptr< SymbolicExpr > LMCAS::zt_exponential ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::shared_ptr< SymbolicExpr > & z, ComputationContext & context )

static

在文件 transform_z.cpp 第 149 行定义.

                                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::shared_ptr<SymbolicExpr> base;
    const bool plain = zt_is_exp_seq(f, n, base);
    if (!plain && !zt_is_weighted_exp(f, n, base)) return nullptr;
    auto difference = SymbolicExpr::add(z, SymbolicExpr::multiply(SymbolicExpr::number(-1), base));
    if (plain) return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(z, difference)), transform_budget));
    auto denominator = SymbolicExpr::power(difference, SymbolicExpr::number(2));
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(SymbolicExpr::multiply(base, z), denominator)), transform_budget));
}

引用了 context, denominator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), zt_exponential(), zt_is_exp_seq() , 以及 zt_is_weighted_exp().

被这些函数引用 z_transform_core() , 以及 zt_exponential().

函数调用图:

这是这个函数的调用关系图:

zt_is_exp_seq()

bool LMCAS::zt_is_exp_seq ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, std::shared_ptr< SymbolicExpr > & base_out )

static

在文件 transform_z.cpp 第 9 行定义.

                                                                  {
    if (!f || !detail::node(f)) {
        return false;
    }
    auto power = std::dynamic_pointer_cast<const PowerNode>(detail::node(f));
    if (!power) {
        return false;
    }
    auto exponent = std::dynamic_pointer_cast<const VariableNode>(power->exponent());
    if (!exponent || exponent->is_constant() || exponent->name() != n) {
        return false;
    }
    auto base = detail::make_expression_ptr(power->base());
    if (te_depends_on(base, n)) {
        return false;
    }
    base_out = base;
    return true;
}

引用了 exponent, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::transform_detail::te_depends_on() , 以及 zt_is_exp_seq().

被这些函数引用 zt_exponential(), zt_is_exp_seq(), zt_is_weighted_exp() , 以及 zt_lookup_roc().

函数调用图:

这是这个函数的调用关系图:

zt_is_weighted_exp()

bool LMCAS::zt_is_weighted_exp ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, std::shared_ptr< SymbolicExpr > & base )

static

在文件 transform_z.cpp 第 30 行定义.

                                                                 {
    auto product = std::dynamic_pointer_cast<const MultiplyNode>(detail::node(f));
    if (!product || product->operands().size() != 2) {
        return false;
    }
    for (std::size_t i = 0; i < 2; ++i) {
        auto variable = std::dynamic_pointer_cast<const VariableNode>(product->operands()[i]);
        auto other = detail::make_expression_ptr(product->operands()[1 - i]);
        if (variable && !variable->is_constant() && variable->name() == n &&
            zt_is_exp_seq(other, n, base)) {
            return true;
        }
    }
    return false;
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), variable, zt_is_exp_seq() , 以及 zt_is_weighted_exp().

被这些函数引用 zt_exponential(), zt_is_weighted_exp() , 以及 zt_lookup_roc().

函数调用图:

这是这个函数的调用关系图:

zt_lookup_roc()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::zt_lookup_roc ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::string & z )

static

在文件 transform_z.cpp 第 98 行定义.

                                                                                  {
    if (zt_polynomial_pattern(f, n) != ZPolynomialPattern::None) return zt_unit_roc(z);
    std::shared_ptr<SymbolicExpr> base;
    if (zt_is_exp_seq(f, n, base) || zt_is_weighted_exp(f, n, base)) return zt_base_roc(base, z);
    bool is_sin = false;
    std::shared_ptr<SymbolicExpr> frequency;
    if (te_is_trig(f, n, is_sin, frequency)) return zt_unit_roc(z);
    return {};
}

引用了 None, LMCAS::transform_detail::te_is_trig(), zt_base_roc(), zt_is_exp_seq(), zt_is_weighted_exp(), zt_lookup_roc(), zt_polynomial_pattern() , 以及 zt_unit_roc().

被这些函数引用 zt_lookup_roc() , 以及 zt_roc().

函数调用图:

这是这个函数的调用关系图:

zt_polynomial()

std::shared_ptr< SymbolicExpr > LMCAS::zt_polynomial ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::shared_ptr< SymbolicExpr > & z, const std::string & z_var, ComputationContext & context )

static

在文件 transform_z.cpp 第 127 行定义.

                                                                                               {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto pattern = zt_polynomial_pattern(f, n);
    if (pattern == ZPolynomialPattern::None) return nullptr;
    if (pattern == ZPolynomialPattern::Cubic) {
        auto square = SymbolicExpr::power(SymbolicExpr::variable(n), SymbolicExpr::number(2));
        auto quadratic = zt_polynomial(square, n, z, z_var, context);
        return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::multiply(
            SymbolicExpr::multiply(SymbolicExpr::number(-1), z),
            detail::make_expression_ptr(detail::differentiate_node(detail::node(quadratic), z_var, transform_budget)))), transform_budget));
    }
    auto denominator = SymbolicExpr::power(SymbolicExpr::add(z, SymbolicExpr::number(-1)),
        SymbolicExpr::number(pattern == ZPolynomialPattern::Linear ? 2 : 3));
    auto numerator = pattern == ZPolynomialPattern::Linear ? z : SymbolicExpr::multiply(z,
        SymbolicExpr::add(z, SymbolicExpr::number(1)));
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(numerator, denominator)), transform_budget));
}

引用了 context, Cubic, denominator, LMCAS::detail::differentiate_node(), Linear, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), None, LMCAS::detail::normalize_node(), z_var, zt_polynomial() , 以及 zt_polynomial_pattern().

被这些函数引用 z_transform_core() , 以及 zt_polynomial().

函数调用图:

这是这个函数的调用关系图:

zt_polynomial_pattern()

ZPolynomialPattern LMCAS::zt_polynomial_pattern ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n )

static

在文件 transform_z.cpp 第 50 行定义.

                                                              {
    auto variable = std::dynamic_pointer_cast<const VariableNode>(detail::node(f));
    if (variable && !variable->is_constant() && variable->name() == n) {
        return ZPolynomialPattern::Linear;
    }
    auto power = std::dynamic_pointer_cast<const PowerNode>(detail::node(f));
    if (!power) {
        return ZPolynomialPattern::None;
    }
    variable = std::dynamic_pointer_cast<const VariableNode>(power->base());
    if (!variable || variable->is_constant() || variable->name() != n) {
        return ZPolynomialPattern::None;
    }
    auto exponent = std::dynamic_pointer_cast<const NumberNode>(power->exponent());
    BigInt integer;
    if (!exponent || !try_get_integer_value(exponent, integer)) {
        return ZPolynomialPattern::None;
    }
    if (integer == BigInt(2)) return ZPolynomialPattern::Quadratic;
    if (integer == BigInt(3)) return ZPolynomialPattern::Cubic;
    return ZPolynomialPattern::None;
}

引用了 Cubic, exponent, integer, Linear, LMCAS::detail::node(), None, Quadratic, try_get_integer_value(), variable , 以及 zt_polynomial_pattern().

被这些函数引用 zt_lookup_roc(), zt_polynomial() , 以及 zt_polynomial_pattern().

函数调用图:

这是这个函数的调用关系图:

zt_roc()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::zt_roc ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::string & z )

static

在文件 transform_z.cpp 第 109 行定义.

                                                                                  {
    if (!f || !detail::node(f)) return {};
    auto addition = std::dynamic_pointer_cast<const AddNode>(detail::node(f));
    if (addition) {
        std::vector<std::shared_ptr<SymbolicExpr>> combined;
        for (const auto& operand : addition->operands()) {
            auto conditions = zt_roc(detail::make_expression_ptr(operand), n, z);
            combined.insert(combined.end(), conditions.begin(), conditions.end());
        }
        return combined;
    }
    if (!te_depends_on(f, n)) return zt_unit_roc(z);
    auto [coefficient, body] = te_split_coeff(f, n);
    if (!coefficient->is_one()) return zt_roc(body, n, z);
    return zt_lookup_roc(f, n, z);
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::transform_detail::te_depends_on(), LMCAS::transform_detail::te_split_coeff(), zt_lookup_roc(), zt_roc() , 以及 zt_unit_roc().

被这些函数引用 z_transform_checked() , 以及 zt_roc().

函数调用图:

这是这个函数的调用关系图:

zt_sum()

std::shared_ptr< SymbolicExpr > LMCAS::zt_sum ( const std::shared_ptr< SymbolicExpr > & f, const AddNode & addition, const std::string & n, const std::string & z, ComputationContext & context )

static

在文件 transform_z.cpp 第 193 行定义.

                                                                         {
    std::shared_ptr<SymbolicExpr> result;
    for (const auto& operand : addition.operands()) {
        auto transformed = z_transform_core(detail::make_expression_ptr(operand), n, z, context);
        if (!transformed) return zt_unevaluated(f, n, z);
        result = result ? SymbolicExpr::add(result, transformed) : transformed;
    }
    return result;
}

引用了 context, LMCAS::detail::make_expression_ptr(), LMCAS::AddNode::operands(), z_transform_core(), zt_sum() , 以及 zt_unevaluated().

被这些函数引用 z_transform_core() , 以及 zt_sum().

函数调用图:

这是这个函数的调用关系图:

zt_trigonometric()

std::shared_ptr< SymbolicExpr > LMCAS::zt_trigonometric ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::shared_ptr< SymbolicExpr > & z, ComputationContext & context )

static

在文件 transform_z.cpp 第 164 行定义.

                                                                       {
 
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    bool is_sin = false;
    std::shared_ptr<SymbolicExpr> frequency;
    if (!te_is_trig(f, n, is_sin, frequency)) return nullptr;
    auto cosine = SymbolicExpr::cos(frequency);
    auto cross = SymbolicExpr::multiply(SymbolicExpr::multiply(SymbolicExpr::number(-2), z), cosine);
    auto denominator = SymbolicExpr::add(SymbolicExpr::add(
        SymbolicExpr::power(z, SymbolicExpr::number(2)), cross), SymbolicExpr::number(1));
    auto factor = is_sin ? SymbolicExpr::sin(frequency) : SymbolicExpr::add(z,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), cosine));
    return detail::make_expression_ptr(detail::normalize_node(detail::node(SymbolicExpr::divide(SymbolicExpr::multiply(z, factor), denominator)), transform_budget));
}

引用了 context, denominator, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::transform_detail::te_is_trig() , 以及 zt_trigonometric().

被这些函数引用 z_transform_core() , 以及 zt_trigonometric().

函数调用图:

这是这个函数的调用关系图:

zt_unevaluated()

std::shared_ptr< SymbolicExpr > LMCAS::zt_unevaluated ( const std::shared_ptr< SymbolicExpr > & f, const std::string & n, const std::string & z )

static

在文件 transform_z.cpp 第 182 行定义.

                                                                                  {
    return detail::make_expression_ptr(detail::make_node<TransformNode>(
        TransformNode::TransformType::ZTransform, detail::node(f)->clone(), n,
        SymbolicFactory::create_variable(z)));
}

引用了 LMCAS::SymbolicFactory::create_variable(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), zt_unevaluated() , 以及 LMCAS::TransformNode::ZTransform.

被这些函数引用 z_transform_core(), zt_sum() , 以及 zt_unevaluated().

函数调用图:

这是这个函数的调用关系图:

zt_unit_roc()

std::vector< std::shared_ptr< SymbolicExpr > > LMCAS::zt_unit_roc ( const std::string & z )

static

在文件 transform_z.cpp 第 82 行定义.

                                                                              {
    auto condition = te_gt_condition(zt_abs_expr(SymbolicExpr::variable(z)),
                                     SymbolicExpr::number(1));
    return condition ? std::vector<std::shared_ptr<SymbolicExpr>>{condition}
                     : std::vector<std::shared_ptr<SymbolicExpr>>{};
}

引用了 LMCAS::transform_detail::te_gt_condition(), zt_abs_expr() , 以及 zt_unit_roc().

被这些函数引用 zt_lookup_roc(), zt_roc() , 以及 zt_unit_roc().

函数调用图:

这是这个函数的调用关系图:

变量说明

a

const std::string const std::shared_ptr< SymbolicExpr > & LMCAS::a

在文件 vector_calculus_curves.hpp 第 50 行定义.

被这些函数引用 LMCAS::detail::ExactBoundArithmetic::add(), add_number_nodes(), add_numbers(), LMCAS::groebner_detail::add_poly(), LMCAS::groebner_detail::align_variables(), LMCAS::detail::inequality_support::append_affine_root(), LMCAS::detail::inequality_support::append_quadratic_roots(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::arc_length_checked_impl(), arc_length_x_checked(), arc_length_x_checked(), arc_length_y_checked(), arc_length_y_checked(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arithmetic(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arithmetic_budget(), assemble_frobenius_polynomial(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::binary_logical_truth(), LMCAS::berlekamp_detail::bk_div_mod(), LMCAS::berlekamp_detail::bk_gcd_mod(), LMCAS::berlekamp_detail::bk_mod_inverse(), LMCAS::berlekamp_detail::bk_poly_mul_mod(), LMCAS::calculus_utils_detail::calculus_utils_expr_equal(), calculus_utils_try_symbolic_definite(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_bounds(), LMCAS::detail::definite::certify_continuity_checked(), LMCAS::modular_detail::checked_positive_product(), choose_main_variable(), classify_hessian_pair(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::combine(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_surd(), LMCAS::detail::definite::compare_boundaries(), LMCAS::MonomialOrder::compare_deglex(), LMCAS::MonomialOrder::compare_grevlex(), LMCAS::MonomialOrder::compare_lex(), complex_add_checked(), complex_add_checked(), complex_div_checked(), complex_div_checked(), complex_locus_circle_checked(), complex_locus_circle_checked(), complex_locus_perpendicular_bisector_checked(), complex_locus_perpendicular_bisector_checked(), complex_mul_checked(), complex_mul_checked(), complex_sub_checked(), complex_sub_checked(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::conjunction(), cross_product(), cross_product_impl(), curve_integral_scalar(), curve_integral_scalar_checked(), curve_integral_scalar_checked(), LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), curve_integral_vector(), curve_integral_vector_checked(), curve_integral_vector_checked(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), deduplicate_roots(), LMCAS::detail::definite::definite_partition_checked(), LMCAS::detail::definite::definite_segment_checked(), LMCAS::detail::detect_difference_of_squares(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::disjunction(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::detail::ExactBoundArithmetic::div(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex(), LMCAS::groebner_detail::divides_mono(), dot_product(), dot_product_impl(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::anonymous_namespace{relation_store.cpp}::expr_equals(), extended_gcd(), extended_gcd_poly(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::factor_biquadratic(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::finish(), LMCAS::NormalizationVisitor::fuse_matrix_product(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::fused_dot_three(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::Polynomial< Rational >::gcd(), LMCAS::detail::definite::gcd_checked(), LMCAS::Polynomial< Rational >::gcd_coeff(), gcd_coeff_impl(), greens_theorem_area(), greens_theorem_area_checked(), greens_theorem_area_checked(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), LMCAS::detail::ExactBoundArithmetic::growth(), hl_mod_inverse(), hl_poly_add_mod(), hl_poly_divmod(), hl_poly_mul_mod(), hl_poly_sub_mod(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_even_case(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::intersection_candidate(), intervals_overlap_checked_impl(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::jordan_dimensions_match(), kronecker(), lammp_gcd(), LMCAS::groebner_detail::lcm_mono(), lcm_monomial(), LMCAS::detail::ExactBoundArithmetic::less(), 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_scaled_radical_rules(), LMCAS::integration_table_detail::load_scaled_trig_rules(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::logical(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), LMCAS::detail::make_integration_entries(), LMCAS::NormalizationVisitor::matrix_product_element(), mixed_product(), mixed_product_impl(), LMCAS::detail::ExactBoundArithmetic::mul(), LMCAS::groebner_detail::mul_mono(), LMCAS::groebner_detail::mul_poly(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::multiply(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::multiply(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::multiply_intervals(), multiply_number_nodes(), multiply_numbers(), LMCAS::Irrational::EnclosureRound::multiply_positive(), LMCAS::anonymous_namespace{inference_engine_product.cpp}::multiply_sign_sets(), multivariate_gcd(), normalization_factor_less(), LMCAS::AddNode::normalize_operands(), LMCAS::detail::ExactBoundArithmetic::operands(), LMCAS::fglm_detail::MonomialEnumerator::HeapCmp::operator()(), LMCAS::groebner_detail::MonomialLess::operator()(), LMCAS::MonomialOrder::operator()(), LMCAS::NodeLess::operator()(), LMCAS::Polynomial< Rational >::operator+(), LMCAS::Polynomial< Rational >::operator-(), LMCAS::detail::definite::ordered_partition_roots(), ordinary_series_recurrence(), plane_general(), LMCAS::detail::definite::polynomial_sign_checked(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::power_bounds(), power_series_add(), power_series_multiply_checked(), power_series_multiply_checked(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::definite::product_checked(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points(), LMCAS::detail::definite::rational_divergence_checked(), rational_gcd(), LMCAS::detail::definite::rational_pole_divergence(), LMCAS::detail::real_quadratic_roots_checked(), recursive_multivariate_gcd(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::relation(), LMCAS::detail::inequality_support::root_less_than(), LMCAS::detail::inequality_support::roots_equal(), scalar_project(), scalar_project_impl(), LMCAS::detail::definite::segment_expression_checked(), LMCAS::anonymous_namespace{property_store.cpp}::signs_conflict(), singular_series_recurrence(), solve_biquadratic(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), solve_closed_form_from_poly(), solve_closed_form_poly(), solve_complex_quadratic_checked(), solve_complex_quadratic_checked(), solve_cubic(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), solve_euler_ode_impl(), solve_linear2_homogeneous(), solve_linear2_ode(), solve_linear2_ode_checked(), solve_linear2_ode_checked(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), solve_quartic(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::detail::ExactBoundArithmetic::sub(), LMCAS::polynomial_solver_detail::sub(), LMCAS::groebner_detail::sub_poly(), LMCAS::anonymous_namespace{normalization_arithmetic.cpp}::sum_term_less(), surface_area_revolution_x_checked(), surface_area_revolution_x_checked(), surface_area_revolution_y_checked(), surface_area_revolution_y_checked(), symbolic_cubic_roots(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), te_inv_power(), te_laplace_lookup(), te_laplace_roc(), tf_nodes_equal(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::to_algebraic(), LMCAS::NormalizationVisitor::try_normalize_squared_norm(), LMCAS::integration_table_detail::u_is_var_a_indep(), LMCAS::integration_table_detail::u_is_var_a_nonzero(), univariate_gcd(), LMCAS::geometry_detail::validate_same_dimension_vectors(), vector_angle_checked(), vector_angle_checked(), vector_angle_symbolic(), vector_angle_symbolic_impl(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), vector_calculus_definite_integral_strict(), LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback(), vector_calculus_numerical_definite(), vector_calculus_try_definite(), 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(), vector_cross(), vector_cross_checked(), vector_cross_checked(), vector_dot(), vector_dot_checked(), vector_dot_checked(), vector_project(), vector_project_impl(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_decomposition(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), volume_of_revolution_x_checked(), volume_of_revolution_x_checked(), volume_of_revolution_y_checked(), volume_of_revolution_y_checked(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_has_trig_of_var(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace() , 以及 zc_rational_reconstruction().

b

const VectorField & LMCAS::b

在文件 multivariate_factor.hpp 第 92 行定义.

被这些函数引用 LMCAS::PowerNode::PowerNode(), LMCAS::ProductNode::ProductNode(), LMCAS::SummationNode::SummationNode(), LMCAS::TransformNode::TransformNode(), LMCAS::detail::ExactBoundArithmetic::add(), add_number_nodes(), add_numbers(), LMCAS::groebner_detail::add_poly(), LMCAS::groebner_detail::align_variables(), LMCAS::detail::inequality_support::append_affine_root(), LMCAS::detail::inequality_support::append_quadratic_roots(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::arc_length_checked_impl(), arc_length_x_checked(), arc_length_x_checked(), arc_length_y_checked(), arc_length_y_checked(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arithmetic(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arithmetic_budget(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::binary_logical_truth(), LMCAS::berlekamp_detail::bk_div_mod(), LMCAS::berlekamp_detail::bk_gcd_mod(), LMCAS::berlekamp_detail::bk_poly_mul_mod(), LMCAS::anonymous_namespace{assumption_serialization.cpp}::boundedness_to_string(), LMCAS::calculus_utils_detail::calculus_utils_expr_equal(), calculus_utils_try_symbolic_definite(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_bounds(), LMCAS::detail::definite::certify_continuity_checked(), LMCAS::modular_detail::checked_positive_product(), choose_main_variable(), classify_hessian_pair(), LMCAS::PiecewiseNode::clone(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::combine(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::comparable_surd(), LMCAS::detail::definite::compare_boundaries(), LMCAS::MonomialOrder::compare_deglex(), LMCAS::MonomialOrder::compare_grevlex(), LMCAS::MonomialOrder::compare_lex(), complex_add_checked(), complex_add_checked(), complex_div_checked(), complex_div_checked(), complex_locus_perpendicular_bisector_checked(), complex_locus_perpendicular_bisector_checked(), complex_mul_checked(), complex_mul_checked(), complex_sub_checked(), complex_sub_checked(), LMCAS::PiecewiseNode::compute_hash(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::conjunction(), cross_product(), cross_product_impl(), curve_integral_scalar(), curve_integral_scalar_checked(), curve_integral_scalar_checked(), LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), curve_integral_vector(), curve_integral_vector_checked(), curve_integral_vector_checked(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), deduplicate_roots(), LMCAS::detail::definite::definite_partition_checked(), LMCAS::detail::definite::definite_segment_checked(), LMCAS::detail::detect_difference_of_squares(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::disjunction(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::detail::ExactBoundArithmetic::div(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex(), LMCAS::groebner_detail::divides_mono(), dot_product(), dot_product_impl(), eliminate_parametric_column(), LMCAS::detail::definite::evaluate_segment_endpoints(), LMCAS::anonymous_namespace{relation_store.cpp}::expr_equals(), extended_gcd(), extended_gcd_poly(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::factor_biquadratic(), LMCAS::detail::anonymous_namespace{mixed_transcendental_isolation.cpp}::RootIsolation::finish(), LMCAS::NormalizationVisitor::fuse_matrix_product(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::fused_dot_three(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::Polynomial< Rational >::gcd(), LMCAS::detail::definite::gcd_checked(), LMCAS::Polynomial< Rational >::gcd_coeff(), gcd_coeff_impl(), gram_schmidt(), greens_theorem_area(), greens_theorem_area_checked(), greens_theorem_area_checked(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), LMCAS::detail::ExactBoundArithmetic::growth(), hl_mignotte_bound(), hl_poly_add_mod(), hl_poly_divmod(), hl_poly_mul_mod(), hl_poly_sub_mod(), hl_two_factor_lift(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::intersection_candidate(), intervals_overlap_checked_impl(), LMCAS::NumberNode::is_positive(), kronecker(), lammp_gcd(), LMCAS::groebner_detail::lcm_mono(), lcm_monomial(), LMCAS::detail::ExactBoundArithmetic::less(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::logical(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), LMCAS::detail::make_integration_entries(), LMCAS::NormalizationVisitor::matrix_product_element(), mixed_product(), mixed_product_impl(), LMCAS::detail::ExactBoundArithmetic::mul(), LMCAS::groebner_detail::mul_mono(), LMCAS::groebner_detail::mul_poly(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::multiply(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::multiply(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::multiply_intervals(), multiply_number_nodes(), multiply_numbers(), LMCAS::Irrational::EnclosureRound::multiply_positive(), LMCAS::anonymous_namespace{inference_engine_product.cpp}::multiply_sign_sets(), multivariate_gcd(), normalization_factor_less(), LMCAS::AddNode::normalize_operands(), LMCAS::detail::ExactBoundArithmetic::operands(), LMCAS::fglm_detail::MonomialEnumerator::HeapCmp::operator()(), LMCAS::groebner_detail::MonomialLess::operator()(), LMCAS::MonomialOrder::operator()(), LMCAS::NodeLess::operator()(), LMCAS::Polynomial< Rational >::operator+(), LMCAS::Polynomial< Rational >::operator-(), LMCAS::detail::definite::ordered_partition_roots(), parametric_linear_solution(), plane_general(), LMCAS::detail::definite::polynomial_sign_checked(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::power_bounds(), power_series_add(), power_series_multiply_checked(), power_series_multiply_checked(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::definite::product_checked(), LMCAS::ode_root_detail::anonymous_namespace{ode_characteristic_roots.cpp}::quadratic_characteristic_roots(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points(), LMCAS::detail::definite::rational_divergence_checked(), rational_gcd(), LMCAS::detail::definite::rational_pole_divergence(), LMCAS::detail::real_quadratic_roots_checked(), recursive_multivariate_gcd(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::relation(), LMCAS::detail::inequality_support::root_less_than(), LMCAS::detail::inequality_support::roots_equal(), scalar_project(), scalar_project_impl(), LMCAS::detail::definite::segment_expression_checked(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_inv_var(), LMCAS::anonymous_namespace{property_store.cpp}::signs_conflict(), solve_biquadratic(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), solve_closed_form_from_poly(), solve_closed_form_poly(), solve_complex_quadratic_checked(), solve_complex_quadratic_checked(), solve_cubic(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), solve_degenerate_cubic(), solve_euler_ode_impl(), solve_linear2_homogeneous(), solve_linear2_ode(), solve_linear2_ode_checked(), solve_linear2_ode_checked(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), solve_quartic(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::solve_real_quadratic(), LMCAS::detail::inequality_support::solve_symbolic_poly(), LMCAS::detail::ExactBoundArithmetic::sub(), LMCAS::polynomial_solver_detail::sub(), LMCAS::groebner_detail::sub_poly(), LMCAS::anonymous_namespace{normalization_arithmetic.cpp}::sum_term_less(), surface_area_revolution_x_checked(), surface_area_revolution_x_checked(), surface_area_revolution_y_checked(), surface_area_revolution_y_checked(), symbolic_cubic_roots(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::transform_detail::te_split_coeff(), tf_nodes_equal(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::to_algebraic(), LMCAS::groebner_detail::to_poly(), LMCAS::NormalizationVisitor::try_normalize_squared_norm(), univariate_gcd(), LMCAS::geometry_detail::validate_same_dimension_vectors(), vector_angle_checked(), vector_angle_checked(), vector_angle_symbolic(), vector_angle_symbolic_impl(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), vector_calculus_definite_integral_strict(), LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback(), vector_calculus_numerical_definite(), vector_calculus_try_definite(), 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(), vector_cross(), vector_cross_checked(), vector_cross_checked(), vector_dot(), vector_dot_checked(), vector_dot_checked(), vector_project(), vector_project_impl(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), volume_of_revolution_x_checked(), volume_of_revolution_x_checked(), volume_of_revolution_y_checked() , 以及 volume_of_revolution_y_checked().

basis

const std::vector<FGLMPoly>& LMCAS::basis

在文件 fglm.hpp 第 102 行定义.

被这些函数引用 LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::ParametricBranchSolver(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::PolynomialSystemSearch(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::assemble_linear_solution(), LMCAS::berlekamp_detail::bk_null_space(), LMCAS::groebner_detail::buchberger(), LMCAS::anonymous_namespace{fglm.cpp}::dependent_polynomial(), LMCAS::anonymous_namespace{solver_groebner.cpp}::extend_basis(), gram_schmidt(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_basis.cpp}::initial_pairs(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_basis.cpp}::initialize_sugar(), is_zero_dimensional(), LMCAS::fglm_detail::leading_monomials(), linear2_root_basis(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_basis.cpp}::minimal_basis(), normal_form(), LMCAS::detail::nullspace_exact(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::parametric_basis(), quotient_dimension(), LMCAS::anonymous_namespace{solver_groebner.cpp}::reconstruct_basis(), LMCAS::groebner_detail::reduce_basis(), LMCAS::anonymous_namespace{fglm_polynomial.cpp}::reduce_leading_term(), LMCAS::groebner_detail::reduced_groebner_basis_impl(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::simplified_basis() , 以及 LMCAS::anonymous_namespace{solver_groebner_system.cpp}::solve_polynomial_system_impl().

binding

const Binding & LMCAS::binding

在文件 expr.hpp 第 303 行定义.

被这些函数引用 binding(), expr_match() , 以及 substitute().

bindings

const NumericBindings & LMCAS::bindings = {})

在文件 expr.hpp 第 310 行定义.

被这些函数引用 LMCAS::detail::NumericEvaluator::NumericEvaluator(), eval_complex(), eval_complex(), evalf(), evalf(), 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::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_operands(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_power(), evaluate_numeric(), evaluate_numeric(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_quadrature_callback(), lookup_integral() , 以及 LMCAS::RewriteVisitor::try_match().

c

const VectorField const VectorField& LMCAS::c

在文件 vector_calculus_vectors.hpp 第 60 行定义.

被这些函数引用 LMCAS::MatrixNode::MatrixNode(), LMCAS::MatrixNode::MatrixNode(), LMCAS::Polynomial< Rational >::Polynomial(), LMCAS::Polynomial< Rational >::Polynomial(), LMCAS::groebner_detail::add_poly(), LMCAS::groebner_detail::Poly::add_term(), LMCAS::fglm_detail::GaussianEliminator::add_vector(), LMCAS::detail::inequality_support::append_quadratic_roots(), berlekamp_factor(), LMCAS::berlekamp_detail::bk_gcd_mod(), LMCAS::berlekamp_detail::bk_reduce_to_mod_coeffs(), LMCAS::berlekamp_detail::bk_split_one_factor(), bk_to_poly_modint(), classify_hessian_pair(), classify_higher_order_ode(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::compatible_periodic_conditions(), LMCAS::MatrixNode::create_storage_from_grid(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::deduplicate_candidates(), LMCAS::Polynomial< Rational >::differentiate(), diophantine_target(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex(), extended_gcd_poly(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::factor_biquadratic(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::find_interval_comma(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::MatrixNode::get(), hensel_lift_checked(), hl_extended_gcd_poly(), hl_l2_norm_squared(), hl_reduce_coeffs(), hl_two_factor_lift(), LMCAS::detail::transcendental::invert_exp_base(), LMCAS::detail::transcendental::invert_lambert_w(), is_constant_coefficient(), LMCAS::expr_detail::ExprParser::is_ident_continue(), LMCAS::expr_detail::ExprParser::is_ident_start(), LMCAS::assumption_detail::is_serialized_numeric_atom(), lagrange_basis_coefficients(), LMCAS::Polynomial< Rational >::make_monic(), LMCAS::expr_detail::ExprParser::match(), matrix_reflection_checked(), matrix_rotation_checked(), mixed_product(), mixed_product_impl(), LMCAS::groebner_detail::mul_poly_term(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex(), operator<<(), LMCAS::detail::parse_finite_decimal(), LMCAS::assumption_detail::AssumptionParser::parse_monotonicity(), plane_general(), LMCAS::Polynomial< CoeffType >::primitive_part(), LMCAS::Polynomial< CoeffType >::pseudo_div_mod(), LMCAS::ode_root_detail::anonymous_namespace{ode_characteristic_roots.cpp}::quadratic_characteristic_roots(), rational_to_symbolic_poly(), LMCAS::anonymous_namespace{integration_rational_coefficients.cpp}::rd_fill_factor_columns(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_normalize_fraction(), LMCAS::detail::real_quadratic_roots_checked(), solve_biquadratic(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), solve_closed_form_from_poly(), LMCAS::detail::solve_coefficients(), solve_complex_nth_root_checked(), solve_complex_nth_root_checked(), solve_complex_quadratic_checked(), solve_complex_quadratic_checked(), solve_cubic(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), solve_degenerate_cubic(), solve_euler_ode_impl(), solve_linear2_homogeneous(), solve_linear2_ode(), solve_linear2_ode_checked(), solve_linear2_ode_checked(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), solve_quartic(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), LMCAS::groebner_detail::sub_poly(), symbolic_cubic_roots(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::transform_detail::te_split_coeff(), tf_build_polynomial_impl(), LMCAS::MatrixNode::validate_dense_storage(), LMCAS::MatrixNode::validate_sparse_storage(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit(), zc_bigint_to_rational_poly() , 以及 zc_reconstruct_candidate().

context

const SymbolicExpr ComputationContext & LMCAS::context

在文件 exact_factorization.hpp 第 65 行定义.

被这些函数引用 LMCAS::assumption_detail::AssumptionParser::AssumptionParser(), LMCAS::anonymous_namespace{integration_definite.cpp}::DefiniteInterval::DefiniteInterval(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::FormalResidual(), LMCAS::InferenceEngine::Impl::Impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::MixedRootCollection(), LMCAS::NormalizationVisitor::NormalizationVisitor(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::ParametricBranchSolver(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::PeriodInference(), LMCAS::groebner_detail::PolyContext::PolyContext(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::PolynomialSystemSearch(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::Reader(), LMCAS::serialization_detail::Recursion::Recursion(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::RecursionFrame::RecursionFrame(), LMCAS::anonymous_namespace{numeric_evaluation.cpp}::RecursionScope::RecursionScope(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::RecursionScope::RecursionScope(), LMCAS::anonymous_namespace{residual_verification.cpp}::ResidualRecursionScope::ResidualRecursionScope(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::SideBranchRewriter(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::Writer(), __attribute__(), abs(), abs(), LMCAS::InferenceEngine::Impl::absolute_domain(), LMCAS::InferenceEngine::Impl::absolute_sign(), LMCAS::InferenceEngine::Impl::accumulate_product_sign(), LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), LMCAS::InferenceEngine::Impl::accumulate_sum_relation_sign(), acos(), acos(), adaptive_simpson_numeric(), adaptive_simpson_numeric(), add(), add(), add_fourier_harmonic(), alternating_sequence_bound(), analytic_continuation(), any_nonreal_sqrt(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::append_exact_factor_roots(), append_factor_solutions(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::append_symbolic_plane_edges(), LMCAS::anonymous_namespace{newton_raphson.cpp}::append_verified_root(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::arc_length_checked_impl(), arc_length_x_checked(), arc_length_x_checked(), arc_length_y_checked(), arc_length_y_checked(), LMCAS::InferenceEngine::Impl::arctangent_domain(), asin(), asin(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::assemble_plane(), asymptote_candidates(), asymptotes_checked(), asymptotes_checked(), asymptotic_expand(), atan(), atan(), attach_unit(), attach_unit(), bisection_checked(), bisection_checked(), LMCAS::anonymous_namespace{property_store.cpp}::bounded_interval_candidate(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_append_repeated(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_factor(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_and_combine(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_bound(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_reduction(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::build_plane_edges(), calculate_residue_checked(), calculate_residue_checked(), calculate_residue_impl(), calculus_utils_contains_nonreal_sqrt(), calculus_utils_extract_real_candidate(), calculus_utils_oblique_from_rational(), calculus_utils_product(), calculus_utils_split_rational(), 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(), cauchy_integral_checked(), cauchy_integral_checked(), cauchy_integral_impl(), ceil(), ceil(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::certified_jordan(), LMCAS::anonymous_namespace{integration_definite.cpp}::certify_partition(), check_equivalent(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::check_plane_normal_nonzero(), LMCAS::anonymous_namespace{residual_verification.cpp}::check_residual_coefficient(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::check_term_budget(), LMCAS::anonymous_namespace{poly_utils.cpp}::check_zero_power_base(), check_zero_residual(), LMCAS::anonymous_namespace{quantity.cpp}::checked_binary(), checked_derivative(), checked_inference_result(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::checked_interval_views(), LMCAS::geometry_detail::checked_nonzero_numeric_or_exact(), LMCAS::geometry_detail::checked_nonzero_numeric_vector(), cholesky_decomposition_checked(), cholesky_decomposition_checked(), christoffel_first_kind_checked(), christoffel_first_kind_checked(), christoffel_first_kind_impl(), christoffel_second_kind_checked(), christoffel_second_kind_checked(), christoffel_second_kind_impl(), clamp(), clamp(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::classify_constant_equation(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::classify_continuity_point_value(), classify_first_order_ode(), 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(), classify_inflection_candidates(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_limit_result(), classify_quadratic_form(), classify_quadric_checked(), classify_quadric_checked(), classify_ratio_limit(), LMCAS::anonymous_namespace{residual_verification.cpp}::classify_residual(), classify_singular_point_checked(), classify_singular_point_checked(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::clear_denominators(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_families(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_pair(), coefficient_power_radius(), collect_bernoulli_coefficients(), collect_exact_solutions(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::collect_fraction_terms(), collect_infinite_asymptotes(), LMCAS::anonymous_namespace{interval_normalization.cpp}::collect_nonempty_intervals(), collect_oblique_asymptote(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::collect_polynomial_operands(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::collect_polynomial_variables(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), collect_vertical_asymptotes(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::anonymous_namespace{limit_result.cpp}::combine_one_sided_limits(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), LMCAS::expr_detail::expr_common::comparison_value(), complex_abs_checked(), complex_abs_checked(), complex_add_checked(), complex_add_checked(), complex_arg_checked(), complex_arg_checked(), complex_conj_checked(), complex_conj_checked(), complex_div_checked(), complex_div_checked(), complex_exp_form_checked(), complex_exp_form_checked(), complex_locus_circle_checked(), complex_locus_circle_checked(), complex_locus_perpendicular_bisector_checked(), complex_locus_perpendicular_bisector_checked(), complex_mul_checked(), complex_mul_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_condition(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_domain(), complex_sub_checked(), complex_sub_checked(), complex_trig_form_checked(), complex_trig_form_checked(), 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(), composition_inner_powers(), conj(), conj(), conjugate_checked(), conjugate_checked(), LMCAS::anonymous_namespace{symbolic_set.cpp}::consume(), continuity_at_checked(), continuity_at_checked(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_from_limits(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_point_value(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), convergence_radius_checked(), convergence_radius_checked(), convergence_radius_checked(), convergence_radius_checked(), convergence_test_checked(), convergence_test_checked(), convergence_test_impl(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::convert_basis_polynomial(), LMCAS::anonymous_namespace{solver_groebner.cpp}::convert_polynomials(), LMCAS::polynomial_solver_detail::convert_to_rational_poly(), convert_to_unit(), convert_to_unit_definition(), convert_unit(), convert_unit(), convolve_checked(), convolve_checked(), cos(), cos(), LMCAS::SymbolicFactory::create_power(), cross_product(), crt_checked(), crt_checked(), curl(), curl_checked(), curl_checked(), curvature_checked(), curvature_checked(), curvature_parametric_checked(), curvature_parametric_checked(), curve_integral_scalar(), curve_integral_scalar_checked(), curve_integral_scalar_checked(), LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), curve_integral_vector(), curve_integral_vector_checked(), curve_integral_vector_checked(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::definite_integral_geometry_checked(), dep_var_is_positive(), detect_parity(), detect_substitution(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::diagonalization_checked(), differential(), differentiate(), differentiate(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::differentiate_geometry_checked(), differentiate_if_dependent(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::differentiate_surface_checked(), dihedral_angle_checked(), dihedral_angle_checked(), directional_derivative(), directional_derivative_checked(), directional_derivative_checked(), LMCAS::anonymous_namespace{symbolic_factory.cpp}::discardable_zero_factor(), dispatch_equation(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::distinct_denominator_product(), div(), div(), divergence(), divergence_checked(), divergence_checked(), divergence_theorem(), divergence_theorem_checked(), divergence_theorem_checked(), LMCAS::vector_calculus_detail::divergence_theorem_strict(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root(), dot_product(), double_root_inequality_intervals(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_already_collected(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace(), eliminate_parametric_column(), eq(), eq(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equality_condition_truth(), equivalent(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::equivalent_with_budget(), essential_exponent(), essential_laurent(), LMCAS::anonymous_namespace{numerical_integration.cpp}::eval_bound_checked(), eval_complex(), eval_complex(), evalf(), evalf(), 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::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_operands(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_power(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_interval(), evaluate_numeric(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_function(), LMCAS::InferenceEngine::Impl::even_power_sign(), exact_factor_roots(), LMCAS::equivalence_detail::exact_integer_node(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_operands(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_polynomial_nodes(), LMCAS::polynomial_solver_detail::exact_polynomial_roots(), exp(), exp(), expand(), expand(), LMCAS::InferenceEngine::Impl::exponential_domain(), LMCAS::InferenceEngine::Impl::exponential_sign(), expr_match(), expr_match(), expr_set_difference(), expr_set_intersection(), expr_set_symmetric_difference(), expr_set_union(), exterior_derivative_checked(), exterior_derivative_checked(), extract_bernoulli_factor(), extract_bernoulli_monomial(), extract_coeff_value< BigInt >(), extract_coefficient(), extract_constant_term(), extract_laurent_regular_part(), 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::anonymous_namespace{multivariate_factor_checked.cpp}::factor_binomial_power(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_common_monomial(), factor_common_polynomial(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_difference_of_squares(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_embedded_univariate(), LMCAS::multivariate_checked_detail::factor_evaluated_linear(), LMCAS::multivariate_checked_detail::factor_linear_hensel(), factor_multivariate_checked(), factor_multivariate_checked(), factor_multivariate_expression(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl(), factor_numeric_content(), factor_rational_univariate(), factor_symbolic_quadratic(), factor_transcendental(), factor_transcendental(), factor_transcendental_expression(), factor_univariate_bridge_checked(), factor_variable_rational_roots(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::factors_defined(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::filter_denominators(), find_extrema(), find_extrema_checked(), find_extrema_checked(), find_extrema_impl(), find_integrating_factor(), find_integrating_factor_impl(), find_parametric_pivot(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::finish(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::finish_cancellation(), LMCAS::anonymous_namespace{bigint_combinatorics.cpp}::finish_combinatorial(), finite_set(), finite_set(), finite_set_difference(), finite_set_intersection(), finite_set_symmetric_difference(), finite_set_union(), LMCAS::anonymous_namespace{limit_result.cpp}::finite_sign(), floor(), floor(), fourier_constant_coefficient(), fourier_harmonics(), fourier_series_checked(), fourier_series_checked(), fourier_transform_checked(), fourier_transform_checked(), fourier_transform_core(), frobenius_coefficient_limit(), LMCAS::groebner_detail::from_poly_ext(), LMCAS::InferenceEngine::Impl::function_domain(), LMCAS::InferenceEngine::Impl::function_sign(), gradient(), gradient_checked(), gradient_checked(), gram_schmidt(), greens_theorem(), greens_theorem_area(), greens_theorem_area_checked(), greens_theorem_area_checked(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), greens_theorem_checked(), greens_theorem_checked(), LMCAS::vector_calculus_detail::greens_theorem_strict(), LMCAS::InferenceEngine::Impl::has_negated_operand(), LMCAS::anonymous_namespace{residual_verification.cpp}::has_zero_root_remainder(), hessian(), hessian_checked(), hessian_checked(), imag(), imag(), imag_part_checked(), imag_part_checked(), implicit_diff(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::include_rational_zeros(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::infer(), infinity_sign(), inflection_curve_defined(), inflection_points_checked(), inflection_points_checked(), LMCAS::InferenceEngine::Impl::integer_power_sign(), LMCAS::InferenceEngine::Impl::integral_power_domain(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), integrate_multiple_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), integrating_factor_from_antiderivative(), integrating_factor_from_ratio(), interval(), interval(), interval_contains_checked(), interval_contains_checked(), interval_covers_checked_impl(), interval_is_empty_checked(), interval_is_empty_checked(), intervals_overlap_checked_impl(), inverse_branch_derivative(), inverse_derivative_checked(), inverse_derivative_checked(), inverse_fourier_transform_checked(), inverse_fourier_transform_checked(), inverse_fourier_transform_core(), inverse_function_checked(), inverse_function_checked(), inverse_laplace_checked(), inverse_laplace_checked(), inverse_laplace_core(), is_analytic_checked(), is_analytic_checked(), is_analytic_impl(), is_bernoulli_ode(), is_euler_equation(), is_exact_ode(), is_homogeneous_ode(), is_linear_first_order(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexPuncturedFacts::is_negative(), LMCAS::FactsQuery::is_negative(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexPuncturedFacts::is_nonnegative(), LMCAS::FactsQuery::is_nonnegative(), is_nonreal_sqrt(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexPuncturedFacts::is_nonzero(), LMCAS::FactsQuery::is_nonzero(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexPuncturedFacts::is_positive(), LMCAS::FactsQuery::is_positive(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexPuncturedFacts::is_real(), LMCAS::FactsQuery::is_real(), is_vertical_asymptote(), isolate_linear_coeff(), isolate_real_roots_checked(), isolate_real_roots_checked(), isolate_roots(), jacobian(), jacobian_checked(), jacobian_checked(), jordan_form_checked(), jordan_form_checked(), kronecker(), lagrange_multipliers_checked(), lagrange_multipliers_checked(), lagrange_multipliers_strict(), laplace_transform_checked(), laplace_transform_checked(), LMCAS::transform_detail::laplace_transform_core(), laplacian(), laplacian_checked(), laplacian_checked(), laurent_series_checked(), laurent_series_checked(), laurent_series_full_checked(), laurent_series_full_checked(), laurent_series_full_impl(), lie_derivative_checked(), lie_derivative_checked(), lie_derivative_impl(), lim_inf_checked(), lim_inf_checked(), lim_sup_checked(), lim_sup_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), limit_checked(), limit_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), limit_expression_checked(), limit_expression_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_real_at_point(), line_from_two_points_checked(), line_from_two_points_checked(), line_plane_intersection_checked(), line_plane_intersection_checked(), LMCAS::integration_table_detail::load_exponential_base_rules(), LMCAS::integration_table_detail::load_polynomial_rules(), log(), log(), log10(), log10(), log_differentiate(), LMCAS::InferenceEngine::Impl::logarithm_domain(), LMCAS::InferenceEngine::Impl::logarithm_monotonicity(), LMCAS::InferenceEngine::Impl::logarithm_sign(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), lu_decomposition_checked(), lu_decomposition_checked(), LMCAS::expr_detail::expr_common::make_binary_expr(), LMCAS::expr_detail::expr_common::make_binary_math_expr(), make_finite_set(), make_interval(), make_membership(), make_rootof_checked(), make_rootof_checked(), make_rootof_solutions(), LMCAS::expr_detail::expr_common::make_unary_function_expr(), LMCAS::expr_detail::expr_common::make_unary_math_expr(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::matrix_axis_sum(), matrix_characteristic_polynomial_checked(), matrix_characteristic_polynomial_checked(), matrix_determinant_checked(), matrix_determinant_checked(), matrix_eigenvalues_checked(), matrix_eigenvalues_checked(), matrix_eigenvectors_checked(), matrix_eigenvectors_checked(), matrix_exp(), matrix_inverse_checked(), matrix_inverse_checked(), matrix_log(), matrix_multiply_checked(), matrix_multiply_checked(), matrix_norm(), matrix_nullspace_checked(), matrix_nullspace_checked(), matrix_rank_checked(), matrix_rank_checked(), matrix_reflection_checked(), matrix_reflection_checked(), matrix_rotation_checked(), matrix_rotation_checked(), matrix_rref_checked(), matrix_rref_checked(), matrix_scaling_checked(), matrix_scaling_checked(), matrix_solve_linear_checked(), matrix_solve_linear_checked(), matrix_trace(), LMCAS::anonymous_namespace{matrix_decomposition.cpp}::maximum_axis_sum(), member(), membership(), LMCAS::anonymous_namespace{interval_normalization.cpp}::merge_checked_intervals(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::merged_half_period_value(), metric_inverse_checked(), metric_inverse_checked(), mixed_product(), mul(), mul(), multi_crt_checked(), multi_crt_checked(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::multiply_checked(), LMCAS::InferenceEngine::Impl::multiply_domain(), multipoly_to_symbolic(), multivariate_factor_expression(), neg(), neg(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::node_to_multivariate_polynomial(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::nonlinear_solution(), LMCAS::InferenceEngine::Impl::nonzero_power_sign(), normalization_can_discard(), normalize_intervals_checked(), normalize_intervals_checked(), LMCAS::geometry_detail::numeric_vector_scale_checked(), LMCAS::InferenceEngine::Impl::operand_sign(), ordinary_frobenius_solution(), ordinary_taylor_coefficients(), 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(), parametric_linear_solution(), parametric_nonzero_value(), parametric_residual_zero(), parametric_zero(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::parse_conditional_relation(), parse_expr(), parse_expr(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_general_expression(), LMCAS::assumption_detail::parse_interval(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_interval_endpoint(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_interval_expression(), LMCAS::assumption_detail::parse_relation(), LMCAS::anonymous_namespace{root_of_identity.cpp}::parse_rootof_request(), LMCAS::assumption_detail::parse_serialized_expression(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::periodicity_checked(), plane_from_three_points_checked(), plane_from_three_points_checked(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::point_difference_scale_checked(), point_plane_distance_checked(), point_plane_distance_checked(), LMCAS::anonymous_namespace{residual_comparison.cpp}::pointwise_values_defined(), LMCAS::InferenceEngine::Impl::positive_integer_power_sign(), LMCAS::InferenceEngine::Impl::positive_power_sign(), LMCAS::InferenceEngine::Impl::positive_relation_chain(), pow(), pow(), power_series_add(), power_series_compose_checked(), power_series_compose_checked(), power_series_multiply_checked(), power_series_multiply_checked(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::power_to_polynomial(), prepare_fourier_period(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prepare_operands(), LMCAS::InferenceEngine::Impl::product_relation_sign(), LMCAS::InferenceEngine::Impl::product_sign(), project_finite_expr_set(), LMCAS::solver_detail::project_unconditional_linear_system(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::propagate(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_checked_operands(), LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::prove_exact_full_column_rank_qr_support(), LMCAS::anonymous_namespace{residual_verification.cpp}::prove_exact_root_residual(), LMCAS::anonymous_namespace{matrix_decomposition_cholesky.cpp}::prove_exact_spd(), 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(), qr_decomposition_checked(), qr_decomposition_checked(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::quadratic_coefficients(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign(), quadratic_form_matrix(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::quadratic_solution(), quadrature_gaussian_numeric(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), quadrature_simpson_numeric(), quantity_add(), quantity_divide(), quantity_multiply(), quantity_power(), quantity_subtract(), LMCAS::InferenceEngine::Impl::query_natural(), LMCAS::InferenceEngine::Impl::query_rational(), LMCAS::InferenceEngine::Impl::query_zero(), LMCAS::InferenceEngine::Impl::quotient_sign(), ratio_convergence_test(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points(), rational_reconstruction_checked(), rational_reconstruction_checked(), rational_root_factors(), LMCAS::anonymous_namespace{integration_rational.cpp}::rd_add_fraction_primitives(), real(), real(), LMCAS::InferenceEngine::Impl::real_definedness(), LMCAS::InferenceEngine::Impl::real_or_integer(), real_part_checked(), real_part_checked(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_node(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_power(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_product(), recognize_rational_polynomial(), recognize_regular_laurent(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_sum(), LMCAS::anonymous_namespace{solver_groebner.cpp}::reconstruct_basis(), reconstruct_rational_root_factors(), reconstruct_rational_roots(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::reconstructs_expression(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::reduce_fraction(), LMCAS::groebner_detail::reduced_groebner_basis_impl(), LMCAS::anonymous_namespace{integration_definite.cpp}::reduced_integrand_checked(), refine_root(), LMCAS::InferenceEngine::Impl::relation_rhs_nonnegative(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::relational_condition_truth(), LMCAS::anonymous_namespace{residual_verification.cpp}::replace_exact_root(), LMCAS::anonymous_namespace{bigint_combinatorics.cpp}::reserve_product(), residue_checked(), riemann_curvature_tensor_checked(), riemann_curvature_tensor_checked(), riemann_curvature_tensor_with_inverse(), rootof_evaluate_checked(), rootof_evaluate_checked(), rootof_evaluate_complex_checked(), rootof_evaluate_complex_checked(), rootof_simplify(), roots(), roots(), round(), round(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_newton_backend(), scalar_project(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::scale_plane_edges_for_cross(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::select_continuity_branch(), sequence_extreme_limit(), series_abs(), series_negate(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_match_exp_neg_quad(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::simplified_basis(), simplify(), simplify(), LMCAS::geometry_detail::simplify_checked(), simplify_finite_limit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::simplify_geometry_checked(), sin(), sin(), singular_frobenius_solution(), singular_taylor_coefficients(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::skew_distance_from_directions(), skew_lines_distance_checked(), skew_lines_distance_checked(), solution_is_excluded(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve(), solve(), solve(), solve_bernoulli_ode_checked(), solve_bernoulli_ode_checked(), solve_bernoulli_ode_impl(), solve_biquadratic(), LMCAS::polynomial_solver_detail::solve_biquadratic_impl(), solve_by_factoring(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl(), solve_closed_form_from_poly(), solve_closed_form_poly(), solve_complex_nth_root_checked(), solve_complex_nth_root_checked(), solve_complex_quadratic_checked(), solve_complex_quadratic_checked(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::solve_condition_truth(), solve_constant_inequality(), solve_cubic(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), solve_degenerate_cubic(), solve_equation(), solve_equation(), solve_euler_ode_checked(), solve_euler_ode_checked(), solve_euler_ode_impl(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::solve_exact_affine_inequality_impl(), solve_exact_factor(), solve_exact_ode_checked(), solve_exact_ode_checked(), solve_exact_ode_impl(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::solve_exact_polynomial_inequality_impl(), solve_exact_polynomial_set(), solve_expr_set(), solve_expr_set(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_factor(), solve_finite_checked(), solve_finite_checked(), solve_finite_mixed(), solve_frobenius_checked(), solve_frobenius_checked(), solve_frobenius_impl(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_function_pattern(), solve_higher_exact_roots(), solve_higher_order_ode_checked(), solve_higher_order_ode_checked(), solve_higher_order_ode_impl(), solve_homogeneous_ode_checked(), solve_homogeneous_ode_checked(), 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{solve_transcendental.cpp}::solve_inverted_values(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial(), solve_lagrange_strict(), solve_linear1_ode(), solve_linear2_homogeneous(), solve_linear2_ode(), solve_linear2_ode_checked(), solve_linear2_ode_checked(), LMCAS::solver_detail::solve_linear_system_impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::solve_mixed_equation(), solve_mixed_transcendental_checked(), solve_mixed_transcendental_checked(), solve_numeric_checked(), solve_numeric_checked(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_polynomial_factor(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::solve_polynomial_system_impl(), solve_product_factor(), solve_product_set(), LMCAS::polynomial_solver_detail::solve_quadratic_internal(), solve_quartic(), LMCAS::polynomial_solver_detail::solve_quartic_impl(), solve_separable_ode(), solve_set(), solve_set(), solve_set_core(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::solve_single_equation(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution(), solve_symbolic_polynomial_set(), solve_symbolic_quadratic(), solve_transcendental(), solve_transcendental(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_constant(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve_transcendental_factor(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl(), solve_variation_of_parameters_checked(), solve_variation_of_parameters_checked(), solve_variation_of_parameters_core(), solve_with_assumptions_checked(), solve_with_assumptions_checked(), solve_with_assumptions_impl(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::solved_inequality(), LMCAS::anonymous_namespace{interval_normalization.cpp}::sort_checked_intervals(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::sort_exact_inequality_roots(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), sqrt(), sqrt(), LMCAS::InferenceEngine::Impl::square_root_domain(), LMCAS::InferenceEngine::Impl::square_root_sign(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::squared_profile(), stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), strip_to_base_value(), strip_to_display_value(), strip_unit(), sub(), sub(), substitute(), substitute(), substitute(), substitute(), substitute(), substitute(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), LMCAS::anonymous_namespace{limit_visitor_taylor.cpp}::substitute_infinity_series(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive(), LMCAS::InferenceEngine::Impl::subtraction_sign(), LMCAS::InferenceEngine::Impl::subtrahend(), LMCAS::InferenceEngine::Impl::sum_nonzero(), LMCAS::InferenceEngine::Impl::sum_relation_sign(), LMCAS::InferenceEngine::Impl::sum_sign(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::sum_to_polynomial(), surface_area_revolution_x_checked(), surface_area_revolution_x_checked(), surface_area_revolution_y_checked(), surface_area_revolution_y_checked(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_at_point_checked(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_scale_checked(), surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), surface_normal_checked(), surface_normal_checked(), svd_decomposition_checked(), svd_decomposition_checked(), 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(), symbolic_poly_to_expr(), symbolic_polynomial_content(), symbolic_polynomial_gcd(), symbolic_power_to_poly(), symbolic_product(), symbolic_product_to_poly(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::symbolic_quadratic_sign(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::polynomial_solver_detail::symbolic_quartic_roots(), symbolic_sum(), symbolic_sum_to_poly(), symbolic_to_poly_recursive(), LMCAS::anonymous_namespace{symbolic_geometry_vector.cpp}::symbolic_vector_finite_numeric(), tan(), tan(), tangent_plane_checked(), tangent_plane_checked(), te_abs_decay(), te_abs_fourier(), te_accept_decay(), te_convolve_core(), te_convolve_sum(), LMCAS::transform_detail::te_factorial(), te_fourier_sum(), te_inv_power(), te_inv_product(), te_laplace_lookup(), te_laplace_sum(), te_validate_convolution_inputs(), LMCAS::transform_detail::te_validate_expr_vars(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_reconstruction.cpp}::term_node(), tf_back_substitute(), tf_build_polynomial(), tf_build_polynomial_impl(), tf_detect_exponential_separation(), tf_factor_substitution(), tf_restore_factors(), tf_simplify_factors(), tf_simplify_factors_impl(), total_differential(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_factor(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_extract_nonneg_int(), LMCAS::InferenceEngine::Impl::trigonometric_sign(), LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_match_radical(), LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_quadratic_coefficients(), LMCAS::integration_table_detail::u_is_real_var(), LMCAS::integration_table_detail::u_is_var_a_indep(), LMCAS::integration_table_detail::u_is_var_a_nonzero(), 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::anonymous_namespace{symbolic_complex.cpp}::validate_expr(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_form_coefficients(), validate_frobenius_regular_singular_domain(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::validate_geometry_inputs(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::validate_intersection_inputs(), LMCAS::geometry_detail::validate_line_checked(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_metric_matrix(), validate_ode_expr_var_pair(), validate_ode_pair_var_pair(), validate_ode_three_expr_one_var(), validate_ode_two_expr_point(), validate_ode_variables(), LMCAS::geometry_detail::validate_plane_checked(), LMCAS::anonymous_namespace{series_engine.cpp}::validate_power_series_order(), validate_property_interval(), LMCAS::geometry_detail::validate_same_dimension_vectors(), validate_series_expr_point(), LMCAS::geometry_detail::validate_surface_point(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_reconstruction.cpp}::variable_node(), vector_angle_checked(), vector_angle_checked(), vector_angle_symbolic(), LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric(), vector_calculus_classify_critical_point(), vector_calculus_constant_integrand(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), vector_calculus_definite_integral_strict(), vector_calculus_evaluate_hessian_at_point(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback(), vector_calculus_multiple_integral_strict(), vector_calculus_numerical_definite(), 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_distinct_vars(), 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_parametrization(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_scalar_inputs(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_vector_inputs(), vector_cross_checked(), vector_cross_checked(), vector_dot_checked(), vector_dot_checked(), vector_project(), verified_quadratic_boundaries(), verified_real_inverse_candidates(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_decomposition(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_identity(), verify_lagrange_solutions(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::verify_quadratic_boundary(), LMCAS::ExpandVisitor::visit(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), volume_of_revolution_x_checked(), volume_of_revolution_x_checked(), volume_of_revolution_y_checked(), volume_of_revolution_y_checked(), LMCAS::InferenceEngine::Impl::weak_subtraction_sign(), 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(), with_unit(), with_unit_definition(), z_transform_checked(), z_transform_checked(), z_transform_core(), zassenhaus_combine_checked(), zassenhaus_combine_checked(), zassenhaus_combine_impl(), zc_enumerate(), zc_subset_product(), zc_validate_lifted_product(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::zero_difference(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::zero_numerator_domain(), LMCAS::InferenceEngine::Impl::zero_power_sign(), zt_exponential(), zt_polynomial(), zt_sum() , 以及 zt_trigonometric().

definition

std::string UnitDefinition LMCAS::definition

在文件 expr.hpp 第 167 行定义.

被这些函数引用 attach_unit(), attach_unit(), convert_to_unit_definition(), convert_unit() , 以及 with_unit_definition().

denominator

const ExprPtr & LMCAS::denominator

在文件 expr.hpp 第 200 行定义.

被这些函数引用 asymptote_candidates(), LMCAS::anonymous_namespace{bigint_arithmetic.cpp}::bigint_div(), LMCAS::anonymous_namespace{differential_geometry.cpp}::bounded_binomial(), calculus_utils_extract_denominator(), calculus_utils_oblique_from_rational(), calculus_utils_split_rational(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::cancel_polynomial_gcd(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::cauchy_index_on_edge(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::classify_fraction_factor(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::collect_fraction_terms(), collect_vertical_asymptotes(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::combine(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::combine_fraction_terms(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::construct_roots(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::count_sheared_edges(), LMCAS::DifferentiationVisitor::differentiate_atan2(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::distinct_denominator_product(), div(), div(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::divide(), LMCAS::detail::matrix_kernel::exact_divide(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::exact_poly_divide(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::exact_rational_square_root(), extract_laurent_regular_part(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::filter_denominators(), implicit_diff(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_even_case(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_odd_case(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::left_pole_sample(), log10(), normalization_exact_square_root(), normalization_pi_function(), LMCAS::NormalizationVisitor::normalize_logarithm(), LMCAS::ode_root_detail::Complex::operator/(), parse_fraction(), 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::anonymous_namespace{exact_sturm.cpp}::polynomial_sign_at(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::product_bounds(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::protected_coordinate_intersection(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::prove(), LMCAS::anonymous_namespace{query_conditions.cpp}::quotient_conditions(), LMCAS::InferenceEngine::Impl::quotient_sign(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::rational(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points(), rational_reconstruction_checked(), rational_root_candidate(), LMCAS::detail::rational_square_root(), LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_fraction_term(), LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_quadratic_logarithm(), LMCAS::detail::definite::recover_rational_cut(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::refine_pole_interval(), LMCAS::Irrational::EnclosureRound::refine_sign(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::register_canonical_radical(), LMCAS::detail::definite::roots_checked(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::same_denominators(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::separate_num_den(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_winding.cpp}::shear_is_valid(), solve_symbolic_quadratic(), LMCAS::detail::NumericEvaluator::square_root(), sym_rational(), te_abs_fourier(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign_impl(), vector_angle_checked(), verified_quadratic_boundaries(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_reduce_rational(), z_transform_core(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::zero_numerator_domain(), zt_exponential(), zt_polynomial() , 以及 zt_trigonometric().

depth

std::size_t std::size_t LMCAS::depth

在文件 equivalence_options.hpp 第 44 行定义.

被这些函数引用 LMCAS::InferenceEngine::Impl::add_deduced(), LMCAS::InferenceEngine::Impl::deduce_function_relation(), LMCAS::InferenceEngine::Impl::deduce_power_relations(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::emit(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_operands(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_polynomial_nodes(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::infer(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::node(), LMCAS::assumption_detail::AssumptionParser::parse_monotonicity(), LMCAS::detail::refine_exact_real_algebraic_to_tolerance(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::search_dyadic_scale(), set_eqv_budget(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_function_pattern(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inverted_values(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl() , 以及 LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::unwrap_parenthesized().

dim

double int LMCAS::dim

初始值:

            = 2
)

在文件 symbolic_matrix.hpp 第 130 行定义.

被这些函数引用 christoffel_first_kind_checked(), christoffel_second_kind_checked(), christoffel_second_kind_impl(), curve_integral_scalar(), curve_integral_vector(), matrix_reflection_checked(), matrix_reflection_checked(), matrix_rotation_checked(), matrix_rotation_checked(), matrix_scaling_checked(), matrix_scaling_checked(), riemann_curvature_tensor_checked() , 以及 LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_index().

direction

const std::string const LimitExprPtr LimitDirection LMCAS::direction = LimitDirection::Both

在文件 limit_result.hpp 第 30 行定义.

被这些函数引用 LMCAS::expr_detail::ExprParser::apply_limit(), LMCAS::detail::definite::boundary_value_checked(), directional_derivative(), directional_derivative_checked(), directional_derivative_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), limit_checked(), limit_checked(), limit_expression_checked(), limit_expression_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_real_at_point(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::search_dyadic_scale(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

display_unit

std::string LMCAS::display_unit

在文件 expr.hpp 第 166 行定义.

被这些函数引用 attach_unit(), convert_to_unit_definition(), convert_unit() , 以及 with_unit_definition().

domain

const std::string const LimitExprPtr LimitDirection Domain LMCAS::domain = Domain::Real)

在文件 expr.hpp 第 378 行定义.

被这些函数引用 LMCAS::NormalizationVisitor::NormalizationVisitor(), 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::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_punctured_domain(), domain_contains(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_complex(), 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_negative_integer_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_node(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_number(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_operands(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_positive_integer_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_rank(), domain_requires_real(), LMCAS::property_detail::domain_str(), exact_radical_domain_excludes(), exact_rational_domain_excludes(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::exact_sqrt_contains(), expr_set_subset_domain(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::factors_defined(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::finish(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), limit_checked(), limit_checked(), limit_expression_checked(), limit_expression_checked(), normalization_can_discard(), numeric_domain_excludes(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit(), LMCAS::anonymous_namespace{residual_comparison.cpp}::pointwise_values_defined(), solution_is_excluded(), solve_with_assumptions_impl(), LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::RewriteVisitor::visit() , 以及 LMCAS::RewriteVisitor::visit().

element

const ExprPtr & LMCAS::element

在文件 expr.hpp 第 368 行定义.

被这些函数引用 LMCAS::FiniteSetNode::canonicalize(), LMCAS::FiniteSetNode::clone(), LMCAS::FiniteSetNode::compute_hash(), LMCAS::FiniteSetNode::contains(), domain_contains(), LMCAS::anonymous_namespace{symbolic_set.cpp}::exact_interval_membership(), expr_set_contains(), expr_set_not_contains(), expr_set_subset_domain(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::expr_detail::ExprParser::finite_set(), finite_set_difference(), finite_set_intersection(), make_finite_set(), make_membership(), member(), LMCAS::expr_detail::ExprParser::membership(), membership(), LMCAS::expr_detail::ExprParser::parse_set_literal(), LMCAS::NormalizationVisitor::scale_matrix(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit() , 以及 LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::ContainsImaginaryVisitor::visit().

exponent

const ExprPtr & LMCAS::exponent

在文件 expr.hpp 第 215 行定义.

被这些函数引用 LMCAS::detail::definite::absolute_argument(), accumulate_bernoulli_exponent(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::add_base(), LMCAS::anonymous_namespace{bigint_number_theory.cpp}::binary_modular_power(), LMCAS::anonymous_namespace{complex_analysis.cpp}::bounded_complex_power(), build_euler_solution(), calculus_utils_split_rational(), LMCAS::NormalizationVisitor::can_combine_nested_power(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_complex.cpp}::canonicalize_power(), LMCAS::anonymous_namespace{poly_utils.cpp}::check_power_coefficient_count(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::classify_fraction_factor(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_power(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_power(), LMCAS::detail::anonymous_namespace{facts_query_rational.cpp}::closed_rational_power(), collect_bernoulli_coefficients(), LMCAS::NormalizationVisitor::collect_expanded_product(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::collect_integer_power(), LMCAS::anonymous_namespace{limit_visitor_composition.cpp}::collect_log_power_factors(), LMCAS::InferenceEngine::Impl::collect_node_exponent(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::collect_polynomial_variables(), LMCAS::NormalizationVisitor::collect_product(), LMCAS::anonymous_namespace{normalization_products.cpp}::ProductAccumulator::collect_variables(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::convert(), LMCAS::SymbolicFactory::create_power(), denominator_factor(), LMCAS::detail::detect_binomial_power(), LMCAS::NormalizationVisitor::distribute_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_fractional_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_power(), essential_exponent(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_exponent(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_power(), LMCAS::InferenceEngine::Impl::even_power_sign(), LMCAS::detail::exact_double_rational(), exact_scalar_radicand(), extract_bernoulli_factor(), extract_bernoulli_monomial(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl(), LMCAS::fglm_detail::generate_degree(), LMCAS::anonymous_namespace{fglm.cpp}::generate_standard_degree(), geometric_term_convergence(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_basis.cpp}::initialize_sugar(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::integer_numeric_power(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::integer_power(), LMCAS::InferenceEngine::Impl::integer_power_sign(), LMCAS::InferenceEngine::Impl::integral_power_domain(), LMCAS::detail::integrate_power_primitive(), integrating_factor_from_antiderivative(), integration_bounded_exponent(), LMCAS::anonymous_namespace{integration_by_parts.cpp}::integration_by_parts_score(), inverse_fourier_transform_core(), is_alternating_factor(), is_bernoulli_ode(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::is_half_exponent(), LMCAS::fglm_detail::anonymous_namespace{fglm_dimension.cpp}::is_pure_power(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::is_undefined_zero_power(), LMCAS::detail::series_support::laurent_power_of_power(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::multiply(), LMCAS::anonymous_namespace{irrational_representation.cpp}::named_power(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::nonintegral_domain(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::nonintegral_power(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::nonintegral_value(), LMCAS::InferenceEngine::Impl::nonzero_power_sign(), normalization_imaginary_power(), normalization_numeric_power(), LMCAS::NormalizationVisitor::normalize_nested_imaginary_power(), LMCAS::NormalizationVisitor::normalize_nested_power(), LMCAS::NormalizationVisitor::normalize_power_identity(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::anonymous_namespace{normalization_norms.cpp}::normalized_norm_argument(), LMCAS::expr_detail::ExprParser::parse_power(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::parse_surd_power(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::polynomial_exponent(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::polynomial_sign_at(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::positive_denominator_exponent(), LMCAS::InferenceEngine::Impl::positive_integer_power_sign(), pow(), pow(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::power(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::power(), LMCAS::detail::NumericEvaluator::power(), LMCAS::Irrational::EnclosureRound::power(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::power_bounds(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::power_candidate(), LMCAS::anonymous_namespace{limit_result.cpp}::power_continuous_structure(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_builder.cpp}::power_degrees_fit(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::power_is_imaginary(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::power_pattern(), power_term_convergence(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::power_to_polynomial(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::product_bounds(), LMCAS::anonymous_namespace{query_conditions.cpp}::product_conditions(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::quantity(), quantity_power(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::radical_radicand(), LMCAS::detail::definite::rational_power_checked(), LMCAS::anonymous_namespace{symbolic_ode.cpp}::reciprocal_on_regular_region(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_power(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::reduce_radicals(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::register_new_atom(), LMCAS::anonymous_namespace{residual_verification.cpp}::replace_root_power(), restore_main_exponent(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::rewrite_square_absolute(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), separable_reciprocal(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_inv_ln_var(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_inv_var(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::small_exact_power(), LMCAS::InferenceEngine::Impl::small_positive_exponent(), solve_bernoulli_ode_impl(), solve_product_factor(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), sqrt(), LMCAS::detail::anonymous_namespace{squared_norm.cpp}::square_root_argument(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::squared_profile(), LMCAS::detail::anonymous_namespace{squared_norm.cpp}::squared_term(), LMCAS::anonymous_namespace{irrational_symbolic.cpp}::symbolic_named_power(), symbolic_power_to_poly(), symbolic_to_poly_recursive(), te_convolve_core(), te_gaussian_fourier(), te_inv_power(), te_is_denominator_factor(), tf_power_degree(), LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_half_exponent(), LMCAS::anonymous_namespace{integration_trig_substitution.cpp}::trigsub_match_radical(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit(), LMCAS::anonymous_namespace{limit_result.cpp}::SideBranchRewriter::visit(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::zero_base_power_value(), zt_is_exp_seq() , 以及 zt_polynomial_pattern().

growth

std::size_t std::size_t std::size_t LMCAS::growth

在文件 equivalence_options.hpp 第 45 行定义.

被这些函数引用 LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arithmetic() , 以及 set_eqv_budget().

imag

ExprPtr LMCAS::imag

在文件 expr.hpp 第 144 行定义.

被这些函数引用 abs(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::approx_complex(), calculus_utils_extract_real_candidate(), LMCAS::equivalence_detail::canonicalize_complex_product(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::checked_complex(), complex(), complex_div_checked(), complex_exp_form_checked(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::complex_facts(), complex_mul_checked(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::construct_roots(), LMCAS::SymbolicFactory::create_complex(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_complex(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_components(), LMCAS::equivalence_detail::exact_integer_node(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), imag(), imag(), make_complex(), LMCAS::NormalizationVisitor::merge_complex_terms(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalized_root(), LMCAS::equivalence_detail::rewrite_exp_log_basic_identity(), LMCAS::equivalence_detail::rewrite_trig_basic_identity(), LMCAS::equivalence_detail::rewritten_complex(), LMCAS::detail::SymbolicRewriter::visit() , 以及 LMCAS::RewriteVisitor::visit().

integer

template<typename Integer, std::enable_if_t< std::is_integral_v< Integer > &&!std::is_same_v< Integer, int >, int > = 0>

ExprResult LMCAS::integer(Integer)=delete ( Integer )

delete

被这些函数引用 LMCAS::InferenceEngine::Impl::absolute_domain(), LMCAS::anonymous_namespace{complex_analysis.cpp}::bounded_complex_power(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_power(), classify_ratio_limit(), LMCAS::anonymous_namespace{normalization_products.cpp}::collectable_power_exponent(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::double_angle_multiple(), eq(), LMCAS::detail::exact_rational_value(), LMCAS::detail::anonymous_namespace{numeric_evaluation_power.cpp}::exponent_parity(), geometric_term_convergence(), get_pi_coeff(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::half_numeric_power(), imaginary_unit(), integer(), integer(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::integer_complex_power(), LMCAS::detail::series_support::integer_value_from_node(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::integral_power(), LMCAS::anonymous_namespace{integration_linearity.cpp}::integration_exponential_argument(), LMCAS::NumberNode::is_negative_one(), neg(), normalization_exact_square_root(), normalization_numeric_power(), LMCAS::NormalizationVisitor::normalize_nested_imaginary_power(), LMCAS::NormalizationVisitor::normalize_product_power(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::number_equals_integer(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::numeric_absolute(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::polynomial_exponent(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::positive_denominator_exponent(), LMCAS::anonymous_namespace{normalization_signs.cpp}::positive_negative_number(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::power(), LMCAS::detail::NumericEvaluator::power(), LMCAS::anonymous_namespace{limit_result.cpp}::power_continuous_structure(), power_term_convergence(), LMCAS::InferenceEngine::Impl::query_rational(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::reciprocal_exact_number(), LMCAS::detail::RewriteBudget::Measurement::require_bits(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_number_sign(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::small_exact_power(), LMCAS::detail::NumericEvaluator::square_root(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::square_root_is_imaginary(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_periodic_values(), try_get_integer_value(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit(), LMCAS::detail::RewriteBudget::Measurement::visit() , 以及 zt_polynomial_pattern().

integrator

const std::vector<IntegrationStep> Integrator& LMCAS::integrator

在文件 multiple_integral.hpp 第 18 行定义.

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::accumulate_segments(), add_fourier_harmonic(), calculus_utils_try_symbolic_definite(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::definite_integral_geometry_checked(), divergence_theorem(), find_integrating_factor_impl(), fourier_constant_coefficient(), fourier_harmonics(), fourier_series_checked(), greens_theorem(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), integrate_multiple_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), integrating_factor_from_ratio(), solve_bernoulli_ode_impl(), solve_exact_ode_impl(), solve_homogeneous_ode_impl(), solve_linear1_ode(), solve_separable_ode(), solve_variation_of_parameters_core(), stokes_theorem(), surface_integral_scalar(), surface_integral_vector(), vector_calculus_multiple_integral_strict() , 以及 vector_calculus_try_definite().

kEquivalentOperation

const char* LMCAS::kEquivalentOperation = "LMCAS.equivalent"

inlineconstexpr

在文件 equivalence_engine.hpp 第 9 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expr_errors.cpp}::equivalence_error_name(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::equivalent_with_budget(), LMCAS::equivalence_detail::expand_equivalence(), LMCAS::equivalence_detail::normalize_equivalence(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), LMCAS::equivalence_detail::prove_rational_polynomial_equivalence() , 以及 LMCAS::equivalence_detail::validate_eqv_options().

kEquivalentProfileOperation

const char* LMCAS::kEquivalentProfileOperation

inlineconstexpr

初始值:

                                                    =
"LMCAS.equivalent.profile"

在文件 equivalence_engine.hpp 第 10 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expr_errors.cpp}::equivalence_error_name() , 以及 LMCAS::anonymous_namespace{equivalence_options.cpp}::eqv_profile_failure().

kEvalComplexOperation

const char* LMCAS::kEvalComplexOperation = "LMCAS.eval_complex"

inlineconstexpr

在文件 expr_internal.hpp 第 16 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::add_complex(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex(), error_name(), eval_complex(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::eval_complex_failure(), 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::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_power(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::integer_complex_power(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex() , 以及 LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::real_to_complex().

kExprSetOperation

const char* LMCAS::kExprSetOperation = "LMCAS.expr_set"

inlineconstexpr

在文件 expr_internal.hpp 第 14 行定义.

被这些函数引用 error_name(), expr_set(), expr_set_contains(), expr_set_difference(), expr_set_intersection(), expr_set_symmetric_difference() , 以及 expr_set_union().

kParseOperation

const char* LMCAS::expr_detail::kParseOperation

inlineconstexpr

在文件 expr_parser.hpp 第 12 行定义.

被这些函数引用 parse_expr().

kSolveExprSetOperation

const char* LMCAS::kSolveExprSetOperation = "LMCAS.solve_expr_set"

inlineconstexpr

在文件 expr_internal.hpp 第 15 行定义.

被这些函数引用 error_name() , 以及 project_finite_expr_set().

l2

const LineSymbolic & LMCAS::l2

在文件 symbolic_geometry_line_plane.hpp 第 96 行定义.

被这些函数引用 skew_lines_distance_checked() , 以及 skew_lines_distance_checked().

lift_bound

const std::vector<Polynomial<ModInt> > int64_t int LMCAS::lift_bound

在文件 exact_factorization.hpp 第 51 行定义.

被这些函数引用 hensel_lift_checked().

lifted_factors

const std::vector< Polynomial< BigInt > > & LMCAS::lifted_factors

在文件 exact_factorization.hpp 第 63 行定义.

被这些函数引用 hl_multi_factor_lift(), zassenhaus_combine_checked(), zassenhaus_combine_checked(), zassenhaus_combine_impl(), zc_enumerate(), zc_subset_product() , 以及 zc_validate_lifted_product().

lower

const ExprPtr & LMCAS::lower

在文件 expr.hpp 第 255 行定义.

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::DefiniteInterval::DefiniteInterval(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::SegmentFacts(), adaptive_simpson_numeric(), adaptive_simpson_numeric(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_component(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::approximate_root(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_bounds(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_endpoint(), bisection_checked(), bisection_checked(), LMCAS::detail::definite::certify_continuity_checked(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::certify_dyadic_candidate(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::checked_interval_views(), clamp(), clamp(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::closed_bounds(), LMCAS::anonymous_namespace{interval_normalization.cpp}::collect_nonempty_intervals(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::complement_lower_from_upper(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::complement_upper_from_lower(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::count_open_roots(), LMCAS::detail::count_real_roots_exact(), LMCAS::detail::definite::definite_partition_checked(), LMCAS::detail::definite::definite_segment_checked(), LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::eliminate_lu_column(), LMCAS::detail::anonymous_namespace{mixed_transcendental_refinement.cpp}::RootRefinement::endpoint_root(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_interval(), LMCAS::anonymous_namespace{symbolic_set.cpp}::exact_interval_membership(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::exact_polynomial_sign_intervals(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::factor_lu(), LMCAS::solver_detail::finite_midpoint(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), LMCAS::expr_detail::ExprParser::interval(), interval(), interval(), interval_contains_checked(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::interval_delimiters_valid(), interval_is_empty_checked(), interval_to_expr(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::lambert_w_domain(), LMCAS::InferenceEngine::Impl::logarithm_monotonicity(), make_interval(), LMCAS::expr_detail::ExprParser::parse_interval_literal(), parse_interval_lower(), parse_single_interval(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::projection_bands(), quadrature_gaussian_numeric(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), quadrature_simpson_numeric(), LMCAS::Irrational::EnclosureRound::radical(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_bounds(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_endpoint_bound(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), LMCAS::detail::definite::segment_expression_checked(), LMCAS::Irrational::EnclosureRound::separated_sign(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial(), LMCAS::anonymous_namespace{interval_normalization.cpp}::sort_checked_intervals(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::sum_bounds(), symbolic_product(), symbolic_sum(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::anonymous_namespace{integration_definite.cpp}::unresolved_integral(), valid_newton_bracket(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::validate_geometry_inputs(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::validate_interval_endpoints(), LMCAS::anonymous_namespace{numerical_integration.cpp}::validate_quadrature_args(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), 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::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit() , 以及 LMCAS::RewriteVisitor::visit().

lower_closed

__attribute__((visibility("default"))) ExprResult finite_set(std const ExprPtr bool LMCAS::lower_closed

在文件 expr.hpp 第 149 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::expr_detail::ExprParser::interval(), interval(), interval(), make_interval() , 以及 LMCAS::expr_detail::ExprParser::parse_interval_literal().

main_var

const std::string & LMCAS::main_var

在文件 multivariate_factor.hpp 第 67 行定义.

被这些函数引用 collect_gcd_samples(), diophantine_target(), extended_gcd_interpolation(), extract_coefficients(), formal_derivative(), lagrange_interpolate(), multivariate_content(), multivariate_hensel_lift(), multivariate_primitive_part(), recursive_multivariate_gcd(), LMCAS::multivariate_checked_detail::restore_specialization_unit(), square_free_decompose() , 以及 tf_convert_main_variable().

mod_factors

const std::vector<Polynomial<ModInt> >& LMCAS::mod_factors

在文件 exact_factorization.hpp 第 49 行定义.

被这些函数引用 hensel_lift_checked().

MODULAR_PRIMES

int64_t LMCAS::MODULAR_PRIMES[]

constexpr

初始值:

                                 = {
    1000000007, 1000000009, 1000000021, 1000000033,
    1000000087, 1000000093, 1000000097, 1000000103,
    1000000123, 1000000181, 1000000207, 1000000223,
    1000000231, 1000000271, 1000000289, 1000000297
}

预定义的大素数表，用于模运算多素数方案

在文件 modular_arithmetic.hpp 第 458 行定义.

name

__attribute__((visibility("default"))) Result< EqvProfile > eqv_profile_from_name(const std const std::string& LMCAS::name

在文件 equivalence_options.hpp 第 41 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeVariableFinder::FreeVariableFinder(), LMCAS::expr_detail::ExprParser::apply_function(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), LMCAS::anonymous_namespace{quantity.cpp}::checked_binary(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::compound_node(), LMCAS::detail::constant_expression(), LMCAS::SymbolicFactory::create_variable(), LMCAS::property_detail::domain_str(), eqv_profile_from_name(), LMCAS::anonymous_namespace{assumption_conditionals.cpp}::evaluate_symbol_sign(), expr_match(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), find_extrema_impl(), LMCAS::expr_detail::anonymous_namespace{expr_parser_functions.cpp}::find_unary_function(), function(), LMCAS::expr_detail::ExprParser::function_node(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::independent(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeVariableCollector::is_bound(), LMCAS::detail::is_imaginary_unit_name(), LMCAS::expr_detail::expr_common::is_reserved_symbol_name(), lookup_integral(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::make_variables(), match_recursive(), LMCAS::anonymous_namespace{irrational_representation.cpp}::named_power(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::node(), LMCAS::expr_detail::ExprParser::parse_call(), LMCAS::expr_detail::ExprParser::parse_identifier_or_call(), LMCAS::assumption_detail::AssumptionParser::parse_record(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::quantity(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::root_of(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::select_equation(), set_eqv_profile(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::solve(), solve_lagrange_strict(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), sym(), LMCAS::anonymous_namespace{irrational_symbolic.cpp}::symbolic_named_power(), LMCAS::expr_detail::ExprParser::uninterpreted_function(), LMCAS::anonymous_namespace{unit.cpp}::valid_unit_name(), LMCAS::anonymous_namespace{symbolic_complex.cpp}::validate_complex_symbolic(), LMCAS::detail::matrix_decomposition::validate_decomposition_output(), LMCAS::anonymous_namespace{symbolic_complex.cpp}::validate_expr(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_index(), LMCAS::detail::series_support::validate_power_series_coefficients(), LMCAS::geometry_detail::validate_symbolic_vector(), verify_lagrange_solutions(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit() , 以及 wildcard().

negated

const ExprPtr bool LMCAS::negated = false)

在文件 expr.hpp 第 161 行定义.

被这些函数引用 LMCAS::expr_detail::ExprParser::membership() , 以及 membership().

NUM_MODULAR_PRIMES

size_t LMCAS::NUM_MODULAR_PRIMES = sizeof(MODULAR_PRIMES) / sizeof(MODULAR_PRIMES[0])

constexpr

预定义素数表的长度

在文件 modular_arithmetic.hpp 第 465 行定义.

op

const ExprPtr RelationOp LMCAS::op

在文件 expr.hpp 第 151 行定义.

被这些函数引用 LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::binary_logical_truth(), LMCAS::calculus_utils_detail::calculus_utils_is_infinity(), LMCAS::AddNode::clone(), LMCAS::MultiplyNode::clone(), LMCAS::anonymous_namespace{limit_visitor_composition.cpp}::collect_log_power_factors(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::collect_transcendental_subexprs(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::compound_node(), LMCAS::AddNode::compute_hash(), LMCAS::MultiplyNode::compute_hash(), LMCAS::SymbolicFactory::create_add(), LMCAS::SymbolicFactory::create_multiply(), LMCAS::anonymous_namespace{relation_store.cpp}::declare_comparison_sign(), LMCAS::anonymous_namespace{relation_store.cpp}::derive_comparison_sign(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::equality_condition_truth(), LMCAS::anonymous_namespace{assumption_conditionals.cpp}::evaluate_symbol_sign(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::extract_linear_coefficient(), factor_common_polynomial(), get_node_degree_helper(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::has_exp_k_var_terms(), interval_to_expr(), inverse_fourier_transform_core(), inverse_laplace_core(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::is_poly_expr_node(), LMCAS::solver_detail::is_polynomial_node(), LMCAS::anonymous_namespace{relation_store.cpp}::is_transitive_op(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::logical(), LMCAS::expr_detail::ExprParser::logical(), LMCAS::anonymous_namespace{expr_facade.cpp}::logical_expression(), make_normalized_multiply_node(), LMCAS::solver_detail::multiply_no_expand(), LMCAS::AddNode::normalize_operands(), LMCAS::MultiplyNode::normalize_operands(), LMCAS::expr_detail::ExprParser::parse_equality(), LMCAS::expr_detail::ExprParser::parse_relational(), polynomial_logic(), polynomial_relation(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_rational(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_sum(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::relation(), relation(), LMCAS::expr_detail::ExprParser::relational(), LMCAS::anonymous_namespace{assumption_serialization.cpp}::relop_to_string(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::SubstNodeVisitor::replace(), LMCAS::detail::reversed_relation(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::rewrite_exp_as_u_power(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::sign_condition(), LMCAS::anonymous_namespace{complex_analysis.cpp}::split_real_imag(), symbolic_node_to_multipoly(), te_inv_product(), LMCAS::transform_detail::te_split_coeff(), tf_collect_transcendental(), tf_degree_in(), tf_detect_exponential_separation(), tf_detect_multiplicative_structure(), tf_extract_exp_factor(), tf_remove_exp_factor(), tf_simplify_pythagorean_node(), tf_substitute_expr(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::visit(), LMCAS::DifferentiationVisitor::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::ContainsImaginaryVisitor::visit(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::ContainsImaginaryVisitor::visit(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_has_trig_of_var(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_is_rational_trig(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_replace() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational().

options

const ExprPtr ComputationContext const LMCAS::EqvOptions & LMCAS::options = {})

在文件 expr.hpp 第 355 行定义.

被这些函数引用 __attribute__(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::apply_root_representation_policy(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), bisection_checked(), bisection_checked(), check_equivalent(), check_zero_residual(), equivalent(), LMCAS::detail::equivalent_impl(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::equivalent_with_budget(), LMCAS::detail::evaluate_root_complex(), LMCAS::detail::evaluate_root_real(), LMCAS::equivalence_detail::exact_integer_node(), LMCAS::detail::finalize_solution_set(), LMCAS::anonymous_namespace{newton_raphson.cpp}::invalid_root_options(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), project_finite_expr_set(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_checked_operands(), 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::detail::refine_complex_isolation(), LMCAS::anonymous_namespace{newton_raphson.cpp}::root_config(), roots(), roots(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_newton_backend(), set_eqv_budget(), set_eqv_profile(), solve(), solve(), solve_expr_set(), solve_expr_set(), solve_finite_checked(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_function_pattern(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inverted_values(), solve_numeric_checked(), solve_product_factor(), solve_product_set(), solve_set(), solve_set(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution(), solve_transcendental(), solve_transcendental(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_transcendental_impl(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::valid_options() , 以及 LMCAS::equivalence_detail::validate_eqv_options().

order

const std::vector<FGLMPoly> const MonomialOrder& LMCAS::order

在文件 fglm.hpp 第 103 行定义.

被这些函数引用 LMCAS::fglm_detail::MonomialEnumerator::MonomialEnumerator(), assemble_frobenius_polynomial(), asymptotic_expand(), calculate_residue_checked(), calculate_residue_checked(), calculate_residue_impl(), composition_inner_powers(), LMCAS::anonymous_namespace{fglm.cpp}::dependent_polynomial(), directional_derivative(), directional_derivative_checked(), directional_derivative_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), lie_derivative_checked(), lie_derivative_checked(), lie_derivative_impl(), normal_form(), ordinary_series_recurrence(), ordinary_taylor_coefficients(), power_series_compose_checked(), power_series_compose_checked(), power_series_multiply_checked(), power_series_multiply_checked(), LMCAS::anonymous_namespace{matrix_decomposition_qr.cpp}::prove_exact_full_column_rank_qr_support(), LMCAS::anonymous_namespace{matrix_decomposition_cholesky.cpp}::prove_exact_spd(), quadrature_gaussian_numeric(), quadrature_gaussian_numeric(), LMCAS::anonymous_namespace{fglm_polynomial.cpp}::reduce_leading_term(), residue_checked(), residue_checked(), singular_series_recurrence(), singular_taylor_coefficients(), solve_frobenius_checked(), solve_frobenius_checked(), solve_frobenius_impl(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::sort_exact_inequality_roots(), LMCAS::anonymous_namespace{fglm_polynomial.cpp}::subtract_leading_multiple(), LMCAS::anonymous_namespace{complex_analysis.cpp}::validate_complex_expr_point_input(), LMCAS::anonymous_namespace{series_engine.cpp}::validate_power_series_order(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

p2

const PlaneSymbolic & LMCAS::p2

在文件 symbolic_geometry_line_plane.hpp 第 162 行定义.

被这些函数引用 LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::append_scaled_plane_edges(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::append_symbolic_plane_edges(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::build_plane_edges(), dihedral_angle_checked(), dihedral_angle_checked(), line_from_two_points_checked(), line_from_two_points_checked(), plane_from_three_points_checked(), plane_from_three_points_checked(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::plane_point_differences_overflow(), LMCAS::anonymous_namespace{symbolic_geometry_line.cpp}::point_difference_scale_checked() , 以及 LMCAS::polynomial_solver_detail::symbolic_quartic_roots().

parametrization

const std::vector< std::string > const VectorField & LMCAS::parametrization

在文件 vector_calculus_curves.hpp 第 49 行定义.

被这些函数引用 curve_integral_scalar(), curve_integral_scalar_checked(), curve_integral_scalar_checked(), LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), curve_integral_vector(), curve_integral_vector_checked(), curve_integral_vector_checked(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), greens_theorem_area(), greens_theorem_area_checked(), greens_theorem_area_checked(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), vector_calculus_cross_product_partials_strict(), vector_calculus_surface_dot_strict(), 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_surface_parametrization(), LMCAS::vector_calculus_detail::vector_calculus_validate_surface_scalar_inputs() , 以及 LMCAS::vector_calculus_detail::vector_calculus_validate_surface_vector_inputs().

plane

const PlaneSymbolic & LMCAS::plane

在文件 symbolic_geometry_line_plane.hpp 第 52 行定义.

被这些函数引用 LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::assemble_plane(), line_plane_intersection_checked(), line_plane_intersection_checked(), point_plane_distance_checked(), point_plane_distance_checked(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::scaled_tangent_plane(), tangent_plane_checked(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::validate_intersection_inputs() , 以及 LMCAS::geometry_detail::validate_plane_checked().

point

const std::vector< std::shared_ptr< SymbolicExpr > > & LMCAS::point

在文件 limit_result.hpp 第 29 行定义.

被这些函数引用 LMCAS::anonymous_namespace{solve_transcendental.cpp}::append_parametric_union(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::assemble_plane(), LMCAS::detail::definite::boundary_value_checked(), collect_vertical_asymptotes(), continuity_at_checked(), continuity_at_checked(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_from_limits(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), LMCAS::anonymous_namespace{limit_result.cpp}::continuous_function_branch(), double_root_inequality_intervals(), LMCAS::anonymous_namespace{limit_result.cpp}::elementary_continuous_structure(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::evaluate_polynomial_double(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), extract_laurent_regular_part(), find_extrema_impl(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::include_rational_zeros(), inflection_curve_defined(), interval_contains_checked(), inverse_derivative_checked(), inverse_derivative_checked(), is_vertical_asymptote(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), limit_checked(), limit_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), limit_expression_checked(), limit_expression_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_real_at_point(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit(), point_plane_distance_checked(), point_plane_distance_checked(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::polynomial_sign_at(), LMCAS::anonymous_namespace{limit_result.cpp}::power_continuous_structure(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::anonymous_namespace{symbolic_geometry_surface.cpp}::surface_gradient_at_point_checked(), surface_normal_checked(), surface_normal_checked(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_point_plane_distance(), tangent_plane_checked(), tangent_plane_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input(), LMCAS::geometry_detail::validate_surface_point(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::variations_at(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::vector_calculus_detail::vector_calculus_point_has_vars(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit() , 以及 LMCAS::RewriteVisitor::visit().

prime

const std::vector< Polynomial< ModInt > > int64_t LMCAS::prime

在文件 exact_factorization.hpp 第 38 行定义.

被这些函数引用 berlekamp_factor(), LMCAS::berlekamp_detail::bk_is_suitable_prime(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_bound(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_reduction(), generate_good_primes(), hensel_lift_checked(), hl_compute_lift_height(), hl_multi_factor_lift() , 以及 hl_validate_lift_inputs().

r

std::shared_ptr< SymbolicExpr > LMCAS::r

在文件 symbolic_complex.hpp 第 209 行定义.

被这些函数引用 LMCAS::ComplexNode::ComplexNode(), LMCAS::LogicalNode::LogicalNode(), LMCAS::MatrixNode::MatrixNode(), LMCAS::MatrixNode::MatrixNode(), LMCAS::RelationalNode::RelationalNode(), LMCAS::berlekamp_detail::bk_div_mod(), LMCAS::berlekamp_detail::bk_gcd_mod(), LMCAS::berlekamp_detail::bk_poly_mul_mod(), LMCAS::berlekamp_detail::bk_poly_pow_mod(), complex_exp_form_checked(), complex_exp_form_checked(), complex_locus_circle_checked(), complex_locus_circle_checked(), complex_trig_form_checked(), complex_trig_form_checked(), LMCAS::MatrixNode::create_storage_from_grid(), deduplicate_roots(), eliminate_parametric_column(), evaluated_lifting_cofactors(), extended_gcd(), extended_gcd_poly(), LMCAS::Polynomial< CoeffType >::gcd(), LMCAS::MatrixNode::get(), get_integer_value(), hl_extended_gcd_poly(), hl_poly_divmod(), hl_two_factor_lift(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), multivariate_diophantine(), multivariate_hensel_lift(), LMCAS::detail::definite::polynomial_sign_checked(), rational_root_factors(), rational_root_product(), LMCAS::anonymous_namespace{integration_rational_factorization.cpp}::rd_factor_piece(), LMCAS::anonymous_namespace{integration_rational_factorization.cpp}::rd_factor_quadratic(), LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_integrate_linear_term(), LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_var_minus(), recursive_multivariate_gcd(), LMCAS::groebner_detail::reduce(), LMCAS::polynomial_solver_detail::solve_by_factoring_impl(), LMCAS::Polynomial< CoeffType >::square_free_part(), LMCAS::polynomial_solver_detail::symbolic_quartic_depression(), LMCAS::polynomial_solver_detail::symbolic_quartic_roots(), tf_power_degree(), LMCAS::MatrixNode::validate_dense_storage(), LMCAS::MatrixNode::validate_sparse_storage(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit() , 以及 LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_to_rational().

reconstruction_modulus

const std::vector< Polynomial< BigInt > > const BigInt & LMCAS::reconstruction_modulus

在文件 exact_factorization.hpp 第 64 行定义.

被这些函数引用 zassenhaus_combine_checked(), zassenhaus_combine_checked() , 以及 zassenhaus_combine_impl().

rhs

const SymbolicExpr & LMCAS::rhs

在文件 expr.hpp 第 150 行定义.

被这些函数引用 LMCAS::NormalizationVisitor::NormalizationVisitor(), add(), add(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::add_complex(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::apply_profile(), LMCAS::ode_root_detail::approximate_polynomial_gcd(), LMCAS::anonymous_namespace{bigint_arithmetic.cpp}::bigint_mul(), LMCAS::FiniteSetNode::canonicalize(), LMCAS::anonymous_namespace{quantity.cpp}::checked_binary(), classify_first_order_ode(), LMCAS::NormalizationVisitor::collect_expanded_product(), LMCAS::MultiplyNode::compare_operands(), LMCAS::InferenceEngine::Impl::deduce_function_relation(), LMCAS::InferenceEngine::Impl::deduce_power_relations(), LMCAS::anonymous_namespace{relation_store.cpp}::derive_comparison_sign(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex(), domain_subset(), eq(), eq(), equivalent(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::equivalent_with_budget(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::NormalizationVisitor::expand_product(), expr_set_difference(), expr_set_intersection(), expr_set_subset(), expr_set_symmetric_difference(), expr_set_union(), finite_set_difference(), finite_set_intersection(), finite_set_symmetric_difference(), finite_set_union(), ge(), gt(), is_bernoulli_ode(), is_homogeneous_ode(), is_linear_first_order(), is_separable(), le(), LMCAS::expr_detail::ExprParser::logical(), logical_and(), LMCAS::anonymous_namespace{expr_facade.cpp}::logical_expression(), logical_or(), lt(), LMCAS::expr_detail::expr_common::make_binary_expr(), LMCAS::expr_detail::expr_common::make_binary_math_expr(), matrix_solve_linear_checked(), mul(), mul(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::multiply_checked(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::multiply_intervals(), ne(), LMCAS::NodeCompare::operator()(), LMCAS::NodeEqual::operator()(), LMCAS::expr_detail::ExprParser::parse_additive(), LMCAS::expr_detail::ExprParser::parse_equality(), LMCAS::expr_detail::ExprParser::parse_logical_and(), LMCAS::expr_detail::ExprParser::parse_logical_or(), LMCAS::expr_detail::ExprParser::parse_membership(), LMCAS::expr_detail::ExprParser::parse_multiplicative(), LMCAS::expr_detail::ExprParser::parse_primary(), LMCAS::expr_detail::ExprParser::parse_relational(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prepare_operands(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_checked_operands(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), quantity_add(), quantity_divide(), quantity_multiply(), quantity_subtract(), relation(), LMCAS::expr_detail::ExprParser::relational(), solve_homogeneous_ode_checked(), solve_homogeneous_ode_checked(), solve_homogeneous_ode_impl(), solve_separable_ode(), structurally_equal(), sub(), sub(), sym_sub(), symbolic_polynomial_gcd(), LMCAS::transform_detail::te_gt_condition(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::verify_gcd_candidate() , 以及 LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::zero_numerator_domain().

right

const ExprPtr& LMCAS::right

在文件 residual_verification.hpp 第 50 行定义.

被这些函数引用 LMCAS::anonymous_namespace{symbolic_geometry_vector.cpp}::accumulate_angle_product(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::add(), LMCAS::anonymous_namespace{poly_utils.cpp}::add_checked_coefficients(), LMCAS::anonymous_namespace{fglm_polynomial.cpp}::add_monomials(), LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::append_symbolic_plane_edges(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::cartesian_add(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::cartesian_multiply(), check_equivalent(), LMCAS::anonymous_namespace{poly_utils.cpp}::checked_product_count(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::coalesce_periodic_pair(), LMCAS::anonymous_namespace{poly_utils.cpp}::coefficient_arithmetic(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::combine(), LMCAS::anonymous_namespace{limit_result.cpp}::combine_one_sided_limits(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::combine_surd_product(), LMCAS::detail::anonymous_namespace{interval_endpoint.cpp}::combine_surd_sum(), LMCAS::detail::ExactRootId::compare(), LMCAS::detail::definite::compare_boundaries(), LMCAS::detail::compare_comparable(), LMCAS::anonymous_namespace{residual_comparison.cpp}::compare_defined_values(), LMCAS::anonymous_namespace{symbolic_number_order.cpp}::compare_exact_nodes(), LMCAS::anonymous_namespace{symbolic_number_order.cpp}::compare_exact_to_rational(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::compare_isolations(), LMCAS::anonymous_namespace{symbolic_node_order.cpp}::compare_matrix_elements(), LMCAS::detail::compare_pointwise_values(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::compare_rationals(), LMCAS::NumberNode::compare_same_type(), LMCAS::anonymous_namespace{symbolic_number_order.cpp}::compare_values(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::compatible_periodic_conditions(), LMCAS::anonymous_namespace{limit_visitor_direction.cpp}::conjunctive_near_point_truth(), continuity_at_checked(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_from_limits(), LMCAS::anonymous_namespace{limit_visitor_direction.cpp}::disjunctive_near_point_truth(), LMCAS::NormalizationVisitor::distribute_product(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::divide_complex(), endpoints_equivalent(), eq(), LMCAS::detail::matrix_kernel::exact_add(), LMCAS::detail::matrix_kernel::exact_multiply(), LMCAS::detail::matrix_kernel::exact_subtract(), LMCAS::NormalizationVisitor::expand_complex_product(), LMCAS::NormalizationVisitor::expand_product(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::finish(), finite_set_difference(), finite_set_intersection(), finite_set_symmetric_difference(), finite_set_union(), LMCAS::NormalizationVisitor::fuse_matrix_product(), hl_coeff_vectors_equal(), LMCAS::detail::RewriteBudget::input_nodes(), intervals_equivalent(), intervals_overlap_checked_impl(), is_vertical_asymptote(), LMCAS::detail::complex_root::isolate_nonreal_roots(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::isolate_sturm_sequence(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_real_at_point(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::logical_condition_truth(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::logical_predicate_truth(), matrix_multiply_checked(), LMCAS::NormalizationVisitor::matrix_product_element(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::multiply(), LMCAS::anonymous_namespace{poly_utils.cpp}::multiply_checked_coefficients(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::multiply_complex(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::multiply_intervals(), LMCAS::anonymous_namespace{inference_engine_product.cpp}::multiply_sign_sets(), normalization_factor_less(), LMCAS::detail::definite::ordered_partition_roots(), LMCAS::anonymous_namespace{residual_comparison.cpp}::pointwise_values_defined(), polynomial_logic(), polynomial_product_fits(), polynomial_relation(), LMCAS::detail::definite::polynomial_sign_checked(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prepare_operands(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), quantity_add(), quantity_divide(), quantity_multiply(), quantity_subtract(), LMCAS::detail::definite::rational_pole_divergence(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::same_polynomial(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::separate_projection_intervals(), solve_equation(), solve_set_core(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::structural(), structurally_equal(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::subdivide_isolation(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::subtract(), LMCAS::anonymous_namespace{fglm_polynomial.cpp}::subtract_monomials(), LMCAS::anonymous_namespace{normalization_arithmetic.cpp}::sum_term_less(), LMCAS::anonymous_namespace{symbolic_algebra_adapter.cpp}::sylvester_matrix(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::sylvester_matrix(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::sylvester_resultant(), te_convolve_core(), tf_pair_constraint(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_cross_component(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_identity(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit() , 以及 LMCAS::anonymous_namespace{solve_transcendental.cpp}::zero_difference().

set

const ExprPtr & LMCAS::set

在文件 expr.hpp 第 161 行定义.

被这些函数引用 LMCAS::FiniteSetNode::compare_same_type(), expr_set_contains(), expr_set_not_contains(), expr_set_subset_domain(), make_membership(), member(), LMCAS::expr_detail::ExprParser::membership(), membership(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::NormalizationVisitor::visit() , 以及 LMCAS::RewriteVisitor::visit().

steps

const std::vector< IntegrationStep > & LMCAS::steps

在文件 equivalence_options.hpp 第 43 行定义.

被这些函数引用 divergence_theorem(), LMCAS::vector_calculus_detail::divergence_theorem_strict(), greens_theorem(), LMCAS::vector_calculus_detail::greens_theorem_strict(), integrate_multiple_checked(), LMCAS::anonymous_namespace{bigint_combinatorics.cpp}::reserve_product(), set_eqv_budget(), stokes_theorem(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), surface_integral_scalar(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), validate_integration_steps(), vector_calculus_multiple_integral_strict() , 以及 LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::verify_quadratic_boundary().

sy

double LMCAS::sy

在文件 symbolic_matrix.hpp 第 167 行定义.

被这些函数引用 matrix_scaling_checked() , 以及 matrix_scaling_checked().

t

const std::string & LMCAS::t

在文件 vector_calculus_curves.hpp 第 50 行定义.

被这些函数引用 LMCAS::FunctionNode::FunctionNode(), add_lagrange_value(), asymptotic_expand(), LMCAS::berlekamp_detail::bk_mod_inverse(), crt_checked(), curvature_parametric_checked(), curvature_parametric_checked(), curve_integral_scalar(), curve_integral_scalar_checked(), curve_integral_scalar_checked(), LMCAS::vector_calculus_detail::curve_integral_scalar_strict(), curve_integral_vector(), curve_integral_vector_checked(), curve_integral_vector_checked(), LMCAS::vector_calculus_detail::curve_integral_vector_strict(), extended_gcd(), extended_gcd_poly(), LMCAS::detail::extract_common_monomial(), fourier_transform_checked(), fourier_transform_checked(), fourier_transform_core(), greens_theorem_area(), greens_theorem_area_checked(), greens_theorem_area_checked(), LMCAS::vector_calculus_detail::greens_theorem_area_strict(), hl_multi_factor_lift(), hl_two_factor_lift(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_even_case(), LMCAS::ModInt::inverse(), inverse_fourier_transform_checked(), inverse_fourier_transform_checked(), inverse_fourier_transform_core(), inverse_laplace_checked(), inverse_laplace_checked(), inverse_laplace_core(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::is_periodic_func(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::is_transcendental_func(), laplace_transform_checked(), laplace_transform_checked(), LMCAS::transform_detail::laplace_transform_core(), LMCAS::groebner_detail::mul_poly_term(), LMCAS::anonymous_namespace{integration_rational_coefficients.cpp}::rd_factor_complements(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_fn_of_var(), LMCAS::anonymous_namespace{symbolic_geometry_line_plane.cpp}::symbolic_line_plane_intersection(), te_abs_decay(), te_extract_exp(), te_fourier_sum(), te_fourier_unevaluated(), te_inv_power(), te_inv_product(), te_laplace_lookup(), te_laplace_roc(), te_laplace_sum(), te_unevaluated_inv_laplace(), te_unevaluated_laplace(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), 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::anonymous_namespace{integration_weierstrass.cpp}::weier_replace_function().

target

const ExprPtr & LMCAS::target

在文件 expr.hpp 第 317 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::FreeSubstitution(), LMCAS::InferenceEngine::Impl::absolute_domain(), LMCAS::InferenceEngine::Impl::absolute_sign(), LMCAS::InferenceEngine::Impl::arctangent_domain(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_bound(), LMCAS::calculus_utils_detail::calculus_utils_validate_expr_target(), complementary_square(), convert_unit(), LMCAS::anonymous_namespace{query_conditions.cpp}::difference_conditions(), diophantine_target(), divides_monomial(), LMCAS::InferenceEngine::Impl::even_power_sign(), LMCAS::detail::exact_e_bounds(), LMCAS::InferenceEngine::Impl::exponential_domain(), LMCAS::InferenceEngine::Impl::exponential_sign(), expr_match(), expr_match(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::InferenceEngine::Impl::function_domain(), LMCAS::InferenceEngine::Impl::function_sign(), LMCAS::InferenceEngine::Impl::integer_power_sign(), LMCAS::InferenceEngine::Impl::integral_power_domain(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::inverse_trig(), LMCAS::InferenceEngine::Impl::known_sign(), LMCAS::InferenceEngine::Impl::logarithm_domain(), LMCAS::InferenceEngine::Impl::logarithm_sign(), match_function(), match_operation(), match_recursive(), LMCAS::InferenceEngine::Impl::multiply_domain(), multivariate_diophantine(), LMCAS::InferenceEngine::Impl::nonnegative_sign(), LMCAS::InferenceEngine::Impl::nonzero_power_sign(), LMCAS::InferenceEngine::Impl::operand_sign(), LMCAS::InferenceEngine::Impl::positive_integer_power_sign(), LMCAS::InferenceEngine::Impl::positive_power_sign(), LMCAS::anonymous_namespace{query_conditions.cpp}::product_conditions(), LMCAS::InferenceEngine::Impl::product_parity_sign(), LMCAS::InferenceEngine::Impl::product_relation_sign(), LMCAS::InferenceEngine::Impl::product_sign(), LMCAS::anonymous_namespace{query_conditions.cpp}::quotient_conditions(), LMCAS::InferenceEngine::Impl::quotient_sign(), record_remainder(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::reduce_above(), LMCAS::detail::anonymous_namespace{exact_rational_solve.cpp}::reduce_rational_pivot(), LMCAS::detail::reduce_rational_rows(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::select_equation(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::select_target(), LMCAS::anonymous_namespace{inference_engine_product.cpp}::sign_set(), LMCAS::detail::anonymous_namespace{exact_constant_bounds.cpp}::small_atan(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::solve(), solve_diophantine_pair(), LMCAS::InferenceEngine::Impl::square_root_domain(), LMCAS::InferenceEngine::Impl::square_root_sign(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::subtract_pivot_row(), LMCAS::InferenceEngine::Impl::subtraction_sign(), LMCAS::anonymous_namespace{query_conditions.cpp}::sum_conditions(), LMCAS::InferenceEngine::Impl::sum_relation_sign(), LMCAS::InferenceEngine::Impl::sum_sign(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::symbolic_determinant_value(), LMCAS::anonymous_namespace{query_conditions.cpp}::variable_operand_conditions(), LMCAS::anonymous_namespace{expression_analysis.cpp}::FreeSubstitution::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::InferenceEngine::Impl::weak_subtraction_sign() , 以及 LMCAS::InferenceEngine::Impl::zero_power_sign().

u

const std::vector< std::string > const VectorField const std::string & LMCAS::u

在文件 vector_calculus_surfaces.hpp 第 59 行定义.

被这些函数引用 gram_schmidt(), is_analytic_impl(), 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::polynomial_solver_detail::solve_biquadratic_impl(), stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitute_candidate(), LMCAS::anonymous_namespace{integration_substitution.cpp}::substitution_primitive(), surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), symbolic_cubic_roots(), LMCAS::polynomial_solver_detail::symbolic_quartic_roots(), symbolic_sum(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), vector_calculus_cross_product_partials_strict(), 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::DifferentiationVisitor::visit().

u_bounds

const std::vector< std::string > const VectorField const std::string const std::string const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > & LMCAS::u_bounds

在文件 vector_calculus_theorems.hpp 第 134 行定义.

被这些函数引用 stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

u_lower

const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > & LMCAS::u_lower

在文件 vector_calculus_surfaces.hpp 第 60 行定义.

被这些函数引用 surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), LMCAS::vector_calculus_detail::vector_calculus_coord_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().

u_upper

const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > & LMCAS::u_upper

在文件 vector_calculus_surfaces.hpp 第 60 行定义.

被这些函数引用 surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), LMCAS::vector_calculus_detail::vector_calculus_coord_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().

unit

const std::string & LMCAS::unit

在文件 expr.hpp 第 163 行定义.

被这些函数引用 attach_unit(), LMCAS::anonymous_namespace{univariate_factor_bridge.cpp}::bridge_lift_and_combine(), convert_to_unit(), LMCAS::multivariate_checked_detail::restore_specialization_unit(), LMCAS::multivariate_checked_detail::verify_linear_assignment() , 以及 with_unit().

upper

const ExprPtr const ExprPtr & LMCAS::upper

在文件 expr.hpp 第 148 行定义.

被这些函数引用 LMCAS::anonymous_namespace{integration_definite.cpp}::DefiniteInterval::DefiniteInterval(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::SegmentFacts(), adaptive_simpson_numeric(), adaptive_simpson_numeric(), alternating_sequence_bound(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_component(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::approximate_root(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_bounds(), bisection_checked(), bisection_checked(), LMCAS::detail::definite::certify_continuity_checked(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::certify_dyadic_candidate(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::checked_interval_views(), clamp(), clamp(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::closed_bounds(), LMCAS::anonymous_namespace{interval_normalization.cpp}::collect_nonempty_intervals(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::complement_lower_from_upper(), LMCAS::anonymous_namespace{interval_set_operations.cpp}::complement_upper_from_lower(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::count_open_roots(), LMCAS::detail::count_real_roots_exact(), LMCAS::detail::definite::definite_partition_checked(), LMCAS::detail::definite::definite_segment_checked(), LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::eliminate_lu_column(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_interval(), LMCAS::anonymous_namespace{symbolic_set.cpp}::exact_interval_membership(), LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::anonymous_namespace{matrix_decomposition_lu.cpp}::factor_lu(), LMCAS::solver_detail::finite_midpoint(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_interval_checked(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_ordered_interval(), LMCAS::anonymous_namespace{integration_definite.cpp}::integrate_segment_primitive(), LMCAS::expr_detail::ExprParser::interval(), interval(), interval(), interval_contains_checked(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::interval_delimiters_valid(), interval_is_empty_checked(), interval_to_expr(), make_interval(), LMCAS::expr_detail::ExprParser::parse_interval_literal(), parse_interval_upper(), parse_single_interval(), LMCAS::detail::definite::prepare_segment_primitive(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_rectangles.cpp}::projection_bands(), quadrature_gaussian_numeric(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), quadrature_simpson_numeric(), LMCAS::Irrational::EnclosureRound::radical(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_bounds(), LMCAS::detail::anonymous_namespace{exact_matrix.cpp}::reduce_above(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), LMCAS::detail::definite::segment_expression_checked(), sequence_extreme_limit(), LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::sum_bounds(), symbolic_product(), symbolic_sum(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::trigonometric_target_range(), LMCAS::anonymous_namespace{integration_definite.cpp}::unresolved_integral(), valid_newton_bracket(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::validate_geometry_inputs(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::validate_interval_endpoints(), LMCAS::anonymous_namespace{numerical_integration.cpp}::validate_quadrature_args(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), 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::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit(), LMCAS::RewriteVisitor::visit() , 以及 LMCAS::RewriteVisitor::visit().

upper_closed

__attribute__((visibility("default"))) ExprResult finite_set(std const ExprPtr bool bool LMCAS::upper_closed

在文件 expr.hpp 第 149 行定义.

被这些函数引用 LMCAS::anonymous_namespace{expr_serialization_reader.cpp}::Reader::extended_node(), LMCAS::expr_detail::ExprParser::interval(), interval(), interval(), make_interval() , 以及 LMCAS::expr_detail::ExprParser::parse_interval_literal().

v

const std::vector< std::string > const VectorField const std::string const std::string & LMCAS::v

在文件 vector_calculus_surfaces.hpp 第 59 行定义.

被这些函数引用 LMCAS::detail::SymbolicVisitor::DepthGuard::DepthGuard(), LMCAS::DifferentiationVisitor::DifferentiationVisitor(), LMCAS::ModInt::ModInt(), LMCAS::NumberNode::NumberNode(), LMCAS::NumberNode::NumberNode(), LMCAS::NumberNode::NumberNode(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::PeriodicCollector::PeriodicCollector(), LMCAS::groebner_detail::PolyBuilder::PolyBuilder(), LMCAS::groebner_detail::PolyBuilder::PolyBuilder(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::TranscendentalDetector::TranscendentalDetector(), LMCAS::fglm_detail::GaussianEliminator::add_vector(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_number(), LMCAS::anonymous_namespace{mixed_transcendental_classification.cpp}::degree_in_var(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::extract_exp_multiplier(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::extract_linear_coefficient(), gram_schmidt(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_sec_power(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::integrate_tan_power(), is_analytic_impl(), LMCAS::anonymous_namespace{solver_assumptions.cpp}::is_integer_value(), LMCAS::integration_table_detail::load_polynomial_rules(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::make_cos_scaled(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::make_sin_scaled(), LMCAS::anonymous_namespace{integration_rational_collection.cpp}::rd_collect_rational(), LMCAS::anonymous_namespace{integration_rational.cpp}::rd_integrate_polynomial(), LMCAS::anonymous_namespace{integration_rational_terms.cpp}::rd_var_minus(), LMCAS::anonymous_namespace{integration_special_functions.cpp}::sf_is_fn_of_var(), stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), symbolic_cubic_roots(), te_is_hyp(), te_is_power_of_var(), LMCAS::transform_detail::te_split_coeff(), tf_degree_in(), total_differential(), LMCAS::anonymous_namespace{integration_trigonometric.cpp}::trig_match_of_var(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials(), vector_calculus_cross_product_partials_strict(), vector_calculus_magnitude_squared(), 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::DifferentiationVisitor::visit().

v_bounds

const std::vector< std::string > const VectorField const std::string const std::string const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > & LMCAS::v_bounds

在文件 vector_calculus_theorems.hpp 第 135 行定义.

被这些函数引用 stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

v_lower

const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > & LMCAS::v_lower

在文件 vector_calculus_surfaces.hpp 第 61 行定义.

被这些函数引用 surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), LMCAS::vector_calculus_detail::vector_calculus_coord_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().

v_upper

const VectorField const std::string const std::string const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > const std::shared_ptr< SymbolicExpr > & LMCAS::v_upper

在文件 vector_calculus_surfaces.hpp 第 61 行定义.

被这些函数引用 surface_integral_scalar(), surface_integral_scalar_checked(), surface_integral_scalar_checked(), LMCAS::vector_calculus_detail::surface_integral_scalar_strict(), surface_integral_vector(), surface_integral_vector_checked(), surface_integral_vector_checked(), LMCAS::vector_calculus_detail::surface_integral_vector_strict(), LMCAS::vector_calculus_detail::vector_calculus_coord_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().

value

double LMCAS::value

在文件 expr.hpp 第 293 行定义.

被这些函数引用 LMCAS::SymbolicPolyCoeff::SymbolicPolyCoeff(), LMCAS::SymbolicPolyCoeff::SymbolicPolyCoeff(), LMCAS::SymbolicPolyCoeff::abs, LMCAS::modular_detail::abs_to_u64(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_symbolic_witness(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::accept_value(), accumulate_bernoulli_exponent(), add_lagrange_value(), LMCAS::anonymous_namespace{transcendental_rewrite.cpp}::FactorSimplification::append_number(), append_product_roots(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::approx_part(), approx_real(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_component(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::approximate_real_isolation(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::approximate_root(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::arctangent_endpoint(), LMCAS::detail::anonymous_namespace{assumption_simplification.cpp}::assumed_transform(), attach_unit(), attach_unit(), bernoulli_integer_exponent(), binding(), LMCAS::detail::definite::boundary_checked(), LMCAS::anonymous_namespace{differential_geometry.cpp}::bounded_binomial(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::certified_jordan(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::certify_dyadic_candidate(), LMCAS::anonymous_namespace{residual_verification.cpp}::check_residual_coefficient(), checked_derivative(), LMCAS::anonymous_namespace{numerical_integration.cpp}::checked_finite_value(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::classify_continuity_point_value(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_product(), LMCAS::anonymous_namespace{limit_result.cpp}::classify_infinite_sum(), LMCAS::detail::anonymous_namespace{exact_matrix_support.cpp}::classify_numeric_value(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_translated_quadric(), LMCAS::detail::anonymous_namespace{facts_query_rational.cpp}::closed_rational_power(), LMCAS::detail::closed_rational_value(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::coefficient(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_square(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::collect_exact_factors(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::compare_algebraic_to_rational(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::constant(), LMCAS::detail::complex_root::anonymous_namespace{complex_root_projection.cpp}::constant_poly(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::constant_satisfies(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_relations.cpp}::consume_delimiter(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_point_value(), LMCAS::anonymous_namespace{calculus_continuity.cpp}::continuity_with_limit(), LMCAS::detail::anonymous_namespace{exact_root.cpp}::conversion_ulp(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::convert_number(), convert_unit(), convert_unit(), crt_checked(), LMCAS::anonymous_namespace{symbolic_construction.cpp}::decimal_rational(), deduplicate_roots(), LMCAS::detail::differentiate_expression(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_number(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root(), LMCAS::anonymous_namespace{symbolic_matrix_eigen.cpp}::eigenvalue_nullspace(), LMCAS::serialization_detail::enum_name(), LMCAS::anonymous_namespace{integration_definite.cpp}::equal_endpoint_integral(), LMCAS::anonymous_namespace{numerical_integration.cpp}::estimated_quadrature_result(), LMCAS::detail::NumericEvaluator::evaluate(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_operands(), LMCAS::anonymous_namespace{expr_complex_evaluation.cpp}::evaluate_complex_power(), LMCAS::anonymous_namespace{numerical_integration.cpp}::evaluate_quadrature_callback(), LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_callback(), LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_function(), LMCAS::detail::exact_atan_bounds(), LMCAS::detail::exact_double_rational(), LMCAS::anonymous_namespace{symbolic_set.cpp}::exact_interval_membership(), LMCAS::anonymous_namespace{value.cpp}::exact_number_as_floating(), LMCAS::detail::matrix_decomposition::exact_number_expr(), LMCAS::detail::inequality_support::exact_numeric_sign(), exact_rational_domain_excludes(), LMCAS::detail::matrix_decomposition::exact_rational_expr(), LMCAS::detail::matrix_decomposition::exact_rational_matrix(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::exact_rational_product(), LMCAS::detail::anonymous_namespace{complex_root_isolation.cpp}::exact_rational_square_root(), LMCAS::detail::matrix_decomposition::anonymous_namespace{matrix_decomposition_support.cpp}::exact_rational_sum(), exact_small_integer_node(), LMCAS::anonymous_namespace{expr_number_domains.cpp}::exact_sqrt_contains(), LMCAS::anonymous_namespace{symbolic_set.cpp}::exact_value(), LMCAS::detail::expand_expression(), LMCAS::detail::anonymous_namespace{numeric_evaluation_power.cpp}::exponent_parity(), expr_match(), extract_bernoulli_factor(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::extract_small_square_factor(), LMCAS::detail::NumericEvaluator::extremum(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::SolutionFinalizer::finalize_value(), find_extrema_impl(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::finish(), LMCAS::anonymous_namespace{bigint_combinatorics.cpp}::finish_combinatorial(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::finite_endpoint(), finite_values_to_set(), LMCAS::anonymous_namespace{value.cpp}::format_float(), frobenius_coefficient_limit(), LMCAS::detail::NumericEvaluator::function(), get_integer_value(), hash_combine(), hl_is_prime(), LMCAS::anonymous_namespace{limit_result.cpp}::infinity_sign(), LMCAS::detail::definite::infinity_sign(), inflection_curve_defined(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::integer(), integer(), integer(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_builder.cpp}::integer_exponent(), LMCAS::detail::series_support::integer_value_from_node(), integration_bounded_exponent(), interval_contains_checked(), interval_contains_checked(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_exponential(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_logarithm(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_inversion.cpp}::invert_trigonometric(), LMCAS::assumption_detail::is_closing_delimiter(), is_euler_equation(), LMCAS::NormalizationVisitor::is_positive_integer_number(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::is_real(), is_representable_small_integer(), is_vertical_asymptote(), LMCAS::anonymous_namespace{integrator.cpp}::is_zero(), LMCAS::anonymous_namespace{bigint_combinatorics.cpp}::kernel_argument(), LMCAS::InferenceEngine::Impl::known_sign(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), limit_expression_checked(), LMCAS::InferenceEngine::Impl::logarithm_sign(), LMCAS::anonymous_namespace{quantity.cpp}::make_quantity(), matrix_characteristic_polynomial_checked(), matrix_eigenvalues_checked(), LMCAS::anonymous_namespace{normalization_matrices.cpp}::matrix_element(), LMCAS::detail::mixed_evaluate_at(), LMCAS::detail::mixed_evaluate_with_retry(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::negate(), LMCAS::anonymous_namespace{solve_solution_finalization.cpp}::negate_truth(), norm_subst_index(), normalization_numeric_function(), normalization_numeric_power(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize(), LMCAS::NormalizationVisitor::normalize_unary_function(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::number(), LMCAS::detail::NumericEvaluator::number(), LMCAS::anonymous_namespace{normalization_numeric_functions.cpp}::number_equals_integer(), LMCAS::detail::numeric_approximation(), numeric_domain_excludes(), numeric_sign_excludes(), operator<<(), LMCAS::anonymous_namespace{limit_result.cpp}::outcome(), parametric_linear_solution(), LMCAS::expr_detail::ExprParser::parse_approx_literal(), parse_approximate_atom(), LMCAS::detail::parse_finite_decimal(), LMCAS::assumption_detail::parse_finite_number_node(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::parse_interval_endpoint(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_values.cpp}::parse_named_value(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::polish_value(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::polynomial_exponent(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::polynomial_exponent(), LMCAS::ode_root_detail::polynomial_root_backward_error(), LMCAS::detail::anonymous_namespace{exact_sturm.cpp}::polynomial_sign_at(), LMCAS::anonymous_namespace{limit_result.cpp}::ComplexContinuityPoint::positive(), LMCAS::anonymous_namespace{symbolic_cancel.cpp}::positive_denominator_exponent(), LMCAS::detail::NumericEvaluator::power(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::power_candidate(), LMCAS::detail::transcendental::anonymous_namespace{transcendental_patterns.cpp}::power_pattern(), LMCAS::detail::NumericEvaluator::product(), LMCAS::detail::definite::product_checked(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::product_exp_multiplier(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::property(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::propose_dyadic_bracket(), LMCAS::anonymous_namespace{residual_verification.cpp}::FormalResidual::prove(), LMCAS::anonymous_namespace{equivalence_engine.cpp}::prove_operands(), LMCAS::equivalence_detail::prove_rational_polynomial_equivalence(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::put_integer(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::put_rational(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::put_size(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::quadratic_eigenvalue_sign(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), rational(), LMCAS::detail::anonymous_namespace{exact_matrix_determinant.cpp}::rational_determinant(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::rational_endpoint_bound(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::rational_is_negative(), LMCAS::detail::anonymous_namespace{exact_matrix_solve.cpp}::rational_linear_solve(), LMCAS::anonymous_namespace{quantity.cpp}::rational_node(), LMCAS::detail::definite::rational_pole_divergence(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::rational_sign(), LMCAS::detail::complex_root::rational_sign(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_sign_intervals(), LMCAS::anonymous_namespace{rational_parsing.cpp}::RationalLiteral::read_exponent(), LMCAS::anonymous_namespace{rational_parsing.cpp}::RationalLiteral::read_exponent_magnitude(), LMCAS::detail::refine_exact_real_algebraic(), LMCAS::detail::refine_exact_real_algebraic_to_tolerance(), 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::anonymous_namespace{residual_verification.cpp}::FormalResidual::rewrite_function(), LMCAS::equivalence_detail::rewritten_complex(), LMCAS::detail::inequality_support::anonymous_namespace{inequality_solver_ordering.cpp}::root_number_sign(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), scale_integral_field(), LMCAS::detail::anonymous_namespace{exact_algebraic_refinement.cpp}::search_dyadic_scale(), separable_reciprocal(), LMCAS::detail::anonymous_namespace{exact_algebraic.cpp}::sign(), LMCAS::detail::definite::sign(), LMCAS::NormalizationVisitor::simplify_assumed_square_root(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::simplify_coefficients(), LMCAS::detail::simplify_expression(), simplify_finite_limit(), LMCAS::anonymous_namespace{normalization_numeric_powers.cpp}::small_exact_power(), solution_is_excluded(), solve_complex_nth_root_checked(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::solve_exact_affine_inequality_impl(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_function_pattern(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inverted_values(), LMCAS::detail::solve_linear_exact(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_substitution(), solve_symbolic_polynomial_set(), solve_transcendental(), LMCAS::detail::anonymous_namespace{numeric_evaluation_functions.cpp}::special(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentExpression::specialize_absolute(), LMCAS::detail::NumericEvaluator::square_root(), LMCAS::detail::anonymous_namespace{squared_norm.cpp}::square_root_argument(), LMCAS::solver_detail::anonymous_namespace{solver_imaginary.cpp}::square_root_is_imaginary(), LMCAS::detail::anonymous_namespace{squared_norm.cpp}::squared_term(), strip_unit(), substitute(), substitute(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::substitute_assignment(), LMCAS::detail::substitute_expression(), LMCAS::detail::substitute_expression(), LMCAS::detail::substitute_raw(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::substitute_solution(), LMCAS::anonymous_namespace{fglm_polynomial.cpp}::subtract_leading_multiple(), LMCAS::detail::NumericEvaluator::sum(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::symbolic_quadratic_sign(), LMCAS::detail::symmetric_remainder(), tf_power_degree(), LMCAS::detail::anonymous_namespace{interval_endpoint_order.cpp}::to_algebraic(), LMCAS::detail::anonymous_namespace{facts_query.cpp}::DomainTraversal::trigonometric_domain(), LMCAS::assumption_detail::anonymous_namespace{assumption_parse_atoms.cpp}::trim_interval_endpoint(), try_get_integer_value(), LMCAS::integration_table_detail::u_is_var(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_expr_vector(), LMCAS::detail::definite::anonymous_namespace{integration_definite_segments.cpp}::SegmentFacts::value_sign_impl(), LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric(), vector_calculus_classify_critical_point(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_decomposition(), LMCAS::anonymous_namespace{matrix_decomposition_eigen.cpp}::verify_jordan_identity(), verify_lagrange_solutions(), LMCAS::anonymous_namespace{expr_serialization.cpp}::Writer::visit(), LMCAS::detail::RecursiveSymbolicVisitor::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::detail::SymbolicRewriter::visit(), LMCAS::ExpandVisitor::visit(), LMCAS::groebner_detail::PolyBuilder::visit(), LMCAS::NormalizationVisitor::visit(), LMCAS::RewriteVisitor::visit(), with_unit(), with_unit_definition() , 以及 zero_remainder().

variable

const std::string & LMCAS::variable

在文件 expr.hpp 第 286 行定义.

被这些函数引用 LMCAS::anonymous_namespace{complex_analysis.cpp}::FunctionDependencyFinder::FunctionDependencyFinder(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::PeriodInference::PeriodInference(), __attribute__(), __attribute__(), active_univariate_variable(), adaptive_simpson_numeric(), adaptive_simpson_numeric(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::append_exact_factor_roots(), LMCAS::expr_detail::ExprParser::apply_integral(), LMCAS::expr_detail::ExprParser::apply_limit(), LMCAS::expr_detail::ExprParser::apply_rootof(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::arc_length_checked_impl(), binding(), bisection_checked(), bisection_checked(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::check_arguments(), checked_derivative(), 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::multivariate_checked_detail::collect_linear_samples(), LMCAS::equivalence_detail::anonymous_namespace{equivalence_proof.cpp}::collect_polynomial_variable_names(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::collect_polynomial_variables(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_polynomial_nonzero(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_condition(), LMCAS::anonymous_namespace{limit_result.cpp}::complex_punctured_domain(), conditional_equation(), conditional_linear_polynomial(), LMCAS::anonymous_namespace{poly_utils.cpp}::constant_to_poly(), contains(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::definite_integral_geometry_checked(), depends_on_integration_variable(), LMCAS::anonymous_namespace{relation_store.cpp}::derive_comparison_sign(), differentiate(), differentiate(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::differentiate_geometry_checked(), differentiate_if_dependent(), embed_hensel_terms(), LMCAS::anonymous_namespace{limit_result.cpp}::evaluate_one_sided_node(), LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_function(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_operands(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::exact_polynomial_nodes(), expression_depends_on_variable(), extract_bernoulli_factor(), LMCAS::multivariate_checked_detail::factor_evaluated_linear(), LMCAS::anonymous_namespace{multivariate_factor_checked.cpp}::factor_multivariate_impl(), find_extrema_impl(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::free_unknowns(), LMCAS::groebner_detail::PolyBuilder::function_depends_on_variables(), LMCAS::fglm_detail::generate_degree(), LMCAS::anonymous_namespace{fglm.cpp}::generate_standard_degree(), get_pi_coeff(), LMCAS::fglm_detail::has_pure_generators(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::has_unrecognized_variable_polynomial(), LMCAS::anonymous_namespace{matrix_quadratic_form.cpp}::independent_of_variables(), integrating_factor_from_antiderivative(), integrating_factor_from_ratio(), interval_to_expr(), is_pi_variable(), LMCAS::anonymous_namespace{symbolic_factor.cpp}::is_poly_expr_node(), LMCAS::fglm_detail::anonymous_namespace{fglm_dimension.cpp}::is_pure_power(), is_zero_dimensional(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_at_checked_point(), limit_checked(), limit_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_complex_at_point(), limit_expression_checked(), limit_expression_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_one_sided_checked(), LMCAS::anonymous_namespace{limit_result.cpp}::limit_real_at_point(), linear2_root_basis(), LMCAS::anonymous_namespace{integration_substitution.cpp}::linear_reduced_expression(), make_rootof_checked(), make_rootof_checked(), matrix_characteristic_polynomial_checked(), matrix_characteristic_polynomial_checked(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), newton_raphson_checked(), LMCAS::anonymous_namespace{symbolic_gcd.cpp}::node_to_multivariate_polynomial(), numeric_sign_excludes(), LMCAS::anonymous_namespace{limit_result.cpp}::oscillatory_one_sided_limit(), LMCAS::assumption_detail::AssumptionParser::parse_periodic(), LMCAS::anonymous_namespace{inference_engine_periodicity.cpp}::periodicity_checked(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::product_exp_multiplier(), LMCAS::anonymous_namespace{mixed_transcendental_search.cpp}::product_linear_coefficient(), project_finite_expr_set(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::propagate(), LMCAS::equivalence_detail::prove_rational_polynomial_equivalence(), quadrature_gaussian_numeric(), quadrature_gaussian_numeric(), quadrature_simpson_numeric(), quadrature_simpson_numeric(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::rational_critical_points(), LMCAS::anonymous_namespace{inequality_solver_polynomial.cpp}::rational_polynomial_expression(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_node(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_number(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_power(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_product(), recognize_rational_polynomial(), LMCAS::anonymous_namespace{rational_polynomial_recognition.cpp}::recognize_sum(), reconstruct_rational_roots(), LMCAS::anonymous_namespace{transcendental_solver_substitution.cpp}::redundant_variable_candidate(), roots(), roots(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend(), LMCAS::anonymous_namespace{newton_raphson.cpp}::run_newton_backend(), LMCAS::anonymous_namespace{limit_result.cpp}::scaled_one_sided_limit(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::select_equation(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::select_target(), LMCAS::anonymous_namespace{assumption_serialization.cpp}::serialize_symbol_properties(), series_index_variable(), solution_is_excluded(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::solve(), LMCAS::anonymous_namespace{solve_mixed_transcendental.cpp}::MixedRootCollection::solve(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::solve(), solve(), solve(), solve_biquadratic(), solve_by_factoring(), solve_cubic(), LMCAS::polynomial_solver_detail::solve_cubic_impl(), solve_expr_set(), solve_expr_set(), solve_finite_checked(), LMCAS::anonymous_namespace{parametric_solver_branches.cpp}::ParametricBranchSolver::solve_free_unknown(), LMCAS::anonymous_namespace{solve_transcendental.cpp}::solve_inner_equation(), solve_product_factor(), solve_product_set(), solve_quartic(), solve_set(), solve_set(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::solve_single_equation(), solve_symbolic_polynomial_set(), solve_with_assumptions_checked(), solve_with_assumptions_checked(), solve_with_assumptions_impl(), LMCAS::anonymous_namespace{inequality_solver_parametric.cpp}::solved_inequality(), substitute(), substitute(), substitute(), LMCAS::anonymous_namespace{solver_groebner_system.cpp}::PolynomialSystemSearch::substitute_basis(), substitute_free(), symbol_name(), symbolic_power_to_poly(), symbolic_product_to_poly(), symbolic_root_term(), symbolic_sum_to_poly(), symbolic_to_poly_recursive(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_accumulate_gaussian_factor(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_atomic_gaussian_rate(), te_convolve_core(), te_convolve_sum(), LMCAS::transform_detail::te_depends_on(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_gaussian_product_rate(), te_inverse_pole(), te_inverse_pole_term(), te_is_abs_variable(), te_is_denominator_factor(), LMCAS::transform_detail::te_is_trig(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_is_variable_square(), LMCAS::transform_detail::te_linear_coefficient(), LMCAS::transform_detail::te_match_pure_gaussian(), LMCAS::transform_detail::te_match_scaled_gaussian(), LMCAS::groebner_detail::anonymous_namespace{solver_groebner_reconstruction.cpp}::term_node(), tf_polynomial_variables(), tf_select_main_variable(), truncated_factor_product(), validate_integration_steps(), LMCAS::anonymous_namespace{limit_result.cpp}::validate_limit_input(), LMCAS::anonymous_namespace{numerical_integration.cpp}::validate_quadrature_args(), LMCAS::anonymous_namespace{inference_engine_bounds.cpp}::BoundsPropagation::variable_bounds(), LMCAS::anonymous_namespace{query_conditions.cpp}::variable_operand_conditions(), vector_calculus_constant_integrand(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), verify_lagrange_solutions(), LMCAS::anonymous_namespace{symbolic_geometry.cpp}::volume_of_revolution_checked_impl(), LMCAS::anonymous_namespace{integration_weierstrass.cpp}::weier_rational_function(), LMCAS::anonymous_namespace{inequality_solver_rational.cpp}::zero_numerator_domain(), zt_is_weighted_exp() , 以及 zt_polynomial_pattern().

vars

const std::vector< std::string > & LMCAS::vars

在文件 vector_calculus_differential.hpp 第 36 行定义.

被这些函数引用 LMCAS::detail::adjust_homogeneous_constant(), apply_hensel_lift_steps(), choose_main_variable(), LMCAS::detail::classify_quadric_impl(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::classify_translated_quadric(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_constant(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::coefficient_of_linear(), curl(), curl_checked(), curl_checked(), LMCAS::vector_calculus_detail::curl_impl(), LMCAS::detail::detect_binomial_power(), LMCAS::detail::detect_difference_of_squares(), directional_derivative(), directional_derivative_checked(), directional_derivative_checked(), LMCAS::vector_calculus_detail::directional_derivative_impl(), divergence(), divergence_checked(), divergence_checked(), LMCAS::vector_calculus_detail::divergence_impl(), divergence_theorem(), divergence_theorem_checked(), divergence_theorem_checked(), LMCAS::vector_calculus_detail::divergence_theorem_strict(), embed_univariate_gcd(), embed_without_lifting(), evaluated_lifting_cofactors(), extended_gcd_interpolation(), exterior_derivative_checked(), exterior_derivative_checked(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_component(), LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_term(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_axis_coefficients(), extract_coefficients(), LMCAS::detail::extract_common_monomial(), LMCAS::detail::anonymous_namespace{symbolic_quadric_classification.cpp}::extract_mixed_coefficients(), LMCAS::detail::factor_homogeneous_bivariate(), find_extrema(), find_extrema_checked(), find_extrema_checked(), find_extrema_impl(), formal_derivative(), gradient(), gradient_checked(), gradient_checked(), LMCAS::vector_calculus_detail::gradient_impl(), greens_theorem(), greens_theorem_checked(), greens_theorem_checked(), LMCAS::vector_calculus_detail::greens_theorem_strict(), hessian(), hessian_checked(), hessian_checked(), LMCAS::vector_calculus_detail::hessian_impl(), LMCAS::detail::homogenize_factor(), jacobian(), jacobian_checked(), jacobian_checked(), LMCAS::vector_calculus_detail::jacobian_impl(), lagrange_gradient_strict(), lagrange_multipliers(), lagrange_multipliers_checked(), lagrange_multipliers_checked(), lagrange_multipliers_strict(), laplacian(), laplacian_checked(), laplacian_checked(), LMCAS::vector_calculus_detail::laplacian_impl(), lie_derivative_checked(), lie_derivative_checked(), lie_derivative_impl(), lifting_error_coefficient(), lifting_shift_powers(), multipoly_to_symbolic(), multivariate_content(), multivariate_diophantine(), multivariate_gcd(), multivariate_hensel_lift(), quadratic_form_matrix(), recursive_multivariate_gcd(), solve_diophantine_pair(), square_free_decompose(), stokes_theorem(), stokes_theorem_checked(), stokes_theorem_checked(), LMCAS::vector_calculus_detail::stokes_theorem_strict(), symbolic_node_to_multipoly(), total_differential(), truncate_mod_var(), univariate_gcd(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_expr_vector(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_form_coefficients(), LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_form_coordinates(), LMCAS::vector_calculus_detail::vector_calculus_coord_vars(), vector_calculus_curl_strict(), LMCAS::vector_calculus_detail::vector_calculus_point_has_vars(), vector_calculus_single_dir_deriv(), LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars(), 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() , 以及 verify_lagrange_solutions().

wildcards

const ExprPtr const std::vector< std::string > & LMCAS::wildcards

在文件 expr.hpp 第 318 行定义.

被这些函数引用 expr_match(), expr_match(), is_wildcard(), match_commutative_recursive(), match_function(), match_operation() , 以及 match_recursive().

x_bounds

const std::vector< std::string > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > & LMCAS::x_bounds

在文件 vector_calculus_theorems.hpp 第 92 行定义.

被这些函数引用 divergence_theorem(), divergence_theorem_checked(), divergence_theorem_checked(), LMCAS::vector_calculus_detail::divergence_theorem_strict(), greens_theorem(), greens_theorem_checked(), greens_theorem_checked(), LMCAS::vector_calculus_detail::greens_theorem_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

y_bounds

const std::vector< std::string > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > & LMCAS::y_bounds

在文件 vector_calculus_theorems.hpp 第 93 行定义.

被这些函数引用 divergence_theorem(), divergence_theorem_checked(), divergence_theorem_checked(), LMCAS::vector_calculus_detail::divergence_theorem_strict(), greens_theorem(), greens_theorem_checked(), greens_theorem_checked(), LMCAS::vector_calculus_detail::greens_theorem_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

z_bounds

const std::vector< std::string > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > & LMCAS::z_bounds

在文件 vector_calculus_theorems.hpp 第 94 行定义.

被这些函数引用 divergence_theorem(), divergence_theorem_checked(), divergence_theorem_checked(), LMCAS::vector_calculus_detail::divergence_theorem_strict() , 以及 LMCAS::vector_calculus_detail::vector_calculus_coord_vars().

z_var

const ComplexSymbolic const std::string & LMCAS::z_var = "z")

在文件 symbolic_complex.hpp 第 210 行定义.

被这些函数引用 complex_locus_circle_checked(), complex_locus_circle_checked(), complex_locus_perpendicular_bisector_checked(), complex_locus_perpendicular_bisector_checked() , 以及 zt_polynomial().