cellula 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de9f62a45eba74c614a88bc2d734061d3003678f
+  data.tar.gz: d75b7307f6fd8e33831b31eb5a0a5d754f40316c
+SHA512:
+  metadata.gz: c3aa5d7269e076dcb6ce23f4a5b72632258791152d432bd629b03e60bfece1b2239f3956736195bcf874c7ac8ac6821b96112f48221ef0a2f41db17e65b9b5e9
+  data.tar.gz: 39d31eed7ea97587959afaf8265fa9b9e59de9fba7b733be2f4fb2dcc85458624b1bbc7320f967584cc41b14ae87cc292603a7ea80061dfd4683309abbb863a9

data/Changelog.markdown

@@ -0,0 +1,27 @@
+This changelog is auto-generated using git-changelog.
+See https://github.com/lkdjiin/git-changelog for more information.
+
+* 2013-08-06 Generate dev's documentation  
+* 2013-08-06 Improve readme  
+* 2013-08-06 Improve documentation  
+* 2013-08-06 Fix bug in single 1 histories method  
+* 2013-08-06 Apache License v2  
+* 2013-08-06 Add tests for single 1 histories study method  
+  Those tests fail for now.
+* 2013-08-04 Add a test for :single study's method  
+* 2013-08-04 Add single 1 study method for elementary CA  
+  This seems to be buggy. It works well with certain wolfram codes and
+  not so well with other ones. Problem is I don't really understand
+  how «single 1 histories» method of study works. I have to read more
+  on the subject.
+* 2013-08-03 Refactoring  
+* 2013-08-03 Add reek to gemspec  
+* 2013-08-03 Extract WolframCodeRule from Rule  
+* 2013-08-03 Use Study instance  
+* 2013-08-03 Replace student by study in doc  
+* 2013-08-03 Rename Student to Study  
+* 2013-08-02 Print message and exit when bad cellula file  
+* 2013-08-02 Add basic Rule class  
+* 2013-08-02 Basic Automaton and Student objects  
+* 2013-08-01 Not anymore a library  
+* 2013-08-01 First commit  

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+ruby '2.0.0'
+
+gemspec
+
+gem 'rake'
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    cellula (0.1.0)
+      docile (= 1.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coco (0.7.1)
+    diff-lcs (1.2.4)
+    docile (1.1.0)
+    rake (10.1.0)
+    reek (1.3.1)
+      ruby2ruby (~> 2.0.2)
+      ruby_parser (~> 3.1.1)
+      sexp_processor
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.2)
+    ruby2ruby (2.0.6)
+      ruby_parser (~> 3.1)
+      sexp_processor (~> 4.0)
+    ruby_parser (3.1.3)
+      sexp_processor (~> 4.1)
+    sexp_processor (4.2.1)
+    tomparse (0.4.2)
+    yard (0.8.7)
+    yard-tomdoc (0.7.1)
+      tomparse (>= 0.4.0)
+      yard
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cellula!
+  coco (>= 0.7.1)
+  rake
+  reek
+  rspec
+  yard
+  yard-tomdoc

data/LICENSE

@@ -0,0 +1,167 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

data/README.markdown

