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

类
struct	RootCallbacks

函数
std::optional< CasError >	append_verified_root (std::vector< NumericRoot > &results, const NumericRootResult &candidate, const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context, lmmc_real_t tolerance)
NumericRootResult	backend_root_result (const lmmc_nonlinear_result_t &backend, double residual_limit)
double	evaluate_root_callback (const std::shared_ptr< SymbolicExpr > &expression, double x, RootCallbacks &callbacks)
Result< double >	evaluate_root_function (const std::shared_ptr< SymbolicExpr > &expression, const std::string &variable, lmmc_real_t value, ComputationContext &context, const char *operation)
NumericRootResult	invalid_root_options (const SolveOptions &options, const char *operation)
lmmc_nonlinear_config_t	root_config (const SolveOptions &options, std::size_t max_iterations)
double	root_derivative_callback (double x, void *user_data)
double	root_function_callback (double x, void *user_data)
NumericRootResult	run_bisection_backend (const std::shared_ptr< SymbolicExpr > &function, const std::string &variable, double lower, double upper, ComputationContext &context, const SolveOptions &options, const char *operation)
NumericRootResult	run_newton_backend (const std::shared_ptr< SymbolicExpr > &function, const std::shared_ptr< SymbolicExpr > &derivative, const std::string &variable, double initial, ComputationContext &context, const SolveOptions &options, bool enforce_bracket, double bracket_lower, double bracket_upper)
NumericRootsResult	solve_initial_guess (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, ComputationContext &context, const SolveOptions &opts)
NumericRootsResult	solve_isolated_polynomial (const std::shared_ptr< SymbolicExpr > &expr, const std::string &var, const Polynomial< Rational > &polynomial, ComputationContext &context, const SolveOptions &opts)

变量
constexpr const char *	kBisectionOperation = "bisection"
constexpr const char *	kNewtonOperation = "newton_raphson"

---

类说明

LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks

struct LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks

在文件 newton_raphson.cpp 第 77 行定义.

LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks 的协作图:

类成员
double	bracket_lower = 0.0
double	bracket_upper = 0.0
ComputationContext *	context = nullptr
const shared_ptr< SymbolicExpr > *	derivative = nullptr
bool	enforce_bracket = false
optional< CasError >	error
const shared_ptr< SymbolicExpr > *	function = nullptr
bool	left_bracket = false
const char *	operation = nullptr
const string *	variable = nullptr

函数说明

append_verified_root()

std::optional< CasError > LMCAS::anonymous_namespace{newton_raphson.cpp}::append_verified_root	(	std::vector< NumericRoot > &	results,
		const NumericRootResult &	candidate,
		const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context,
		lmmc_real_t	tolerance )

在文件 newton_raphson.cpp 第 220 行定义.

                                                        {
    if (!candidate) {
        return candidate.error();
    }
    if (!candidate.value()) {
        return std::nullopt;
    }
    auto root = *candidate.value();
    auto verified = evaluate_root_function(expr, var, root.value, context, "solve_numeric");
    if (!verified) {
        return std::move(verified.error());
    }
    root.residual = std::abs(verified.value());
    if (root.residual <= tolerance) {
        results.push_back(root);
    }
    return std::nullopt;
}

引用了 append_verified_root(), LMCAS::context, LMCAS::Result< T >::error(), evaluate_root_function() , 以及 LMCAS::Result< T >::value().

被这些函数引用 append_verified_root(), solve_initial_guess() , 以及 solve_isolated_polynomial().

函数调用图:

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

backend_root_result()

NumericRootResult LMCAS::anonymous_namespace{newton_raphson.cpp}::backend_root_result	(	const lmmc_nonlinear_result_t &	backend,
		double	residual_limit )

在文件 newton_raphson.cpp 第 137 行定义.

                           {
    if (!backend.converged || !std::isfinite(backend.root) ||
        !std::isfinite(backend.residual_norm) ||
        backend.residual_norm > residual_limit) {
        return NumericRootResult::success(std::nullopt);
    }
    const int iterations =
        backend.num_iter > static_cast<std::size_t>(std::numeric_limits<int>::max())
            ? std::numeric_limits<int>::max()
            : static_cast<int>(backend.num_iter);
    return NumericRootResult::success(
        NumericRoot{backend.root, backend.residual_norm, iterations});
}

引用了 backend_root_result() , 以及 LMCAS::Result< std::optional< NumericRoot > >::success().

被这些函数引用 backend_root_result(), run_bisection_backend() , 以及 run_newton_backend().

函数调用图:

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

evaluate_root_callback()

double LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_callback	(	const std::shared_ptr< SymbolicExpr > &	expression,
		double	x,
		RootCallbacks &	callbacks )

