LMCAS::vector_calculus_detail 命名空间参考

函数
VectorField	curl_impl (const VectorField &F, const std::vector< std::string > &vars, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	curve_integral_scalar_strict (const std::shared_ptr< SymbolicExpr > &function, const VectorField &parametrization, const std::string &parameter, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	curve_integral_vector_strict (const VectorField &field, const VectorField &parametrization, const std::string &parameter, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	directional_derivative_impl (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, const VectorField &direction, int order, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	divergence_impl (const VectorField &F, const std::vector< std::string > &vars, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	divergence_theorem_strict (const VectorField &field, const std::vector< std::string > &variables, 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, const std::string &operation, detail::RewriteBudget &transform_budget)
VectorField	gradient_impl (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	greens_theorem_area_strict (const VectorField &parametrization, const std::string &parameter, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, const std::string &operation, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	greens_theorem_strict (const std::shared_ptr< SymbolicExpr > &p, const std::shared_ptr< SymbolicExpr > &q, const std::vector< std::string > &variables, 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, const std::string &operation, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	hessian_impl (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	jacobian_impl (const std::vector< std::shared_ptr< SymbolicExpr > > &functions, const std::vector< std::string > &vars, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	laplacian_impl (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	stokes_theorem_strict (const VectorField &field, const std::vector< std::string > &variables, 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, const std::string &operation, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	surface_integral_scalar_strict (const std::shared_ptr< SymbolicExpr > &function, 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, const std::string &operation, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	surface_integral_vector_strict (const VectorField &field, 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, const std::string &operation, detail::RewriteBudget &transform_budget)
bool	vector_calculus_checked_finite_numeric (const std::shared_ptr< SymbolicExpr > &expr, double &value, ComputationContext &context)
std::vector< std::string >	vector_calculus_coord_vars (std::size_t dimension)
std::shared_ptr< SymbolicExpr >	vector_calculus_cross_component (const VectorField &left, const VectorField &right, std::size_t index)
VectorField	vector_calculus_cross_product_partials (const VectorField &parametrization, const std::string &u, const std::string &v, detail::RewriteBudget &transform_budget)
VectorCalculusExprResult	vector_calculus_differentiate_strict (const std::shared_ptr< SymbolicExpr > &expr, const std::string &variable, const std::string &operation, detail::RewriteBudget &transform_budget)
bool	vector_calculus_expr_zero_after_substitution (const std::shared_ptr< SymbolicExpr > &expr, const std::map< std::string, std::shared_ptr< SymbolicExpr > > &point, ComputationContext &context, detail::RewriteBudget &transform_budget)
std::shared_ptr< SymbolicExpr >	vector_calculus_integrate_with_fallback (const std::shared_ptr< SymbolicExpr > &integrand, const std::string &variable, const std::shared_ptr< SymbolicExpr > &lower, const std::shared_ptr< SymbolicExpr > &upper, ComputationContext &context, detail::RewriteBudget &transform_budget)
bool	vector_calculus_point_has_vars (const std::map< std::string, std::shared_ptr< SymbolicExpr > > &point, const std::vector< std::string > &vars)
VectorCalculusExprResult	vector_calculus_simplify_strict (const std::shared_ptr< SymbolicExpr > &expr, const std::string &operation, const std::string &message, detail::RewriteBudget &transform_budget)
Result< void >	vector_calculus_validate_bound_pair (const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &bounds, ComputationContext &context, const std::string &operation, const std::string &label)
Result< void >	vector_calculus_validate_curve_parametrization (const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context, const std::string &operation)
Result< void >	vector_calculus_validate_curve_scalar_inputs (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, const std::string &operation)
Result< void >	vector_calculus_validate_curve_vector_inputs (const VectorField &F, const VectorField &parametrization, const std::string &t, const std::shared_ptr< SymbolicExpr > &a, const std::shared_ptr< SymbolicExpr > &b, ComputationContext &context, const std::string &operation)
Result< void >	vector_calculus_validate_distinct_vars (const std::vector< std::string > &vars, std::size_t expected, ComputationContext &context, const std::string &operation)
Result< void >	vector_calculus_validate_expr_vars (const std::shared_ptr< SymbolicExpr > &f, const std::vector< std::string > &vars, ComputationContext &context, const std::string &operation)
Result< void >	vector_calculus_validate_field_vars (const VectorField &field, const std::vector< std::string > &vars, ComputationContext &context, const std::string &operation)
Result< void >	vector_calculus_validate_functions_vars (const std::vector< std::shared_ptr< SymbolicExpr > > &functions, const std::vector< std::string > &vars, ComputationContext &context, const std::string &operation)
static Result< void >	vector_calculus_validate_surface_bounds (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, const std::string &operation)
Result< void >	vector_calculus_validate_surface_parametrization (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, const std::string &operation)
Result< void >	vector_calculus_validate_surface_scalar_inputs (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, const std::string &operation)
Result< void >	vector_calculus_validate_surface_vector_inputs (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, const std::string &operation)
VectorCalculusExprResult	vector_calculus_wrap_expr (std::shared_ptr< SymbolicExpr > expr, const std::string &operation)
VectorCalculusFieldResult	vector_calculus_wrap_field (VectorField field, const std::string &operation)

函数说明

curl_impl()

VectorField LMCAS::vector_calculus_detail::curl_impl	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		detail::RewriteBudget &	transform_budget )

二维标量旋度: ∂F₂/∂x₁ - ∂F₁/∂x₂

三维旋度

curl_x = ∂F₃/∂x₂ - ∂F₂/∂x₃

curl_y = ∂F₁/∂x₃ - ∂F₃/∂x₁

curl_z = ∂F₂/∂x₁ - ∂F₁/∂x₂

在文件 vector_calculus_differential.cpp 第 194 行定义.

{
    if (F.size() != vars.size()) {
        throw std::invalid_argument(
            "curl: F and vars must have the same dimension");
    }
 
    /// 二维标量旋度: ∂F₂/∂x₁ - ∂F₁/∂x₂
    if (F.size() == 2 && vars.size() == 2) {
        auto dF2_dx1 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[1]), vars[0], transform_budget));
        auto dF1_dx2 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[0]), vars[1], transform_budget));
 
        auto neg_dF1_dx2 = SymbolicExpr::multiply(
            SymbolicExpr::number(-1), dF1_dx2);
        auto scalar_curl = SymbolicExpr::add(dF2_dx1, neg_dF1_dx2);
        scalar_curl = detail::make_expression_ptr(detail::normalize_node(detail::node(scalar_curl), transform_budget));
 
        return VectorField{scalar_curl};
    }
 
    /// 三维旋度
    if (F.size() != 3 || vars.size() != 3) {
        throw std::invalid_argument(
            "curl: requires 2D or 3D vector field");
    }
 
    /// curl_x = ∂F₃/∂x₂ - ∂F₂/∂x₃
    auto dF3_dx2 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[2]), vars[1], transform_budget));
    auto dF2_dx3 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[1]), vars[2], transform_budget));
    auto curl_x = SymbolicExpr::add(
        dF3_dx2,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dF2_dx3));
    curl_x = detail::make_expression_ptr(detail::normalize_node(detail::node(curl_x), transform_budget));
 
    /// curl_y = ∂F₁/∂x₃ - ∂F₃/∂x₁
    auto dF1_dx3 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[0]), vars[2], transform_budget));
    auto dF3_dx1 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[2]), vars[0], transform_budget));
    auto curl_y = SymbolicExpr::add(
        dF1_dx3,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dF3_dx1));
    curl_y = detail::make_expression_ptr(detail::normalize_node(detail::node(curl_y), transform_budget));
 
    /// curl_z = ∂F₂/∂x₁ - ∂F₁/∂x₂
    auto dF2_dx1 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[1]), vars[0], transform_budget));
    auto dF1_dx2 = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[0]), vars[1], transform_budget));
    auto curl_z = SymbolicExpr::add(
        dF2_dx1,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dF1_dx2));
    curl_z = detail::make_expression_ptr(detail::normalize_node(detail::node(curl_z), transform_budget));
 
    VectorField result{curl_x, curl_y, curl_z};
    std::size_t nodes = 0;
    for (const auto& component : result) {
        nodes = transform_budget.append_size(
            nodes, transform_budget.measure(detail::node(component)));
    }
    return result;
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::vars.

