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

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

@@ -1,393 +0,0 @@
-"""
-This is a module that preprocesses the inputs.
-
-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.
-"""
-
-from warnings import warn
-
-import numpy as np
-
-from .consts import (
-    CTOL_DEFAULT,
-    CWEIGHT_DEFAULT,
-    DEBUGGING,
-    EPS,
-    ETA1_DEFAULT,
-    ETA2_DEFAULT,
-    FTARGET_DEFAULT,
-    GAMMA1_DEFAULT,
-    GAMMA2_DEFAULT,
-    IPRINT_DEFAULT,
-    MAXFILT_DEFAULT,
-    MAXHISTMEM,
-    MIN_MAXFILT,
-    RHOBEG_DEFAULT,
-    RHOEND_DEFAULT,
-)
-from .present import present
-
-
-def preproc(
-    solver,
-    num_vars,
-    iprint,
-    maxfun,
-    maxhist,
-    ftarget,
-    rhobeg,
-    rhoend,
-    num_constraints=None,
-    npt=None,
-    maxfilt=None,
-    ctol=None,
-    cweight=None,
-    eta1=None,
-    eta2=None,
-    gamma1=None,
-    gamma2=None,
-    is_constrained=None,
-    has_rhobeg=None,
-    honour_x0=None,
-    xl=None,
-    xu=None,
-    x0=None,
-):
-    """
-    This subroutine preprocesses the inputs. It does nothing to the inputs that are valid.
-    """
-    # Preconditions
-    if DEBUGGING:
-        assert num_vars >= 1
-        if present(num_constraints):
-            assert num_constraints >= 0
-            assert num_constraints == 0 or solver.lower() == "cobyla"
-        if (
-            solver.lower() == "cobyla"
-            and present(num_constraints)
-            and present(is_constrained)
-        ):
-            assert num_constraints == 0 or is_constrained
-        if solver.lower() == "bobyqa":
-            assert present(xl) and present(xu)
-            assert all(xu - xl >= 2 * EPS)
-        if present(honour_x0):
-            assert (
-                solver.lower() == "bobyqa"
-                and present(has_rhobeg)
-                and present(xl)
-                and present(xu)
-                and present(x0)
-            )
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # Read num_constraints, if necessary
-    num_constraints = (
-        num_constraints
-        if (present(num_constraints) and solver.lower() == "cobyla")
-        else 0
-    )
-
-    # Decide whether the problem is truly constrained
-    is_constrained = (
-        is_constrained if (present(is_constrained)) else num_constraints > 0
-    )
-
-    # Validate IPRINT
-    if np.abs(iprint) > 3:
-        iprint = IPRINT_DEFAULT
-        warn(
-            f"{solver}: Invalid IPRINT; it should be 0, 1, -1, 2, -2, 3, or -3; it is set to {iprint}"
-        )
-
-    # Validate MAXFUN
-    if solver.lower() == "uobyqa":
-        min_maxfun = (num_vars + 1) * (num_vars + 2) / 2 + 1
-        min_maxfun_str = "(N+1)(N+2)/2 + 1"
-    elif solver.lower() == "cobyla":
-        min_maxfun = num_vars + 2
-        min_maxfun_str = "num_vars + 2"
-    else:  # CASE ('NEWUOA', 'BOBYQA', 'LINCOA')
-        min_maxfun = num_vars + 3
-        min_maxfun_str = "num_vars + 3"
-    if maxfun < min_maxfun:
-        maxfun = min_maxfun
-        warn(
-            f"{solver}: Invalid MAXFUN; it should be at least {min_maxfun_str}; it is set to {maxfun}"
-        )
-
-    # Validate MAXHIST
-    if maxhist < 0:
-        maxhist = maxfun
-        warn(
-            f"{solver}: Invalid MAXHIST; it should be a nonnegative integer; it is set to {maxhist}"
-        )
-    maxhist = min(maxhist, maxfun)  # MAXHIST > MAXFUN is never needed.
-
-    # Validate FTARGET
-    if np.isnan(ftarget):
-        ftarget = FTARGET_DEFAULT
-        warn(
-            f"{solver}: Invalid FTARGET; it should be a real number; it is set to {ftarget}"
-        )
-
-    # Validate NPT
-    if (
-        solver.lower() == "newuoa"
-        or solver.lower() == "bobyqa"
-        or solver.lower() == "lincoa"
-    ) and present(npt):
-        if npt < num_vars + 2 or npt > min(
-            maxfun - 1, ((num_vars + 2) * (num_vars + 1)) / 2
-        ):
-            npt = int(min(maxfun - 1, 2 * num_vars + 1))
-            warn(
-                f"{solver}: Invalid NPT; it should be an integer in the interval [N+2, (N+1)(N+2)/2] and less than MAXFUN; it is set to {npt}"
-            )
-
-    # Validate MAXFILT
-    if present(maxfilt) and (solver.lower() == "lincoa" or solver.lower() == "cobyla"):
-        maxfilt_in = maxfilt
-        if maxfilt < 1:
-            maxfilt = MAXFILT_DEFAULT  # The inputted MAXFILT is obviously wrong.
-        else:
-            maxfilt = max(MIN_MAXFILT, maxfilt)  # The inputted MAXFILT is too small.
-        # Further revise MAXFILT according to MAXHISTMEM.
-        if solver.lower() == "lincoa":
-            unit_memo = (num_vars + 2) * np.dtype(float).itemsize
-        elif solver.lower() == "cobyla":
-            unit_memo = (num_constraints + num_vars + 2) * np.dtype(float).itemsize
-        else:
-            unit_memo = 1
-        # We cannot simply set MAXFILT = MIN(MAXFILT, MAXHISTMEM/...), as they may not have
-        # the same kind, and compilers may complain. We may convert them, but overflow may occur.
-        if maxfilt > MAXHISTMEM / unit_memo:
-            maxfilt = int(MAXHISTMEM / unit_memo)  # Integer division.
-        maxfilt = min(maxfun, max(MIN_MAXFILT, maxfilt))
-        if is_constrained:
-            if maxfilt_in < 1:
-                warn(
-                    f"{solver}: Invalid MAXFILT; it should be a positive integer; it is set to  {maxfilt}"
-                )
-            elif maxfilt_in < min(maxfun, MIN_MAXFILT):
-                warn(f"{solver}: MAXFILT is too small; it is set to {maxfilt}")
-            elif maxfilt < min(maxfilt_in, maxfun):
-                warn(f"{solver}: MAXFILT is set to {maxfilt} due to memory limit")
-
-    # Validate ETA1 and ETA2
-    eta1_local = eta1 if present(eta1) else ETA1_DEFAULT
-    eta2_local = eta2 if present(eta2) else ETA2_DEFAULT
-
-    # When the difference between ETA1 and ETA2 is tiny, we force them to equal.
-    # See the explanation around RHOBEG and RHOEND for the reason.
-    if present(eta1) and present(eta2):
-        if np.abs(eta1 - eta2) < 1.0e2 * EPS * max(np.abs(eta1), 1):
-            eta2 = eta1
-
-    if present(eta1):
-        if np.isnan(eta1):
-            # In this case, we take the value hard coded in Powell's original code
-            # without any warning. It is useful when interfacing with MATLAB/Python.
-            eta1 = ETA1_DEFAULT
-        elif eta1 < 0 or eta1 >= 1:
-            # Take ETA2 into account if it has a valid value.
-            if present(eta2) and eta2_local > 0 and eta2_local <= 1:
-                eta1 = max(EPS, eta2 / 7.0)
-            else:
-                eta1 = ETA1_DEFAULT
-            warn(
-                f"{solver}: Invalid ETA1; it should be in the interval [0, 1) and not more than ETA2; it is set to {eta1}"
-            )
-
-    if present(eta2):
-        if np.isnan(eta2):
-            # In this case, we take the value hard coded in Powell's original code
-            # without any warning. It is useful when interfacing with MATLAB/Python.
-            eta2 = ETA2_DEFAULT
-        elif present(eta1) and (eta2 < eta1_local or eta2 > 1):
-            eta2 = (eta1 + 2) / 3.0
-            warn(
-                f"{solver}: Invalid ETA2; it should be in the interval [0, 1) and not less than ETA1; it is set to {eta2}"
-            )
-
-    # Validate GAMMA1 and GAMMA2
-    if present(gamma1):
-        if np.isnan(gamma1):
-            # In this case, we take the value hard coded in Powell's original code
-            # without any warning. It is useful when interfacing with MATLAB/Python.
-            gamma1 = GAMMA1_DEFAULT
-        elif gamma1 <= 0 or gamma1 >= 1:
-            gamma1 = GAMMA1_DEFAULT
-            warn(
-                f"{solver}: Invalid GAMMA1; it should in the interval (0, 1); it is set to {gamma1}"
-            )
-
-    if present(gamma2):
-        if np.isnan(gamma2):
-            # In this case, we take the value hard coded in Powell's original code
-            # without any warning. It is useful when interfacing with MATLAB/Python.
-            gamma2 = GAMMA2_DEFAULT
-        elif gamma2 < 1 or np.isinf(gamma2):
-            gamma2 = GAMMA2_DEFAULT
-            warn(
-                f"{solver}: Invalid GAMMA2; it should be a real number not less than 1; it is set to {gamma2}"
-            )
-
-    # Validate RHOBEG and RHOEND
-
-    if np.abs(rhobeg - rhoend) < 1.0e2 * EPS * np.maximum(np.abs(rhobeg), 1):
-        # When the data is passed from the interfaces (e.g., MEX) to the Fortran code, RHOBEG, and RHOEND
-        # may change a bit. It was observed in a MATLAB test that MEX passed 1 to Fortran as
-        # 0.99999999999999978. Therefore, if we set RHOEND = RHOBEG in the interfaces, then it may happen
-        # that RHOEND > RHOBEG, which is considered as an invalid input. To avoid this situation, we
-        # force RHOBEG and RHOEND to equal when the difference is tiny.
-        rhoend = rhobeg
-
-    # Revise the default values for RHOBEG/RHOEND according to the solver.
-    if solver.lower() == "bobyqa":
-        rhobeg_default = np.maximum(EPS, np.min(RHOBEG_DEFAULT, np.min(xu - xl) / 4.0))
-        rhoend_default = np.maximum(EPS, np.min(0.1 * rhobeg_default, RHOEND_DEFAULT))
-    else:
-        rhobeg_default = RHOBEG_DEFAULT
-        rhoend_default = RHOEND_DEFAULT
-
-    if solver.lower() == "bobyqa":
-        # Do NOT merge the IF below into the ELIF above! Otherwise, XU and XL may be accessed even if
-        # the solver is not BOBYQA, because the logical evaluation is not short-circuit.
-        if rhobeg > np.min(xu - xl) / 2:
-            # Do NOT make this revision if RHOBEG not positive or not finite, because otherwise RHOBEG
-            # will get a huge value when XU or XL contains huge values that indicate unbounded variables.
-            rhobeg = np.min(xu - xl) / 4.0  # Here, we do not take RHOBEG_DEFAULT.
-            warn(
-                f"{solver}: Invalid RHOBEG; {solver} requires 0 < RHOBEG <= np.min(XU-XL)/2; it is set to np.min(XU-XL)/4"
-            )
-    if rhobeg <= 0 or np.isnan(rhobeg) or np.isinf(rhobeg):
-        # Take RHOEND into account if it has a valid value. We do not do this if the solver is BOBYQA,
-        # which requires that RHOBEG <= (XU-XL)/2.
-        if np.isfinite(rhoend) and rhoend > 0 and solver.lower() != "bobyqa":
-            rhobeg = max(10 * rhoend, rhobeg_default)
-        else:
-            rhobeg = rhobeg_default
-        warn(
-            f"{solver}: Invalid RHOBEG; it should be a positive number; it is set to {rhobeg}"
-        )
-
-    if rhoend <= 0 or rhobeg < rhoend or np.isnan(rhoend) or np.isinf(rhoend):
-        rhoend = max(EPS, min(0.1 * rhobeg, rhoend_default))
-        warn(
-            f"{solver}: Invalid RHOEND; it should be a positive number and RHOEND <= RHOBEG; it is set to {rhoend}"
-        )
-
-    # For BOBYQA, revise X0 or RHOBEG so that the distance between X0 and the inactive bounds is at
-    # least RHOBEG. If HONOUR_X0 == TRUE, revise RHOBEG if needed; otherwise, revise HONOUR_X0 if needed.
-    if present(honour_x0):
-        if honour_x0:
-            rhobeg_old = rhobeg
-            lbx = np.isfinite(xl) & (
-                x0 - xl <= EPS * np.maximum(1, np.abs(xl))
-            )  # X0 essentially equals XL
-            ubx = np.isfinite(xu) & (
-                x0 - xu >= -EPS * np.maximum(1, np.abs(xu))
-            )  # X0 essentially equals XU
-            x0[lbx] = xl[lbx]
-            x0[ubx] = xu[ubx]
-            rhobeg = max(
-                EPS, np.min([rhobeg, x0[~lbx] - xl[~lbx], xu[~ubx] - x0[~ubx]])
-            )
-            if rhobeg_old - rhobeg > EPS * max(1, rhobeg_old):
-                rhoend = max(
-                    EPS, min(0.1 * rhobeg, rhoend)
-                )  # We do not revise RHOEND unless RHOBEG is truly revised.
-                if has_rhobeg:
-                    warn(
-                        f"{solver}: RHOBEG is revised to {rhobeg} and RHOEND to at most 0.1*RHOBEG so that the distance between X0 and the inactive bounds is at least RHOBEG"
-                    )
-            else:
-                rhoend = np.minimum(rhoend, rhobeg)  # This may update RHOEND slightly.
-        else:
-            x0_old = x0  # Recorded to see whether X0 is really revised.
-            # N.B.: The following revision is valid only if XL <= X0 <= XU and RHOBEG <= MINVAL(XU-XL)/2,
-            # which should hold at this point due to the revision of RHOBEG and moderation of X0.
-            # The cases below are mutually exclusive in precise arithmetic as MINVAL(XU-XL) >= 2*RHOBEG.
-            lbx = x0 <= xl + 0.5 * rhobeg
-            lbx_plus = (x0 > xl + 0.5 * rhobeg) & (x0 < xl + rhobeg)
-            ubx = x0 >= xu - 0.5 * rhobeg
-            ubx_minus = (x0 < xu - 0.5 * rhobeg) & (x0 > xu - rhobeg)
-            x0[lbx] = xl[lbx]
-            x0[lbx_plus] = xl[lbx_plus] + rhobeg
-            x0[ubx] = xu[ubx]
-            x0[ubx_minus] = xu[ubx_minus] - rhobeg
-
-            if any(np.abs(x0_old - x0) > 0):
-                warn(
-                    f"{solver}: X0 is revised so that the distance between X0 and the inactive bounds is at least RHOBEG set HONOUR_X0 to .TRUE. if you prefer to keep X0 unchanged"
-                )
-
-    # Validate CTOL (it can be 0)
-    if present(ctol):
-        if np.isnan(ctol) or ctol < 0:
-            ctol = CTOL_DEFAULT
-            if is_constrained:
-                warn(
-                    f"{solver}: Invalid CTOL; it should be a nonnegative number; it is set to {ctol}"
-                )
-
-    # Validate CWEIGHT (it can be +Inf)
-    if present(cweight):
-        if np.isnan(cweight) or cweight < 0:
-            cweight = CWEIGHT_DEFAULT
-            if is_constrained:
-                warn(
-                    f"{solver}: Invalid CWEIGHT; it should be a nonnegative number; it is set to {cweight}"
-                )
-
-    # ====================#
-    #  Calculation ends  #
-    # ====================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert abs(iprint) <= 3
-        assert maxhist >= 0 and maxhist <= maxfun
-        if present(npt):
-            assert maxfun >= npt + 1
-            assert npt >= 3
-        if present(maxfilt):
-            assert maxfilt >= np.minimum(MIN_MAXFILT, maxfun) and maxfilt <= maxfun
-        if present(eta1) and present(eta2):
-            assert eta1 >= 0 and eta1 <= eta2 and eta2 < 1
-        if present(gamma1) and present(gamma2):
-            assert gamma1 > 0 and gamma1 < 1 and gamma2 > 1
-        assert rhobeg >= rhoend and rhoend > 0
-        if solver.lower() == "bobyqa":
-            assert all(rhobeg <= (xu - xl) / 2)
-            assert all(np.isfinite(x0))
-            assert all(x0 >= xl and (x0 <= xl or x0 >= xl + rhobeg))
-            assert all(x0 <= xu and (x0 >= xu or x0 <= xu - rhobeg))
-        if present(ctol):
-            assert ctol >= 0
-
-    return (
-        iprint,
-        maxfun,
-        maxhist,
-        ftarget,
-        rhobeg,
-        rhoend,
-        npt,
-        maxfilt,
-        ctol,
-        cweight,
-        eta1,
-        eta2,
-        gamma1,
-        gamma2,
-        x0,
-    )

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