在文件 newton_raphson.cpp 第 90 行定义.

                              {
    if (callbacks.error) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    if (callbacks.enforce_bracket &&
        (x < callbacks.bracket_lower || x > callbacks.bracket_upper)) {
        callbacks.left_bracket = true;
        return std::numeric_limits<double>::quiet_NaN();
    }
    auto value = evaluate_root_function(
        expression, *callbacks.variable, x, *callbacks.context,
        callbacks.operation);
    if (!value) {
        callbacks.error = value.error();
        return std::numeric_limits<double>::quiet_NaN();
    }
    return value.value();
}

引用了 LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::bracket_upper, LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::context, LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::enforce_bracket, LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::error, evaluate_root_callback(), evaluate_root_function(), LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::left_bracket, LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::operation, LMCAS::value , 以及 LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::variable.

被这些函数引用 evaluate_root_callback(), root_derivative_callback() , 以及 root_function_callback().

函数调用图:

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

evaluate_root_function()

Result< double > LMCAS::anonymous_namespace{newton_raphson.cpp}::evaluate_root_function	(	const std::shared_ptr< SymbolicExpr > &	expression,
		const std::string &	variable,
		lmmc_real_t	value,
		ComputationContext &	context,
		const char *	operation )

在文件 newton_raphson.cpp 第 25 行定义.

                           {
    if (!expression) {
        return Result<double>::failure(
            CasErrc::InvalidArgument,
            "root function expression cannot be null",
            operation);
    }
    if (variable.empty()) {
        return Result<double>::failure(
            CasErrc::InvalidArgument,
            "root variable cannot be empty",
            operation);
    }
    auto evaluated = evaluate_numeric(
        *expression, NumericBindings{{variable, static_cast<double>(value)}},
        context);
    if (!evaluated) {
        return Result<double>::failure(evaluated.error());
    }
    if (!evaluated.value().is_finite() ||
        !std::isfinite(evaluated.value().value)) {
        return Result<double>::failure(
            CasErrc::NumericFailure,
            "root function evaluation is not finite",
            operation);
    }
    return Result<double>::success(evaluated.value().value);
}

引用了 LMCAS::context, LMCAS::evaluate_numeric(), evaluate_root_function(), LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, LMCAS::NumericFailure, LMCAS::Result< T >::success(), LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 append_verified_root(), evaluate_root_callback(), evaluate_root_function() , 以及 run_bisection_backend().

函数调用图:

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

invalid_root_options()

NumericRootResult LMCAS::anonymous_namespace{newton_raphson.cpp}::invalid_root_options	(	const SolveOptions &	options,
		const char *	operation )

在文件 newton_raphson.cpp 第 59 行定义.

                           {
    if (!std::isfinite(options.tolerance) || options.tolerance <= 0.0) {
        return NumericRootResult::failure(
            CasErrc::InvalidArgument,
            "root tolerance must be finite and positive",
            operation);
    }
    if (options.max_newton_iterations <= 0) {
        return NumericRootResult::failure(
            CasErrc::InvalidArgument,
            "maximum iteration count must be positive",
            operation);
    }
    return NumericRootResult::success(std::nullopt);
}

引用了 LMCAS::Result< std::optional< NumericRoot > >::failure(), invalid_root_options(), LMCAS::InvalidArgument, LMCAS::options , 以及 LMCAS::Result< std::optional< NumericRoot > >::success().

被这些函数引用 invalid_root_options().

函数调用图:

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

root_config()

lmmc_nonlinear_config_t LMCAS::anonymous_namespace{newton_raphson.cpp}::root_config	(	const SolveOptions &	options,
		std::size_t	max_iterations )

在文件 newton_raphson.cpp 第 122 行定义.

                              {
    lmmc_nonlinear_config_t config{};
    if (lmmc_nonlinear_default_config(&config) != LMMC_STATUS_OK) {
        std::terminate();
    }
    config.abs_tol = options.tolerance;
    config.rel_tol = 0.0;
    config.max_iter = max_iterations;
    config.min_derivative = 1.0e-15;
    config.min_step = 0.0;
    return config;
}

引用了 LMCAS::options , 以及 root_config().

被这些函数引用 root_config(), run_bisection_backend() , 以及 run_newton_backend().

函数调用图:

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

root_derivative_callback()

double LMCAS::anonymous_namespace{newton_raphson.cpp}::root_derivative_callback	(	double	x,
		void *	user_data )

在文件 newton_raphson.cpp 第 117 行定义.

                                                           {
    auto& callbacks = *static_cast<RootCallbacks*>(user_data);
    return evaluate_root_callback(*callbacks.derivative, x, callbacks);
}

引用了 evaluate_root_callback() , 以及 root_derivative_callback().

被这些函数引用 root_derivative_callback() , 以及 run_newton_backend().

函数调用图:

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

root_function_callback()

