@pytest.fixture

def tsys(self):

class TSys:

pass

T = TSys()

"""Return some test systems"""

# Create a single input/single output linear system

T.siso_linsys = ct.StateSpace(

[[-1, 1], [0, -2]], [[0], [1]], [[1, 0]], [[0]])

# Create a multi input/multi output linear system

T.mimo_linsys1 = ct.StateSpace(

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

[[1, 0], [0, 1]], np.zeros((2, 2)))

# Create a multi input/multi output linear system

T.mimo_linsys2 = ct.StateSpace(

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

[[1, 0], [0, 1]], np.zeros((2, 2)))

# Create a static gain linear system

T.staticgain = ct.StateSpace([], [], [], 1)

# Create simulation parameters

T.T = np.linspace(0, 10, 100)

T.U = np.sin(T.T)

T.X0 = [0, 0]

return T

def test_linear_iosys(self, tsys):

# Create an input/output system from the linear system

linsys = tsys.siso_linsys

iosys = ct.StateSpace(linsys).copy()

# Make sure that the right hand side matches linear system

for x, u in (([0, 0], 0), ([1, 0], 0), ([0, 1], 0), ([0, 0], 1)):

np.testing.assert_array_almost_equal(

iosys._rhs(0, x, u),

linsys.A @ np.array(x) + linsys.B @ np.array(u, ndmin=1))

# Make sure that simulations also line up

T, U, X0 = tsys.T, tsys.U, tsys.X0

lti_t, lti_y = ct.forced_response(linsys, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys, T, U, X0)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y, atol=0.002, rtol=0.)

# Make sure that a static linear system has dt=None

# and otherwise dt is as specified

assert ct.StateSpace(tsys.staticgain).dt is None

assert ct.StateSpace(tsys.staticgain, dt=.1).dt == .1

def test_tf2io(self, tsys):

# Create a transfer function from the state space system

linsys = tsys.siso_linsys

tfsys = ct.ss2tf(linsys)

with pytest.warns(FutureWarning, match="use tf2ss"):

iosys = ct.tf2io(tfsys)

# Verify correctness via simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

lti_t, lti_y = ct.forced_response(linsys, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys, T, U, X0)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y, atol=0.002, rtol=0.)

# Make sure that non-proper transfer functions generate an error

tfsys = ct.tf('s')

with pytest.raises(ValueError):

with pytest.warns(FutureWarning, match="use tf2ss"):

iosys=ct.tf2io(tfsys)

def test_ss2io(self, tsys):

# Create an input/output system from the linear system

linsys = tsys.siso_linsys

with pytest.warns(FutureWarning, match="use ss"):

iosys = ct.ss2io(linsys)

np.testing.assert_allclose(linsys.A, iosys.A)

np.testing.assert_allclose(linsys.B, iosys.B)

np.testing.assert_allclose(linsys.C, iosys.C)

np.testing.assert_allclose(linsys.D, iosys.D)

# Try adding names to things

with pytest.warns(FutureWarning, match="use ss"):

iosys_named = ct.ss2io(linsys, inputs='u', outputs='y',

states=['x1', 'x2'], name='iosys_named')

assert iosys_named.find_input('u') == 0

assert iosys_named.find_input('x') is None

assert iosys_named.find_output('y') == 0

assert iosys_named.find_output('u') is None

assert iosys_named.find_state('x0') is None

assert iosys_named.find_state('x1') == 0

assert iosys_named.find_state('x2') == 1

np.testing.assert_allclose(linsys.A, iosys_named.A)

np.testing.assert_allclose(linsys.B, iosys_named.B)

np.testing.assert_allclose(linsys.C, iosys_named.C)

np.testing.assert_allclose(linsys.D, iosys_named.D)

def test_sstf_rename(self):

# Create a state space system

sys = ct.rss(4, 1, 1)

sys_ss = ct.ss(sys, inputs=['u1'], outputs=['y1'])

assert sys_ss.input_labels == ['u1']

assert sys_ss.output_labels == ['y1']

assert sys_ss.name == sys.name

# Convert to transfer function with renaming

