diff options
Diffstat (limited to 'numpy/polynomial')
| -rw-r--r-- | numpy/polynomial/polytemplate.py | 379 |
1 files changed, 250 insertions, 129 deletions
diff --git a/numpy/polynomial/polytemplate.py b/numpy/polynomial/polytemplate.py index 2106ad84e..657b48508 100644 --- a/numpy/polynomial/polytemplate.py +++ b/numpy/polynomial/polytemplate.py @@ -31,16 +31,22 @@ class $name(pu.PolyBase) : $name coefficients, in increasing order. For example, ``(1, 2, 3)`` implies ``P_0 + 2P_1 + 3P_2`` where the ``P_i`` are a graded polynomial basis. - domain : (2,) array_like + domain : (2,) array_like, optional Domain to use. The interval ``[domain[0], domain[1]]`` is mapped to - the interval ``$domain`` by shifting and scaling. + the interval ``[window[0], window[1]]`` by shifting and scaling. + The default value is $domain. + window : (2,) array_like, optional + Window, see ``domain`` for its use. The default value is $domain. + .. versionadded:: 1.6.0 Attributes ---------- coef : (N,) array $name coefficients, from low to high. - domain : (2,) array_like - Domain that is mapped to ``$domain``. + domain : (2,) array + Domain that is mapped to ``window``. + window : (2,) array + Window that ``domain`` is mapped to. Class Attributes ---------------- @@ -49,6 +55,8 @@ class $name(pu.PolyBase) : ``p(x)**n`` is allowed. This is to limit runaway polynomial size. domain : (2,) ndarray Default domain of the class. + window : (2,) ndarray + Default window of the class. Notes ----- @@ -65,25 +73,115 @@ class $name(pu.PolyBase) : maxpower = 16 # Default domain domain = np.array($domain) + # Default window + window = np.array($domain) # Don't let participate in array operations. Value doesn't matter. __array_priority__ = 0 - def __init__(self, coef, domain=$domain) : - [coef, domain] = pu.as_series([coef, domain], trim=False) - if len(domain) != 2 : + def has_samecoef(self, other): + """Check if coefficients match. + + Parameters + ---------- + other : class instance + The other class must have the ``coef`` attribute. + + Returns + ------- + bool : boolean + True if the coefficients are the same, False otherwise. + + Notes + ----- + .. versionadded:: 1.6.0 + + """ + if len(self.coef) != len(other.coef): + return False + elif not np.all(self.coef == other.coef): + return False + else: + return True + + def has_samedomain(self, other): + """Check if domains match. + + Parameters + ---------- + other : class instance + The other class must have the ``domain`` attribute. + + Returns + ------- + bool : boolean + True if the domains are the same, False otherwise. + + Notes + ----- + .. versionadded:: 1.6.0 + + """ + return np.all(self.domain == other.domain) + + def has_samewindow(self, other): + """Check if windows match. + + Parameters + ---------- + other : class instance + The other class must have the ``window`` attribute. + + Returns + ------- + bool : boolean + True if the windows are the same, False otherwise. + + Notes + ----- + .. versionadded:: 1.6.0 + + """ + return np.all(self.window == other.window) + + def has_samewindow(self, other): + """Check if windows match. + + Parameters + ---------- + other : class instance + The other class must have the ``window`` attribute. + + Returns + ------- + bool : boolean + True if the windows are the same, False otherwise. + + """ + return np.all(self.window == other.window) + + def __init__(self, coef, domain=$domain, window=$domain) : + [coef, dom, win] = pu.as_series([coef, domain, window], trim=False) + if len(dom) != 2 : raise ValueError("Domain has wrong number of elements.") + if len(win) != 2 : + raise ValueError("Window has wrong number of elements.") self.coef = coef - self.domain = domain + self.domain = dom + self.window = win def __repr__(self): - format = "%s(%s, %s)" + format = "%s(%s, %s, %s)" coef = repr(self.coef)[6:-1] domain = repr(self.domain)[6:-1] - return format % ('$name', coef, domain) + window = repr(self.domain)[6:-1] + return format % ('$name', coef, domain, window) def __str__(self) : - format = "%s(%s, %s)" - return format % ('$nick', str(self.coef), str(self.domain)) + format = "%s(%s, %s, %s)" + coef = str(self.coef)[6:-1] + domain = str(self.domain)[6:-1] + window = str(self.domain)[6:-1] + return format % ('$nick', coef, domain, window) # Pickle and copy @@ -91,6 +189,7 @@ class $name(pu.PolyBase) : ret = self.__dict__.copy() ret['coef'] = self.coef.copy() ret['domain'] = self.domain.copy() + ret['window'] = self.window.copy() return ret def __setstate__(self, dict) : @@ -99,11 +198,10 @@ class $name(pu.PolyBase) : # Call def __call__(self, arg) : - off, scl = pu.mapparms(self.domain, $domain) + off, scl = pu.mapparms(self.domain, self.window) arg = off + scl*arg return ${nick}val(arg, self.coef) - def __iter__(self) : return iter(self.coef) @@ -112,9 +210,8 @@ class $name(pu.PolyBase) : # Numeric properties. - def __neg__(self) : - return self.__class__(-self.coef, self.domain) + return self.__class__(-self.coef, self.domain, self.window) def __pos__(self) : return self @@ -122,7 +219,7 @@ class $name(pu.PolyBase) : def __add__(self, other) : """Returns sum""" if isinstance(other, self.__class__) : - if np.all(self.domain == other.domain) : + if self.has_samedomain(other) and self.has_samewindow(other): coef = ${nick}add(self.coef, other.coef) else : raise PolyDomainError() @@ -131,12 +228,12 @@ class $name(pu.PolyBase) : coef = ${nick}add(self.coef, other) except : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __sub__(self, other) : """Returns difference""" if isinstance(other, self.__class__) : - if np.all(self.domain == other.domain) : + if self.has_samedomain(other) and self.has_samewindow(other): coef = ${nick}sub(self.coef, other.coef) else : raise PolyDomainError() @@ -145,12 +242,12 @@ class $name(pu.PolyBase) : coef = ${nick}sub(self.coef, other) except : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __mul__(self, other) : """Returns product""" if isinstance(other, self.__class__) : - if np.all(self.domain == other.domain) : + if self.has_samedomain(other) and self.has_samewindow(other): coef = ${nick}mul(self.coef, other.coef) else : raise PolyDomainError() @@ -159,7 +256,7 @@ class $name(pu.PolyBase) : coef = ${nick}mul(self.coef, other) except : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __div__(self, other): # set to __floordiv__ /. @@ -175,10 +272,11 @@ class $name(pu.PolyBase) : else : return NotImplemented elif np.isscalar(other) : + # this might be overly restrictive coef = self.coef/other else : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __floordiv__(self, other) : """Returns the quotient.""" @@ -192,12 +290,12 @@ class $name(pu.PolyBase) : quo, rem = ${nick}div(self.coef, other) except : return NotImplemented - return self.__class__(quo, self.domain) + return self.__class__(quo, self.domain, self.window) def __mod__(self, other) : """Returns the remainder.""" if isinstance(other, self.__class__) : - if np.all(self.domain == other.domain) : + if self.has_samedomain(other) and self.has_samewindow(other): quo, rem = ${nick}div(self.coef, other.coef) else : raise PolyDomainError() @@ -206,12 +304,12 @@ class $name(pu.PolyBase) : quo, rem = ${nick}div(self.coef, other) except : return NotImplemented - return self.__class__(rem, self.domain) + return self.__class__(rem, self.domain, self.window) def __divmod__(self, other) : """Returns quo, remainder""" if isinstance(other, self.__class__) : - if np.all(self.domain == other.domain) : + if self.has_samedomain(other) and self.has_samewindow(other): quo, rem = ${nick}div(self.coef, other.coef) else : raise PolyDomainError() @@ -220,35 +318,37 @@ class $name(pu.PolyBase) : quo, rem = ${nick}div(self.coef, other) except : return NotImplemented - return self.__class__(quo, self.domain), self.__class__(rem, self.domain) + quo = self.__class__(quo, self.domain, self.window) + rem = self.__class__(rem, self.domain, self.window) + return quo, rem def __pow__(self, other) : try : coef = ${nick}pow(self.coef, other, maxpower = self.maxpower) except : raise - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __radd__(self, other) : try : coef = ${nick}add(other, self.coef) except : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __rsub__(self, other): try : coef = ${nick}sub(other, self.coef) except : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __rmul__(self, other) : try : coef = ${nick}mul(other, self.coef) except : return NotImplemented - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def __rdiv__(self, other): # set to __floordiv__ /. @@ -263,46 +363,62 @@ class $name(pu.PolyBase) : quo, rem = ${nick}div(other, self.coef[0]) except : return NotImplemented - return self.__class__(quo, self.domain) + return self.__class__(quo, self.domain, self.window) def __rfloordiv__(self, other) : try : quo, rem = ${nick}div(other, self.coef) except : return NotImplemented - return self.__class__(quo, self.domain) + return self.__class__(quo, self.domain, self.window) def __rmod__(self, other) : try : quo, rem = ${nick}div(other, self.coef) except : return NotImplemented - return self.__class__(rem, self.domain) + return self.__class__(rem, self.domain, self.window) def __rdivmod__(self, other) : try : quo, rem = ${nick}div(other, self.coef) except : return NotImplemented - return self.__class__(quo, self.domain), self.__class__(rem, self.domain) + quo = self.__class__(quo, self.domain, self.window) + rem = self.__class__(rem, self.domain, self.window) + return quo, rem # Enhance me # some augmented arithmetic operations could be added here def __eq__(self, other) : res = isinstance(other, self.__class__) \ - and len(self.coef) == len(other.coef) \ - and np.all(self.domain == other.domain) \ - and np.all(self.coef == other.coef) + and self.has_samecoef(other) \ + and self.has_samedomain(other) \ + and self.has_samewindow(other) return res def __ne__(self, other) : return not self.__eq__(other) # - # Extra numeric functions. + # Extra methods. # + def copy(self) : + """Return a copy. + + A new instance of $name is returned that has the same + coefficients and domain as the current instance. + + Returns + ------- + new_instance : $name + New instance of $name with the same coefficients and domain. + + """ + return self.__class__(self.coef, self.domain, self.window) + def degree(self) : """The degree of the series. @@ -340,68 +456,6 @@ class $name(pu.PolyBase) : """ return self.truncate(deg + 1) - def convert(self, domain=None, kind=None) : - """Convert to different class and/or domain. - - Parameters - ---------- - domain : array_like, optional - The domain of the new series type instance. If the value is None, - then the default domain of `kind` is used. - kind : class, optional - The polynomial series type class to which the current instance - should be converted. If kind is None, then the class of the - current instance is used. - - Returns - ------- - new_series_instance : `kind` - The returned class can be of different type than the current - instance and/or have a different domain. - - Notes - ----- - Conversion between domains and class types can result in - numerically ill defined series. - - Examples - -------- - - """ - if kind is None : - kind = $name - if domain is None : - domain = kind.domain - return self(kind.identity(domain)) - - def mapparms(self) : - """Return the mapping parameters. - - The returned values define a linear map ``off + scl*x`` that is - applied to the input arguments before the series is evaluated. The - of the map depend on the domain; if the current domain is equal to - the default domain ``$domain`` the resulting map is the identity. - If the coeffients of the ``$name`` instance are to be used - separately, then the linear function must be substituted for the - ``x`` in the standard representation of the base polynomials. - - Returns - ------- - off, scl : floats or complex - The mapping function is defined by ``off + scl*x``. - - Notes - ----- - If the current domain is the interval ``[l_1, r_1]`` and the default - interval is ``[l_2, r_2]``, then the linear mapping function ``L`` is - defined by the equations:: - - L(l_1) = l_2 - L(r_1) = r_2 - - """ - return pu.mapparms(self.domain, $domain) - def trim(self, tol=0) : """Remove small leading coefficients @@ -422,7 +476,8 @@ class $name(pu.PolyBase) : Contains the new set of coefficients. """ - return self.__class__(pu.trimcoef(self.coef, tol), self.domain) + coef = pu.trimcoef(self.coef, tol) + return self.__class__(coef, self.domain, self.window) def truncate(self, size) : """Truncate series to length `size`. @@ -448,23 +503,75 @@ class $name(pu.PolyBase) : if isize != size or isize < 1 : raise ValueError("size must be a positive integer") if isize >= len(self.coef) : - return self.__class__(self.coef, self.domain) + coef = self.coef else : - return self.__class__(self.coef[:isize], self.domain) + coef = self.coef[:isize] + return self.__class__(coef, self.domain, self.window) - def copy(self) : - """Return a copy. + def convert(self, domain=None, kind=None, window=None) : + """Convert to different class and/or domain. - A new instance of $name is returned that has the same - coefficients and domain as the current instance. + Parameters + ---------- + domain : array_like, optional + The domain of the new series type instance. If the value is None, + then the default domain of `kind` is used. + kind : class, optional + The polynomial series type class to which the current instance + should be converted. If kind is None, then the class of the + current instance is used. Returns ------- - new_instance : $name - New instance of $name with the same coefficients and domain. + new_series_instance : `kind` + The returned class can be of different type than the current + instance and/or have a different domain. + + Notes + ----- + Conversion between domains and class types can result in + numerically ill defined series. + + Examples + -------- + + """ + if kind is None: + kind = $name + if domain is None: + domain = kind.domain + if window is None: + window = kind.window + return self(kind.identity(domain, window=window)) + + def mapparms(self) : + """Return the mapping parameters. + + The returned values define a linear map ``off + scl*x`` that is + applied to the input arguments before the series is evaluated. The + map depends on the ``domain`` and ``window``; if the current + ``domain`` is equal to the ``window`` the resulting map is the + identity. If the coeffients of the ``$name`` instance are to be + used by themselves outside this class, then the linear function + must be substituted for the ``x`` in the standard representation of + the base polynomials. + + Returns + ------- + off, scl : floats or complex + The mapping function is defined by ``off + scl*x``. + + Notes + ----- + If the current domain is the interval ``[l_1, r_1]`` and the window + is ``[l_2, r_2]``, then the linear mapping function ``L`` is + defined by the equations:: + + L(l_1) = l_2 + L(r_1) = r_2 """ - return self.__class__(self.coef, self.domain) + return pu.mapparms(self.domain, self.window) def integ(self, m=1, k=[], lbnd=None) : """Integrate. @@ -501,7 +608,7 @@ class $name(pu.PolyBase) : else : lbnd = off + scl*lbnd coef = ${nick}int(self.coef, m, k, lbnd, 1./scl) - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def deriv(self, m=1): """Differentiate. @@ -527,7 +634,7 @@ class $name(pu.PolyBase) : """ off, scl = self.mapparms() coef = ${nick}der(self.coef, m, scl) - return self.__class__(coef, self.domain) + return self.__class__(coef, self.domain, self.window) def roots(self) : """Return list of roots. @@ -543,9 +650,9 @@ class $name(pu.PolyBase) : """ roots = ${nick}roots(self.coef) - return pu.mapdomain(roots, $domain, self.domain) + return pu.mapdomain(roots, self.window, self.domain) - def linspace(self, n=100): + def linspace(self, n=100, domain=None): """Return x,y values at equally spaced points in domain. Returns x, y values at `n` equally spaced points across domain. @@ -566,14 +673,17 @@ class $name(pu.PolyBase) : .. versionadded:: 1.5.0 """ - x = np.linspace(self.domain[0], self.domain[1], n) + if domain is None: + domain = self.domain + x = np.linspace(domain[0], domain[1], n) y = self(x) return x, y @staticmethod - def fit(x, y, deg, domain=None, rcond=None, full=False, w=None) : + def fit(x, y, deg, domain=None, rcond=None, full=False, w=None, + window=$domain): """Least squares fit to data. Return a `$name` instance that is the least squares fit to the data @@ -616,6 +726,10 @@ class $name(pu.PolyBase) : ``w[i]*y[i]`` all have the same variance. The default value is None. .. versionadded:: 1.5.0 + window : {[beg, end]}, optional + Window to use for the returned $name instance. The default + value is ``$domain`` + .. versionadded:: 1.6.0 Returns ------- @@ -634,21 +748,25 @@ class $name(pu.PolyBase) : ${nick}fit : similar function """ - if domain is None : + if domain is None: domain = pu.getdomain(x) - elif domain == [] : + elif domain == []: domain = $domain - xnew = pu.mapdomain(x, domain, $domain) + + if window == []: + window = $domain + + xnew = pu.mapdomain(x, domain, window) res = ${nick}fit(xnew, y, deg, w=w, rcond=rcond, full=full) if full : [coef, status] = res - return $name(coef, domain=domain), status + return $name(coef, domain=domain, window=window), status else : coef = res - return $name(coef, domain=domain) + return $name(coef, domain=domain, window=window) @staticmethod - def fromroots(roots, domain=$domain) : + def fromroots(roots, domain=$domain, window=$domain) : """Return $name object with specified roots. See ${nick}fromroots for full documentation. @@ -660,12 +778,12 @@ class $name(pu.PolyBase) : """ if domain is None : domain = pu.getdomain(roots) - rnew = pu.mapdomain(roots, domain, $domain) + rnew = pu.mapdomain(roots, domain, window) coef = ${nick}fromroots(rnew) - return $name(coef, domain=domain) + return $name(coef, domain=domain, window=window) @staticmethod - def identity(domain=$domain) : + def identity(domain=$domain, window=$domain) : """Identity function. If ``p`` is the returned $name object, then ``p(x) == x`` for all @@ -676,13 +794,16 @@ class $name(pu.PolyBase) : domain : array_like The resulting array must be if the form ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of the domain. + window : array_like + The resulting array must be if the form ``[beg, end]``, where + ``beg`` and ``end`` are the endpoints of the window. Returns ------- identity : $name object """ - off, scl = pu.mapparms($domain, domain) + off, scl = pu.mapparms(window, domain) coef = ${nick}line(off, scl) - return $name(coef, domain) + return $name(coef, domain, window) '''.replace('REL_IMPORT', rel_import)) |