@@ -1,5 +0,0 @@
-def present(x):
-    """
-    This is a Python equivalent of the Fortran 'present' function for optional arguments.
-    """
-    return x is not None

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

@@ -1,56 +0,0 @@
-"""
-This module calculates the reduction ratio for trust-region methods.
-
-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 DEBUGGING, REALMAX
-
-
-def redrat(ared, pred, rshrink):
-    """
-    This function evaluates the reduction ratio of a trust-region step, handling inf/nan properly.
-    """
-
-    # Preconditions
-    if DEBUGGING:
-        assert rshrink >= 0
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    if np.isnan(ared):
-        # This should not happen in unconstrained problems due to the moderated extreme barrier.
-        ratio = -REALMAX
-    elif np.isnan(pred) or pred <= 0:
-        # The trust-region subproblem solver fails in this rare case. Instead of terminating as Powell's
-        # original code does, we set ratio as follows so that the solver may continue to progress.
-        if ared > 0:
-            # The trial point will be accepted, but the trust-region radius will be shrunk if rshrink>0
-            ratio = rshrink / 2
-        else:
-            # Set the ration to a large negative number to signify a bad trust-region step, so that the
-            # solver will check whether to take a geometry step or reduce rho.
-            ratio = -REALMAX
-    elif np.isposinf(pred) and np.isposinf(ared):
-        ratio = 1  # ared/pred = NaN if calculated directly
-    elif np.isposinf(pred) and np.isneginf(ared):
-        ratio = -REALMAX  # ared/pred = NaN if calculated directly
-    else:
-        ratio = ared / pred
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert not np.isnan(ratio)
-    return ratio

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

@@ -1,49 +0,0 @@
-"""
-This module provides a function that calculates RHO when it needs to be reduced.
-
-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 DEBUGGING
-
-
-def redrho(rho_in, rhoend):
-    """
-    This function calculates RHO when it needs to be reduced.
-    The scheme is shared by UOBYQA, NEWUOA, BOBYQA, LINCOA. For COBYLA, Powell's code reduces RHO by
-    'RHO *= 0.5; if RHO <= 1.5 * RHOEND: RHO = RHOEND' as specified in (11) of the COBYLA
-    paper. However, this scheme seems to work better, especially after we introduce DELTA.
-    """
-
-    # Preconditions
-    if DEBUGGING:
-        assert rho_in > rhoend > 0
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    rho_ratio = rho_in / rhoend
-
-    if rho_ratio > 250:
-        rho = 0.1 * rho_in
-    elif rho_ratio <= 16:
-        rho = rhoend
-    else:
-        rho = np.sqrt(rho_ratio) * rhoend  # rho = np.sqrt(rho * rhoend)
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert rho_in > rho >= rhoend
-
-    return rho