Struct Classic 

pub struct Classic<S: Symbol> { /* private fields */ }

Classic is a common TuringMachine realization that can be used freely for program execution.

Implementations

impl<S: Symbol> Classic<S>

pub fn new(program: Program<S>, default: S) -> Result<Self, String>

Constructs a new Classic Turing machine from the program Program and the default symbol Symbol.

Returns [Ok(Classic)] when the default symbol is in the program alphabet otherwise [Err(String)] with diagnostic information.

Examples

Trying to return the new machine with a mismatched default symbol:

use turing_machine_rs::instruction::State;
use turing_machine_rs::machines::Classic;
use turing_machine_rs::program::Program;

let program = Program::new(vec!['0', '1'], State(1));
let machine = Classic::new(program, '!');

assert!(machine.is_err());

Successful creation:

use turing_machine_rs::instruction::State;
use turing_machine_rs::machines::Classic;
use turing_machine_rs::program::Program;

let program = Program::new(vec!['0', '1'], State(1));
let machine = Classic::new(program, '0');

assert!(machine.is_ok());

Examples found in repository

examples/nice_test.rs (line 25)

fn main() -> Result<(), String> {
    let alphabet = vec!['t', 'e', 's', 'n', 'i', 'c', 'e', '_'];
    let mut program = Program::new(alphabet, State(4));
    program.extend([
        (1, 't', 2, 'n', Move::Right),
        (2, 'e', 3, 'i', Move::Right),
        (3, 's', 4, 'c', Move::Right),
        (4, 't', 0, 'e', Move::None),
        // Revers
        (1, 'n', 2, 't', Move::Right),
        (2, 'i', 3, 'e', Move::Right),
        (3, 'c', 4, 's', Move::Right),
        (4, 'e', 0, 't', Move::None),
    ])?;
    let machine = Classic::new(program, '_')?;

    let test = Tape::from("test");
    let nice = machine.translate_nrm(test.clone())?;
    println!(
        "{} {}!",
        String::from_iter(nice.as_vec()),
        String::from_iter(test.as_vec())
    );
    Ok(())
}

examples/binary_addition.rs (line 59)

fn main() -> Result<(), String> {
    let mut program = Program::new(vec![' ', '0', '1', '+'], State(8));
    program.extend([
        // Sub 1, also init zero check
        (1, ' ', 0, ' ', Move::None),
        (1, '0', 1, '0', Move::Left),
        (1, '1', 2, '0', Move::Right),
        (1, '+', 6, '+', Move::Right),
        // Subs part
        (2, ' ', 3, ' ', Move::Left),
        (2, '0', 2, '1', Move::Right),
        // 2, '1' -> Impl
        // 2, '+' -> Err
        //
        // Find + on left
        // 3, ' ' -> Err
        (3, '0', 3, '0', Move::Left),
        (3, '1', 3, '1', Move::Left),
        (3, '+', 4, '+', Move::Left),
        // Add 1
        (4, ' ', 5, '1', Move::Right),
        (4, '0', 5, '1', Move::Right),
        (4, '1', 4, '0', Move::Left),
        // 4, '+' -> Err
        //
        // Find + on rigth
        // 5, ' ' -> Imp
        (5, '0', 5, '0', Move::Right),
        (5, '1', 5, '1', Move::Right),
        (5, '+', 6, '+', Move::Right),
        // Zero check
        (6, ' ', 8, ' ', Move::Left),
        (6, '0', 6, '0', Move::Right),
        (6, '1', 7, '1', Move::Right),
        // 6, '+' -> Err
        //
        // Find last num
        (7, ' ', 1, ' ', Move::Left),
        (7, '0', 7, '0', Move::Right),
        (7, '1', 7, '1', Move::Right),
        // 7, '+' -> Err
        //
        // Clear + and after
        // 8, ' ' - Imp
        (8, '0', 8, ' ', Move::Left),
        // 8, '1' - Imp
        (8, '+', 0, ' ', Move::Right),
    ])?;
    let machine = Classic::new(program, ' ')?;

    // Change and try to run this example!
    let lhs = "10101";
    let rhs = "111";
    // -----------------------------------
    let tape = Tape::from(format!("{}+{}", lhs, rhs));

    let res = machine.translate_std(tape)?;
    println!("{} + {} = {}", lhs, rhs, String::from_iter(res.as_vec()));

    Ok(())
}

examples/hyper_machine.rs (line 58)