被这些函数引用 LMCAS::curl(), LMCAS::curl_checked(), LMCAS::stokes_theorem() , 以及 vector_calculus_coord_vars().

函数调用图:

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

curve_integral_scalar_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::curve_integral_scalar_strict	(	const std::shared_ptr< SymbolicExpr > &	function,
		const VectorField &	parametrization,
		const std::string &	parameter,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 278 行定义.

{
    const auto coord_vars = vector_calculus_coord_vars(parametrization.size());
    auto f_composed = vector_calculus_substitute_coords_strict(f, coord_vars, parametrization, operation, transform_budget);
    if (!f_composed) {
        return f_composed;
    }
 
    std::shared_ptr<SymbolicExpr> speed_sq;
    for (const auto& component : parametrization) {
        auto derivative = vector_calculus_differentiate_strict(component, t, operation, transform_budget);
        if (!derivative) {
            return derivative;
        }
        auto sq = SymbolicExpr::power(derivative.value(), SymbolicExpr::number(2));
        auto sq_checked = vector_calculus_simplify_strict(sq, operation, "curve speed construction is outside the supported domain", transform_budget);
        if (!sq_checked) {
            return sq_checked;
        }
        speed_sq = speed_sq ? SymbolicExpr::add(speed_sq, sq_checked.value())
                            : sq_checked.value();
        auto speed_sq_checked = vector_calculus_simplify_strict(speed_sq, operation, "curve speed construction is outside the supported domain", transform_budget);
        if (!speed_sq_checked) {
            return speed_sq_checked;
        }
        speed_sq = std::move(speed_sq_checked.value());
    }
 
    auto speed = SymbolicExpr::sqrt(speed_sq);
    auto speed_checked = vector_calculus_simplify_strict(speed, operation, "curve speed construction is outside the supported domain", transform_budget);
    if (!speed_checked) {
        return speed_checked;
    }
 
    auto integrand = SymbolicExpr::multiply(f_composed.value(), speed_checked.value());
    auto integrand_checked = vector_calculus_simplify_strict(integrand, operation, "curve integrand construction is outside the supported domain", transform_budget);
    if (!integrand_checked) {
        return integrand_checked;
    }
 
    return vector_calculus_definite_integral_strict(integrand_checked.value(), t, a, b, context, operation, transform_budget);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::parametrization, LMCAS::t, vector_calculus_coord_vars(), LMCAS::vector_calculus_definite_integral_strict(), vector_calculus_differentiate_strict(), vector_calculus_simplify_strict() , 以及 LMCAS::vector_calculus_substitute_coords_strict().

被这些函数引用 LMCAS::curve_integral_scalar_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

curve_integral_vector_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::curve_integral_vector_strict	(	const VectorField &	field,
		const VectorField &	parametrization,
		const std::string &	parameter,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

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

{
    const auto coord_vars = vector_calculus_coord_vars(parametrization.size());
    std::shared_ptr<SymbolicExpr> dot_product;
    for (size_t i = 0; i < F.size(); ++i) {
        auto Fi_composed = vector_calculus_substitute_coords_strict(F[i], coord_vars, parametrization, operation, transform_budget);
        if (!Fi_composed) return Fi_composed;
 
        auto ri_prime = vector_calculus_differentiate_strict(parametrization[i], t, operation, transform_budget);
        if (!ri_prime) return ri_prime;
 
        auto term = SymbolicExpr::multiply(Fi_composed.value(), ri_prime.value());
        auto term_checked = vector_calculus_simplify_strict(term, operation, "curve integrand construction is outside the supported domain", 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, "curve integrand construction is outside the supported domain", transform_budget);
        if (!dot_checked) return dot_checked;
        dot_product = std::move(dot_checked.value());
    }
 
    return vector_calculus_definite_integral_strict(dot_product, t, a, b, context, operation, transform_budget);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::dot_product(), LMCAS::parametrization, LMCAS::t, LMCAS::Result< T >::value(), vector_calculus_coord_vars(), LMCAS::vector_calculus_definite_integral_strict(), vector_calculus_differentiate_strict(), vector_calculus_simplify_strict() , 以及 LMCAS::vector_calculus_substitute_coords_strict().

被这些函数引用 LMCAS::curve_integral_vector_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

directional_derivative_impl()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::directional_derivative_impl	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		const VectorField &	direction,
		int	order,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_directional.cpp 第 128 行定义.

{
    if (!f) {
        throw std::invalid_argument("directional_derivative: f must not be null");
    }
    if (direction.size() != vars.size()) {
        throw std::invalid_argument(
            "directional_derivative: direction and vars must have the same dimension");
    }
    if (order < 1) {
        throw std::invalid_argument(
            "directional_derivative: order must be >= 1");
    }
 
    auto mag_sq = vector_calculus_magnitude_squared(direction, transform_budget);
    if (!mag_sq || mag_sq->is_zero()) {
        return nullptr;
    }
 
    auto magnitude = SymbolicExpr::sqrt(mag_sq);
    magnitude = detail::make_expression_ptr(detail::normalize_node(detail::node(magnitude), transform_budget));
    VectorField unit_dir;
    unit_dir.reserve(direction.size());
    for (const auto& comp : direction) {
        if (!comp || comp->is_zero()) {
            unit_dir.push_back(SymbolicExpr::number(0));
        } else {
            auto u_comp = SymbolicExpr::multiply(
                comp,
                SymbolicExpr::power(magnitude, SymbolicExpr::number(-1)));
            u_comp = detail::make_expression_ptr(detail::normalize_node(detail::node(u_comp), transform_budget));
            unit_dir.push_back(u_comp);
        }
    }
 
    auto result = f;
    for (int k = 0; k < order; ++k) {
        result = vector_calculus_single_dir_deriv(result, vars, unit_dir, transform_budget);
        if (!result) {
            return SymbolicExpr::number(0);
        }
    }
 
    return result;
}

引用了 LMCAS::direction, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::order, LMCAS::vars, LMCAS::vector_calculus_magnitude_squared() , 以及 LMCAS::vector_calculus_single_dir_deriv().

被这些函数引用 LMCAS::directional_derivative(), LMCAS::directional_derivative_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

divergence_impl()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::divergence_impl	(	const VectorField &	F,
		const std::vector< std::string > &	vars,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_differential.cpp 第 112 行定义.

{
    if (F.size() != vars.size()) {
        throw std::invalid_argument(
            "divergence: F and vars must have the same dimension");
    }
    if (F.empty()) {
        return SymbolicExpr::number(0);
    }
 
    std::shared_ptr<SymbolicExpr> sum = nullptr;
    for (size_t i = 0; i < F.size(); ++i) {
        if (!F[i]) {
            continue;
        }
        auto partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(F[i]), vars[i], transform_budget));
        if (!partial) {
            continue;
        }
        partial = detail::make_expression_ptr(detail::normalize_node(detail::node(partial), transform_budget));
        if (!sum) {
            sum = partial;
        } else {
            sum = SymbolicExpr::add(sum, partial);
            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() , 以及 LMCAS::vars.

被这些函数引用 LMCAS::divergence(), LMCAS::divergence_checked(), LMCAS::divergence_theorem() , 以及 vector_calculus_coord_vars().

函数调用图:

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

divergence_theorem_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::divergence_theorem_strict	(	const VectorField &	field,
		const std::vector< std::string > &	variables,
		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,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 544 行定义.

{
    std::shared_ptr<SymbolicExpr> div_F;
    for (size_t i = 0; i < 3; ++i) {
        auto partial = vector_calculus_differentiate_strict(F[i], vars[i], operation, transform_budget);
        if (!partial) return partial;
        div_F = div_F ? SymbolicExpr::add(div_F, partial.value()) : partial.value();
        auto div_checked = vector_calculus_simplify_strict(div_F, operation, "divergence theorem integrand is outside the supported domain", transform_budget);
        if (!div_checked) return div_checked;
        div_F = std::move(div_checked.value());
    }
 
    std::vector<IntegrationStep> steps;
    steps.push_back({vars[2], z_bounds.first, z_bounds.second});
    steps.push_back({vars[1], y_bounds.first, y_bounds.second});
    steps.push_back({vars[0], x_bounds.first, x_bounds.second});
    return vector_calculus_multiple_integral_strict(div_F, steps, context, operation, transform_budget);
}

引用了 LMCAS::context, LMCAS::steps, LMCAS::vars, vector_calculus_differentiate_strict(), LMCAS::vector_calculus_multiple_integral_strict(), vector_calculus_simplify_strict(), LMCAS::x_bounds, LMCAS::y_bounds , 以及 LMCAS::z_bounds.

被这些函数引用 LMCAS::divergence_theorem_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

gradient_impl()

VectorField LMCAS::vector_calculus_detail::gradient_impl	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_differential.cpp 第 49 行定义.

{
    if (!f) {
        throw std::invalid_argument("gradient: f must not be null");
    }
    VectorField result;
    transform_budget.require_nodes(vars.size());
    std::size_t nodes = 0;
    result.reserve(vars.size());
    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));
        }
        nodes = transform_budget.append_size(
            nodes, transform_budget.measure(detail::node(partial)));
        result.push_back(partial);
    }
    return result;
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 LMCAS::vars.

被这些函数引用 LMCAS::gradient(), LMCAS::gradient_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

greens_theorem_area_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::greens_theorem_area_strict	(	const VectorField &	parametrization,
		const std::string &	parameter,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 511 行定义.

{
    auto dx_dt = vector_calculus_differentiate_strict(parametrization[0], t, operation, transform_budget);
    if (!dx_dt) return dx_dt;
    auto dy_dt = vector_calculus_differentiate_strict(parametrization[1], t, operation, transform_budget);
    if (!dy_dt) return dy_dt;
 
    auto term1 = SymbolicExpr::multiply(parametrization[0], dy_dt.value());
    auto term2 = SymbolicExpr::multiply(parametrization[1], dx_dt.value());
    auto integrand = SymbolicExpr::add(
        term1,
        SymbolicExpr::multiply(SymbolicExpr::number(-1), term2));
    auto integrand_checked = vector_calculus_simplify_strict(integrand, operation, "Green's area integrand is outside the supported domain", transform_budget);
    if (!integrand_checked) return integrand_checked;
    integrand_checked = vector_calculus_constant_integrand(integrand_checked.value(), t, context, transform_budget);
    if (!integrand_checked) return integrand_checked;
 
    auto integral = vector_calculus_definite_integral_strict(integrand_checked.value(), t, a, b, context, operation, transform_budget);
    if (!integral) return integral;
 
    auto half = LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<NumberNode>(Rational(1, 2)));
    auto area = SymbolicExpr::multiply(half, integral.value());
    return vector_calculus_simplify_strict(area, operation, "Green's area result is outside the supported domain", transform_budget);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::parametrization, LMCAS::t, LMCAS::Result< T >::value(), LMCAS::vector_calculus_constant_integrand(), LMCAS::vector_calculus_definite_integral_strict(), vector_calculus_differentiate_strict() , 以及 vector_calculus_simplify_strict().

被这些函数引用 LMCAS::greens_theorem_area_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

greens_theorem_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::greens_theorem_strict	(	const std::shared_ptr< SymbolicExpr > &	p,
		const std::shared_ptr< SymbolicExpr > &	q,
		const std::vector< std::string > &	variables,
		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,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 459 行定义.

{
    auto dQ_dx = vector_calculus_differentiate_strict(Q, vars[0], operation, transform_budget);
    if (!dQ_dx) return dQ_dx;
    auto dP_dy = vector_calculus_differentiate_strict(P, vars[1], operation, transform_budget);
    if (!dP_dy) return dP_dy;
 
    auto integrand = SymbolicExpr::add(
        dQ_dx.value(),
        SymbolicExpr::multiply(SymbolicExpr::number(-1), dP_dy.value()));
    auto integrand_checked = vector_calculus_simplify_strict(integrand, operation, "Green's theorem integrand is outside the supported domain", transform_budget);
    if (!integrand_checked) return integrand_checked;
 
    std::vector<IntegrationStep> steps;
    steps.push_back({vars[1], y_bounds.first, y_bounds.second});
    steps.push_back({vars[0], x_bounds.first, x_bounds.second});
    return vector_calculus_multiple_integral_strict(integrand_checked.value(), steps, context, operation, transform_budget);
}

引用了 LMCAS::context, LMCAS::steps, LMCAS::vars, vector_calculus_differentiate_strict(), LMCAS::vector_calculus_multiple_integral_strict(), vector_calculus_simplify_strict(), LMCAS::x_bounds , 以及 LMCAS::y_bounds.

被这些函数引用 LMCAS::greens_theorem_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

hessian_impl()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::hessian_impl	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_matrices.cpp 第 119 行定义.

{
    size_t n = vars.size();
    std::size_t nodes = 1;
    transform_budget.require_nodes(nodes);
 
    std::vector<std::shared_ptr<SymbolicExpr>> first_partials;
    first_partials.reserve(n);
    for (size_t i = 0; i < n; ++i) {
        first_partials.push_back(detail::make_expression_ptr(detail::differentiate_node(detail::node(f), vars[i], transform_budget)));
    }
 
    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 = i; j < n; ++j) {
            auto second_partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(first_partials[i]), vars[j], transform_budget));
            second_partial = detail::make_expression_ptr(detail::normalize_node(detail::node(second_partial), transform_budget));
            const auto partial_nodes = transform_budget.measure(detail::node(second_partial));
            nodes = transform_budget.append_size(nodes, partial_nodes);
            if (i != j) nodes = transform_budget.append_size(nodes, partial_nodes);
            grid[i][j] = second_partial;
            if (i != j) {
                grid[j][i] = second_partial;
            }
        }
    }
 
    return SymbolicExpr::matrix(grid);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 LMCAS::vars.

被这些函数引用 LMCAS::find_extrema_impl(), LMCAS::hessian(), LMCAS::hessian_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

jacobian_impl()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::jacobian_impl	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	functions,
		const std::vector< std::string > &	vars,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_matrices.cpp 第 50 行定义.

{
    size_t m = functions.size();
    size_t n = vars.size();
    std::size_t nodes = 1;
    transform_budget.require_nodes(nodes);
 
    std::vector<std::vector<std::shared_ptr<SymbolicExpr>>> grid;
    grid.reserve(m);
 
    for (size_t i = 0; i < m; ++i) {
        std::vector<std::shared_ptr<SymbolicExpr>> row;
        row.reserve(n);
        for (size_t j = 0; j < n; ++j) {
            auto partial = detail::make_expression_ptr(detail::differentiate_node(detail::node(functions[i]), vars[j], transform_budget));
            partial = detail::make_expression_ptr(detail::normalize_node(detail::node(partial), transform_budget));
            nodes = transform_budget.append_size(
                nodes, transform_budget.measure(detail::node(partial)));
            row.push_back(partial);
        }
        grid.push_back(std::move(row));
    }
 
    return SymbolicExpr::matrix(grid);
}

引用了 LMCAS::detail::RewriteBudget::append_size(), LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::detail::RewriteBudget::require_nodes() , 以及 LMCAS::vars.

被这些函数引用 LMCAS::jacobian(), LMCAS::jacobian_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

laplacian_impl()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::laplacian_impl	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_differential.cpp 第 295 行定义.

{
    if (!f) {
        throw std::invalid_argument("laplacian: f must not be null");
    }
    if (vars.empty()) {
        return SymbolicExpr::number(0);
    }
 
    std::shared_ptr<SymbolicExpr> sum = nullptr;
    for (const auto& var : vars) {
        auto first = detail::make_expression_ptr(detail::differentiate_node(detail::node(f), var, transform_budget));
        if (!first) {
            continue;
        }
        auto second = detail::make_expression_ptr(detail::differentiate_node(detail::node(first), var, transform_budget));
        if (!second) {
            continue;
        }
        second = detail::make_expression_ptr(detail::normalize_node(detail::node(second), transform_budget));
        if (!sum) {
            sum = second;
        } else {
            sum = SymbolicExpr::add(sum, second);
            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() , 以及 LMCAS::vars.

被这些函数引用 LMCAS::laplacian(), LMCAS::laplacian_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

stokes_theorem_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::stokes_theorem_strict	(	const VectorField &	field,
		const std::vector< std::string > &	variables,
		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,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 632 行定义.

{
    auto curl_F = vector_calculus_curl_strict(F, vars, operation, transform_budget);
    if (!curl_F) return VectorCalculusExprResult::failure(curl_F.error());
 
    auto cross = vector_calculus_cross_product_partials_strict(parametrization, u, v, operation, transform_budget);
    if (!cross) return VectorCalculusExprResult::failure(cross.error());
 
    auto dot_product = vector_calculus_surface_dot_strict(curl_F.value(), vars, parametrization, cross.value(),
    "Stokes theorem integrand is outside the supported domain",
    operation, transform_budget);
    if (!dot_product) return dot_product;
 
    std::vector<IntegrationStep> steps;
    steps.push_back({v, v_bounds.first, v_bounds.second});
    steps.push_back({u, u_bounds.first, u_bounds.second});
    return vector_calculus_multiple_integral_strict(dot_product.value(), steps, context, operation, transform_budget);
}

引用了 LMCAS::context, LMCAS::dot_product(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::parametrization, LMCAS::steps, LMCAS::u, LMCAS::u_bounds, LMCAS::v, LMCAS::v_bounds, LMCAS::Result< T >::value(), LMCAS::vars, LMCAS::vector_calculus_cross_product_partials_strict(), LMCAS::vector_calculus_curl_strict(), LMCAS::vector_calculus_multiple_integral_strict() , 以及 LMCAS::vector_calculus_surface_dot_strict().

被这些函数引用 LMCAS::stokes_theorem_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

surface_integral_scalar_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::surface_integral_scalar_strict	(	const std::shared_ptr< SymbolicExpr > &	function,
		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,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 360 行定义.

{
    const std::vector<std::string> coord_vars = {"x", "y", "z"};
    auto f_composed = vector_calculus_substitute_coords_strict(f, coord_vars, parametrization, operation, transform_budget);
    if (!f_composed) return f_composed;
 
    auto cross = vector_calculus_cross_product_partials_strict(parametrization, u, v, operation, transform_budget);
    if (!cross) return VectorCalculusExprResult::failure(cross.error());
 
    std::shared_ptr<SymbolicExpr> mag_sq;
    for (const auto& component : cross.value()) {
        auto sq = SymbolicExpr::power(component, SymbolicExpr::number(2));
        auto sq_checked = vector_calculus_simplify_strict(sq, operation, "surface magnitude construction is outside the supported domain", transform_budget);
        if (!sq_checked) return sq_checked;
        mag_sq = mag_sq ? SymbolicExpr::add(mag_sq, sq_checked.value())
                        : sq_checked.value();
        auto mag_sq_checked = vector_calculus_simplify_strict(mag_sq, operation, "surface magnitude construction is outside the supported domain", transform_budget);
        if (!mag_sq_checked) return mag_sq_checked;
        mag_sq = std::move(mag_sq_checked.value());
    }
 
    auto magnitude = SymbolicExpr::sqrt(mag_sq);
    auto magnitude_checked = vector_calculus_simplify_strict(magnitude, operation, "surface magnitude construction is outside the supported domain", transform_budget);
    if (!magnitude_checked) return magnitude_checked;
 
    auto integrand = SymbolicExpr::multiply(f_composed.value(), magnitude_checked.value());
    auto integrand_checked = vector_calculus_simplify_strict(integrand, operation, "surface integrand construction is outside the supported domain", transform_budget);
    if (!integrand_checked) return integrand_checked;
 
    std::vector<IntegrationStep> steps;
    steps.push_back({v, v_lower, v_upper});
    steps.push_back({u, u_lower, u_upper});
    return vector_calculus_multiple_integral_strict(integrand_checked.value(), steps, context, operation, transform_budget);
}

引用了 LMCAS::context, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::parametrization, LMCAS::steps, LMCAS::u, LMCAS::u_lower, LMCAS::u_upper, LMCAS::v, LMCAS::v_lower, LMCAS::v_upper, LMCAS::vector_calculus_cross_product_partials_strict(), LMCAS::vector_calculus_multiple_integral_strict(), vector_calculus_simplify_strict() , 以及 LMCAS::vector_calculus_substitute_coords_strict().

被这些函数引用 LMCAS::surface_integral_scalar_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

surface_integral_vector_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::surface_integral_vector_strict	(	const VectorField &	field,
		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,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 435 行定义.

{
    const std::vector<std::string> coord_vars = {"x", "y", "z"};
    auto cross = vector_calculus_cross_product_partials_strict(parametrization, u, v, operation, transform_budget);
    if (!cross) return VectorCalculusExprResult::failure(cross.error());
 
    auto dot_product = vector_calculus_surface_dot_strict(F, coord_vars, parametrization, cross.value(),
    "surface integrand construction is outside the supported domain",
    operation, transform_budget);
    if (!dot_product) return dot_product;
 
    std::vector<IntegrationStep> steps;
    steps.push_back({v, v_lower, v_upper});
    steps.push_back({u, u_lower, u_upper});
    return vector_calculus_multiple_integral_strict(dot_product.value(), steps, context, operation, transform_budget);
}

引用了 LMCAS::context, LMCAS::dot_product(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::parametrization, LMCAS::steps, LMCAS::u, LMCAS::u_lower, LMCAS::u_upper, LMCAS::v, LMCAS::v_lower, LMCAS::v_upper, LMCAS::Result< T >::value(), LMCAS::vector_calculus_cross_product_partials_strict(), LMCAS::vector_calculus_multiple_integral_strict() , 以及 LMCAS::vector_calculus_surface_dot_strict().

被这些函数引用 LMCAS::surface_integral_vector_checked() , 以及 vector_calculus_coord_vars().

函数调用图:

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

vector_calculus_checked_finite_numeric()

bool LMCAS::vector_calculus_detail::vector_calculus_checked_finite_numeric	(	const std::shared_ptr< SymbolicExpr > &	expr,
		double &	value,
		ComputationContext &	context )

在文件 vector_calculus_support.cpp 第 19 行定义.

{
    if (!expr) return false;
    auto numeric = detail::try_finite_numeric(*expr, context);
    if (!numeric) return false;
    value = *numeric;
    return true;
}

引用了 LMCAS::context, LMCAS::detail::try_finite_numeric(), LMCAS::value , 以及 vector_calculus_checked_finite_numeric().

被这些函数引用 LMCAS::classify_hessian_eigenvalues(), vector_calculus_checked_finite_numeric(), vector_calculus_coord_vars(), LMCAS::vector_calculus_evaluate_hessian_at_point(), vector_calculus_expr_zero_after_substitution() , 以及 LMCAS::vector_calculus_numerical_definite().

函数调用图:

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

vector_calculus_coord_vars()

std::vector< std::string > LMCAS::vector_calculus_detail::vector_calculus_coord_vars

(

std::size_t

dimension

)

引用了 LMCAS::a, LMCAS::b, LMCAS::context, curl_impl(), curve_integral_scalar_strict(), curve_integral_vector_strict(), LMCAS::direction, directional_derivative_impl(), divergence_impl(), divergence_theorem_strict(), LMCAS::function(), gradient_impl(), greens_theorem_area_strict(), greens_theorem_strict(), hessian_impl(), jacobian_impl(), laplacian_impl(), LMCAS::lower, LMCAS::order, LMCAS::parametrization, LMCAS::point, LMCAS::right, stokes_theorem_strict(), surface_integral_scalar_strict(), surface_integral_vector_strict(), LMCAS::t, LMCAS::u, LMCAS::u_bounds, LMCAS::u_lower, LMCAS::u_upper, LMCAS::upper, LMCAS::v, LMCAS::v_bounds, LMCAS::v_lower, LMCAS::v_upper, LMCAS::value, LMCAS::variable, LMCAS::vars, vector_calculus_checked_finite_numeric(), vector_calculus_coord_vars(), vector_calculus_cross_component(), vector_calculus_cross_product_partials(), vector_calculus_differentiate_strict(), vector_calculus_expr_zero_after_substitution(), vector_calculus_integrate_with_fallback(), vector_calculus_point_has_vars(), vector_calculus_simplify_strict(), vector_calculus_validate_bound_pair(), vector_calculus_validate_curve_parametrization(), vector_calculus_validate_curve_scalar_inputs(), vector_calculus_validate_curve_vector_inputs(), vector_calculus_validate_distinct_vars(), vector_calculus_validate_expr_vars(), vector_calculus_validate_field_vars(), vector_calculus_validate_functions_vars(), vector_calculus_validate_surface_parametrization(), vector_calculus_validate_surface_scalar_inputs(), vector_calculus_validate_surface_vector_inputs(), vector_calculus_wrap_expr(), vector_calculus_wrap_field(), LMCAS::x_bounds, LMCAS::y_bounds , 以及 LMCAS::z_bounds.

被这些函数引用 LMCAS::curve_integral_scalar(), curve_integral_scalar_strict(), LMCAS::curve_integral_vector(), curve_integral_vector_strict() , 以及 vector_calculus_coord_vars().

函数调用图:

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

vector_calculus_cross_component()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::vector_calculus_cross_component	(	const VectorField &	left,
		const VectorField &	right,
		std::size_t	index )

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

                                                                        {
    static constexpr std::size_t first[] = {1, 2, 0};
    static constexpr std::size_t second[] = {2, 0, 1};
    return SymbolicExpr::add(
        SymbolicExpr::multiply(left[first[index]], right[second[index]]),
        SymbolicExpr::multiply(
            SymbolicExpr::number(-1),
            SymbolicExpr::multiply(
                left[second[index]], right[first[index]])));
}

引用了 LMCAS::right.

被这些函数引用 LMCAS::cross_product_impl(), vector_calculus_coord_vars(), vector_calculus_cross_product_partials() , 以及 LMCAS::vector_calculus_cross_product_partials_strict().

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

vector_calculus_cross_product_partials()

VectorField LMCAS::vector_calculus_detail::vector_calculus_cross_product_partials	(	const VectorField &	parametrization,
		const std::string &	u,
		const std::string &	v,
		detail::RewriteBudget &	transform_budget )

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

{
    VectorField r_u;
    r_u.reserve(3);
    for (size_t i = 0; i < 3; ++i) {
        auto deriv = detail::make_expression_ptr(detail::differentiate_node(detail::node(parametrization[i]), u, transform_budget));
        r_u.push_back(deriv ? detail::make_expression_ptr(detail::normalize_node(detail::node(deriv), transform_budget)) : SymbolicExpr::number(0));
    }
 
    VectorField r_v;
    r_v.reserve(3);
    for (size_t i = 0; i < 3; ++i) {
        auto deriv = detail::make_expression_ptr(detail::differentiate_node(detail::node(parametrization[i]), v, transform_budget));
        r_v.push_back(deriv ? detail::make_expression_ptr(detail::normalize_node(detail::node(deriv), transform_budget)) : SymbolicExpr::number(0));
    }
 
    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(r_u, r_v, index)), transform_budget)));
    }
    return result;
}

引用了 LMCAS::detail::differentiate_node(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::parametrization, LMCAS::u, LMCAS::v , 以及 vector_calculus_cross_component().

被这些函数引用 LMCAS::stokes_theorem(), LMCAS::surface_integral_scalar(), LMCAS::surface_integral_vector() , 以及 vector_calculus_coord_vars().

函数调用图:

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

vector_calculus_differentiate_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::vector_calculus_differentiate_strict	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	variable,
		const std::string &	operation,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 154 行定义.

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return vector_calculus_inconclusive(
            operation, "expression derivative is outside the supported domain");
    }
    try {
        auto derivative = detail::make_expression_ptr(detail::differentiate_node(detail::node(expr), var, transform_budget));
        return vector_calculus_simplify_strict(derivative, operation,
        "expression derivative is outside the supported domain", transform_budget);
    } catch (const CasError& error) {
        if (error.code != CasErrc::UnsupportedExpression) {
            return VectorCalculusExprResult::failure(error);
        }
        return vector_calculus_inconclusive(
            operation, "expression derivative is outside the supported domain");
    }
}

引用了 LMCAS::CasError::code, LMCAS::detail::differentiate_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::UnsupportedExpression, LMCAS::vector_calculus_inconclusive() , 以及 vector_calculus_simplify_strict().

被这些函数引用 curve_integral_scalar_strict(), curve_integral_vector_strict(), divergence_theorem_strict(), LMCAS::find_extrema_checked(), greens_theorem_area_strict(), greens_theorem_strict(), LMCAS::lagrange_gradient_strict(), vector_calculus_coord_vars(), LMCAS::vector_calculus_cross_product_partials_strict() , 以及 LMCAS::vector_calculus_curl_strict().

函数调用图:

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

vector_calculus_expr_zero_after_substitution()

bool LMCAS::vector_calculus_detail::vector_calculus_expr_zero_after_substitution	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::map< std::string, std::shared_ptr< SymbolicExpr > > &	point,
		ComputationContext &	context,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_support.cpp 第 376 行定义.

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return false;
    }
    auto substituted = expr;
    for (const auto& [var, value] : point) {
        if (!value || !LMCAS::detail::node(value)) {
            return false;
        }
        substituted = detail::make_expression_ptr(detail::substitute_node(detail::node(substituted), var, detail::node(value), transform_budget));
        if (!substituted || !LMCAS::detail::node(substituted)) {
            return false;
        }
    }
    substituted = detail::make_expression_ptr(detail::normalize_node(detail::node(substituted), transform_budget));
    if (!substituted || !LMCAS::detail::node(substituted)) {
        return false;
    }
    if (substituted->is_zero()) {
        return true;
    }
    double value = 0.0;
    return vector_calculus_checked_finite_numeric(substituted, value, context) &&
           std::abs(value) < 1e-8;
}

引用了 LMCAS::context, LMCAS::e(), LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::point, LMCAS::detail::substitute_node(), LMCAS::value, vector_calculus_checked_finite_numeric() , 以及 vector_calculus_expr_zero_after_substitution().

被这些函数引用 LMCAS::find_extrema_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_expr_zero_after_substitution().

函数调用图:

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

vector_calculus_integrate_with_fallback()

std::shared_ptr< SymbolicExpr > LMCAS::vector_calculus_detail::vector_calculus_integrate_with_fallback	(	const std::shared_ptr< SymbolicExpr > &	integrand,
		const std::string &	variable,
		const std::shared_ptr< SymbolicExpr > &	lower,
		const std::shared_ptr< SymbolicExpr > &	upper,
		ComputationContext &	context,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 112 行定义.

{
    auto symbolic_result = vector_calculus_try_definite(integrand, var, a, b, context, transform_budget);
    if (symbolic_result && symbolic_result.value()) {
        return std::move(symbolic_result.value());
    }
    if (!symbolic_result) throw symbolic_result.error();
    auto numerical_result = vector_calculus_numerical_definite(integrand, var, a, b, context, transform_budget);
    if (!numerical_result) throw numerical_result.error();
    return std::move(numerical_result.value());
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::vector_calculus_numerical_definite() , 以及 LMCAS::vector_calculus_try_definite().

被这些函数引用 LMCAS::curve_integral_scalar(), LMCAS::curve_integral_vector() , 以及 vector_calculus_coord_vars().

函数调用图:

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

vector_calculus_point_has_vars()

bool LMCAS::vector_calculus_detail::vector_calculus_point_has_vars	(	const std::map< std::string, std::shared_ptr< SymbolicExpr > > &	point,
		const std::vector< std::string > &	vars )

在文件 vector_calculus_support.cpp 第 407 行定义.

{
    for (const auto& var : vars) {
        auto it = point.find(var);
        if (it == point.end() || !it->second || !LMCAS::detail::node(it->second)) {
            return false;
        }
    }
    return true;
}

引用了 LMCAS::detail::node(), LMCAS::point, LMCAS::vars , 以及 vector_calculus_point_has_vars().

被这些函数引用 LMCAS::find_extrema_checked(), vector_calculus_coord_vars(), vector_calculus_point_has_vars() , 以及 LMCAS::verify_lagrange_solutions().

函数调用图:

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

vector_calculus_simplify_strict()

VectorCalculusExprResult LMCAS::vector_calculus_detail::vector_calculus_simplify_strict	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	operation,
		const std::string &	message,
		detail::RewriteBudget &	transform_budget )

在文件 vector_calculus_integrals.cpp 第 138 行定义.

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return vector_calculus_inconclusive(operation, message);
    }
    auto simplified = detail::make_expression_ptr(detail::normalize_node(detail::node(expr), transform_budget));
    if (!simplified || !LMCAS::detail::node(simplified)) {
        return vector_calculus_inconclusive(operation, message);
    }
    return VectorCalculusExprResult::success(std::move(simplified));
}

引用了 LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 LMCAS::vector_calculus_inconclusive().

被这些函数引用 curve_integral_scalar_strict(), curve_integral_vector_strict(), divergence_theorem_strict(), greens_theorem_area_strict(), greens_theorem_strict(), LMCAS::lagrange_multipliers_strict(), surface_integral_scalar_strict(), vector_calculus_coord_vars(), LMCAS::vector_calculus_cross_product_partials_strict(), LMCAS::vector_calculus_curl_strict(), vector_calculus_differentiate_strict(), LMCAS::vector_calculus_multiple_integral_strict(), LMCAS::vector_calculus_substitute_coords_strict() , 以及 LMCAS::vector_calculus_surface_dot_strict().

函数调用图:

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

vector_calculus_validate_bound_pair()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_bound_pair	(	const std::pair< std::shared_ptr< SymbolicExpr >, std::shared_ptr< SymbolicExpr > > &	bounds,
		ComputationContext &	context,
		const std::string &	operation,
		const std::string &	label )

在文件 vector_calculus_support.cpp 第 331 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!bounds.first || !LMCAS::detail::node(bounds.first) || !bounds.second || !LMCAS::detail::node(bounds.second)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     label + " bounds cannot be null",
                                     operation);
    }
    return Result<void>::success();
}

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

