nudge 0.0.1 → 0.0.2

data/.gitignore

@@ -1,4 +1,6 @@
 .hg*
+pkg/*
+nudge.gemspec
 *.pdf
 *.aux
 *.dvi

data/Rakefile

@@ -5,16 +5,18 @@ begin
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "nudge"
     gemspec.summary = "Genetic Programming in the Nudge language"
-    gemspec.description = "It's way complicated"
+    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.email = "bill@vagueinnovation.com"
     gemspec.homepage = "http://github.com/Vaguery/PragGP"
     gemspec.authors = ["Bill Tozier", "Trek Glowacki"]
     
-    gemspec.add_dependency('couchrest')
-    gemspec.add_dependency('sinatra')
-    gemspec.add_dependency('treetop')
-    gemspec.add_dependency('polyglot')
-    gemspec.add_dependency('active_support')
+    gemspec.required_ruby_version = '>= 1.9.1'
+    
+    gemspec.add_dependency('couchrest', '>= 0.33')
+    gemspec.add_dependency('sinatra', '>= 0.9.4')
+    gemspec.add_dependency('treetop', '>= 1.4.3')
+    gemspec.add_dependency('polyglot', '>= 0.2.9')
+    gemspec.add_dependency('activesupport', '>= 2.3.5')
   end
   
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/_spikes/nudge3_syntax_spike.txt

@@ -0,0 +1,23 @@
+NUDGECODE:
+
+block {
+  literal «1»
+  literal «2»
+  block {
+    sample «3»
+    sample «4»
+  }
+}
+
+# local values:
+«1» float: 9.128
+«2» code: block {literal code «5» block {sample bool «6»}}
+«3» image: file:///881727183.jpg
+«4» int: 881
+«5» code: block { do int_add do int_multiply }
+«6» bool: false
+
+# local values can include references to other local values, but can never backtrack
+# syntax check: are all local values assigned?
+# syntax check: are all local values strings?
+# semantic check: are there no backward-references?

data/app_generators/nudge/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/app_generators/nudge/nudge_generator.rb

@@ -0,0 +1,73 @@
+class NudgeGenerator < RubiGen::Base
+
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      # Create stubs
+      # m.template "template.rb",  "some_file_after_erb.rb"
+      # m.template_copy_each ["template.rb", "template2.rb"]
+      # m.file     "file",         "some_file_copied"
+      
+      m.file "activate.rb", "activate.rb"
+      
+      # m.file_copy_each ["path/to/file", "path/to/file2"]
+
+      m.dependency "install_rubigen_scripts", [destination_root, 'nudge'],
+        :shebang => options[:shebang], :collision => :force
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |o| options[:author] = o }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      config
+      experiment
+      spec
+      tmp
+    )
+end

data/bin/nudge

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rubigen'
+
+if %w(-v --version).include? ARGV.first
+  require 'nudge/version'
+  puts "#{File.basename($0)} #{Nudge::VERSION}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+source = RubiGen::PathSource.new(:application, 
+  File.join(File.dirname(__FILE__), "../app_generators"))
+RubiGen::Base.reset_sources
+RubiGen::Base.append_sources source
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'nudge')

data/lib/interpreter/interpreter.rb

@@ -101,15 +101,18 @@ module Nudge
     def enable(item)
       if item.superclass == Instruction
         @instructions_library[item] = item.new(self)
-      elsif item.superclass == NudgeType
+      elsif item.include? NudgeType
         @types |= [item]
       end
     end
     
     def active?(item)
+      puts "#{item.inspect} is the item"
       if item.superclass == Instruction
         @instructions_library.include?(item)
-      elsif item.superclass == NudgeType
+      elsif item.include? NudgeType
+        puts "#{@types} is the type list"
+        
         @types.include?(item)
       end
     end
@@ -160,7 +163,7 @@ module Nudge
     def disable(item)
       if item.superclass == Instruction
         @instructions_library.delete(item)
-      elsif item.superclass == NudgeType
+      elsif item.include? NudgeType
         @types.delete(item)
       end
     end

data/lib/interpreter/programPoints.rb

@@ -82,7 +82,7 @@ module Nudge
     def randomize(context)
       raise(ArgumentError,"Random code cannot be created") if context.types == [CodeType]
       newType = context.types.sample
-      @type = newType.to_s.slice(0..-5).downcase
+      @type = newType.to_nudgecode
       if newType != CodeType
         @value = newType.any_value
       else
@@ -123,7 +123,7 @@ module Nudge
     
     def randomize(context)
       newType = context.types.sample
-      @type = newType.to_s.slice(0..-5).downcase
+      @type = newType.to_nudgecode
       if newType != CodeType
         @value = newType.any_value
       else

data/lib/interpreter/types/codeType.rb

@@ -1,108 +1,111 @@
 # coding: utf-8
-
-class CodeType < NudgeType
-  @@defaultPoints = 20
+module NudgeType
   
-  def self.random_skeleton(points=@@defaultPoints, blocks=points/10)
-    blocks = [0,[points,blocks].min].max
+  class CodeType
+    include TypeBehaviors
+    @@defaultPoints = 20
+  
+    def self.random_skeleton(points=@@defaultPoints, blocks=points/10)
+      blocks = [0,[points,blocks].min].max
     
-    if points > 1
-      skel = ["block {"]
-      (points-2).times {skel << "*"}
-      skel << "*}"
-      front = 0
-      (blocks-1).times do
-        until skel[front].include?("*") do
-          a,b = rand(points), rand(points)
-          front,back = [a,b].min, [a,b].max
+      if points > 1
+        skel = ["block {"]
+        (points-2).times {skel << "*"}
+        skel << "*}"
+        front = 0
+        (blocks-1).times do
+          until skel[front].include?("*") do
+            a,b = rand(points), rand(points)
+            front,back = [a,b].min, [a,b].max
+          end
+          skel[front] = skel[front].sub(/\*/," block {")
+          skel[back] = skel[back] + "}"
         end
