LMCAS::transform_detail 命名空间参考

命名空间
namespace	anonymous_namespace{transform_support.cpp}

类
struct	GaussianMatch

函数
std::shared_ptr< SymbolicExpr >	laplace_transform_core (const std::shared_ptr< SymbolicExpr > &expression, const std::string &input_var, const std::string &output_var, ComputationContext &context)
bool	te_contains_transform (const std::shared_ptr< const SymbolicNode > &node)
bool	te_depends_on (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable)
BigInt	te_factorial (const BigInt &n, ComputationContext &context)
std::shared_ptr< SymbolicExpr >	te_gt_condition (const std::shared_ptr< SymbolicExpr > &lhs, const std::shared_ptr< SymbolicExpr > &rhs)
bool	te_is_trig (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable, bool &is_sin, std::shared_ptr< SymbolicExpr > &frequency)
bool	te_is_zero (const std::shared_ptr< SymbolicExpr > &expression)
std::shared_ptr< SymbolicExpr >	te_linear_coefficient (const std::shared_ptr< const SymbolicNode > &argument, const std::string &variable)
std::optional< Rational >	te_match_pure_gaussian (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable)
std::optional< GaussianMatch >	te_match_scaled_gaussian (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable)
std::optional< Rational >	te_number_value (const std::shared_ptr< const SymbolicNode > &node)
std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > >	te_split_coeff (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable)
Result< void >	te_validate_expr_vars (const std::shared_ptr< SymbolicExpr > &expression, const std::string &input_var, const std::string &output_var, ComputationContext &context, const std::string &operation)
TransformEngineResult	te_wrap_transform_result (std::shared_ptr< SymbolicExpr > expression, const std::string &operation)

---

类说明

LMCAS::transform_detail::GaussianMatch

struct LMCAS::transform_detail::GaussianMatch

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

LMCAS::transform_detail::GaussianMatch 的协作图:

类成员
shared_ptr< SymbolicExpr >	coefficient
Rational	rate

函数说明

laplace_transform_core()

std::shared_ptr< SymbolicExpr > LMCAS::transform_detail::laplace_transform_core	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	input_var,
		const std::string &	output_var,
		ComputationContext &	context )

在文件 transform_laplace.cpp 第 153 行定义.

                                                     {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    auto step = context.consume_steps(1, "laplace_transform.recursive");
    if (!step) {
        return nullptr;
    }
    if (!f || !LMCAS::detail::node(f)) {
        return nullptr;
    }
    if (te_is_zero(f)) {
        return SymbolicExpr::number(0);
    }
    if (!te_depends_on(f, t)) {
        return SymbolicExpr::divide(f, SymbolicExpr::variable(s));
    }
    auto add = std::dynamic_pointer_cast<const AddNode>(LMCAS::detail::node(f));
    if (add) {
        return te_laplace_sum(f, *add, t, s, context);
    }
    auto [coeff, body] = te_split_coeff(f, t);
    if (!coeff->is_one()) {
        auto lt_body = laplace_transform_core(body, t, s, context);
        if (lt_body) {
            return SymbolicExpr::multiply(coeff, lt_body);
        }
    }
    std::shared_ptr<SymbolicExpr> a_shift, remainder;
    if (te_extract_exp(f, t, a_shift, remainder)) {
        if (te_depends_on(remainder, t)) {
            auto lt_rem = laplace_transform_core(remainder, t, s, context);
            if (lt_rem) {
                return detail::make_expression_ptr(detail::substitute_node(detail::node(lt_rem), s, detail::node(SymbolicExpr::add(SymbolicExpr::variable(s), SymbolicExpr::multiply(SymbolicExpr::number(-1), a_shift))), transform_budget));
            }
        } else {
            return SymbolicExpr::divide(remainder, SymbolicExpr::add(SymbolicExpr::variable(s), SymbolicExpr::multiply(SymbolicExpr::number(-1), a_shift)));
        }
    }
    auto lookup = te_laplace_lookup(f, t, s, context);
    if (lookup) {
        return lookup;
    }
    return te_unevaluated_laplace(f, t, s);
}

