use NumPy printoptions in LaTeX representations

Author: murrayrm

control/config.py

@@ -266,7 +266,7 @@ def use_legacy_defaults(version):
     Parameters
     ----------
     version : string
-        Version number of the defaults desired. Ranges from '0.1' to '0.8.4'.
+        Version number of the defaults desired. Ranges from '0.1' to '0.10.1'.
 
     Examples
     --------
@@ -279,26 +279,26 @@ def use_legacy_defaults(version):
     (major, minor, patch) = (None, None, None)  # default values
 
     # Early release tag format: REL-0.N
-    match = re.match("REL-0.([12])", version)
+    match = re.match(r"^REL-0.([12])$", version)
     if match: (major, minor, patch) = (0, int(match.group(1)), 0)
 
     # Early release tag format: control-0.Np
-    match = re.match("control-0.([3-6])([a-d])", version)
+    match = re.match(r"^control-0.([3-6])([a-d])$", version)
     if match: (major, minor, patch) = \
        (0, int(match.group(1)), ord(match.group(2)) - ord('a') + 1)
 
     # Early release tag format: v0.Np
-    match = re.match("[vV]?0.([3-6])([a-d])", version)
+    match = re.match(r"^[vV]?0\.([3-6])([a-d])$", version)
     if match: (major, minor, patch) = \
        (0, int(match.group(1)), ord(match.group(2)) - ord('a') + 1)
 
     # Abbreviated version format: vM.N or M.N
-    match = re.match("([vV]?[0-9]).([0-9])", version)
+    match = re.match(r"^[vV]?([0-9]*)\.([0-9]*)$", version)
     if match: (major, minor, patch) = \
        (int(match.group(1)), int(match.group(2)), 0)
 
     # Standard version format: vM.N.P or M.N.P
-    match = re.match("[vV]?([0-9]).([0-9]).([0-9])", version)
+    match = re.match(r"^[vV]?([0-9]*)\.([0-9]*)\.([0-9]*)$", version)
     if match: (major, minor, patch) = \
         (int(match.group(1)), int(match.group(2)), int(match.group(3)))
 
@@ -311,6 +311,10 @@ def use_legacy_defaults(version):
     #
     reset_defaults()            # start from a clean slate
 
+    # Verions 0.10.2
+    if major == 0 and minor <= 10 and patch < 2:
+        set_defaults('iosys', repr_format='loadable')
+
     # Version 0.9.2:
     if major == 0 and minor < 9 or (minor == 9 and patch < 2):
         from math import inf

control/statesp.py

@@ -13,15 +13,16 @@
 """
 
 import math
+import sys
 from collections.abc import Iterable
 from copy import deepcopy
 from warnings import warn
 
 import numpy as np
 import scipy as sp
 import scipy.linalg
-from numpy import any, asarray, concatenate, cos, delete, empty, exp, eye, \
-    isinf, ones, pad, sin, squeeze, zeros
+from numpy import any, array, asarray, concatenate, cos, delete, empty, \
+    exp, eye, isinf, ones, pad, sin, squeeze, zeros
 from numpy.linalg import LinAlgError, eigvals, matrix_rank, solve
 from numpy.random import rand, randn
 from scipy.signal import StateSpace as signalStateSpace
@@ -442,14 +443,18 @@ def _latex_partitioned_stateless(self):
         -------
         s : string with LaTeX representation of model
         """
+        # Apply NumPy formatting
+        with np.printoptions(threshold=sys.maxsize):
+            D = eval(repr(self.D))
+
         lines = [
             r'$$',
             (r'\left('
              + r'\begin{array}'
              + r'{' + 'rll' * self.ninputs + '}')
             ]
 
-        for Di in asarray(self.D):
+        for Di in asarray(D):
             lines.append('&'.join(_f2s(Dij) for Dij in Di)
                          + '\\\\')
 
@@ -474,19 +479,24 @@ def _latex_partitioned(self):
         if self.nstates == 0:
             return self._latex_partitioned_stateless()
 
+        # Apply NumPy formatting
+        with np.printoptions(threshold=sys.maxsize):
+            A, B, C, D = (
+                eval(repr(getattr(self, M))) for M in ['A', 'B', 'C', 'D'])
+
         lines = [
             r'$$',
             (r'\left('
              + r'\begin{array}'
              + r'{' + 'rll' * self.nstates + '|' + 'rll' * self.ninputs + '}')
             ]
 
-        for Ai, Bi in zip(asarray(self.A), asarray(self.B)):
+        for Ai, Bi in zip(asarray(A), asarray(B)):
             lines.append('&'.join([_f2s(Aij) for Aij in Ai]
                                   + [_f2s(Bij) for Bij in Bi])
                          + '\\\\')
         lines.append(r'\hline')
-        for Ci, Di in zip(asarray(self.C), asarray(self.D)):
+        for Ci, Di in zip(asarray(C), asarray(D)):
             lines.append('&'.join([_f2s(Cij) for Cij in Ci]
                                   + [_f2s(Dij) for Dij in Di])
                          + '\\\\')

