turing_machine 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6270dca8cb1652af9e145537e52bb199d0cd7190
-  data.tar.gz: 3f57b50ac59a9849fe4d59640d166aeaf8166446
+  metadata.gz: 6343fe9455c4501953afaaefc30d0705f348528a
+  data.tar.gz: 662f0eedd0069a630a6d3ac22a1cd3fa1a895b15
 SHA512:
-  metadata.gz: 440063906e7969e16d560a98878e9ee2e3eb85916ffd06cb60cf438d6d4d7b836b6693da4e07d9edc607b509c2445d1104ae5b453d18a36f0c9ff527bbf56536
-  data.tar.gz: fd2ee8011de8838ddb7ab259ae9b2ae2ed42d3664a2401202a4441e094cef67e4b5e974da29c651b334822db38cd2e0f043b045f86f86109149809fb72fdca23
+  metadata.gz: 40f2436cfdcc9da7fd82146e84fb81dbeb505914b6fa905b199cc091771b328cec3c8ed7d7b10cc2e43b8bc40d62f2c18ca4de10d2296678fa83191af83fdcc3
+  data.tar.gz: 3a67ca0e6a8bad420e241bc974979d627c2ccb45691be3a4af4d02d3a9c5f3c71e2b11d508452243289a2203c2d511c1f4afe529908bea2dbdac25a85d6ab798

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--order=random

data/README.md

@@ -6,9 +6,7 @@ TuringMachine
 
 ![Photo of Alan Turing](alan-turing2.jpg)
 
-Currently, in version 0.0.2, you could just run the hardcoded 3 states busy beaver
-algorithm. There is nothing to tweak.
-I wish to be able to run any instruction sets in a very near future.
+A Turing machine that can run (almost) (one day maybe) (I hope) any instruction set.
 
 ## Installation
 
@@ -18,11 +16,18 @@ Install it with:
 
 ## Usage
 