被这些函数引用 LMCAS::divergence_theorem_checked(), LMCAS::greens_theorem_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_bound_pair().

函数调用图:

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

vector_calculus_validate_curve_parametrization()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_curve_parametrization	(	const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 127 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (parametrization.size() != 2 && parametrization.size() != 3) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "curve parametrization must be two- or three-dimensional",
                                     operation);
    }
    if (t.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "parameter variable name cannot be empty",
                                     operation);
    }
    if (!a || !LMCAS::detail::node(a) || !b || !LMCAS::detail::node(b)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "curve integral bounds cannot be null",
                                     operation);
    }
    for (const auto& component : parametrization) {
        if (!component || !LMCAS::detail::node(component)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "curve parametrization components cannot be null",
                                         operation);
        }
    }
    return Result<void>::success();
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::parametrization, LMCAS::Result< T >::success(), LMCAS::t , 以及 vector_calculus_validate_curve_parametrization().

被这些函数引用 LMCAS::greens_theorem_area_checked(), vector_calculus_coord_vars(), vector_calculus_validate_curve_parametrization(), vector_calculus_validate_curve_scalar_inputs() , 以及 vector_calculus_validate_curve_vector_inputs().

函数调用图:

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

vector_calculus_validate_curve_scalar_inputs()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_curve_scalar_inputs	(	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,
		const std::string &	operation )

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

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!f || !LMCAS::detail::node(f)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "scalar field cannot be null",
                                     operation);
    }
    return vector_calculus_validate_curve_parametrization(
        parametrization, t, a, b, context, operation);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::parametrization, LMCAS::t, vector_calculus_validate_curve_parametrization() , 以及 vector_calculus_validate_curve_scalar_inputs().