control/tests/config_test.py

@@ -319,3 +319,16 @@ def test_system_indexing(self):
             indexed_system_name_suffix='POST')
         sys2 = sys[1:, 1:]
         assert sys2.name == 'PRE' + sys.name + 'POST'
+
+    def test_legacy_repr_format(self):
+        from ..statesp import StateSpace
+        from numpy import array
+
+        sys = ct.ss([[1]], [[1]], [[1]], [[0]])
+        with pytest.raises(SyntaxError, match="invalid syntax"):
+            new = eval(repr(sys))               # iosys is default
+
+        ct.use_legacy_defaults('0.10.1')        # loadable is default
+        new = eval(repr(sys))
+        for attr in ['A', 'B', 'C', 'D']:
+            assert getattr(sys, attr) == getattr(sys, attr)

control/tests/lti_test.py

@@ -1,15 +1,19 @@
 """lti_test.py"""
 
+import re
+
 import numpy as np
 import pytest
-from .conftest import editsdefaults
 
 import control as ct
-from control import c2d, tf, ss, tf2ss, NonlinearIOSystem
-from control.lti import LTI, evalfr, damp, dcgain, zeros, poles, bandwidth
-from control import common_timebase, isctime, isdtime, issiso
-from control.tests.conftest import slycotonly
+from control import NonlinearIOSystem, c2d, common_timebase, isctime, \
+    isdtime, issiso, ss, tf, tf2ss
 from control.exception import slycot_check
+from control.lti import LTI, bandwidth, damp, dcgain, evalfr, poles, zeros
+from control.tests.conftest import slycotonly
+
+from .conftest import editsdefaults
+
 
 class TestLTI:
     @pytest.mark.parametrize("fun, args", [
@@ -368,3 +372,41 @@ def test_scalar_algebra(op, fcn):
 
     scaled = getattr(sys, op)(2)
     np.testing.assert_almost_equal(getattr(sys(1j), op)(2), scaled(1j))
+
+
+@pytest.mark.parametrize(
+    "fcn, args, kwargs, suppress, " +
+    "repr_expected, str_expected, latex_expected", [
+    (ct.ss, (-1e-12, 1, 2, 3), {}, False,
+     r"StateSpace\([\s]*array\(\[\[-1.e-12\]\]\).*",
+     None,                      # standard Numpy formatting
+     r"10\^\{-12\}"),
+    (ct.ss, (-1e-12, 1, 3, 3), {}, True,
+     r"StateSpace\([\s]*array\(\[\[-0\.\]\]\).*",
+     None,                      # standard Numpy formatting
+     r"-0"),
+    (ct.tf, ([1, 1e-12, 1], [1, 2, 1]), {}, False,
+     r"\[1\.e\+00, 1\.e-12, 1.e\+00\]",
+     r"s\^2 \+ 1e-12 s \+ 1",
+     r"1 \\times 10\^\{-12\}"),
+    (ct.tf, ([1, 1e-12, 1], [1, 2, 1]), {}, True,
+     r"\[1\., 0., 1.\]",
+     r"s\^2 \+ 1",
+     r"\{s\^2 \+ 1\}"),
+])
+@pytest.mark.usefixtures("editsdefaults")
+def test_printoptions(
+        fcn, args, kwargs, suppress,
+        repr_expected, str_expected, latex_expected):
+    sys = fcn(*args, **kwargs)
+
+    with np.printoptions(suppress=suppress):
+        # Test loadable representation
+        assert re.search(repr_expected, sys.iosys_repr('loadable')) is not None
+
+        # Test string representation
+        if str_expected is not None:
+            assert re.search(str_expected, str(sys)) is not None
+
+        # Test LaTeX representation
+        assert re.search(latex_expected, sys._repr_latex_()) is not None

control/xferfcn.py

@@ -12,6 +12,7 @@
 
 """
 
+import sys
 from collections.abc import Iterable
 from copy import deepcopy
 from itertools import chain, product
@@ -1346,9 +1347,12 @@ def _c2d_matched(sysC, Ts, **kwargs):
 # Borrowed from poly1d library
 def _tf_polynomial_to_string(coeffs, var='s'):
     """Convert a transfer function polynomial to a string."""
-
     thestr = "0"
 
+    # Apply NumPy formatting
+    with np.printoptions(threshold=sys.maxsize):
+        coeffs = eval(repr(coeffs))
+
     # Compute the number of coefficients
     N = len(coeffs) - 1
 
@@ -1393,6 +1397,9 @@ def _tf_polynomial_to_string(coeffs, var='s'):
 
 def _tf_factorized_polynomial_to_string(roots, gain=1, var='s'):
     """Convert a factorized polynomial to a string."""
+    # Apply NumPy formatting
+    with np.printoptions(threshold=sys.maxsize):
+        roots = eval(repr(roots))
 
     if roots.size == 0:
         return _float2str(gain)