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

函数
Result< std::size_t >	bounded_binomial (std::size_t n, std::size_t k, std::size_t limit, const std::string &operation)
DifferentialGeometryExprResult	checked_geometry_expression (std::shared_ptr< SymbolicExpr > &&result, CasErrc error, const char *message, const std::string &operation)
DifferentialGeometryExprResult	exterior_derivative_component (const std::vector< std::shared_ptr< SymbolicExpr > > &form_coeffs, const std::vector< std::string > &vars, const std::map< std::vector< std::size_t >, std::size_t > &coefficient_index, const std::vector< std::size_t > &output_index, detail::RewriteBudget &budget, const std::string &operation)
DifferentialGeometryExprResult	exterior_derivative_term (const std::vector< std::shared_ptr< SymbolicExpr > > &form_coeffs, const std::vector< std::string > &vars, const std::map< std::vector< std::size_t >, std::size_t > &coefficient_index, const std::vector< std::size_t > &output_index, std::size_t removed, detail::RewriteBudget &budget, const std::string &operation)
std::vector< std::vector< std::size_t > >	index_combinations (std::size_t n, std::size_t k, std::size_t count)
Result< void >	validate_expr_vector (const std::vector< std::shared_ptr< SymbolicExpr > > &values, const std::vector< std::string > &vars, const std::string &value_name, const std::string &operation)
Result< std::size_t >	validate_form_coefficients (const std::vector< std::shared_ptr< SymbolicExpr > > &form_coeffs, int degree, const std::vector< std::string > &vars, ComputationContext &context, const std::string &operation)
Result< void >	validate_form_coordinates (const std::vector< std::string > &vars, const std::string &operation)
Result< void >	validate_index (int idx, std::size_t dim, const std::string &name, const std::string &operation)
Result< std::shared_ptr< const MatrixNode > >	validate_metric_matrix (const std::shared_ptr< SymbolicExpr > &metric, const std::vector< std::string > *coords, ComputationContext &context, const std::string &operation)

函数说明

bounded_binomial()

Result< std::size_t > LMCAS::anonymous_namespace{differential_geometry.cpp}::bounded_binomial	(	std::size_t	n,
		std::size_t	k,
		std::size_t	limit,
		const std::string &	operation )

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

{
    if (k > n) return Result<std::size_t>::success(0);
    k = std::min(k, n - k);
    std::size_t value = 1;
    for (std::size_t i = 1; i <= k; ++i) {
        std::size_t numerator = n - k + i;
        std::size_t denominator = i;
        const auto fraction_gcd = std::gcd(numerator, denominator);
        numerator /= fraction_gcd;
        denominator /= fraction_gcd;
        const auto value_gcd = std::gcd(value, denominator);
        value /= value_gcd;
        denominator /= value_gcd;
        if (denominator != 1) {
            return Result<std::size_t>::failure(
                CasErrc::InternalInvariant,
                "binomial coefficient reduction was not exact",
                operation);
        }
        if (numerator != 0 && value > limit / numerator) {
            return Result<std::size_t>::failure(
                CasErrc::ResourceLimit,
                "differential-form component count exceeds the expansion budget",
                operation);
        }
        value *= numerator;
    }
    if (value > limit) {
        return Result<std::size_t>::failure(
            CasErrc::ResourceLimit,
            "differential-form component count exceeds the expansion budget",
            operation);
    }
    return Result<std::size_t>::success(value);
}

引用了 bounded_binomial(), LMCAS::denominator, LMCAS::Result< T >::failure(), LMCAS::InternalInvariant, LMCAS::ResourceLimit, LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 bounded_binomial() , 以及 validate_form_coefficients().

函数调用图:

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

checked_geometry_expression()

DifferentialGeometryExprResult LMCAS::anonymous_namespace{differential_geometry.cpp}::checked_geometry_expression	(	std::shared_ptr< SymbolicExpr > &&	result,
		CasErrc	error,
		const char *	message,
		const std::string &	operation )

在文件 differential_geometry.cpp 第 188 行定义.

{
    if (!result || !LMCAS::detail::node(result)) {
        return DifferentialGeometryExprResult::failure(error, message, operation);
    }
    return DifferentialGeometryExprResult::success(std::move(result));
}

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

被这些函数引用 checked_geometry_expression() , 以及 exterior_derivative_component().

函数调用图:

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

exterior_derivative_component()

DifferentialGeometryExprResult LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_component	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	form_coeffs,
		const std::vector< std::string > &	vars,
		const std::map< std::vector< std::size_t >, std::size_t > &	coefficient_index,
		const std::vector< std::size_t > &	output_index,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