引用了 LMCAS::add(), LMCAS::context, laplace_transform_core(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::substitute_node(), LMCAS::t, te_depends_on(), LMCAS::te_extract_exp(), te_is_zero(), LMCAS::te_laplace_lookup(), LMCAS::te_laplace_sum(), te_split_coeff() , 以及 LMCAS::te_unevaluated_laplace().

被这些函数引用 LMCAS::inverse_laplace_checked(), LMCAS::laplace_transform_checked(), laplace_transform_core() , 以及 LMCAS::te_laplace_sum().

函数调用图:

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

te_contains_transform()

bool LMCAS::transform_detail::te_contains_transform

(

const std::shared_ptr< const SymbolicNode > &

node

)

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

                                                   {
    return LMCAS::detail::contains_node_type<TransformNode>(node);
}

引用了 LMCAS::detail::contains_node_type() , 以及 te_contains_transform().

被这些函数引用 LMCAS::inverse_fourier_transform_checked(), LMCAS::inverse_laplace_checked(), te_contains_transform() , 以及 te_wrap_transform_result().

函数调用图:

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

te_depends_on()

bool LMCAS::transform_detail::te_depends_on	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable )

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

                                                     {
    return expression &&
           expression_depends_on_variable(
               LMCAS::detail::node(expression), variable);
}

引用了 LMCAS::expression_depends_on_variable(), LMCAS::detail::node(), te_depends_on() , 以及 LMCAS::variable.

被这些函数引用 LMCAS::fourier_transform_core(), LMCAS::inverse_fourier_transform_core(), laplace_transform_core(), LMCAS::te_convolve_core(), te_depends_on(), LMCAS::te_inv_product(), LMCAS::te_laplace_lookup(), LMCAS::te_laplace_roc(), te_split_coeff(), LMCAS::z_transform_core(), LMCAS::zt_is_exp_seq() , 以及 LMCAS::zt_roc().

函数调用图:

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

te_factorial()

BigInt LMCAS::transform_detail::te_factorial	(	const BigInt &	n,
		ComputationContext &	context )

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

                                                                  {
    auto result = BigInt::factorial_checked(n, context);
    if (!result) throw result.error();
    return std::move(result.value());
}

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

被这些函数引用 te_factorial(), LMCAS::te_inv_power() , 以及 LMCAS::te_laplace_lookup().

函数调用图:

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

te_gt_condition()

std::shared_ptr< SymbolicExpr > LMCAS::transform_detail::te_gt_condition	(	const std::shared_ptr< SymbolicExpr > &	lhs,
		const std::shared_ptr< SymbolicExpr > &	rhs )

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

                                            {
    if (!lhs || !LMCAS::detail::node(lhs) || !rhs || !LMCAS::detail::node(rhs)) return nullptr;
    return LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<RelationalNode>(LMCAS::detail::node(lhs), LMCAS::detail::node(rhs), RelationalNode::Op::GT));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::rhs , 以及 te_gt_condition().

被这些函数引用 LMCAS::te_decay_condition(), te_gt_condition(), LMCAS::te_laplace_roc(), LMCAS::zt_base_roc() , 以及 LMCAS::zt_unit_roc().

函数调用图:

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

te_is_trig()

bool LMCAS::transform_detail::te_is_trig	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable,
		bool &	is_sin,
		std::shared_ptr< SymbolicExpr > &	frequency )

在文件 transform_support.cpp 第 222 行定义.

                                                        {
    if (!expression || !detail::node(expression)) {
        return false;
    }
    auto function = std::dynamic_pointer_cast<const FunctionNode>(detail::node(expression));
    if (!function || function->arguments().empty()) {
        return false;
    }
    if (function->type() != FunctionNode::FuncType::Sin &&
        function->type() != FunctionNode::FuncType::Cos) {
        return false;
    }
    is_sin = function->type() == FunctionNode::FuncType::Sin;
    frequency = te_linear_coefficient(function->arguments()[0], variable);
    return frequency != nullptr;
}

引用了 LMCAS::FunctionNode::Cos, LMCAS::function(), LMCAS::detail::node(), LMCAS::FunctionNode::Sin, te_is_trig(), te_linear_coefficient() , 以及 LMCAS::variable.

被这些函数引用 te_is_trig(), LMCAS::te_laplace_lookup(), LMCAS::te_laplace_roc(), LMCAS::zt_lookup_roc() , 以及 LMCAS::zt_trigonometric().

函数调用图:

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

te_is_zero()

bool LMCAS::transform_detail::te_is_zero

(

const std::shared_ptr< SymbolicExpr > &

expression

)

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

                                                      {
    return e && LMCAS::detail::node(e) && e->is_zero();
}

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

被这些函数引用 LMCAS::inverse_laplace_core(), laplace_transform_core(), LMCAS::te_convolve_core(), LMCAS::te_inv_power() , 以及 te_is_zero().

