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

divi/exp/scipy/pyprima/common/_project.py

@@ -1,224 +0,0 @@
-"""
-This module provides the _project function that attempts to project the initial guess
-onto the feasible set.
-
-Adapted from the corresponding function in the PDFO package (https://www.pdfo.net) by
-Tom M. Ragonneau (https://ragonneau.github.io) and Zaikun Zhang (https://www.zhangzk.net).
-"""
-
-import numpy as np
-from scipy.optimize import OptimizeResult
-
-from ._linear_constraints import LinearConstraint
-
-# All the accepted scalar types; np.generic correspond to all NumPy types.
-scalar_types = (int, float, np.generic)
-eps = np.finfo(np.float64).eps
-
-
-def _project(x0, lb, ub, constraints):
-    """Projection of the initial guess onto the feasible set.
-
-    Parameters
-    ----------
-    x0: ndarray, shape (n,)
-        The same as in prepdfo.
-    lb: ndarray, shape (n,)
-        The same as in prepdfo.
-    ub: ndarray, shape (n,)
-        The same as in prepdfo.
-    constraints: dict
-        The general constraints of the problem, defined as a dictionary with
-        fields:
-            linear: LinearConstraint
-                The linear constraints of the problem.
-            nonlinear: dict
-                The nonlinear constraints of the problem. When ``_project`` is called, the nonlinear constraints are
-                None.
-
-    Returns
-    -------
-    result: OptimizeResult
-        The result of the projection.
-
-    Authors
-    -------
-    Tom M. RAGONNEAU (ragonneau.github.io)
-    and Zaikun ZHANG (www.zhangzk.net)
-
-    Dedicated to the late Professor M. J. D. Powell FRS (1936--2015).
-    """
-    invoker = "prima"
-
-    # Validate x0.
-    if isinstance(x0, scalar_types):
-        x0_c = [x0]
-    elif hasattr(x0, "__len__"):
-        x0_c = x0
-    else:
-        raise ValueError("{}: UNEXPECTED ERROR: x0 should be a vector.".format(invoker))
-    try:
-        x0_c = np.asarray(x0_c, dtype=np.float64)
-    except ValueError:
-        raise ValueError(
-            "{}: UNEXPECTED ERROR: x0 should contain only scalars.".format(invoker)
-        )
-    if len(x0_c.shape) != 1:
-        raise ValueError("{}: UNEXPECTED ERROR: x0 should be a vector.".format(invoker))
-    lenx0 = x0_c.size
-
-    # Validate lb.
-    if isinstance(lb, scalar_types):
-        lb_c = [lb]
-    elif hasattr(lb, "__len__"):
-        lb_c = lb
-    else:
-        raise ValueError("{}: UNEXPECTED ERROR: lb should be a vector.".format(invoker))
-    try:
-        lb_c = np.asarray(lb_c, dtype=np.float64)
-    except ValueError:
-        raise ValueError(
-            "{}: UNEXPECTED ERROR: lb should contain only scalars.".format(invoker)
-        )
-    if len(lb_c.shape) != 1 or lb_c.size != lenx0:
-        raise ValueError(
-            "{}: UNEXPECTED ERROR: the size of lb is inconsistent with x0.".format(
-                invoker
-            )
-        )
-
-    # Validate ub.
-    if isinstance(ub, scalar_types):
-        ub_c = [ub]
-    elif hasattr(ub, "__len__"):
-        ub_c = ub
-    else:
-        raise ValueError("{}: UNEXPECTED ERROR: ub should be a vector.".format(invoker))
-    try:
-        ub_c = np.asarray(ub_c, dtype=np.float64)
-    except ValueError:
-        raise ValueError(
-            "{}: UNEXPECTED ERROR: ub should contain only scalars.".format(invoker)
-        )
-    if len(ub_c.shape) != 1 or ub_c.size != lenx0:
-        raise ValueError(
-            "{}: UNEXPECTED ERROR: the size of ub is inconsistent with x0.".format(
-                invoker
-            )
-        )
-
-    # Validate constraints.
-    if (
-        not isinstance(constraints, dict)
-        or not ({"linear", "nonlinear"} <= set(constraints.keys()))
-        or not (
-            isinstance(constraints["linear"], LinearConstraint)
-            or constraints["linear"] is None
-        )
-    ):
-        # the nonlinear constraints will not be taken into account in this function and are, therefore, not validated
-        raise ValueError(
-            "{}: UNEXPECTED ERROR: The constraints are ill-defined.".format(invoker)
-        )
-
-    max_con = 1e20  # Decide whether an inequality constraint can be ignored
-
-    # Project onto the feasible set.
-    if constraints["linear"] is None:
-        # Direct projection onto the bound constraints
-        x_proj = np.nanmin((np.nanmax((x0_c, lb_c), axis=0), ub_c), axis=0)
-        return OptimizeResult(x=x_proj)
-    elif (
-        all(
-            np.less_equal(
-                np.abs(constraints["linear"].ub - constraints["linear"].lb), eps
-            )
-        )
-        and np.max(lb_c) <= -max_con
-        and np.min(ub_c) >= max_con
-    ):
-        # The linear constraints are all equality constraints. The projection can therefore be done by solving the
-        # least-squares problem: min ||A*x - (b - A*x_0)||.
-        a = constraints["linear"].A
-        b = (constraints["linear"].lb + constraints["linear"].ub) / 2
-        xi, _, _, _ = np.linalg.lstsq(a, b - np.dot(a, x0_c), rcond=None)
-
-        # The problem is not bounded. However, if the least-square solver returned values bigger in absolute value
-        # than max_con, they will be reduced to this bound.
-        x_proj = np.nanmin((np.nanmax((x0_c + xi, lb_c), axis=0), ub_c), axis=0)
-
-        return OptimizeResult(x=x_proj)
-
-    if constraints["linear"] is not None:
-        try:
-            # Project the initial guess onto the linear constraints via SciPy.
-            from scipy.optimize import Bounds as ScipyBounds
-            from scipy.optimize import LinearConstraint as ScipyLinearConstraint
-            from scipy.optimize import minimize
-
-            linear = constraints["linear"]
-
-            # To be more efficient, SciPy asks to separate the equality and the inequality constraints into two
-            # different LinearConstraint structures
-            pc_args_ineq, pc_args_eq = dict(), dict()
-            pc_args_ineq["A"], pc_args_eq["A"] = np.asarray([[]]), np.asarray([[]])
-            pc_args_ineq["A"] = pc_args_ineq["A"].reshape(0, linear.A.shape[1])
-            pc_args_eq["A"] = pc_args_eq["A"].reshape(0, linear.A.shape[1])
-            pc_args_ineq["lb"], pc_args_eq["lb"] = np.asarray([]), np.asarray([])
-            pc_args_ineq["ub"], pc_args_eq["ub"] = np.asarray([]), np.asarray([])
-
-            for i in range(linear.lb.size):
-                if linear.lb[i] != linear.ub[i]:
-                    pc_args_ineq["A"] = np.concatenate(
-                        (pc_args_ineq["A"], linear.A[i : i + 1, :]), axis=0
-                    )
-                    pc_args_ineq["lb"] = np.r_[pc_args_ineq["lb"], linear.lb[i]]
-                    pc_args_ineq["ub"] = np.r_[pc_args_ineq["ub"], linear.ub[i]]
-                else:
-                    pc_args_eq["A"] = np.concatenate(
-                        (pc_args_eq["A"], linear.A[i : i + 1, :]), axis=0
-                    )
-                    pc_args_eq["lb"] = np.r_[pc_args_eq["lb"], linear.lb[i]]
-                    pc_args_eq["ub"] = np.r_[pc_args_eq["ub"], linear.ub[i]]
-
-            if (
-                pc_args_ineq["A"].size > 0
-                and pc_args_ineq["lb"].size > 0
-                and pc_args_eq["lb"].size > 0
-            ):
-                project_constraints = [
-                    ScipyLinearConstraint(**pc_args_ineq),
-                    ScipyLinearConstraint(**pc_args_eq),
-                ]
-            elif pc_args_ineq["A"].size > 0 and pc_args_ineq["lb"].size > 0:
-                project_constraints = ScipyLinearConstraint(**pc_args_ineq)
-            elif pc_args_eq["A"].size > 0:
-                project_constraints = ScipyLinearConstraint(**pc_args_eq)
-            else:
-                project_constraints = ()
-
-            # Perform the actual projection.
-            ax_ineq = np.dot(pc_args_ineq["A"], x0_c)
-            ax_eq = np.dot(pc_args_eq["A"], x0_c)
-            if (
-                np.greater(ax_ineq, pc_args_ineq["ub"]).any()
-                or np.greater(pc_args_ineq["lb"], ax_ineq).any()
-                or np.not_equal(ax_eq, pc_args_eq["lb"]).any()
-                or np.greater(x0_c, ub_c).any()
-                or np.greater(lb_c, x0_c).any()
-            ):
-                return minimize(
-                    lambda x: np.dot(x - x0_c, x - x0_c) / 2,
-                    x0_c,
-                    jac=lambda x: (x - x0_c),
-                    bounds=ScipyBounds(lb_c, ub_c),
-                    constraints=project_constraints,
-                )
-            else:
-                # Do not perform any projection if the initial guess is feasible.
-                return OptimizeResult(x=x0_c)
-
-        except ImportError:
-            return OptimizeResult(x=x0_c)
-
-    return OptimizeResult(x=x0_c)

