Finite state machine: Difference between revisions

*[https://www.youtube.com/watch?v=vhiiia1_hC4 Computers Without Memory (Finite State Automata)], A Computerphile Video.

<br/><br/>

 

=={{header|BASIC}}==

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM.

Note that the program uses no variables and makes no use of the return stack: all the state is expressed in the (so to speak) state.

 

20 IF INKEY$="D" THEN GOTO 50

30 IF INKEY$="Q" THEN STOP

130 GOTO 120

140 PRINT "REFUNDED"

{{out}}

It will be seen that the user has pressed, in order, <tt>D</tt>, <tt>R</tt>, <tt>D</tt>, <tt>S</tt>, <tt>R</tt>, and <tt>Q</tt>.

=={{header|C}}==

Here is a manually-constructed table-driven finite state machine that is fairly general and could be adapted to different applications.

#include <stdio.h>

#include <ctype.h>

return 0;

}

Machine simulation :

<pre>

 

=={{header|C++}}==

#include <map>

}

}

 

{{out}}

=={{header|D}}==

{{trans|Kotlin}}

import std.range;

import std.stdio;

void main() {

fsm();

 

=={{header|Delphi}}==

{{Trans|Go}}

program Finite_state_machine;

 

begin

fsm;

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

func main() {

fsm()

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private enum State {

Ready(true, "Deposit", "Quit"),

}

}

 

=={{header|Haskell}}==

import Data.Maybe

import Control.Monad

, Implicit "Refunding" "Ready" ]

finishStates = ["Exit"]

 

=={{header|Java}}==

 

public class FiniteStateMachine {

}

}

<pre>[Deposit, Quit]

> Deposit

=={{header|JavaScript}}==

===On browser using blocking window methods===

var states = [{

'name': 'Ready',

}

}

 

=={{header|Julia}}==

 

struct Ready <: State

 

runsim(Ready())

<pre>

Vending machine is ready. (q)uit, (d)eposit: d

 

=={{header|Kotlin}}==

 

enum class State { READY, WAITING, EXIT, DISPENSE, REFUNDING }

fun main(args: Array<String>) {

fsm()

 

Sample input/output:

OK, quitting

</pre>

 

=={{header|Ol}}==

(import (scheme read))

 

; run

(state-machine states 'ready)

{{Out}}

<pre>

 

</pre>

{

fsm1.pas

end.

 

 

 

=={{header|Perl}}==

Added a dummy input called "IMPLICIT" that does not actually require input but automatically transitions to next state.

 

use strict; # https://rosettacode.org/wiki/Finite_state_machine

waiting REFUND refunding take the refund

dispense REMOVE ready Thank You

{{out}}

<pre>

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

Non-interactive random switch between states.

(de atm NIL

(state '(ready)

(nil (prinl "quit")) ) ) )

(do 3

{{out}}

<pre>

=={{header|Prolog}}==

 

state(ready, quit, exit).

state(waiting, select, dispense).

act(NextState).

{{out}}

<pre>

=={{header|Python}}==

{{works with|Python 3}}

Actually two of them. The main FSM described in the task and a second one of the Acceptor variety described on

the WP page to get the input from the user.

if __name__ == "__main__":

finite_state_machine('ready','q')

{{out}}

<pre>

 

=={{header|Racket}}==

 

(define states

(let/ec quit

(with-input-from-string "deposit select remove deposit refund quit"

{{out}}

<pre>CURRENT STATE: ready

(formerly Perl 6)

 

 

class StateMachine {

$machine.add-transition("refunding", "ready");

 

 

=={{header|REXX}}==

::* a mixture of uppercase and lowercase text is used for the output messages

::* messages have extra blanks for readability &nbsp; (and options are spelled out)

10: say "Press D (deposit) or Q (quit)" /*display a prompt (message) to term. */

20: $=inkey(); upper $ /*since this a terminal, uppercase KEY.*/

 

140: say "Refunded" /*display what action just happened. */

{{out|output|text= &nbsp; when using (pressing) the exact same input(s) as the '''BASIC''' entry: &nbsp; &nbsp; <tt> D &nbsp; R &nbsp; D &nbsp; S &nbsp; R &nbsp; Q </tt>}}

<pre>

works withooRexx (and any other REXX).

key and Enter must be pressed-

10: k=inkey('D (deposit) or Q (quit)','DQ')

if k=="D" then signal 50 /*Is response a "D" ? Process deposit.*/

Say 'Invalid key, try again.'

End

{{out}}

<pre>Press D (deposit) or Q (quit) and Enter

Refunded

Press D (deposit) or Q (quit) and Enter</pre>

 

=={{header|VBA}}==

{{trans|Phix}}

READY

WAITING

End Select

Loop

<pre>Machine is READY. (D)eposit or (Q)uit :

D

{{trans|Kotlin}}

{{libheader|Wren-str}}

import "io" for Stdin, Stdout

 

}

 

 

{{out}}

(D)ispense or (Q)uit : q

OK, quitting

</pre>

 

 

If we need true state to state hops, we could use tail recursion (another name for goto).

var bank=0, item=Void;

fcn deposit(coin){ bank=coin }

}

 

program=program.replace("(",".fp("); // deposit(10)-->deposit.fp(10)

a,b,p := 0,0,Sink("class P(FSM){ state(); ");

// println(program); // WTH did I just do?

Compiler.Compiler.compileText(program)(); // compile and run our little FSM

The above is converted to:

state();

act(select.fp());

act( select.fp("snickers"));

act( take.fp());

The .fp() is function application (ie deferred execution) so I can extract the

function name and print it.