被这些函数引用 LMCAS::curve_integral_scalar_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_curve_scalar_inputs().

函数调用图:

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

vector_calculus_validate_curve_vector_inputs()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_curve_vector_inputs	(	const VectorField &	F,
		const VectorField &	parametrization,
		const std::string &	t,
		const std::shared_ptr< SymbolicExpr > &	a,
		const std::shared_ptr< SymbolicExpr > &	b,
		ComputationContext &	context,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 182 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (F.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "vector field cannot be empty",
                                     operation);
    }
    if (F.size() != parametrization.size()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "vector field and parametrization must have the same dimension",
                                     operation);
    }
    for (const auto& component : F) {
        if (!component || !LMCAS::detail::node(component)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "vector field components cannot be null",
                                         operation);
        }
    }
    return vector_calculus_validate_curve_parametrization(
        parametrization, t, a, b, context, operation);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::parametrization, LMCAS::t, vector_calculus_validate_curve_parametrization() , 以及 vector_calculus_validate_curve_vector_inputs().

被这些函数引用 LMCAS::curve_integral_vector_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_curve_vector_inputs().

函数调用图:

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

vector_calculus_validate_distinct_vars()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_distinct_vars	(	const std::vector< std::string > &	vars,
		std::size_t	expected,
		ComputationContext &	context,
		const std::string &	operation )

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

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (vars.size() != expected) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "variable list has the wrong dimension",
                                     operation);
    }
    std::set<std::string> seen;
    for (const auto& var : vars) {
        if (var.empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable name cannot be empty",
                                         operation);
        }
        if (!seen.insert(var).second) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable names must be distinct",
                                         operation);
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 LMCAS::divergence_theorem_checked(), LMCAS::find_extrema_checked(), LMCAS::greens_theorem_checked(), LMCAS::lagrange_multipliers_checked(), LMCAS::stokes_theorem_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_distinct_vars().

