FIXED_POINT

=FIXED_POINT(func_expr, x_zero, [xtol], [maxiter], [fixed_point_method])

=FIXED_POINT("math.cos(x)", 0.5, 1E-10, 600, "del2")

=FIXED_POINT("0.25*x + 3", {0})

=FIXED_POINT("math.exp(-x)", 0.7, 1E-10)

=FIXED_POINT("1 + 0.3*x", 2, , , "iteration")

import math
from scipy.optimize import fixed_point as scipy_fixed_point
 
 
def fixed_point(func_expr: str, x_zero, xtol: float = 1e-8, maxiter: int = 500, fixed_point_method: str = 'del2'):
    """
    Find a fixed point x such that f(x) = x for a scalar function expression.
 
    This function wraps scipy.optimize.fixed_point to find fixed points of scalar functions.
    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fixed_point.html
 
    Args:
        func_expr: String expression defining the function of x (e.g., 'math.cos(x)'). Must contain variable 'x'.
        x_zero: Initial guess for the fixed-point iteration as a float.
        xtol: Absolute tolerance for termination of the iteration. Must be positive. Default is 1e-8.
        maxiter: Maximum number of iterations allowed. Must be a positive integer. Default is 500.
        fixed_point_method: Acceleration method. Options are 'del2' (Aitken-accelerated) or 'iteration' (simple fixed-point iteration). Default is 'del2'.
 
    Returns:
        float or str: Fixed-point value on success, otherwise an error message describing the issue.
 
    This example function is provided as-is without any representation of accuracy.
    """
    # Validate func_expr
    if not isinstance(func_expr, str):
        return "Invalid input: func_expr must be a string."
    if 'x' not in func_expr:
        return "Invalid input: func_expr must contain the variable 'x'."
 
    # Validate x_zero (accepts only float)
    try:
        x0 = float(x_zero)
    except (TypeError, ValueError):
        return "Invalid input: x_zero must be a float."
 
    # Validate numeric parameters (ensure proper types)
    if not isinstance(xtol, (int, float)):
        return "Invalid input: xtol must be a numeric value."
    if not isinstance(maxiter, int):
        return "Invalid input: maxiter must be an integer."
    
    xtol = float(xtol)
    maxiter = int(maxiter)
 
    if xtol <= 0:
        return "Invalid input: xtol must be positive."
    if maxiter <= 0:
        return "Invalid input: maxiter must be positive."
 
    # Validate method
    valid_methods = ['del2', 'iteration']
    if fixed_point_method not in valid_methods:
        return f"Invalid method: {fixed_point_method}. Must be one of: {', '.join(valid_methods)}"
    
    # Build function from expression
    def func(x):
        try:
            # Limit available globals to safe operations
            safe_dict = {"x": x, "math": math}
            safe_dict.update(math.__dict__)  # Add math functions like sin, cos, exp, etc.
            return eval(func_expr, {"__builtins__": {}}, safe_dict)
        except Exception as exc:
            raise ValueError(f"Error evaluating function: {exc}")
 
    try:
        result = scipy_fixed_point(func, x0=x0, xtol=xtol, maxiter=maxiter, method=fixed_point_method)
    except Exception as exc:
        return f"Error during fixed-point iteration: {exc}"
 
    try:
        value = float(result)
    except (TypeError, ValueError):
        return "Fixed-point iteration returned a non-scalar result."
 
    if math.isnan(value) or math.isinf(value):
        return "Fixed-point iteration failed: result is NaN or inf."
 
    # Verify convergence by checking |f(value) - value|
    try:
        residual = abs(func(value) - value)
    except Exception as exc:
        return f"Error evaluating residual: {exc}"
 
    if residual > xtol:
        return f"Fixed-point iteration may not have converged: residual {residual} exceeds xtol {xtol}."
 
    return value