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

divi/exp/scipy/pyprima/cobyla/update.py

@@ -1,331 +0,0 @@
-"""
-This module contains subroutines concerning the update of the interpolation set.
-
-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 ..common.consts import DEBUGGING
-from ..common.infos import DAMAGING_ROUNDING, INFO_DEFAULT
-from ..common.linalg import inprod, inv, isinv, matprod, outprod, primasum
-
-
-def updatexfc(jdrop, constr, cpen, cstrv, d, f, conmat, cval, fval, sim, simi):
-    """
-    This function revises the simplex by updating the elements of SIM, SIMI, FVAL, CONMAT, and CVAL
-    """
-
-    # Local variables
-    itol = 1
-
-    # Sizes
-    num_constraints = np.size(constr)
-    num_vars = np.size(sim, 0)
-
-    # Preconditions
-    if DEBUGGING:
-        assert num_constraints >= 0
-        assert num_vars >= 1
-        assert jdrop >= 0 and jdrop <= num_vars + 1
-        assert not any(np.isnan(constr) | np.isneginf(constr))
-        assert not (np.isnan(cstrv) | np.isposinf(cstrv))
-        assert np.size(d) == num_vars and all(np.isfinite(d))
-        assert not (np.isnan(f) | np.isposinf(f))
-        assert (
-            np.size(conmat, 0) == num_constraints and np.size(conmat, 1) == num_vars + 1
-        )
-        assert not (np.isnan(conmat) | np.isneginf(conmat)).any()
-        assert np.size(cval) == num_vars + 1 and not any(
-            cval < 0 | np.isnan(cval) | np.isposinf(cval)
-        )
-        assert np.size(fval) == num_vars + 1 and not any(
-            np.isnan(fval) | np.isposinf(fval)
-        )
-        assert np.size(sim, 0) == num_vars and np.size(sim, 1) == num_vars + 1
-        assert np.isfinite(sim).all()
-        assert all(primasum(abs(sim[:, :num_vars]), axis=0) > 0)
-        assert np.size(simi, 0) == num_vars and np.size(simi, 1) == num_vars
-        assert np.isfinite(simi).all()
-        assert isinv(sim[:, :num_vars], simi, itol)
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # Do nothing when JDROP is None. This can only happen after a trust-region step.
-    if jdrop is None:  # JDROP is None is impossible if the input is correct.
-        return conmat, cval, fval, sim, simi, INFO_DEFAULT
-
-    sim_old = sim
-    simi_old = simi
-    if jdrop < num_vars:
-        sim[:, jdrop] = d
-        simi_jdrop = simi[jdrop, :] / inprod(simi[jdrop, :], d)
-        simi -= outprod(matprod(simi, d), simi_jdrop)
-        simi[jdrop, :] = simi_jdrop
-    else:  # jdrop == num_vars
-        sim[:, num_vars] += d
-        sim[:, :num_vars] -= np.tile(d, (num_vars, 1)).T
-        simid = matprod(simi, d)
-        sum_simi = primasum(simi, axis=0)
-        simi += outprod(simid, sum_simi / (1 - sum(simid)))
-
-    # Check whether SIMI is a poor approximation to the inverse of SIM[:, :NUM_VARS]
-    # Calculate SIMI from scratch if the current one is damaged by rounding errors.
-    itol = 1
-    erri = np.max(
-        abs(matprod(simi, sim[:, :num_vars]) - np.eye(num_vars))
-    )  # np.max returns NaN if any input is NaN
-    if erri > 0.1 * itol or np.isnan(erri):
-        simi_test = inv(sim[:, :num_vars])
-        erri_test = np.max(
-            abs(matprod(simi_test, sim[:, :num_vars]) - np.eye(num_vars))
-        )
-        if erri_test < erri or (np.isnan(erri) and not np.isnan(erri_test)):
-            simi = simi_test
-            erri = erri_test
-
-    # If SIMI is satisfactory, then update FVAL, CONMAT, CVAL, and the pole position. Otherwise restore
-    # SIM and SIMI, and return with INFO = DAMAGING_ROUNDING.
-    if erri <= itol:
-        fval[jdrop] = f
-        conmat[:, jdrop] = constr
-        cval[jdrop] = cstrv
-        # Switch the best vertex to the pole position SIM[:, NUM_VARS] if it is not there already
-        conmat, cval, fval, sim, simi, info = updatepole(
-            cpen, conmat, cval, fval, sim, simi
-        )
-    else:
-        info = DAMAGING_ROUNDING
-        sim = sim_old
-        simi = simi_old
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert (
-            np.size(conmat, 0) == num_constraints and np.size(conmat, 1) == num_vars + 1
-        )
-        assert not (np.isnan(conmat) | np.isneginf(conmat)).any()
-        assert np.size(cval) == num_vars + 1 and not any(
-            cval < 0 | np.isnan(cval) | np.isposinf(cval)
-        )
-        assert np.size(fval) == num_vars + 1 and not any(
-            np.isnan(fval) | np.isposinf(fval)
-        )
-        assert np.size(sim, 0) == num_vars and np.size(sim, 1) == num_vars + 1
-        assert np.isfinite(sim).all()
-        assert all(primasum(abs(sim[:, :num_vars]), axis=0) > 0)
-        assert np.size(simi, 0) == num_vars and np.size(simi, 1) == num_vars
-        assert np.isfinite(simi).all()
-        assert isinv(sim[:, :num_vars], simi, itol) or info == DAMAGING_ROUNDING
-
-    return sim, simi, fval, conmat, cval, info
-
-
-def findpole(cpen, cval, fval):
-    """
-    This subroutine identifies the best vertex of the current simplex with respect to the merit
-    function PHI = F + CPEN * CSTRV.
-    """
-
-    # Size
-    num_vars = np.size(fval) - 1
-
-    # Preconditions
-    if DEBUGGING:
-        assert cpen > 0
-        assert np.size(cval) == num_vars + 1 and not any(
-            cval < 0 | np.isnan(cval) | np.isposinf(cval)
-        )
-        assert np.size(fval) == num_vars + 1 and not any(
-            np.isnan(fval) | np.isposinf(fval)
-        )
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # Identify the optimal vertex of the current simplex
-    jopt = np.size(fval) - 1
-    phi = fval + cpen * cval
-    phimin = min(phi)
-    # Essentially jopt = np.argmin(phi). However, we keep jopt = num_vars unless there
-    # is a strictly better choice. When there are multiple choices, we choose the jopt
-    # with the smallest value of cval.
-    if phimin < phi[jopt] or any((cval < cval[jopt]) & (phi <= phi[jopt])):
-        # While we could use argmin(phi), there may be two places where phi achieves
-        # phimin, and in that case we should choose the one with the smallest cval.
-        jopt = np.ma.array(cval, mask=(phi > phimin)).argmin()
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert jopt >= 0 and jopt < num_vars + 1
-        assert (
-            jopt == num_vars
-            or phi[jopt] < phi[num_vars]
-            or (phi[jopt] <= phi[num_vars] and cval[jopt] < cval[num_vars])
-        )
-    return jopt
-
-
-def updatepole(cpen, conmat, cval, fval, sim, simi):
-    # --------------------------------------------------------------------------------------------------!
-    # This subroutine identifies the best vertex of the current simplex with respect to the merit
-    # function PHI = F + CPEN * CSTRV, and then switch this vertex to SIM[:, NUM_VARS], which Powell called
-    # the "pole position" in his comments. CONMAT, CVAL, FVAL, and SIMI are updated accordingly.
-    #
-    # N.B. 1: In precise arithmetic, the following two procedures produce the same results:
-    # 1) apply UPDATEPOLE to SIM twice, first with CPEN = CPEN1 and then with CPEN = CPEN2;
-    # 2) apply UPDATEPOLE to SIM with CPEN = CPEN2.
-    # In finite-precision arithmetic, however, they may produce different results unless CPEN1 = CPEN2.
-    #
-    # N.B. 2: When JOPT == N+1, the best vertex is already at the pole position, so there is nothing to
-    # switch. However, as in Powell's code, the code below will check whether SIMI is good enough to
-    # work as the inverse of SIM(:, 1:N) or not. If not, Powell's code would invoke an error return of
-    # COBYLB; our implementation, however, will try calculating SIMI from scratch; if the recalculated
-    # SIMI is still of poor quality, then UPDATEPOLE will return with INFO = DAMAGING_ROUNDING,
-    # informing COBYLB that SIMI is poor due to damaging rounding errors.
-    #
-    # N.B. 3: UPDATEPOLE should be called when and only when FINDPOLE can potentially returns a value
-    # other than N+1. The value of FINDPOLE is determined by CPEN, CVAL, and FVAL, the latter two being
-    # decided by SIM. Thus UPDATEPOLE should be called after CPEN or SIM changes. COBYLA updates CPEN at
-    # only two places: the beginning of each trust-region iteration, and when REDRHO is called;
-    # SIM is updated only by UPDATEXFC, which itself calls UPDATEPOLE internally. Therefore, we only
-    # need to call UPDATEPOLE after updating CPEN at the beginning of each trust-region iteration and
-    # after each invocation of REDRHO.
-
-    # Local variables
-    itol = 1
-
-    # Sizes
-    num_constraints = conmat.shape[0]
-    num_vars = sim.shape[0]
-
-    # Preconditions
-    if DEBUGGING:
-        assert num_constraints >= 0
-        assert num_vars >= 1
-        assert cpen > 0
-        assert (
-            np.size(conmat, 0) == num_constraints and np.size(conmat, 1) == num_vars + 1
-        )
-        assert not (np.isnan(conmat) | np.isneginf(conmat)).any()
-        assert np.size(cval) == num_vars + 1 and not any(
-            cval < 0 | np.isnan(cval) | np.isposinf(cval)
-        )
-        assert np.size(fval) == num_vars + 1 and not any(
-            np.isnan(fval) | np.isposinf(fval)
-        )
-        assert np.size(sim, 0) == num_vars and np.size(sim, 1) == num_vars + 1
-        assert np.isfinite(sim).all()
-        assert all(primasum(abs(sim[:, :num_vars]), axis=0) > 0)
-        assert np.size(simi, 0) == num_vars and np.size(simi, 1) == num_vars
-        assert np.isfinite(simi).all()
-        assert isinv(sim[:, :num_vars], simi, itol)
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # INFO must be set, as it is an output.
-    info = INFO_DEFAULT
-
-    # Identify the optimal vertex of the current simplex.
-    jopt = findpole(cpen, cval, fval)
-
-    # Switch the best vertex to the pole position SIM[:, NUM_VARS] if it is not there already and update
-    # SIMI. Before the update, save a copy of SIM and SIMI. If the update is unsuccessful due to
-    # damaging rounding errors, we restore them and return with INFO = DAMAGING_ROUNDING.
-    sim_old = sim.copy()
-    simi_old = simi.copy()
-    if 0 <= jopt < num_vars:
-        # Unless there is a bug in FINDPOLE it is guaranteed that JOPT >= 0
-        # When JOPT == NUM_VARS, there is nothing to switch; in addition SIMI[JOPT, :] will be illegal.
-        # fval[[jopt, -1]] = fval[[-1, jopt]]
-        # conmat[:, [jopt, -1]] = conmat[:, [-1, jopt]] # Exchange CONMAT[:, JOPT] AND CONMAT[:, -1]
-        # cval[[jopt, -1]] = cval[[-1, jopt]]
-        sim[:, num_vars] += sim[:, jopt]
-        sim_jopt = sim[:, jopt].copy()
-        sim[:, jopt] = 0  # np.zeros(num_constraints)?
-        sim[:, :num_vars] -= np.tile(sim_jopt, (num_vars, 1)).T
-        # The above update is equivalent to multiplying SIM[:, :NUM_VARS] from the right side by a matrix whose
-        # JOPT-th row is [-1, -1, ..., -1], while all the other rows are the same as those of the
-        # identity matrix. It is easy to check that the inverse of this matrix is itself. Therefore,
-        # SIMI should be updated by a multiplication with this matrix (i.e. its inverse) from the left
-        # side, as is done in the following line. The JOPT-th row of the updated SIMI is minus the sum
-        # of all rows of the original SIMI, whereas all the other rows remain unchanged.
-        # NDB 20250114: In testing the cutest problem 'SYNTHES2' between the Python implementation and
-        # the Fortran bindings, I saw a difference between the following for loop and the
-        # np.sum command. The differences were small, on the order of 1e-16, i.e. epsilon.
-        # According to numpy documentation, np.sum sometimes uses partial pairwise summation,
-        # depending on the memory layout of the array and the axis specified.
-        # for i in range(simi.shape[1]):
-        #     simi[jopt, i] = -sum(simi[:, i])
-        simi[jopt, :] = -primasum(simi, axis=0)
-
-    # Check whether SIMI is a poor approximation to the inverse of SIM[:, :NUM_VARS]
-    # Calculate SIMI from scratch if the current one is damaged by rounding errors.
-    erri = np.max(
-        abs(matprod(simi, sim[:, :num_vars]) - np.eye(num_vars))
-    )  # np.max returns NaN if any input is NaN
-    itol = 1
-    if erri > 0.1 * itol or np.isnan(erri):
-        simi_test = inv(sim[:, :num_vars])
-        erri_test = np.max(
-            abs(matprod(simi_test, sim[:, :num_vars]) - np.eye(num_vars))
-        )
-        if erri_test < erri or (np.isnan(erri) and not np.isnan(erri_test)):
-            simi = simi_test
-            erri = erri_test
-
-    # If SIMI is satisfactory, then update FVAL, CONMAT, and CVAL. Otherwise restore SIM and SIMI, and
-    # return with INFO = DAMAGING_ROUNDING.
-    if erri <= itol:
-        if 0 <= jopt < num_vars:
-            fval[[jopt, num_vars]] = fval[[num_vars, jopt]]
-            conmat[:, [jopt, num_vars]] = conmat[:, [num_vars, jopt]]
-            cval[[jopt, num_vars]] = cval[[num_vars, jopt]]
-    else:  # erri > itol or erri is NaN
-        info = DAMAGING_ROUNDING
-        sim = sim_old
-        simi = simi_old
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert findpole(cpen, cval, fval) == num_vars or info == DAMAGING_ROUNDING
-        assert (
-            np.size(conmat, 0) == num_constraints and np.size(conmat, 1) == num_vars + 1
-        )
-        assert not (np.isnan(conmat) | np.isneginf(conmat)).any()
-        assert np.size(cval) == num_vars + 1 and not any(
-            cval < 0 | np.isnan(cval) | np.isposinf(cval)
-        )
-        assert np.size(fval) == num_vars + 1 and not any(
-            np.isnan(fval) | np.isposinf(fval)
-        )
-        assert np.size(sim, 0) == num_vars and np.size(sim, 1) == num_vars + 1
-        assert np.isfinite(sim).all()
-        assert all(primasum(abs(sim[:, :num_vars]), axis=0) > 0)
-        assert np.size(simi, 0) == num_vars and np.size(simi, 1) == num_vars
-        assert np.isfinite(simi).all()
-        # Do not check SIMI = SIM[:, :num_vars]^{-1}, as it may not be true due to damaging rounding.
-        assert isinv(sim[:, :num_vars], simi, itol) or info == DAMAGING_ROUNDING
-
-    return conmat, cval, fval, sim, simi, info

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

@@ -1,41 +0,0 @@
-import numpy as np
-from scipy.optimize import Bounds
-
-
-def process_bounds(bounds, lenx0):
-    """
-    `bounds` can either be an object with the properties lb and ub, or a list of tuples
-    indicating a lower bound and an upper bound for each variable. If the list contains
-    fewer entries than the length of x0, the remaining entries will generated as -/+ infinity.
-    Some examples of valid lists of tuple, assuming len(x0) == 3:
-    [(0, 1), (2, 3), (4, 5)] -> returns [0, 2, 4], [1, 3, 5]
-    [(0, 1), (None, 3)]      -> returns [0, -inf, -inf], [1, 3, inf]
-    [(0, 1), (-np.inf, 3)]   -> returns [0, -inf, -inf], [1, 3, inf]
-    """
-
-    if bounds is None:
-        lb = np.array([-np.inf] * lenx0, dtype=np.float64)
-        ub = np.array([np.inf] * lenx0, dtype=np.float64)
-        return lb, ub
-
-    if isinstance(bounds, Bounds):
-        lb = np.array(bounds.lb, dtype=np.float64)
-        ub = np.array(bounds.ub, dtype=np.float64)
-        lb = np.concatenate((lb, -np.inf * np.ones(lenx0 - len(lb))))
-        ub = np.concatenate((ub, np.inf * np.ones(lenx0 - len(ub))))
-        return lb, ub
-
-    # If neither of the above conditions are true, we assume that bounds is a list of tuples
-    lb = np.array(
-        [bound[0] if bound[0] is not None else -np.inf for bound in bounds],
-        dtype=np.float64,
-    )
-    ub = np.array(
-        [bound[1] if bound[1] is not None else np.inf for bound in bounds],
-        dtype=np.float64,
-    )
-    # If there were fewer bounds than variables, pad the rest with -/+ infinity
-    lb = np.concatenate((lb, -np.inf * np.ones(lenx0 - len(lb))))
-    ub = np.concatenate((ub, np.inf * np.ones(lenx0 - len(ub))))
-
-    return lb, ub

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

@@ -1,46 +0,0 @@
-import numpy as np
-from scipy.optimize import LinearConstraint
-
-
-def combine_multiple_linear_constraints(constraints):
-    full_A = constraints[0].A
-    full_lb = constraints[0].lb
-    full_ub = constraints[0].ub
-    for constraint in constraints[1:]:
-        full_A = np.concatenate((full_A, constraint.A), axis=0)
-        full_lb = np.concatenate((full_lb, constraint.lb), axis=0)
-        full_ub = np.concatenate((full_ub, constraint.ub), axis=0)
-    return LinearConstraint(full_A, full_lb, full_ub)
-
-
-def separate_LC_into_eq_and_ineq(linear_constraint):
-    # The Python interface receives linear constraints lb <= A*x <= ub, but the
-    # Fortran backend of PRIMA expects that the linear constraints are specified
-    # as A_eq*x = b_eq, A_ineq*x <= b_ineq.
-    # As such, we must:
-    # 1. for constraints with lb == ub, rewrite them as A_eq*x = lb;
-    # 2. for constraints with lb < ub, rewrite them as A_ineq*x <= b_ineq.
-
-    # We suppose lb == ub if ub <= lb + 2*epsilon, assuming that the preprocessing
-    # ensures lb <= ub.
-    epsilon = np.finfo(np.float64).eps
-
-    eq_indices = linear_constraint.ub <= (linear_constraint.lb + 2 * epsilon)
-    A_eq = linear_constraint.A[eq_indices]
-    b_eq = (linear_constraint.lb[eq_indices] + linear_constraint.ub[eq_indices]) / 2.0
-
-    ineq_lb_indices = linear_constraint.lb > -np.inf
-    A_ineq_lb = -linear_constraint.A[~eq_indices & ineq_lb_indices]
-    b_ineq_lb = -linear_constraint.lb[~eq_indices & ineq_lb_indices]
-    ineq_ub_indices = linear_constraint.ub < np.inf
-    A_ineq_ub = linear_constraint.A[~eq_indices & ineq_ub_indices]
-    b_ineq_ub = linear_constraint.ub[~eq_indices & ineq_ub_indices]
-    A_ineq = np.concatenate((A_ineq_lb, A_ineq_ub))
-    b_ineq = np.concatenate((b_ineq_lb, b_ineq_ub))
-
-    # Ensure dtype is float64, or set to None if empty
-    A_eq = np.array(A_eq, dtype=np.float64) if len(A_eq) > 0 else None
-    b_eq = np.array(b_eq, dtype=np.float64) if len(b_eq) > 0 else None
-    A_ineq = np.array(A_ineq, dtype=np.float64) if len(A_ineq) > 0 else None
-    b_ineq = np.array(b_ineq, dtype=np.float64) if len(b_ineq) > 0 else None
-    return A_eq, b_eq, A_ineq, b_ineq

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

@@ -1,64 +0,0 @@
-import numpy as np
-
-
-def transform_constraint_function(nlc):
-    """
-    The Python interfaces receives the constraints as lb <= constraint(x) <= ub,
-    but the Fortran backend expects the nonlinear constraints to be constraint(x) <= 0.
-    Thus a conversion is needed.
-
-    In addition to the conversion, we add a check to ensure that the provided lower/upper bounds
-    have a shape consistent with the output of the constraint function.
-    """
-
-    def newconstraint(x):
-        values = np.atleast_1d(np.array(nlc.fun(x), dtype=np.float64))
-
-        # Upgrade the lower/upper bounds to vectors if necessary
-        lb = nlc.lb
-        try:
-            _ = len(lb)
-        except TypeError:
-            lb = np.array([nlc.lb] * len(values), dtype=np.float64)
-
-        ub = nlc.ub
-        try:
-            _ = len(ub)
-        except TypeError:
-            ub = np.array([nlc.ub] * len(values), dtype=np.float64)
-
-        # Check the shapes and raise an exception if they do not match
-        if len(values) != len(lb):
-            raise ValueError(
-                "The number of elements in the constraint function's output does not match the number of elements in the lower bound."
-            )
-        if len(values) != len(ub):
-            raise ValueError(
-                "The number of elements in the constraint function's output does not match the number of elements in the upper bound."
-            )
-
-        # Combine the upper and lower bounds to transform the function into the form
-        # expected by the Fortran backend.
-        return np.concatenate(
-            (
-                [lb_ii - vi for lb_ii, vi in zip(lb, values) if lb_ii > -np.inf],
-                [vi - ub_ii for ub_ii, vi in zip(ub, values) if ub_ii < np.inf],
-            )
-        )
-
-    return newconstraint
-
-
-def process_nl_constraints(nlcs):
-    functions = []
-    for nlc in nlcs:
-        fun_i = transform_constraint_function(nlc)
-        functions.append(fun_i)
-
-    def constraint_function(x):
-        values = np.empty(0, dtype=np.float64)
-        for fun in functions:
-            values = np.concatenate((values, fun(x)))
-        return values
-
-    return constraint_function