函数调用图:

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

vector_calculus_validate_expr_vars()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_expr_vars	(	const std::shared_ptr< SymbolicExpr > &	f,
		const std::vector< std::string > &	vars,
		ComputationContext &	context,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 32 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!f || !LMCAS::detail::node(f)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "expression cannot be null", operation);
    }
    if (vars.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "variable list cannot be empty", operation);
    }
    for (const auto& var : vars) {
        if (var.empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable name cannot be empty",
                                         operation);
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 LMCAS::directional_derivative_checked(), LMCAS::find_extrema_checked(), LMCAS::gradient_checked(), LMCAS::hessian_checked(), LMCAS::lagrange_multipliers_checked(), LMCAS::laplacian_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_expr_vars().

函数调用图:

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

vector_calculus_validate_field_vars()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_field_vars	(	const VectorField &	field,
		const std::vector< std::string > &	vars,
		ComputationContext &	context,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 58 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (field.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "vector field cannot be empty", operation);
    }
    if (field.size() != vars.size()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "vector field and variables must have the same dimension",
                                     operation);
    }
    for (const auto& var : vars) {
        if (var.empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable name cannot be empty",
                                         operation);
        }
    }
    for (const auto& component : field) {
        if (!component || !LMCAS::detail::node(component)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "vector field components cannot be null",
                                         operation);
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 LMCAS::curl_checked(), LMCAS::directional_derivative_checked(), LMCAS::divergence_checked(), LMCAS::divergence_theorem_checked(), LMCAS::stokes_theorem_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_field_vars().

函数调用图:

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

vector_calculus_validate_functions_vars()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_functions_vars	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	functions,
		const std::vector< std::string > &	vars,
		ComputationContext &	context,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 92 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (functions.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "function list cannot be empty",
                                     operation);
    }
    if (vars.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "variable list cannot be empty",
                                     operation);
    }
    for (const auto& var : vars) {
        if (var.empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable name cannot be empty",
                                         operation);
        }
    }
    for (const auto& function : functions) {
        if (!function || !LMCAS::detail::node(function)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "function expressions cannot be null",
                                         operation);
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 LMCAS::jacobian_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_functions_vars().

函数调用图:

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

vector_calculus_validate_surface_bounds()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_surface_bounds ( 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, const std::string & operation )

static

在文件 vector_calculus_support.cpp 第 214 行定义.

{
    for (const auto* bound : {&u_lower, &u_upper, &v_lower, &v_upper}) {
        if (!*bound || !LMCAS::detail::node(*bound)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "surface integral bounds cannot be null",
                                         operation);
        }
    }
    return Result<void>::success();
}

