# [Numpy-discussion] numpy.polynomial.Polynomial

josef.pktd@gmai... josef.pktd@gmai...
Fri Oct 22 12:47:16 CDT 2010

```On Fri, Oct 22, 2010 at 12:26 PM, Charles R Harris
<charlesr.harris@gmail.com> wrote:
>
>
> On Fri, Oct 22, 2010 at 9:51 AM, <josef.pktd@gmail.com> wrote:
>>
>> I'm subclassing numpy.polynomial.Polynomial. So far it works well.
>>
>> One question on inplace changes
>>
>> Is it safe to change coef directly without creating a new instance?
>> I'm not trying to change anything else in the polynomial, just for
>> example pad, truncate or invert the coef inplace, e.g
>>
>> def pad(self, maxlag):
>>    self.coef = np.r_[self.coef, np.zeros(maxlag - len(self.coef))]
>>
>> Currently, I have rewritten this to return a new instance.
>>
>
> You can (currently) modify the coef and it should work, but I think it best
> to regard the Polynomial class as immutable. I'm even contemplating making
> the coef attribute read only just to avoid such things. Another tip is to
> use // instead of / for division, polynomials are rather like integers that
> way and don't have a true divide so plain old / will fail for python 3.x
>
> Note that most operations will trim trailing zeros off the result.
>
> In [6]: P((1,1,1,0,0,0))
> Out[6]: Polynomial([ 1.,  1.,  1.,  0.,  0.,  0.], [-1.,  1.])
>
> In [7]: P((1,1,1,0,0,0)) + 1
> Out[7]: Polynomial([ 2.,  1.,  1.], [-1.,  1.])
>
> The reason the constructor doesn't was because trailing zeros can be of
> interest in least squares fits. Is there a particular use case for which
> trailing zeros are important for you? The polynomial modules aren't finished
> products yet, I can still add some functionality if you think it useful.

I need "long" division, example was A(L)/B(L) for lag-polynomials as I
showed before.

My current version (unfinished since I got distracted by
stats.distribution problems):

from numpy import polynomial as npp

class LagPolynomial(npp.Polynomial):

#def __init__(self, maxlag):

def pad(self, maxlag):
return LagPolynomial(np.r_[self.coef, np.zeros(maxlag-len(self.coef))])

def padflip(self, maxlag):
return LagPolynomial(np.r_[self.coef,
np.zeros(maxlag-len(self.coef))][::-1])

def flip(self):
'''reverse polynomial coefficients
'''
return LagPolynomial(self.coef[::-1])

def div(self, other, maxlag=None):
'''padded division, pads numerator with zeros to maxlag
'''
if maxlag is None:
maxlag = max(len(self.coef), len(other.coef)) + 1
return (self.padflip(maxlag) / other.flip()).flip()

def filter(self, arr):
return (self * arr)  #trim to end

another method I haven't copied over yet is the adjusted fromroots
(normalized lag-polynomial from roots)

Essentially, I want to do get the AR and ARMA processes in several
different ways because I don't trust (my interpretation) of any single
implementation and eventually to see which one is fastest.

Josef

>
> Chuck
>
>
> _______________________________________________
> NumPy-Discussion mailing list
> NumPy-Discussion@scipy.org
> http://mail.scipy.org/mailman/listinfo/numpy-discussion
>
>
```

More information about the NumPy-Discussion mailing list