函数调用图:

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

te_linear_coefficient()

std::shared_ptr< SymbolicExpr > LMCAS::transform_detail::te_linear_coefficient	(	const std::shared_ptr< const SymbolicNode > &	argument,
		const std::string &	variable )

在文件 transform_support.cpp 第 108 行定义.

                                                                                  {
    auto symbol = std::dynamic_pointer_cast<const VariableNode>(argument);
    if (symbol && !symbol->is_constant() && symbol->name() == variable) {
        return detail::make_expression_ptr(SymbolicFactory::create_number(BigInt(1)));
    }
    auto product = std::dynamic_pointer_cast<const MultiplyNode>(argument);
    if (!product || product->operands().size() != 2) {
        return nullptr;
    }
    for (std::size_t i = 0; i < 2; ++i) {
        symbol = std::dynamic_pointer_cast<const VariableNode>(product->operands()[i]);
        const auto& other = product->operands()[1 - i];
        if (!symbol || symbol->is_constant() || symbol->name() != variable) continue;
        if (expression_depends_on_variable(other, variable)) continue;
        return detail::make_expression_ptr(other);
    }
    return nullptr;
}

引用了 LMCAS::SymbolicFactory::create_number(), LMCAS::expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), te_linear_coefficient() , 以及 LMCAS::variable.

被这些函数引用 LMCAS::te_extract_exp(), LMCAS::te_is_hyp(), te_is_trig() , 以及 te_linear_coefficient().

函数调用图:

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

te_match_pure_gaussian()

std::optional< Rational > LMCAS::transform_detail::te_match_pure_gaussian	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable )

在文件 transform_support.cpp 第 185 行定义.

                               {
    if (!expression || !detail::node(expression)) return std::nullopt;
    const auto function = std::dynamic_pointer_cast<const FunctionNode>(
        detail::node(expression));
    if (!function || function->type() != FunctionNode::FuncType::Exp ||
        function->arguments().empty()) {
        return std::nullopt;
    }
    const auto product = std::dynamic_pointer_cast<const MultiplyNode>(
        function->arguments()[0]);
    if (!product) return std::nullopt;
 
    return te_gaussian_product_rate(*product, variable);
}

引用了 LMCAS::FunctionNode::Exp, LMCAS::function(), LMCAS::detail::node(), te_match_pure_gaussian() , 以及 LMCAS::variable.

被这些函数引用 LMCAS::fourier_transform_core(), LMCAS::inverse_fourier_transform_core() , 以及 te_match_pure_gaussian().

函数调用图:

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

te_match_scaled_gaussian()

std::optional< GaussianMatch > LMCAS::transform_detail::te_match_scaled_gaussian	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable )

在文件 transform_support.cpp 第 202 行定义.

                               {
    auto parts = te_split_coeff(expression, variable);
    const auto coefficient = te_number_value(detail::node(parts.first));
    if (!coefficient) {
        return std::nullopt;
    }
    const auto function = std::dynamic_pointer_cast<const FunctionNode>(
        detail::node(parts.second));
    if (!function || function->type() != FunctionNode::FuncType::Exp ||
        function->arguments().size() != 1) {
        return std::nullopt;
    }
    const auto rate =
        te_atomic_gaussian_rate(function->arguments()[0], variable);
    if (!rate) return std::nullopt;
    return GaussianMatch{std::move(parts.first), *rate};
}

引用了 LMCAS::FunctionNode::Exp, LMCAS::function(), LMCAS::detail::node(), te_match_scaled_gaussian(), te_number_value(), te_split_coeff() , 以及 LMCAS::variable.

被这些函数引用 LMCAS::te_convolve_core() , 以及 te_match_scaled_gaussian().

函数调用图:

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

te_number_value()

std::optional< Rational > LMCAS::transform_detail::te_number_value

(

const std::shared_ptr< const SymbolicNode > &

node

)

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

                                                   {
    const auto number = std::dynamic_pointer_cast<const NumberNode>(node);
    if (!number) return std::nullopt;
    if (std::holds_alternative<BigInt>(number->value())) {
        return Rational(std::get<BigInt>(number->value()));
    }
    return std::get<Rational>(number->value());
}

引用了 te_number_value().

被这些函数引用 LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_accumulate_gaussian_factor(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_atomic_gaussian_rate(), LMCAS::te_is_denominator_factor(), te_match_scaled_gaussian() , 以及 te_number_value().

函数调用图:

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

te_split_coeff()

std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > LMCAS::transform_detail::te_split_coeff	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable )

