'iosys.state_name_delim': '_',

'iosys.duplicate_system_name_prefix': '',

'iosys.duplicate_system_name_suffix': '$copy',

'iosys.linearized_system_name_prefix': '',

'iosys.linearized_system_name_suffix': '$linearized',

'iosys.sampled_system_name_prefix': '',

'iosys.sampled_system_name_suffix': '$sampled',

'iosys.indexed_system_name_prefix': '',

'iosys.indexed_system_name_suffix': '$indexed',

'iosys.converted_system_name_prefix': '',

'iosys.converted_system_name_suffix': '$converted',

'iosys.repr_format': 'eval',

'iosys.repr_show_count': True,

"""Named signal with label-based access.

def __new__(cls, input_array, signal_labels=None, trace_labels=None):

# See https://numpy.org/doc/stable/user/basics.subclassing.html

obj = np.asarray(input_array).view(cls) # Cast to our class type

obj.signal_labels = signal_labels # Save signal labels

obj.trace_labels = trace_labels # Save trace labels

obj.data_shape = input_array.shape # Save data shape

return obj # Return new object

def __array_finalize__(self, obj):

# See https://numpy.org/doc/stable/user/basics.subclassing.html

if obj is None:

return

self.signal_labels = getattr(obj, 'signal_labels', None)

self.trace_labels = getattr(obj, 'trace_labels', None)

self.data_shape = getattr(obj, 'data_shape', None)

def _parse_key(self, key, labels=None, level=0):

if labels is None:

labels = self.signal_labels

try:

if isinstance(key, str):

key = labels.index(item := key)

if level == 0 and len(self.data_shape) < 2:

# This is the only signal => use it

return ()

elif isinstance(key, list):

keylist = []

for item in key: # use for loop to save item for error

keylist.append(

self._parse_key(item, labels=labels, level=level+1))

if level == 0 and key != keylist and len(self.data_shape) < 2:

raise ControlIndexError

key = keylist

elif isinstance(key, tuple) and len(key) > 0:

keylist = []

keylist.append(

self._parse_key(

item := key[0], labels=self.signal_labels,

level=level+1))

if len(key) > 1:

keylist.append(

self._parse_key(

item := key[1], labels=self.trace_labels,

level=level+1))

if level == 0 and key[:len(keylist)] != tuple(keylist) \

and len(keylist) > len(self.data_shape) - 1:

raise ControlIndexError

for i in range(2, len(key)):

keylist.append(key[i]) # pass on remaining elements

key = tuple(keylist)

except ValueError:

raise ValueError(f"unknown signal name '{item}'")

except ControlIndexError:

raise ControlIndexError(

"signal name(s) not valid for squeezed data")

return key

def __getitem__(self, key):

return super().__getitem__(self._parse_key(key))

def __repr__(self):

out = "NamedSignal(\n"

out += repr(np.array(self)) # NamedSignal -> array

if self.signal_labels is not None:

out += f",\nsignal_labels={self.signal_labels}"

if self.trace_labels is not None:

out += f",\ntrace_labels={self.trace_labels}"

out += ")"

"""Base class for input/output systems.

# Allow ndarray * IOSystem to give IOSystem._rmul_() priority

# https://docs.scipy.org/doc/numpy/reference/arrays.classes.html

__array_priority__ = 20

def __init__(

self, name=None, inputs=None, outputs=None, states=None,

input_prefix='u', output_prefix='y', state_prefix='x', **kwargs):

# system name

self.name = self._name_or_default(name)

# Parse and store the number of inputs and outputs

self.set_inputs(inputs, prefix=input_prefix)

self.set_outputs(outputs, prefix=output_prefix)

self.set_states(states, prefix=state_prefix)

# Process timebase: if not given use default, but allow None as value

self.dt = _process_dt_keyword(kwargs)

self._repr_format = kwargs.pop('repr_format', None)

# Make sure there were no other keywords

if kwargs:

raise TypeError("unrecognized keywords: ", str(kwargs))

# Keep track of the keywords that we recognize

_kwargs_list = [

'name', 'inputs', 'outputs', 'states', 'input_prefix',

'output_prefix', 'state_prefix', 'dt']