在文件 differential_geometry.cpp 第 292 行定义.

    {
    auto component = SymbolicExpr::number(0);
    for (std::size_t removed = 0; removed < output_index.size(); ++removed) {
        auto partial = exterior_derivative_term(
            form_coeffs, vars, coefficient_index, output_index, removed, budget, operation);
        if (!partial) return partial;
        component = SymbolicExpr::add(component, partial.value());
    }
    component = detail::make_expression_ptr(
        detail::normalize_node(detail::node(component), budget));
    return checked_geometry_expression(std::move(component), CasErrc::InternalInvariant,
                                       "exterior derivative produced a null component",
                                       operation);
} catch (const CasError& error) {
    return DifferentialGeometryExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 checked_geometry_expression(), exterior_derivative_component(), exterior_derivative_term(), LMCAS::InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::node(), LMCAS::detail::normalize_node() , 以及 LMCAS::vars.

被这些函数引用 exterior_derivative_component().

函数调用图:

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

exterior_derivative_term()

DifferentialGeometryExprResult LMCAS::anonymous_namespace{differential_geometry.cpp}::exterior_derivative_term	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	form_coeffs,
		const std::vector< std::string > &	vars,
		const std::map< std::vector< std::size_t >, std::size_t > &	coefficient_index,
		const std::vector< std::size_t > &	output_index,
		std::size_t	removed,
		detail::RewriteBudget &	budget,
		const std::string &	operation )

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

    {
    auto term_budget = budget.context().consume_steps(4, operation);
    if (!term_budget) return DifferentialGeometryExprResult::failure(term_budget.error());
 
    auto source_index = output_index;
    const std::size_t derivative_variable = source_index[removed];
    source_index.erase(source_index.begin() + static_cast<std::ptrdiff_t>(removed));
    const auto source = coefficient_index.find(source_index);
    if (source == coefficient_index.end()) {
        return DifferentialGeometryExprResult::failure(
            CasErrc::InternalInvariant,
            "exterior derivative could not locate an input coefficient", operation);
    }
    auto partial = detail::make_expression_ptr(detail::differentiate_node(
        detail::node(form_coeffs[source->second]), vars[derivative_variable], budget));
    if (removed % 2 != 0) {
        partial = SymbolicExpr::multiply(SymbolicExpr::number(-1), partial);
    }
    budget.measure(detail::node(partial));
    return DifferentialGeometryExprResult::success(std::move(partial));
} catch (const CasError& error) {
    return DifferentialGeometryExprResult::failure(error);
} catch (const std::bad_alloc&) {
    return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit, "allocation failed", operation);
} catch (const std::length_error& error) {
    return DifferentialGeometryExprResult::failure(CasErrc::ResourceLimit, error.what(), operation);
} catch (const std::exception& error) {
    return DifferentialGeometryExprResult::failure(CasErrc::InternalInvariant, error.what(), operation);
}

引用了 LMCAS::ComputationContext::consume_steps(), LMCAS::detail::RewriteBudget::context(), LMCAS::detail::differentiate_node(), exterior_derivative_term(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::InternalInvariant, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::node(), LMCAS::Result< std::shared_ptr< SymbolicExpr > >::success() , 以及 LMCAS::vars.

被这些函数引用 exterior_derivative_component() , 以及 exterior_derivative_term().

函数调用图:

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

index_combinations()

std::vector< std::vector< std::size_t > > LMCAS::anonymous_namespace{differential_geometry.cpp}::index_combinations	(	std::size_t	n,
		std::size_t	k,
		std::size_t	count )

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

{
    std::vector<std::vector<std::size_t>> combinations;
    combinations.reserve(count);
    if (k > n) return combinations;
    if (k == 0) {
        combinations.emplace_back();
        return combinations;
    }
 
    std::vector<std::size_t> current(k);
    std::iota(current.begin(), current.end(), 0);
    while (true) {
        combinations.push_back(current);
        std::size_t position = k;
        while (position > 0) {
            --position;
            if (current[position] < n - k + position) break;
        }
        if (position == 0 && current[0] == n - k) break;
        ++current[position];
        for (std::size_t i = position + 1; i < k; ++i) {
            current[i] = current[i - 1] + 1;
        }
    }
    return combinations;
}

引用了 index_combinations().

被这些函数引用 index_combinations().

函数调用图:

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

validate_expr_vector()

Result< void > LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_expr_vector	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	values,
		const std::vector< std::string > &	vars,
		const std::string &	value_name,
		const std::string &	operation )

在文件 differential_geometry.cpp 第 86 行定义.

{
    if (vars.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "variable list cannot be empty",
                                     operation);
    }
    if (values.size() != vars.size()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     value_name + " dimension must match variable count",
                                     operation);
    }
    for (const auto& var : vars) {
        if (var.empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable names cannot be empty",
                                         operation);
        }
    }
    for (const auto& value : values) {
        if (!value || !LMCAS::detail::node(value)) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         value_name + " components cannot be null",
                                         operation);
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 validate_expr_vector().

函数调用图:

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

validate_form_coefficients()

Result< std::size_t > LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_form_coefficients	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	form_coeffs,
		int	degree,
		const std::vector< std::string > &	vars,
		ComputationContext &	context,
		const std::string &	operation )