divi/exp/scipy/pyprima/common/checkbreak.py

@@ -1,107 +0,0 @@
-"""
-This module checks whether to break out of the solver loop.
-
-Translated from Zaikun Zhang's modern-Fortran reference implementation in PRIMA.
-
-Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
-
-Python translation by Nickolai Belakovski.
-"""
-
-import numpy as np
-
-from .infos import FTARGET_ACHIEVED, INFO_DEFAULT, MAXFUN_REACHED, NAN_INF_F, NAN_INF_X
-
-
-def checkbreak_unc(maxfun, nf, f, ftarget, x):
-    """
-    This module checks whether to break out of the solver loop in the unconstrained case.
-    """
-
-    # Outputs
-    info = INFO_DEFAULT
-
-    # Local variables
-    srname = "CHECKbreak_UNC"
-
-    # Preconditions
-    assert INFO_DEFAULT not in [
-        NAN_INF_X,
-        NAN_INF_F,
-        FTARGET_ACHIEVED,
-        MAXFUN_REACHED,
-    ], f"NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, and MAXFUN_REACHED differ from INFO_DFT {srname}"
-    # X does not contain NaN if the initial X does not contain NaN and the subroutines generating
-    # trust-region/geometry steps work properly so that they never produce a step containing NaN/Inf.
-    assert not any(np.isnan(x)), f"X does not contain NaN {srname}"
-    # With the moderated extreme barrier, F cannot be NaN/+Inf.
-    assert not (any(np.isnan(f)) or any(np.isposinf(f))), f"F is not NaN/+Inf {srname}"
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # Although X should not contain NaN unless there is a bug, we include the following for security.
-    # X can be Inf, as finite + finite can be Inf numerically.
-    if any(np.isnan(x)) or any(np.isinf(x)):
-        info = NAN_INF_X
-
-    # Although NAN_INF_F should not happen unless there is a bug, we include the following for security.
-    if any(np.isnan(f)) or any(np.isposinf(f)):
-        info = NAN_INF_F
-
-    if f <= ftarget:
-        info = FTARGET_ACHIEVED
-
-    if nf >= maxfun:
-        info = MAXFUN_REACHED
-
-    return info
-
-
-def checkbreak_con(maxfun, nf, cstrv, ctol, f, ftarget, x):
-    """
-    This module checks whether to break out of the solver loop in the constrained case.
-    """
-
-    # Outputs
-    info = INFO_DEFAULT
-
-    # Local variables
-    srname = "CHECKbreak_CON"
-
-    # Preconditions
-    assert INFO_DEFAULT not in [
-        NAN_INF_X,
-        NAN_INF_F,
-        FTARGET_ACHIEVED,
-        MAXFUN_REACHED,
-    ], f"NAN_INF_X, NAN_INF_F, FTARGET_ACHIEVED, and MAXFUN_REACHED differ from INFO_DFT {srname}"
-    # X does not contain NaN if the initial X does not contain NaN and the subroutines generating
-    # trust-region/geometry steps work properly so that they never produce a step containing NaN/Inf.
-    assert not any(np.isnan(x)), f"X does not contain NaN {srname}"
-    # With the moderated extreme barrier, F or CSTRV cannot be NaN/+Inf.
-    assert not (
-        np.isnan(f) or np.isposinf(f) or np.isnan(cstrv) or np.isposinf(cstrv)
-    ), f"F or CSTRV is not NaN/+Inf {srname}"
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # Although X should not contain NaN unless there is a bug, we include the following for security.
-    # X can be Inf, as finite + finite can be Inf numerically.
-    if any(np.isnan(x)) or any(np.isinf(x)):
-        info = NAN_INF_X
-
-    # Although NAN_INF_F should not happen unless there is a bug, we include the following for security.
-    if np.isnan(f) or np.isposinf(f) or np.isnan(cstrv) or np.isposinf(cstrv):
-        info = NAN_INF_F
-
-    if cstrv <= ctol and f <= ftarget:
-        info = FTARGET_ACHIEVED
-
-    if nf >= maxfun:
-        info = MAXFUN_REACHED
-
-    return info

