scipy 1.15.2__cp313-cp313t-macosx_14_0_arm64.whl → 1.16.0rc1__cp313-cp313t-macosx_14_0_arm64.whl

scipy/_lib/pyprima/common/message.py

@@ -0,0 +1,290 @@
+'''
+This module provides some functions that print messages to terminal/files.
+
+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.
+
+N.B.:
+1. In case parallelism is desirable (especially during initialization), the functions may
+have to be modified or disabled due to the IO operations.
+2. IPRINT indicates the level of verbosity, which increases with the absolute value of IPRINT.
+IPRINT = +/-3 can be expensive due to high IO operations.
+'''
+
+from .consts import DEBUGGING
+from .infos import FTARGET_ACHIEVED, MAXFUN_REACHED, MAXTR_REACHED, \
+    SMALL_TR_RADIUS, TRSUBP_FAILED, NAN_INF_F, NAN_INF_X, NAN_INF_MODEL, DAMAGING_ROUNDING, \
+    NO_SPACE_BETWEEN_BOUNDS, ZERO_LINEAR_CONSTRAINT, CALLBACK_TERMINATE
+from .present import present
+import numpy as np
+
+spaces = '   '
+
+
+def get_info_string(solver, info):
+    if info == FTARGET_ACHIEVED:
+        reason = 'the target function value is achieved.'
+    elif info == MAXFUN_REACHED:
+        reason = 'the objective function has been evaluated MAXFUN times.'
+    elif info == MAXTR_REACHED:
+        reason = 'the maximal number of trust region iterations has been reached.'
+    elif info == SMALL_TR_RADIUS:
+        reason = 'the trust region radius reaches its lower bound.'
+    elif info == TRSUBP_FAILED:
+        reason = 'a trust region step has failed to reduce the quadratic model.'
+    elif info == NAN_INF_X:
+        reason = 'NaN or Inf occurs in x.'
+    elif info == NAN_INF_F:
+        reason = 'the objective function returns NaN/+Inf.'
+    elif info == NAN_INF_MODEL:
+        reason = 'NaN or Inf occurs in the models.'
+    elif info == DAMAGING_ROUNDING:
+        reason = 'rounding errors are becoming damaging.'
+    elif info == NO_SPACE_BETWEEN_BOUNDS:
+        reason = 'there is no space between the lower and upper bounds of variable.'
+    elif info == ZERO_LINEAR_CONSTRAINT:
+        reason = 'one of the linear constraints has a zero gradient'
+    elif info == CALLBACK_TERMINATE:
+        reason = 'the callback function requested termination'
+    else:
+        reason = 'UNKNOWN EXIT FLAG'
+    ret_message = f'Return from {solver} because {reason.strip()}'
+    return ret_message
+
+
+def retmsg(solver, info, iprint, nf, f, x, cstrv=None, constr=None):
+    '''
+    This function prints messages at return.
+    '''
+    # Local variables
+    valid_exit_codes = [FTARGET_ACHIEVED, MAXFUN_REACHED, MAXTR_REACHED,
+        SMALL_TR_RADIUS, TRSUBP_FAILED, NAN_INF_F, NAN_INF_X, NAN_INF_MODEL, DAMAGING_ROUNDING,
+        NO_SPACE_BETWEEN_BOUNDS, ZERO_LINEAR_CONSTRAINT, CALLBACK_TERMINATE]
+
+    # Preconditions
+    if DEBUGGING:
+        assert info in valid_exit_codes
+
+    #====================#
+    # Calculation starts #
+    #====================#
+
+    if abs(iprint) < 1:  # No printing (iprint == 0)
+        return
+    elif iprint > 0:  # Print the message to the standard out.
+        fname = ''
+    else:  # Print the message to a file named FNAME.
+        fname = f'{solver}_output.txt'
+
+    # Decide whether the problem is truly constrained.
+    if present(constr):
+        is_constrained = (np.size(constr) > 0)
+    else:
+        is_constrained = present(cstrv)
+
+    # Decide the constraint violation.
+    if present(cstrv):
+        cstrv_loc = cstrv
+    elif present(constr):
+        cstrv_loc = np.max(np.append(0, -constr))  # N.B.: We assume that the constraint is CONSTR >= 0.
+    else:
+        cstrv_loc = 0
+
+    # Decide the return message.
+    ret_message = get_info_string(solver, info)
+
+    if np.size(x) <= 2:
+        x_message = f'\nThe corresponding X is: {x}'  # Printed in one line
+    else:
+        x_message = f'\nThe corresponding X is:\n{x}'
+
+    if is_constrained:
+        nf_message = (f'\nNumber of function values = {nf}{spaces}'
+            f'Least value of F = {f}{spaces}Constraint violation = {cstrv_loc}')
+    else:
+        nf_message = f'\nNumber of function values = {nf}{spaces}Least value of F = {f}'
+
+    if is_constrained and present(constr):
+        if np.size(constr) <= 2:
+            constr_message = f'\nThe constraint value is: {constr}'  # Printed in one line
+        else:
+            constr_message = f'\nThe constraint value is:\n{constr}'
+    else:
+        constr_message = ''
+
+    # Print the message.
+    if abs(iprint) >= 2:
+        message = f'\n{ret_message}{nf_message}{x_message}{constr_message}\n'
+    else:
+        message = f'{ret_message}{nf_message}{x_message}{constr_message}\n'
+    if len(fname) > 0:
+        with open(fname, 'a') as f: f.write(message)
+    else:
+        print(message)
+
+
+def rhomsg(solver, iprint, nf, delta, f, rho, x, cstrv=None, constr=None, cpen=None):
+    '''
+    This function prints messages when RHO is updated.
+    '''
+
+    #====================#
+    # Calculation starts #
+    #====================#
+
+    if abs(iprint) < 2:  # No printing
+        return
+    elif iprint > 0:  # Print the message to the standard out.
+        fname = ''
+    else:  # Print the message to a file named FNAME.
+        fname = f'{solver.strip()}_output.txt'
+
+    # Decide whether the problem is truly constrained.
+    if present(constr):
+        is_constrained = (np.size(constr) > 0)
+    else:
+        is_constrained = present(cstrv)
+
+    # Decide the constraint violation.
+    if present(cstrv):
+        cstrv_loc = cstrv
+    elif present(constr):
+        cstrv_loc = np.max(np.append(0, -constr))  # N.B.: We assume that the constraint is CONSTR >= 0.
+    else:
+        cstrv_loc = 0
+
+    if present(cpen):
+        rho_message = (f'\nNew RHO = {rho}{spaces}Delta = {delta}{spaces}'
+            f'CPEN = {cpen}')
+    else:
+        rho_message = f'\nNew RHO = {rho}{spaces}Delta = {delta}'
+
+    if np.size(x) <= 2:
+        x_message = f'\nThe corresponding X is: {x}'  # Printed in one line
+    else:
+        x_message = f'\nThe corresponding X is:\n{x}'
+
+    if is_constrained:
+        nf_message = (f'\nNumber of function values = {nf}{spaces}'
+            f'Least value of F = {f}{spaces}Constraint violation = {cstrv_loc}')
+    else:
+        nf_message = f'\nNumber of function values = {nf}{spaces}Least value of F = {f}'
+
+    if is_constrained and present(constr):
+        if np.size(constr) <= 2:
+            constr_message = f'\nThe constraint value is: {constr}'  # Printed in one line
+        else:
+            constr_message = f'\nThe constraint value is:\n{constr}'
+    else:
+        constr_message = ''
+
+    # Print the message.
+    if abs(iprint) >= 3:
+        message = f'\n{rho_message}{nf_message}{x_message}{constr_message}'
+    else:
+        message = f'{rho_message}{nf_message}{x_message}{constr_message}'
+    if len(fname) > 0:
+        with open(fname, 'a') as f: f.write(message)
+    else:
+        print(message)
+
+    #====================#
+    #  Calculation ends  #
+    #====================#
+
+
+def cpenmsg(solver, iprint, cpen):
+    '''
+    This function prints a message when CPEN is updated.
+    '''
+
+    #====================#
+    # Calculation starts #
+    #====================#
+
+    if abs(iprint) < 2:  # No printing
+        return
+    elif iprint > 0:  # Print the message to the standard out.
+        fname = ''
+    else:  # Print the message to a file named FNAME.
+        fname = f'{solver.strip()}_output.txt'
+
+    # Print the message.
+    if abs(iprint) >= 3:
+        message = f'\nSet CPEN to {cpen}'
+    else:
+        message = f'\n\nSet CPEN to {cpen}'
+    if len(fname) > 0:
+        with open(fname, 'a') as f: f.write(message)
+    else:
+        print(message)
+
+    #====================#
+    #  Calculation ends  #
+    #====================#
+
+
+def fmsg(solver, state, iprint, nf, delta, f, x, cstrv=None, constr=None):
+    '''
+    This subroutine prints messages for each evaluation of the objective function.
+    '''
+
+    #====================#
+    # Calculation starts #
+    #====================#
+
+    if abs(iprint) < 2:  # No printing
+        return
+    elif iprint > 0:  # Print the message to the standard out.
+        fname = ''
+    else:  # Print the message to a file named FNAME.
+        fname = f'{solver.strip()}_output.txt'
+
+    # Decide whether the problem is truly constrained.
+    if present(constr):
+        is_constrained = (np.size(constr) > 0)
+    else:
+        is_constrained = present(cstrv)
+
+    # Decide the constraint violation.
+    if present(cstrv):
+        cstrv_loc = cstrv
+    elif present(constr):
+        cstrv_loc = np.max(np.append(0, -constr))  # N.B.: We assume that the constraint is CONSTR >= 0.
+    else:
+        cstrv_loc = 0
+
+    delta_message = f'\n{state} step with radius = {delta}'
+
+    if is_constrained:
+        nf_message = (f'\nNumber of function values = {nf}{spaces}'
+            f'Least value of F = {f}{spaces}Constraint violation = {cstrv_loc}')
+    else:
+        nf_message = f'\nNumber of function values = {nf}{spaces}Least value of F = {f}'
+
+    if np.size(x) <= 2:
+        x_message = f'\nThe corresponding X is: {x}'  # Printed in one line
+    else:
+        x_message = f'\nThe corresponding X is:\n{x}'
+
+    if is_constrained and present(constr):
+        if np.size(constr) <= 2:
+            constr_message = f'\nThe constraint value is: {constr}'  # Printed in one line
+        else:
+            constr_message = f'\nThe constraint value is:\n{constr}'
+    else:
+        constr_message = ''
+
+    # Print the message.
+    message = f'{delta_message}{nf_message}{x_message}{constr_message}'
+    if len(fname) > 0:
+        with open(fname, 'a') as f: f.write(message)
+    else:
+        print(message)
+
+    #====================#
+    #  Calculation ends  #
+    #====================#