@@ -0,0 +1,97 @@
+Cellula
+================
+
+Description
+-----------
+
+Cellula aims to be a framework for building, running and studying
+cellular automata.
+
+My main goal with Cellula is to *study* cellular automata, not only to *run*
+them, so don't expect fancy graphics.
+
+Another goal is to provide a simple DSL, allowing non-programmers to use
+Cellula. Following is an example of Cellula DSL:
+
+``` ruby
+automaton "Test CA" do
+  dimensions 1
+  type       :elementary
+  width      20
+  rule       :wolfram_code_110
+end
+
+study "Test CA" do
+  method      :random
+  generations 4
+end
+```
+
+Save the previous example in a file named `my_automaton.rb` and
+launch it with:
+
+    cellula path/to/my_automaton.rb
+
+
+Install
+-------------------------
+
+    gem install cellula
+
+Usage
+--------------------------
+*This is a work in progress. More documentation is coming…*
+
+### automaton specifications
+
+* dimensions
+  Number of dimensions of the grid. Currently Cellula supports only
+  1D grids.
+* type
+  Type of the automaton. Currently only :elementary (one-dimensional, 2
+  possible states per cell, neighbors are the immediate neighbors' cells.
+* width
+  Width of the grid.
+* rule
+  Currently only Wolfram code.
+
+### study specifications
+
+* method
+  The study's method. Could be :random or :single. (View doc/study.rb
+  for more details)
+* generations
+  Number of generations to process.
+
+Dependencies
+--------------------------
+
+  * ruby >= 2.0.0
+
+Contributing
+-------------------------
+
+1. Fork it
+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`)
+5. Create new Pull Request
+
+### There is many other ways to contibute to Cellula
+
+1. Report any bugs
+2. Give me ideas
+3. Correct my poor english syntax
+4. Blog about Cellula
+5. Tell Cellula to your friends and colleagues
+
+License
+--------------------------
+Apache v2 License (See LICENSE file).
+
+
+Questions and/or Comments
+--------------------------
+
+Feel free to email [Xavier Nayrac](mailto:xavier.nayrac@gmail.com)
+with any questions, or contact me on [twitter](https://twitter.com/lkdjiin).

data/Rakefile

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc 'Test CellulaCore'
+task :default => :spec
+
+desc 'Test CellulaCore with rspec'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ['--color']
+end
+
+desc 'Check for code smells'
+task :reek do
+  puts 'Checking for code smells...'
+  files = Dir.glob 'lib/**/*.rb'
+  args = files.join(' ')
+  sh "reek --quiet #{args} | ./reek.sed"
+end
+
+desc 'Generate documentation'
+task :doc do
+  sh "yard --plugin tomdoc"
+end
+
+desc "Generate the changelog"
+task :changelog do
+  system "git changelog > Changelog.markdown"
+end

data/TODO

@@ -0,0 +1,9 @@
+les noms ne sont pas obligatoires, et pour l'instant ils ne servent à rien.
+
+life like
+
+Séparer Cellula et CellulaCore ?
+
+Option --backtrace pour exception ?
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/cellula

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$CELLULA_PATH = File.expand_path(File.dirname(__FILE__)) + '/..'
+
+require 'cellula'
+include Cellula
+
+banner
+
+if ARGV[0].nil?
+  usage
+  exit
+end
+
+load ARGV[0].dup
+puts @study.say_hello
+puts
+
+def to_single_1_histories(gen)
+  right_remove = (gen[1].size - (gen[0] * 2 + 1)) / 2
+  gen[1].pop(right_remove)
+  gen[1].join
+end
+
+generations = []
+
+@auto.generate(@study) do |num, generation|
+  generations << [num, generation]
+end
+
+generations.each do |gen|
+  printf "%4s: %s\n", gen[0], gen[1].join()
+end
+
+if @study.method == :single
+  puts "Serie: " +
+    generations.map{|e| to_single_1_histories(e).to_i(2)}.join(', ')
+end
+

data/lib/cellula.rb

@@ -0,0 +1,77 @@
+require 'docile'
+require 'cellula/automaton'
+require 'cellula/study'
+require 'cellula/automaton_builder'
+require 'cellula/study_builder'
+require 'cellula/rule'
+
+# Public: Cellula is a framework for building, running and studying
+# cellular automata. For this, Cellula provides a simple DSL.
+#
+# Following is an example of Cellula DSL:
+#
+#     automaton "his name" do
+#       dimension 1
+#       type      :elementary
+#       width     20
+#       rule      :wolfram_code_110
+#     end
+#
+#  Save the previous example in a file named `my_automaton.rb` and
+#  launch it with:
+#
+#     cellula path/to/my_automaton.rb
+module Cellula
+
+  # Internal: Part of the DSL API, this method builds a new Automaton
+  # object via AutomatonBuilder.
+  #
+  # name  - String name of the automaton.
+  # block - A Ruby block to build the automaton.
+  #
+  # Returns nothing.
+  def automaton(name, &block)
+    @auto = Docile.dsl_eval(AutomatonBuilder.new(name), &block).build
+  end
+
+  # Internal: Part of the DSL API, this method builds a new Study
+  # object via StudyBuilder.
+  #
+  # name  - String name of the automaton to study.
+  # block - A Ruby block to build the automaton.
+  #
+  # Returns nothing.
+  def study(name, &block)
+    @study = Docile.dsl_eval(StudyBuilder.new(name), &block).build
+  end
+
+  # Public: Display a banner on stdout.
+  #
+  # Returns nothing.
+  def banner
+    puts "Cellula version " + File.read('VERSION').strip
+    puts ""
+  end
+
+  # Public: Display application's usage on stdout.
+  #
+  # Returns nothing.
+  def usage
+    puts "
+    usage:
+
+    cellula path/to/automaton_file.rb
+    "
+  end
+
+  # Public: Print an error message and exit with code 1.
+  #
+  # message - The String message to display to user before exiting.
+  #
+  # Returns nothing.
+  def panic(message = "Unknown error")
+    puts "** Panic **"
+    puts message
+    exit(1)
+  end
+end

data/lib/cellula/automaton.rb

@@ -0,0 +1,125 @@
+module Cellula
+
+  # Public: This class provides all it's needed to run a cellular
+  # automaton.
+  #
+  # You rarely wants to initialize an Automaton directly. This is
+  # because Automaton's creation needs a lots of parameters. It is
+  # much more simpler to create Automata using AutomatonBuilder class.
+  #
+  # Dimensions
+  # ----------
+  # Currently only support 1D cellular automata.
+  #
+  # Type of automaton
+  # -----------------
+  # Currently only support elementary cellular automaton. Quoted from
+  # Wikipedia:
+  #
+  # an elementary cellular automaton is a one-dimensional cellular
+  # automaton where there are two possible states (labeled 0 and 1)
+  # and the rule to determine the state of a cell in the next generation
+  # depends only on the current state of the cell and its two immediate
+  # neighbors. 
+  #
+  # See http://en.wikipedia.org/wiki/Elementary_cellular_automaton
+  # for more details.
+  #
+  # Rule
+  # ----
+  # Currently support only wolfram code rules.
+  #
+  # I hope to support custom rules and types soon.
+  class Automaton
+
+    # Public: Initialize a new Automaton.
+    #
+    # name        - String name of the automaton.
+    # dimensions  - Integer number of dimensions for the automaton's
+    #               grid. Default is 1.
+    # type        - Currently only :elementary.
+    # width       - The Integer width of the automaton's grid.
+    # rule        - Rule of the automaton. Currently rule is a Symbol
+    #               following this pattern: :wolfram_code_X, where X is
+    #               the rule number, from 0 to 255.
+    def initialize(name, dimensions, type, width, rule)
+      panic "Bad dimensions: #{dimensions}" if dimensions != 1
+      panic "Bad type: #{type}" if type != :elementary
+      panic "Bad width: #{width}" if width < 1
+      @name = name
+      @dimensions = dimensions
+      @type = type
+      @width = width
+      @rule = Rule.new(rule)
+      @grid = Array.new(@width)
+      @grid.map! {|item| rand(2) }
+    end
+
+    # Public: Get the String name of the automaton.
+    attr_reader :name
+
+    # Public: Set/get the Integer dimensions of the automaton's grid.
+    attr_accessor :dimensions
+
+    # Public: Set/get the Symbol type of the automaton.
+    attr_accessor :type
+
+    # Public: Set/get the Integer width of the automaton's grid.
+    attr_accessor :width
+
+    # Public: Get the rule of the automaton.
+    attr_reader :rule
+
+    # Public: Generate successive generations of this automaton.
+    # If, for example, `student.generations == 4` then #generate will
+    # produce 5 generations: The original generation plus the four you
+    # want.
+    #
+    # study - Study instance.
+    # block - What to do with a generation.
+    #
+    # Example
+    #
+    #    automaton.generate(study) do |num, generation|
+    #      printf "Gen %4s: %s\n", num, generation.join()
+    #    end
+    #    # => will result in something like that:
+    #    # => Gen    0: 0101001010001011000001000100000100101011
+    #    # => Gen    1: 0000010000010000000010001000001001000000
+    #    # => Gen    2: 0000100000100000000100010000010010000000
+    #    # => Gen    3: 0001000001000000001000100000100100000000
+    #    # => Gen    4: 0010000010000000010001000001001000000000
+    #
+    # Returns successive generations as Array.
+    def generate(study, &block)
+      adapt_for_single_method if study.method == :single
+      block.call(0, @grid)
+      1.upto(study.generations) do |cell_index|
+        apply_rule(study)
+        block.call(cell_index, @grid)
+      end
+    end
+
+    private
+
+    # Returns nothing.
+    def adapt_for_single_method
+      @width += 1 if @width % 2 == 0
+      @grid = Array.new(@width, 0)
+      @grid[@width / 2] = 1
+    end
+
+    # Apply rule to the entire grid. @grid becomes the next generation.
+    #
+    # study - Study instance.
+    #
+    # Returns nothing.
+    def apply_rule(study)
+      next_grid = @grid.map.with_index do |cell, index|
+        @rule.apply_rule(index, @grid, study)
+      end
+      @grid = next_grid
+    end
+
+  end
+end

data/lib/cellula/automaton_builder.rb

@@ -0,0 +1,55 @@
+module Cellula
+
+  # Public: Provides an interface to build Automaton objects.
+  # 
+  # Examples
+  #
+  #   ca = AutomatonBuilder.new("my name").build
+  #   ca = AutomatonBuilder.new("my name").dimensions(2).build
+  class AutomatonBuilder
+
+    # Public: Initialize an new AutomatonBuilder.
+    #
+    # name - String name of the futur Automaton.
+    def initialize(name)
+      @name = name
+      @dimensions = 1
+      @type = :elementary
+      @width = 20
+      @rule = :wolfram_code_110
+    end
+
+    # Public: Set the Integer dimensions of the automaton's grid.
+    # Default is 1.
+    #
+    # Returns self.
+    def dimensions(val); @dimensions = val; self; end
+
+    # Public: Set the Symbol type of the automaton. Default is
+    # :elementary.
+    #
+    # Returns self.
+    def type(val); @type = val; self; end
+
+    # Public: Set the Integer width of the automaton's grid.
+    # Default is 20.
+    #
+    # Returns self.
+    def width(val); @width = val; self; end
+
+    # Public: Set the rule of the automaton.
+    # Default is :wolfram_code_110.
+    #
+    # Returns self.
+    def rule(val); @rule = val; self; end
+
+    # Public: Builds an Automaton with characteristics given with
+    # the setters methods.
+    #
+    # Returns Automaton.
+    def build
+      Automaton.new(@name, @dimensions, @type, @width, @rule)
+    end
+  end
+end
+

data/lib/cellula/rule.rb

@@ -0,0 +1,2 @@
+require 'cellula/rules/rule'
+require 'cellula/rules/wolfram_code_rule'

data/lib/cellula/rules/rule.rb

@@ -0,0 +1,30 @@
+module Cellula
+
+  # Internal: Know how to apply a rule to a single cell.
+  class Rule
+
+    # Public: Initialize a new Rule object.
+    #
+    # rule - Currently accept only wolfram code, in the form
+    #        of a Symbol like :wolfram_code_110.
+    def initialize(rule)
+      if WolframCodeRule.wolfram_code?(rule)
+        @rule = WolframCodeRule.new WolframCodeRule.wolfram_code(rule)
+      else
+        panic "Unknown rule: #{rule.to_s}"
+      end
+    end
+
+    # Public: Apply the rule on a single cell.
+    #
+    # cell_number - Integer number of the cell to apply the rule on.
+    # grid        - The entire grid as an Array of Integer.
+    # study       - Study instance.
+    #
+    # Returns the Integer new state of the cell for the next generation.
+    def apply_rule(cell_number, grid, study)
+      @rule.apply_rule(cell_number, grid, study)
+    end
+
+  end
+end

data/lib/cellula/rules/wolfram_code_rule.rb

@@ -0,0 +1,145 @@
+module Cellula
+
+  # Internal: Know how to apply a Wolfram code rule on a single cell.
+  class WolframCodeRule
+
+    # Public: Initialize a new WolframCodeRule object.
+    # See http://en.wikipedia.org/wiki/Wolfram_code and
+    # http://en.wikipedia.org/wiki/Elementary_cellular_automaton
+    # for details.
+    #
+    # rule_number - Integer number of the wolfram code (a number between
+    #               0 and 255).
+    def initialize(rule_number)
+      @rule_number = rule_number
+      begin
+        check_rule_number
+      rescue Exception => ex
+        panic ex.message
+      end
+      @binary_string = "%08b" % @rule_number
+    end
+
+    # Public: Get the Integer wolfram code of the rule.
+    attr_reader :rule_number
+
+    # Public: Apply the rule on a single cell.
+    #
+    # cell_number - Integer number of the cell to apply the rule on.
+    # grid        - The entire grid as an Array of Integer.
+    # study       - Study instance.
+    #
+    # Returns the Integer new state of the cell for the next generation.
+    def apply_rule(cell_number, grid, study)
+      @cell_number = cell_number
+      @grid = grid
+      case study.method
+      when :random then apply_rule_with_random_method
+      when :single then apply_rule_with_single_method
+      end
+    end
+
+    # Get the Integer number part of a :wolfram_code_X pattern.
+    #
+    # pattern - Wolfram code pattern as a Symbol.
+    #
+    # Returns the Integer number part of the pattern.
+    # Exit application if the resulting number isn't between 0 and 255.
+    def self.wolfram_code(pattern)
+      pattern = pattern.to_s
+      num = pattern.delete("wolfram_code_").to_i
+      if num < 0 || num > 255
+        panic "Bad wolfram code: #{pattern}"
+      else
+        num
+      end
+    end
+
+    # Tells if a symbol follow the :wolfram_code_X pattern.
+    #
+    # symb - The Symbol to test.
+    #
+    # Returns Boolean true if sym is a :wolfram_code_X pattern.
+    def self.wolfram_code?(symb)
+      symb.is_a?(Symbol) && symb.to_s.start_with?("wolfram_code_")
+    end
+
+    private
+
+    # Returns 0 or 1.
+    def apply_rule_with_random_method
+      next_generation_cell(left_cell, @grid[@cell_number], right_cell)
+    end
+
+    # Get state of the cell to the left of the current one.
+    #
+    # Returns 0 or 1.
+    def left_cell
+      if @cell_number > 0
+        @grid[@cell_number - 1]
+      else
+        @grid[-1]
+      end
+    end
+
+    # Get state of the cell to the right of the current one.
+    #
+    # Returns 0 or 1.
+    def right_cell
+      if @cell_number == @grid.size - 1
+        @grid[0]
+      else
+        @grid[@cell_number + 1]
+      end
+    end
+
+    # Returns 0 or 1.
+    def apply_rule_with_single_method
+      next_generation_cell(left_cell_single, @grid[@cell_number], right_cell_single)
+    end
+
+    # Returns 0 or 1.
+    def next_generation_cell(left, middle, right)
+      case [left, middle, right]
+      when [1,1,1] then @binary_string[0].to_i
+      when [1,1,0] then @binary_string[1].to_i
+      when [1,0,1] then @binary_string[2].to_i
+      when [1,0,0] then @binary_string[3].to_i
+      when [0,1,1] then @binary_string[4].to_i
+      when [0,1,0] then @binary_string[5].to_i
+      when [0,0,1] then @binary_string[6].to_i
+      when [0,0,0] then @binary_string[7].to_i
+      end
+    end
+
+    # Returns 0 or 1.
+    def left_cell_single
+      if @cell_number > 0
+        @grid[@cell_number - 1]
+      else
+        0
+      end
+    end
+
+    # Returns 0 or 1.
+    def right_cell_single
+      if @cell_number == @grid.size - 1
+        0
+      else
+        @grid[@cell_number + 1]
+      end
+    end
+
+    # Check if rule's number (@rule_number) is in the range 0..255.
+    #
+    # Returns nothing.
+    # Raises ArgumentError if rule's number isn't in the range 0..255.
+    def check_rule_number
+      unless @rule_number >= 0 and @rule_number <= 255
+        raise ArgumentError, "Bad Wolfram Code: #{number}"
+      end
+    end
+
+  end
+
+end

data/lib/cellula/study.rb

@@ -0,0 +1,76 @@
+module Cellula
+
+  # Public: This class provides all it's needed to set up a study.
+  # Study's goal is to study cellular automaton.
+  #
+  # You rarely wants to initialize an Study object directly. This is
+  # because Study's creation needs a lots of parameters. It is
+  # much more simpler to create a Study object using StudyBuilder.
+  #
+  # Study's methods
+  # ---------------
+  # There is currently two kind of study's methods: random initial state
+  # (:random) and single 1 histories (:single). The following is quoted
+  # from Wikipedia:
+  #
+  # **Single 1 histories**
+  #
+  # One method used to study these automata is to follow its history
+  # with an initial state of all 0s except for a single cell with a 1.
+  # When the rule number is even (so that an input of 000 does not
+  # compute to a 1) it makes sense to interpret state at each time, t,
+  # as an integer expressed in binary, producing a sequence a(t) of
+  # integers.
+  #
+  # **Random initial state**
+  #
+  # A second way to investigate the behavior of these automata is to
+  # examine its history starting with a random state.  Each computed
+  # result is placed under that results' source creating a
+  # two-dimensional representation of the system's evolution.
+  class Study
+
+    # Public: Initialize a new Study.
+    #
+    # ca_name     - String name of the automaton to study.
+    # method      - Symbol how to study the automaton.
+    #               Default is :random.
+    #               Could be one of:
+    #               * :random
+    #               * :single
+    #               * :summed
+    #               * :averaged
+    #               Currently limited to :random and :single.
+    # generations - Integer number of generations to study.
+    #               Default is 10.
+    def initialize(ca_name, method, generations)
+      @ca_name = ca_name
+      @method = method
+      @generations = generations
+      panic "Bad number of generations: #{generations}" if generations < 1
+      panic "Bad studying method: #{method}" if bad_studying_method
+    end
+
+    # Public: Get the String ca_name of the automaton to study.
+    attr_reader :ca_name
+
+    # Public: Set/get the Symbol studying method.
+    attr_accessor :method
+
+    # Public: Set/get the Integer number of generations to study.
+    attr_accessor :generations
+
+    def say_hello
+      "Studying #{@ca_name} with #{@method} method " +
+      "over #{@generations} generations."
+    end
+
+    private
+
+    def bad_studying_method
+      @method != :random && @method != :single
+    end
+  end
+end
+
+

data/lib/cellula/study_builder.rb

@@ -0,0 +1,43 @@
+module Cellula
+
+  # Public: Provides an interface to build Study objects.
+  # 
+  # Examples
+  #
+  #   ca = StudyBuilder.new("CA name").build
+  #   ca = StudyBuilder.new("CA name").generations(99).build
+  class StudyBuilder
+
+    # Public: Initialize an new StudyBuilder.
+    #
+    # ca_name - String name of the cellular automaton that the Study
+    #           wants to study.
+    def initialize(ca_name)
+      @ca_name = ca_name
+      @method = :random
+      @generations = 10
+    end
+
+    # Public: Set the Symbol method of study.
+    # Default is :random.
+    #
+    # Returns self.
+    def method(val); @method = val; self; end
+
+    # Public: Set the Integer number of generations to study.
+    # Default is 10.
+    #
+    # Returns self.
+    def generations(val); @generations = val; self; end
+
+    # Public: Builds a Study with characteristics given with
+    # the setters methods.
+    #
+    # Returns Study.
+    def build
+      Study.new(@ca_name, @method, @generations)
+    end
+  end
+end
+
+

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: cellula
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Xavier Nayrac
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coco
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard-tomdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Cellula aims to be a framework for building,
+  running and studying cellular automata.
+email: xavier.nayrac@gmail.com
+executables:
+- cellula
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cellula.rb
+- lib/cellula/automaton.rb
+- lib/cellula/automaton_builder.rb
+- lib/cellula/rule.rb
+- lib/cellula/rules/rule.rb
+- lib/cellula/rules/wolfram_code_rule.rb
+- lib/cellula/study.rb
+- lib/cellula/study_builder.rb
+- bin/cellula
+- Changelog.markdown
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.markdown
+- Rakefile
+- TODO
+- VERSION
+homepage: https://github.com/lkdjiin/cellula
+licenses:
+- ''
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Cellular Automata framework with a simple DSL
+test_files: []
+has_rdoc: