diff --git a/control/statesp.py b/control/statesp.py
index 80da2a5f8..1c220630a 100644
--- a/control/statesp.py
+++ b/control/statesp.py
@@ -122,34 +122,35 @@ def __init__(self, *args):
else:
raise ValueError("Needs 1 or 4 arguments; received %i." % len(args))
- # Here we're going to convert inputs to matrices, if the user gave a
- # non-matrix type.
- #! TODO: [A, B, C, D] = map(matrix, [A, B, C, D])?
- matrices = [A, B, C, D]
- for i in range(len(matrices)):
- # Convert to matrix first, if necessary.
- matrices[i] = matrix(matrices[i])
- [A, B, C, D] = matrices
-
- LTI.__init__(self, B.shape[1], C.shape[0], dt)
+ A, B, C, D = [matrix(M) for M in (A, B, C, D)]
+
+ # TODO: use super here?
+ LTI.__init__(self, inputs=D.shape[1], outputs=D.shape[0], dt=dt)
self.A = A
self.B = B
self.C = C
self.D = D
- self.states = A.shape[0]
+ self.states = A.shape[1]
+
+ if 0 == self.states:
+ # static gain
+ # matrix's default "empty" shape is 1x0
+ A.shape = (0,0)
+ B.shape = (0,self.inputs)
+ C.shape = (self.outputs,0)
# Check that the matrix sizes are consistent.
- if self.states != A.shape[1]:
+ if self.states != A.shape[0]:
raise ValueError("A must be square.")
if self.states != B.shape[0]:
- raise ValueError("B must have the same row size as A.")
+ raise ValueError("A and B must have the same number of rows.")
if self.states != C.shape[1]:
- raise ValueError("C must have the same column size as A.")
- if self.inputs != D.shape[1]:
- raise ValueError("D must have the same column size as B.")
- if self.outputs != D.shape[0]:
- raise ValueError("D must have the same row size as C.")
+ raise ValueError("A and C must have the same number of columns.")
+ if self.inputs != B.shape[1]:
+ raise ValueError("B and D must have the same number of columns.")
+ if self.outputs != C.shape[0]:
+ raise ValueError("C and D must have the same number of rows.")
# Check for states that don't do anything, and remove them.
self._remove_useless_states()
@@ -179,17 +180,10 @@ def _remove_useless_states(self):
useless.append(i)
# Remove the useless states.
- if all(useless == range(self.states)):
- # All the states were useless.
- self.A = zeros((1, 1))
- self.B = zeros((1, self.inputs))
- self.C = zeros((self.outputs, 1))
- else:
- # A more typical scenario.
- self.A = delete(self.A, useless, 0)
- self.A = delete(self.A, useless, 1)
- self.B = delete(self.B, useless, 0)
- self.C = delete(self.C, useless, 1)
+ self.A = delete(self.A, useless, 0)
+ self.A = delete(self.A, useless, 1)
+ self.B = delete(self.B, useless, 0)
+ self.C = delete(self.C, useless, 1)
self.states = self.A.shape[0]
self.inputs = self.B.shape[1]
@@ -405,7 +399,7 @@ def freqresp(self, omega):
def pole(self):
"""Compute the poles of a state space system."""
- return eigvals(self.A)
+ return eigvals(self.A) if self.states else np.array([])
def zero(self):
"""Compute the zeros of a state space system."""
@@ -477,18 +471,22 @@ def feedback(self, other=1, sign=-1):
def minreal(self, tol=0.0):
"""Calculate a minimal realization, removes unobservable and
uncontrollable states"""
- try:
- from slycot import tb01pd
- B = empty((self.states, max(self.inputs, self.outputs)))
- B[:,:self.inputs] = self.B
- C = empty((max(self.outputs, self.inputs), self.states))
- C[:self.outputs,:] = self.C
- A, B, C, nr = tb01pd(self.states, self.inputs, self.outputs,
- self.A, B, C, tol=tol)
- return StateSpace(A[:nr,:nr], B[:nr,:self.inputs],
- C[:self.outputs,:nr], self.D)
- except ImportError:
- raise TypeError("minreal requires slycot tb01pd")
+ if self.states:
+ try:
+ from slycot import tb01pd
+ B = empty((self.states, max(self.inputs, self.outputs)))
+ B[:,:self.inputs] = self.B
+ C = empty((max(self.outputs, self.inputs), self.states))
+ C[:self.outputs,:] = self.C
+ A, B, C, nr = tb01pd(self.states, self.inputs, self.outputs,
+ self.A, B, C, tol=tol)
+ return StateSpace(A[:nr,:nr], B[:nr,:self.inputs],
+ C[:self.outputs,:nr], self.D)
+ except ImportError:
+ raise TypeError("minreal requires slycot tb01pd")
+ else:
+ return StateSpace(self)
+
# TODO: add discrete time check
def returnScipySignalLTI(self):
diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py
index c19f4f38b..bcb411026 100644
--- a/control/tests/statesp_test.py
+++ b/control/tests/statesp_test.py
@@ -5,7 +5,8 @@
import unittest
import numpy as np
-from scipy.linalg import eigvals
+from numpy.linalg import solve
+from scipy.linalg import eigvals, block_diag
from control import matlab
from control.statesp import StateSpace, _convertToStateSpace
from control.xferfcn import TransferFunction
@@ -235,6 +236,79 @@ def test_dcgain(self):
sys3 = StateSpace(0., 1., 1., 0.)
np.testing.assert_equal(sys3.dcgain(), np.nan)
+
+ def test_scalarStaticGain(self):
+ """Regression: can we create a scalar static gain?"""
+ g1=StateSpace([],[],[],[2])
+ g2=StateSpace([],[],[],[3])
+
+ # make sure StateSpace internals, specifically ABC matrix
+ # sizes, are OK for LTI operations
+ g3 = g1*g2
+ self.assertEqual(6, g3.D[0,0])
+ g4 = g1+g2
+ self.assertEqual(5, g4.D[0,0])
+ g5 = g1.feedback(g2)
+ self.assertAlmostEqual(2./7, g5.D[0,0])
+ g6 = g1.append(g2)
+ np.testing.assert_array_equal(np.diag([2,3]),g6.D)
+
+ def test_matrixStaticGain(self):
+ """Regression: can we create matrix static gains?"""
+ d1 = np.matrix([[1,2,3],[4,5,6]])
+ d2 = np.matrix([[7,8],[9,10],[11,12]])
+ g1=StateSpace([],[],[],d1)
+
+ # _remove_useless_states was making A = [[0]]
+ self.assertEqual((0,0), g1.A.shape)
+
+ g2=StateSpace([],[],[],d2)
+ g3=StateSpace([],[],[],d2.T)
+
+ h1 = g1*g2
+ np.testing.assert_array_equal(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)+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)))
+ self.assertEqual((0,0), g1.A.shape)
+ self.assertEqual((0,4), g1.B.shape)
+ self.assertEqual((5,0), g1.C.shape)
+ self.assertEqual((5,4), g1.D.shape)
+ self.assertEqual(0, g1.states)
+
+
+ def test_BadEmptyMatrices(self):
+ """Mismatched ABCD matrices when some are empty"""
+ self.assertRaises(ValueError,StateSpace, [1], [], [], [1])
+ self.assertRaises(ValueError,StateSpace, [1], [1], [], [1])
+ self.assertRaises(ValueError,StateSpace, [1], [], [1], [1])
+ self.assertRaises(ValueError,StateSpace, [], [1], [], [1])
+ self.assertRaises(ValueError,StateSpace, [], [1], [1], [1])
+ self.assertRaises(ValueError,StateSpace, [], [], [1], [1])
+ self.assertRaises(ValueError,StateSpace, [1], [1], [1], [])
+
+
+ def test_minrealStaticGain(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)
+
+
class TestRss(unittest.TestCase):
"""These are tests for the proper functionality of statesp.rss."""
@@ -304,6 +378,12 @@ def testPole(self):
self.assertTrue(abs(z) < 1)
+ def testPoleStatic(self):
+ """Regression: pole() of static gain is empty array"""
+ np.testing.assert_array_equal(np.array([]),
+ StateSpace([],[],[],[[1]]).pole())
+
+
def suite():
return unittest.TestLoader().loadTestsFromTestCase(TestStateSpace)
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy