MINIMIZE

=MINIMIZE(func_expr, x_zero, [bounds], [minimize_method])

=MINIMIZE("(1 - x[0])**2 + 100*(x[1] - x[0]**2)**2", {-1,2}, {-2,2;-2,2}, "L-BFGS-B")

=MINIMIZE("(x[0]-3)**2 + (x[1]-4)**2 + 7", {1,1}, {0,10;0,10})

=MINIMIZE("(1 - x[0])**2 + 100*(x[1] - x[0]**2)**2", {-1,2}, , "BFGS")

=MINIMIZE("(x[0]-3)**2 + (x[1]-4)**2 + 7", {1,1}, {0,10;0,10}, "L-BFGS-B")

import math
from typing import List, Optional, Tuple, Union
 
import numpy as np
from scipy.optimize import minimize as scipy_minimize
 
 
Number = Union[int, float]
 
 
def minimize(
    func_expr: str,
    x_zero: List[List[Number]],
    bounds: Optional[List[List[Optional[Number]]]] = None,
    minimize_method: Optional[str] = None,
) -> Union[List[List[float]], str]:
    """Minimize a multivariate function using SciPy's ``minimize`` routine.
 
    Args:
        func_expr: Objective expression written in terms of ``x`` (for example, ``"x[0]**2 + x[1]**2"``).
        x_zero: 2D list providing the initial guess for each variable.
        bounds: Optional 2D list of ``[lower, upper]`` bounds per variable. Use ``None`` for an
            unbounded side.
        minimize_method: Optional string naming any solver supported by ``scipy.optimize.minimize``.
 
    Returns:
        Single-row 2D list containing the optimal variable values followed by the objective
        value, or an error message string if validation fails or the solver cannot complete.
 
    This example function is provided as-is without any representation of accuracy.
    """
    def normalize_to_2d_list(value):
        if not isinstance(value, list):
            return [[value]]
        return value
    
    if not isinstance(func_expr, str) or func_expr.strip() == "":
        return "Invalid input: func_expr must be a non-empty string."
    if "x" not in func_expr:
        return "Invalid input: function expression must contain the variable 'x'."
 
    # Normalize x_zero in case Excel passes a scalar instead of a 2D list
    x_zero = normalize_to_2d_list(x_zero)
    
    if not isinstance(x_zero, list) or len(x_zero) == 0 or not isinstance(x_zero[0], list):
        return "Invalid input: x_zero must be a 2D list, e.g., [[0, 0]]."
 
    x0_row = x_zero[0]
    if len(x0_row) == 0:
        return "Invalid input: x_zero must contain at least one variable."
 
    try:
        x0_vector = np.asarray([float(value) for value in x0_row], dtype=float)
    except (TypeError, ValueError):
        return "Invalid input: x_zero must contain numeric values."
 
    variable_count = x0_vector.size
 
    processed_bounds: Optional[List[Tuple[Optional[float], Optional[float]]]] = None
    if bounds is not None:
        # Normalize bounds in case Excel passes a scalar instead of a 2D list
        bounds = normalize_to_2d_list(bounds)
        if not isinstance(bounds, list) or len(bounds) != variable_count:
            return "Invalid input: bounds must provide one [min, max] pair per variable."
        processed_bounds = []
        for index, pair in enumerate(bounds):
            if not isinstance(pair, list) or len(pair) != 2:
                return "Invalid input: each bounds entry must be a [min, max] pair."
            lower_raw, upper_raw = pair
            try:
                lower_val = float(lower_raw) if lower_raw is not None else None
                upper_val = float(upper_raw) if upper_raw is not None else None
            except (TypeError, ValueError):
                return f"Invalid input: bounds for variable {index + 1} must be numeric or None."
            if lower_val is not None and not math.isfinite(lower_val):
                return f"Invalid input: bounds lower value for variable {index + 1} must be finite or None."
            if upper_val is not None and not math.isfinite(upper_val):
                return f"Invalid input: bounds upper value for variable {index + 1} must be finite or None."
            if lower_val is not None and upper_val is not None and lower_val > upper_val:
                return f"Invalid input: lower bound cannot exceed upper bound for variable {index + 1}."
            processed_bounds.append((lower_val, upper_val))
 
    solver_method = None
    if minimize_method is not None:
        # Check if method is a scalar that needs to be handled as a 2D list
        if not isinstance(minimize_method, list):
            # If method is not a list, treat it as a scalar and handle appropriately
            if isinstance(minimize_method, str):
                solver_method = minimize_method
            else:
                # If it's not a string and not a list, normalize it as a 2D list
                minimize_method = [[minimize_method]]
        if isinstance(minimize_method, list):
            if len(minimize_method) == 0:
                solver_method = None
            elif isinstance(minimize_method[0], list) and len(minimize_method[0]) > 0:
                solver_method = str(minimize_method[0][0])
            elif isinstance(minimize_method[0], str):
                solver_method = minimize_method[0]
            else:
                return "Invalid input: minimize_method must be a string, 2D list, or None."
        elif isinstance(minimize_method, str):
            solver_method = minimize_method
        else:
            return "Invalid input: minimize_method must be a string, 2D list, or None."
 
    safe_globals = {
        name: getattr(math, name)
        for name in dir(math)
        if not name.startswith("_")
    }
    safe_globals.update({
        "np": np,
        "numpy": np,
        "sin": np.sin,
        "cos": np.cos,
        "tan": np.tan,
        "asin": np.arcsin,
        "acos": np.arccos,
        "atan": np.arctan,
        "sinh": np.sinh,
        "cosh": np.cosh,
        "tanh": np.tanh,
        "exp": np.exp,
        "log": np.log,
        "sqrt": np.sqrt,
        "abs": np.abs,
        "pow": np.power,
    })
 
    # Objective wrapper that evaluates the expression for SciPy.
    def _objective(vector: np.ndarray) -> float:
        local_context = {"x": vector}
        try:
            value = eval(func_expr, safe_globals, local_context)
        except Exception:
            return float("inf")
        try:
            numeric_value = float(value)
        except (TypeError, ValueError):
            return float("inf")
        if not math.isfinite(numeric_value):
            return float("inf")
        return numeric_value
 
    # Pre-evaluate the objective at the initial guess to catch parse/eval errors early.
    try:
        initial_check = eval(func_expr, safe_globals, {"x": x0_vector})
    except Exception as exc:
        return f"Error: Invalid model expression at initial guess: {exc}"
    try:
        initial_value = float(initial_check)
    except (TypeError, ValueError):
        return "Error: Invalid model expression: objective did not return a numeric value at initial guess."
    if not math.isfinite(initial_value):
        return "Error: Invalid model expression: objective returned a non-finite value at initial guess."
 
    minimize_kwargs = {}
    if processed_bounds is not None:
        minimize_kwargs["bounds"] = processed_bounds
    if solver_method is not None:
        minimize_kwargs["method"] = solver_method
 
    try:
        result = scipy_minimize(_objective, x0=x0_vector, **minimize_kwargs)
    except ValueError as exc:
        return f"minimize error: {exc}"
    except Exception as exc:
        return f"minimize error: {exc}"
 
    if not result.success or result.x is None or result.fun is None:
        message = result.message if hasattr(result, "message") else "Optimization failed."
        return f"minimize failed: {message}"
 
    if not math.isfinite(result.fun):
        return "minimize failed: objective value is not finite."
 
    try:
        solution = [float(value) for value in result.x]
    except (TypeError, ValueError):
        return "minimize failed: solution vector could not be converted to floats."
 
    return [solution + [float(result.fun)]]