在文件 differential_geometry.cpp 第 221 行定义.

{
    auto coordinates = validate_form_coordinates(vars, operation);
    if (!coordinates) return Result<std::size_t>::failure(coordinates.error());
    if (degree < 0 || static_cast<std::size_t>(degree) > vars.size()) {
        return Result<std::size_t>::failure(
            CasErrc::InvalidArgument,
            "form degree must be between zero and the coordinate dimension", operation);
    }
    const auto input_count = bounded_binomial(vars.size(),
                                              static_cast<std::size_t>(degree),
                                              context.limits().max_expansion_terms,
                                              operation);
    if (!input_count) return input_count;
    if (form_coeffs.size() != input_count.value()) {
        return Result<std::size_t>::failure(
            CasErrc::InvalidArgument,
            "form coefficient count does not match degree and dimension", operation);
    }
    for (const auto& coeff : form_coeffs) {
        if (!coeff || !LMCAS::detail::node(coeff)) {
            return Result<std::size_t>::failure(CasErrc::InvalidArgument,
                                                "form coefficients cannot be null", operation);
        }
    }
    return input_count;
}

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

被这些函数引用 validate_form_coefficients().

函数调用图:

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

validate_form_coordinates()

Result< void > LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_form_coordinates	(	const std::vector< std::string > &	vars,
		const std::string &	operation )

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

{
    if (vars.empty()) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     "variable list cannot be empty", operation);
    }
    for (std::size_t i = 0; i < vars.size(); ++i) {
        if (vars[i].empty()) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "variable names cannot be empty", operation);
        }
        const auto current = vars.begin() + static_cast<std::ptrdiff_t>(i);
        if (std::find(vars.begin(), current, vars[i]) != current) {
            return Result<void>::failure(CasErrc::InvalidArgument,
                                         "coordinate variables must be unique", operation);
        }
    }
    return Result<void>::success();
}

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

被这些函数引用 validate_form_coefficients() , 以及 validate_form_coordinates().

函数调用图:

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

validate_index()

Result< void > LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_index	(	int	idx,
		std::size_t	dim,
		const std::string &	name,
		const std::string &	operation )

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

{
    if (idx < 0 || static_cast<std::size_t>(idx) >= dim) {
        return Result<void>::failure(CasErrc::InvalidArgument,
                                     name + " index is out of bounds",
                                     operation);
    }
    return Result<void>::success();
}

引用了 LMCAS::dim, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::name, LMCAS::Result< T >::success() , 以及 validate_index().

被这些函数引用 validate_index().

函数调用图:

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

validate_metric_matrix()

Result< std::shared_ptr< const MatrixNode > > LMCAS::anonymous_namespace{differential_geometry.cpp}::validate_metric_matrix	(	const std::shared_ptr< SymbolicExpr > &	metric,
		const std::vector< std::string > *	coords,
		ComputationContext &	context,
		const std::string &	operation )

在文件 differential_geometry.cpp 第 21 行定义.

{
    auto step = context.consume_steps(1, operation);
    if (!step) return Result<std::shared_ptr<const MatrixNode>>::failure(step.error());
    if (!metric || !LMCAS::detail::node(metric)) {
        return Result<std::shared_ptr<const MatrixNode>>::failure(
            CasErrc::InvalidArgument,
            "metric tensor cannot be null",
            operation);
    }
    auto matrix = std::dynamic_pointer_cast<const MatrixNode>(LMCAS::detail::node(metric));
    if (!matrix) {
        return Result<std::shared_ptr<const MatrixNode>>::failure(
            CasErrc::InvalidArgument,
            "metric tensor must be a matrix",
            operation);
    }
    if (matrix->rows() != matrix->cols()) {
        return Result<std::shared_ptr<const MatrixNode>>::failure(
            CasErrc::InvalidArgument,
            "metric tensor must be square",
            operation);
    }
    if (coords) {
        if (coords->empty()) {
            return Result<std::shared_ptr<const MatrixNode>>::failure(
                CasErrc::InvalidArgument,
                "coordinate list cannot be empty",
                operation);
        }
        if (coords->size() != matrix->rows()) {
            return Result<std::shared_ptr<const MatrixNode>>::failure(
                CasErrc::InvalidArgument,
                "coordinate count must match metric dimension",
                operation);
        }
        for (const auto& coord : *coords) {
            if (coord.empty()) {
                return Result<std::shared_ptr<const MatrixNode>>::failure(
                    CasErrc::InvalidArgument,
                    "coordinate names cannot be empty",
                    operation);
            }
        }
    }
    return Result<std::shared_ptr<const MatrixNode>>::success(matrix);
}

引用了 LMCAS::context, LMCAS::InvalidArgument, LMCAS::detail::node() , 以及 validate_metric_matrix().

被这些函数引用 validate_metric_matrix().

函数调用图:

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