ez-optimize 0.1.0__tar.gz

ez_optimize-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quinn Marsh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ez_optimize-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: ez-optimize
+Version: 0.1.0
+Summary: A drop-in for scipy optimize that allows keyword args (x0={'x': 1, 'y': 2}) and more
+Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
+Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/qthedoc/ez-optimize
+Project-URL: Repository, https://github.com/qthedoc/ez-optimize
+Project-URL: Issues, https://github.com/qthedoc/ez-optimize/issues
+Project-URL: Say Thanks!, http://quinnmarsh.com
+Keywords: optimize,optimizer,minimize,minimizer,maximize,maximizer,keyword,keyword optimize,keyword optimizer,keyword minimizer,keyword maximizer,scipy,scipy optimize,scipy minimize,scipy root,quality of life
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.15
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Dynamic: license-file
+
+
+# ez-optimize
+
+**Author**: Quinn Marsh\
+**GitHub**: https://github.com/qthedoc/ez-optimize/ \
+**PyPI**: https://pypi.org/project/ez-optimize/ 
+
+`ez-optimize` makes optimization easy and intuitive. It is a lightweight wrapper for SciPy's `optimize` that offer a drop-in replacements for SciPy's `minimize` function with enhanced features like keyword-based parameter definitions and quick switching between minimization and maximization.
+
+The Ironman suit for optimization.
+
+## Why ez-optimize?
+
+### 1. Keyword-Based Optimization (e.g.: `x0={'x': 1, 'y': 2}`)
+By default, optimization uses arrays `x0=[1, 2]`. However sometimes it's more intuitive to use named parameters `x0={'x': 1, 'y': 2}`. `ez-optimize` allows you to define parameters as dictionaries. Then under the hood, `ez-optimize` automatically flattens parameters (and wraps your function) for SciPy while restoring the original structure in results. Keyword-based optimization is especially useful in complex systems like aerospace or energy models where parameters have meaningful names representing physical quantities.
+
+### 2. Switch to Maximize with `direction='max'`
+By default, optimization minimizes the objective function. To maximize, you typically need to write a negated version of your function. With `ez-optimize`, simply set `direction='max'` and the library will automatically negates your function under the hood.
+
+
+## Examples
+
+### Example 1: Minimizing the Rosenbrock Function with Array Mode
+
+```python
+import numpy as np
+from ez_optimize import minimize
+
+def rosenbrock_2d(x, y, a, b):
+    return (a - x)**2 + b * (y - x**2)**2
+
+x0 = {'x': 1.3, 'y': 0.7}
+
+result = minimize(rosenbrock_2d, x0, method='BFGS')
+
+print(f"Optimal x: {result.x_original}")
+print(f"Optimal value: {result.fun}")
+```
+```
+Optimal x: {'x': 1.0, 'y': 1.0}
+Optimal value: 0.0
+```
+
+### Example 2: Using OptimizationProblem for Advanced Manual Control
+
+For more control, use the `OptimizationProblem` class directly. This also serves as a look under the hood for how `minimize` works.:
+
+```python
+from ez_optimize import OptimizationProblem
+from scipy.optimize import minimize as scipy_minimize
+
+def objective(a, b, c):
+    return a**2 + b**2 + c**2
+
+x0 = {'a': 1.0, 'b': 2.0, 'c': 3.0}
+bounds = {'a': (0, 5), 'b': (0, 5), 'c': (0, 5)}
+
+# Define the optimization problem
+problem = OptimizationProblem(objective, x0, method='SLSQP', bounds=bounds)
+
+# Run SciPy method directly, passing in the arguments prepared by the OptimizationProblem
+scipy_result = scipy_minimize(**problem.scipy.get_minimize_args())
+
+# Use the OptimizationProblem to interpret the result back into our structured format
+result = problem.scipy.interpret_result(scipy_result)
+
+print(f"Optimal parameters: {result.x_original}")
+print(f"Optimal value: {result.fun}")
+```
+```
+Optimal parameters: {'a': 0.0, 'b': 0.0, 'c': 0.0}
+Optimal value: 0.0
+```
+
+## Fundumentally Why?
+Lets be honest, there is good reason optimization typically uses arrays and always minimizes... it makes the math simple and efficient. For example, optimizing in a vector space allows the hessian to be represented as a matrix. However, this level of optimization isn't always necessary like with black-box functions that have no gradient or hessian. In those cases, the convenience of defining keyword-based parameters and easy switching between min/max can outweigh the mathematical perfection of array-based optimization.
+
+## Acknowledgments
+
+Inspired by [better_optimize](https://github.com/jessegrabowski/better_optimize) by Jesse Grabowski, licensed under MIT.
+
+## Contributing
+
+Contributions Welcome! Report bugs, request features, or improve documentation via GitHub issues or pull requests.
+
+
+

ez_optimize-0.1.0/README.md

@@ -0,0 +1,87 @@
+
+# ez-optimize
+
+**Author**: Quinn Marsh\
+**GitHub**: https://github.com/qthedoc/ez-optimize/ \
+**PyPI**: https://pypi.org/project/ez-optimize/ 
+
+`ez-optimize` makes optimization easy and intuitive. It is a lightweight wrapper for SciPy's `optimize` that offer a drop-in replacements for SciPy's `minimize` function with enhanced features like keyword-based parameter definitions and quick switching between minimization and maximization.
+
+The Ironman suit for optimization.
+
+## Why ez-optimize?
+
+### 1. Keyword-Based Optimization (e.g.: `x0={'x': 1, 'y': 2}`)
+By default, optimization uses arrays `x0=[1, 2]`. However sometimes it's more intuitive to use named parameters `x0={'x': 1, 'y': 2}`. `ez-optimize` allows you to define parameters as dictionaries. Then under the hood, `ez-optimize` automatically flattens parameters (and wraps your function) for SciPy while restoring the original structure in results. Keyword-based optimization is especially useful in complex systems like aerospace or energy models where parameters have meaningful names representing physical quantities.
+
+### 2. Switch to Maximize with `direction='max'`
+By default, optimization minimizes the objective function. To maximize, you typically need to write a negated version of your function. With `ez-optimize`, simply set `direction='max'` and the library will automatically negates your function under the hood.
+
+
+## Examples
+
+### Example 1: Minimizing the Rosenbrock Function with Array Mode
+
+```python
+import numpy as np
+from ez_optimize import minimize
+
+def rosenbrock_2d(x, y, a, b):
+    return (a - x)**2 + b * (y - x**2)**2
+
+x0 = {'x': 1.3, 'y': 0.7}
+
+result = minimize(rosenbrock_2d, x0, method='BFGS')
+
+print(f"Optimal x: {result.x_original}")
+print(f"Optimal value: {result.fun}")
+```
+```
+Optimal x: {'x': 1.0, 'y': 1.0}
+Optimal value: 0.0
+```
+
+### Example 2: Using OptimizationProblem for Advanced Manual Control
+
+For more control, use the `OptimizationProblem` class directly. This also serves as a look under the hood for how `minimize` works.:
+
+```python
+from ez_optimize import OptimizationProblem
+from scipy.optimize import minimize as scipy_minimize
+
+def objective(a, b, c):
+    return a**2 + b**2 + c**2
+
+x0 = {'a': 1.0, 'b': 2.0, 'c': 3.0}
+bounds = {'a': (0, 5), 'b': (0, 5), 'c': (0, 5)}
+
+# Define the optimization problem
+problem = OptimizationProblem(objective, x0, method='SLSQP', bounds=bounds)
+
+# Run SciPy method directly, passing in the arguments prepared by the OptimizationProblem
+scipy_result = scipy_minimize(**problem.scipy.get_minimize_args())
+
+# Use the OptimizationProblem to interpret the result back into our structured format
+result = problem.scipy.interpret_result(scipy_result)
+
+print(f"Optimal parameters: {result.x_original}")
+print(f"Optimal value: {result.fun}")
+```
+```
+Optimal parameters: {'a': 0.0, 'b': 0.0, 'c': 0.0}
+Optimal value: 0.0
+```
+
+## Fundumentally Why?
+Lets be honest, there is good reason optimization typically uses arrays and always minimizes... it makes the math simple and efficient. For example, optimizing in a vector space allows the hessian to be represented as a matrix. However, this level of optimization isn't always necessary like with black-box functions that have no gradient or hessian. In those cases, the convenience of defining keyword-based parameters and easy switching between min/max can outweigh the mathematical perfection of array-based optimization.
+
+## Acknowledgments
+
+Inspired by [better_optimize](https://github.com/jessegrabowski/better_optimize) by Jesse Grabowski, licensed under MIT.
+
+## Contributing
+
+Contributions Welcome! Report bugs, request features, or improve documentation via GitHub issues or pull requests.
+
+
+

ez_optimize-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["ez_optimize*"]
+
+[project]
+name = 'ez-optimize'
+version = "0.1.0"
+requires-python = ">=3.10"
+authors = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
+maintainers = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
+description = "A drop-in for scipy optimize that allows keyword args (x0={'x': 1, 'y': 2}) and more"
+readme = "README.md"
+license = {text = "MIT License"}
+keywords = [
+  "optimize", "optimizer", 
+  "minimize", "minimizer", 
+  "maximize", "maximizer", 
+  "keyword", "keyword optimize", "keyword optimizer", 
+  "keyword minimizer", "keyword maximizer",
+  "scipy", "scipy optimize", 
+  "scipy minimize", "scipy root",
+  "quality of life"
+]
+classifiers =[
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Mathematics"
+]
+
+dependencies = [
+  'numpy',
+  'scipy>=1.15',
+]
+
+
+
+[project.optional-dependencies]
+tests = [
+  'pytest',
+]
+
+[project.urls]
+Homepage = "https://github.com/qthedoc/ez-optimize"
+Repository = "https://github.com/qthedoc/ez-optimize"
+Issues = "https://github.com/qthedoc/ez-optimize/issues"
+"Say Thanks!" = "http://quinnmarsh.com"
+
+

ez_optimize-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ez_optimize-0.1.0/src/ez_optimize/__init__.py

@@ -0,0 +1,15 @@
+import logging
+
+from ez_optimize.minimize import minimize
+from ez_optimize.optimization_problem import OptimizationProblem
+
+_log = logging.getLogger(__name__)
+
+if not logging.root.handlers:
+    _log.setLevel(logging.INFO)
+    if len(_log.handlers) == 0:
+        handler = logging.StreamHandler()
+        _log.addHandler(handler)
+
+# __version__ = get_versions()["version"]
+__all__ = ["minimize", "OptimizationProblem"]

ez_optimize-0.1.0/src/ez_optimize/constants.py

@@ -0,0 +1,35 @@
+from typing import Literal, get_args
+
+MinimizeMethod = Literal[
+    "nelder-mead",
+    "powell",
+    "CG",
+    "BFGS",
+    "Newton-CG",
+    "L-BFGS-B",
+    "TNC",
+    "COBYLA",
+    "SLSQP",
+    "trust-constr",
+    "dogleg",
+    "trust-ncg",
+    "trust-exact",
+    "trust-krylov",
+]
+
+MINIMIZE_METHODS = tuple(get_args(MinimizeMethod))
+
+RootMethod = Literal[
+    "hybr",
+    "lm",
+    "broyden1",
+    "broyden2",
+    "anderson",
+    "linearmixing",
+    "diagbroyden",
+    "excitingmixing",
+    "krylov",
+    "df-sane",
+]
+
+ROOT_METHODS = tuple(get_args(RootMethod))

ez_optimize-0.1.0/src/ez_optimize/minimize.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+
+import numpy as np
+
+from ez_optimize.optimization_problem import OptimizationProblem
+from ez_optimize.utilities import EzOptimizeResult
+from ez_optimize.constants import MinimizeMethod
+
+def minimize(
+    fun: Callable,
+    x0: Union[np.ndarray, Dict[str, Any]],
+    method: Optional[MinimizeMethod] = None,
+    direction: Literal["min", "max"] = "min",
+    bounds: Optional[Union[List[Tuple[float, float]], Dict[str, Tuple[float, float]], Dict[str, List[Tuple[float, float]]]]] = None,
+    x_mode: Optional[Literal["array", "dict"]] = None,
+    **kwargs,  # bounds, constraints, args, options, etc. stored for later use
+) -> EzOptimizeResult:
+    """
+    Minimize (or maximize) a scalar function of one or more variables.
+
+    This function provides a high-level interface to optimization algorithms,
+    supporting both array and dict-based parameter modes, with automatic
+    flattening and restoration of structures.
+
+    Parameters
+    ----------
+    fun : callable
+        The objective function to be minimized (or maximized).
+        For array mode: fun(x) where x is a numpy array.
+        For dict mode: fun(**params) where params is a dict of parameters.
+    x0 : array_like or dict
+        Initial guess. Array of real elements of size (n,),
+        or dict with parameter names as keys.
+    method : str, optional
+        Type of solver. Should be one of the methods supported by SciPy.
+    direction : {'min', 'max'}, optional
+        Direction of optimization. Default is 'min'.
+    x_mode : {'array', 'dict'}, optional
+        Mode for parameter handling. If None, inferred from x0.
+    bounds : sequence or dict, optional
+        Bounds on variables. For array mode: list of (min, max) pairs.
+        For dict mode: dict with same keys as x0, values as (min, max) or list of pairs.
+    **kwargs
+        Additional keyword arguments passed to the optimizer.
+
+    Returns
+    -------
+    EzOptimizeResult
+        The optimization result represented as an EzOptimizeResult object.
+        Important attributes are: ``x`` the solution array/dict, ``success`` a
+        Boolean flag indicating if the optimizer exited successfully and
+        ``message`` which describes the cause of the termination. See
+        EzOptimizeResult for a description of other attributes.
+
+    Notes
+    -----
+    This function uses the OptimizationProblem class internally to handle
+    parameter flattening, bounds, and direction, then delegates to SciPy's
+    minimize function.
+    """
+    problem = OptimizationProblem(
+        fun=fun,
+        x0=x0,
+        method=method,
+        direction=direction,
+        x_mode=x_mode,
+        bounds=bounds,
+        **kwargs
+    )
+    return problem.optimize()

ez_optimize-0.1.0/src/ez_optimize/optimization_problem.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+
+import numpy as np
+
+from ez_optimize.utilities import EzOptimizeResult, wrap_reconstruct_args, wrap_negate_if_max
+from ez_optimize.constants import MINIMIZE_METHODS, MinimizeMethod
+from scipy.optimize import minimize as scipy_minimize, OptimizeResult  # lazy import
+
+class OptimizationProblem:
+    """
+    Defines an optimization problem in a backend-agnostic way.
+
+    Handles:
+    - named / dict parameters
+    - flattening of nested structures (scalars, arrays, matrices)
+    - min / max direction
+    - fused objective return formats
+
+    SciPy-specific functionality is isolated in `.scipy` namespace.
+    """
+
+    def __init__(
+        self,
+        fun: Callable,
+        x0: Union[np.ndarray, Dict[str, Any]],
+        method: Optional[MinimizeMethod] = None,
+        direction: Literal["min", "max"] = "min",
+        bounds: Optional[Union[List[Tuple[float, float]], Dict[str, Tuple[float, float]], Dict[str, List[Tuple[float, float]]]]] = None,
+        x_mode: Optional[Literal["array", "dict"]] = None,
+        # fused_fun_map: Optional[Union[Literal["dict"], tuple[str, ...], Dict[str, str]]] = None,
+        # jac: Optional[Callable] = None,
+        # hess: Optional[Callable] = None,
+        # hessp: Optional[Callable] = None,
+        **kwargs,  # bounds, constraints, args, options, etc. stored for later use
+    ):
+        # Mode & flattening setup
+        self._prepare_parameters(x0, x_mode)
+
+        self._prepare_bounds(bounds)
+
+        self.method = self._prepare_method(method)
+
+        self.user_fun = fun
+        self.direction = direction.lower()
+        if self.direction not in ("min", "max"):
+            raise ValueError("direction must be 'min' or 'max'")
+
+
+        # Pass-through kwargs (bounds, constraints, tol, options, args, etc.)
+        self.kwargs = kwargs
+
+
+        # Return map for fused objectives
+        # self.fused_fun_map = fused_fun_map
+
+    # ────────────────────────────────────────────────────────────────
+    # Public API – backend agnostic
+    # ────────────────────────────────────────────────────────────────
+
+    @property
+    def scipy(self):
+        """SciPy-specific interface."""
+        return OptimizationProblem.SciPyInterface(self)
+
+    def optimize(self) -> EzOptimizeResult:
+        """
+        Convenience: run optimization using SciPy backend and return interpreted result.
+        """
+
+        args = self.scipy.get_minimize_args()
+        res = scipy_minimize(**args)
+        return self.scipy.interpret_result(res)
+
+    # ────────────────────────────────────────────────────────────────
+    # Internal helpers – shared across backends
+    # ────────────────────────────────────────────────────────────────
+
+    def _prepare_parameters(self, x0, x_mode: Optional[str] = None):
+        """Determine mode, flatten x0 and store mapping back to original structure."""
+
+        # Determine mode: array vs dict
+        self.x_mode = x_mode.lower() if x_mode is not None else ("dict" if isinstance(x0, dict) else "array")
+        if self.x_mode not in ("array", "dict"):
+            raise ValueError("x_mode must be 'array' or 'dict'")
+        
+        # For array mode, flatten x0 to 1D and store shape for restoration
+        if self.x_mode == "array":
+            x0_array = np.atleast_1d(np.asarray(x0, dtype=float))
+            if x0_array.ndim > 1:
+                raise ValueError("x0 must be 1D or scalar for array mode; multi-dimensional arrays are not supported")
+            self.x0_flat = x0_array.flatten()
+            self.x_map = x0_array.shape
+            self.x_keys = None
+            self.x_to_original = lambda x: x.reshape(self.x_map)
+            return
+        
+        # dict mode
+        if not isinstance(x0, dict):
+            raise ValueError("x0 must be a dict when x_mode='dict'")
+        
+        self.x_keys = list(x0.keys())
+        self.x_map = {}
+        flat_parts = []
+        for k in self.x_keys:
+            val = np.asarray(x0[k], dtype=float)
+            if val.ndim > 1:
+                raise ValueError(f"x0['{k}'] must be 1D or scalar for dict mode; multi-dimensional arrays are not supported")
+            self.x_map[k] = val.shape
+            flat_parts.append(val.ravel())
+        self.x0_flat = np.concatenate(flat_parts) if flat_parts else np.array([])
+        self.x_to_original = self._reconstruct_dict
+
+    def _reconstruct_dict(self, flat: np.ndarray) -> Dict[str, Any]:
+        result = {}
+        idx = 0
+        for k in self.x_keys:
+            shape = self.x_map[k]
+            size = np.prod(shape, dtype=int)
+            result[k] = flat[idx : idx + size].reshape(shape)
+            idx += size
+        return result
+    
+    def _prepare_bounds(self, bounds: Optional[Union[List[Tuple[float, float]], Dict[str, Tuple[float, float]], Dict[str, List[Tuple[float, float]]]]]):
+        """
+        Validates bounds against x_mode and x_map, and flattens bounds if in dict mode.
+        """
+        if bounds is None:
+            self.bounds_flat = None
+            return
+        
+        if self.x_mode == "array":
+            # Expect bounds as list of (min, max) tuples matching x0 length
+            if not isinstance(bounds, list) or len(bounds) != self.x0_flat.size or any(not isinstance(b, tuple) or len(b) != 2 for b in bounds):
+                raise ValueError(f"Bounds must be a list of (min, max) tuples matching the size of x0 ({self.x0_flat.size}) in array mode.")
+            self.bounds_flat = bounds
+            return
+        
+        # Dict mode: expect bounds as dict with same keys as x0, values are (min, max) tuples or lists of tuples
+        if not isinstance(bounds, dict):
+            raise ValueError("Bounds must be a dict when x_mode='dict'")
+        
+        flat_bounds = []
+        for k in self.x_keys:
+            if k not in bounds:
+                # fill in with (None, None) if key is missing
+                flat_bounds.extend([(None, None)] * np.prod(self.x_map[k], dtype=int))
+                continue
+
+            b = bounds[k]
+            shape = self.x_map[k]
+            if isinstance(b, tuple) and len(shape) == 0:
+                # Scalar parameter with (min, max)
+                flat_bounds.append(b)
+            elif isinstance(b, list) and len(b) == np.prod(shape) and all(isinstance(t, tuple) and len(t) == 2 for t in b):
+                # Parameter with shape > 0, bounds provided as list of tuples
+                flat_bounds.extend(b)
+            else:
+                raise ValueError(f"Bounds for key '{k}' must be a tuple for scalar parameters or a list of tuples matching the size of the parameter in dict mode.")
+        
+        if len(flat_bounds) != self.x0_flat.size:
+            raise ValueError(f"Internal error preparing bounds: Number of bounds ({len(flat_bounds)}) does not match number of parameters ({self.x0_flat.size})")
+
+        self.bounds_flat = flat_bounds
+    
+    @staticmethod
+    def _prepare_method(method: Optional[str]) -> Optional[str]:
+        if method is None or not isinstance(method, str):
+            raise ValueError("method must be a str")
+        if method not in MINIMIZE_METHODS:
+            raise ValueError(f"Unsupported method '{method}'. Supported: {', '.join(MINIMIZE_METHODS)}")
+        return method
+
+    class SciPyInterface:
+        """
+        Everything related to scipy.optimize.minimize is isolated here.
+        """
+
+        def __init__(self, parent: "OptimizationProblem"):
+            self.parent = parent
+
+        def get_minimize_args(
+            self,
+        ) -> dict:
+            """Build arguments for scipy.optimize.minimize."""
+
+            # Validate method
+            method = self.parent.method
+            if method is None or method not in MINIMIZE_METHODS:
+                raise ValueError(f"Unsupported method '{method}'. Supported: {', '.join(MINIMIZE_METHODS)}")
+
+            # Core arguments
+            args = {
+                "fun": self._wrap_fun(),
+                "x0": self.parent.x0_flat,
+                "method": method,
+                "bounds": self.parent.bounds_flat,
+            }
+
+            # Merge any extra kwargs
+            args.update(self.parent.kwargs)
+
+            return args
+
+        def interpret_result(self, scipy_result: OptimizeResult) -> EzOptimizeResult:
+            """Convert SciPy result into EasyOptimizeResult with restored structure."""
+
+            # Check success and warn if not successful
+            if not scipy_result.success:
+                warnings.warn(f"Optimization did not converge: {scipy_result.message}", RuntimeWarning)
+
+            result_dict = dict(scipy_result)
+
+            # Correct sign for maximization
+            if self.parent.direction == "max":
+                if "fun" in result_dict and result_dict["fun"] is not None:
+                    result_dict["fun"] = -result_dict.get("fun", 0.0)
+                # if "jac" in result_dict and result_dict["jac"] is not None:
+                #     result_dict["jac"] = -result_dict["jac"]
+
+            return EzOptimizeResult(
+                scipy_result=scipy_result,
+                x_mode=self.parent.x_mode,
+                x_map=self.parent.x_map,
+                x_to_original=self.parent.x_to_original,
+                direction=self.parent.direction,
+                **result_dict,
+            )
+        
+        # ─── SciPy-specific wrappers ────────────────────────────────────────
+
+        def _wrap_fun(self) -> Callable:
+            """
+            Wrap the user's objective function, return a scipy-ready function
+            """
+            fun = self.parent.user_fun
+
+            # Argument transformation and wrapping for SciPy
+            fun = wrap_reconstruct_args(
+                fun=fun,
+                x_mode=self.parent.x_mode,
+                x_to_original=self.parent.x_to_original
+            )
+
+            fun = wrap_negate_if_max(fun, self.parent.direction)
+
+            return fun
+
+        # def _wrap_jac(self, jac_func: Optional[Callable]) -> Callable:
+        #     if not jac_func:
+        #         return None
+
+        #     def wrapped(x_flat):
+        #         x = self.parent.flat_to_original(x_flat)
+        #         g = jac_func(**x) if self.parent.x_mode == "dict" else jac_func(x)
+        #         return -g if self.parent.direction == "max" else g
+
+        #     return wrapped
+
+        # def _wrap_hess(self, hess_func: Optional[Callable]) -> Callable:
+        #     # Hessian usually not negated
+        #     def wrapped(x_flat):
+        #         x = self.parent.flat_to_original(x_flat)
+        #         return hess_func(**x) if self.parent.x_mode == "dict" else hess_func(x)
+
+        #     return wrapped
+
+        # def _wrap_hessp(self, hessp_func: Optional[Callable]) -> Callable:
+        #     def wrapped(x_flat, p):
+        #         x = self.parent.flat_to_original(x_flat)
+        #         return hessp_func(x=x, p=p) if self.parent.x_mode == "array" else hessp_func(**x, p=p)
+
+        #     return wrapped
+
+        # def _add_fused_derivatives(self, args: dict):
+        #     # TODO: extract value, grad, hess from fused call
+        #     # For now just placeholder
+        #     raise NotImplementedError("Fused derivatives not yet implemented")
+        

ez_optimize-0.1.0/src/ez_optimize/utilities.py

@@ -0,0 +1,191 @@
+import logging
+
+import inspect
+from collections.abc import Callable
+from typing import Any, Dict, Optional, Union
+import warnings
+from scipy.optimize import OptimizeResult as ScipyOptimizeResult
+
+import numpy as np
+
+_log = logging.getLogger(__name__)
+
+def call_with_kwargs(func: Callable, kwargs: Dict[str, Any]) -> Any:
+    '''
+    Calls a function with matching kwargs, passing all provided kwargs if the function has **kwargs,
+    while checking for missing required arguments. Functions with *args are not supported and log a warning.
+
+    Args:
+        func: The function to call.
+        kwargs: Dictionary of keyword arguments to pass.
+
+    Returns:
+        The result of the function call.
+
+    Raises:
+        ValueError: If required arguments (without defaults) are missing.
+    '''
+    # Get the function signature
+    signature = inspect.signature(func)
+    parameters = signature.parameters
+
+    # Check for *args (VAR_POSITIONAL)
+    if any(param.kind == inspect.Parameter.VAR_POSITIONAL for param in parameters.values()):
+        _log.warning(
+            f"Function '{func.__name__}' has a *args parameter, which may not be fully supported by call_with_kwargs. "
+            "Consider using keyword arguments or **kwargs instead."
+        )
+
+    # Check for missing required arguments
+    missing_args = []
+    for name, param in parameters.items():
+        if (
+            param.default == inspect.Parameter.empty
+            and param.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+            and name not in kwargs
+        ):
+            missing_args.append(name)
+
+    # Raise an error if required arguments are missing
+    if missing_args:
+        missing_args_str = [f"'{arg}'" for arg in missing_args]
+        raise ValueError(
+            f"Missing required parameters for function '{func.__name__}': {', '.join(missing_args_str)}"
+        )
+
+    # Check if the function has a **kwargs parameter
+    has_kwargs = any(param.kind == inspect.Parameter.VAR_KEYWORD for param in parameters.values())
+
+    if has_kwargs:
+        # Pass all kwargs, including those matching named parameters and extras
+        return func(**kwargs)
+    else:
+        # Pass only kwargs that match the function's parameters, log if extras
+        extra_kwargs = set(kwargs.keys()) - set(parameters.keys())
+        if extra_kwargs:
+            _log.warning(
+                f"Extra kwargs provided to '{func.__name__}' without **kwargs support: {extra_kwargs}. They will be ignored."
+            )
+        matched_kwargs = {name: kwargs[name] for name in kwargs if name in parameters}
+        return func(**matched_kwargs)
+
+def wrap_reconstruct_args(
+    fun: Optional[Callable],
+    x_mode: str,
+    x_to_original: Callable[[np.ndarray], Any],
+    pos_arg_names: list[str] = None,               # e.g. ['p'] for hessp
+) -> Optional[Callable]:
+    """
+    Returns a wrapped version of a function that:
+    - take flat x (and optionally other args like p) for SciPy compatibility
+    - reconstruct original parameter structure
+    - call user function
+
+    Args:
+        fun: The user-provided callable (objective, jac, hess, hessp, ...)
+        x_mode: "array" or "dict"
+        x_to_original: Function that turns flat array → original x (dict or array)
+        pos_arg_names: Names to map positional args to (e.g. ['p'] for hessp)
+    """
+    if fun is None:
+        return None
+
+    pos_arg_names = pos_arg_names or []
+
+    def wrapped(x_flat: np.ndarray, *extra_args) -> Any:
+        # Reconstruct original parameters
+        x = x_to_original(x_flat)
+
+        # Prepare call arguments
+        if x_mode == "dict":
+            call_args = x.copy()  # dict
+        else:
+            call_args = [x]       # positional for array mode
+
+        # Map positional extra args (e.g. p for hessp)
+        extra_kwargs = {}
+        for name, value in zip(pos_arg_names, extra_args):
+            if name in extra_kwargs:
+                raise ValueError(f"Duplicate argument: {name}")
+            extra_kwargs[name] = value
+
+        # Call the function
+        if x_mode == "dict":
+            result = call_with_kwargs(fun, {**call_args, **extra_kwargs})
+        else:
+            result = fun(*call_args, *extra_args)
+
+        return result
+
+    return wrapped
+
+def wrap_negate_if_max(fun: Callable, direction: str) -> Callable:
+    """
+    Wraps a function to negate its output if the optimization direction is 'max'.
+
+    Args:
+        fun: The original function to wrap.
+        direction: 'min' or 'max'. If 'max', the output of `fun` will be negated.
+    Returns:
+        A wrapped function that negates the output of `fun` if direction is 'max'.
+    """
+    if direction == 'min':
+        return fun
+    
+    def wrapped(*args, **kwargs):
+        return -fun(*args, **kwargs)
+
+    return wrapped
+
+class EzOptimizeResult():
+    """
+    Enhanced result object for optimizations performed via ez-optimize.
+
+    Adds support for:
+    - Named/dict mode results (x_dict)
+    - Restored original shapes/structures (x_original)
+    - Automatic sign correction when direction='max'
+    """
+    def __init__(
+            self,
+            scipy_result: ScipyOptimizeResult,
+            x_mode: str = 'array', 
+            x_map: Optional[list[str]] = None, 
+            x_to_original: Optional[Callable[[np.ndarray], Any]] = None,
+            direction: str = 'min',
+            **extra_attrs
+        ):
+        # super().__init__(**scipy_result.__dict__)
+        self.scipy_result = scipy_result
+        self._x_mode = x_mode  # Store mode ('array' or 'dict')
+        self._x_map = x_map  # Store sorted keys from x0 dict
+        self.x_flat = scipy_result.x  # flat optimized parameters
+        self._x_to_original = x_to_original
+        self._direction = direction
+
+        # Attach any extra attributes
+        for k, v in extra_attrs.items():
+            setattr(self, k, v)
+
+    @property
+    def x_original(self) -> Union[np.ndarray, Dict[str, float]]:
+        '''
+        x_original property returns the optimized parameters as a numpy array or dictionary based on the mode.
+        '''
+        return self._restore_original_x()
+    
+    def _restore_original_x(self) -> Union[np.ndarray, Dict[str, Any]]:
+        """Convert flat optimized x back to original form (dict or shaped array)."""
+        if self._x_to_original is None:
+            return self.x_flat
+
+        try:
+            restored = self._x_to_original(self.x_flat)
+        except Exception as e:
+            warnings.warn(f"Failed to restore original shape: {e}", RuntimeWarning)
+            restored = self.x_flat
+
+        return restored
+
+
+    

ez_optimize-0.1.0/src/ez_optimize.egg-info/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: ez-optimize
+Version: 0.1.0
+Summary: A drop-in for scipy optimize that allows keyword args (x0={'x': 1, 'y': 2}) and more
+Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
+Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/qthedoc/ez-optimize
+Project-URL: Repository, https://github.com/qthedoc/ez-optimize
+Project-URL: Issues, https://github.com/qthedoc/ez-optimize/issues
+Project-URL: Say Thanks!, http://quinnmarsh.com
+Keywords: optimize,optimizer,minimize,minimizer,maximize,maximizer,keyword,keyword optimize,keyword optimizer,keyword minimizer,keyword maximizer,scipy,scipy optimize,scipy minimize,scipy root,quality of life
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.15
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Dynamic: license-file
+
+
+# ez-optimize
+
+**Author**: Quinn Marsh\
+**GitHub**: https://github.com/qthedoc/ez-optimize/ \
+**PyPI**: https://pypi.org/project/ez-optimize/ 
+
+`ez-optimize` makes optimization easy and intuitive. It is a lightweight wrapper for SciPy's `optimize` that offer a drop-in replacements for SciPy's `minimize` function with enhanced features like keyword-based parameter definitions and quick switching between minimization and maximization.
+
+The Ironman suit for optimization.
+
+## Why ez-optimize?
+
+### 1. Keyword-Based Optimization (e.g.: `x0={'x': 1, 'y': 2}`)
+By default, optimization uses arrays `x0=[1, 2]`. However sometimes it's more intuitive to use named parameters `x0={'x': 1, 'y': 2}`. `ez-optimize` allows you to define parameters as dictionaries. Then under the hood, `ez-optimize` automatically flattens parameters (and wraps your function) for SciPy while restoring the original structure in results. Keyword-based optimization is especially useful in complex systems like aerospace or energy models where parameters have meaningful names representing physical quantities.
+
+### 2. Switch to Maximize with `direction='max'`
+By default, optimization minimizes the objective function. To maximize, you typically need to write a negated version of your function. With `ez-optimize`, simply set `direction='max'` and the library will automatically negates your function under the hood.
+
+
+## Examples
+
+### Example 1: Minimizing the Rosenbrock Function with Array Mode
+
+```python
+import numpy as np
+from ez_optimize import minimize
+
+def rosenbrock_2d(x, y, a, b):
+    return (a - x)**2 + b * (y - x**2)**2
+
+x0 = {'x': 1.3, 'y': 0.7}
+
+result = minimize(rosenbrock_2d, x0, method='BFGS')
+
+print(f"Optimal x: {result.x_original}")
+print(f"Optimal value: {result.fun}")
+```
+```
+Optimal x: {'x': 1.0, 'y': 1.0}
+Optimal value: 0.0
+```
+
+### Example 2: Using OptimizationProblem for Advanced Manual Control
+
+For more control, use the `OptimizationProblem` class directly. This also serves as a look under the hood for how `minimize` works.:
+
+```python
+from ez_optimize import OptimizationProblem
+from scipy.optimize import minimize as scipy_minimize
+
+def objective(a, b, c):
+    return a**2 + b**2 + c**2
+
+x0 = {'a': 1.0, 'b': 2.0, 'c': 3.0}
+bounds = {'a': (0, 5), 'b': (0, 5), 'c': (0, 5)}
+
+# Define the optimization problem
+problem = OptimizationProblem(objective, x0, method='SLSQP', bounds=bounds)
+
+# Run SciPy method directly, passing in the arguments prepared by the OptimizationProblem
+scipy_result = scipy_minimize(**problem.scipy.get_minimize_args())
+
+# Use the OptimizationProblem to interpret the result back into our structured format
+result = problem.scipy.interpret_result(scipy_result)
+
+print(f"Optimal parameters: {result.x_original}")
+print(f"Optimal value: {result.fun}")
+```
+```
+Optimal parameters: {'a': 0.0, 'b': 0.0, 'c': 0.0}
+Optimal value: 0.0
+```
+
+## Fundumentally Why?
+Lets be honest, there is good reason optimization typically uses arrays and always minimizes... it makes the math simple and efficient. For example, optimizing in a vector space allows the hessian to be represented as a matrix. However, this level of optimization isn't always necessary like with black-box functions that have no gradient or hessian. In those cases, the convenience of defining keyword-based parameters and easy switching between min/max can outweigh the mathematical perfection of array-based optimization.
+
+## Acknowledgments
+
+Inspired by [better_optimize](https://github.com/jessegrabowski/better_optimize) by Jesse Grabowski, licensed under MIT.
+
+## Contributing
+
+Contributions Welcome! Report bugs, request features, or improve documentation via GitHub issues or pull requests.
+
+
+

ez_optimize-0.1.0/src/ez_optimize.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/ez_optimize/__init__.py
+src/ez_optimize/constants.py
+src/ez_optimize/minimize.py
+src/ez_optimize/optimization_problem.py
+src/ez_optimize/utilities.py
+src/ez_optimize.egg-info/PKG-INFO
+src/ez_optimize.egg-info/SOURCES.txt
+src/ez_optimize.egg-info/dependency_links.txt
+src/ez_optimize.egg-info/requires.txt
+src/ez_optimize.egg-info/top_level.txt
+tests/test_minimize.py
+tests/test_optimization_problem.py

ez_optimize-0.1.0/src/ez_optimize.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ez_optimize-0.1.0/src/ez_optimize.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+scipy>=1.15
+
+[tests]
+pytest

ez_optimize-0.1.0/src/ez_optimize.egg-info/top_level.txt

@@ -0,0 +1 @@
+ez_optimize

ez_optimize-0.1.0/tests/test_minimize.py

@@ -0,0 +1,122 @@
+import pytest
+from functools import partial
+
+import numpy as np
+
+from numpy.testing import assert_allclose
+
+from ez_optimize.minimize import minimize
+from ez_optimize.utilities import EzOptimizeResult
+
+no_grad_methods = ["nelder-mead", "powell", "CG", "BFGS", "L-BFGS-B"]
+
+
+def rosen(x, a, b) -> float:
+    """The Rosenbrock function"""
+    return sum(a * (x[1:] - x[:-1] ** 2.0) ** 2.0 + (1 - x[:-1]) ** 2.0) + b
+
+
+def rosen_2d_kw(x, y, a, b) -> float:
+    """The 2D Rosenbrock function in keyword mode"""
+    return rosen(np.array([x, y]), a, b)
+
+
+@pytest.mark.parametrize("method", no_grad_methods, ids=no_grad_methods)
+def test_array_5d(method: str):
+    x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
+
+    res = minimize(rosen, x0, method=method, args=(100, 0), tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+
+
+@pytest.mark.parametrize("method", no_grad_methods, ids=no_grad_methods)
+def test_kw_2d(method: str):
+    x0 = {'x': 1.3, 'y': 0.7}
+
+    res = minimize(partial(rosen_2d_kw, a=100, b=0), x0, method=method, tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(2), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(list(res.x_original.values()), np.ones(2), atol=1e-4, rtol=1e-4)
+
+
+@pytest.mark.parametrize("method", no_grad_methods, ids=no_grad_methods)
+def test_kw_array(method: str):
+    x0 = {'x':np.array([1.3, 0.7, 0.8, 1.9, 1.2])}
+
+    res = minimize(partial(rosen, a=100, b=0), x0, method=method, tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(res.x_original['x'], np.ones(5), atol=1e-4, rtol=1e-4)
+
+
+def test_array_direction_max():
+    def f(x):
+        return - (x - 1)**2
+
+    res = minimize(f, np.array([0.]), method='SLSQP', direction='max', bounds=[(0, 2)], tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, 1.0, atol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8)
+
+
+def test_kw_direction_max():
+    def f_kw(x):
+        return - (x - 1)**2
+
+    res = minimize(f_kw, {'x': 0.}, method='SLSQP', direction='max', tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(1), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(res.x_original['x'], np.ones(1), atol=1e-4, rtol=1e-4)
+
+
+@pytest.mark.parametrize("method", ["SLSQP", "L-BFGS-B"], ids=["SLSQP", "L-BFGS-B"])
+def test_array_with_bounds(method: str):
+    x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
+    bounds = [(0, 2), (0, 2), (0, 2), (0, 2), (0, 2)]
+
+    res = minimize(rosen, x0, method=method, args=(100, 0), bounds=bounds, tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+
+
+@pytest.mark.parametrize("method", ["SLSQP", "L-BFGS-B"], ids=["SLSQP", "L-BFGS-B"])
+def test_kw_with_bounds(method: str):
+    x0 = {'x': 1.3, 'y': 0.7}
+    bounds = {'x': (0, 2), 'y': (0, 2)}
+
+    res = minimize(partial(rosen_2d_kw, a=100, b=0), x0, method=method, bounds=bounds, tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(2), atol=1e-2, rtol=1e-2)
+    assert_allclose(res.fun, 0.0, atol=1e-5, rtol=1e-5)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(list(res.x_original.values()), np.ones(2), atol=1e-2, rtol=1e-2)
+
+
+@pytest.mark.parametrize("method", ["SLSQP", "L-BFGS-B"], ids=["SLSQP", "L-BFGS-B"])
+def test_kw_array_with_bounds(method: str):
+    x0 = {'x':np.array([1.3, 0.7, 0.8, 1.9, 1.2])}
+    bounds = {'x': [(0, 2), (0, 2), (0, 2), (0, 2), (0, 2)]}
+
+    res = minimize(partial(rosen, a=100, b=0), x0, method=method, bounds=bounds, tol=1e-8)
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(res.x_original['x'], np.ones(5), atol=1e-4, rtol=1e-4)

ez_optimize-0.1.0/tests/test_optimization_problem.py

@@ -0,0 +1,134 @@
+import pytest
+from functools import partial
+
+import numpy as np
+
+from numpy.testing import assert_allclose
+
+from ez_optimize.optimization_problem import OptimizationProblem
+from ez_optimize.utilities import EzOptimizeResult
+
+no_grad_methods = ["nelder-mead", "powell", "CG", "BFGS", "L-BFGS-B"]
+
+
+def rosen(x, a, b) -> float:
+    """The Rosenbrock function"""
+    return sum(a * (x[1:] - x[:-1] ** 2.0) ** 2.0 + (1 - x[:-1]) ** 2.0) + b
+
+
+def rosen_2d_kw(x, y, a, b) -> float:
+    """The 2D Rosenbrock function in keyword mode"""
+    return rosen(np.array([x, y]), a, b)
+
+
+@pytest.mark.parametrize("method", no_grad_methods, ids=no_grad_methods)
+def test_array_5d(method: str):
+    x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
+
+    prob = OptimizationProblem(rosen, x0, method=method, args=(100, 0), tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+
+
+@pytest.mark.parametrize("method", no_grad_methods, ids=no_grad_methods)
+def test_kw_2d(method: str):
+    x0 = {'x': 1.3, 'y': 0.7}
+
+    prob = OptimizationProblem(partial(rosen_2d_kw, a=100, b=0), x0, method=method, tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(2), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(list(res.x_original.values()), np.ones(2), atol=1e-4, rtol=1e-4)
+
+@pytest.mark.parametrize("method", no_grad_methods, ids=no_grad_methods)
+def test_kw_array(method: str):
+    x0 = {'x':np.array([1.3, 0.7, 0.8, 1.9, 1.2])}
+
+    prob = OptimizationProblem(partial(rosen, a=100, b=0), x0, method=method, tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(res.x_original['x'], np.ones(5), atol=1e-4, rtol=1e-4)
+
+def test_array_direction_max():
+    def f(x):
+        return - (x - 1)**2
+
+    prob = OptimizationProblem(f, np.array([0.]), method='SLSQP', direction='max', bounds=[(0, 2)], tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, 1.0, atol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8)
+
+
+def test_kw_direction_max():
+    def f_kw(x):
+        return - (x - 1)**2
+
+    prob = OptimizationProblem(f_kw, {'x': 0.}, method='SLSQP', direction='max', tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(1), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(res.x_original['x'], np.ones(1), atol=1e-4, rtol=1e-4)
+
+@pytest.mark.parametrize("method", ["SLSQP", "L-BFGS-B"], ids=["SLSQP", "L-BFGS-B"])
+def test_array_with_bounds(method: str):
+    x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
+    bounds = [(0, 2), (0, 2), (0, 2), (0, 2), (0, 2)]
+
+    prob = OptimizationProblem(rosen, x0, method=method, args=(100, 0), bounds=bounds, tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+
+
+@pytest.mark.parametrize("method", ["SLSQP", "L-BFGS-B"], ids=["SLSQP", "L-BFGS-B"])
+def test_kw_with_bounds(method: str):
+    x0 = {'x': 1.3, 'y': 0.7}
+    bounds = {'x': (0, 2), 'y': (0, 2)}
+
+    prob = OptimizationProblem(partial(rosen_2d_kw, a=100, b=0), x0, method=method, bounds=bounds, tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(2), atol=1e-2, rtol=1e-2)
+    assert_allclose(res.fun, 0.0, atol=1e-5, rtol=1e-5)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(list(res.x_original.values()), np.ones(2), atol=1e-2, rtol=1e-2)
+
+@pytest.mark.parametrize("method", ["SLSQP", "L-BFGS-B"], ids=["SLSQP", "L-BFGS-B"])
+def test_kw_array_with_bounds(method: str):
+    x0 = {'x':np.array([1.3, 0.7, 0.8, 1.9, 1.2])}
+    bounds = {'x': [(0, 2), (0, 2), (0, 2), (0, 2), (0, 2)]}
+
+    prob = OptimizationProblem(partial(rosen, a=100, b=0), x0, method=method, bounds=bounds, tol=1e-8)
+
+    res = prob.optimize()
+
+    assert isinstance(res, EzOptimizeResult)
+    assert_allclose(res.x, np.ones(5), atol=1e-4, rtol=1e-4)
+    assert_allclose(res.fun, 0.0, atol=1e-8, rtol=1e-8)
+    assert isinstance(res.x_original, dict)
+    assert_allclose(res.x_original['x'], np.ones(5), atol=1e-4, rtol=1e-4)