加快Python中简单多项式表达式的求值速度

Question

I've written a rather large Python program to do some analysis of data given in the form of a list of cubic Bezier splines. It's very slow and, much to my surprise, after profiling I found that most of the time is spent in the following quite simple function.

    def point(P0,P1,P2,P3,t):
        return ((1-t)**3 * P0) + \
               (3 * (1-t)**2 * t * P1) + \
               (3 * (1-t) * t**2 * P2) + \
               (t**3 * P3)

where t is a float and P0, P1, P2, and P3 are complex numbers.

Attempting to decrease the number of times this function is executed would, I worry, cause me a lot of headache and might reduce accuracy of my results, so before I try that I'm wondering if anyone knows of a simple way to speed this up.

I've heard I might be able to compile this as a C/C++ function that could be called from my python code, but I've never done something like that (and it's been a long time since I used C/C++ for anything) so I wanted to get an expert opinion before spending time diving into anything like that.

Also, to be thorough, the above function is really a method of the Path class in a module called svg.path. Its exact syntax is as follows.

    def point(self, pos):
        """Calculate the x,y position at a certain position of the path"""
        return ((1-pos) ** 3 * self.start) + \
               (3 * (1-pos) ** 2 * pos * self.control1) + \
               (3 * (1-pos) * pos ** 2 * self.control2) + \
               (pos ** 3 * self.end)

Answer 1

If you replace ** by * and factor the polynomial like:

def point(P0, P1, P2, P3, t):
    return P0 + \ 
        t * (3 * (P1 - P0) + \
        t * (3 * (P0 + P2) - 6 * P1 + \
        t * (-P0 + 3 * (P1 - P2) + P3)))

You gain nearly a factor 2 in performance.