#

# Functions to manipulate the system name

#

_idCounter = 0 # Counter for creating generic system name

# Return system name

def _name_or_default(self, name=None, prefix_suffix_name=None):

if name is None:

name = "sys[{}]".format(InputOutputSystem._idCounter)

InputOutputSystem._idCounter += 1

elif re.match(r".*\..*", name):

raise ValueError(f"invalid system name '{name}' ('.' not allowed)")

prefix = "" if prefix_suffix_name is None else config.defaults[

'iosys.' + prefix_suffix_name + '_system_name_prefix']

suffix = "" if prefix_suffix_name is None else config.defaults[

'iosys.' + prefix_suffix_name + '_system_name_suffix']

return prefix + name + suffix

# Check if system name is generic

def _generic_name_check(self):

return re.match(r'^sys\[\d*\]$', self.name) is not None

#

# Class attributes

#

# These attributes are defined as class attributes so that they are

# documented properly. They are "overwritten" in __init__.

#

#: Number of system inputs.

#:

#: :meta hide-value:

ninputs = None

#: Number of system outputs.

#:

#: :meta hide-value:

noutputs = None

#: Number of system states.

#:

#: :meta hide-value:

nstates = None

#: System timebase.

#:

#: :meta hide-value:

dt = None

#

# System representation

#

def __str__(self):

"""String representation of an input/output object"""

out = f"<{self.__class__.__name__}>: {self.name}"

out += f"\nInputs ({self.ninputs}): {self.input_labels}"

out += f"\nOutputs ({self.noutputs}): {self.output_labels}"

if self.nstates is not None:

out += f"\nStates ({self.nstates}): {self.state_labels}"

out += self._dt_repr(separator="\n", space=" ")

return out

def __repr__(self):

return iosys_repr(self, format=self.repr_format)

def _repr_info_(self, html=False):

out = f"<{self.__class__.__name__} {self.name}: " + \

f"{list(self.input_labels)} -> {list(self.output_labels)}"

out += self._dt_repr(separator=", ", space="") + ">"

if html:

# Replace symbols that might be interpreted by HTML processing

# TODO: replace -> with right arrow (later)

escape_chars = {

'$': r'\$',

'<': '&lt;',

'>': '&gt;',

}

return "".join([c if c not in escape_chars else

escape_chars[c] for c in out])

else:

return out

def _repr_eval_(self):

# Defaults to _repr_info_; override in subclasses

return self._repr_info_()

def _repr_latex_(self):

# Defaults to using __repr__; override in subclasses

return None

def _repr_html_(self):

# Defaults to using __repr__; override in subclasses

return None

def _repr_markdown_(self):

return self._repr_html_()

@property

def repr_format(self):