-        skel[front] = skel[front].sub(/\*/," block {")
-        skel[back] = skel[back] + "}"
-      end
-      skel = skel.join
-    else
-      if blocks>0
-        skel = "block {}"
+        skel = skel.join
       else
-        skel = "*"
+        if blocks>0
+          skel = "block {}"
+        else
+          skel = "*"
+        end
       end
+      return skel
     end
-    return skel
-  end
   
   
-  def self.any_type(types)
-    raise(ArgumentError,"no available NudgeTypes") if types.empty?
-    return types.sample
-  end
+    def self.any_type(types)
+      raise(ArgumentError,"no available NudgeTypes") if types.empty?
+      return types.sample
+    end
   
   
-  def self.any_instruction(instructions)
-    raise(ArgumentError,"no available Instructions") if instructions.empty?
-    return instructions.sample
-  end
+    def self.any_instruction(instructions)
+      raise(ArgumentError,"no available Instructions") if instructions.empty?
+      return instructions.sample
+    end
   
   
-  def self.any_reference(references)
-    raise(ArgumentError,"no available references") if references.empty?
-    return references.sample
-  end
+    def self.any_reference(references)
+      raise(ArgumentError,"no available references") if references.empty?
+      return references.sample
+    end
   
   
-  def self.roulette_wheel(references, instructions, types)
-    basis = Hash["reference", references.length,
-      "instruction", instructions.length,
-      "sample", types.length]
-    sum = basis.values.inject(:+)
-    spin = rand(sum)
-    basis.each do |result,weight|
-      return result if spin <= weight && weight > 0
-      spin -= weight
+    def self.roulette_wheel(references, instructions, types)
+      basis = Hash["reference", references.length,
+        "instruction", instructions.length,
+        "sample", types.length]
+      sum = basis.values.inject(:+)
+      spin = rand(sum)
+      basis.each do |result,weight|
+        return result if spin <= weight && weight > 0
+        spin -= weight
+      end
+      raise "A problem occurred when executing CodeType#roulette_wheel"
     end
