nudge 0.0.2 → 0.1.0

data/.gitignore

@@ -5,3 +5,4 @@ nudge.gemspec
 *.aux
 *.dvi
 *.log
+exploring_nudge

data/Rakefile

@@ -4,19 +4,23 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "nudge"
-    gemspec.summary = "Genetic Programming in the Nudge language"
-    gemspec.description = "DOES NOT WORK YET. The nudge gem will provide a simple framework for building, running and managing genetic programming experiments which automatically discover algorithms and equations to solve well-defined target problems. It depends on CouchDB and Ruby 1.9+"
+    gemspec.summary = "Nudge Language interpreter"
+    gemspec.description = "Provides a Ruby library & CLI implementing a flexible Nudge Language interpreter, plus a set of generators for adding domain-specific instructions and types."
     gemspec.email = "bill@vagueinnovation.com"
-    gemspec.homepage = "http://github.com/Vaguery/PragGP"
-    gemspec.authors = ["Bill Tozier", "Trek Glowacki"]
+    gemspec.homepage = "http://github.com/Vaguery/Nudge"
+    gemspec.authors = ["Bill Tozier", "Trek Glowacki", "Jesse Sielaff"]
     
+    # Ruby
     gemspec.required_ruby_version = '>= 1.9.1'
     
-    gemspec.add_dependency('couchrest', '>= 0.33')
-    gemspec.add_dependency('sinatra', '>= 0.9.4')
+    # dependencies
     gemspec.add_dependency('treetop', '>= 1.4.3')
-    gemspec.add_dependency('polyglot', '>= 0.2.9')
     gemspec.add_dependency('activesupport', '>= 2.3.5')
+    
+    # files
+    gemspec.files.exclude '_spikes/**'
+    gemspec.files.exclude('exploring_nudge/**')
+    
   end
   
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/lib/instructions/bool/bool_and.rb

@@ -0,0 +1,19 @@
+class BoolAndInstruction < Instruction
+  
+  def preconditions?
+    needs :bool, 2
+  end
+  
+  def setup
+    @arg1 = @context.pop_value(:bool)
+    @arg2 = @context.pop_value(:bool)
+  end
+  
+  def derive
+    @result = ValuePoint.new("bool", @arg1 && @arg2)
+  end
+  
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/bool/bool_define.rb

@@ -0,0 +1,6 @@
+class BoolDefineInstruction < Instruction
+  include DefineInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_depth.rb

@@ -0,0 +1,6 @@
+class BoolDepthInstruction < Instruction
+  include DepthInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_duplicate.rb

@@ -0,0 +1,6 @@
+class BoolDuplicateInstruction < Instruction
+  include DuplicateInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_equal_q.rb

@@ -0,0 +1,19 @@
+class BoolEqualQInstruction < Instruction
+  
+  def preconditions?
+    needs :bool, 2
+  end
+  
+  def setup
+    @arg1 = @context.pop_value(:bool)
+    @arg2 = @context.pop_value(:bool)
+  end
+  
+  def derive
+    @result = ValuePoint.new("bool", @arg1 == @arg2)
+  end
+  
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/bool/bool_flush.rb

@@ -0,0 +1,6 @@
+class BoolFlushInstruction < Instruction
+  include FlushInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_not.rb

@@ -0,0 +1,18 @@
+class BoolNotInstruction < Instruction
+  
+  def preconditions?
+    needs :bool, 1
+  end
+  
+  def setup
+    @arg1 = @context.pop_value(:bool)
+  end
+  
+  def derive
+    @result = ValuePoint.new("bool", !@arg1)
+  end
+  
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/bool/bool_or.rb

@@ -0,0 +1,19 @@
+class BoolOrInstruction < Instruction
+  
+  def preconditions?
+    needs :bool, 2
+  end
+  
+  def setup
+    @arg1 = @context.pop_value(:bool)
+    @arg2 = @context.pop_value(:bool)
+  end
+  
+  def derive
+    @result = ValuePoint.new("bool", @arg1 || @arg2)
+  end
+  
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/bool/bool_pop.rb