scipy/_lib/pyprima/common/powalg.py

@@ -0,0 +1,131 @@
+'''
+This module provides some Powell-style linear algebra procedures.
+
+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 .linalg import isminor, planerot, matprod, inprod, hypot
+from .consts import DEBUGGING, EPS
+
+
+def qradd_Rdiag(c, Q, Rdiag, n):
+    '''
+    This function updates the QR factorization of an MxN matrix A of full column rank, attempting to
+    add a new column C to this matrix as the LAST column while maintaining the full-rankness.
+    Case 1. If C is not in range(A) (theoretically, it implies N < M), then the new matrix is np.hstack([A, C])
+    Case 2. If C is in range(A), then the new matrix is np.hstack([A[:, :n-1], C])
+    N.B.:
+    0. Instead of R, this subroutine updates Rdiag, which is np.diag(R), with a size at most M and at
+    least min(m, n+1). The number is min(m, n+1) rather than min(m, n) as n may be augmented by 1 in
+    the function.
+    1. With the two cases specified as above, this function does not need A as an input.
+    2. The function changes only Q[:, nsave:m] (nsave is the original value of n) and
+    R[:, n-1] (n takes the updated value)
+    3. Indeed, when C is in range(A), Powell wrote in comments that "set iOUT to the index of the
+    constraint (here, column of A --- Zaikun) to be deleted, but branch if no suitable index can be
+    found". The idea is to replace a column of A by C so that the new matrix still has full rank
+    (such a column must exist unless C = 0). But his code essentially sets iout=n always. Maybe he
+    found this worked well enough in practice. Meanwhile, Powell's code includes a snippet that can
+    never be reached, which was probably intended to deal with the case that IOUT != n
+    '''
+    m = Q.shape[1]
+    nsave = n  # Needed for debugging (only)
+
+    # As in Powell's COBYLA, CQ is set to 0 at the positions with CQ being negligible as per ISMINOR.
+    # This may not be the best choice if the subroutine is used in other contexts, e.g. LINCOA.
+    cq = matprod(c, Q)
+    cqa = matprod(abs(c), abs(Q))
+    # The line below basically makes an element of cq 0 if adding it to the corresponding element of
+    # cqa does not change the latter.
+    cq = np.array([0 if isminor(cqi, cqai) else cqi for cqi, cqai in zip(cq, cqa)])
+
+    # Update Q so that the columns of Q[:, n+1:m] are orthogonal to C. This is done by applying a 2D
+    # Givens rotation to Q[:, [k, k+1]] from the right to zero C' @ Q[:, k+1] out for K=n+1, ... m-1.
+    # Nothing will be done if n >= m-1
+    for k in range(m-2, n-1, -1):
+        if abs(cq[k+1]) > 0:
+            # Powell wrote cq[k+1] != 0 instead of abs. The two differ if cq[k+1] is NaN.
+            # If we apply the rotation below when cq[k+1] = 0, then cq[k] will get updated to |cq[k]|.
+            G = planerot(cq[k:k+2])
+            Q[:, [k, k+1]] = matprod(Q[:, [k, k+1]], G.T)
+            cq[k] = hypot(*cq[k:k+2])
+
+    # Augment n by 1 if C is not in range(A)
+    if n < m:
+        # Powell's condition for the following if: cq[n+1] != 0
+        if abs(cq[n]) > EPS**2 and not isminor(cq[n], cqa[n]):
+            n += 1
+
+    # Update Rdiag so that Rdiag[n] = cq[n] = np.dot(c, q[:, n]). Note that N may be been augmented.
+    if n - 1 >= 0 and n - 1 < m:  # n >= m should not happen unless the input is wrong
+        Rdiag[n - 1] = cq[n - 1]
+
+    if DEBUGGING:
+        assert nsave <= n <= min(nsave + 1, m)
+        assert n <= len(Rdiag) <= m
+        assert Q.shape == (m, m)
+
+    return Q, Rdiag, n
+
+
+def qrexc_Rdiag(A, Q, Rdiag, i):  # Used in COBYLA
+    '''
+    This function updates the QR factorization for an MxN matrix A=Q@R so that the updated Q and
+    R form a QR factorization of [A_0, ..., A_{I-1}, A_{I+1}, ..., A_{N-1}, A_I] which is the matrix
+    obtained by rearranging columns [I, I+1, ... N-1] of A to [I+1, ..., N-1, I]. Here A is ASSUMED TO
+    BE OF FULL COLUMN RANK, Q is a matrix whose columns are orthogonal, and R, which is not present,
+    is an upper triangular matrix whose diagonal entries are nonzero. Q and R need not be square.
+    N.B.:
+    0. Instead of R, this function updates Rdiag, which is np.diag(R), the size being n.
+    1. With L = Q.shape[1] = R.shape[0], we have M >= L >= N. Most often L = M or N.
+    2. This function changes only Q[:, i:] and Rdiag[i:]
+    3. (NDB 20230919) In Python, i is either icon or nact - 2, whereas in FORTRAN it is either icon or nact - 1.
+    '''
+
+    # Sizes
+    m, n = A.shape
+
+    # Preconditions
+    assert n >= 1 and n <= m
+    assert i >= 0 and i < n
+    assert len(Rdiag) == n
+    assert Q.shape[0] == m and Q.shape[1] >= n and Q.shape[1] <= m
+    # tol = max(1.0E-8, min(1.0E-1, 1.0E8 * EPS * m + 1))
+    # assert isorth(Q, tol)  # Costly!
+
+
+    if i < 0 or i >= n:
+        return Q, Rdiag
+
+    # Let R be the upper triangular matrix in the QR factorization, namely R = Q.T@A.
+    # For each k, find the Givens rotation G with G@(R[k:k+2, :]) = [hypt, 0], and update Q[:, k:k+2]
+    # to Q[:, k:k+2]@(G.T). Then R = Q.T@A is an upper triangular matrix as long as A[:, [k, k+1]] is
+    # updated to A[:, [k+1, k]]. Indeed, this new upper triangular matrix can be obtained by first
+    # updating R[[k, k+1], :] to G@(R[[k, k+1], :]) and then exchanging its columns K and K+1; at the same
+    # time, entries k and k+1 of R's diagonal Rdiag become [hypt, -(Rdiag[k+1]/hypt)*RDiag[k]].
+    # After this is done for each k = 0, ..., n-2, we obtain the QR factorization of the matrix that
+    # rearranges columns [i, i+1, ... n-1] of A as [i+1, ..., n-1, i].
+    # Powell's code, however, is slightly different: before everything, he first exchanged columns k and
+    # k+1 of Q (as well as rows k and k+1 of R). This makes sure that the entries of the update Rdiag
+    # are all positive if it is the case for the original Rdiag.
+    for k in range(i, n-1):
+        G = planerot([Rdiag[k+1], inprod(Q[:, k], A[:, k+1])])
+        Q[:, [k, k+1]] = matprod(Q[:, [k+1, k]], (G.T))
+        # Powell's code updates Rdiag in the following way:
+        # hypt = np.sqrt(Rdiag[k+1]**2 + np.dot(Q[:, k], A[:, k+1])**2)
+        # Rdiag[[k, k+1]] = [hypt, (Rdiag[k+1]/hypt)*Rdiag[k]]
+        # Note that Rdiag[n-1] inherits all rounding in Rdiag[i:n-1] and Q[:, i:n-1] and hence contains
+        # significant errors. Thus we may modify Powell's code to set only Rdiag[k] = hypt here and then
+        # calculate Rdiag[n] by an inner product after the loop. Nevertheless, we simple calculate RDiag
+        # from scratch below.
+
+    # Calculate Rdiag(i:n) from scratch
+    Rdiag[i:n-1] = [inprod(Q[:, k], A[:, k+1]) for k in range(i, n-1)]
+    Rdiag[n-1] = inprod(Q[:, n-1], A[:, i])
+
+    return Q, Rdiag