double LMCAS::anonymous_namespace{newton_raphson.cpp}::root_function_callback	(	double	x,
		void *	user_data )

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

                                                         {
    auto& callbacks = *static_cast<RootCallbacks*>(user_data);
    return evaluate_root_callback(*callbacks.function, x, callbacks);
}

引用了 evaluate_root_callback() , 以及 root_function_callback().

被这些函数引用 root_function_callback(), run_bisection_backend() , 以及 run_newton_backend().

函数调用图:

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

run_bisection_backend()

NumericRootResult LMCAS::anonymous_namespace{newton_raphson.cpp}::run_bisection_backend	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::string &	variable,
		double	lower,
		double	upper,
		ComputationContext &	context,
		const SolveOptions &	options,
		const char *	operation )

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

                           {
    if (lower == upper) {
        auto value = evaluate_root_function(
            function, variable, lower, context, operation);
        if (!value) {
            return NumericRootResult::failure(value.error());
        }
        if (std::abs(value.value()) <= options.tolerance) {
            return NumericRootResult::success(
                NumericRoot{lower, std::abs(value.value()), 0});
        }
        return NumericRootResult::success(std::nullopt);
    }
 
    detail::ensure_lmmc_lifecycle();
    RootCallbacks callbacks{
        &function, nullptr, &variable, &context, operation,
        false, lower, upper, false, std::nullopt};
    const std::size_t max_iterations =
        static_cast<std::size_t>(options.max_newton_iterations) * 3;
    auto config = root_config(options, max_iterations);
    lmmc_nonlinear_result_t backend{};
    const auto status = lmmc_bisection_solve(
        root_function_callback, &callbacks, lower, upper, &config, &backend);
    if (callbacks.error) {
        return NumericRootResult::failure(*callbacks.error);
    }
    if (status == LMMC_STATUS_INVALID_ARGUMENT &&
        backend.failure_reason == LMMC_NONLINEAR_FAILURE_INVALID_BRACKET) {
        return NumericRootResult::success(std::nullopt);
    }
    return backend_root_result(backend, options.tolerance * 100.0);
}

引用了 backend_root_result(), LMCAS::context, LMCAS::detail::ensure_lmmc_lifecycle(), LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::error, evaluate_root_function(), LMCAS::Result< std::optional< NumericRoot > >::failure(), LMCAS::function(), LMCAS::lower, LMCAS::options, root_config(), root_function_callback(), run_bisection_backend(), LMCAS::Result< std::optional< NumericRoot > >::success(), LMCAS::upper, LMCAS::value , 以及 LMCAS::variable.

被这些函数引用 run_bisection_backend().

函数调用图:

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

run_newton_backend()

NumericRootResult LMCAS::anonymous_namespace{newton_raphson.cpp}::run_newton_backend	(	const std::shared_ptr< SymbolicExpr > &	function,
		const std::shared_ptr< SymbolicExpr > &	derivative,
		const std::string &	variable,
		double	initial,
		ComputationContext &	context,
		const SolveOptions &	options,
		bool	enforce_bracket,
		double	bracket_lower,
		double	bracket_upper )

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

                          {
    detail::ensure_lmmc_lifecycle();
    RootCallbacks callbacks{
        &function, &derivative, &variable, &context, kNewtonOperation,
        enforce_bracket, bracket_lower, bracket_upper, false, std::nullopt};
    auto config = root_config(
        options, static_cast<std::size_t>(options.max_newton_iterations));
    lmmc_nonlinear_result_t backend{};
    (void)lmmc_newton_solve(
        root_function_callback, root_derivative_callback, &callbacks, initial,
        &config, &backend);
    if (callbacks.error) {
        return NumericRootResult::failure(*callbacks.error);
    }
    return backend_root_result(backend, options.tolerance);
}

引用了 backend_root_result(), LMCAS::context, LMCAS::detail::ensure_lmmc_lifecycle(), LMCAS::anonymous_namespace{newton_raphson.cpp}::RootCallbacks::error, LMCAS::Result< std::optional< NumericRoot > >::failure(), LMCAS::function(), kNewtonOperation, LMCAS::options, root_config(), root_derivative_callback(), root_function_callback(), run_newton_backend() , 以及 LMCAS::variable.

被这些函数引用 run_newton_backend().

函数调用图:

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

solve_initial_guess()

NumericRootsResult LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_initial_guess	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		ComputationContext &	context,
		const SolveOptions &	opts )