@@ -0,0 +1,6 @@
+class BoolPopInstruction < Instruction
+  include PopInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_random.rb

@@ -0,0 +1,13 @@
+class BoolRandomInstruction < Instruction
+  def preconditions?
+    true # no preconditions
+  end
+  def setup
+  end
+  def derive
+    @result = ValuePoint.new("bool", BoolType.any_value)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/bool/bool_rotate.rb

@@ -0,0 +1,6 @@
+class BoolRotateInstruction < Instruction
+  include RotateInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_shove.rb

@@ -0,0 +1,6 @@
+class BoolShoveInstruction < Instruction
+  include ShoveInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_swap.rb

@@ -0,0 +1,6 @@
+class BoolSwapInstruction < Instruction
+  include SwapInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_xor.rb

@@ -0,0 +1,19 @@
+class BoolXorInstruction < Instruction
+  
+  def preconditions?
+    needs :bool, 2
+  end
+  
+  def setup
+    @arg1 = @context.pop_value(:bool)
+    @arg2 = @context.pop_value(:bool)
+  end
+  
+  def derive
+    @result = ValuePoint.new("bool", @arg1 != @arg2)
+  end
+  
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/bool/bool_yank.rb

@@ -0,0 +1,6 @@
+class BoolYankInstruction < Instruction
+  include YankInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/bool/bool_yankdup.rb

@@ -0,0 +1,6 @@
+class BoolYankdupInstruction < Instruction
+  include YankdupInstruction
+  def initialize(context)
+    super(context, :bool)
+  end
+end

data/lib/instructions/code/code_atom_q.rb

@@ -0,0 +1,16 @@
+class CodeAtomQInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+  end
+  def setup
+    arg_blueprint = @context.pop_value(:code)
+    @arg1 = NudgeProgram.new(arg_blueprint)
+  end
+  def derive
+    atomQ = @arg1.parses? && @arg1.points == 1
+    @result = ValuePoint.new("bool", atomQ)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/code/code_backbone_points.rb

@@ -0,0 +1,24 @@
+class CodeBackbonePointsInstruction < Instruction
+  
+  def preconditions?
+    needs :code, 1
+  end
+  
+  def setup
+    arg_blueprint = @context.pop_value(:code)
+    @parsed = NudgeProgram.new(arg_blueprint)
+  end
+  
+  def derive
+    if @parsed.parses?
+      pts = @parsed.linked_code.kind_of?(CodeblockPoint) ? @parsed[1].contents.length : 0
+    else
+      pts = 0
+    end
+    @result = ValuePoint.new("int",pts)
+  end
+  
+  def cleanup
+    pushes :int, @result
+  end
+end

data/lib/instructions/code/code_car.rb