引用了 LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::Result< T >::success(), LMCAS::u_lower, LMCAS::u_upper, LMCAS::v_lower, LMCAS::v_upper , 以及 vector_calculus_validate_surface_bounds().

被这些函数引用 vector_calculus_validate_surface_bounds() , 以及 vector_calculus_validate_surface_parametrization().

函数调用图:

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

vector_calculus_validate_surface_parametrization()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_surface_parametrization	(	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,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 231 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) {
        return step;
    }
    if (parametrization.size() != 3) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "surface parametrization must be three-dimensional",
                                     operation);
    }
    if (u.empty() || v.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "surface parameter variable names cannot be empty",
                                     operation);
    }
    if (u == v) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "surface parameter variables must be distinct",
                                     operation);
    }
    auto bounds = vector_calculus_validate_surface_bounds(
        u_lower, u_upper, v_lower, v_upper, operation);
    if (!bounds) {
        return bounds;
    }
    for (const auto& component : parametrization) {
        if (!component || !LMCAS::detail::node(component)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "surface parametrization components cannot be null",
                                         operation);
        }
    }
    return Result<void>::success();
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::parametrization, LMCAS::Result< T >::success(), LMCAS::u, LMCAS::u_lower, LMCAS::u_upper, LMCAS::v, LMCAS::v_lower, LMCAS::v_upper, vector_calculus_validate_surface_bounds() , 以及 vector_calculus_validate_surface_parametrization().