-    $ turing_machine
+Look at some well-known instruction sets in [instruction_sets](instruction_sets)
+or create your own. Then run the Turing machine with, for example:
+
+    $ turing_machine instruction_sets/busy_beaver_1
+
+Look at the
+[InstructionsParser class](lib/turing_machine/instructions_parser.rb) for a
+documentation of the instruction format.
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/turing_machine/fork )
+1. Fork it ( https://github.com/lkdjiin/turing_machine/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/bin/turing_machine

@@ -4,19 +4,26 @@ require 'turing_machine'
 
 include TuringMachine
 
-instructions = {
-  ['0', 'A'] => {write: '1', move: 'R', next_state: 'B'},
-  ['1', 'A'] => {write: '1', move: 'L', next_state: 'C'},
-  ['0', 'B'] => {write: '1', move: 'L', next_state: 'A'},
-  ['1', 'B'] => {write: '1', move: 'R', next_state: 'B'},
-  ['0', 'C'] => {write: '1', move: 'L', next_state: 'B'},
-  ['1', 'C'] => {write: '1', move: 'R', next_state: 'HALT'},
-}
+if ARGV[0].nil?
+  exit(1)
+else
+  filename = ARGV[0]
+end
+
+if File.exist?(filename)
+  raw_instructions = IO.read(filename)
+else
+  exit(2)
+end
+
+parser = InstructionsParser.new(raw_instructions)
+instructions = parser.parse
 
 initial_state = 'A'
 
 instance = Instance.new(instructions, initial_state)
 
+# This should be testable.
 loop do
   puts instance.to_s
   break if instance.halted?

data/instruction_sets/README.md

@@ -0,0 +1,9 @@
+Examples of instruction sets for the Turing machine
+===================================================
+
+- `busy_beaver_1` : Busy beaver one state
+- `busy_beaver_2` : Busy beaver two states
+- `busy_beaver_3` : Busy beaver three states
+- `busy_beaver_3-2` : Another busy beaver three states
+- `busy_beaver_4` : Busy beaver four states
+- `write101` : Write the number 101

data/instruction_sets/busy_beaver_1

@@ -0,0 +1 @@
+0 A => 1 R HALT

data/instruction_sets/busy_beaver_2

@@ -0,0 +1,4 @@
+0 A => 1 R B
+1 A => 1 L B
+0 B => 1 L A
+1 B => 1 R HALT

data/instruction_sets/busy_beaver_3

@@ -0,0 +1,6 @@
+0 A => 1 R B
+1 A => 1 L C
+0 B => 1 L A
+1 B => 1 R B
+0 C => 1 L B
+1 C => 1 R HALT

data/instruction_sets/busy_beaver_3-2

@@ -0,0 +1,6 @@
+0 A => 1 R B
+1 A => 1 R HALT
+0 B => 1 L B
+1 B => 0 R C
+0 C => 1 L C
+1 C => 1 L A

data/instruction_sets/busy_beaver_4

@@ -0,0 +1,8 @@
+0 A => 1 R B
+1 A => 1 L B
+0 B => 1 L A
+1 B => 0 L C
+0 C => 1 R HALT
+1 C => 1 L D
+0 D => 1 R D
+1 D => 0 R A

data/instruction_sets/copy_with_data

@@ -0,0 +1,13 @@
+0 A  => 1 L B
+0 B  => 1 L C
+0 C  => 1 N s1
+0 s1 => N N HALT
+1 s1 => 0 R s2
+0 s2 => 0 R s3
+1 s2 => 1 R s2
+0 s3 => 1 L s4
+1 s3 => 1 R s3
+0 s4 => 0 L s5
+1 s4 => 1 L s4
+0 s5 => 1 R s1
+1 s5 => 1 L s5

data/instruction_sets/write101

@@ -0,0 +1,3 @@
+0 A => 1 R B
+0 B => 0 R C
+0 C => 1 R HALT

data/lib/turing_machine/instance.rb

@@ -4,7 +4,7 @@ module TuringMachine
   class Instance
 
     def initialize(instructions, initial_state)
-      @instruction = Instruction.new(instructions)
+      @instructions = Instructions.new(instructions)
       @state = StateRegister.new(initial_state)
       @tape = Tape.new
       @sequence = 1
@@ -33,8 +33,9 @@ module TuringMachine
     end
 
     def update_tape(current_action)
-      @tape.head = current_action[:write]
-      current_action[:move] == 'L' ? @tape.shift_left : @tape.shift_right
+      @tape.head = current_action[:write] unless current_action[:write] == 'N'
+      @tape.shift_left if current_action[:move] == 'L'
+      @tape.shift_right if current_action[:move] == 'R'
     end
 
     def update_state(current_action)
@@ -42,7 +43,7 @@ module TuringMachine
     end
 
     def action
-      @instruction.for(@tape.head, @state.current)
+      @instructions.get(@tape.head, @state.current)
     end
 
     def instr_to_s

data/lib/turing_machine/{instruction.rb → instructions.rb}

@@ -1,13 +1,13 @@
 module TuringMachine
 
   # Public: The instruction table of a Turing machine.
-  class Instruction
+  class Instructions
 
     def initialize(table)
       @table = table
     end
 
-    def for(symbol, state)
+    def get(symbol, state)
       @table[[symbol, state]]
     end
 

data/lib/turing_machine/instructions_parser.rb

@@ -0,0 +1,55 @@
+module TuringMachine
+
+  # Public: Parser for a newline separated instruction set.
+  #
+  # Instruction format
+  # ------------------
+  #
+  # Here is an example file with four instructions :
+  #
+  # ```
+  # 0 A => 1 R B
+  # 1 A => 1 L B
+  # 0 B => 1 L A
+  # 1 B => 1 R HALT
+  # ```
+  #
+  # So each instruction is :
+  #
+  # ```
+  # scanned-symbol  current-state  =>  symbol-to-write  move  next-state
+  # ```
+  #
+  # `symbol-to-write` is usually `1` or `0`. Note that `N` is a special
+  # symbol meaning «write nothing».
+  #
+  # `move` could be either `L` for left, `R` for right, or `N` for no
+  # movement.
+  class InstructionsParser
+
+    def initialize(raw_instructions)
+      @lines = raw_instructions.split("\n")
+      @instructions = {}
+    end
+
+    def parse
+      build_instructions
+      @instructions
+    end
+
+    private
+
+    def build_instructions
+      @lines.each do |instruction|
+        keys, value = instruction.split('=>')
+        key_symbol, key_state = keys.split
+        write, move, next_state = value.split
+        @instructions[[key_symbol, key_state]] = {
+          write: write, move: move, next_state: next_state
+        }
+      end
+    end
+
+  end
+
+end

data/lib/turing_machine/tape.rb

@@ -6,8 +6,8 @@ module TuringMachine
     def initialize
       # @symbols = [ '0' ]
       # @index = 0
-      @symbols = Array.new(10) { '0' }
-      @index = 4
+      @symbols = Array.new(40) { '0' }
+      @index = 19
     end
 
     attr_reader :index

data/lib/turing_machine/version.rb

@@ -1,3 +1,3 @@
 module TuringMachine
-  VERSION = "0.0.2"
+  VERSION = "0.2.0"
 end

data/lib/turing_machine.rb

@@ -1,7 +1,8 @@
 require "turing_machine/version"
 require 'turing_machine/tape'
 require 'turing_machine/state_register'
-require 'turing_machine/instruction'
+require 'turing_machine/instructions'
+require 'turing_machine/instructions_parser'
 require 'turing_machine/instance'
 
 module TuringMachine

data/spec/instance_spec.rb

@@ -16,19 +16,46 @@ initial_state = 'A'
 describe Instance do
   it 'produces an output' do
     instance = Instance.new(instructions, initial_state)
-    expected = "  1 0000000000 A -> 1RB\n" +
-               "        ^"
+    expected = "  1 0000000000000000000000000000000000000000 A -> 1RB\n" +
+               "                       ^"
     expect(instance.to_s).to eq expected
   end
 
   it 'computes a step' do
     instance = Instance.new(instructions, initial_state)
     instance.proceed
-    expected = "  2 0000100000 B -> 1LA\n" +
-               "         ^"
+    expected = "  2 0000000000000000000100000000000000000000 B -> 1LA\n" +
+               "                        ^"
     expect(instance.to_s).to eq expected
   end
 
+  describe 'null movement' do
+    it 'does not move the head' do
+      instructions = {
+        ['0', 'A'] => {write: '1', move: 'N', next_state: 'HALT'}
+      }
+      instance = Instance.new(instructions, initial_state)
+      instance.proceed
+      expected = "  2 0000000000000000000100000000000000000000 HALT\n" +
+                 "                       ^"
+      expect(instance.to_s).to eq expected
+    end
+  end
+
+  describe 'null write' do
+    it 'does not write the current cell' do
+      instructions = {
+        ['0', 'A'] => {write: 'N', move: 'N', next_state: 'HALT'}
+      }
+      instance = Instance.new(instructions, initial_state)
+      instance.proceed
+      expected = "  2 0000000000000000000000000000000000000000 HALT\n" +
+                 "                       ^"
+      expect(instance.to_s).to eq expected
+
+    end
+  end
+
   context 'when halted' do
 
     it 'tells if the machine is halted' do
@@ -47,8 +74,8 @@ describe Instance do
       }
       instance = Instance.new(instructions, initial_state)
       instance.proceed
