ninputs = 1 if isinstance(inputs, str) else \

inputs if isinstance(inputs, int) else len(inputs)

sum = ct.summing_junction(

inputs=inputs, output=output, dimension=dimension)

dim = 1 if dimension is None else dimension

np.testing.assert_allclose(sum.A, np.ndarray((0, 0)))

np.testing.assert_allclose(sum.B, np.ndarray((0, ninputs*dim)))

np.testing.assert_allclose(sum.C, np.ndarray((dim, 0)))

# Bad input description

with pytest.raises(ValueError, match="could not parse input"):

ct.summing_junction(np.pi, 'y')

# Bad output description

with pytest.raises(ValueError, match="could not parse output"):

ct.summing_junction('u', np.pi)

# Bad input dimension

with pytest.raises(ValueError, match="unrecognized dimension"):

"""Test the use of implicit connections in interconnect()"""

import random

if dim != 1 and not ct.slycot_check():

pytest.xfail("slycot not installed")

# System definition

P = ct.rss(2, dim, dim, strictly_proper=True, name='P')

# Controller defintion: PI in each input/output pair

kp = ct.tf(np.ones((dim, dim, 1)), np.ones((dim, dim, 1))) \

* random.uniform(1, 10)

ki = random.uniform(1, 10)

num, den = np.zeros((dim, dim, 1)), np.ones((dim, dim, 2))

for i, j in zip(range(dim), range(dim)):

num[i, j] = ki

den[i, j] = np.array([1, 0])

ki = ct.tf(num, den)

C = ct.tf(kp + ki, name='C',

inputs=[f'e[{i}]' for i in range(dim)],

outputs=[f'u[{i}]' for i in range(dim)])

# same but static C2

C2 = ct.tf(kp * random.uniform(1, 10), name='C2',

inputs=[f'e[{i}]' for i in range(dim)],

outputs=[f'u[{i}]' for i in range(dim)])

# Block diagram computation

Tss = ct.feedback(P * C, np.eye(dim))

Tss2 = ct.feedback(P * C2, np.eye(dim))

# Construct the interconnection explicitly

Tio_exp = ct.interconnect(

(C, P),

connections=[['P.u', 'C.u'], ['C.e', '-P.y']],

inplist='C.e', outlist='P.y')

# Compare to bdalg computation

np.testing.assert_almost_equal(Tio_exp.A, Tss.A)

np.testing.assert_almost_equal(Tio_exp.B, Tss.B)

np.testing.assert_almost_equal(Tio_exp.C, Tss.C)

np.testing.assert_almost_equal(Tio_exp.D, Tss.D)

# Construct the interconnection via a summing junction

sumblk = ct.summing_junction(

inputs=['r', '-y'], output='e', dimension=dim, name="sum")

Tio_sum = ct.interconnect(

[C, P, sumblk], inplist=['r'], outlist=['y'], debug=True)

np.testing.assert_almost_equal(Tio_sum.A, Tss.A)

np.testing.assert_almost_equal(Tio_sum.B, Tss.B)

np.testing.assert_almost_equal(Tio_sum.C, Tss.C)

np.testing.assert_almost_equal(Tio_sum.D, Tss.D)

# test whether signal names work for static system C2

Tio_sum2 = ct.interconnect(

[C2, P, sumblk], inplist='r', outlist='y')

np.testing.assert_almost_equal(Tio_sum2.A, Tss2.A)

np.testing.assert_almost_equal(Tio_sum2.B, Tss2.B)

np.testing.assert_almost_equal(Tio_sum2.C, Tss2.C)

np.testing.assert_almost_equal(Tio_sum2.D, Tss2.D)

# Setting connections to False should lead to an empty connection map

empty = ct.interconnect(

[C, P, sumblk], connections=False, inplist=['r'], outlist=['y'])

np.testing.assert_allclose(empty.connect_map, np.zeros((4*dim, 3*dim)))

# Implicit summation across repeated signals (using updated labels)

