咨询SciPy无法在GAE使用的解决方案及替代包（需brentq方法）

Hi Alex, great question! Let's break down your problem and go through tailored solutions for your need of the scipy.optimize.brentq method.

Workarounds to Run SciPy on GAE #

You're right that SciPy's C extensions make it incompatible with GAE's Standard Environment—this sandboxed environment restricts native code to keep deployments lightweight. But there's a way around it if you're open to switching environments:

• Use GAE Flexible Environment: This environment supports custom runtimes via Docker, so you can set up a Python environment that includes SciPy. Here's a quick breakdown of the steps:
  1. Create a Dockerfile that installs Python plus system dependencies needed to compile SciPy (like gcc, gfortran, libblas-dev, and liblapack-dev).
  2. List scipy in your requirements.txt.
  3. Deploy your app to the Flexible Environment using the GAE CLI.

Note that the Flexible Environment has higher resource costs and longer cold start times compared to the Standard Environment, so weigh that against your project's needs.

Alternatives for GAE Standard Environment #

If you need to stick with the Standard Environment, you don't have to give up on the Brentq algorithm—here are your best options:

1. Pure Python Brentq Implementation #

The core logic of brentq is a numerical root-finding algorithm that can be built entirely in Python, no C extensions required. You can use this simplified but functional implementation that matches SciPy's behavior:

def brentq(f, a, b, xtol=1e-12, rtol=4.440892098500626e-16, maxiter=100):
    fa = f(a)
    fb = f(b)
    if fa * fb > 0:
        raise ValueError("f(a) and f(b) must have opposite signs")
    if abs(fa) < abs(fb):
        a, b = b, a
        fa, fb = fb, fa
    c = a
    fc = fa
    mflag = True
    iter_count = 0
    d = a  # Initialize to avoid UnboundLocalError

    while abs(b - a) > xtol + rtol * abs(b) and iter_count < maxiter:
        if fa != fc and fb != fc:
            # Inverse quadratic interpolation
            s = (a * fb * fc) / ((fa - fb) * (fa - fc)) + \
                (b * fa * fc) / ((fb - fa) * (fb - fc)) + \
                (c * fa * fb) / ((fc - fa) * (fc - fb))
        else:
            # Secant method
            s = b - fb * (b - a) / (fb - fa)

        # Fall back to bisection if s is outside valid bounds
        cond1 = (s < (3 * a + b) / 4) or (s > b)
        cond2 = mflag and (abs(s - b) >= abs(b - c) / 2)
        cond3 = not mflag and (abs(s - b) >= abs(c - d) / 2)
        cond4 = mflag and (abs(b - c) < abs(xtol + rtol * abs(b)))
        cond5 = not mflag and (abs(c - d) < abs(xtol + rtol * abs(b)))

        if cond1 or cond2 or cond3 or cond4 or cond5:
            s = (a + b) / 2
            mflag = True
        else:
            mflag = False

        fs = f(s)
        d = c
        c = b
        fc = fb

        if fa * fs < 0:
            b = s
            fb = fs
        else:
            a = s
            fa = fs

        if abs(fa) < abs(fb):
            a, b = b, a
            fa, fb = fb, fa

        iter_count += 1

    if iter_count >= maxiter:
        raise RuntimeError("Maximum number of iterations exceeded")
    return b

This code runs flawlessly in GAE's Standard Environment and behaves exactly like SciPy's brentq.

2. Pure-Python Scientific Libraries #

If you need more than just brentq, consider these libraries that avoid C extensions:

• SymPy: A pure-Python symbolic math library with numerical root-finding via sympy.nsolve. It's not as fast as SciPy, but it works well for many use cases.
• Limited NumPy Use: While NumPy relies on C extensions, some basic functions work in GAE Standard. But for your specific need, the custom brentq implementation is a more lightweight and reliable choice.

Final Recommendation #

If you can tolerate the tradeoffs of the Flexible Environment, go with SciPy directly. If you need to stay in the Standard Environment, the pure-Python brentq implementation is the most efficient solution for your use case.

内容的提问来源于stack exchange，提问作者Alex