"""Tests for the StateSpace class."""

@pytest.fixture

def sys322ABCD(self):

"""Matrices for sys322"""

A322 = [[-3., 4., 2.],

[-1., -3., 0.],

[2., 5., 3.]]

B322 = [[1., 4.],

[-3., -3.],

[-2., 1.]]

C322 = [[4., 2., -3.],

[1., 4., 3.]]

D322 = [[-2., 4.],

[0., 1.]]

return (A322, B322, C322, D322)

@pytest.fixture

def sys322(self, sys322ABCD):

"""3-states square system (2 inputs x 2 outputs)"""

return StateSpace(*sys322ABCD)

@pytest.fixture

def sys222(self):

"""2-states square system (2 inputs x 2 outputs)"""

A222 = [[4., 1.],

[2., -3]]

B222 = [[5., 2.],

[-3., -3.]]

C222 = [[2., -4],

[0., 1.]]

D222 = [[3., 2.],

[1., -1.]]

return StateSpace(A222, B222, C222, D222)

@pytest.fixture

def sys623(self):

"""sys3: 6 states non square system (2 inputs x 3 outputs)"""

A623 = np.array([[1, 0, 0, 0, 0, 0],

[0, 1, 0, 0, 0, 0],

[0, 0, 3, 0, 0, 0],

[0, 0, 0, -4, 0, 0],

[0, 0, 0, 0, -1, 0],

[0, 0, 0, 0, 0, 3]])

B623 = np.array([[0, -1],

[-1, 0],

[1, -1],

[0, 0],

[0, 1],

[-1, -1]])

C623 = np.array([[1, 0, 0, 1, 0, 0],

[0, 1, 0, 1, 0, 1],

[0, 0, 1, 0, 0, 1]])

D623 = np.zeros((3, 2))

return StateSpace(A623, B623, C623, D623)