divi/exp/scipy/pyprima/common/consts.py

@@ -1,48 +0,0 @@
-"""
-This is a module defining some constants.
-
-Translated from Zaikun Zhang's modern-Fortran reference implementation in PRIMA.
-
-Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
-
-Python translation by Nickolai Belakovski.
-"""
-
-import os
-
-import numpy as np
-
-DEBUGGING = bool(os.getenv("PRIMA_DEBUGGING"))
-
-REALMIN = np.finfo(float).tiny
-REALMAX = np.finfo(float).max
-FUNCMAX = 10.0**30
-CONSTRMAX = FUNCMAX
-EPS = np.finfo(float).eps
-
-# Any bound with an absolute value at least BOUNDMAX is considered as no bound.
-BOUNDMAX = REALMAX / 4
-
-# Some default values
-RHOBEG_DEFAULT = 1
-RHOEND_DEFAULT = 1e-6
-FTARGET_DEFAULT = -REALMAX
-CTOL_DEFAULT = np.sqrt(EPS)
-CWEIGHT_DEFAULT = 1e8
-ETA1_DEFAULT = 0.1
-ETA2_DEFAULT = 0.7
-GAMMA1_DEFAULT = 0.5
-GAMMA2_DEFAULT = 2
-IPRINT_DEFAULT = 0
-MAXFUN_DIM_DEFAULT = 500
-
-PRIMA_MAX_HIST_MEM_MB = 300  # 1MB > 10^5*REAL64. 100 can be too small.
-
-# Maximal amount of memory (Byte) allowed for XHIST, FHIST, CONHIST, CHIST, and the filters.
-MHM = PRIMA_MAX_HIST_MEM_MB * 10**6
-# Make sure that MAXHISTMEM does not exceed HUGE(0) to avoid overflow and memory errors.
-MAXHISTMEM = min(MHM, np.iinfo(np.int32).max)
-
-# Maximal length of the filter used in constrained solvers.
-MIN_MAXFILT = 200  # Should be positive; < 200 is not recommended.
-MAXFILT_DEFAULT = 10 * MIN_MAXFILT