-    raise "A problem occurred when executing CodeType#roulette_wheel"
-  end
   
   
-  def self.random_value(context, params = {})
-    points = params[:points] || @@defaultPoints
-    blocks = params[:blocks] || points/10
-    skeleton = params[:skeleton] || self.random_skeleton(points, blocks)
-    instructions = params[:instructions] || context.instructions
-    references = params[:references] || context.references
-    types = params[:types] || context.types
+    def self.random_value(context, params = {})
+      points = params[:points] || @@defaultPoints
+      blocks = params[:blocks] || points/10
+      skeleton = params[:skeleton] || self.random_skeleton(points, blocks)
+      instructions = params[:instructions] || context.instructions
+      references = params[:references] || context.references
+      types = params[:types] || context.types
     
-    while skeleton.include?("*") do
-      case self.roulette_wheel(references,instructions,types)
-      when "instruction"
-        newPoint = " do " + self.any_instruction(instructions).to_nudgecode
-      when "reference"
-        newPoint = " ref " + self.any_reference(references)
-      when "sample"
-        theType = any_type(types)
-        if theType == CodeType
-          if types != [CodeType]
-            theType = self.any_type(types - [CodeType])
-          else
-            raise ArgumentError, "Random code cannot be created"
+      while skeleton.include?("*") do
+        case self.roulette_wheel(references,instructions,types)
+        when "instruction"
+          newPoint = " do " + self.any_instruction(instructions).to_nudgecode
+        when "reference"
+          newPoint = " ref " + self.any_reference(references)
+        when "sample"
+          theType = any_type(types)
+          if theType == CodeType
+            if types != [CodeType]
+              theType = self.any_type(types - [CodeType])
+            else
+              raise ArgumentError, "Random code cannot be created"
+            end
           end
+          newPoint = " sample " + theType.to_nudgecode + " (" + theType.any_value.to_s + ")"
+        else
+          raise ArgumentError, "Nothing to make random code from"
         end
-        newPoint = " sample " + theType.to_nudgecode + " (" + theType.any_value.to_s + ")"
-      else
-        raise ArgumentError, "Nothing to make random code from"
+        skeleton = skeleton.sub(/\*/, newPoint)
+        skeleton = skeleton.sub(/\n/,'')
       end
-      skeleton = skeleton.sub(/\*/, newPoint)
-      skeleton = skeleton.sub(/\n/,'')
+      skeleton
     end
-    skeleton
-  end
   
   
   
-  def self.from_s(string_value)
-    return string_value.sub(/\(/,"«").sub(/\)/,"»")
-  end
+    def self.from_s(string_value)
+      return string_value.sub(/\(/,"«").sub(/\)/,"»")
+    end
   
-  def self.any_value(context)
-    self.random_value(context)
+    def self.any_value(context)
+      self.random_value(context)
+    end
   end
 end

data/lib/interpreter/types/pushTypes.rb

@@ -1,102 +1,115 @@
 # coding: utf-8
 
-class NudgeType
-  require 'singleton'
-  include Singleton
-  
-  @@all_types = []
-  
-  def self.inherited(subclass)
-    @@all_types << subclass
-    super
-  end
+module NudgeType
   
   def self.all_types
-    @@all_types
+    @all_types ||= []
   end
   
   def self.push_types
     [IntType, BoolType, FloatType]
   end
   
-  def self.to_nudgecode
-    self.to_s.slice(0..-5).downcase
-  end
-  
-  def self.from_s
-    raise "Your subclass of NudgeType should provide a method for parsing string values in code"
-  end
-end
-
+  module TypeBehaviors
+    def self.extended(subclass)
+      NudgeType.all_types << subclass
+    end
+    
+    def to_nudgecode
+      self.to_s.demodulize.slice(0..-5).downcase.intern
+    end
 
+    def from_s(some_string)
+      raise "This class must implement #{self.inspect}.from_s"
+    end
 
+    def any_value
+      raise "This class must implement #{self.inspect}.any_value"
+    end
 
-class IntType < NudgeType
-  @defaultLowest = -100
-  @defaultHighest = 100
-  
-  def self.defaultLowest
-    @defaultLowest
+    def random_value(params)
+      raise "This class must implement #{self.inspect}.random_value"
+    end
   end
   