@pytest.mark.parametrize(

@pytest.mark.parametrize(

def test_constructor(self, sys322ABCD, dt, argfun):

"""Test different ways to call the StateSpace() constructor"""

args, kwargs = argfun(sys322ABCD + dt)

sys = StateSpace(*args, **kwargs)

dtref = defaults['control.default_dt'] if len(dt) == 0 else dt[0]

np.testing.assert_almost_equal(sys.A, sys322ABCD[0])

np.testing.assert_almost_equal(sys.B, sys322ABCD[1])

np.testing.assert_almost_equal(sys.C, sys322ABCD[2])

np.testing.assert_almost_equal(sys.D, sys322ABCD[3])

assert sys.dt == dtref

@pytest.mark.parametrize("args, exc, errmsg",

def test_constructor_invalid(self, args, exc, errmsg):

"""Test invalid input to StateSpace() constructor"""

with pytest.raises(exc, match=errmsg):

StateSpace(*args)

with pytest.raises(exc, match=errmsg):

ss(*args)

def test_copy_constructor(self):

"""Test the copy constructor"""

# Create a set of matrices for a simple linear system

A = np.array([[-1]])

B = np.array([[1]])

C = np.array([[1]])

D = np.array([[0]])

# Create the first linear system and a copy

linsys = StateSpace(A, B, C, D)

cpysys = StateSpace(linsys)

# Change the original A matrix

A[0, 0] = -2

np.testing.assert_array_equal(linsys.A, [[-1]]) # original value

np.testing.assert_array_equal(cpysys.A, [[-1]]) # original value

# Change the A matrix for the original system

linsys.A[0, 0] = -3

np.testing.assert_array_equal(cpysys.A, [[-1]]) # original value

def test_matlab_style_constructor(self):

"""Use (deprecated) matrix-style construction string"""

with pytest.deprecated_call():

sys = StateSpace("-1 1; 0 2", "0; 1", "1, 0", "0")

assert sys.A.shape == (2, 2)

assert sys.B.shape == (2, 1)

assert sys.C.shape == (1, 2)

assert sys.D.shape == (1, 1)

for X in [sys.A, sys.B, sys.C, sys.D]:

assert ismatarrayout(X)

def test_D_broadcast(self, sys623):

"""Test broadcast of D=0 to the right shape"""

# Giving D as a scalar 0 should broadcast to the right shape

sys = StateSpace(sys623.A, sys623.B, sys623.C, 0)

np.testing.assert_array_equal(sys623.D, sys.D)

# Giving D as a matrix of the wrong size should generate an error

with pytest.raises(ValueError):

sys = StateSpace(sys.A, sys.B, sys.C, np.array([[0]]))

# Make sure that empty systems still work

sys = StateSpace([], [], [], 1)

np.testing.assert_array_equal(sys.D, [[1]])

sys = StateSpace([], [], [], [[0]])

np.testing.assert_array_equal(sys.D, [[0]])

sys = StateSpace([], [], [], [0])

np.testing.assert_array_equal(sys.D, [[0]])

sys = StateSpace([], [], [], 0)

np.testing.assert_array_equal(sys.D, [[0]])

def test_pole(self, sys322):

"""Evaluate the poles of a MIMO system."""

p = np.sort(sys322.pole())

true_p = np.sort([3.34747678408874,

-3.17373839204437 + 1.47492908003839j,

-3.17373839204437 - 1.47492908003839j])

np.testing.assert_array_almost_equal(p, true_p)

def test_zero_empty(self):

"""Test to make sure zero() works with no zeros in system."""

sys = _convertToStateSpace(TransferFunction([1], [1, 2, 1]))

np.testing.assert_array_equal(sys.zero(), np.array([]))

@slycotonly

def test_zero_siso(self, sys222):

"""Evaluate the zeros of a SISO system."""

# extract only first input / first output system of sys222. This system is denoted sys111

# or tf111

tf111 = ss2tf(sys222)

sys111 = tf2ss(tf111[0, 0])

# compute zeros as root of the characteristic polynomial at the numerator of tf111

# this method is simple and assumed as valid in this test

true_z = np.sort(tf111[0, 0].zero())

# Compute the zeros through ab08nd, which is tested here

z = np.sort(sys111.zero())

np.testing.assert_almost_equal(true_z, z)

@slycotonly

def test_zero_mimo_sys322_square(self, sys322):

"""Evaluate the zeros of a square MIMO system."""

z = np.sort(sys322.zero())

true_z = np.sort([44.41465, -0.490252, -5.924398])

np.testing.assert_array_almost_equal(z, true_z)

@slycotonly

def test_zero_mimo_sys222_square(self, sys222):

"""Evaluate the zeros of a square MIMO system."""

z = np.sort(sys222.zero())

true_z = np.sort([-10.568501, 3.368501])

np.testing.assert_array_almost_equal(z, true_z)

@slycotonly

def test_zero_mimo_sys623_non_square(self, sys623):

"""Evaluate the zeros of a non square MIMO system."""

z = np.sort(sys623.zero())

true_z = np.sort([2., -1.])

np.testing.assert_array_almost_equal(z, true_z)

def test_add_ss(self, sys222, sys322):

"""Add two MIMO systems."""

A = [[-3., 4., 2., 0., 0.], [-1., -3., 0., 0., 0.],

[2., 5., 3., 0., 0.], [0., 0., 0., 4., 1.], [0., 0., 0., 2., -3.]]

B = [[1., 4.], [-3., -3.], [-2., 1.], [5., 2.], [-3., -3.]]

C = [[4., 2., -3., 2., -4.], [1., 4., 3., 0., 1.]]

D = [[1., 6.], [1., 0.]]

sys = sys322 + sys222

np.testing.assert_array_almost_equal(sys.A, A)

np.testing.assert_array_almost_equal(sys.B, B)

np.testing.assert_array_almost_equal(sys.C, C)

np.testing.assert_array_almost_equal(sys.D, D)

def test_subtract_ss(self, sys222, sys322):

"""Subtract two MIMO systems."""

A = [[-3., 4., 2., 0., 0.], [-1., -3., 0., 0., 0.],

[2., 5., 3., 0., 0.], [0., 0., 0., 4., 1.], [0., 0., 0., 2., -3.]]

B = [[1., 4.], [-3., -3.], [-2., 1.], [5., 2.], [-3., -3.]]

C = [[4., 2., -3., -2., 4.], [1., 4., 3., 0., -1.]]

D = [[-5., 2.], [-1., 2.]]

sys = sys322 - sys222

np.testing.assert_array_almost_equal(sys.A, A)

np.testing.assert_array_almost_equal(sys.B, B)

np.testing.assert_array_almost_equal(sys.C, C)

np.testing.assert_array_almost_equal(sys.D, D)

def test_multiply_ss(self, sys222, sys322):

"""Multiply two MIMO systems."""

A = [[4., 1., 0., 0., 0.], [2., -3., 0., 0., 0.], [2., 0., -3., 4., 2.],

[-6., 9., -1., -3., 0.], [-4., 9., 2., 5., 3.]]

B = [[5., 2.], [-3., -3.], [7., -2.], [-12., -3.], [-5., -5.]]

C = [[-4., 12., 4., 2., -3.], [0., 1., 1., 4., 3.]]

D = [[-2., -8.], [1., -1.]]

sys = sys322 * sys222

np.testing.assert_array_almost_equal(sys.A, A)

np.testing.assert_array_almost_equal(sys.B, B)

np.testing.assert_array_almost_equal(sys.C, C)

np.testing.assert_array_almost_equal(sys.D, D)

@pytest.mark.parametrize("omega, resp",

@pytest.mark.parametrize("dt", [None, 0, 1e-3])

def test_evalfr(self, dt, omega, resp):

"""Evaluate the frequency response at single frequencies"""

A = [[-2, 0.5], [0.5, -0.3]]

B = [[0.3, -1.3], [0.1, 0.]]

C = [[0., 0.1], [-0.3, -0.2]]

D = [[0., -0.8], [-0.3, 0.]]

sys = StateSpace(A, B, C, D)

if dt:

sys = sample_system(sys, dt)

s = np.exp(omega * 1j * dt)

else:

s = omega * 1j

# Correct version of the call

np.testing.assert_allclose(evalfr(sys, s), resp, atol=1e-3)

# Deprecated version of the call (should generate warning)

with pytest.deprecated_call():

np.testing.assert_allclose(sys.evalfr(omega), resp, atol=1e-3)

# call above nyquist frequency

if dt:

with pytest.warns(UserWarning):

np.testing.assert_allclose(sys._evalfr(omega + 2 * np.pi / dt),

resp,

atol=1e-3)

@slycotonly

def test_freq_resp(self):

"""Evaluate the frequency response at multiple frequencies."""

A = [[-2, 0.5], [0.5, -0.3]]

B = [[0.3, -1.3], [0.1, 0.]]

C = [[0., 0.1], [-0.3, -0.2]]

D = [[0., -0.8], [-0.3, 0.]]

sys = StateSpace(A, B, C, D)

true_mag = [[[0.0852992637230322, 0.00103596611395218],

[0.935374692849736, 0.799380720864549]],

[[0.55656854563842, 0.301542699860857],

[0.609178071542849, 0.0382108097985257]]]

true_phase = [[[-0.566195599644593, -1.68063565332582],

[3.0465958317514, 3.14141384339534]],

[[2.90457947657161, 3.10601268291914],

[-0.438157380501337, -1.40720969147217]]]

true_omega = [0.1, 10.]

mag, phase, omega = sys.freqresp(true_omega)

np.testing.assert_almost_equal(mag, true_mag)

np.testing.assert_almost_equal(phase, true_phase)

np.testing.assert_equal(omega, true_omega)

@pytest.mark.skip("is_static_gain is introduced in gh-431")

def test_is_static_gain(self):

A0 = np.zeros((2,2))

A1 = A0.copy()

A1[0,1] = 1.1

B0 = np.zeros((2,1))

B1 = B0.copy()

B1[0,0] = 1.3

C0 = A0

C1 = np.eye(2)

D0 = 0

D1 = np.ones((2,1))

assert StateSpace(A0, B0, C1, D1).is_static_gain()

# TODO: fix this once remove_useless_states is false by default

# should be False when remove_useless is false

# print(StateSpace(A1, B0, C1, D1).is_static_gain())

assert not StateSpace(A0, B1, C1, D1).is_static_gain()

assert not StateSpace(A1, B1, C1, D1).is_static_gain()

assert StateSpace(A0, B0, C0, D0).is_static_gain()

assert StateSpace(A0, B0, C0, D1).is_static_gain()

assert StateSpace(A0, B0, C1, D0).is_static_gain()

@slycotonly

def test_minreal(self):

"""Test a minreal model reduction."""

# A = [-2, 0.5, 0; 0.5, -0.3, 0; 0, 0, -0.1]

A = [[-2, 0.5, 0], [0.5, -0.3, 0], [0, 0, -0.1]]

# B = [0.3, -1.3; 0.1, 0; 1, 0]

B = [[0.3, -1.3], [0.1, 0.], [1.0, 0.0]]

# C = [0, 0.1, 0; -0.3, -0.2, 0]

C = [[0., 0.1, 0.0], [-0.3, -0.2, 0.0]]

# D = [0 -0.8; -0.3 0]

D = [[0., -0.8], [-0.3, 0.]]

# sys = ss(A, B, C, D)

sys = StateSpace(A, B, C, D)

sysr = sys.minreal()

assert sysr.states == 2

assert sysr.inputs == sys.inputs

assert sysr.outputs == sys.outputs

np.testing.assert_array_almost_equal(

eigvals(sysr.A), [-2.136154, -0.1638459])

def test_append_ss(self):

"""Test appending two state-space systems."""

A1 = [[-2, 0.5, 0], [0.5, -0.3, 0], [0, 0, -0.1]]

B1 = [[0.3, -1.3], [0.1, 0.], [1.0, 0.0]]

C1 = [[0., 0.1, 0.0], [-0.3, -0.2, 0.0]]

D1 = [[0., -0.8], [-0.3, 0.]]

A2 = [[-1.]]

B2 = [[1.2]]

C2 = [[0.5]]

D2 = [[0.4]]

A3 = [[-2, 0.5, 0, 0], [0.5, -0.3, 0, 0], [0, 0, -0.1, 0],

[0, 0, 0., -1.]]

B3 = [[0.3, -1.3, 0], [0.1, 0., 0], [1.0, 0.0, 0], [0., 0, 1.2]]

C3 = [[0., 0.1, 0.0, 0.0], [-0.3, -0.2, 0.0, 0.0], [0., 0., 0., 0.5]]

D3 = [[0., -0.8, 0.], [-0.3, 0., 0.], [0., 0., 0.4]]

sys1 = StateSpace(A1, B1, C1, D1)

sys2 = StateSpace(A2, B2, C2, D2)

sys3 = StateSpace(A3, B3, C3, D3)

sys3c = sys1.append(sys2)

np.testing.assert_array_almost_equal(sys3.A, sys3c.A)

np.testing.assert_array_almost_equal(sys3.B, sys3c.B)

np.testing.assert_array_almost_equal(sys3.C, sys3c.C)

np.testing.assert_array_almost_equal(sys3.D, sys3c.D)

def test_append_tf(self):

"""Test appending a state-space system with a tf"""

A1 = [[-2, 0.5, 0], [0.5, -0.3, 0], [0, 0, -0.1]]

B1 = [[0.3, -1.3], [0.1, 0.], [1.0, 0.0]]

C1 = [[0., 0.1, 0.0], [-0.3, -0.2, 0.0]]

D1 = [[0., -0.8], [-0.3, 0.]]

s = TransferFunction([1, 0], [1])

h = 1 / (s + 1) / (s + 2)

sys1 = StateSpace(A1, B1, C1, D1)

sys2 = _convertToStateSpace(h)

sys3c = sys1.append(sys2)

np.testing.assert_array_almost_equal(sys1.A, sys3c.A[:3, :3])

np.testing.assert_array_almost_equal(sys1.B, sys3c.B[:3, :2])

np.testing.assert_array_almost_equal(sys1.C, sys3c.C[:2, :3])

np.testing.assert_array_almost_equal(sys1.D, sys3c.D[:2, :2])

np.testing.assert_array_almost_equal(sys2.A, sys3c.A[3:, 3:])

np.testing.assert_array_almost_equal(sys2.B, sys3c.B[3:, 2:])

np.testing.assert_array_almost_equal(sys2.C, sys3c.C[2:, 3:])

np.testing.assert_array_almost_equal(sys2.D, sys3c.D[2:, 2:])

np.testing.assert_array_almost_equal(sys3c.A[:3, 3:], np.zeros((3, 2)))

np.testing.assert_array_almost_equal(sys3c.A[3:, :3], np.zeros((2, 3)))

def test_array_access_ss(self):

sys1 = StateSpace([[1., 2.], [3., 4.]],

[[5., 6.], [6., 8.]],

[[9., 10.], [11., 12.]],

[[13., 14.], [15., 16.]], 1)

sys1_11 = sys1[0, 1]

np.testing.assert_array_almost_equal(sys1_11.A,

sys1.A)

np.testing.assert_array_almost_equal(sys1_11.B,

sys1.B[:, 1:2])

np.testing.assert_array_almost_equal(sys1_11.C,

sys1.C[0:1, :])

np.testing.assert_array_almost_equal(sys1_11.D,

sys1.D[0, 1])

assert sys1.dt == sys1_11.dt

def test_dc_gain_cont(self):

"""Test DC gain for continuous-time state-space systems."""

sys = StateSpace(-2., 6., 5., 0)

np.testing.assert_allclose(sys.dcgain(), 15.)

sys2 = StateSpace(-2, [6., 4.], [[5.], [7.], [11]], np.zeros((3, 2)))

expected = np.array([[15., 10.], [21., 14.], [33., 22.]])

np.testing.assert_allclose(sys2.dcgain(), expected)

sys3 = StateSpace(0., 1., 1., 0.)

np.testing.assert_equal(sys3.dcgain(), np.nan)

def test_dc_gain_discr(self):

"""Test DC gain for discrete-time state-space systems."""

# static gain

sys = StateSpace([], [], [], 2, True)

np.testing.assert_equal(sys.dcgain(), 2)

# averaging filter

sys = StateSpace(0.5, 0.5, 1, 0, True)

np.testing.assert_allclose(sys.dcgain(), 1)

# differencer

sys = StateSpace(0, 1, -1, 1, True)

np.testing.assert_equal(sys.dcgain(), 0)

# summer

sys = StateSpace(1, 1, 1, 0, True)

np.testing.assert_equal(sys.dcgain(), np.nan)

@pytest.mark.parametrize("outputs", range(1, 6))

@pytest.mark.parametrize("inputs", range(1, 6))

@pytest.mark.parametrize("dt", [None, 0, 1, True],

def test_dc_gain_integrator(self, outputs, inputs, dt):

"""DC gain when eigenvalue at DC returns appropriately sized array of nan.

states = max(inputs, outputs)

# a matrix that is singular at DC, and has no "useless" states as in

# _remove_useless_states

a = np.triu(np.tile(2, (states, states)))

# eigenvalues all +2, except for ...

a[0, 0] = 0 if dt in [0, None] else 1

b = np.eye(max(inputs, states))[:states, :inputs]

c = np.eye(max(outputs, states))[:outputs, :states]

d = np.zeros((outputs, inputs))

sys = StateSpace(a, b, c, d, dt)

dc = np.squeeze(np.full_like(d, np.nan))

np.testing.assert_array_equal(dc, sys.dcgain())

def test_scalar_static_gain(self):

"""Regression: can we create a scalar static gain?

g1 = StateSpace([], [], [], [2])

g2 = StateSpace([], [], [], [3])

g3 = g1 * g2

assert 6 == g3.D[0, 0]

g4 = g1 + g2

assert 5 == g4.D[0, 0]

g5 = g1.feedback(g2)

np.testing.assert_allclose(2. / 7, g5.D[0, 0])

g6 = g1.append(g2)

np.testing.assert_allclose(np.diag([2, 3]), g6.D)

def test_matrix_static_gain(self):

"""Regression: can we create matrix static gains?"""

d1 = np.array([[1, 2, 3], [4, 5, 6]])

d2 = np.array([[7, 8], [9, 10], [11, 12]])

g1 = StateSpace([], [], [], d1)

# _remove_useless_states was making A = [[0]]

assert (0, 0) == g1.A.shape

g2 = StateSpace([], [], [], d2)

g3 = StateSpace([], [], [], d2.T)

h1 = g1 * g2

np.testing.assert_array_equal(np.dot(d1, d2), h1.D)

h2 = g1 + g3

np.testing.assert_array_equal(d1 + d2.T, h2.D)

h3 = g1.feedback(g2)

np.testing.assert_array_almost_equal(

solve(np.eye(2) + np.dot(d1, d2), d1), h3.D)

h4 = g1.append(g2)

np.testing.assert_array_equal(block_diag(d1, d2), h4.D)

def test_remove_useless_states(self):

"""Regression: _remove_useless_states gives correct ABC sizes."""

g1 = StateSpace(np.zeros((3, 3)),

np.zeros((3, 4)),

np.zeros((5, 3)),

np.zeros((5, 4)))

assert (0, 0) == g1.A.shape

assert (0, 4) == g1.B.shape

assert (5, 0) == g1.C.shape

assert (5, 4) == g1.D.shape

assert 0 == g1.states

@pytest.mark.parametrize("A, B, C, D",

def test_bad_empty_matrices(self, A, B, C, D):

"""Mismatched ABCD matrices when some are empty."""

with pytest.raises(ValueError):

StateSpace(A, B, C, D)

def test_minreal_static_gain(self):

"""Regression: minreal on static gain was failing."""

g1 = StateSpace([], [], [], [1])

g2 = g1.minreal()

np.testing.assert_array_equal(g1.A, g2.A)

np.testing.assert_array_equal(g1.B, g2.B)

np.testing.assert_array_equal(g1.C, g2.C)

np.testing.assert_array_equal(g1.D, g2.D)

def test_empty(self):

"""Regression: can we create an empty StateSpace object?"""

g1 = StateSpace([], [], [], [])

assert 0 == g1.states

assert 0 == g1.inputs

assert 0 == g1.outputs

def test_matrix_to_state_space(self):

"""_convertToStateSpace(matrix) gives ss([],[],[],D)"""

with pytest.deprecated_call():

D = np.matrix([[1, 2, 3], [4, 5, 6]])

g = _convertToStateSpace(D)

np.testing.assert_array_equal(np.empty((0, 0)), g.A)

np.testing.assert_array_equal(np.empty((0, D.shape[1])), g.B)

np.testing.assert_array_equal(np.empty((D.shape[0], 0)), g.C)

np.testing.assert_array_equal(D, g.D)

def test_lft(self):

""" test lft function with result obtained from matlab implementation"""

# test case

A = [[1, 2, 3],

[1, 4, 5],

[2, 3, 4]]

B = [[0, 2],

[5, 6],

[5, 2]]

C = [[1, 4, 5],

[2, 3, 0]]

D = [[0, 0],

[3, 0]]

P = StateSpace(A, B, C, D)

Ak = [[0, 2, 3],

[2, 3, 5],

[2, 1, 9]]

Bk = [[1, 1],

[2, 3],

[9, 4]]

Ck = [[1, 4, 5],

[2, 3, 6]]

Dk = [[0, 2],

[0, 0]]

K = StateSpace(Ak, Bk, Ck, Dk)

# case 1

pk = P.lft(K, 2, 1)

Amatlab = [1, 2, 3, 4, 6, 12, 1, 4, 5, 17, 38, 61, 2, 3, 4, 9, 26, 37,

2, 3, 0, 3, 14, 18, 4, 6, 0, 8, 27, 35, 18, 27, 0, 29, 109,

144]

Bmatlab = [0, 10, 10, 7, 15, 58]

Cmatlab = [1, 4, 5, 0, 0, 0]

Dmatlab = [0]

np.testing.assert_allclose(np.array(pk.A).reshape(-1), Amatlab)

np.testing.assert_allclose(np.array(pk.B).reshape(-1), Bmatlab)

np.testing.assert_allclose(np.array(pk.C).reshape(-1), Cmatlab)

np.testing.assert_allclose(np.array(pk.D).reshape(-1), Dmatlab)

# case 2

pk = P.lft(K)

Amatlab = [1, 2, 3, 4, 6, 12, -3, -2, 5, 11, 14, 31, -2, -3, 4, 3, 2,

7, 0.6, 3.4, 5, -0.6, -0.4, 0, 0.8, 6.2, 10, 0.2, -4.2,

-4, 7.4, 33.6, 45, -0.4, -8.6, -3]

Bmatlab = []

Cmatlab = []

Dmatlab = []

np.testing.assert_allclose(np.array(pk.A).reshape(-1), Amatlab)

np.testing.assert_allclose(np.array(pk.B).reshape(-1), Bmatlab)

np.testing.assert_allclose(np.array(pk.C).reshape(-1), Cmatlab)

np.testing.assert_allclose(np.array(pk.D).reshape(-1), Dmatlab)

def test_repr(self, sys322):

"""Test string representation"""

ref322 = "\n".join(["StateSpace(array([[-3., 4., 2.],",

" [-1., -3., 0.],",

" [ 2., 5., 3.]]), array([[ 1., 4.],",

" [-3., -3.],",

" [-2., 1.]]), array([[ 4., 2., -3.],",

" [ 1., 4., 3.]]), array([[-2., 4.],",

" [ 0., 1.]]){dt})"])

assert repr(sys322) == ref322.format(dt='')

sysd = StateSpace(sys322.A, sys322.B,

sys322.C, sys322.D, 0.4)

assert repr(sysd), ref322.format(dt=" == 0.4")

array = np.array # noqa

sysd2 = eval(repr(sysd))

np.testing.assert_allclose(sysd.A, sysd2.A)

np.testing.assert_allclose(sysd.B, sysd2.B)

np.testing.assert_allclose(sysd.C, sysd2.C)

np.testing.assert_allclose(sysd.D, sysd2.D)

def test_str(self, sys322):

"""Test that printing the system works"""

tsys = sys322

tref = ("A = [[-3. 4. 2.]\n"

" [-1. -3. 0.]\n"

" [ 2. 5. 3.]]\n"

"\n"

"B = [[ 1. 4.]\n"

" [-3. -3.]\n"

" [-2. 1.]]\n"

"\n"

"C = [[ 4. 2. -3.]\n"

" [ 1. 4. 3.]]\n"

"\n"

"D = [[-2. 4.]\n"

" [ 0. 1.]]\n")

assert str(tsys) == tref

tsysdtunspec = StateSpace(tsys.A, tsys.B, tsys.C, tsys.D, True)

assert str(tsysdtunspec) == tref + "\ndt unspecified\n"

sysdt1 = StateSpace(tsys.A, tsys.B, tsys.C, tsys.D, 1.)

assert str(sysdt1) == tref + "\ndt = 1.0\n"

def test_pole_static(self):

"""Regression: pole() of static gain is empty array."""

np.testing.assert_array_equal(np.array([]),

StateSpace([], [], [], [[1]]).pole())

def test_horner(self, sys322):

"""Test horner() function"""

# Make sure we can compute the transfer function at a complex value

sys322.horner(1. + 1.j)

# Make sure result agrees with frequency response

mag, phase, omega = sys322.freqresp([1])

np.testing.assert_array_almost_equal(

sys322.horner(1.j),

"""These are tests for the proper functionality of statesp.rss."""

# Maxmimum number of states to test + 1

maxStates = 10

# Maximum number of inputs and outputs to test + 1

maxIO = 5

@pytest.mark.parametrize('states', range(1, maxStates))

@pytest.mark.parametrize('outputs', range(1, maxIO))

@pytest.mark.parametrize('inputs', range(1, maxIO))

def test_shape(self, states, outputs, inputs):

"""Test that rss outputs have the right state, input, and output size."""

sys = rss(states, outputs, inputs)

assert sys.states == states

assert sys.inputs == inputs

assert sys.outputs == outputs

@pytest.mark.parametrize('states', range(1, maxStates))

@pytest.mark.parametrize('outputs', range(1, maxIO))

@pytest.mark.parametrize('inputs', range(1, maxIO))

def test_pole(self, states, outputs, inputs):

"""Test that the poles of rss outputs have a negative real part."""

sys = rss(states, outputs, inputs)

p = sys.pole()

for z in p:

"""These are tests for the proper functionality of statesp.drss."""

# Maximum number of states to test + 1

maxStates = 10

# Maximum number of inputs and outputs to test + 1

maxIO = 5

@pytest.mark.parametrize('states', range(1, maxStates))

@pytest.mark.parametrize('outputs', range(1, maxIO))

@pytest.mark.parametrize('inputs', range(1, maxIO))

def test_shape(self, states, outputs, inputs):

"""Test that drss outputs have the right state, input, and output size."""

sys = drss(states, outputs, inputs)

assert sys.states == states

assert sys.inputs == inputs

assert sys.outputs == outputs

@pytest.mark.parametrize('states', range(1, maxStates))

@pytest.mark.parametrize('outputs', range(1, maxIO))

@pytest.mark.parametrize('inputs', range(1, maxIO))

def test_pole(self, states, outputs, inputs):

"""Test that the poles of drss outputs have less than unit magnitude."""

sys = drss(states, outputs, inputs)

p = sys.pole()

for z in p:

"""Test returnScipySignalLTI method"""

@pytest.fixture

def mimoss(self, request):

"""Test system with various dt values"""

n = 5

m = 3

p = 2

bx, bu = np.mgrid[1:n + 1, 1:m + 1]

cy, cx = np.mgrid[1:p + 1, 1:n + 1]

dy, du = np.mgrid[1:p + 1, 1:m + 1]

return StateSpace(np.eye(5) + np.eye(5, 5, 1),

bx * bu,

cy * cx,

dy * du,

request.param)

@pytest.mark.parametrize("mimoss",

def test_returnScipySignalLTI(self, mimoss):

"""Test returnScipySignalLTI method with strict=False"""

sslti = mimoss.returnScipySignalLTI(strict=False)

for i in range(mimoss.outputs):

for j in range(mimoss.inputs):

np.testing.assert_allclose(sslti[i][j].A, mimoss.A)

np.testing.assert_allclose(sslti[i][j].B, mimoss.B[:,

j:j + 1])

np.testing.assert_allclose(sslti[i][j].C, mimoss.C[i:i + 1,

:])

np.testing.assert_allclose(sslti[i][j].D, mimoss.D[i:i + 1,

j:j + 1])

if mimoss.dt == 0:

assert sslti[i][j].dt is None

else:

assert sslti[i][j].dt == mimoss.dt

@pytest.mark.parametrize("mimoss", [None], indirect=True)

def test_returnScipySignalLTI_error(self, mimoss):

"""Test returnScipySignalLTI method with dt=None and strict=True"""

with pytest.raises(ValueError):

mimoss.returnScipySignalLTI()

with pytest.raises(ValueError):

"""Test the configuration of the StateSpace module"""

@pytest.fixture

def matarrayout(self):

"""Override autoused global fixture within this class"""

pass

def test_statespace_defaults(self, matarrayout):

"""Make sure the tests are run with the configured defaults"""

for k, v in _statesp_defaults.items():

assert defaults[k] == v, \