MAIN: Make output of Polynomial representations consistent

Author: eendebakpt

doc/release/upcoming_changes/21760.compatibility.rst

@@ -0,0 +1,6 @@
+Modified representation for ``Polynomial``
+------------------------------------------
+The representation method for `numpy.polynomial.Polynomial` was updated to include the domain in the representation.
+The plain text and latex representations are now consistent.
+For example the output of ``str(np.polynomial.Polynomial([1, 1], domain=[.1, .2]))`` used to be ``1.0 + 1.0 x``, but 
+now is ``1.0 + 1.0 (-3.0000000000000004 + 20.0 x)``.

numpy/polynomial/_polybase.py

@@ -9,6 +9,7 @@
 import os
 import abc
 import numbers
+from typing import Callable
 
 import numpy as np
 from . import polyutils as pu
@@ -367,6 +368,14 @@ def _generate_string(self, term_method):
         if linewidth < 1:
             linewidth = 1
         out = pu.format_float(self.coef[0])
+
+        off, scale = self.mapparms()
+
+        scaled_symbol, needs_parens = self._format_term(pu.format_float,
+                                                        off, scale)
+        if needs_parens:
+            scaled_symbol = '(' + scaled_symbol + ')'
+
         for i, coef in enumerate(self.coef[1:]):
             out += " "
             power = str(i + 1)
@@ -376,13 +385,13 @@ def _generate_string(self, term_method):
             # complex). In this case, represent the coefficient as-is.
             try:
                 if coef >= 0:
-                    next_term = f"+ " + pu.format_float(coef, parens=True)
+                    next_term = "+ " + pu.format_float(coef, parens=True)
                 else:
-                    next_term = f"- " + pu.format_float(-coef, parens=True)
+                    next_term = "- " + pu.format_float(-coef, parens=True)
             except TypeError:
                 next_term = f"+ {coef}"
             # Polynomial term
-            next_term += term_method(power, self.symbol)
+            next_term += term_method(power, scaled_symbol)
             # Length of the current line with next term added
             line_len = len(out.split('\n')[-1]) + len(next_term)
             # If not the last term in the polynomial, it will be two
@@ -437,24 +446,30 @@ def _repr_latex_scalar(x, parens=False):
         # exponents in this function
         return r'\text{{{}}}'.format(pu.format_float(x, parens=parens))
 
-    def _repr_latex_(self):
-        # get the scaled argument string to the basis functions
-        off, scale = self.mapparms()
+    def _format_term(self, scalar_format: Callable, off: float, scale: float):
+        """ Format a single term in the expansion """
         if off == 0 and scale == 1:
             term = self.symbol
             needs_parens = False
         elif scale == 1:
-            term = f"{self._repr_latex_scalar(off)} + {self.symbol}"
+            term = f"{scalar_format(off)} + {self.symbol}"
             needs_parens = True
         elif off == 0:
-            term = f"{self._repr_latex_scalar(scale)}{self.symbol}"
+            term = f"{scalar_format(scale)}{self.symbol}"
             needs_parens = True
         else:
             term = (
-                f"{self._repr_latex_scalar(off)} + "
-                f"{self._repr_latex_scalar(scale)}{self.symbol}"
+                f"{scalar_format(off)} + "
+                f"{scalar_format(scale)}{self.symbol}"
             )
             needs_parens = True
+        return term, needs_parens
+    
+    def _repr_latex_(self):
+        # get the scaled argument string to the basis functions
+        off, scale = self.mapparms()
+        term, needs_parens = self._format_term(self._repr_latex_scalar,
+                                               off, scale)
 
         mute = r"\color{{LightGray}}{{{}}}".format
 

numpy/polynomial/tests/test_printing.py

@@ -323,16 +323,27 @@ def test_symbol(poly, tgt):
     assert_equal(f"{p:unicode}", tgt)
 
 
-class TestRepr:
+class TestStr:
     def test_polynomial_str(self):
+        res = str(poly.Polynomial([0, 1]))
+        tgt = '0.0 + 1.0 x'
+        assert_equal(res, tgt)
+
+        res = str(poly.Polynomial([0, 1], domain=[0, 2]))
+        tgt = '0.0 + 1.0 (-1.0 + x)'
+        assert_equal(res, tgt)
+
+
+class TestRepr:
+    def test_polynomial_repr(self):
         res = repr(poly.Polynomial([0, 1]))
         tgt = (
             "Polynomial([0., 1.], domain=[-1,  1], window=[-1,  1], "
             "symbol='x')"
         )
         assert_equal(res, tgt)
 
-    def test_chebyshev_str(self):
+    def test_chebyshev_repr(self):
         res = repr(poly.Chebyshev([0, 1]))
         tgt = (
             "Chebyshev([0., 1.], domain=[-1,  1], window=[-1,  1], "