-  def self.defaultHighest
-    @defaultHighest
+  class BasicType
+    def self.inherited(subclass)
+      subclass.extend TypeBehaviors
+    end
   end
   
-  def self.random_value(params={})
-    bottom = params[:randomIntegerLowerBound] || @defaultLowest
-    top = params[:randomIntegerUpperBound] || @defaultHighest
-    lowest, highest = [bottom,top].min, [bottom,top].max
-    rand(highest-lowest).to_i + lowest
-  end
-  
-  def self.from_s(string_value)
-    return string_value.to_i
-  end
-  
-  def self.any_value
-    self.random_value
-  end
-end
+  class IntType < Fixnum
+    extend TypeBehaviors
+    @defaultLowest = -100
+    @defaultHighest = 100
 
+    def self.defaultLowest
+      @defaultLowest
+    end
 
+    def self.defaultHighest
+      @defaultHighest
+    end
 
+    def self.random_value(params={})
+      bottom = params[:randomIntegerLowerBound] || @defaultLowest
+      top = params[:randomIntegerUpperBound] || @defaultHighest
+      lowest, highest = [bottom,top].min, [bottom,top].max
+      rand(highest-lowest).to_i + lowest
+    end
 
-class BoolType < NudgeType  
-  def self.random_value(params = {})
-    p = params[:randomBooleanTruthProb] || 0.5
-    rand() < p
-  end
-  
-  def self.from_s(string_value)
-    return string_value.downcase == "true"
-  end
-  
-  def self.any_value
-    self.random_value
+    def self.from_s(string_value)
+      return string_value.to_i
+    end
+
+    def self.any_value
+      self.random_value
+    end
   end
-end
 
 
 
 
-class FloatType < NudgeType
-  @defaultLowest = -1000.0
-  @defaultHighest = 1000.0
-  
-  def self.random_value(params = {})
-    bottom = params[:randomFloatLowerBound] || @defaultLowest
-    top = params[:randomFloatUpperBound] || @defaultHighest
-    bottom, top = [bottom,top].min, [bottom,top].max
-    range = top - bottom
-    (rand*range) + bottom
-  end
-  
-  def self.from_s(string_value)
-    return string_value.to_f
+  class BoolType
+    extend TypeBehaviors
+
+    def self.random_value(params = {})
+      p = params[:randomBooleanTruthProb] || 0.5
+      rand() < p
+    end
+
+    def self.from_s(string_value)
+      string_value.downcase == "true" ? true : false
+    end
+
+    def self.any_value
+      self.random_value
+    end
   end
-  
-  def self.any_value
-    self.random_value
+
+
+
+
+  class FloatType < Float
+    extend TypeBehaviors
+
+    @defaultLowest = -1000.0
+    @defaultHighest = 1000.0
+
+    def self.random_value(params = {})
+      bottom = params[:randomFloatLowerBound] || @defaultLowest
+      top = params[:randomFloatUpperBound] || @defaultHighest
+      bottom, top = [bottom,top].min, [bottom,top].max
+      range = top - bottom
+      (rand*range) + bottom
+    end
+
+    def self.from_s(string_value)
+      return string_value.to_f
+    end
+
+    def self.any_value
+      self.random_value
+    end
   end
-end
+end

data/lib/nudge.rb

@@ -35,4 +35,6 @@ require 'search/operators/basic_operators'
 require 'search/operators/samplers_and_selectors'
 require 'search/operators/evaluators'
 require 'search/stations/station'
-require 'search/experiments/experiment'
+require 'search/experiments/experiment'
+
+include NudgeType

data/lib/search/individual/individual.rb

@@ -28,9 +28,7 @@ module Nudge
     attr_reader :id
     
     def initialize(listing)
-      @helperParser = 
-      
-      @genome = listing
+      @helperParser = @genome = listing
       raise(ArgumentError, "Nudge program cannot be parsed") if Individual.helperParser.parse(genome) == nil
       @program = Individual.helperParser.parse(genome).to_points
       @scores = Hash.new