被这些函数引用 LMCAS::stokes_theorem_checked(), vector_calculus_coord_vars(), vector_calculus_validate_surface_parametrization(), vector_calculus_validate_surface_scalar_inputs() , 以及 vector_calculus_validate_surface_vector_inputs().

函数调用图:

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

vector_calculus_validate_surface_scalar_inputs()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_surface_scalar_inputs	(	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,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 276 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (!f || !LMCAS::detail::node(f)) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "scalar field cannot be null",
                                     operation);
    }
    return vector_calculus_validate_surface_parametrization(
        parametrization, u, v, u_lower, u_upper, v_lower, v_upper,
        context, operation);
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::parametrization, LMCAS::u, LMCAS::u_lower, LMCAS::u_upper, LMCAS::v, LMCAS::v_lower, LMCAS::v_upper, vector_calculus_validate_surface_parametrization() , 以及 vector_calculus_validate_surface_scalar_inputs().

被这些函数引用 LMCAS::surface_integral_scalar_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_surface_scalar_inputs().

函数调用图:

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

vector_calculus_validate_surface_vector_inputs()

Result< void > LMCAS::vector_calculus_detail::vector_calculus_validate_surface_vector_inputs	(	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,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 300 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return step;
    if (F.size() != 3) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "surface vector field must have three components",
                                     operation);
    }
    for (const auto& component : F) {
        if (!component || !LMCAS::detail::node(component)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "surface vector field components cannot be null",
                                         operation);
        }
    }
    return vector_calculus_validate_surface_parametrization(
        parametrization, u, v, u_lower, u_upper, v_lower, v_upper,
        context, operation);
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::detail::node(), LMCAS::parametrization, LMCAS::u, LMCAS::u_lower, LMCAS::u_upper, LMCAS::v, LMCAS::v_lower, LMCAS::v_upper, vector_calculus_validate_surface_parametrization() , 以及 vector_calculus_validate_surface_vector_inputs().