sys_tf = ct.tf(sys, inputs=['a'], outputs=['c'])

assert sys_tf.input_labels == ['a']

assert sys_tf.output_labels == ['c']

assert sys_tf.name != sys_ss.name

def test_iosys_unspecified(self, tsys):

"""System with unspecified inputs and outputs"""

sys = ct.NonlinearIOSystem(secord_update, secord_output)

np.testing.assert_raises(TypeError, sys.__mul__, sys)

def test_iosys_print(self, tsys, capsys):

"""Make sure we can print various types of I/O systems"""

# Send the output to /dev/null

# Simple I/O system

iosys = ct.ss(tsys.siso_linsys)

print(iosys)

# I/O system without ninputs, noutputs

ios_unspecified = ct.NonlinearIOSystem(secord_update, secord_output)

print(ios_unspecified)

# I/O system with derived inputs and outputs

ios_linearized = ct.linearize(ios_unspecified, [0, 0], [0])

print(ios_linearized)

@pytest.mark.parametrize("ss", [ct.NonlinearIOSystem, ct.ss])

def test_nonlinear_iosys(self, tsys, ss):

# Create a simple nonlinear I/O system

nlsys = ct.NonlinearIOSystem(predprey)

T = tsys.T

# Start by simulating from an equilibrium point

X0 = [0, 0]

ios_t, ios_y = ct.input_output_response(nlsys, T, 0, X0)

np.testing.assert_array_almost_equal(ios_y, np.zeros(np.shape(ios_y)))

# Now simulate from a nonzero point

X0 = [0.5, 0.5]

ios_t, ios_y = ct.input_output_response(nlsys, T, 0, X0)

#

# Simulate a linear function as a nonlinear function and compare

#

# Create a single input/single output linear system

linsys = tsys.siso_linsys

# Create a nonlinear system with the same dynamics

nlupd = lambda t, x, u, params: \

np.reshape(linsys.A @ np.reshape(x, (-1, 1))

+ linsys.B @ np.reshape(u, (-1, 1)),

(-1,))

nlout = lambda t, x, u, params: \

np.reshape(linsys.C @ np.reshape(x, (-1, 1))

+ linsys.D @ np.reshape(u, (-1, 1)),

(-1,))

nlsys = ct.NonlinearIOSystem(nlupd, nlout, inputs=1, outputs=1)

# Make sure that simulations also line up

T, U, X0 = tsys.T, tsys.U, tsys.X0

lti_t, lti_y = ct.forced_response(linsys, T, U, X0)

ios_t, ios_y = ct.input_output_response(nlsys, T, U, X0)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.)

@pytest.fixture

def kincar(self):

# Create a simple nonlinear system to check (kinematic car)

def kincar_update(t, x, u, params):

return np.array([np.cos(x[2]) * u[0], np.sin(x[2]) * u[0], u[1]])

def kincar_output(t, x, u, params):

return np.array([x[0], x[1]])

return ct.NonlinearIOSystem(

kincar_update, kincar_output,

inputs = ['v', 'phi'],

outputs = ['x', 'y'],

states = ['x', 'y', 'theta'])

def test_linearize(self, tsys, kincar):

# Create a single input/single output linear system

linsys = tsys.siso_linsys

iosys = ct.StateSpace(linsys)

# Linearize it and make sure we get back what we started with

linearized = iosys.linearize([0, 0], 0)

np.testing.assert_array_almost_equal(linsys.A, linearized.A)

np.testing.assert_array_almost_equal(linsys.B, linearized.B)

np.testing.assert_array_almost_equal(linsys.C, linearized.C)

np.testing.assert_array_almost_equal(linsys.D, linearized.D)

# Create a simple nonlinear system to check (kinematic car)

iosys = kincar

linearized = iosys.linearize([0, 0, 0], [0, 0])

np.testing.assert_array_almost_equal(linearized.A, np.zeros((3,3)))

np.testing.assert_array_almost_equal(

linearized.B, [[1, 0], [0, 0], [0, 1]])

np.testing.assert_array_almost_equal(

linearized.C, [[1, 0, 0], [0, 1, 0]])