divi/exp/scipy/pyprima/common/evaluate.py

@@ -1,101 +0,0 @@
-"""
-This is a module evaluating the objective/constraint function with Nan/Inf handling.
-
-Translated from Zaikun Zhang's modern-Fortran reference implementation in PRIMA.
-
-Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
-
-Python translation by Nickolai Belakovski.
-"""
-
-import numpy as np
-
-from .consts import CONSTRMAX, DEBUGGING, FUNCMAX, REALMAX
-from .linalg import matprod, primasum
-
-# This is a module evaluating the objective/constraint function with Nan/Inf handling.
-
-
-def moderatex(x):
-    """
-    This function moderates a decision variable. It replaces NaN by 0 and Inf/-Inf by
-    REALMAX/-REALMAX.
-    """
-    x[np.isnan(x)] = 0
-    x = np.clip(x, -REALMAX, REALMAX)
-    return x
-
-
-def moderatef(f):
-    """
-    This function moderates the function value of a MINIMIZATION problem. It replaces
-    NaN and any value above FUNCMAX by FUNCMAX.
-    """
-    f = FUNCMAX if np.isnan(f) else f
-    f = np.clip(f, -REALMAX, FUNCMAX)
-    # We may moderate huge negative function values as follows, but we decide not to.
-    # f = np.clip(f, -FUNCMAX, FUNCMAX)
-    return f
-
-
-def moderatec(c):
-    """
-    This function moderates the constraint value, the constraint demanding this value
-    to be NONNEGATIVE. It replaces any value below -CONSTRMAX by -CONSTRMAX, and any
-    NaN or value above CONSTRMAX by CONSTRMAX.
-    """
-    np.nan_to_num(c, copy=False, nan=CONSTRMAX)
-    c = np.clip(c, -CONSTRMAX, CONSTRMAX)
-    return c
-
-
-def evaluate(calcfc, x, m_nlcon, amat, bvec):
-    """
-    This function evaluates CALCFC at X, returning the objective function value and the
-    constraint value. Nan/Inf are handled by a moderated extreme barrier.
-    """
-
-    # Sizes
-    m_lcon = len(bvec) if bvec is not None else 0
-
-    # Preconditions
-    if DEBUGGING:
-        # X should not contain NaN if the initial X does not contain NaN and the
-        # subroutines generating # trust-region/geometry steps work properly so that
-        # they never produce a step containing NaN/Inf.
-        assert not any(np.isnan(x))
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    constr = np.zeros(m_lcon + m_nlcon)
-    if amat is not None:
-        constr[:m_lcon] = matprod(x, amat.T) - bvec
-
-    if any(np.isnan(x)):
-        # Although this should not happen unless there is a bug, we include this case
-        # for robustness.
-        f = primasum(x)
-        constr = np.ones(m_nlcon) * f
-    else:
-        f, constr[m_lcon:] = calcfc(moderatex(x))
-
-        # Moderated extreme barrier: replace NaN/huge objective or constraint values
-        # with a large but finite value. This is naive, and better approaches surely
-        # exist.
-        f = moderatef(f)
-        constr[m_lcon:] = moderatec(constr[m_lcon:])
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        # With X not containing NaN, and with the moderated extreme barrier, F cannot
-        # be NaN/+Inf, and CONSTR cannot be NaN/-Inf.
-        assert not (np.isnan(f) or np.isposinf(f))
-        assert not any(np.isnan(constr) | np.isposinf(constr))
-
-    return f, constr

