feat: Implement a DFA and Mealy Automaton

This commit is contained in:
PapaTutuWawa 2022-05-13 13:40:52 +02:00
parent 7fa0876b08
commit f92bef517f
5 changed files with 184 additions and 1 deletions

View File

@ -5,3 +5,7 @@
## 0.1.1
* Switch to selfhosted pub repository
## 0.1.2
* Add [DeterministicFiniteAutomaton] and [MealyAutomaton]

99
lib/automaton.dart Normal file
View File

@ -0,0 +1,99 @@
class NoTransitionPossibleException implements Exception {
@override
String errMsg() => "The transition graph allows no transition";
}
/// A deterministic finite automaton. [T] is the state type while
/// [I] is the input type.
/// Edges of the node must be added with [addTransition]. If a trap state
/// is required, it can be set in the constructor.
class DeterministicFiniteAutomaton<T, I> {
/// The current state of the DFA
T _state;
/// The edges of the DFA: State x Input -> State
Map<T, Map<I, T>> _transitions;
/// Trap state
T? trapState;
/// The argument is the initial state
DeterministicFiniteAutomaton(this._state, { this.trapState }) : _transitions = {};
T get state => _state;
void addTransition(T oldState, I input, T newState) {
assert(oldState != trapState);
// These are handled implicitly if no transition has been found
assert(newState != trapState);
if (!_transitions.containsKey(oldState)) {
_transitions[oldState] = {};
}
_transitions[oldState]![input] = newState;
}
/// Transition the DFA based on its current state and the input [input].
void onInput(I input) {
final newState = _transitions[_state]?[input];
if (newState == null) {
// Go to the trap state if we can
if (trapState != null) {
_state = trapState!;
return;
} else {
throw NoTransitionPossibleException();
}
}
_state = newState;
}
/// Returns where [input] would take the automaton to. Returns null if no transition
/// is possible, ignoring trap transitions.
T? peekTransition(I input) {
if (!_transitions.containsKey(_state) || !_transitions[_state]!.containsKey(input)) {
return null;
}
return _transitions[_state]![input]!;
}
}
typedef MealyAutomatonCallback<T, I> = void Function(T oldState, I input);
class MealyAutomaton<T, I> {
/// The base automaton
final DeterministicFiniteAutomaton<T, I> _automaton;
/// Mapping of State x Input -> Output callback
Map<T, Map<I, MealyAutomatonCallback<T, I>>> _outputs;
/// Trap state
MealyAutomatonCallback<T, I>? trapCallback;
// TODO: Assert that trapState != null implies trapCallback != null.
MealyAutomaton(T initialState, { T? trapState, this.trapCallback })
: _outputs = {},
_automaton = DeterministicFiniteAutomaton(initialState, trapState: trapState);
T get state => _automaton.state;
void addTransition(T oldState, I input, T newState, MealyAutomatonCallback<T, I> callback) {
_automaton.addTransition(oldState, input, newState);
if (!_outputs.containsKey(oldState)) {
_outputs[oldState] = {};
}
_outputs[oldState]![input] = callback;
}
void onInput(I input) {
final _state = _automaton.state;
if (_automaton.peekTransition(input) == null && trapCallback == null) {
throw new NoTransitionPossibleException();
}
final callback = _outputs[_state]?[input] ?? trapCallback!;
_automaton.onInput(input);
callback(_state, input);
}
}

View File

@ -1,3 +1,4 @@
library moxlib;
export "awaitabledatasender.dart";
export "automaton.dart";

View File

@ -1,6 +1,6 @@
name: moxlib
description: A collection of code for sharing between various moxxy libraries. Not inteded for outside use.
version: 0.1.1
version: 0.1.2
homepage: https://codeberg.org/moxxy/moxlib
publish_to: https://pub.polynom.me

79
test/automaton_test.dart Normal file
View File

@ -0,0 +1,79 @@
import "package:moxlib/automaton.dart";
import "package:test/test.dart";
enum States {
a, b, c, trap
}
void main() {
test("Test a simple DFA", () {
final automaton = DeterministicFiniteAutomaton<States, int>(States.a);
automaton.addTransition(States.a, 1, States.b);
automaton.addTransition(States.b, 2, States.c);
automaton.addTransition(States.c, 3, States.a);
expect(automaton.state, States.a);
automaton.onInput(1);
expect(automaton.state, States.b);
automaton.onInput(2);
expect(automaton.state, States.c);
automaton.onInput(3);
expect(automaton.state, States.a);
});
test("Test a simple DFA with a trap state", () {
final automaton = DeterministicFiniteAutomaton<States, int>(States.a, trapState: States.trap);
automaton.addTransition(States.a, 1, States.b);
automaton.addTransition(States.b, 2, States.c);
automaton.addTransition(States.c, 3, States.a);
expect(automaton.state, States.a);
automaton.onInput(1);
expect(automaton.state, States.b);
automaton.onInput(2);
expect(automaton.state, States.c);
automaton.onInput(4);
expect(automaton.state, States.trap);
// Transitioning away from the trap state should not be possible
automaton.onInput(5);
expect(automaton.state, States.trap);
});
test("Test a simple Mealy Automaton", () {
bool called = false;
final callback = (state, input) {
called = true;
};
final automaton = MealyAutomaton<States, int>(States.a);
automaton.addTransition(States.a, 1, States.b, callback);
automaton.onInput(1);
expect(automaton.state, States.b);
expect(called, true);
});
test("Test a simple Mealy Automaton with a trap state", () {
bool called = false;
bool trapCalled = false;
final callback = (state, input) {
called = true;
};
final trapCallback = (state, input) {
trapCalled = true;
};
final automaton = MealyAutomaton<States, int>(States.a, trapState: States.trap, trapCallback: trapCallback);
automaton.addTransition(States.a, 1, States.b, callback);
automaton.onInput(1);
expect(called, true);
automaton.onInput(1);
expect(automaton.state, States.trap);
expect(trapCalled, true);
});
}