kp_io = ct.tf(

kp, inputs=dim, input_prefix='e',

outputs=dim, output_prefix='u', name='kp')

ki_io = ct.tf(

ki, inputs=dim, input_prefix='e',

outputs=dim, output_prefix='u', name='ki')

Tio_sum = ct.interconnect(

[kp_io, ki_io, P, sumblk], inplist=['r'], outlist=['y'])

np.testing.assert_almost_equal(Tio_sum.A, Tss.A)

np.testing.assert_almost_equal(Tio_sum.B, Tss.B)

np.testing.assert_almost_equal(Tio_sum.C, Tss.C)

np.testing.assert_almost_equal(Tio_sum.D, Tss.D)

# Make sure that repeated inplist/outlist names work

pi_io = ct.interconnect(

[kp_io, ki_io], inplist=['e'], outlist=['u'])

pi_ss = ct.tf2ss(kp + ki)

np.testing.assert_almost_equal(pi_io.A, pi_ss.A)

np.testing.assert_almost_equal(pi_io.B, pi_ss.B)

np.testing.assert_almost_equal(pi_io.C, pi_ss.C)

np.testing.assert_almost_equal(pi_io.D, pi_ss.D)

# Default input and output lists, along with singular versions

Tio_sum = ct.interconnect(

[kp_io, ki_io, P, sumblk], input='r', output='y', debug=True)

np.testing.assert_almost_equal(Tio_sum.A, Tss.A)

np.testing.assert_almost_equal(Tio_sum.B, Tss.B)

np.testing.assert_almost_equal(Tio_sum.C, Tss.C)

np.testing.assert_almost_equal(Tio_sum.D, Tss.D)

# Signal not found

with pytest.raises(ValueError, match="could not find"):

Tio_sum = ct.interconnect(

(C, P, sumblk), inplist=['x'], outlist=['y'])

with pytest.raises(ValueError, match="could not find"):