"""String representation format.

return self._repr_format if self._repr_format is not None \

else config.defaults['iosys.repr_format']

@repr_format.setter

def repr_format(self, value):

self._repr_format = value

def _label_repr(self, show_count=None):

show_count = config._get_param(

'iosys', 'repr_show_count', show_count, True)

out, count = "", 0

# Include the system name if not generic

if not self._generic_name_check():

name_spec = f"name='{self.name}'"

count += len(name_spec)

out += name_spec

# Include the state, output, and input names if not generic

for sig_name, sig_default, sig_labels in zip(

['states', 'outputs', 'inputs'],

['x', 'y', 'u'], # TODO: replace with defaults

[self.state_labels, self.output_labels, self.input_labels]):

if sig_name == 'states' and self.nstates is None:

continue

# Check if the signal labels are generic

if any([re.match(r'^' + sig_default + r'\[\d*\]$', label) is None

for label in sig_labels]):

spec = f"{sig_name}={sig_labels}"

elif show_count:

spec = f"{sig_name}={len(sig_labels)}"

else:

spec = ""

# Append the specification string to the output, with wrapping

if count == 0:

count = len(spec) # no system name => suppress comma

elif count + len(spec) > 72:

# TODO: check to make sure a single line is enough (minor)

out += ",\n"

count = len(spec)

elif len(spec) > 0:

out += ", "

count += len(spec) + 2

out += spec

return out

def _dt_repr(self, separator="\n", space=""):

if config.defaults['control.default_dt'] != self.dt:

return "{separator}dt{space}={space}{dt}".format(

separator=separator, space=space,

dt='None' if self.dt is None else self.dt)

else:

return ""

# Find a list of signals by name, index, or pattern

def _find_signals(self, name_list, sigdict):

if not isinstance(name_list, (list, tuple)):

name_list = [name_list]

index_list = []

for name in name_list:

# Look for signal ranges (slice-like or base name)

ms = re.match(r'([\w$]+)\[([\d]*):([\d]*)\]$', name) # slice

mb = re.match(r'([\w$]+)$', name) # base

if ms:

base = ms.group(1)

start = None if ms.group(2) == '' else int(ms.group(2))

stop = None if ms.group(3) == '' else int(ms.group(3))

for var in sigdict:

# Find variables that match

msig = re.match(r'([\w$]+)\[([\d]+)\]$', var)

if msig and msig.group(1) == base and \

(start is None or int(msig.group(2)) >= start) and \

(stop is None or int(msig.group(2)) < stop):

index_list.append(sigdict.get(var))

elif mb and sigdict.get(name, None) is None:

# Try to use name as a base name

for var in sigdict:

msig = re.match(name + r'\[([\d]+)\]$', var)

if msig:

index_list.append(sigdict.get(var))

else:

index_list.append(sigdict.get(name, None))

return None if len(index_list) == 0 or \

any([idx is None for idx in index_list]) else index_list

def _copy_names(self, sys, prefix="", suffix="", prefix_suffix_name=None):

"""copy the signal and system name of sys. Name is given as a keyword

# Figure out the system name and assign it

self.name = _extended_system_name(

sys.name, prefix, suffix, prefix_suffix_name)

# Name the inputs, outputs, and states

self.input_index = sys.input_index.copy()

self.output_index = sys.output_index.copy()

if self.nstates and sys.nstates:

# only copy state names for state space systems

self.state_index = sys.state_index.copy()

def copy(self, name=None, use_prefix_suffix=True):

"""Make a copy of an input/output system.

# Create a copy of the system

newsys = deepcopy(self)

# Update the system name

if name is None and use_prefix_suffix:

# Get the default prefix and suffix to use

newsys.name = self._name_or_default(

self.name, prefix_suffix_name='duplicate')

else:

newsys.name = self._name_or_default(name)

return newsys

def set_inputs(self, inputs, prefix='u'):

"""Set the number/names of the system inputs.

self.ninputs, self.input_index = \

_process_signal_list(inputs, prefix=prefix)

def find_input(self, name):

"""Find the index for an input given its name (None if not found).

return self.input_index.get(name, None)

def find_inputs(self, name_list):

"""Return list of indices matching input spec (None if not found).

return self._find_signals(name_list, self.input_index)

# Property for getting and setting list of input signals

input_labels = property(

lambda self: list(self.input_index.keys()), # getter

set_inputs, # setter

doc="List of labels for the input signals.")

def set_outputs(self, outputs, prefix='y'):

"""Set the number/names of the system outputs.

self.noutputs, self.output_index = \

_process_signal_list(outputs, prefix=prefix)

def find_output(self, name):

"""Find the index for a output given its name (None if not found).

return self.output_index.get(name, None)

def find_outputs(self, name_list):

"""Return list of indices matching output spec (None if not found).

return self._find_signals(name_list, self.output_index)

# Property for getting and setting list of output signals

output_labels = property(

lambda self: list(self.output_index.keys()), # getter

set_outputs, # setter

doc="List of labels for the output signals.")

def set_states(self, states, prefix='x'):

"""Set the number/names of the system states.

self.nstates, self.state_index = \

_process_signal_list(states, prefix=prefix, allow_dot=True)

def find_state(self, name):

"""Find the index for a state given its name (None if not found).

return self.state_index.get(name, None)

def find_states(self, name_list):

"""Return list of indices matching state spec (None if not found).

return self._find_signals(name_list, self.state_index)

# Property for getting and setting list of state signals

state_labels = property(

lambda self: list(self.state_index.keys()), # getter

set_states, # setter

doc="List of labels for the state signals.")

