scipy 1.16.2__cp311-cp311-win_arm64.whl

scipy/_lib/pyprima/cobyla/update.py

@@ -0,0 +1,289 @@
+'''
+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.
+'''
+
+from ..common.consts import DEBUGGING
+from ..common.infos import DAMAGING_ROUNDING, INFO_DEFAULT
+from ..common.linalg import isinv, matprod, outprod, inprod, inv, primasum
+import numpy as np
+
+
+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

scipy/_lib/pyprima/common/_bounds.py

@@ -0,0 +1,34 @@
+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

scipy/_lib/pyprima/common/_linear_constraints.py

@@ -0,0 +1,46 @@
+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

scipy/_lib/pyprima/common/_nonlinear_constraints.py

@@ -0,0 +1,54 @@
+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

scipy/_lib/pyprima/common/_project.py

@@ -0,0 +1,173 @@
+'''
+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 ._linear_constraints import LinearConstraint
+from scipy.optimize import OptimizeResult
+
+# 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 minimize
+            from scipy.optimize import Bounds as ScipyBounds
+            from scipy.optimize import LinearConstraint as ScipyLinearConstraint
+
+            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)