""" A sub-package for efficiently dealing with polynomials. Within the documentation for this sub-package, a "finite power series," i.e., a polynomial (also referred to simply as a "series") is represented by a 1-D numpy array of the polynomial's coefficients, ordered from lowest order term to highest. For example, array([1,2,3]) represents ``P_0 + 2*P_1 + 3*P_2``, where P_n is the n-th order basis polynomial applicable to the specific module in question, e.g., `polynomial` (which "wraps" the "standard" basis) or `chebyshev`. For optimal performance, all operations on polynomials, including evaluation at an argument, are implemented as operations on the coefficients. Additional (module-specific) information can be found in the docstring for the module of interest. This package provides *convenience classes* for each of six different kinds of polynomials: ======================== ================ **Name** **Provides** ======================== ================ `~polynomial.Polynomial` Power series `~chebyshev.Chebyshev` Chebyshev series `~legendre.Legendre` Legendre series `~laguerre.Laguerre` Laguerre series `~hermite.Hermite` Hermite series `~hermite_e.HermiteE` HermiteE series ======================== ================ These *convenience classes* provide a consistent interface for creating, manipulating, and fitting data with polynomials of different bases. The convenience classes are the preferred interface for the `~numpy.polynomial` package, and are available from the ``numpy.polynomial`` namespace. This eliminates the need to navigate to the corresponding submodules, e.g. ``np.polynomial.Polynomial`` or ``np.polynomial.Chebyshev`` instead of ``np.polynomial.polynomial.Polynomial`` or ``np.polynomial.chebyshev.Chebyshev``, respectively. The classes provide a more consistent and concise interface than the type-specific functions defined in the submodules for each type of polynomial. For example, to fit a Chebyshev polynomial with degree ``1`` to data given by arrays ``xdata`` and ``ydata``, the `~chebyshev.Chebyshev.fit` class method:: >>> from numpy.polynomial import Chebyshev >>> c = Chebyshev.fit(xdata, ydata, deg=1) is preferred over the `chebyshev.chebfit` function from the ``np.polynomial.chebyshev`` module:: >>> from numpy.polynomial.chebyshev import chebfit >>> c = chebfit(xdata, ydata, deg=1) See :doc:`routines.polynomials.classes` for more details. Convenience Classes =================== The following lists the various constants and methods common to all of the classes representing the various kinds of polynomials. In the following, the term ``Poly`` represents any one of the convenience classes (e.g. `~polynomial.Polynomial`, `~chebyshev.Chebyshev`, `~hermite.Hermite`, etc.) while the lowercase ``p`` represents an **instance** of a polynomial class. Constants --------- - ``Poly.domain`` -- Default domain - ``Poly.window`` -- Default window - ``Poly.basis_name`` -- String used to represent the basis - ``Poly.maxpower`` -- Maximum value ``n`` such that ``p**n`` is allowed - ``Poly.nickname`` -- String used in printing Creation -------- Methods for creating polynomial instances. - ``Poly.basis(degree)`` -- Basis polynomial of given degree - ``Poly.identity()`` -- ``p`` where ``p(x) = x`` for all ``x`` - ``Poly.fit(x, y, deg)`` -- ``p`` of degree ``deg`` with coefficients determined by the least-squares fit to the data ``x``, ``y`` - ``Poly.fromroots(roots)`` -- ``p`` with specified roots - ``p.copy()`` -- Create a copy of ``p`` Conversion ---------- Methods for converting a polynomial instance of one kind to another. - ``p.cast(Poly)`` -- Convert ``p`` to instance of kind ``Poly`` - ``p.convert(Poly)`` -- Convert ``p`` to instance of kind ``Poly`` or map between ``domain`` and ``window`` Calculus -------- - ``p.deriv()`` -- Take the derivative of ``p`` - ``p.integ()`` -- Integrate ``p`` Validation ---------- - ``Poly.has_samecoef(p1, p2)`` -- Check if coefficients match - ``Poly.has_samedomain(p1, p2)`` -- Check if domains match - ``Poly.has_sametype(p1, p2)`` -- Check if types match - ``Poly.has_samewindow(p1, p2)`` -- Check if windows match Misc ---- - ``p.linspace()`` -- Return ``x, p(x)`` at equally-spaced points in ``domain`` - ``p.mapparms()`` -- Return the parameters for the linear mapping between ``domain`` and ``window``. - ``p.roots()`` -- Return the roots of `p`. - ``p.trim()`` -- Remove trailing coefficients. - ``p.cutdeg(degree)`` -- Truncate p to given degree - ``p.truncate(size)`` -- Truncate p to given size """ from .polynomial import Polynomial from .chebyshev import Chebyshev from .legendre import Legendre from .hermite import Hermite from .hermite_e import HermiteE from .laguerre import Laguerre __all__ = [ "set_default_printstyle", "polynomial", "Polynomial", "chebyshev", "Chebyshev", "legendre", "Legendre", "hermite", "Hermite", "hermite_e", "HermiteE", "laguerre", "Laguerre", ] def set_default_printstyle(style): """ Set the default format for the string representation of polynomials. Values for ``style`` must be valid inputs to ``__format__``, i.e. 'ascii' or 'unicode'. Parameters ---------- style : str Format string for default printing style. Must be either 'ascii' or 'unicode'. Notes ----- The default format depends on the platform: 'unicode' is used on Unix-based systems and 'ascii' on Windows. This determination is based on default font support for the unicode superscript and subscript ranges. Examples -------- >>> p = np.polynomial.Polynomial([1, 2, 3]) >>> c = np.polynomial.Chebyshev([1, 2, 3]) >>> np.polynomial.set_default_printstyle('unicode') >>> print(p) 1.0 + 2.0·x + 3.0·x² >>> print(c) 1.0 + 2.0·T₁(x) + 3.0·T₂(x) >>> np.polynomial.set_default_printstyle('ascii') >>> print(p) 1.0 + 2.0 x + 3.0 x**2 >>> print(c) 1.0 + 2.0 T_1(x) + 3.0 T_2(x) >>> # Formatting supersedes all class/package-level defaults >>> print(f"{p:unicode}") 1.0 + 2.0·x + 3.0·x² """ if style not in ('unicode', 'ascii'): raise ValueError( f"Unsupported format string '{style}'. Valid options are 'ascii' " f"and 'unicode'" ) _use_unicode = True if style == 'ascii': _use_unicode = False from ._polybase import ABCPolyBase ABCPolyBase._use_unicode = _use_unicode from numpy._pytesttester import PytestTester test = PytestTester(__name__) del PytestTester