I thought about using np.vander when I wrote this, but decided against it.

You're talking about replacing two lines:

    order = np.arange(polyorder + 1).reshape(-1,1)
    A = x ** order

with one line, either:

    np.vander(x, polyorder + 1).T[::-1]

or

    polyvander(x, 3).T


The readability improvement is miniscule, and there is a performance cost:

    In [18]: def myvander(x, polyorder):
       ....:     order = np.arange(polyorder + 1).reshape(-1,1)
       ....:     A = x ** order
       ....:     return A
       ....: 
    
    In [19]: x = arange(-4,5)
    
    In [20]: myvander(x, 3)
    Out[20]: 
    array([[  1,   1,   1,   1,   1,   1,   1,   1,   1],
           [ -4,  -3,  -2,  -1,   0,   1,   2,   3,   4],
           [ 16,   9,   4,   1,   0,   1,   4,   9,  16],
           [-64, -27,  -8,  -1,   0,   1,   8,  27,  64]])
    
    In [21]: np.vander(x, 4).T[::-1]
    Out[21]: 
    array([[  1,   1,   1,   1,   1,   1,   1,   1,   1],
           [ -4,  -3,  -2,  -1,   0,   1,   2,   3,   4],
           [ 16,   9,   4,   1,   0,   1,   4,   9,  16],
           [-64, -27,  -8,  -1,   0,   1,   8,  27,  64]])
    
    In [22]: polyvander(x,3).T
    Out[22]: 
    array([[  1.,   1.,   1.,   1.,   1.,   1.,   1.,   1.,   1.],
           [ -4.,  -3.,  -2.,  -1.,   0.,   1.,   2.,   3.,   4.],
           [ 16.,   9.,   4.,   1.,   0.,   1.,   4.,   9.,  16.],
           [-64., -27.,  -8.,  -1.,   0.,   1.,   8.,  27.,  64.]])
    
    In [23]: %timeit myvander(x, 3)
    100000 loops, best of 3: 14.7 us per loop
    
    In [24]: %timeit np.vander(x, 4).T[::-1]
    10000 loops, best of 3: 35.3 us per loop
    
    In [25]: %timeit polyvander(x,3).T
    10000 loops, best of 3: 40.5 us per loop
    

The performance in this part of the code is probably not critical, so a significant improvement in readability would be worth it, but in this case, I don't think replacing two lines with one improves readability signficantly.  Anyone familiar with numpy broadcasting will most likely understand, even without comments, that `A = x ** order` is a Vandermonde matrix.

Having said that, if y'all still think the change is worth it, I'll do it.