divi/exp/scipy/pyprima/common/history.py

@@ -1,39 +0,0 @@
-"""
-This module provides subroutines that handle the X/F/C histories of the solver, taking into
-account that MAXHIST may be smaller than NF.
-
-Translated from Zaikun Zhang's modern-Fortran reference implementation in PRIMA.
-
-Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
-
-Python translation by Nickolai Belakovski.
-"""
-
-
-def savehist(maxhist, x, xhist, f, fhist, cstrv, chist, constr, conhist):
-    """
-    Save the data values to the history lists.
-
-    The implementation of this function is vastly different from the Fortran implementation.
-    This is mostly due to the ease of creating and appending to lists in Python
-
-    However just like the Fortran version we should be concerned about both performance
-    and memory constraints. It will probably be better to initialize an array of NaN for
-    each of the histories and keep track of how many indices we have stored. Not needed for
-    the moment.
-    """
-    if len(xhist) < maxhist:
-        xhist.append(x)
-        fhist.append(f)
-        chist.append(cstrv)
-        conhist.append(constr)
-    else:
-        # This effectively accomplishes what rangehist does in the Fortran implementation
-        xhist.pop(0)
-        fhist.pop(0)
-        chist.pop(0)
-        conhist.pop(0)
-        xhist.append(x)
-        fhist.append(f)
-        chist.append(cstrv)
-        conhist.append(constr)

divi/exp/scipy/pyprima/common/infos.py

@@ -1,30 +0,0 @@
-"""
-This is a module defining exit flags.
-
-Translated from Zaikun Zhang's modern-Fortran reference implementation in PRIMA.
-
-Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
-
-Python translation by Nickolai Belakovski.
-"""
-
-INFO_DEFAULT = 0
-SMALL_TR_RADIUS = 0
-FTARGET_ACHIEVED = 1
-TRSUBP_FAILED = 2
-MAXFUN_REACHED = 3
-MAXTR_REACHED = 20
-NAN_INF_X = -1
-NAN_INF_F = -2
-NAN_INF_MODEL = -3
-NO_SPACE_BETWEEN_BOUNDS = 6
-DAMAGING_ROUNDING = 7
-ZERO_LINEAR_CONSTRAINT = 8
-CALLBACK_TERMINATE = 30
-
-# Stop-codes.
-# The following codes are used by ERROR STOP as stop-codes, which should be default integers.
-INVALID_INPUT = 100
-ASSERTION_FAILS = 101
-VALIDATION_FAILS = 102
-MEMORY_ALLOCATION_FAILS = 103