qoro-divi 0.2.0b1__py3-none-any.whl → 0.6.0__py3-none-any.whl

divi/exp/scipy/pyprima/__init__.py

@@ -1,263 +0,0 @@
-# Bounds may appear unused in this file but we need to import it to make it available to the user
-from collections.abc import Iterable
-from enum import Enum
-
-import numpy as np
-from scipy.optimize import Bounds, LinearConstraint, NonlinearConstraint
-
-from .cobyla.cobyla import cobyla
-from .common._bounds import process_bounds
-from .common._linear_constraints import (
-    combine_multiple_linear_constraints,
-    separate_LC_into_eq_and_ineq,
-)
-from .common._nonlinear_constraints import process_nl_constraints
-from .common._project import _project
-from .common.linalg import get_arrays_tol
-
-
-class ConstraintType(Enum):
-    LINEAR_OBJECT = 5
-    NONLINEAR_OBJECT = 10
-    LINEAR_DICT = 15
-    NONLINEAR_DICT = 20
-
-
-def get_constraint_type(constraint):
-    if (
-        isinstance(constraint, dict)
-        and ("A" in constraint)
-        and ("lb" in constraint)
-        and ("ub" in constraint)
-    ):
-        return ConstraintType.LINEAR_DICT
-    elif (
-        isinstance(constraint, dict)
-        and ("fun" in constraint)
-        and ("lb" in constraint)
-        and ("ub" in constraint)
-    ):
-        return ConstraintType.NONLINEAR_DICT
-    elif (
-        hasattr(constraint, "A")
-        and hasattr(constraint, "lb")
-        and hasattr(constraint, "ub")
-    ):
-        return ConstraintType.LINEAR_OBJECT
-    elif (
-        hasattr(constraint, "fun")
-        and hasattr(constraint, "lb")
-        and hasattr(constraint, "ub")
-    ):
-        return ConstraintType.NONLINEAR_OBJECT
-    else:
-        raise ValueError(f"Constraint type {type(constraint)} not recognized")
-
-
-def process_constraints(constraints):
-    # First throw it back if it's an empty tuple
-    if not constraints:
-        return None, None
-    # Next figure out if it's a list of constraints or a single constraint
-    # If it's a single constraint, make it a list, and then the remaining logic
-    # doesn't have to change
-    if not isinstance(constraints, Iterable):
-        constraints = [constraints]
-
-    # Separate out the linear and nonlinear constraints
-    linear_constraints = []
-    nonlinear_constraints = []
-    for constraint in constraints:
-        constraint_type = get_constraint_type(constraint)
-        if constraint_type is ConstraintType.LINEAR_OBJECT:
-            linear_constraints.append(constraint)
-        elif constraint_type is ConstraintType.NONLINEAR_OBJECT:
-            nonlinear_constraints.append(constraint)
-        elif constraint_type == ConstraintType.LINEAR_DICT:
-            linear_constraints.append(
-                LinearConstraint(constraint["A"], constraint["lb"], constraint["ub"])
-            )
-        elif constraint_type == ConstraintType.NONLINEAR_DICT:
-            nonlinear_constraints.append(
-                NonlinearConstraint(
-                    constraint["fun"], constraint["lb"], constraint["ub"]
-                )
-            )
-        else:
-            raise ValueError("Constraint type not recognized")
-
-    if len(nonlinear_constraints) > 0:
-        nonlinear_constraint_function = process_nl_constraints(nonlinear_constraints)
-    else:
-        nonlinear_constraint_function = None
-
-    # Determine if we have multiple linear constraints, just 1, or none, and process accordingly
-    if len(linear_constraints) > 1:
-        linear_constraint = combine_multiple_linear_constraints(linear_constraints)
-    elif len(linear_constraints) == 1:
-        linear_constraint = linear_constraints[0]
-    else:
-        linear_constraint = None
-
-    return linear_constraint, nonlinear_constraint_function
-
-
-def minimize(
-    fun,
-    x0,
-    args=(),
-    method=None,
-    bounds=None,
-    constraints=(),
-    callback=None,
-    options=None,
-):
-
-    linear_constraint, nonlinear_constraint_function = process_constraints(constraints)
-
-    options = {"quiet": True} if options is None else options
-    quiet = options.get("quiet", True)
-
-    if method is None:
-        if nonlinear_constraint_function is not None:
-            if not quiet:
-                print("Nonlinear constraints detected, applying COBYLA")
-            method = "cobyla"
-        elif linear_constraint is not None:
-            if not quiet:
-                print(
-                    "Linear constraints detected without nonlinear constraints, applying LINCOA"
-                )
-            method = "lincoa"
-        elif bounds is not None:
-            if not quiet:
-                print(
-                    "Bounds without linear or nonlinear constraints detected, applying BOBYQA"
-                )
-            method = "bobyqa"
-        else:
-            if not quiet:
-                print("No bounds or constraints detected, applying NEWUOA")
-            method = "newuoa"
-    else:
-        # Raise some errors if methods were called with inappropriate options
-        method = method.lower()
-        if method not in ("newuoa", "uobyqa", "bobyqa", "cobyla", "lincoa"):
-            raise ValueError(
-                f"Method must be one of NEWUOA, UOBYQA, BOBYQA, COBYLA, or LINCOA, not '{method}'"
-            )
-        if method != "cobyla" and nonlinear_constraint_function is not None:
-            raise ValueError(
-                "Nonlinear constraints were provided for an algorithm that cannot handle them"
-            )
-        if method not in ("cobyla", "lincoa") and linear_constraint is not None:
-            raise ValueError(
-                "Linear constraints were provided for an algorithm that cannot handle them"
-            )
-        if method not in ("cobyla", "bobyqa", "lincoa") and bounds is not None:
-            raise ValueError(
-                "Bounds were provided for an algorithm that cannot handle them"
-            )
-
-    # Try to get the length of x0. If we can't that likely means it's a scalar, and
-    # in that case we turn it into an array and wrap the original function so that it
-    # can accept an array and return a scalar.
-    try:
-        lenx0 = len(x0)
-    except TypeError:
-        x0 = np.array([x0])
-        original_scalar_fun = fun
-
-        def scalar_fun(x):
-            return original_scalar_fun(x[0], *args)
-
-        fun = scalar_fun
-        lenx0 = 1
-
-    lb, ub = process_bounds(bounds, lenx0)
-
-    # Check which variables are fixed and eliminate them from the problem.
-    # Save the indices and values so that we can call the original function with
-    # an array of the appropriate size, and so that we can add the fixed values to the
-    # result when COBYLA returns.
-    tol = get_arrays_tol(lb, ub)
-    _fixed_idx = (lb <= ub) & (np.abs(lb - ub) < tol)
-    if any(_fixed_idx):
-        _fixed_values = 0.5 * (lb[_fixed_idx] + ub[_fixed_idx])
-        _fixed_values = np.clip(
-            _fixed_values,
-            lb[_fixed_idx],
-            ub[_fixed_idx],
-        )
-        x0 = x0[~_fixed_idx]
-        lb = lb[~_fixed_idx]
-        ub = ub[~_fixed_idx]
-        original_fun = fun
-
-        def fixed_fun(x):
-            newx = np.zeros(lenx0)
-            newx[_fixed_idx] = _fixed_values
-            newx[~_fixed_idx] = x
-            return original_fun(newx, *args)
-
-        fun = fixed_fun
-
-    # Project x0 onto the feasible set
-    if nonlinear_constraint_function is None:
-        result = _project(x0, lb, ub, {"linear": linear_constraint, "nonlinear": None})
-        x0 = result.x
-
-    if linear_constraint is not None:
-        A_eq, b_eq, A_ineq, b_ineq = separate_LC_into_eq_and_ineq(linear_constraint)
-    else:
-        A_eq, b_eq, A_ineq, b_ineq = None, None, None, None
-
-    if nonlinear_constraint_function is not None:
-        # If there is a nonlinear constraint function, we will call COBYLA, which needs the number of nonlinear
-        # constraints (m_nlcon). In order to get this number we need to evaluate the constraint function at x0.
-        # The constraint value at x0 (nlconstr0) is not discarded but passed down to the Fortran backend, as its
-        # evaluation is assumed to be expensive. We also evaluate the objective function at x0 and pass the result
-        # (f0) down to the Fortran backend, which expects nlconstr0 and f0 to be provided in sync.
-        def calcfc(x):
-            f = fun(x, *args)
-            nlconstr = nonlinear_constraint_function(x)
-            return f, nlconstr
-
-    else:
-
-        def calcfc(x):
-            f = fun(x, *args)
-            constr = np.zeros(0)
-            return f, constr
-
-    f0, nlconstr0 = calcfc(x0)
-
-    if "quiet" in options:
-        del options["quiet"]
-
-    if "maxfev" in options:
-        options["maxfun"] = options["maxfev"]
-        del options["maxfev"]
-
-    result = cobyla(
-        calcfc,
-        len(nlconstr0),
-        x0,
-        A_ineq,
-        b_ineq,
-        A_eq,
-        b_eq,
-        lb,
-        ub,
-        f0=f0,
-        nlconstr0=nlconstr0,
-        callback=callback,
-        **options,
-    )
-
-    if any(_fixed_idx):
-        newx = np.zeros(lenx0)
-        newx[_fixed_idx] = _fixed_values
-        newx[~_fixed_idx] = result.x
-        result.x = newx
-    return result