Package tulip :: Package transys :: Module machines :: Class MealyMachine

Class MealyMachine

Mealy machine.

Examples

Traffic Light: Fig. 3.14, p.72 [LS11]

>>> m = MealyMachine()
>>> pure_signal = {'present', 'absent'}
>>> m.add_inputs([('tick', pure_signal) ])
>>> m.add_outputs([('go', pure_signal), ('stop', pure_signal) ])
>>> m.states.add_from(['red', 'green', 'yellow'])
>>> m.states.initial.add('red')

For brevity:

>>> p = 'present'
>>> a = 'absent'

The transitions can equivalently be defined with dict(). So instead of the previous m.transitions.add, we can use:

>>> label = {'tick':p, 'go':p, 'stop':a}
>>> m.transitions.add('red', 'green', **label)
>>> label = {'tick':p, 'go':a, 'stop':p}
>>> m.transitions.add('green', 'yellow', **label)
>>> label = {'tick':p, 'go':a, 'stop':p}
>>> m.transitions.add('yellow', 'red', **label)

This avoids any ordering issues, i.e., changing the order of the sublabels does not matter:

>>> label = {'go':p, 'tick':p, 'stop':a}
>>> m.transitions.add('red', 'green', **label)

Theory

A Mealy machine implements the discrete dynamics:

   x[k+1] = f(x[k], u[k] )
   y[k] = g(x[k], u[k] )

where:

k: discrete time = sequence index
x: state = valuation of state variables
X: set of states = S
u: inputs = valuation of input ports
y: output actions = valuation of output ports
f: X-> 2^X, transition function
g: X-> Out, output function

Observe that the output is defined when a reaction occurs to an input.

Note

valuation: assignment of values to each port

Reference

[M55]

Nested Classes

Inherited from networkx.classes.multigraph.MultiGraph: edge_key_dict_factory

Inherited from networkx.classes.graph.Graph: adjlist_dict_factory, edge_attr_dict_factory, node_dict_factory

Instance Methods

__init__(self)
Initialize a graph with edges, name, graph attributes.

__str__(self)
Get informal string representation.

add_outputs(self, new_outputs, masks=None)
Add new outputs.

(outputs, next_state) where outputs: {'port_name':port_value, ...}

reaction(self, from_state, inputs, lazy=False)
Return next state and output, when reacting to given inputs.

reactionpart(self, from_state, inputs)
Wraps reaction() with lazy=True

run(self, from_state=None, input_sequences=None)
Guided or interactive run.

Inherited from Transducer: add_inputs, add_state_vars

Inherited from labeled_graphs.LabeledDiGraph: add_edge, add_edges_from, add_node, add_nodes_from, dot_str, has_deadends, is_consistent, plot, remove_deadends, remove_labeled_edge, remove_labeled_edges_from, save

Inherited from networkx.classes.multidigraph.MultiDiGraph: degree_iter, edges_iter, in_degree_iter, in_edges, in_edges_iter, is_directed, is_multigraph, out_degree_iter, out_edges, out_edges_iter, remove_edge, reverse, subgraph, to_directed, to_undirected

Inherited from networkx.classes.multigraph.MultiGraph: edges, get_edge_data, has_edge, number_of_edges, remove_edges_from, selfloop_edges

Inherited from networkx.classes.digraph.DiGraph: clear, has_predecessor, has_successor, in_degree, neighbors, neighbors_iter, out_degree, predecessors, predecessors_iter, remove_node, remove_nodes_from, successors, successors_iter

Inherited from networkx.classes.graph.Graph: __contains__, __getitem__, __iter__, __len__, add_cycle, add_path, add_star, add_weighted_edges_from, adjacency_iter, adjacency_list, copy, degree, has_node, nbunch_iter, nodes, nodes_iter, nodes_with_selfloops, number_of_nodes, number_of_selfloops, order, size

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __new__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __subclasshook__

Properties

Inherited from networkx.classes.graph.Graph: name

Inherited from object: __class__

Method Details

init(self)
(Constructor)

Initialize a graph with edges, name, graph attributes.

Parameters
----------
data : input graph
    Data to initialize graph.  If data=None (default) an empty
    graph is created.  The data can be an edge list, or any
    NetworkX graph object.  If the corresponding optional Python
    packages are installed the data can also be a NumPy matrix
    or 2d ndarray, a SciPy sparse matrix, or a PyGraphviz graph.
name : string, optional (default='')
    An optional name for the graph.
attr : keyword arguments, optional (default= no attributes)
    Attributes to add to graph as key=value pairs.

See Also
--------
convert

Examples
--------
>>> G = nx.Graph()   # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G = nx.Graph(name='my graph')
>>> e = [(1,2),(2,3),(3,4)] # list of edges
>>> G = nx.Graph(e)

Arbitrary graph attribute pairs (key=value) may be assigned

>>> G=nx.Graph(e, day="Friday")
>>> G.graph
{'day': 'Friday'}

Overrides: object.__init__: (inherited documentation)

str(self)
(Informal representation operator)

Get informal string representation.

Overrides: object.__str__

add_outputs(self, new_outputs, masks=None)

Add new outputs.

Parameters:

new_outputs (dict) - dict of pairs {port_name : port_type} where:
- port_name: str
- port_type: Iterable | check class
masks (dict of functions keys are port_names (see arg: new_outputs) each function returns bool) - custom mask functions, for each sublabel based on its current value each such function returns:
- True, if the sublabel should be shown
- False, otherwise (to hide it)

reaction(self, from_state, inputs, lazy=False)

Return next state and output, when reacting to given inputs.

The machine must be deterministic. (for each state and input at most a single transition enabled, this notion does not coincide with output-determinism)

Not exactly a wrapper of Transitions.find, because it matches only that part of an edge label that corresponds to the inputs.

Parameters:

from_state (element of self.states) - transition starts from this state.
inputs ({'port_name':port_value, ...}) - dict assigning a valid value to each input port.
lazy (bool) - Lazy evaluation of inputs? If lazy=True, then allow an incomplete specification of input if there is precisely one enabled transition.

Returns: (outputs, next_state) where outputs: {'port_name':port_value, ...}

output values and next state.

run(self, from_state=None, input_sequences=None)

Guided or interactive run.

Parameters:

input_sequences - if None, then call interactive_run, otherwise call guided_run.

Returns:

output of guided_run, otherwise None.

Class MealyMachine

Examples

Theory

Note

Reference

__init__(self) (Constructor)

__str__(self) (Informal representation operator)

add_outputs(self, new_outputs, masks=None)

reaction(self, from_state, inputs, lazy=False)

run(self, from_state=None, input_sequences=None)

init(self)
(Constructor)

str(self)
(Informal representation operator)