@property

def shape(self):

"""2-tuple of I/O system dimension, (noutputs, ninputs)."""

return (self.noutputs, self.ninputs)

# TODO: add dict as a means to selective change names? [GH #1019]

def update_names(self, **kwargs):

"""update_names([name, inputs, outputs, states])

self.name = kwargs.pop('name', self.name)

if 'inputs' in kwargs:

ninputs, input_index = _process_signal_list(

kwargs.pop('inputs'), prefix=kwargs.pop('input_prefix', 'u'))

if self.ninputs and self.ninputs != ninputs:

raise ValueError("number of inputs does not match system size")

self.input_index = input_index

if 'outputs' in kwargs:

noutputs, output_index = _process_signal_list(

kwargs.pop('outputs'), prefix=kwargs.pop('output_prefix', 'y'))

if self.noutputs and self.noutputs != noutputs:

raise ValueError("number of outputs does not match system size")

self.output_index = output_index

if 'states' in kwargs:

nstates, state_index = _process_signal_list(

kwargs.pop('states'), prefix=kwargs.pop('state_prefix', 'x'))

if self.nstates != nstates:

raise ValueError("number of states does not match system size")

self.state_index = state_index

# Make sure we processed all of the arguments

if kwargs:

raise TypeError("unrecognized keywords: ", str(kwargs))

def isctime(self, strict=False):

"""

# If no timebase is given, answer depends on strict flag

if self.dt is None:

return True if not strict else False

return self.dt == 0

def isdtime(self, strict=False):

"""

# If no timebase is given, answer depends on strict flag

if self.dt == None:

return True if not strict else False

# Look for dt > 0 (also works if dt = True)

return self.dt > 0

def issiso(self):

"""Check to see if a system is single input, single output."""

"""

if isinstance(sys, (int, float, complex, np.number)) and not strict:

return True

elif not isinstance(sys, InputOutputSystem):

raise ValueError("Object is not an I/O or LTI system")

# Done with the tricky stuff...

"""Return the timebase for a system.

# System needs to be either a constant or an I/O or LTI system

if isinstance(sys, (int, float, complex, np.number)):

return None

elif not isinstance(sys, InputOutputSystem):

raise ValueError("Timebase not defined")

# Return the sample time, with conversion to float if strict is false

if sys.dt == None:

return None

elif strict:

return float(sys.dt)

"""

# explanation:

# if either dt is None, they are compatible with anything

# if either dt is True (discrete with unspecified time base),

# use the timebase of the other, if it is also discrete

# otherwise both dt's must be equal

if hasattr(dt1, 'dt'):

dt1 = dt1.dt

if hasattr(dt2, 'dt'):

dt2 = dt2.dt

if dt1 is None:

return dt2

elif dt2 is None:

return dt1

elif dt1 is True:

if dt2 > 0:

return dt2

else:

raise ValueError("Systems have incompatible timebases")

elif dt2 is True:

if dt1 > 0:

return dt1

else:

raise ValueError("Systems have incompatible timebases")

elif np.isclose(dt1, dt2):

return dt1

else:

"""

# See if we were passed a timebase instead of a system

if sys is None:

if dt is None:

return True if not strict else False

else:

return dt > 0

elif dt is not None:

raise TypeError("passing both system and timebase not allowed")

# Check timebase of the system

if isinstance(sys, (int, float, complex, np.number)):

# Constants OK as long as strict checking is off

return True if not strict else False

else:

"""

# See if we were passed a timebase instead of a system

if sys is None:

if dt is None:

return True if not strict else False

else:

return dt == 0

elif dt is not None:

raise TypeError("passing both system and timebase not allowed")

# Check timebase of the system

if isinstance(sys, (int, float, complex, np.number)):

# Constants OK as long as strict checking is off

return True if not strict else False

else:

"""Return representation of an I/O system.

format = config.defaults['iosys.repr_format'] if format is None else format

match format:

case 'info':

return sys._repr_info_()

case 'eval':

return sys._repr_eval_()

case 'latex':

return sys._repr_html_()

case _:

keywords={}, defaults={}, static=False, end=False):

"""Process iosys specification.