在文件 transform_support.cpp 第 91 行定义.

                                                                         {
    if (!e || !LMCAS::detail::node(e) || !te_depends_on(e, v)) return {e ? e : SymbolicExpr::number(1), SymbolicExpr::number(1)};
    auto mul = std::dynamic_pointer_cast<const MultiplyNode>(LMCAS::detail::node(e));
    if (!mul) return {SymbolicExpr::number(1), e};
    std::vector<std::shared_ptr<const SymbolicNode>> cp, vp;
    for (auto& op : mul->operands()) {
        if (expression_depends_on_variable(op, v)) vp.push_back(op); else cp.push_back(op);
    }
    if (cp.empty()) return {SymbolicExpr::number(1), e};
    if (vp.empty()) return {e, SymbolicExpr::number(1)};
    auto c = (cp.size()==1) ? LMCAS::detail::make_expression_ptr(cp[0])
        : LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<MultiplyNode>(cp));
    auto b = (vp.size()==1) ? LMCAS::detail::make_expression_ptr(vp[0])
        : LMCAS::detail::make_expression_ptr(LMCAS::detail::make_node<MultiplyNode>(vp));
    return {c, b};
}

引用了 LMCAS::b, LMCAS::c, LMCAS::e(), LMCAS::expression_depends_on_variable(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::mul(), LMCAS::detail::node(), LMCAS::op, te_depends_on(), te_split_coeff() , 以及 LMCAS::v.

被这些函数引用 LMCAS::fourier_transform_core(), LMCAS::inverse_laplace_core(), laplace_transform_core(), LMCAS::te_abs_decay(), LMCAS::transform_detail::anonymous_namespace{transform_support.cpp}::te_atomic_gaussian_rate(), LMCAS::te_convolve_core(), te_match_scaled_gaussian(), te_split_coeff(), LMCAS::z_transform_core() , 以及 LMCAS::zt_roc().

函数调用图:

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

te_validate_expr_vars()

Result< void > LMCAS::transform_detail::te_validate_expr_vars	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	input_var,
		const std::string &	output_var,
		ComputationContext &	context,
		const std::string &	operation )

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

                                                                      {
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!expr || !LMCAS::detail::node(expr)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "transform expression cannot be null",
                                     operation);
    }
    if (input_var.empty() || output_var.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "transform variable names cannot be empty",
                                     operation);
    }
    if (input_var == output_var) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "input and output variables must be distinct",
                                     operation);
    }
    return Result<void>::success();
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success() , 以及 te_validate_expr_vars().

被这些函数引用 LMCAS::fourier_transform_checked(), LMCAS::inverse_fourier_transform_checked(), LMCAS::inverse_laplace_checked(), LMCAS::laplace_transform_checked(), te_validate_expr_vars() , 以及 LMCAS::z_transform_checked().

函数调用图:

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

te_wrap_transform_result()

TransformEngineResult LMCAS::transform_detail::te_wrap_transform_result	(	std::shared_ptr< SymbolicExpr >	expression,
		const std::string &	operation )

在文件 transform_support.cpp 第 42 行定义.

                                {
    if (!expr || !LMCAS::detail::node(expr)) {
        return TransformEngineResult::failure(
            CasErrc::InternalInvariant,
            "transform construction produced a null expression",
            operation);
    }
 
    if (te_contains_transform(LMCAS::detail::node(expr))) {
        return TransformEngineResult::failure(
            CasErrc::Inconclusive,
            "transform is outside the current evaluated support domain",
            operation);
    }
 
    return TransformEngineResult::success(
        Verified<EvaluatedTransform>{
            EvaluatedTransform{std::move(expr), {}, {}},
            ByConstructionProof{}});
}

引用了 LMCAS::Result< Verified< EvaluatedTransform > >::failure(), LMCAS::Inconclusive, LMCAS::InternalInvariant, LMCAS::detail::node(), LMCAS::Result< Verified< EvaluatedTransform > >::success(), te_contains_transform() , 以及 te_wrap_transform_result().

被这些函数引用 LMCAS::fourier_transform_checked(), LMCAS::inverse_fourier_transform_checked(), LMCAS::inverse_laplace_checked(), LMCAS::laplace_transform_checked(), LMCAS::te_convolve_core(), LMCAS::te_convolve_sum(), te_wrap_transform_result() , 以及 LMCAS::z_transform_checked().

函数调用图:

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