[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