np.testing.assert_array_almost_equal(linearized.D, np.zeros((2,2)))

# Pass fewer than the required elements

padded = iosys.linearize([0, 0], np.array([0]))

assert padded.nstates == linearized.nstates

assert padded.ninputs == linearized.ninputs

# Check for warning if last element before padding is nonzero

with pytest.warns(UserWarning, match="x0 too short; padding"):

padded = iosys.linearize([0, 1], np.array([0]))

@pytest.mark.usefixtures("editsdefaults")

def test_linearize_named_signals(self, kincar):

# Full form of the call

linearized = kincar.linearize(

[0, 0, 0], [0, 0], copy_names=True, name='linearized')

assert linearized.name == 'linearized'

assert linearized.find_input('v') == 0

assert linearized.find_input('phi') == 1

assert linearized.find_output('x') == 0

assert linearized.find_output('y') == 1

assert linearized.find_state('x') == 0

assert linearized.find_state('y') == 1

assert linearized.find_state('theta') == 2

# If we copy signal names w/out a system name, append '$linearized'

linearized = kincar.linearize([0, 0, 0], [0, 0], copy_names=True)

assert linearized.name == kincar.name + '$linearized'

# If copy is False, signal names should not be copied

lin_nocopy = kincar.linearize(0, 0, copy_names=False)

assert lin_nocopy.find_input('v') is None

assert lin_nocopy.find_output('x') is None

assert lin_nocopy.find_state('x') is None

# if signal names are provided, they should override those of kincar

linearized_newnames = kincar.linearize(

[0, 0, 0], [0, 0], name='linearized',

copy_names=True, inputs=['v2', 'phi2'], outputs=['x2','y2'])

assert linearized_newnames.name == 'linearized'

assert linearized_newnames.find_input('v2') == 0

assert linearized_newnames.find_input('phi2') == 1

assert linearized_newnames.find_input('v') is None

assert linearized_newnames.find_input('phi') is None

assert linearized_newnames.find_output('x2') == 0

assert linearized_newnames.find_output('y2') == 1

assert linearized_newnames.find_output('x') is None

assert linearized_newnames.find_output('y') is None

# if system name is provided but copy_names is false, override name

linearized_newsysname = kincar.linearize(

[0, 0, 0], [0, 0], name='newname', copy_names=False)

assert linearized_newsysname.name == 'newname'

# Test legacy version as well

with pytest.warns(UserWarning, match="NumPy matrix class no longer"):

ct.use_legacy_defaults('0.8.4')

linearized = kincar.linearize([0, 0, 0], [0, 0], copy_names=True)

assert linearized.name == kincar.name + '_linearized'

def test_connect(self, tsys):

# Define a couple of (linear) systems to interconnection

linsys1 = tsys.siso_linsys

iosys1 = ct.StateSpace(linsys1, name='iosys1')

linsys2 = tsys.siso_linsys

iosys2 = ct.StateSpace(linsys2, name='iosys2')

# Connect systems in different ways and compare to StateSpace

linsys_series = linsys2 * linsys1

iosys_series = ct.InterconnectedSystem(

[iosys1, iosys2], # systems

[[1, 0]], # interconnection (series)

0, # input = first system

1 # output = second system

)

# Run a simulation and compare to linear response

T, U = tsys.T, tsys.U

X0 = np.concatenate((tsys.X0, tsys.X0))

ios_t, ios_y, ios_x = ct.input_output_response(

iosys_series, T, U, X0, return_x=True)

lti_t, lti_y = ct.forced_response(linsys_series, T, U, X0)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.)

# Connect systems with different timebases

linsys2c = tsys.siso_linsys

linsys2c.dt = 0 # Reset the timebase

iosys2c = ct.StateSpace(linsys2c)

iosys_series = ct.InterconnectedSystem(

[iosys1, iosys2c], # systems

[[1, 0]], # interconnection (series)

0, # input = first system

1 # output = second system

)

assert ct.isctime(iosys_series, strict=True)

ios_t, ios_y, ios_x = ct.input_output_response(

iosys_series, T, U, X0, return_x=True)

lti_t, lti_y = ct.forced_response(linsys_series, T, U, X0)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.)