@@ -0,0 +1,20 @@
+class CodeCarInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+  end
+  def setup
+    @arg = @context.pop_value(:code)
+  end
+  def derive
+    tree = NudgeProgram.new(@arg)
+    if tree.linked_code.kind_of?(CodeblockPoint) && (tree.points > 2)
+      new_tree = tree[1].contents[0]
+    else
+      new_tree = tree
+    end
+    @result = ValuePoint.new("code", new_tree.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_cdr.rb

@@ -0,0 +1,20 @@
+class CodeCdrInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+  end
+  def setup
+    @arg = @context.pop_value(:code)
+  end
+  def derive
+    tree = NudgeProgram.new(@arg)
+    if tree.linked_code.kind_of?(CodeblockPoint) && (tree.points > 2)
+      new_tree = tree.delete_point(2)
+    else
+      new_tree = CodeblockPoint.new([])
+    end
+    @result = ValuePoint.new("code", new_tree.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_concatenate.rb

@@ -0,0 +1,31 @@
+class CodeConcatenateInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    t1 = NudgeProgram.new(@arg1)
+    t2 = NudgeProgram.new(@arg2)
+    if t1.parses? && t2.parses?
+      if t1.linked_code.kind_of?(CodeblockPoint)
+        if t2.linked_code.kind_of?(CodeblockPoint)
+          new_tree = t1[1].contents + t2[1].contents
+        else
+          new_tree = t1[1].contents << t2.linked_code
+        end
+      else
+        new_tree = [t1.linked_code, t2.linked_code]
+      end
+      listed = CodeblockPoint.new(new_tree).blueprint
+      @result = ValuePoint.new("code", listed)
+    else
+      @result = ValuePoint.new("code", "block {}")
+    end
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_cons.rb

@@ -0,0 +1,25 @@
+# This is a tricky one to translate from Push, which assumes a very Lisp-like list structure. Here we'll simply build a new block with the consed item first, and the original code second.
+
+class CodeConsInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    t1 = NudgeProgram.new(@arg1)
+    t2 = NudgeProgram.new(@arg2)
+    if t1.parses? && t2.parses?
+      consed_tree = t2.insert_point_before(1,t1.linked_code)
+    else
+      raise InstructionMethodError,
+        "#{self.class.to_nudgecode} cannot parse the arguments"
+    end
+    @result = ValuePoint.new("code", consed_tree.blueprint)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_container.rb

@@ -0,0 +1,28 @@
+# Pushes the "container" of the second CODE stack item within the first CODE stack item onto the CODE stack. If second item contains the first anywhere (i.e. in any nested list) then the container is the smallest sub-list that contains but is not equal to the first instance. For example, if the top piece of code is "( B ( C ( A ) ) ( D ( A ) ) )" and the second piece of code is "( A )" then this pushes ( C ( A ) ). Pushes an empty list if there is no such container
+
+
+class CodeContainerInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @searching_in_this = @context.pop_value(:code)
+    @searching_for_this = @context.pop_value(:code)
+  end
+  def derive
+    needle = NudgeProgram.new(@searching_for_this).linked_code.blueprint
+    haystack_program = NudgeProgram.new(@searching_in_this)
+    haystack = haystack_program.linked_code
+    
+    if needle == haystack.blueprint
+      result_value = "block {}"
+    else
+      where = haystack.find_index {|point| point.blueprint == needle}
+      result_value = where.nil? ? "block {}" : haystack_program[where].blueprint
+    end
+    @result = ValuePoint.new("code", result_value)
+  end
+  def cleanup
+    pushes :code, @result
+  end
+end

data/lib/instructions/code/code_contains_q.rb

@@ -0,0 +1,22 @@
+class CodeContainsQInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    looking_for_this = NudgeProgram.new(@arg1)
+    tree = NudgeProgram.new(@arg2)
+    if tree.parses? && looking_for_this.parses?
+      found = tree.linked_code.any? {|point| point.blueprint == looking_for_this.blueprint}
+    else
+      found = false
+    end
+    @result = ValuePoint.new("bool", found)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/code/code_define.rb

@@ -0,0 +1,21 @@
+class CodeDefineInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+    needs :name, 1
+  end
+  def setup
+    @ref = @context.pop(:name).name
+    @code = @context.pop_value(:code)
+  end
+  def derive
+    if @context.variables.keys.include?(@ref)
+      raise InstructionMethodError, "#{self.class.to_nudgecode} cannot change the value of a variable"
+    else
+      new_value = NudgeProgram.new(@code).linked_code
+      raise InstructionMethodError, "#{self.class.to_nudgecode} cannot parse '#{@code}'" if new_value.is_a?(NilPoint)
+      @context.names[@ref] = new_value
+    end
+  end
+  def cleanup
+  end
+end

data/lib/instructions/code/code_depth.rb

@@ -0,0 +1,6 @@
+class CodeDepthInstruction < Instruction
+  include DepthInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_discrepancy.rb

@@ -0,0 +1,29 @@
+# ORIGINAL DESCRIPTION in Push3:
+# Pushes a measure of the discrepancy between the top two CODE stack items onto the INTEGER stack. This will be zero if the top two items are equivalent, and will be higher the 'more different' the items are from one another. The calculation is as follows:
+# 1. Construct a list of all of the unique items in both of the lists (where uniqueness is determined by equalp). Sub-lists and atoms all count as items.
+# 2. Initialize the result to zero.
+# 3. For each unique item increment the result by the difference between the number of occurrences of the item in the two pieces of code.
+# 4. Push the result.
+
+
+class CodeDiscrepancyInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+     # collect string blueprints of every point
+    parts_of_1 = NudgeProgram.new(@arg1).linked_code.collect {|pt| pt.blueprint}
+    parts_of_2 = NudgeProgram.new(@arg2).linked_code.collect {|pt| pt.blueprint}
+    unique_parts = (parts_of_1.uniq + parts_of_2.uniq).reject {|i| i == ""}
+    summed_differences = unique_parts.inject(0) {|sum, uniq_string| sum +
+      (parts_of_2.count(uniq_string) - parts_of_1.count(uniq_string)).abs}
+    @result = ValuePoint.new("int", summed_differences)
+  end
+  def cleanup
+    pushes :int, @result
+  end
+end

data/lib/instructions/code/code_do_count.rb

@@ -0,0 +1,27 @@
+# Again, the original description of this instruction appears to be confusing "CODE.DO*RANGE" with "EXEC.DO*RANGE"; I've made the adjustment to the code so that the behavior is as described, not the implementation.
+
+class CodeDoCountInstruction < Instruction
+  def preconditions?
+    needs ExecDoRangeInstruction
+    needs :code, 1
+    needs :int, 1
+  end
+  
+  def setup
+    @destination = @context.pop(:int)
+    @code = @context.pop_value(:code)
+    raise InstructionMethodError,
+      "#{self.class.to_nudgecode} needs a positive argument" if @destination.value < 1
+  end
+  
+  def derive
+    @codeblock = NudgeProgram.new(@code).linked_code
+    @one_less = ValuePoint.new("int",@destination.value-1)
+  end
+  
+  def cleanup
+    recursor = CodeblockPoint.new([ValuePoint.new("int",0), @one_less,
+      InstructionPoint.new("exec_do_range"),@codeblock])
+    pushes :exec, recursor
+  end
+end

data/lib/instructions/code/code_do_range.rb

@@ -0,0 +1,42 @@
+# ORIGINAL DESCRIPTION: An iteration instruction that executes the top item on the CODE stack a number of times that depends on the top two integers, while also pushing the loop counter onto the INTEGER stack for possible access during the execution of the body of the loop. The top integer is the "destination index" and the second integer is the "current index." First the code and the integer arguments are saved locally and popped. Then the integers are compared. If the integers are equal then the current index is pushed onto the INTEGER stack and the code (which is the "body" of the loop) is pushed onto the EXEC stack for subsequent execution. If the integers are not equal then the current index will still be pushed onto the INTEGER stack but two items will be pushed onto the EXEC stack -- first a recursive call to CODE.DO*RANGE (with the same code and destination index, but with a current index that has been either incremented or decremented by 1 to be closer to the destination index) and then the body code. Note that the range is inclusive of both endpoints; a call with integer arguments 3 and 5 will cause its body to be executed 3 times, with the loop counter having the values 3, 4, and 5. Note also that one can specify a loop that "counts down" by providing a destination index that is less than the specified current index.
+
+# That description must be flawed; "a recursive call to CODE.DO*RANGE" would not run the same code, but rather run the next piece of code from the :code stack. I'm interpreting it as a typo, and using exec_do_range instead, since that will have the desired outcome without running through all kinds of weird :code items.
+
+class CodeDoRangeInstruction < Instruction
+  def preconditions?
+    needs ExecDoRangeInstruction
+    needs :code, 1
+    needs :int, 2
+  end
+  
+  def setup
+    @destination = @context.pop(:int)
+    @counter = @context.pop(:int)
+    @code = @context.pop_value(:code)
+  end
+  
+  def derive
+    @codeblock = NudgeProgram.new(@code).linked_code
+    @finished = false
+    if @counter.value == @destination.value
+      @finished = true
+    elsif @counter.value < @destination.value
+      @new_counter = ValuePoint.new("int", @counter.value + 1)
+    else
+      @new_counter = ValuePoint.new("int", @counter.value - 1)
+    end
+    @recursor = CodeblockPoint.new([@new_counter, @destination,
+      InstructionPoint.new("exec_do_range"),@codeblock])
+  end
+  
+  def cleanup
+    if @finished
+      pushes :int, @counter
+      pushes :exec, @codeblock
+    else
+      pushes :int, @counter
+      pushes :exec, @recursor
+      pushes :exec, @codeblock
+    end
+  end
+end

data/lib/instructions/code/code_do_times.rb

@@ -0,0 +1,38 @@
+# Again, the original description of this instruction appears to be confusing "CODE.DO*RANGE" with "EXEC.DO*RANGE"; I've made the adjustment to the code so that the behavior is as described, not the implementation.
+
+class CodeDoTimesInstruction < Instruction
+  def preconditions?
+    needs ExecDoTimesInstruction
+    needs :code, 1
+    needs :int, 2
+  end
+  
+  def setup
+    @destination = @context.pop(:int)
+    @counter = @context.pop(:int)
+    @code = @context.pop_value(:code)
+  end
+  
+  def derive
+    @finished = false
+    if @counter.value == @destination.value
+      @finished = true
+    elsif @counter.value < @destination.value
+      @new_counter = ValuePoint.new("int", @counter.value + 1)
+    else
+      @new_counter = ValuePoint.new("int", @counter.value - 1)
+    end
+    @codeblock = NudgeProgram.new(@code).linked_code
+  end
+  
+  def cleanup
+    if @finished
+      pushes :exec, @codeblock
+    else
+      recursor = CodeblockPoint.new([@new_counter, @destination,
+        InstructionPoint.new("exec_do_times"),@codeblock])
+      pushes :exec, recursor
+      pushes :exec, @codeblock
+    end
+  end
+end

data/lib/instructions/code/code_duplicate.rb

@@ -0,0 +1,6 @@
+class CodeDuplicateInstruction < Instruction
+  include DuplicateInstruction
+  def initialize(context)
+    super(context, :code)
+  end
+end

data/lib/instructions/code/code_equal_q.rb

@@ -0,0 +1,17 @@
+class CodeEqualQInstruction < Instruction
+  def preconditions?
+    needs :code, 2
+  end
+  def setup
+    @arg2 = @context.pop_value(:code)
+    @arg1 = @context.pop_value(:code)
+  end
+  def derive
+    c1 = NudgeProgram.new(@arg1).blueprint
+    c2 = NudgeProgram.new(@arg2).blueprint
+    @result = ValuePoint.new("bool", c1 == c2)
+  end
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/lib/instructions/code/code_execute.rb

@@ -0,0 +1,19 @@
+class CodeExecuteInstruction < Instruction
+  def preconditions?
+    needs :code, 1
+  end
+  def setup
+    @arg = @context.pop_value(:code)
+  end
+  def derive
+    that_becomes = NudgeProgram.new(@arg)
+    if that_becomes.parses?
+      @result = NudgeProgram.new(@arg).linked_code
+    else
+      @result = CodeblockPoint.new([])
+    end
+  end
+  def cleanup
+    pushes :exec, @result
+  end
+end