1222 lines
44 KiB
Python
1222 lines
44 KiB
Python
import warnings
|
|
|
|
import numpy as np
|
|
from numpy.testing import (assert_almost_equal, assert_equal, assert_allclose,
|
|
assert_, suppress_warnings)
|
|
from pytest import raises as assert_raises
|
|
|
|
from scipy.signal import (ss2tf, tf2ss, lti,
|
|
dlti, bode, freqresp, lsim, impulse, step,
|
|
abcd_normalize, place_poles,
|
|
TransferFunction, StateSpace, ZerosPolesGain)
|
|
from scipy.signal._filter_design import BadCoefficients
|
|
import scipy.linalg as linalg
|
|
|
|
|
|
def _assert_poles_close(P1,P2, rtol=1e-8, atol=1e-8):
|
|
"""
|
|
Check each pole in P1 is close to a pole in P2 with a 1e-8
|
|
relative tolerance or 1e-8 absolute tolerance (useful for zero poles).
|
|
These tolerances are very strict but the systems tested are known to
|
|
accept these poles so we should not be far from what is requested.
|
|
"""
|
|
P2 = P2.copy()
|
|
for p1 in P1:
|
|
found = False
|
|
for p2_idx in range(P2.shape[0]):
|
|
if np.allclose([np.real(p1), np.imag(p1)],
|
|
[np.real(P2[p2_idx]), np.imag(P2[p2_idx])],
|
|
rtol, atol):
|
|
found = True
|
|
np.delete(P2, p2_idx)
|
|
break
|
|
if not found:
|
|
raise ValueError("Can't find pole " + str(p1) + " in " + str(P2))
|
|
|
|
|
|
class TestPlacePoles:
|
|
|
|
def _check(self, A, B, P, **kwargs):
|
|
"""
|
|
Perform the most common tests on the poles computed by place_poles
|
|
and return the Bunch object for further specific tests
|
|
"""
|
|
fsf = place_poles(A, B, P, **kwargs)
|
|
expected, _ = np.linalg.eig(A - np.dot(B, fsf.gain_matrix))
|
|
_assert_poles_close(expected, fsf.requested_poles)
|
|
_assert_poles_close(expected, fsf.computed_poles)
|
|
_assert_poles_close(P,fsf.requested_poles)
|
|
return fsf
|
|
|
|
def test_real(self):
|
|
# Test real pole placement using KNV and YT0 algorithm and example 1 in
|
|
# section 4 of the reference publication (see place_poles docstring)
|
|
A = np.array([1.380, -0.2077, 6.715, -5.676, -0.5814, -4.290, 0,
|
|
0.6750, 1.067, 4.273, -6.654, 5.893, 0.0480, 4.273,
|
|
1.343, -2.104]).reshape(4, 4)
|
|
B = np.array([0, 5.679, 1.136, 1.136, 0, 0, -3.146,0]).reshape(4, 2)
|
|
P = np.array([-0.2, -0.5, -5.0566, -8.6659])
|
|
|
|
# Check that both KNV and YT compute correct K matrix
|
|
self._check(A, B, P, method='KNV0')
|
|
self._check(A, B, P, method='YT')
|
|
|
|
# Try to reach the specific case in _YT_real where two singular
|
|
# values are almost equal. This is to improve code coverage but I
|
|
# have no way to be sure this code is really reached
|
|
|
|
# on some architectures this can lead to a RuntimeWarning invalid
|
|
# value in divide (see gh-7590), so suppress it for now
|
|
with np.errstate(invalid='ignore'):
|
|
self._check(A, B, (2,2,3,3))
|
|
|
|
def test_complex(self):
|
|
# Test complex pole placement on a linearized car model, taken from L.
|
|
# Jaulin, Automatique pour la robotique, Cours et Exercices, iSTE
|
|
# editions p 184/185
|
|
A = np.array([[0, 7, 0, 0],
|
|
[0, 0, 0, 7/3.],
|
|
[0, 0, 0, 0],
|
|
[0, 0, 0, 0]])
|
|
B = np.array([[0, 0],
|
|
[0, 0],
|
|
[1, 0],
|
|
[0, 1]])
|
|
# Test complex poles on YT
|
|
P = np.array([-3, -1, -2-1j, -2+1j])
|
|
# on macOS arm64 this can lead to a RuntimeWarning invalid
|
|
# value in divide, so suppress it for now
|
|
with np.errstate(divide='ignore', invalid='ignore'):
|
|
self._check(A, B, P)
|
|
|
|
# Try to reach the specific case in _YT_complex where two singular
|
|
# values are almost equal. This is to improve code coverage but I
|
|
# have no way to be sure this code is really reached
|
|
|
|
P = [0-1e-6j,0+1e-6j,-10,10]
|
|
with np.errstate(divide='ignore', invalid='ignore'):
|
|
self._check(A, B, P, maxiter=1000)
|
|
|
|
# Try to reach the specific case in _YT_complex where the rank two
|
|
# update yields two null vectors. This test was found via Monte Carlo.
|
|
|
|
A = np.array(
|
|
[-2148,-2902, -2267, -598, -1722, -1829, -165, -283, -2546,
|
|
-167, -754, -2285, -543, -1700, -584, -2978, -925, -1300,
|
|
-1583, -984, -386, -2650, -764, -897, -517, -1598, 2, -1709,
|
|
-291, -338, -153, -1804, -1106, -1168, -867, -2297]
|
|
).reshape(6,6)
|
|
|
|
B = np.array(
|
|
[-108, -374, -524, -1285, -1232, -161, -1204, -672, -637,
|
|
-15, -483, -23, -931, -780, -1245, -1129, -1290, -1502,
|
|
-952, -1374, -62, -964, -930, -939, -792, -756, -1437,
|
|
-491, -1543, -686]
|
|
).reshape(6,5)
|
|
P = [-25.-29.j, -25.+29.j, 31.-42.j, 31.+42.j, 33.-41.j, 33.+41.j]
|
|
self._check(A, B, P)
|
|
|
|
# Use a lot of poles to go through all cases for update_order
|
|
# in _YT_loop
|
|
|
|
big_A = np.ones((11,11))-np.eye(11)
|
|
big_B = np.ones((11,10))-np.diag([1]*10,1)[:,1:]
|
|
big_A[:6,:6] = A
|
|
big_B[:6,:5] = B
|
|
|
|
P = [-10,-20,-30,40,50,60,70,-20-5j,-20+5j,5+3j,5-3j]
|
|
with np.errstate(divide='ignore', invalid='ignore'):
|
|
self._check(big_A, big_B, P)
|
|
|
|
#check with only complex poles and only real poles
|
|
P = [-10,-20,-30,-40,-50,-60,-70,-80,-90,-100]
|
|
self._check(big_A[:-1,:-1], big_B[:-1,:-1], P)
|
|
P = [-10+10j,-20+20j,-30+30j,-40+40j,-50+50j,
|
|
-10-10j,-20-20j,-30-30j,-40-40j,-50-50j]
|
|
self._check(big_A[:-1,:-1], big_B[:-1,:-1], P)
|
|
|
|
# need a 5x5 array to ensure YT handles properly when there
|
|
# is only one real pole and several complex
|
|
A = np.array([0,7,0,0,0,0,0,7/3.,0,0,0,0,0,0,0,0,
|
|
0,0,0,5,0,0,0,0,9]).reshape(5,5)
|
|
B = np.array([0,0,0,0,1,0,0,1,2,3]).reshape(5,2)
|
|
P = np.array([-2, -3+1j, -3-1j, -1+1j, -1-1j])
|
|
with np.errstate(divide='ignore', invalid='ignore'):
|
|
place_poles(A, B, P)
|
|
|
|
# same test with an odd number of real poles > 1
|
|
# this is another specific case of YT
|
|
P = np.array([-2, -3, -4, -1+1j, -1-1j])
|
|
with np.errstate(divide='ignore', invalid='ignore'):
|
|
self._check(A, B, P)
|
|
|
|
def test_tricky_B(self):
|
|
# check we handle as we should the 1 column B matrices and
|
|
# n column B matrices (with n such as shape(A)=(n, n))
|
|
A = np.array([1.380, -0.2077, 6.715, -5.676, -0.5814, -4.290, 0,
|
|
0.6750, 1.067, 4.273, -6.654, 5.893, 0.0480, 4.273,
|
|
1.343, -2.104]).reshape(4, 4)
|
|
B = np.array([0, 5.679, 1.136, 1.136, 0, 0, -3.146, 0, 1, 2, 3, 4,
|
|
5, 6, 7, 8]).reshape(4, 4)
|
|
|
|
# KNV or YT are not called here, it's a specific case with only
|
|
# one unique solution
|
|
P = np.array([-0.2, -0.5, -5.0566, -8.6659])
|
|
fsf = self._check(A, B, P)
|
|
# rtol and nb_iter should be set to np.nan as the identity can be
|
|
# used as transfer matrix
|
|
assert_equal(fsf.rtol, np.nan)
|
|
assert_equal(fsf.nb_iter, np.nan)
|
|
|
|
# check with complex poles too as they trigger a specific case in
|
|
# the specific case :-)
|
|
P = np.array((-2+1j,-2-1j,-3,-2))
|
|
fsf = self._check(A, B, P)
|
|
assert_equal(fsf.rtol, np.nan)
|
|
assert_equal(fsf.nb_iter, np.nan)
|
|
|
|
#now test with a B matrix with only one column (no optimisation)
|
|
B = B[:,0].reshape(4,1)
|
|
P = np.array((-2+1j,-2-1j,-3,-2))
|
|
fsf = self._check(A, B, P)
|
|
|
|
# we can't optimize anything, check they are set to 0 as expected
|
|
assert_equal(fsf.rtol, 0)
|
|
assert_equal(fsf.nb_iter, 0)
|
|
|
|
def test_errors(self):
|
|
# Test input mistakes from user
|
|
A = np.array([0,7,0,0,0,0,0,7/3.,0,0,0,0,0,0,0,0]).reshape(4,4)
|
|
B = np.array([0,0,0,0,1,0,0,1]).reshape(4,2)
|
|
|
|
#should fail as the method keyword is invalid
|
|
assert_raises(ValueError, place_poles, A, B, (-2.1,-2.2,-2.3,-2.4),
|
|
method="foo")
|
|
|
|
#should fail as poles are not 1D array
|
|
assert_raises(ValueError, place_poles, A, B,
|
|
np.array((-2.1,-2.2,-2.3,-2.4)).reshape(4,1))
|
|
|
|
#should fail as A is not a 2D array
|
|
assert_raises(ValueError, place_poles, A[:,:,np.newaxis], B,
|
|
(-2.1,-2.2,-2.3,-2.4))
|
|
|
|
#should fail as B is not a 2D array
|
|
assert_raises(ValueError, place_poles, A, B[:,:,np.newaxis],
|
|
(-2.1,-2.2,-2.3,-2.4))
|
|
|
|
#should fail as there are too many poles
|
|
assert_raises(ValueError, place_poles, A, B, (-2.1,-2.2,-2.3,-2.4,-3))
|
|
|
|
#should fail as there are not enough poles
|
|
assert_raises(ValueError, place_poles, A, B, (-2.1,-2.2,-2.3))
|
|
|
|
#should fail as the rtol is greater than 1
|
|
assert_raises(ValueError, place_poles, A, B, (-2.1,-2.2,-2.3,-2.4),
|
|
rtol=42)
|
|
|
|
#should fail as maxiter is smaller than 1
|
|
assert_raises(ValueError, place_poles, A, B, (-2.1,-2.2,-2.3,-2.4),
|
|
maxiter=-42)
|
|
|
|
# should fail as ndim(B) is two
|
|
assert_raises(ValueError, place_poles, A, B, (-2,-2,-2,-2))
|
|
|
|
#unctrollable system
|
|
assert_raises(ValueError, place_poles, np.ones((4,4)),
|
|
np.ones((4,2)), (1,2,3,4))
|
|
|
|
# Should not raise ValueError as the poles can be placed but should
|
|
# raise a warning as the convergence is not reached
|
|
with warnings.catch_warnings(record=True) as w:
|
|
warnings.simplefilter("always")
|
|
fsf = place_poles(A, B, (-1,-2,-3,-4), rtol=1e-16, maxiter=42)
|
|
assert_(len(w) == 1)
|
|
assert_(issubclass(w[-1].category, UserWarning))
|
|
assert_("Convergence was not reached after maxiter iterations"
|
|
in str(w[-1].message))
|
|
assert_equal(fsf.nb_iter, 42)
|
|
|
|
# should fail as a complex misses its conjugate
|
|
assert_raises(ValueError, place_poles, A, B, (-2+1j,-2-1j,-2+3j,-2))
|
|
|
|
# should fail as A is not square
|
|
assert_raises(ValueError, place_poles, A[:,:3], B, (-2,-3,-4,-5))
|
|
|
|
# should fail as B has not the same number of lines as A
|
|
assert_raises(ValueError, place_poles, A, B[:3,:], (-2,-3,-4,-5))
|
|
|
|
# should fail as KNV0 does not support complex poles
|
|
assert_raises(ValueError, place_poles, A, B,
|
|
(-2+1j,-2-1j,-2+3j,-2-3j), method="KNV0")
|
|
|
|
|
|
class TestSS2TF:
|
|
|
|
def check_matrix_shapes(self, p, q, r):
|
|
ss2tf(np.zeros((p, p)),
|
|
np.zeros((p, q)),
|
|
np.zeros((r, p)),
|
|
np.zeros((r, q)), 0)
|
|
|
|
def test_shapes(self):
|
|
# Each tuple holds:
|
|
# number of states, number of inputs, number of outputs
|
|
for p, q, r in [(3, 3, 3), (1, 3, 3), (1, 1, 1)]:
|
|
self.check_matrix_shapes(p, q, r)
|
|
|
|
def test_basic(self):
|
|
# Test a round trip through tf2ss and ss2tf.
|
|
b = np.array([1.0, 3.0, 5.0])
|
|
a = np.array([1.0, 2.0, 3.0])
|
|
|
|
A, B, C, D = tf2ss(b, a)
|
|
assert_allclose(A, [[-2, -3], [1, 0]], rtol=1e-13)
|
|
assert_allclose(B, [[1], [0]], rtol=1e-13)
|
|
assert_allclose(C, [[1, 2]], rtol=1e-13)
|
|
assert_allclose(D, [[1]], rtol=1e-14)
|
|
|
|
bb, aa = ss2tf(A, B, C, D)
|
|
assert_allclose(bb[0], b, rtol=1e-13)
|
|
assert_allclose(aa, a, rtol=1e-13)
|
|
|
|
def test_zero_order_round_trip(self):
|
|
# See gh-5760
|
|
tf = (2, 1)
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[0]], rtol=1e-13)
|
|
assert_allclose(B, [[0]], rtol=1e-13)
|
|
assert_allclose(C, [[0]], rtol=1e-13)
|
|
assert_allclose(D, [[2]], rtol=1e-13)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[2, 0]], rtol=1e-13)
|
|
assert_allclose(den, [1, 0], rtol=1e-13)
|
|
|
|
tf = ([[5], [2]], 1)
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[0]], rtol=1e-13)
|
|
assert_allclose(B, [[0]], rtol=1e-13)
|
|
assert_allclose(C, [[0], [0]], rtol=1e-13)
|
|
assert_allclose(D, [[5], [2]], rtol=1e-13)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[5, 0], [2, 0]], rtol=1e-13)
|
|
assert_allclose(den, [1, 0], rtol=1e-13)
|
|
|
|
def test_simo_round_trip(self):
|
|
# See gh-5753
|
|
tf = ([[1, 2], [1, 1]], [1, 2])
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[-2]], rtol=1e-13)
|
|
assert_allclose(B, [[1]], rtol=1e-13)
|
|
assert_allclose(C, [[0], [-1]], rtol=1e-13)
|
|
assert_allclose(D, [[1], [1]], rtol=1e-13)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[1, 2], [1, 1]], rtol=1e-13)
|
|
assert_allclose(den, [1, 2], rtol=1e-13)
|
|
|
|
tf = ([[1, 0, 1], [1, 1, 1]], [1, 1, 1])
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[-1, -1], [1, 0]], rtol=1e-13)
|
|
assert_allclose(B, [[1], [0]], rtol=1e-13)
|
|
assert_allclose(C, [[-1, 0], [0, 0]], rtol=1e-13)
|
|
assert_allclose(D, [[1], [1]], rtol=1e-13)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[1, 0, 1], [1, 1, 1]], rtol=1e-13)
|
|
assert_allclose(den, [1, 1, 1], rtol=1e-13)
|
|
|
|
tf = ([[1, 2, 3], [1, 2, 3]], [1, 2, 3, 4])
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[-2, -3, -4], [1, 0, 0], [0, 1, 0]], rtol=1e-13)
|
|
assert_allclose(B, [[1], [0], [0]], rtol=1e-13)
|
|
assert_allclose(C, [[1, 2, 3], [1, 2, 3]], rtol=1e-13)
|
|
assert_allclose(D, [[0], [0]], rtol=1e-13)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[0, 1, 2, 3], [0, 1, 2, 3]], rtol=1e-13)
|
|
assert_allclose(den, [1, 2, 3, 4], rtol=1e-13)
|
|
|
|
tf = (np.array([1, [2, 3]], dtype=object), [1, 6])
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[-6]], rtol=1e-31)
|
|
assert_allclose(B, [[1]], rtol=1e-31)
|
|
assert_allclose(C, [[1], [-9]], rtol=1e-31)
|
|
assert_allclose(D, [[0], [2]], rtol=1e-31)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[0, 1], [2, 3]], rtol=1e-13)
|
|
assert_allclose(den, [1, 6], rtol=1e-13)
|
|
|
|
tf = (np.array([[1, -3], [1, 2, 3]], dtype=object), [1, 6, 5])
|
|
A, B, C, D = tf2ss(*tf)
|
|
assert_allclose(A, [[-6, -5], [1, 0]], rtol=1e-13)
|
|
assert_allclose(B, [[1], [0]], rtol=1e-13)
|
|
assert_allclose(C, [[1, -3], [-4, -2]], rtol=1e-13)
|
|
assert_allclose(D, [[0], [1]], rtol=1e-13)
|
|
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[0, 1, -3], [1, 2, 3]], rtol=1e-13)
|
|
assert_allclose(den, [1, 6, 5], rtol=1e-13)
|
|
|
|
def test_all_int_arrays(self):
|
|
A = [[0, 1, 0], [0, 0, 1], [-3, -4, -2]]
|
|
B = [[0], [0], [1]]
|
|
C = [[5, 1, 0]]
|
|
D = [[0]]
|
|
num, den = ss2tf(A, B, C, D)
|
|
assert_allclose(num, [[0.0, 0.0, 1.0, 5.0]], rtol=1e-13, atol=1e-14)
|
|
assert_allclose(den, [1.0, 2.0, 4.0, 3.0], rtol=1e-13)
|
|
|
|
def test_multioutput(self):
|
|
# Regression test for gh-2669.
|
|
|
|
# 4 states
|
|
A = np.array([[-1.0, 0.0, 1.0, 0.0],
|
|
[-1.0, 0.0, 2.0, 0.0],
|
|
[-4.0, 0.0, 3.0, 0.0],
|
|
[-8.0, 8.0, 0.0, 4.0]])
|
|
|
|
# 1 input
|
|
B = np.array([[0.3],
|
|
[0.0],
|
|
[7.0],
|
|
[0.0]])
|
|
|
|
# 3 outputs
|
|
C = np.array([[0.0, 1.0, 0.0, 0.0],
|
|
[0.0, 0.0, 0.0, 1.0],
|
|
[8.0, 8.0, 0.0, 0.0]])
|
|
|
|
D = np.array([[0.0],
|
|
[0.0],
|
|
[1.0]])
|
|
|
|
# Get the transfer functions for all the outputs in one call.
|
|
b_all, a = ss2tf(A, B, C, D)
|
|
|
|
# Get the transfer functions for each output separately.
|
|
b0, a0 = ss2tf(A, B, C[0], D[0])
|
|
b1, a1 = ss2tf(A, B, C[1], D[1])
|
|
b2, a2 = ss2tf(A, B, C[2], D[2])
|
|
|
|
# Check that we got the same results.
|
|
assert_allclose(a0, a, rtol=1e-13)
|
|
assert_allclose(a1, a, rtol=1e-13)
|
|
assert_allclose(a2, a, rtol=1e-13)
|
|
assert_allclose(b_all, np.vstack((b0, b1, b2)), rtol=1e-13, atol=1e-14)
|
|
|
|
|
|
class TestLsim:
|
|
digits_accuracy = 7
|
|
|
|
def lti_nowarn(self, *args):
|
|
with suppress_warnings() as sup:
|
|
sup.filter(BadCoefficients)
|
|
system = lti(*args)
|
|
return system
|
|
|
|
def test_first_order(self):
|
|
# y' = -y
|
|
# exact solution is y(t) = exp(-t)
|
|
system = self.lti_nowarn(-1.,1.,1.,0.)
|
|
t = np.linspace(0,5)
|
|
u = np.zeros_like(t)
|
|
tout, y, x = lsim(system, u, t, X0=[1.0])
|
|
expected_x = np.exp(-tout)
|
|
assert_almost_equal(x, expected_x)
|
|
assert_almost_equal(y, expected_x)
|
|
|
|
def test_second_order(self):
|
|
t = np.linspace(0, 10, 1001)
|
|
u = np.zeros_like(t)
|
|
# Second order system with a repeated root: x''(t) + 2*x(t) + x(t) = 0.
|
|
# With initial conditions x(0)=1.0 and x'(t)=0.0, the exact solution
|
|
# is (1-t)*exp(-t).
|
|
system = self.lti_nowarn([1.0], [1.0, 2.0, 1.0])
|
|
tout, y, x = lsim(system, u, t, X0=[1.0, 0.0])
|
|
expected_x = (1.0 - tout) * np.exp(-tout)
|
|
assert_almost_equal(x[:, 0], expected_x)
|
|
|
|
def test_integrator(self):
|
|
# integrator: y' = u
|
|
system = self.lti_nowarn(0., 1., 1., 0.)
|
|
t = np.linspace(0,5)
|
|
u = t
|
|
tout, y, x = lsim(system, u, t)
|
|
expected_x = 0.5 * tout**2
|
|
assert_almost_equal(x, expected_x, decimal=self.digits_accuracy)
|
|
assert_almost_equal(y, expected_x, decimal=self.digits_accuracy)
|
|
|
|
def test_two_states(self):
|
|
# A system with two state variables, two inputs, and one output.
|
|
A = np.array([[-1.0, 0.0], [0.0, -2.0]])
|
|
B = np.array([[1.0, 0.0], [0.0, 1.0]])
|
|
C = np.array([1.0, 0.0])
|
|
D = np.zeros((1, 2))
|
|
|
|
system = self.lti_nowarn(A, B, C, D)
|
|
|
|
t = np.linspace(0, 10.0, 21)
|
|
u = np.zeros((len(t), 2))
|
|
tout, y, x = lsim(system, U=u, T=t, X0=[1.0, 1.0])
|
|
expected_y = np.exp(-tout)
|
|
expected_x0 = np.exp(-tout)
|
|
expected_x1 = np.exp(-2.0 * tout)
|
|
assert_almost_equal(y, expected_y)
|
|
assert_almost_equal(x[:, 0], expected_x0)
|
|
assert_almost_equal(x[:, 1], expected_x1)
|
|
|
|
def test_double_integrator(self):
|
|
# double integrator: y'' = 2u
|
|
A = np.array([[0., 1.], [0., 0.]])
|
|
B = np.array([[0.], [1.]])
|
|
C = np.array([[2., 0.]])
|
|
system = self.lti_nowarn(A, B, C, 0.)
|
|
t = np.linspace(0,5)
|
|
u = np.ones_like(t)
|
|
tout, y, x = lsim(system, u, t)
|
|
expected_x = np.transpose(np.array([0.5 * tout**2, tout]))
|
|
expected_y = tout**2
|
|
assert_almost_equal(x, expected_x, decimal=self.digits_accuracy)
|
|
assert_almost_equal(y, expected_y, decimal=self.digits_accuracy)
|
|
|
|
def test_jordan_block(self):
|
|
# Non-diagonalizable A matrix
|
|
# x1' + x1 = x2
|
|
# x2' + x2 = u
|
|
# y = x1
|
|
# Exact solution with u = 0 is y(t) = t exp(-t)
|
|
A = np.array([[-1., 1.], [0., -1.]])
|
|
B = np.array([[0.], [1.]])
|
|
C = np.array([[1., 0.]])
|
|
system = self.lti_nowarn(A, B, C, 0.)
|
|
t = np.linspace(0,5)
|
|
u = np.zeros_like(t)
|
|
tout, y, x = lsim(system, u, t, X0=[0.0, 1.0])
|
|
expected_y = tout * np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_miso(self):
|
|
# A system with two state variables, two inputs, and one output.
|
|
A = np.array([[-1.0, 0.0], [0.0, -2.0]])
|
|
B = np.array([[1.0, 0.0], [0.0, 1.0]])
|
|
C = np.array([1.0, 0.0])
|
|
D = np.zeros((1,2))
|
|
system = self.lti_nowarn(A, B, C, D)
|
|
|
|
t = np.linspace(0, 5.0, 101)
|
|
u = np.zeros((len(t), 2))
|
|
tout, y, x = lsim(system, u, t, X0=[1.0, 1.0])
|
|
expected_y = np.exp(-tout)
|
|
expected_x0 = np.exp(-tout)
|
|
expected_x1 = np.exp(-2.0*tout)
|
|
assert_almost_equal(y, expected_y)
|
|
assert_almost_equal(x[:,0], expected_x0)
|
|
assert_almost_equal(x[:,1], expected_x1)
|
|
|
|
def test_nonzero_initial_time(self):
|
|
system = self.lti_nowarn(-1.,1.,1.,0.)
|
|
t = np.linspace(1,2)
|
|
u = np.zeros_like(t)
|
|
tout, y, x = lsim(system, u, t, X0=[1.0])
|
|
expected_y = np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_nonequal_timesteps(self):
|
|
t = np.array([0.0, 1.0, 1.0, 3.0])
|
|
u = np.array([0.0, 0.0, 1.0, 1.0])
|
|
# Simple integrator: x'(t) = u(t)
|
|
system = ([1.0], [1.0, 0.0])
|
|
with assert_raises(ValueError,
|
|
match="Time steps are not equally spaced."):
|
|
tout, y, x = lsim(system, u, t, X0=[1.0])
|
|
|
|
|
|
class TestImpulse:
|
|
def test_first_order(self):
|
|
# First order system: x'(t) + x(t) = u(t)
|
|
# Exact impulse response is x(t) = exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
tout, y = impulse(system)
|
|
expected_y = np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_first_order_fixed_time(self):
|
|
# Specify the desired time values for the output.
|
|
|
|
# First order system: x'(t) + x(t) = u(t)
|
|
# Exact impulse response is x(t) = exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
n = 21
|
|
t = np.linspace(0, 2.0, n)
|
|
tout, y = impulse(system, T=t)
|
|
assert_equal(tout.shape, (n,))
|
|
assert_almost_equal(tout, t)
|
|
expected_y = np.exp(-t)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_first_order_initial(self):
|
|
# Specify an initial condition as a scalar.
|
|
|
|
# First order system: x'(t) + x(t) = u(t), x(0)=3.0
|
|
# Exact impulse response is x(t) = 4*exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
tout, y = impulse(system, X0=3.0)
|
|
expected_y = 4.0 * np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_first_order_initial_list(self):
|
|
# Specify an initial condition as a list.
|
|
|
|
# First order system: x'(t) + x(t) = u(t), x(0)=3.0
|
|
# Exact impulse response is x(t) = 4*exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
tout, y = impulse(system, X0=[3.0])
|
|
expected_y = 4.0 * np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_integrator(self):
|
|
# Simple integrator: x'(t) = u(t)
|
|
system = ([1.0], [1.0,0.0])
|
|
tout, y = impulse(system)
|
|
expected_y = np.ones_like(tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_second_order(self):
|
|
# Second order system with a repeated root:
|
|
# x''(t) + 2*x(t) + x(t) = u(t)
|
|
# The exact impulse response is t*exp(-t).
|
|
system = ([1.0], [1.0, 2.0, 1.0])
|
|
tout, y = impulse(system)
|
|
expected_y = tout * np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_array_like(self):
|
|
# Test that function can accept sequences, scalars.
|
|
system = ([1.0], [1.0, 2.0, 1.0])
|
|
# TODO: add meaningful test where X0 is a list
|
|
tout, y = impulse(system, X0=[3], T=[5, 6])
|
|
tout, y = impulse(system, X0=[3], T=[5])
|
|
|
|
def test_array_like2(self):
|
|
system = ([1.0], [1.0, 2.0, 1.0])
|
|
tout, y = impulse(system, X0=3, T=5)
|
|
|
|
|
|
class TestStep:
|
|
def test_first_order(self):
|
|
# First order system: x'(t) + x(t) = u(t)
|
|
# Exact step response is x(t) = 1 - exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
tout, y = step(system)
|
|
expected_y = 1.0 - np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_first_order_fixed_time(self):
|
|
# Specify the desired time values for the output.
|
|
|
|
# First order system: x'(t) + x(t) = u(t)
|
|
# Exact step response is x(t) = 1 - exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
n = 21
|
|
t = np.linspace(0, 2.0, n)
|
|
tout, y = step(system, T=t)
|
|
assert_equal(tout.shape, (n,))
|
|
assert_almost_equal(tout, t)
|
|
expected_y = 1 - np.exp(-t)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_first_order_initial(self):
|
|
# Specify an initial condition as a scalar.
|
|
|
|
# First order system: x'(t) + x(t) = u(t), x(0)=3.0
|
|
# Exact step response is x(t) = 1 + 2*exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
tout, y = step(system, X0=3.0)
|
|
expected_y = 1 + 2.0*np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_first_order_initial_list(self):
|
|
# Specify an initial condition as a list.
|
|
|
|
# First order system: x'(t) + x(t) = u(t), x(0)=3.0
|
|
# Exact step response is x(t) = 1 + 2*exp(-t).
|
|
system = ([1.0], [1.0,1.0])
|
|
tout, y = step(system, X0=[3.0])
|
|
expected_y = 1 + 2.0*np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_integrator(self):
|
|
# Simple integrator: x'(t) = u(t)
|
|
# Exact step response is x(t) = t.
|
|
system = ([1.0],[1.0,0.0])
|
|
tout, y = step(system)
|
|
expected_y = tout
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_second_order(self):
|
|
# Second order system with a repeated root:
|
|
# x''(t) + 2*x(t) + x(t) = u(t)
|
|
# The exact step response is 1 - (1 + t)*exp(-t).
|
|
system = ([1.0], [1.0, 2.0, 1.0])
|
|
tout, y = step(system)
|
|
expected_y = 1 - (1 + tout) * np.exp(-tout)
|
|
assert_almost_equal(y, expected_y)
|
|
|
|
def test_array_like(self):
|
|
# Test that function can accept sequences, scalars.
|
|
system = ([1.0], [1.0, 2.0, 1.0])
|
|
# TODO: add meaningful test where X0 is a list
|
|
tout, y = step(system, T=[5, 6])
|
|
|
|
def test_complex_input(self):
|
|
# Test that complex input doesn't raise an error.
|
|
# `step` doesn't seem to have been designed for complex input, but this
|
|
# works and may be used, so add regression test. See gh-2654.
|
|
step(([], [-1], 1+0j))
|
|
|
|
|
|
class TestLti:
|
|
def test_lti_instantiation(self):
|
|
# Test that lti can be instantiated with sequences, scalars.
|
|
# See PR-225.
|
|
|
|
# TransferFunction
|
|
s = lti([1], [-1])
|
|
assert_(isinstance(s, TransferFunction))
|
|
assert_(isinstance(s, lti))
|
|
assert_(not isinstance(s, dlti))
|
|
assert_(s.dt is None)
|
|
|
|
# ZerosPolesGain
|
|
s = lti(np.array([]), np.array([-1]), 1)
|
|
assert_(isinstance(s, ZerosPolesGain))
|
|
assert_(isinstance(s, lti))
|
|
assert_(not isinstance(s, dlti))
|
|
assert_(s.dt is None)
|
|
|
|
# StateSpace
|
|
s = lti([], [-1], 1)
|
|
s = lti([1], [-1], 1, 3)
|
|
assert_(isinstance(s, StateSpace))
|
|
assert_(isinstance(s, lti))
|
|
assert_(not isinstance(s, dlti))
|
|
assert_(s.dt is None)
|
|
|
|
|
|
class TestStateSpace:
|
|
def test_initialization(self):
|
|
# Check that all initializations work
|
|
StateSpace(1, 1, 1, 1)
|
|
StateSpace([1], [2], [3], [4])
|
|
StateSpace(np.array([[1, 2], [3, 4]]), np.array([[1], [2]]),
|
|
np.array([[1, 0]]), np.array([[0]]))
|
|
|
|
def test_conversion(self):
|
|
# Check the conversion functions
|
|
s = StateSpace(1, 2, 3, 4)
|
|
assert_(isinstance(s.to_ss(), StateSpace))
|
|
assert_(isinstance(s.to_tf(), TransferFunction))
|
|
assert_(isinstance(s.to_zpk(), ZerosPolesGain))
|
|
|
|
# Make sure copies work
|
|
assert_(StateSpace(s) is not s)
|
|
assert_(s.to_ss() is not s)
|
|
|
|
def test_properties(self):
|
|
# Test setters/getters for cross class properties.
|
|
# This implicitly tests to_tf() and to_zpk()
|
|
|
|
# Getters
|
|
s = StateSpace(1, 1, 1, 1)
|
|
assert_equal(s.poles, [1])
|
|
assert_equal(s.zeros, [0])
|
|
assert_(s.dt is None)
|
|
|
|
def test_operators(self):
|
|
# Test +/-/* operators on systems
|
|
|
|
class BadType:
|
|
pass
|
|
|
|
s1 = StateSpace(np.array([[-0.5, 0.7], [0.3, -0.8]]),
|
|
np.array([[1], [0]]),
|
|
np.array([[1, 0]]),
|
|
np.array([[0]]),
|
|
)
|
|
|
|
s2 = StateSpace(np.array([[-0.2, -0.1], [0.4, -0.1]]),
|
|
np.array([[1], [0]]),
|
|
np.array([[1, 0]]),
|
|
np.array([[0]])
|
|
)
|
|
|
|
s_discrete = s1.to_discrete(0.1)
|
|
s2_discrete = s2.to_discrete(0.2)
|
|
s3_discrete = s2.to_discrete(0.1)
|
|
|
|
# Impulse response
|
|
t = np.linspace(0, 1, 100)
|
|
u = np.zeros_like(t)
|
|
u[0] = 1
|
|
|
|
# Test multiplication
|
|
for typ in (int, float, complex, np.float32, np.complex128, np.array):
|
|
assert_allclose(lsim(typ(2) * s1, U=u, T=t)[1],
|
|
typ(2) * lsim(s1, U=u, T=t)[1])
|
|
|
|
assert_allclose(lsim(s1 * typ(2), U=u, T=t)[1],
|
|
lsim(s1, U=u, T=t)[1] * typ(2))
|
|
|
|
assert_allclose(lsim(s1 / typ(2), U=u, T=t)[1],
|
|
lsim(s1, U=u, T=t)[1] / typ(2))
|
|
|
|
with assert_raises(TypeError):
|
|
typ(2) / s1
|
|
|
|
assert_allclose(lsim(s1 * 2, U=u, T=t)[1],
|
|
lsim(s1, U=2 * u, T=t)[1])
|
|
|
|
assert_allclose(lsim(s1 * s2, U=u, T=t)[1],
|
|
lsim(s1, U=lsim(s2, U=u, T=t)[1], T=t)[1],
|
|
atol=1e-5)
|
|
|
|
with assert_raises(TypeError):
|
|
s1 / s1
|
|
|
|
with assert_raises(TypeError):
|
|
s1 * s_discrete
|
|
|
|
with assert_raises(TypeError):
|
|
# Check different discretization constants
|
|
s_discrete * s2_discrete
|
|
|
|
with assert_raises(TypeError):
|
|
s1 * BadType()
|
|
|
|
with assert_raises(TypeError):
|
|
BadType() * s1
|
|
|
|
with assert_raises(TypeError):
|
|
s1 / BadType()
|
|
|
|
with assert_raises(TypeError):
|
|
BadType() / s1
|
|
|
|
# Test addition
|
|
assert_allclose(lsim(s1 + 2, U=u, T=t)[1],
|
|
2 * u + lsim(s1, U=u, T=t)[1])
|
|
|
|
# Check for dimension mismatch
|
|
with assert_raises(ValueError):
|
|
s1 + np.array([1, 2])
|
|
|
|
with assert_raises(ValueError):
|
|
np.array([1, 2]) + s1
|
|
|
|
with assert_raises(TypeError):
|
|
s1 + s_discrete
|
|
|
|
with assert_raises(ValueError):
|
|
s1 / np.array([[1, 2], [3, 4]])
|
|
|
|
with assert_raises(TypeError):
|
|
# Check different discretization constants
|
|
s_discrete + s2_discrete
|
|
|
|
with assert_raises(TypeError):
|
|
s1 + BadType()
|
|
|
|
with assert_raises(TypeError):
|
|
BadType() + s1
|
|
|
|
assert_allclose(lsim(s1 + s2, U=u, T=t)[1],
|
|
lsim(s1, U=u, T=t)[1] + lsim(s2, U=u, T=t)[1])
|
|
|
|
# Test subtraction
|
|
assert_allclose(lsim(s1 - 2, U=u, T=t)[1],
|
|
-2 * u + lsim(s1, U=u, T=t)[1])
|
|
|
|
assert_allclose(lsim(2 - s1, U=u, T=t)[1],
|
|
2 * u + lsim(-s1, U=u, T=t)[1])
|
|
|
|
assert_allclose(lsim(s1 - s2, U=u, T=t)[1],
|
|
lsim(s1, U=u, T=t)[1] - lsim(s2, U=u, T=t)[1])
|
|
|
|
with assert_raises(TypeError):
|
|
s1 - BadType()
|
|
|
|
with assert_raises(TypeError):
|
|
BadType() - s1
|
|
|
|
s = s_discrete + s3_discrete
|
|
assert_(s.dt == 0.1)
|
|
|
|
s = s_discrete * s3_discrete
|
|
assert_(s.dt == 0.1)
|
|
|
|
s = 3 * s_discrete
|
|
assert_(s.dt == 0.1)
|
|
|
|
s = -s_discrete
|
|
assert_(s.dt == 0.1)
|
|
|
|
class TestTransferFunction:
|
|
def test_initialization(self):
|
|
# Check that all initializations work
|
|
TransferFunction(1, 1)
|
|
TransferFunction([1], [2])
|
|
TransferFunction(np.array([1]), np.array([2]))
|
|
|
|
def test_conversion(self):
|
|
# Check the conversion functions
|
|
s = TransferFunction([1, 0], [1, -1])
|
|
assert_(isinstance(s.to_ss(), StateSpace))
|
|
assert_(isinstance(s.to_tf(), TransferFunction))
|
|
assert_(isinstance(s.to_zpk(), ZerosPolesGain))
|
|
|
|
# Make sure copies work
|
|
assert_(TransferFunction(s) is not s)
|
|
assert_(s.to_tf() is not s)
|
|
|
|
def test_properties(self):
|
|
# Test setters/getters for cross class properties.
|
|
# This implicitly tests to_ss() and to_zpk()
|
|
|
|
# Getters
|
|
s = TransferFunction([1, 0], [1, -1])
|
|
assert_equal(s.poles, [1])
|
|
assert_equal(s.zeros, [0])
|
|
|
|
|
|
class TestZerosPolesGain:
|
|
def test_initialization(self):
|
|
# Check that all initializations work
|
|
ZerosPolesGain(1, 1, 1)
|
|
ZerosPolesGain([1], [2], 1)
|
|
ZerosPolesGain(np.array([1]), np.array([2]), 1)
|
|
|
|
def test_conversion(self):
|
|
#Check the conversion functions
|
|
s = ZerosPolesGain(1, 2, 3)
|
|
assert_(isinstance(s.to_ss(), StateSpace))
|
|
assert_(isinstance(s.to_tf(), TransferFunction))
|
|
assert_(isinstance(s.to_zpk(), ZerosPolesGain))
|
|
|
|
# Make sure copies work
|
|
assert_(ZerosPolesGain(s) is not s)
|
|
assert_(s.to_zpk() is not s)
|
|
|
|
|
|
class Test_abcd_normalize:
|
|
def setup_method(self):
|
|
self.A = np.array([[1.0, 2.0], [3.0, 4.0]])
|
|
self.B = np.array([[-1.0], [5.0]])
|
|
self.C = np.array([[4.0, 5.0]])
|
|
self.D = np.array([[2.5]])
|
|
|
|
def test_no_matrix_fails(self):
|
|
assert_raises(ValueError, abcd_normalize)
|
|
|
|
def test_A_nosquare_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, [1, -1],
|
|
self.B, self.C, self.D)
|
|
|
|
def test_AB_mismatch_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, self.A, [-1, 5],
|
|
self.C, self.D)
|
|
|
|
def test_AC_mismatch_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, self.A, self.B,
|
|
[[4.0], [5.0]], self.D)
|
|
|
|
def test_CD_mismatch_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, self.A, self.B,
|
|
self.C, [2.5, 0])
|
|
|
|
def test_BD_mismatch_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, self.A, [-1, 5],
|
|
self.C, self.D)
|
|
|
|
def test_normalized_matrices_unchanged(self):
|
|
A, B, C, D = abcd_normalize(self.A, self.B, self.C, self.D)
|
|
assert_equal(A, self.A)
|
|
assert_equal(B, self.B)
|
|
assert_equal(C, self.C)
|
|
assert_equal(D, self.D)
|
|
|
|
def test_shapes(self):
|
|
A, B, C, D = abcd_normalize(self.A, self.B, [1, 0], 0)
|
|
assert_equal(A.shape[0], A.shape[1])
|
|
assert_equal(A.shape[0], B.shape[0])
|
|
assert_equal(A.shape[0], C.shape[1])
|
|
assert_equal(C.shape[0], D.shape[0])
|
|
assert_equal(B.shape[1], D.shape[1])
|
|
|
|
def test_zero_dimension_is_not_none1(self):
|
|
B_ = np.zeros((2, 0))
|
|
D_ = np.zeros((0, 0))
|
|
A, B, C, D = abcd_normalize(A=self.A, B=B_, D=D_)
|
|
assert_equal(A, self.A)
|
|
assert_equal(B, B_)
|
|
assert_equal(D, D_)
|
|
assert_equal(C.shape[0], D_.shape[0])
|
|
assert_equal(C.shape[1], self.A.shape[0])
|
|
|
|
def test_zero_dimension_is_not_none2(self):
|
|
B_ = np.zeros((2, 0))
|
|
C_ = np.zeros((0, 2))
|
|
A, B, C, D = abcd_normalize(A=self.A, B=B_, C=C_)
|
|
assert_equal(A, self.A)
|
|
assert_equal(B, B_)
|
|
assert_equal(C, C_)
|
|
assert_equal(D.shape[0], C_.shape[0])
|
|
assert_equal(D.shape[1], B_.shape[1])
|
|
|
|
def test_missing_A(self):
|
|
A, B, C, D = abcd_normalize(B=self.B, C=self.C, D=self.D)
|
|
assert_equal(A.shape[0], A.shape[1])
|
|
assert_equal(A.shape[0], B.shape[0])
|
|
assert_equal(A.shape, (self.B.shape[0], self.B.shape[0]))
|
|
|
|
def test_missing_B(self):
|
|
A, B, C, D = abcd_normalize(A=self.A, C=self.C, D=self.D)
|
|
assert_equal(B.shape[0], A.shape[0])
|
|
assert_equal(B.shape[1], D.shape[1])
|
|
assert_equal(B.shape, (self.A.shape[0], self.D.shape[1]))
|
|
|
|
def test_missing_C(self):
|
|
A, B, C, D = abcd_normalize(A=self.A, B=self.B, D=self.D)
|
|
assert_equal(C.shape[0], D.shape[0])
|
|
assert_equal(C.shape[1], A.shape[0])
|
|
assert_equal(C.shape, (self.D.shape[0], self.A.shape[0]))
|
|
|
|
def test_missing_D(self):
|
|
A, B, C, D = abcd_normalize(A=self.A, B=self.B, C=self.C)
|
|
assert_equal(D.shape[0], C.shape[0])
|
|
assert_equal(D.shape[1], B.shape[1])
|
|
assert_equal(D.shape, (self.C.shape[0], self.B.shape[1]))
|
|
|
|
def test_missing_AB(self):
|
|
A, B, C, D = abcd_normalize(C=self.C, D=self.D)
|
|
assert_equal(A.shape[0], A.shape[1])
|
|
assert_equal(A.shape[0], B.shape[0])
|
|
assert_equal(B.shape[1], D.shape[1])
|
|
assert_equal(A.shape, (self.C.shape[1], self.C.shape[1]))
|
|
assert_equal(B.shape, (self.C.shape[1], self.D.shape[1]))
|
|
|
|
def test_missing_AC(self):
|
|
A, B, C, D = abcd_normalize(B=self.B, D=self.D)
|
|
assert_equal(A.shape[0], A.shape[1])
|
|
assert_equal(A.shape[0], B.shape[0])
|
|
assert_equal(C.shape[0], D.shape[0])
|
|
assert_equal(C.shape[1], A.shape[0])
|
|
assert_equal(A.shape, (self.B.shape[0], self.B.shape[0]))
|
|
assert_equal(C.shape, (self.D.shape[0], self.B.shape[0]))
|
|
|
|
def test_missing_AD(self):
|
|
A, B, C, D = abcd_normalize(B=self.B, C=self.C)
|
|
assert_equal(A.shape[0], A.shape[1])
|
|
assert_equal(A.shape[0], B.shape[0])
|
|
assert_equal(D.shape[0], C.shape[0])
|
|
assert_equal(D.shape[1], B.shape[1])
|
|
assert_equal(A.shape, (self.B.shape[0], self.B.shape[0]))
|
|
assert_equal(D.shape, (self.C.shape[0], self.B.shape[1]))
|
|
|
|
def test_missing_BC(self):
|
|
A, B, C, D = abcd_normalize(A=self.A, D=self.D)
|
|
assert_equal(B.shape[0], A.shape[0])
|
|
assert_equal(B.shape[1], D.shape[1])
|
|
assert_equal(C.shape[0], D.shape[0])
|
|
assert_equal(C.shape[1], A.shape[0])
|
|
assert_equal(B.shape, (self.A.shape[0], self.D.shape[1]))
|
|
assert_equal(C.shape, (self.D.shape[0], self.A.shape[0]))
|
|
|
|
def test_missing_ABC_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, D=self.D)
|
|
|
|
def test_missing_BD_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, A=self.A, C=self.C)
|
|
|
|
def test_missing_CD_fails(self):
|
|
assert_raises(ValueError, abcd_normalize, A=self.A, B=self.B)
|
|
|
|
|
|
class Test_bode:
|
|
|
|
def test_01(self):
|
|
# Test bode() magnitude calculation (manual sanity check).
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1),
|
|
# cutoff: 1 rad/s, slope: -20 dB/decade
|
|
# H(s=0.1) ~= 0 dB
|
|
# H(s=1) ~= -3 dB
|
|
# H(s=10) ~= -20 dB
|
|
# H(s=100) ~= -40 dB
|
|
system = lti([1], [1, 1])
|
|
w = [0.1, 1, 10, 100]
|
|
w, mag, phase = bode(system, w=w)
|
|
expected_mag = [0, -3, -20, -40]
|
|
assert_almost_equal(mag, expected_mag, decimal=1)
|
|
|
|
def test_02(self):
|
|
# Test bode() phase calculation (manual sanity check).
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1),
|
|
# angle(H(s=0.1)) ~= -5.7 deg
|
|
# angle(H(s=1)) ~= -45 deg
|
|
# angle(H(s=10)) ~= -84.3 deg
|
|
system = lti([1], [1, 1])
|
|
w = [0.1, 1, 10]
|
|
w, mag, phase = bode(system, w=w)
|
|
expected_phase = [-5.7, -45, -84.3]
|
|
assert_almost_equal(phase, expected_phase, decimal=1)
|
|
|
|
def test_03(self):
|
|
# Test bode() magnitude calculation.
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1)
|
|
system = lti([1], [1, 1])
|
|
w = [0.1, 1, 10, 100]
|
|
w, mag, phase = bode(system, w=w)
|
|
jw = w * 1j
|
|
y = np.polyval(system.num, jw) / np.polyval(system.den, jw)
|
|
expected_mag = 20.0 * np.log10(abs(y))
|
|
assert_almost_equal(mag, expected_mag)
|
|
|
|
def test_04(self):
|
|
# Test bode() phase calculation.
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1)
|
|
system = lti([1], [1, 1])
|
|
w = [0.1, 1, 10, 100]
|
|
w, mag, phase = bode(system, w=w)
|
|
jw = w * 1j
|
|
y = np.polyval(system.num, jw) / np.polyval(system.den, jw)
|
|
expected_phase = np.arctan2(y.imag, y.real) * 180.0 / np.pi
|
|
assert_almost_equal(phase, expected_phase)
|
|
|
|
def test_05(self):
|
|
# Test that bode() finds a reasonable frequency range.
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1)
|
|
system = lti([1], [1, 1])
|
|
n = 10
|
|
# Expected range is from 0.01 to 10.
|
|
expected_w = np.logspace(-2, 1, n)
|
|
w, mag, phase = bode(system, n=n)
|
|
assert_almost_equal(w, expected_w)
|
|
|
|
def test_06(self):
|
|
# Test that bode() doesn't fail on a system with a pole at 0.
|
|
# integrator, pole at zero: H(s) = 1 / s
|
|
system = lti([1], [1, 0])
|
|
w, mag, phase = bode(system, n=2)
|
|
assert_equal(w[0], 0.01) # a fail would give not-a-number
|
|
|
|
def test_07(self):
|
|
# bode() should not fail on a system with pure imaginary poles.
|
|
# The test passes if bode doesn't raise an exception.
|
|
system = lti([1], [1, 0, 100])
|
|
w, mag, phase = bode(system, n=2)
|
|
|
|
def test_08(self):
|
|
# Test that bode() return continuous phase, issues/2331.
|
|
system = lti([], [-10, -30, -40, -60, -70], 1)
|
|
w, mag, phase = system.bode(w=np.logspace(-3, 40, 100))
|
|
assert_almost_equal(min(phase), -450, decimal=15)
|
|
|
|
def test_from_state_space(self):
|
|
# Ensure that bode works with a system that was created from the
|
|
# state space representation matrices A, B, C, D. In this case,
|
|
# system.num will be a 2-D array with shape (1, n+1), where (n,n)
|
|
# is the shape of A.
|
|
# A Butterworth lowpass filter is used, so we know the exact
|
|
# frequency response.
|
|
a = np.array([1.0, 2.0, 2.0, 1.0])
|
|
A = linalg.companion(a).T
|
|
B = np.array([[0.0], [0.0], [1.0]])
|
|
C = np.array([[1.0, 0.0, 0.0]])
|
|
D = np.array([[0.0]])
|
|
with suppress_warnings() as sup:
|
|
sup.filter(BadCoefficients)
|
|
system = lti(A, B, C, D)
|
|
w, mag, phase = bode(system, n=100)
|
|
|
|
expected_magnitude = 20 * np.log10(np.sqrt(1.0 / (1.0 + w**6)))
|
|
assert_almost_equal(mag, expected_magnitude)
|
|
|
|
|
|
class Test_freqresp:
|
|
|
|
def test_output_manual(self):
|
|
# Test freqresp() output calculation (manual sanity check).
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1),
|
|
# re(H(s=0.1)) ~= 0.99
|
|
# re(H(s=1)) ~= 0.5
|
|
# re(H(s=10)) ~= 0.0099
|
|
system = lti([1], [1, 1])
|
|
w = [0.1, 1, 10]
|
|
w, H = freqresp(system, w=w)
|
|
expected_re = [0.99, 0.5, 0.0099]
|
|
expected_im = [-0.099, -0.5, -0.099]
|
|
assert_almost_equal(H.real, expected_re, decimal=1)
|
|
assert_almost_equal(H.imag, expected_im, decimal=1)
|
|
|
|
def test_output(self):
|
|
# Test freqresp() output calculation.
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1)
|
|
system = lti([1], [1, 1])
|
|
w = [0.1, 1, 10, 100]
|
|
w, H = freqresp(system, w=w)
|
|
s = w * 1j
|
|
expected = np.polyval(system.num, s) / np.polyval(system.den, s)
|
|
assert_almost_equal(H.real, expected.real)
|
|
assert_almost_equal(H.imag, expected.imag)
|
|
|
|
def test_freq_range(self):
|
|
# Test that freqresp() finds a reasonable frequency range.
|
|
# 1st order low-pass filter: H(s) = 1 / (s + 1)
|
|
# Expected range is from 0.01 to 10.
|
|
system = lti([1], [1, 1])
|
|
n = 10
|
|
expected_w = np.logspace(-2, 1, n)
|
|
w, H = freqresp(system, n=n)
|
|
assert_almost_equal(w, expected_w)
|
|
|
|
def test_pole_zero(self):
|
|
# Test that freqresp() doesn't fail on a system with a pole at 0.
|
|
# integrator, pole at zero: H(s) = 1 / s
|
|
system = lti([1], [1, 0])
|
|
w, H = freqresp(system, n=2)
|
|
assert_equal(w[0], 0.01) # a fail would give not-a-number
|
|
|
|
def test_from_state_space(self):
|
|
# Ensure that freqresp works with a system that was created from the
|
|
# state space representation matrices A, B, C, D. In this case,
|
|
# system.num will be a 2-D array with shape (1, n+1), where (n,n) is
|
|
# the shape of A.
|
|
# A Butterworth lowpass filter is used, so we know the exact
|
|
# frequency response.
|
|
a = np.array([1.0, 2.0, 2.0, 1.0])
|
|
A = linalg.companion(a).T
|
|
B = np.array([[0.0],[0.0],[1.0]])
|
|
C = np.array([[1.0, 0.0, 0.0]])
|
|
D = np.array([[0.0]])
|
|
with suppress_warnings() as sup:
|
|
sup.filter(BadCoefficients)
|
|
system = lti(A, B, C, D)
|
|
w, H = freqresp(system, n=100)
|
|
s = w * 1j
|
|
expected = (1.0 / (1.0 + 2*s + 2*s**2 + s**3))
|
|
assert_almost_equal(H.real, expected.real)
|
|
assert_almost_equal(H.imag, expected.imag)
|
|
|
|
def test_from_zpk(self):
|
|
# 4th order low-pass filter: H(s) = 1 / (s + 1)
|
|
system = lti([],[-1]*4,[1])
|
|
w = [0.1, 1, 10, 100]
|
|
w, H = freqresp(system, w=w)
|
|
s = w * 1j
|
|
expected = 1 / (s + 1)**4
|
|
assert_almost_equal(H.real, expected.real)
|
|
assert_almost_equal(H.imag, expected.imag)
|