# Feedback interconnection

linsys_feedback = ct.feedback(linsys1, linsys2)

iosys_feedback = ct.InterconnectedSystem(

[iosys1, iosys2], # systems

[[1, 0], # input of sys2 = output of sys1

[0, (1, 0, -1)]], # input of sys1 = -output of sys2

0, # input = first system

0 # output = first system

)

ios_t, ios_y, ios_x = ct.input_output_response(

iosys_feedback, T, U, X0, return_x=True)

lti_t, lti_y = ct.forced_response(linsys_feedback, T, U, X0)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.)

@pytest.mark.parametrize(

def test_connect_spec_variants(self, tsys, connections, inplist, outlist):

# Define a couple of (linear) systems to interconnection

linsys1 = tsys.siso_linsys

iosys1 = ct.StateSpace(linsys1, name="sys1")

linsys2 = tsys.siso_linsys

iosys2 = ct.StateSpace(linsys2, name="sys2")

# Simple series connection

linsys_series = linsys2 * linsys1

# Create a simulation run to compare against

T, U = tsys.T, tsys.U

X0 = np.concatenate((tsys.X0, tsys.X0))

lti_t, lti_y, lti_x = ct.forced_response(

linsys_series, T, U, X0, return_x=True)

# Create the input/output system with different parameter variations

iosys_series = ct.InterconnectedSystem(

[iosys1, iosys2], connections, inplist, outlist)

ios_t, ios_y, ios_x = ct.input_output_response(

iosys_series, T, U, X0, return_x=True)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y, atol=0.002, rtol=0.)

@pytest.mark.parametrize(

def test_connect_spec_warnings(self, tsys, connections, inplist, outlist):

# Define a couple of (linear) systems to interconnection

linsys1 = tsys.siso_linsys

iosys1 = ct.StateSpace(linsys1, name="sys1")

linsys2 = tsys.siso_linsys

iosys2 = ct.StateSpace(linsys2, name="sys2")

# Simple series connection

linsys_series = linsys2 * linsys1

# Create a simulation run to compare against

T, U = tsys.T, tsys.U

X0 = np.concatenate((tsys.X0, tsys.X0))

lti_t, lti_y, lti_x = ct.forced_response(

linsys_series, T, U, X0, return_x=True)

# Set up multiple gainst and make sure a warning is generated

with pytest.warns(UserWarning, match="multiple.*combining"):

iosys_series = ct.InterconnectedSystem(

[iosys1, iosys2], connections, inplist, outlist)

ios_t, ios_y, ios_x = ct.input_output_response(

iosys_series, T, U, X0, return_x=True)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_allclose(lti_y, ios_y, atol=0.002, rtol=0.)

def test_static_nonlinearity(self, tsys):

# Linear dynamical system

linsys = tsys.siso_linsys

ioslin = ct.StateSpace(linsys)

# Nonlinear saturation

sat = lambda u: u if abs(u) < 1 else np.sign(u)

sat_output = lambda t, x, u, params: sat(u)

nlsat = ct.NonlinearIOSystem(None, sat_output, inputs=1, outputs=1)

# Set up parameters for simulation

T, U, X0 = tsys.T, 2 * tsys.U, tsys.X0

Usat = np.vectorize(sat)(U)

# Make sure saturation works properly by comparing linear system with

# saturated input to nonlinear system with saturation composition

lti_t, lti_y, lti_x = ct.forced_response(

linsys, T, Usat, X0, return_x=True)

ios_t, ios_y, ios_x = ct.input_output_response(

ioslin * nlsat, T, U, X0, return_x=True)

np.testing.assert_array_almost_equal(lti_t, ios_t)

np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=2)

@pytest.mark.filterwarnings("ignore:Duplicate name::control.iosys")

def test_algebraic_loop(self, tsys):

# Create some linear and nonlinear systems to play with

linsys = tsys.siso_linsys

lnios = ct.StateSpace(linsys)

nlios = ct.NonlinearIOSystem(None, \

lambda t, x, u, params: u*u, inputs=1, outputs=1)

nlios1 = nlios.copy(name='nlios1')

