BRUTE

=BRUTE(func_expr, bounds, [ns], [finish])

=BRUTE("(x[0]-1)**2 + (x[1]+2)**2", {-3,3;-3,3}, 25, "fmin_powell")

=BRUTE("(x[0]-2)**2 + (x[1]-1)**2", {-4,4;-4,4}, 15, )

=BRUTE("(x[0]+1)**2 + (x[1]-0.5)**2 + (x[2]-2)**2", {-2,2;-2,2;0,4}, 12)

=BRUTE("x[0]**2 + x[1]**2", {-5,5;-5,5}, 10, "fmin_powell")

import math
from typing import List, Optional
 
import numpy as np
from scipy.optimize import brute as scipy_brute
from scipy.optimize import fmin as scipy_fmin
from scipy.optimize import fmin_powell as scipy_fmin_powell
 
 
def brute(
    func_expr: str,
    bounds: List[List[float]],
    ns: int = 20,
    finish: Optional[str] = 'fmin',
):
    """
    Perform a brute-force grid search to approximate the global minimum of a function.
    
    This function wraps scipy.optimize.brute to perform global optimization over a specified domain.
    For more information, see: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.brute.html
    
    Args:
        func_expr: Objective expression using `x[i]` for variable access.
        bounds: 2D list of [min, max] pairs describing each variable's domain.
        ns: Number of grid points per dimension (must be >= 2).
        finish: Optional local optimizer applied to the best grid point. Choices: 'fmin', 'fmin_powell', None.
 
    Returns:
        list[list[float]] or str: [[x1, x2, ..., objective]] on success, otherwise an error message string.
 
    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 reference variable x (e.g., x[0])."
 
    # Validate bounds
    if not isinstance(bounds, list) or len(bounds) == 0:
        return "Invalid input: bounds must be a 2D list of [min, max] pairs."
    slices = []
    for idx, bound in enumerate(bounds):
        if not isinstance(bound, list) or len(bound) != 2:
            return "Invalid input: each bound must be a [min, max] pair."
        try:
            lower = float(bound[0])
            upper = float(bound[1])
        except (TypeError, ValueError):
            return "Invalid input: bounds must contain numeric values."
        if lower > upper:
            return f"Invalid input: lower bound must not exceed upper bound for variable index {idx}."
        slices.append(slice(lower, upper, complex(0, ns)))
 
    dimension = len(slices)
 
    # Validate ns
    try:
        ns = int(ns)
    except (TypeError, ValueError):
        return "Invalid input: ns must be an integer."
    if ns < 2:
        return "Invalid input: ns must be at least 2."
 
    # Validate finish option
    finish_map = {
        'fmin': scipy_fmin,
        'fmin_powell': scipy_fmin_powell,
        None: None,
        'none': None,
    }
    if finish not in finish_map:
        return "Invalid input: finish must be one of 'fmin', 'fmin_powell', or None."
    finish_callable = finish_map[finish]
 
    # Objective evaluation
    def objective(x_vector):
        try:
            local_x = [float(val) for val in np.atleast_1d(x_vector)]
            value = eval(func_expr, {"x": local_x, "math": math, "np": np})
        except Exception as exc:
            raise ValueError(f"Error evaluating func_expr: {exc}")
        try:
            result_value = float(value)
        except (TypeError, ValueError):
            raise ValueError("Objective expression must return a scalar numeric value.")
        if math.isnan(result_value) or math.isinf(result_value):
            raise ValueError("Objective evaluation produced NaN or infinity.")
        return result_value
 
    try:
        result = scipy_brute(
            objective,
            ranges=slices,
            Ns=ns,
            full_output=True,
            finish=finish_callable,
            disp=False,
        )
    except ValueError as exc:
        return f"Error during brute optimization: {exc}"
    except Exception as exc:
        return f"Error during brute optimization: {exc}"
 
    if not isinstance(result, tuple) or len(result) < 2:
        return "Brute optimization failed: unexpected result structure."
 
    solution_vector, objective_value = result[0], result[1]
 
    try:
        solution_list = [float(val) for val in np.atleast_1d(solution_vector)]
    except (TypeError, ValueError):
        return "Error converting solution vector to floats."
 
    objective_value = float(objective_value)
 
    return [solution_list + [objective_value]]