fn main() -> Result<(), String> {
    use nrm_machines::*;

    let stand = new_stand_machine();
    let zerofy = new_zerofy_machine();
    let l_shift = new_left_shift_machine();
    let r_shift = new_right_shift_machine();
    let trans = new_trans_machine();

    let mut program = Program::new(
        vec![
            stand.clone(),
            zerofy.clone(),
            l_shift.clone(),
            r_shift.clone(),
            trans.clone(),
        ],
        State(9),
    );
    // This is simplest implementation of `change choose second to choose third` machine
    program.extend([
        // Find l_shift
        (1, r_shift.clone(), 1, r_shift.clone(), Move::Right),
        (1, trans.clone(), 1, trans.clone(), Move::Right),
        (1, zerofy.clone(), 1, zerofy.clone(), Move::Right),
        (1, l_shift.clone(), 2, stand.clone(), Move::Left),
        // Clear until r_shift
        (2, zerofy.clone(), 2, stand.clone(), Move::Left),
        (2, trans.clone(), 2, stand.clone(), Move::Left),
        (2, r_shift.clone(), 3, r_shift.clone(), Move::Right),
        //
        // Set second r_shift
        (3, stand.clone(), 4, r_shift.clone(), Move::Right),
        // Set first trans
        (4, stand.clone(), 5, trans.clone(), Move::Right),
        // Set first zerofy
        (5, stand.clone(), 6, zerofy.clone(), Move::Right),
        // Set first l_shift
        (6, stand.clone(), 7, l_shift.clone(), Move::Right),
        // Set second trans
        (7, stand.clone(), 8, trans.clone(), Move::Right),
        // Set second zerofy
        (8, stand.clone(), 9, zerofy.clone(), Move::Right),
        // Set second l_shift and stop execution
        (9, stand.clone(), 0, l_shift.clone(), Move::None),
    ])?;

    let hyper_machine = Classic::new(program, stand.clone())?;
    let choose_second = Tape::new([
        r_shift.clone(),
        trans.clone(),
        zerofy.clone(),
        l_shift.clone(),
    ]);
    let result_choose_third = hyper_machine.translate_nrm(choose_second)?;

    let expected_choose_third = Tape::new([
        r_shift.clone(),
        r_shift.clone(),
        trans.clone(),
        zerofy.clone(),
        l_shift.clone(),
        trans.clone(),
        zerofy.clone(),
        l_shift.clone(),
    ]);

    assert_eq!(expected_choose_third, result_choose_third);
    println!("If you're reading this, hyper machine successful transform choose second machine");

    let tape = Tape::from("0101101110");
    let mut conf = Configuration::new_nrm(tape.clone())?;
    for machine in result_choose_third.as_vec() {
        conf = machine.execute(conf).unwrap();
        conf.state = State(1)
    }
    println!(
        "Choose third machine translate {} into {}",
        String::from_iter(tape.as_vec()),
        String::from_iter(conf.tape().as_vec())
    );

    Ok(())
}

// This module just contains several nrm machines
mod nrm_machines {
    use super::*;

    pub fn new_stand_machine() -> Classic<char> {
        let mut program = Program::new(vec!['0', '1'], State(1));
        program
            .extend([(1, '0', 0, '0', Move::None), (1, '1', 0, '1', Move::None)])
            .unwrap();
        Classic::new(program, '0').unwrap()
    }

    pub fn new_zerofy_machine() -> Classic<char> {
        let mut program = Program::new(vec!['0', '1'], State(4));
        program
            .extend([
                (1, '0', 2, '0', Move::Right),
                (2, '0', 3, '0', Move::Left),
                (2, '1', 2, '1', Move::Right),
                (3, '0', 0, '0', Move::None),
                (3, '1', 4, '0', Move::None),
                (4, '0', 3, '0', Move::Left),
            ])
            .unwrap();
        Classic::new(program, '0').unwrap()
    }

    pub fn new_left_shift_machine() -> Classic<char> {
        let mut program = Program::new(vec!['0', '1'], State(2));
        program
            .extend([
                (1, '0', 2, '0', Move::Left),
                (2, '0', 0, '0', Move::None),
                (2, '1', 2, '1', Move::Left),
            ])
            .unwrap();
        Classic::new(program, '0').unwrap()
    }

    pub fn new_right_shift_machine() -> Classic<char> {
        let mut program = Program::new(vec!['0', '1'], State(2));
        program
            .extend([
                (1, '0', 2, '0', Move::Right),
                (2, '0', 0, '0', Move::None),
                (2, '1', 2, '1', Move::Right),
            ])
            .unwrap();
        Classic::new(program, '0').unwrap()
    }