nlios2 = nlios.copy(name='nlios2')

# Set up parameters for simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

# Single nonlinear system - no states

ios_t, ios_y = ct.input_output_response(nlios, T, U)

np.testing.assert_array_almost_equal(ios_y, U*U, decimal=3)

# Composed nonlinear system (series)

ios_t, ios_y = ct.input_output_response(nlios1 * nlios2, T, U)

np.testing.assert_array_almost_equal(ios_y, U**4, decimal=3)

# Composed nonlinear system (parallel)

ios_t, ios_y = ct.input_output_response(nlios1 + nlios2, T, U)

np.testing.assert_array_almost_equal(ios_y, 2*U**2, decimal=3)

# Nonlinear system composed with LTI system (series) -- with states

ios_t, ios_y = ct.input_output_response(

nlios * lnios * nlios, T, U, X0)

lti_t, lti_y = ct.forced_response(linsys, T, U*U, X0)

np.testing.assert_array_almost_equal(ios_y, lti_y*lti_y, decimal=3)

# Nonlinear system in feeback loop with LTI system

iosys = ct.InterconnectedSystem(

[lnios, nlios], # linear system w/ nonlinear feedback

[[1], # feedback interconnection (sig to 0)

[0, (1, 0, -1)]],

0, # input to linear system

0 # output from linear system

)

ios_t, ios_y = ct.input_output_response(iosys, T, U, X0)

# No easy way to test the result

# Algebraic loop from static nonlinear system in feedback

# (error will be due to no states)

iosys = ct.InterconnectedSystem(

[nlios1, nlios2], # two copies of a static nonlinear system

[[0, 1], # feedback interconnection

[1, (0, 0, -1)]],

0, 0

)

args = (iosys, T, U)

with pytest.raises(RuntimeError):

ct.input_output_response(*args)

# Algebraic loop due to feedthrough term

linsys = ct.StateSpace(

[[-1, 1], [0, -2]], [[0], [1]], [[1, 0]], [[1]])

lnios = ct.StateSpace(linsys)

iosys = ct.InterconnectedSystem(

[nlios, lnios], # linear system w/ nonlinear feedback

[[0, 1], # feedback interconnection

[1, (0, 0, -1)]],

0, 0

)

args = (iosys, T, U, X0)

# ios_t, ios_y = ct.input_output_response(iosys, T, U, X0)

with pytest.raises(RuntimeError):

ct.input_output_response(*args)

def test_summer(self, tsys):

# Construct a MIMO system for testing

linsys = tsys.mimo_linsys1

linio1 = ct.StateSpace(linsys, name='linio1')

linio2 = ct.StateSpace(linsys, name='linio2')

linsys_parallel = linsys + linsys

iosys_parallel = linio1 + linio2

# Set up parameters for simulation

T = tsys.T

U = [np.sin(T), np.cos(T)]

X0 = 0

