multiple_integral.cpp

浏览该文件的文档.

#include <stdexcept>
#include "internal/expression_transform.hpp"
#include "internal/integration_support.hpp"
 
namespace LMCAS {
 
static bool validate_integration_steps(const std::vector<IntegrationStep>& steps) {
    if (steps.empty()) return false;
 
    for (size_t i = 0; i < steps.size(); ++i) {
        const auto& s = steps[i];
        if (s.variable.empty()) return false;
 
        // Bounds must be either both null (indefinite) or both set (definite).
        const bool has_lower = static_cast<bool>(s.lower);
        const bool has_upper = static_cast<bool>(s.upper);
        if (has_lower != has_upper) return false;
 
        // Reject duplicate variables.
        for (size_t j = 0; j < i; ++j) {
            if (steps[j].variable == s.variable) return false;
        }
    }
    return true;
}
 
Result<SymbolicExpr> integrate_multiple_checked(
    const SymbolicExpr& integrand,
    const std::vector<IntegrationStep>& steps,
    Integrator& integrator,
    ComputationContext& context) try {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
 
    if (!validate_integration_steps(steps)) {
        return Result<SymbolicExpr>::failure(
            CasErrc::InvalidArgument, "invalid multiple integration steps",
            "integrate.multiple");
    }
    auto access = context.consume_steps(0, "integrate.multiple");
    if (!access) return Result<SymbolicExpr>::failure(access.error());
 
    auto current = LMCAS::detail::make_expression_ptr(integrand);
 
    for (const auto& step : steps) {
        auto step_access = context.consume_steps(1, "integrate.multiple");
        if (!step_access) {
            return Result<SymbolicExpr>::failure(step_access.error());
        }
        if (!current) {
            return Result<SymbolicExpr>::failure(
                CasErrc::InternalInvariant, "multiple integration lost its expression",
                "integrate.multiple");
        }
 
 
        const bool definite = static_cast<bool>(step.lower) && static_cast<bool>(step.upper);
 
        if (!definite) {
            auto result = integrator.integrate_checked(*current, step.variable, context);
            if (!result) return result;
            current = LMCAS::detail::make_expression_ptr(result.value());
        } else {
            auto result = integrator.integrate_def_checked(
                *current, step.variable, *step.lower, *step.upper, context);
            if (!result) return result;
            auto res_ptr = LMCAS::detail::make_expression_ptr(result.value());
            auto simp = detail::make_expression_ptr(detail::normalize_node(detail::node(res_ptr), transform_budget));
            current = simp ? simp : res_ptr;
        }
    }
    auto final_access = context.consume_steps(0, "integrate.multiple");
    if (!final_access) return Result<SymbolicExpr>::failure(final_access.error());
 
    return Result<SymbolicExpr>::success(*current);
} catch (const CasError& error) {
    return Result<SymbolicExpr>::failure(error);
} catch (const std::bad_alloc&) {
    return Result<SymbolicExpr>::failure(CasErrc::ResourceLimit, "allocation failed", "integrate_multiple_checked");
} catch (const std::length_error& error) {
    return Result<SymbolicExpr>::failure(CasErrc::ResourceLimit, error.what(), "integrate_multiple_checked");
} catch (const std::exception& error) {
    return Result<SymbolicExpr>::failure(CasErrc::InternalInvariant, error.what(), "integrate_multiple_checked");
}
 
} // namespace LMCAS