-      expected = "  2 0000100000 HALT\n" +
-                 "         ^"
+      expected = "  2 0000000000000000000100000000000000000000 HALT\n" +
+                 "                        ^"
       expect(instance.to_s).to eq expected
     end
 

data/spec/instructions_parser_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+include TuringMachine
+
+describe InstructionsParser do
+
+  let(:busy_beaver_1) { "0 A => 1 R HALT" }
+
+  let(:busy_beaver_2) do
+    "0 A => 1 R B\n1 A => 1 L B\n0 B => 1 L A\n1 B => 1 R HALT"
+  end
+
+  describe '#parse' do
+    it 'returns Instruction' do
+      parser = InstructionsParser.new(busy_beaver_1)
+      value = parser.parse
+      expect(value).to be_a Hash
+    end
+  end
+
+  context 'when parsing busy beaver 1 state' do
+    it 'parses the single instruction' do
+      parser = InstructionsParser.new(busy_beaver_1)
+      value = parser.parse
+      expected = {write: '1', move: 'R', next_state: 'HALT'}
+      expect(value[['0', 'A']]).to eq expected
+    end
+  end
+
+  context 'when parsing busy beaver 2 states' do
+    it 'parses all four instructions' do
+      parser = InstructionsParser.new(busy_beaver_2)
+      value = parser.parse
+      expected = {write: '1', move: 'R', next_state: 'HALT'}
+      expect(value[['1', 'B']]).to eq expected
+    end
+  end
+
+end