被这些函数引用 LMCAS::surface_integral_vector_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_validate_surface_vector_inputs().

函数调用图:

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

vector_calculus_wrap_expr()

VectorCalculusExprResult LMCAS::vector_calculus_detail::vector_calculus_wrap_expr	(	std::shared_ptr< SymbolicExpr >	expr,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 420 行定义.

{
    if (!expr || !LMCAS::detail::node(expr)) {
        return VectorCalculusExprResult::failure(
            CasErrc::InternalInvariant,
            "vector calculus construction produced a null expression",
            operation);
    }
    return VectorCalculusExprResult::success(std::move(expr));
}

引用了 LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::InternalInvariant, LMCAS::detail::node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 vector_calculus_wrap_expr().

被这些函数引用 LMCAS::directional_derivative_checked(), LMCAS::divergence_checked(), LMCAS::hessian_checked(), LMCAS::jacobian_checked(), LMCAS::laplacian_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_wrap_expr().

函数调用图:

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

vector_calculus_wrap_field()

VectorCalculusFieldResult LMCAS::vector_calculus_detail::vector_calculus_wrap_field	(	VectorField	field,
		const std::string &	operation )

在文件 vector_calculus_support.cpp 第 433 行定义.

{
    for (const auto& component : field) {
        if (!component || !LMCAS::detail::node(component)) {
            return VectorCalculusFieldResult::failure(
                CasErrc::InternalInvariant,
                "vector calculus construction produced a null component",
                operation);
        }
    }
    return VectorCalculusFieldResult::success(std::move(field));
}

引用了 LMCAS::Result< VectorField >::failure(), LMCAS::InternalInvariant, LMCAS::detail::node(), LMCAS::Result< VectorField >::success() , 以及 vector_calculus_wrap_field().

被这些函数引用 LMCAS::curl_checked(), LMCAS::gradient_checked(), vector_calculus_coord_vars() , 以及 vector_calculus_wrap_field().

函数调用图:

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