Tio_sum = ct.interconnect(

"""Test the examples from the interconnect() docstring"""

# MIMO interconnection (note: use [C, P] instead of [P, C] for state order)

P = ct.StateSpace(

ct.rss(2, 2, 2, strictly_proper=True), name='P')

C = ct.StateSpace(ct.rss(2, 2, 2), name='C')

T = ct.interconnect(

[C, P],

connections = [

['P.u[0]', 'C.y[0]'], ['P.u[1]', 'C.y[1]'],

['C.u[0]', '-P.y[0]'], ['C.u[1]', '-P.y[1]']],

inplist = ['C.u[0]', 'C.u[1]'],

outlist = ['P.y[0]', 'P.y[1]'],

)

T_ss = ct.feedback(P * C, ct.ss([], [], [], np.eye(2)))

np.testing.assert_almost_equal(T.A, T_ss.A)

np.testing.assert_almost_equal(T.B, T_ss.B)

np.testing.assert_almost_equal(T.C, T_ss.C)

np.testing.assert_almost_equal(T.D, T_ss.D)

# Implicit interconnection (note: use [C, P, sumblk] for proper state order)

P = ct.tf(1, [1, 0], inputs='u', outputs='y')

C = ct.tf(10, [1, 1], inputs='e', outputs='u')

sumblk = ct.summing_junction(inputs=['r', '-y'], output='e')

T = ct.interconnect([C, P, sumblk], inplist='r', outlist='y')

T_ss = ct.ss(ct.feedback(P * C, 1))

# Test in a manner that recognizes that recognizes non-unique realization

np.testing.assert_almost_equal(

np.sort(np.linalg.eig(T.A)[0]), np.sort(np.linalg.eig(T_ss.A)[0]))

np.testing.assert_almost_equal(T.C @ T.B, T_ss.C @ T_ss.B)

np.testing.assert_almost_equal(T.C @ T. A @ T.B, T_ss.C @ T_ss.A @ T_ss.B)

P = ct.ss(1,1,1,0, inputs='u', outputs='y', name='P')

C = ct.tf(10, [.1, 1], inputs='e', outputs='u', name='C')

L = ct.interconnect([C, P], inputs='e', outputs='y')

L.connection_table(show_names=show_names)

captured_from_method = capsys.readouterr().out

ct.connection_table(L, show_names=show_names)

captured_from_function = capsys.readouterr().out

# break the following strings separately because the printout order varies

# because signal names are stored as a set

mystrings = \

["signal | source | destination",

"------------------------------------------------------------------"]

if show_names:

mystrings += \

["e | input | C",

"u | C | P",

"y | P | output"]

else:

mystrings += \

["e | input | system 0",

"u | system 0 | system 1",

"y | system 1 | output"]

for str_ in mystrings:

assert str_ in captured_from_method

assert str_ in captured_from_function

# check auto-sum

P1 = ct.ss(1,1,1,0, inputs='u', outputs='y', name='P1')

P2 = ct.tf(10, [.1, 1], inputs='e', outputs='y', name='P2')

P3 = ct.tf(10, [.1, 1], inputs='x', outputs='y', name='P3')

P = ct.interconnect([P1, P2, P3], inputs=['e', 'u', 'x'], outputs='y')

P.connection_table(show_names=show_names)

captured_from_method = capsys.readouterr().out

ct.connection_table(P, show_names=show_names)

captured_from_function = capsys.readouterr().out

mystrings = \

["signal | source | destination",

"-------------------------------------------------------------------"]

if show_names:

mystrings += \

["u | input | P1",

"e | input | P2",

"x | input | P3",

"y | P1, P2, P3 | output"]

else:

mystrings += \

["u | input | system 0",

"e | input | system 1",

"x | input | system 2",

"y | system 0, system 1, system 2 | output"]

for str_ in mystrings:

assert str_ in captured_from_method

assert str_ in captured_from_function

# check auto-split

P1 = ct.ss(1,1,1,0, inputs='u', outputs='x', name='P1')

P2 = ct.tf(10, [.1, 1], inputs='u', outputs='y', name='P2')

P3 = ct.tf(10, [.1, 1], inputs='u', outputs='z', name='P3')

P = ct.interconnect([P1, P2, P3], inputs=['u'], outputs=['x','y','z'])

P.connection_table(show_names=show_names)

captured_from_method = capsys.readouterr().out

ct.connection_table(P, show_names=show_names)

captured_from_function = capsys.readouterr().out

mystrings = \

["signal | source | destination",

"-------------------------------------------------------------------"]

if show_names:

mystrings += \

["u | input | P1, P2, P3",

"x | P1 | output ",

"y | P2 | output",

"z | P3 | output"]

else:

mystrings += \

["u | input | system 0, system 1, system 2",

"x | system 0 | output ",

"y | system 1 | output",

"z | system 2 | output"]

for str_ in mystrings:

assert str_ in captured_from_method

assert str_ in captured_from_function

# check change column width

P.connection_table(show_names=show_names, column_width=20)

captured_from_method = capsys.readouterr().out

ct.connection_table(P, show_names=show_names, column_width=20)

captured_from_function = capsys.readouterr().out

mystrings = \

["signal | source | destination",

"------------------------------------------------"]

if show_names:

mystrings += \

["u | input | P1, P2, P3",

"x | P1 | output ",

"y | P2 | output",

"z | P3 | output"]

else:

mystrings += \

["u | input | system 0, syste.. ",

"x | system 0 | output ",

"y | system 1 | output",

"z | system 2 | output"]

for str_ in mystrings:

assert str_ in captured_from_method

# First make sure the docstring example works

P = ct.tf(1, [1, 0], input='u', output='y')

C = ct.tf(10, [1, 1], input='e', output='u')

sumblk = ct.summing_junction(inputs=['r', '-y'], output='e')

T = ct.interconnect((P, C, sumblk), input='r', output='y')

assert (T.ninputs, T.noutputs, T.nstates) == (1, 1, 2)

# Unrecognized arguments

# StateSpace

with pytest.raises(TypeError, match="unrecognized keyword"):

P = ct.StateSpace(ct.rss(2, 1, 1), output_name='y')

# Interconnect

with pytest.raises(TypeError, match="unrecognized keyword"):

T = ct.interconnect((P, C, sumblk), input_name='r', output='y')

# Interconnected system

with pytest.raises(TypeError, match="unrecognized keyword"):

T = ct.InterconnectedSystem((P, C, sumblk), input_name='r', output='y')

# NonlinearIOSytem

with pytest.raises(TypeError, match="unrecognized keyword"):

ct.NonlinearIOSystem(

None, lambda t, x, u, params: u*u, input_count=1, output_count=1)

# Summing junction

with pytest.raises(TypeError, match="input specification is required"):

sumblk = ct.summing_junction()

with pytest.raises(TypeError, match="unrecognized keyword"):

# regression test for gh-692

P1 = ct.rss(2, 1, 1)

P1_iosys = ct.StateSpace(P1, inputs='u1', outputs='y1')

P2 = ct.rss(2, 1, 1)

P2_iosys = ct.StateSpace(P2, inputs='y1', outputs='y2')

P_s1 = ct.interconnect(

[P1_iosys, P2_iosys], inputs='u1', outputs=['y2'], debug=True)

assert P_s1.input_index == {'u1' : 0}

assert P_s1.output_index == {'y2' : 0}

P_s2 = ct.interconnect([P1_iosys, P2_iosys], input='u1', outputs=['y2'])

assert P_s2.input_index == {'u1' : 0}

assert P_s2.output_index == {'y2' : 0}

P_s1 = ct.interconnect([P1_iosys, P2_iosys], inputs=['u1'], outputs='y2')

assert P_s1.input_index == {'u1' : 0}

assert P_s1.output_index == {'y2' : 0}

P_s2 = ct.interconnect([P1_iosys, P2_iosys], inputs=['u1'], output='y2')

assert P_s2.input_index == {'u1' : 0}

tf_ctrl = ct.tf(1, (10.1, 1), inputs='e', outputs='u', name='ctrl')

tf_plant = ct.tf(1, (10.1, 1), inputs='u', outputs='y', name='plant')

ss_ctrl = ct.ss(1, 2, 1, 0, inputs='e', outputs='u', name='ctrl')

ss_plant = ct.ss(1, 2, 1, 0, inputs='u', outputs='y', name='plant')

nl_ctrl = ct.NonlinearIOSystem(

lambda t, x, u, params: x*x, lambda t, x, u, params: u*x,

states=1, inputs='e', outputs='u', name='ctrl')

nl_plant = ct.NonlinearIOSystem(

lambda t, x, u, params: x*x, lambda t, x, u, params: u*x,

states=1, inputs='u', outputs='y', name='plant')

sumblk = ct.summing_junction(inputs=['r', '-y'], outputs=['e'], name='sum')

# Interconnections of linear I/O systems should be linear I/O system

assert isinstance(

ct.interconnect([tf_ctrl, tf_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

assert isinstance(

ct.interconnect([ss_ctrl, ss_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

assert isinstance(

ct.interconnect([tf_ctrl, ss_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

assert isinstance(

ct.interconnect([ss_ctrl, tf_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

# Interconnections with nonliner I/O systems should not be linear

assert not isinstance(

ct.interconnect([nl_ctrl, ss_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

assert not isinstance(

ct.interconnect([nl_ctrl, tf_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

assert not isinstance(

ct.interconnect([ss_ctrl, nl_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

assert not isinstance(

ct.interconnect([tf_ctrl, nl_plant, sumblk], inputs='r', outputs='y'),

ct.StateSpace)

# Implicit converstion of transfer function should retain name

clsys = ct.interconnect(

[tf_ctrl, ss_plant, sumblk],

connections=[

['plant.u', 'ctrl.u'],

['ctrl.e', 'sum.e'],

['sum.y', 'plant.y']

],

inplist=['sum.r'], inputs='r',

outlist=['plant.y'], outputs='y')

# Create an interconnected system for testing

sys1 = ct.rss(4, 3, 3, name='sys1')

sys2 = ct.rss(4, 3, 3, name='sys2')

series = sys2 * sys1

# Simple series interconnection

icsys = ct.interconnect(

[sys1, sys2], connections=connections,

inplist=inplist, outlist=outlist, inputs=inputs, outputs=outputs

)

np.testing.assert_allclose(icsys.A, series.A)

np.testing.assert_allclose(icsys.B, series.B)

np.testing.assert_allclose(icsys.C, series.C)

# Create an interconnected system for testing

P = ct.rss(4, 2, 2, name='P', strictly_proper=True)

C = ct.rss(4, 2, 2, name='C')

feedback = ct.feedback(P * C, np.eye(2))

# Simple feedback interconnection

icsys = ct.interconnect(

[C, P], connections=connections,

inplist=inplist, outlist=outlist

)

np.testing.assert_allclose(icsys.A, feedback.A)

np.testing.assert_allclose(icsys.B, feedback.B)

np.testing.assert_allclose(icsys.C, feedback.C)

pinputs, poutputs, connections, inplist, outlist):

P = ct.rss(

states=6, name='P', strictly_proper=True,

inputs=pinputs, outputs=poutputs)

C = ct.rss(4, 2, 2, name='C')

# Low level feedback connection (feedback around "lower" process I/O)

partial = ct.interconnect(

[C, P],

connections=[

[(1, 2), (0, 0)], [(1, 3), (0, 1)],

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

inplist=[(0, 0), (0, 1), (1, 0), (1, 1)], # C.u, P.w

outlist=[(1, 0), (1, 1), (1, 2), (1, 3),

(0, 0), (0, 1)], # P.z, P.y, C.y

)

# High level feedback conections

icsys = ct.interconnect(

[C, P], connections=connections,

inplist=inplist, outlist=outlist

)

np.testing.assert_allclose(icsys.A, partial.A)

np.testing.assert_allclose(icsys.B, partial.B)

np.testing.assert_allclose(icsys.C, partial.C)

P = ct.rss(

states=6, name='P', strictly_proper=True,

inputs=['u[0]', 'u[1]', 'v[0]', 'v[1]'],

outputs=['y[0]', 'y[1]', 'z[0]', 'z[1]'])

C = ct.rss(4, 2, 2, name='C', input_prefix='e', output_prefix='u')

sumblk = ct.summing_junction(

inputs=['r', '-y'], outputs='e', dimension=2, name='sum')

clsys1 = ct.interconnect(

[C, P, sumblk],

connections=[

['P.u[0]', 'C.u[0]'], ['P.u[1]', 'C.u[1]'],

['C.e[0]', 'sum.e[0]'], ['C.e[1]', 'sum.e[1]'],

['sum.y[0]', 'P.y[0]'], ['sum.y[1]', 'P.y[1]'],

],

inplist=['sum.r[0]', 'sum.r[1]', 'P.v[0]', 'P.v[1]'],

outlist=['P.y[0]', 'P.y[1]', 'P.z[0]', 'P.z[1]', 'C.u[0]', 'C.u[1]']

)

clsys2 = ct.interconnect(

[C, P, sumblk],

connections=[

['P.u[0:2]', 'C.u[0:2]'],

['C.e[0:2]', 'sum.e[0:2]'],

['sum.y[0:2]', 'P.y[0:2]']

],

inplist=['sum.r[0:2]', 'P.v[0:2]'],

outlist=['P.y[0:2]', 'P.z[0:2]', 'C.u[0:2]']

)

np.testing.assert_equal(clsys2.A, clsys1.A)

np.testing.assert_equal(clsys2.B, clsys1.B)

np.testing.assert_equal(clsys2.C, clsys1.C)

np.testing.assert_equal(clsys2.D, clsys1.D)

clsys3 = ct.interconnect(

[C, P, sumblk],

connections=[['P.u', 'C.u'], ['C.e', 'sum.e'], ['sum.y', 'P.y']],

inplist=['sum.r', 'P.v'], outlist=['P.y', 'P.z', 'C.u']

)

np.testing.assert_equal(clsys3.A, clsys1.A)

np.testing.assert_equal(clsys3.B, clsys1.B)

np.testing.assert_equal(clsys3.C, clsys1.C)

np.testing.assert_equal(clsys3.D, clsys1.D)

clsys4 = ct.interconnect(

[C, P, sumblk],

connections=[['P.u', 'C'], ['C', 'sum'], ['sum.y', 'P.y']],

inplist=['sum.r', 'P.v'], outlist=['P', 'C.u']

)

np.testing.assert_equal(clsys4.A, clsys1.A)

np.testing.assert_equal(clsys4.B, clsys1.B)

np.testing.assert_equal(clsys4.C, clsys1.C)

np.testing.assert_equal(clsys4.D, clsys1.D)

clsys5 = ct.interconnect(

[C, P, sumblk],

inplist=['sum.r', 'P.v'], outlist=['P', 'C.u']

)

np.testing.assert_equal(clsys5.A, clsys1.A)

np.testing.assert_equal(clsys5.B, clsys1.B)

np.testing.assert_equal(clsys5.C, clsys1.C)

sys = ct.rss(

states=2, name='sys', strictly_proper=True,

inputs=['u[0]', 'u[1]', 'v[0]', 'v[1]', 'w[0]', 'w[1]'],

outputs=['y[0]', 'y[1]', 'z[0]', 'z[1]', 'z[2]'])

# Create an input/output system w/out inplist, outlist

icsys = ct.interconnect(

[sys], connections=[['sys.v', 'sys.y']],

inputs=['u', 'w'],

outputs=['y', 'z'])

# Create a nominally unstable system

sys1 = ct.nlsys(

lambda t, x, u, params: params['a'] * x[0] + u[0],

states=1, inputs='u', outputs='y', params={'a': 2, 'c':2})

# Simple system for serial interconnection

sys2 = ct.nlsys(

None, lambda t, x, u, params: u[0],

inputs='r', outputs='u', params={'a': 4, 'b': 3})

# Make sure default parameters get set as expected

sys = ct.interconnect([sys1, sys2], inputs='r', outputs='y')

assert sys.params == {'a': 4, 'c': 2, 'b': 3}

assert sys.dynamics(0, [1], [0]).item() == 4

# Make sure we can override the parameters

sys = ct.interconnect(

[sys1, sys2], inputs='r', outputs='y', params={'b': 1})

assert sys.params == {'b': 1}

assert sys.dynamics(0, [1], [0]).item() == 2

assert sys.dynamics(0, [1], [0], params={'a': 5}).item() == 5

# Create final series interconnection, with proper parameter values

sys = ct.interconnect(

[sys1, sys2], inputs='r', outputs='y', params={'a': 1})

assert sys.params == {'a': 1}

# Make sure we can call the update function

sys.updfcn(0, [0], [0], {})

# Make sure the serial interconnection is unstable to start

assert sys.linearize([0], [0]).poles()[0].real == 1

# Change the parameter and make sure it takes

assert sys.linearize([0], [0], params={'a': -1}).poles()[0].real == -1

# Now try running a simulation

timepts = np.linspace(0, 10)

resp = ct.input_output_response(sys, timepts, 0, params={'a': -1})

sys1 = ct.rss(2, 1, 1, name='S1')

sys2 = ct.rss(2, 1, 1, name='S2')

sys_bd = sys1 + sys2

sys_ic = ct.interconnect(

[sys1, sys2],

inplist=[['S1.u[0]', 'S2.u[0]']],

outlist=[['S1.y[0]', 'S2.y[0]']])

np.testing.assert_allclose(sys_bd.A, sys_ic.A)

np.testing.assert_allclose(sys_bd.B, sys_ic.B)

np.testing.assert_allclose(sys_bd.C, sys_ic.C)