在文件 newton_raphson.cpp 第 285 行定义.

                                                               {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<NumericRoot> results;
    const lmmc_real_t initial = opts.has_initial_guess ? opts.initial_guess : 0.0;
    auto derivative = detail::make_expression_ptr(detail::differentiate_node(detail::node(expr), var, transform_budget));
    auto candidate = newton_raphson_checked(expr, derivative, var, initial, context, opts);
    auto failure = append_verified_root(
        results, candidate, expr, var, context, opts.tolerance);
    if (failure) {
        return NumericRootsResult::failure(std::move(*failure));
    }
    return NumericRootsResult::success(std::move(results));
} catch (const CasError& error) {
    return NumericRootsResult::failure(error);
} catch (const std::bad_alloc&) {
    return NumericRootsResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_initial_guess");
} catch (const std::length_error& error) {
    return NumericRootsResult::failure(CasErrc::ResourceLimit, error.what(), "solve_initial_guess");
} catch (const std::exception& error) {
    return NumericRootsResult::failure(CasErrc::InternalInvariant, error.what(), "solve_initial_guess");
}

引用了 append_verified_root(), LMCAS::context, LMCAS::detail::differentiate_node(), LMCAS::Result< std::vector< NumericRoot > >::failure(), LMCAS::SolveOptions::has_initial_guess, LMCAS::SolveOptions::initial_guess, LMCAS::detail::make_expression_ptr(), LMCAS::newton_raphson_checked(), LMCAS::detail::node(), solve_initial_guess(), LMCAS::Result< std::vector< NumericRoot > >::success() , 以及 LMCAS::SolveOptions::tolerance.

被这些函数引用 solve_initial_guess().

函数调用图:

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

solve_isolated_polynomial()

NumericRootsResult LMCAS::anonymous_namespace{newton_raphson.cpp}::solve_isolated_polynomial	(	const std::shared_ptr< SymbolicExpr > &	expr,
		const std::string &	var,
		const Polynomial< Rational > &	polynomial,
		ComputationContext &	context,
		const SolveOptions &	opts )

在文件 newton_raphson.cpp 第 242 行定义.

                                  {
    detail::RewriteBudget transform_budget(context, (context).limits().max_recursion_depth,
                                            (context).limits().max_ast_nodes, "transform");
    std::vector<NumericRoot> results;
    auto derivative = detail::make_expression_ptr(detail::differentiate_node(detail::node(expr), var, transform_budget));
    auto isolated = isolate_real_roots_checked(polynomial, context);
    if (!isolated) {
        return NumericRootsResult::failure(isolated.error());
    }
    for (const auto& [lower, upper] : isolated.value()) {
        if (opts.max_roots > 0 &&
            static_cast<int>(results.size()) >= opts.max_roots) {
            break;
        }
        auto step = context.consume_steps(1, "solve_numeric");
        if (!step) {
            return NumericRootsResult::failure(step.error());
        }
        const lmmc_real_t lo = lower.to_double();
        const lmmc_real_t hi = upper.to_double();
        const lmmc_real_t initial = solver_detail::finite_midpoint(lo, hi);
        auto candidate = newton_raphson_checked(
            expr, derivative, var, initial, lo, hi, context, opts);
        auto failure = append_verified_root(
            results, candidate, expr, var, context, opts.tolerance * 100.0);
        if (failure) {
            return NumericRootsResult::failure(std::move(*failure));
        }
    }
    return NumericRootsResult::success(std::move(results));
} catch (const CasError& error) {
    return NumericRootsResult::failure(error);
} catch (const std::bad_alloc&) {
    return NumericRootsResult::failure(CasErrc::ResourceLimit, "allocation failed", "solve_isolated_polynomial");
} catch (const std::length_error& error) {
    return NumericRootsResult::failure(CasErrc::ResourceLimit, error.what(), "solve_isolated_polynomial");
} catch (const std::exception& error) {
    return NumericRootsResult::failure(CasErrc::InternalInvariant, error.what(), "solve_isolated_polynomial");
}

引用了 append_verified_root(), LMCAS::context, LMCAS::detail::differentiate_node(), LMCAS::Result< std::vector< NumericRoot > >::failure(), LMCAS::solver_detail::finite_midpoint(), LMCAS::isolate_real_roots_checked(), LMCAS::lower, LMCAS::detail::make_expression_ptr(), LMCAS::SolveOptions::max_roots, LMCAS::newton_raphson_checked(), LMCAS::detail::node(), solve_isolated_polynomial(), LMCAS::Result< std::vector< NumericRoot > >::success(), LMCAS::SolveOptions::tolerance , 以及 LMCAS::upper.

被这些函数引用 solve_isolated_polynomial().

函数调用图:

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

变量说明

kBisectionOperation

const char* LMCAS::anonymous_namespace{newton_raphson.cpp}::kBisectionOperation = "bisection"

constexpr

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

kNewtonOperation

const char* LMCAS::anonymous_namespace{newton_raphson.cpp}::kNewtonOperation = "newton_raphson"

constexpr

在文件 newton_raphson.cpp 第 22 行定义.

被这些函数引用 run_newton_backend().