data/spec/{instruction_spec.rb → instructions_spec.rb}

@@ -2,17 +2,17 @@ require 'spec_helper'
 
 include TuringMachine
 
-describe Instruction do
+describe Instructions do
 
-  let(:instruction) do
-    Instruction.new({
+  let(:instructions) do
+    Instructions.new({
       ['0', 'A'] => {write: '1', move: 'R', next_state: 'B'},
       ['1', 'A'] => {write: '1', move: 'L', next_state: 'C'},
     })
   end
 
   it 'finds actions' do
-    hash = instruction.for('0', 'A')
+    hash = instructions.get('0', 'A')
     expect(hash[:write]).to eq '1'
     expect(hash[:move]).to eq 'R'
     expect(hash[:next_state]).to eq 'B'

data/spec/tape_spec.rb

@@ -44,7 +44,7 @@ describe Tape do
   end
 
   it 'has a string representation' do
-    expect("#{tape}").to eq '0000000000'
+    expect("#{tape}").to eq '0' * 40
   end
 
 end

data/turing_machine.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = TuringMachine::VERSION
   spec.authors       = ["Xavier Nayrac"]
   spec.email         = ["xavier.nayrac@gmail.com"]
-  spec.summary       = %q{Turing machine}
-  spec.description   = %q{Turing machine}
+  spec.summary       = %q{A Turing machine}
+  spec.description   = %q{A Turing machine that can run your instruction set}
   spec.homepage      = "http://lkdjiin.github.com/turing_machine/"
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turing_machine
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Xavier Nayrac
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-01 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,7 +94,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
-description: Turing machine
+description: A Turing machine that can run your instruction set
 email:
 - xavier.nayrac@gmail.com
 executables:
@@ -112,14 +112,24 @@ files:
 - Rakefile
 - alan-turing2.jpg
 - bin/turing_machine
+- instruction_sets/README.md
+- instruction_sets/busy_beaver_1
+- instruction_sets/busy_beaver_2
+- instruction_sets/busy_beaver_3
+- instruction_sets/busy_beaver_3-2
+- instruction_sets/busy_beaver_4
+- instruction_sets/copy_with_data
+- instruction_sets/write101
 - lib/turing_machine.rb
 - lib/turing_machine/instance.rb
-- lib/turing_machine/instruction.rb
+- lib/turing_machine/instructions.rb
+- lib/turing_machine/instructions_parser.rb
 - lib/turing_machine/state_register.rb
 - lib/turing_machine/tape.rb
 - lib/turing_machine/version.rb
 - spec/instance_spec.rb
-- spec/instruction_spec.rb
+- spec/instructions_parser_spec.rb
+- spec/instructions_spec.rb
 - spec/spec_helper.rb
 - spec/state_register_spec.rb
 - spec/tape_spec.rb
@@ -148,10 +158,11 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Turing machine
+summary: A Turing machine
 test_files:
 - spec/instance_spec.rb
-- spec/instruction_spec.rb
+- spec/instructions_parser_spec.rb
+- spec/instructions_spec.rb
 - spec/spec_helper.rb
 - spec/state_register_spec.rb
 - spec/tape_spec.rb