lin_t, lin_y = ct.forced_response(linsys_parallel, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_parallel, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

def test_rmul(self, tsys):

# Test right multiplication

# Note: this is also tested in types_conversion_test.py

# Set up parameters for simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

# Linear system with input and output nonlinearities

# Also creates a nested interconnected system

ioslin = ct.StateSpace(tsys.siso_linsys)

nlios = ct.NonlinearIOSystem(None, \

lambda t, x, u, params: u*u, inputs=1, outputs=1)

sys1 = nlios * ioslin

sys2 = sys1 * nlios

# Make sure we got the right thing (via simulation comparison)

ios_t, ios_y = ct.input_output_response(sys2, T, U, X0)

lti_t, lti_y = ct.forced_response(ioslin, T, U*U, X0)

np.testing.assert_array_almost_equal(ios_y, lti_y*lti_y, decimal=3)

def test_neg(self, tsys):

"""Test negation of a system"""

# Set up parameters for simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

# Static nonlinear system

nlios = ct.NonlinearIOSystem(None, \

lambda t, x, u, params: u*u, inputs=1, outputs=1)

ios_t, ios_y = ct.input_output_response(-nlios, T, U)

np.testing.assert_array_almost_equal(ios_y, -U*U, decimal=3)

# Linear system with input nonlinearity

# Also creates a nested interconnected system

ioslin = ct.StateSpace(tsys.siso_linsys)

sys = (ioslin) * (-nlios)

# Make sure we got the right thing (via simulation comparison)

ios_t, ios_y = ct.input_output_response(sys, T, U, X0)

lti_t, lti_y = ct.forced_response(ioslin, T, U*U, X0)

np.testing.assert_array_almost_equal(ios_y, -lti_y, decimal=3)

def test_feedback(self, tsys):

# Set up parameters for simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

# Linear system with constant feedback (via "nonlinear" mapping)

ioslin = ct.StateSpace(tsys.siso_linsys)

nlios = ct.NonlinearIOSystem(None, \

lambda t, x, u, params: u, inputs=1, outputs=1)

iosys = ct.feedback(ioslin, nlios)

linsys = ct.feedback(tsys.siso_linsys, 1)

ios_t, ios_y = ct.input_output_response(iosys, T, U, X0)

lti_t, lti_y = ct.forced_response(linsys, T, U, X0)

np.testing.assert_allclose(ios_y, lti_y,atol=0.002,rtol=0.)

def test_bdalg_functions(self, tsys):

"""Test block diagram functions algebra on I/O systems"""

# Set up parameters for simulation

T = tsys.T

U = [np.sin(T), np.cos(T)]

X0 = 0

# Set up systems to be composed

linsys1 = tsys.mimo_linsys1

linio1 = ct.StateSpace(linsys1)

linsys2 = tsys.mimo_linsys2

linio2 = ct.StateSpace(linsys2)

# Series interconnection

linsys_series = ct.series(linsys1, linsys2)

iosys_series = ct.series(linio1, linio2)

lin_t, lin_y = ct.forced_response(linsys_series, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_series, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Make sure that systems don't commute

linsys_series = ct.series(linsys2, linsys1)

lin_t, lin_y = ct.forced_response(linsys_series, T, U, X0)

assert not (np.abs(lin_y - ios_y) < 1e-3).all()

# Parallel interconnection

linsys_parallel = ct.parallel(linsys1, linsys2)

iosys_parallel = ct.parallel(linio1, linio2)

lin_t, lin_y = ct.forced_response(linsys_parallel, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_parallel, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Negation

linsys_negate = ct.negate(linsys1)

iosys_negate = ct.negate(linio1)

lin_t, lin_y = ct.forced_response(linsys_negate, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_negate, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Feedback interconnection

linsys_feedback = ct.feedback(linsys1, linsys2)

iosys_feedback = ct.feedback(linio1, linio2)

lin_t, lin_y = ct.forced_response(linsys_feedback, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_feedback, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

def test_algebraic_functions(self, tsys):

"""Test algebraic operations on I/O systems"""

# Set up parameters for simulation

T = tsys.T

U = [np.sin(T), np.cos(T)]

X0 = 0

# Set up systems to be composed

linsys1 = tsys.mimo_linsys1

linio1 = ct.StateSpace(linsys1)

linsys2 = tsys.mimo_linsys2

linio2 = ct.StateSpace(linsys2)

# Multiplication

linsys_mul = linsys2 * linsys1

iosys_mul = linio2 * linio1

lin_t, lin_y = ct.forced_response(linsys_mul, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_mul, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Make sure that systems don't commute

linsys_mul = linsys1 * linsys2

lin_t, lin_y = ct.forced_response(linsys_mul, T, U, X0)

assert not (np.abs(lin_y - ios_y) < 1e-3).all()

# Addition

linsys_add = linsys1 + linsys2

iosys_add = linio1 + linio2

lin_t, lin_y = ct.forced_response(linsys_add, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_add, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Subtraction

linsys_sub = linsys1 - linsys2

iosys_sub = linio1 - linio2

lin_t, lin_y = ct.forced_response(linsys_sub, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_sub, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Make sure that systems don't commute

linsys_sub = linsys2 - linsys1

lin_t, lin_y = ct.forced_response(linsys_sub, T, U, X0)

assert not (np.abs(lin_y - ios_y) < 1e-3).all()

# Negation

linsys_negate = -linsys1

iosys_negate = -linio1

lin_t, lin_y = ct.forced_response(linsys_negate, T, U, X0)

ios_t, ios_y = ct.input_output_response(iosys_negate, T, U, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

def test_nonsquare_bdalg(self, tsys):

# Set up parameters for simulation

T = tsys.T

U2 = [np.sin(T), np.cos(T)]

U3 = [np.sin(T), np.cos(T), T]

X0 = 0

# Set up systems to be composed

linsys_2i3o = ct.StateSpace(

[[-1, 1, 0], [0, -2, 0], [0, 0, -3]], [[1, 0], [0, 1], [1, 1]],

[[1, 0, 0], [0, 1, 0], [0, 0, 1]], np.zeros((3, 2)))

iosys_2i3o = ct.StateSpace(linsys_2i3o)

linsys_3i2o = ct.StateSpace(

[[-1, 1, 0], [0, -2, 0], [0, 0, -3]],

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

[[1, 0, 1], [0, 1, -1]], np.zeros((2, 3)))

iosys_3i2o = ct.StateSpace(linsys_3i2o)

# Multiplication

linsys_multiply = linsys_3i2o * linsys_2i3o

iosys_multiply = iosys_3i2o * iosys_2i3o

lin_t, lin_y = ct.forced_response(linsys_multiply, T, U2, X0)

ios_t, ios_y = ct.input_output_response(iosys_multiply, T, U2, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

linsys_multiply = linsys_2i3o * linsys_3i2o

iosys_multiply = iosys_2i3o * iosys_3i2o

lin_t, lin_y = ct.forced_response(linsys_multiply, T, U3, X0)

ios_t, ios_y = ct.input_output_response(iosys_multiply, T, U3, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Right multiplication

iosys_multiply = iosys_2i3o * iosys_3i2o

ios_t, ios_y = ct.input_output_response(iosys_multiply, T, U3, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Feedback

linsys_multiply = ct.feedback(linsys_3i2o, linsys_2i3o)

iosys_multiply = iosys_3i2o.feedback(iosys_2i3o)

lin_t, lin_y = ct.forced_response(linsys_multiply, T, U3, X0)

ios_t, ios_y = ct.input_output_response(iosys_multiply, T, U3, X0)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Mismatch should generate exception

args = (iosys_3i2o, iosys_3i2o)

with pytest.raises(ValueError):

ct.series(*args)

def test_discrete(self, tsys):

"""Test discrete-time functionality"""

# Create some linear and nonlinear systems to play with

linsys = ct.StateSpace(

[[-1, 1], [0, -2]], [[0], [1]], [[1, 0]], [[0]], True)

lnios = ct.StateSpace(linsys)

# Set up parameters for simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

# Simulate and compare to LTI output

ios_t, ios_y = ct.input_output_response(lnios, T, U, X0)

lin_t, lin_y = ct.forced_response(linsys, T, U, X0)

np.testing.assert_allclose(ios_t, lin_t,atol=0.002,rtol=0.)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

# Test MIMO system, converted to discrete time

linsys = ct.StateSpace(tsys.mimo_linsys1)

linsys.dt = tsys.T[1] - tsys.T[0]

lnios = ct.StateSpace(linsys)

# Set up parameters for simulation

T = tsys.T

U = [np.sin(T), np.cos(T)]

X0 = 0

# Simulate and compare to LTI output

ios_t, ios_y = ct.input_output_response(lnios, T, U, X0)

lin_t, lin_y = ct.forced_response(linsys, T, U, X0)

np.testing.assert_allclose(ios_t, lin_t,atol=0.002,rtol=0.)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

def test_discrete_iosys(self, tsys):

"""Create a discrete-time system from scratch"""

linsys = ct.StateSpace(

[[-1, 1], [0, -2]], [[0], [1]], [[1, 0]], [[0]], True)

# Create nonlinear version of the same system

def nlsys_update(t, x, u, params):

A, B = params['A'], params['B']

return A @ x + B @ u

def nlsys_output(t, x, u, params):

C = params['C']

return C @ x

nlsys = ct.NonlinearIOSystem(

nlsys_update, nlsys_output, inputs=1, outputs=1, states=2, dt=True)

# Set up parameters for simulation

T, U, X0 = tsys.T, tsys.U, tsys.X0

# Simulate and compare to LTI output

ios_t, ios_y = ct.input_output_response(

nlsys, T, U, X0,

params={'A': linsys.A, 'B': linsys.B, 'C': linsys.C})

lin_t, lin_y = ct.forced_response(linsys, T, U, X0)

np.testing.assert_allclose(ios_t, lin_t,atol=0.002,rtol=0.)

np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.)

def test_find_eqpts_dfan(self, tsys):

"""Test find_eqpt function on dfan example"""

# Simple equilibrium point with no inputs

nlsys = ct.NonlinearIOSystem(predprey)

xeq, ueq, result = ct.find_eqpt(

nlsys, [1.6, 1.2], None, return_result=True)

assert result.success

np.testing.assert_array_almost_equal(xeq, [1.64705879, 1.17923874])

np.testing.assert_array_almost_equal(

nlsys._rhs(0, xeq, ueq), np.zeros((2,)))

# Ducted fan dynamics with output = velocity

nlsys = ct.NonlinearIOSystem(pvtol, lambda t, x, u, params: x[0:2])

# Make sure the origin is a fixed point

xeq, ueq, result = ct.find_eqpt(

nlsys, [0, 0, 0, 0], [0, 4*9.8], return_result=True)

assert result.success

np.testing.assert_array_almost_equal(

nlsys._rhs(0, xeq, ueq), np.zeros((4,)))

np.testing.assert_array_almost_equal(xeq, [0, 0, 0, 0])

# Use a small lateral force to cause motion

xeq, ueq, result = ct.find_eqpt(

nlsys, [0, 0, 0, 0], [0.01, 4*9.8], return_result=True)

assert result.success

np.testing.assert_array_almost_equal(

nlsys._rhs(0, xeq, ueq), np.zeros((4,)), decimal=5)

# Equilibrium point with fixed output

xeq, ueq, result = ct.find_eqpt(

nlsys, [0, 0, 0, 0], [0.01, 4*9.8],

y0=[0.1, 0.1], return_result=True)

assert result.success

np.testing.assert_array_almost_equal(

nlsys._out(0, xeq, ueq), [0.1, 0.1], decimal=5)

np.testing.assert_array_almost_equal(

nlsys._rhs(0, xeq, ueq), np.zeros((4,)), decimal=5)

# Specify outputs to constrain (replicate previous)

xeq, ueq, result = ct.find_eqpt(

nlsys, [0, 0, 0, 0], [0.01, 4*9.8], y0=[0.1, 0.1],

iy = [0, 1], return_result=True)

assert result.success

np.testing.assert_array_almost_equal(

nlsys._out(0, xeq, ueq), [0.1, 0.1], decimal=5)

np.testing.assert_array_almost_equal(

nlsys._rhs(0, xeq, ueq), np.zeros((4,)), decimal=5)

# Specify inputs to constrain (replicate previous), w/ no result

xeq, ueq = ct.find_eqpt(

nlsys, [0, 0, 0, 0], [0.01, 4*9.8], y0=[0.1, 0.1], iu = [])

np.testing.assert_array_almost_equal(

nlsys._out(0, xeq, ueq), [0.1, 0.1], decimal=5)

np.testing.assert_array_almost_equal(

nlsys._rhs(0, xeq, ueq), np.zeros((4,)), decimal=5)

# Now solve the problem with the original PVTOL variables

# Constrain the output angle and x velocity

nlsys_full = ct.NonlinearIOSystem(pvtol_full, None)

xeq, ueq, result = ct.find_eqpt(

nlsys_full, [0, 0, 0, 0, 0, 0], [0.01, 4*9.8],

y0=[0, 0, 0.1, 0.1, 0, 0], iy = [2, 3],

idx=[2, 3, 4, 5], ix=[0, 1], return_result=True)

assert result.success

np.testing.assert_array_almost_equal(