    pub fn new_trans_machine() -> Classic<char> {
        let mut program = Program::new(vec!['0', '1'], State(19));
        program
            .extend([
                (1, '0', 2, '0', Move::Right),
                (2, '0', 3, '0', Move::None),
                (2, '1', 2, '1', Move::Right),
                (3, '0', 4, '0', Move::Left),
                (4, '0', 7, '0', Move::None),
                (4, '1', 5, '0', Move::None),
                (5, '0', 6, '0', Move::Left),
                (6, '0', 7, '1', Move::None),
                (6, '1', 6, '1', Move::Left),
                (7, '0', 16, '1', Move::None),
                (7, '1', 8, '1', Move::Left),
                (8, '0', 18, '0', Move::Right),
                (8, '1', 9, '0', Move::None),
                (9, '0', 10, '0', Move::Right),
                (10, '0', 11, '1', Move::None),
                (10, '1', 10, '1', Move::Right),
                (11, '1', 12, '1', Move::Left),
                (12, '1', 13, '0', Move::None),
                (13, '0', 14, '0', Move::Left),
                (14, '0', 15, '1', Move::None),
                (14, '1', 14, '1', Move::Left),
                (15, '0', 7, '0', Move::None),
                (15, '1', 7, '1', Move::None),
                (16, '1', 17, '1', Move::Left),
                (17, '0', 19, '0', Move::Right),
                (17, '1', 15, '0', Move::None),
                (18, '0', 0, '0', Move::None),
                (18, '1', 18, '1', Move::Right),
                (19, '1', 0, '0', Move::None),
            ])
            .unwrap();
        Classic::new(program, '0').unwrap()
    }

Trait Implementations

impl<S: Clone + Symbol> Clone for Classic<S>

fn clone(&self) -> Classic<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + Symbol> Debug for Classic<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Symbol> Display for Classic<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S: PartialEq + Symbol> PartialEq for Classic<S>

fn eq(&self, other: &Classic<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Symbol> TuringMachine<S> for Classic<S>

fn execute_once( &self, conf: Configuration<S>, ) -> Result<Configuration<S>, String>

Executes Configuration once by mutation.

Returns [Ok(Configuration)] when an crate::instruction::Instruction exists for the current Configuration symbol and state. And otherwise returns [Err(String)] with diagnostic information.

fn execute_until( &self, conf: Configuration<S>, until: impl Fn(&Configuration<S>) -> bool, ) -> Result<Configuration<S>, String>

Executes Configuration until predicate is false by mutation.

Returns [Ok(Configuration)] when an crate::instruction::Instruction exists for the current Configuration symbol and state. And otherwise returns [Err(String)] with diagnostic information.

fn execute(&self, conf: Configuration<S>) -> Result<Configuration<S>, String>

Executes the crate::program::Program and returns a mutated Configuration using the TuringMachine::execute_until method with the conf.state == 0 predicate. This is the most commonly used method for crate::program::Program execution.

fn translate_std(&self, tape: Tape<S>) -> Result<Tape<S>, String>

Translates and returns a mutated Tape using the TuringMachine::execute method as the Configuration::new_std.

fn translate_nrm(&self, tape: Tape<S>) -> Result<Tape<S>, String>

Translates and returns a mutated Tape using the TuringMachine::execute method as the Configuration::new_nrm.

impl<S: Symbol> With<Classic<S>> for Classic<S>

fn with(&self, other: &Classic<S>) -> Self::Output

Makes superposition with two or more Classic machines by chain. This method accept only Classic struct and can be used only for another Classic machine.

Returns a new [Ok(Classic)] when machines can be concatenated and [Err(String)] with diagnostic information when machines have different alphabets or default symbols.

type Output = Result<Classic<S>, String>

Output type may have several variantions accoriding to the needs.

impl<S: Symbol> With<Classic<S>> for Result<Classic<S>, String>

fn with(&self, other: &Classic<S>) -> Self::Output

Makes superposition with two or more Classic machines by chain. This method accept only Classic struct and can be used only for Result<Classic, String>.

Returns a new [Ok(Classic)] when self is Result::Ok and machines can be concatenated and [Err(String)] when self is Result::Ok but machines have different alphabets or default symbols.

And Returns a copy of [Err(String)] when self is Result::Err.

type Output = Result<Classic<S>, String>

Output type may have several variantions accoriding to the needs.

impl<S: Eq + Symbol> Eq for Classic<S>

impl<S: Symbol> StructuralPartialEq for Classic<S>