y_nelson 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d19c1eb4d0fca009913f2c4632ea803aafee8a0
+  data.tar.gz: 2ae45a24959f7041a7017a0ef44ee1f5023f4b44
+SHA512:
+  metadata.gz: e42a83132fbecca38473d47c05ef1e7ecb3d1e134e517c7eda1c18b79b10df80d1d1340eae7e1e896e0027a3dca2339c35b703fb472ea38c5cf7a1874fd29b19
+  data.tar.gz: 51d15c79f5210d76e936dc0777285dccf7447b2a5faa59013822429798776c06ee092771f285af058d0c302a8cff0e9912fed75b4b87238cf32ba7fc4b344f2b

data/.gitignore

@@ -0,0 +1,20 @@
+*~
+.#*
+\#*#
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in y_nelson.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 boris
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# YNelson
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'y_nelson'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install y_nelson
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/y_nelson/dimension.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Zz dimension can in principle be any object, in YNelson, special class
+# Dimension is used.
+# 
+class YNelson::Dimension
+  class << self
+    alias __new__ new
+
+    # Presents class-owned instances (array).
+    # 
+    def instances
+      return @instances ||= []
+    end
+
+    # The #new constructor is changed, so that same instance is returned for
+    # same constructor arguments.
+    # 
+    def new *args
+      instances.find { |ɪ| ɪ.object == args } or
+        __new__( *args ).tap { |ɪ| instances << ɪ }
+    end
+  end
+
+  attr_reader :object
+
+  # Simply assigns array of arguments to @object atrribute.
+  # 
+  def initialize *args
+    @object = args
+  end
+
+  # Short instance description string.
+  # 
+  def to_s
+    "#<YNelson::Dimension [#{object.join ', '}]>"
+  end
+end # class YNelson::Dimension
+
+# Convenience constructor.
+# 
+def YNelson.Dimension *args
+  YNelson::Dimension.new *args
+end

data/lib/y_nelson/dimension_point.rb

@@ -0,0 +1,15 @@
+#encoding: utf-8
+
+# A pointer to a zz dimension.
+# 
+class YNelson::DimensionPoint
+  attr_accessor :dimension
+
+  def initialize dimension
+    @dimension = dimension
+  end
+
+  def default_dimension
+    YNelson.default_dimension
+  end
+end # class YTed::DimensionPoint

data/lib/y_nelson/manipulator.rb

@@ -0,0 +1,360 @@
+# -*- coding: utf-8 -*-
+# YNelson user inteface. Ted Nelson, in his introduction of zz structures, has
+# remarks regarding a desired UI, such as:
+#
+# <em>Selection</em> is a pointer to a collection of cells.
+# <em>View</em> consists of selection and a coordinate system.
+# <em>Field<em> is a connected (contiguous) selection.
+# <em>Coordinate system</em> is a collection of oriented dimensions.
+#
+# Apart from that, this manipulator should offer similar functionality as
+# YPetri::Manipulator - that is, should allow constructing a Petri net
+# without much ado about zz aspect, just like YPetri does.
+#
+class YNelson::Manipulator
+  attr_reader :workspace
+
+  include YPetri::Manipulator::PetriNetRelatedMethods
+  include YPetri::Manipulator::SimulationRelatedMethods
+
+  def initialize
+    # For YNelson manipulators, the workspace is always YNelson itself.
+    @workspace = ::YNelson
+    super
+    # A hash of sheets. For the moment being, YNelson acts as a spreadsheet.
+    @sheets = {}
+    # Default dimension of this manipulator.
+    @default_dimension = YNelson.Dimension :row
+    # Zz object pointers of this manipulator.
+    @primary_point = YNelson::ZzPoint.new
+    @secondary_point = YNelson::ZzPoint.new
+    # Zz dimension pointers of this manipulator.
+    @primary_dimension_point =
+      YNelson::DimensionPoint.new YNelson.Dimension( :row )
+    @secondary_dimension_point =
+      YNelson::DimensionPoint.new YNelson.Dimension( :column )
+  end
+
+  # Now the part related to the zz structure itself, like in
+  # module YNelson::Manipulator::ZzRelatedMethods
+  #   blah blah
+  # end
+  # include YNelson::Manipulator::ZzRelatedMethods
+
+  attr_reader :sheets
+
+  # Dimension convenience constructor from 
+  delegate( :Dimension,
+            to: :workspace )
+  
+  # Creation of a single-output formula known well from spreadseets. Given a
+  # place, it creates a new assignment transition.
+  # 
+  def ϝ &block
+    new_place = YNelson::Place.new
+    new_transition = YNelson::Transition.new assignment: true,
+                                             codomain: new_place,
+                                             action: block
+    return new_place, new_transition
+  end
+
+  # Now let's look into the graph visualization.
+
+  def default_dimension; @default_dimension end
+
+  def primary_point; @primary_point end
+  alias p1 primary_point
+
+  def secondary_point; @secondary_point end
+  alias p2 secondary_point
+
+  def primary_dimension_point; @primary_dimension_point end
+  alias d1 primary_dimension_point
+
+  def secondary_dimension_point; @secondary_dimension_point end
+  alias d2 secondary_dimension_point
+
+  # Define function to display it with kioclient
+  def visualize *args, &block; graphviz *args, &block end
+
+  # Define graphviz places
+  def graphviz dim1=primary_dimension_point, dim2=secondary_dimension_point
+    γ = GraphViz.new :G, type: :digraph  # Create a new graph
+
+    # main        = γ.add_nodes( "main", shape: "box" )
+    # parse       = γ.add_nodes( "parse", fillcolor: "yellow", style: "rounded,filled", shape: "diamond" )
+    # execute     = γ.add_nodes( "execute", shape: "record", label: "{ a | b | c }", style: "rounded" )
+    # init        = γ.add_nodes( "init", fillcolor: "yellow", style: "filled" )
+
+    # set global node options
+    γ.node[:color] = "#ddaa66"
+    γ.node[:style] = "filled"
+    γ.node[:shape] = "box"
+    γ.node[:penwidth] = "1"
+    γ.node[:fontname] = "Trebuchet MS"
+    γ.node[:fontsize] = "8"
+    γ.node[:fillcolor] = "#ffeecc"
+    γ.node[:fontcolor] = "#775500"
+    γ.node[:margin] = "0.0"
+
+    # set global edge options
+    γ.edge[:color] = "#999999"
+    γ.edge[:weight] = "1"
+    γ.edge[:fontsize] = "6"
+    γ.edge[:fontcolor] = "#444444"
+    γ.edge[:fontname] = "Verdana"
+    γ.edge[:dir] = "forward"
+    γ.edge[:arrowsize] = "0.5"
+
+    # add zz objects
+    place_nodes = places.map.with_object Hash.new do |place, ꜧ|
+      ꜧ[place] = γ.add_nodes place.name.to_s
+    end
+    transition_nodes = transitions.map.with_object Hash.new do |transition, ꜧ|
+      ꜧ[transition] = γ.add_nodes transition.name.to_s
+    end
+    nodes = place_nodes.merge transition_nodes
+    # add edges for selected dimensions
+    nodes.each { |instance, node|
+      negward_neighbor = instance.( dim1 ).negward.neighbor
+      nodes[ negward_neighbor ] << node if negward_neighbor # color 1
+      negward_neighbor = instance.( dim2 ).negward.neighbor
+      nodes[ negward_neighbor ] << node if negward_neighbor # color 2
+    }
+
+    γ.output png: "zz.png"        # Generate output image
+    YSupport::KDE.show_file_with_kioclient File.expand_path( '.', "zz.png" )
+
+    # main        = γ.add_nodes( "main", shape: "box" )
+    # parse       = γ.add_nodes( "parse", fillcolor: "yellow", style: "rounded,filled", shape: "diamond" )
+    # execute     = γ.add_nodes( "execute", shape: "record", label: "{ a | b | c }", style: "rounded" )
+    # init        = γ.add_nodes( "init", fillcolor: "yellow", style: "filled" )
+  end
+
+  # graphviz [:domain, 0 ], [:codomain, 0]
+
+  # Cell side referencers with r. to primary and secondary point
+  def ξ_posward_side dim=nil; ::YTed::POINT.posward_side dim end
+  alias :ξp :ξ_posward_side
+  def ξ_negward_side dim=nil; ::YTed::POINT.negward_side dim end
+  alias :ξn :ξ_negward_side
+  def ξ2_posward_side dim=nil; ::YTed::POINT2.posward_side dim end
+  alias :ξ2p :ξ2_posward_side
+  def ξ2_negward_side dim=nil; ::YTed::POINT2.negward_side dim end
+  alias :ξ2n :ξ2_negward_side
+
+  # Point walkers
+  def ξ_step_posward dim=nil; ::YTed::POINT.step_posward dim end
+  alias :ξp! :ξ_step_posward
+  def ξ_step_negward dim=nil; ::YTed::POINT.step_negward dim end
+  alias :ξn! :ξ_step_negward
+  def ξ2_step_posward dim=nil; ::YTed::POINT2.step_posward dim end
+  alias :ξ2p! :ξ2_step_posward
+  def ξ2_step_negward dim=nil; ::YTed::POINT2.step_negward dim end
+  alias :ξ2n! :ξ2_step_negward
+
+  # Point rank rewinders
+  # (rewinders without exclamation mark expect block or return enumerator
+  def ξ_rewind_posward *aa, &b; ::YTed::POINT.rewind_posward *aa, &b end
+  alias :ξrp :ξ_rewind_posward
+  def ξ_rewind_negward *aa, &b; ::YTed::POINT.rewind_negward *aa, &b end
+  alias :ξpp :ξ_rewind_posward
+  def ξ2_rewind_posward *aa, &b; ::YTed::POINT.rewind_posward *aa, &b end
+  alias :ξ2rp :ξ2_rewind_posward
+  def ξ2_rewind_negward *aa, &b; ::YTed::POINT.rewind_negward *aa, &b end
+  alias :ξ2pp :ξ2_rewind_posward
+
+  # Point rak rewinters with exclamation mark (no block or enum, just do it)
+  def ξ_rewind_posward! dim=nil; ::YTed::POINT.rewind_posward! dim end
+  alias :ξrn! :ξ_rewind_posward!
+  alias :ξnn! :ξ_rewind_posward!
+  def ξ_rewind_negward! dim=nil; ::YTed::POINT.rewind_negward! dim end
+  alias :ξrn! :ξ_rewind_negward!
+  alias :ξnn! :ξ_rewind_negward!
+  def ξ2_rewind_posward! dim=nil; ::YTed::POINT2.rewind_posward! dim end
+  alias :ξ2rp! :ξ2_rewind_posward!
+  alias :ξ2pp! :ξ2_rewind_posward!
+  def ξ2_rewind_negward! dim=nil; ::YTed::POINT2.rewind_negward! dim end
+  alias :ξ2rn! :ξ2_rewind_negward!
+  alias :ξ2nn! :ξ2_rewind_negward!
+
+  # Neighbor referencers
+  def ξ_posward_neighbor dim=nil; ::YTed::POINT.posward_neighbor dim end
+  alias :ξP :ξ_posward_neighbor
+  def ξ_negward_neighbor dim=nil; ::YTed::POINT.negward_neighbor dim end
+  alias :ξN :ξ_negward_neighbor
+  def ξ2_posward_neighbor dim=nil; ::YTed::POINT2.posward_neighbor dim end
+  alias :ξ2P :ξ2_posward_neighbor
+  def ξ2_negward_neighbor dim=nil; ::YTed::POINT2.negward_neighbor dim end
+  alias :ξ2N :ξ2_negward_neighbor
+
+  # Neighbor redefinition
+  def ξ_redefine_posward_neighbor *args
+    ::YTed::POINT.redefine_posward_neighbor *args end
+  alias :ξP! :ξ_redefine_posward_neighbor
+  def ξ_redefine_negward_neighbor *args
+    ::YTed::POINT.redefine_negward_neighbor *args end
+  alias :ξN! :ξ_redefine_negward_neighbor
+  def ξ2_redefine_posward_neighbor *args
+    ::YTed::POINT2.redefine_posward_neighbor *args end
+  alias :ξ2P! :ξ2_redefine_posward_neighbor
+  def ξ2_redefine_negward_neighbor *args
+    ::YTed::POINT2.redefine_negward_neighbor *args end
+  alias :ξ2N! :ξ2_redefine_negward_neighbor
+
+
+  # FIXME these methods do not work well
+  # #rank method creates a rank of connected cells along the given
+  # dimension (named arg :dimension, alias :dΞ ), from values given as array
+  # (named arg :array, alias :ᴀ). The rank is returned as a cell array.
+  def zz_rank( array, dimension )
+    array.map{ |e| ZzCell( e ) }.each_consecutive_pair{ |a, b|
+      a.redefine_neighbors( dimension: dimension, posward: b )
+    }
+  end
+
+  # Zips an array of ZzCells (receiver) with another array of ZzCells
+  # in a given dimension. That is, each cell in the first array is made
+  # to point (have posward neighbor) to the corresponding cell in the
+  # second array.
+  def zz_zip( cell_array, dimension )
+    cell_array.a℈_all_∈( ::YTed::ZzCell )
+    self.a℈_all_∈( ::YTed::ZzCell ).each.with_index{|cell, i|
+      cell.redefine_neighbors( dimension: dimension,
+                               posward: cell_array[i] )
+    }
+  end
+
+  # All we need right now is use Zz as a spreadsheet, writing data in rows.
+
+  # FIXME: Zz properites not used at all - classical Ruby data structures
+  # are used instead. ξ is just a holder for sheet name
+
+  # Creates a new row (rank along :row dimension) zipped to current row
+  # along ξ.dim, using the supplied arguments as new row's cell values.
+  def new_zz_row *args
+    args = args[0].first if args.size == 1 and args[0].is_a? Hash
+    previous_row = ( ::YTed::SHEETS[@current_sheet_name][-1] || [] ).dup
+    row = args.map{ |a| ZzCell( a ) }
+    row.each_consecutive_pair{ |a, b| a.P! x: b } # connect along :x
+    row.each{ |e| e.N! y: previous_row.shift } # zip to previous row
+    ::YTed::SHEETS[@current_sheet_name] << row
+    if row[0].value.is_a? Symbol then
+      ::YTed::SHEETS[@current_sheet_name]
+        .define_singleton_method args[0] { row[1].aE_kind_of ::YPetri::Place }
+    end
+  end
+  alias :→ :new_zz_row
+
+  # #new_zz_sheet creates a new sheet with a single cell holding the sheet's
+  # name and sets main point to it in :col dimenion sheet name as its value
+  def new_zz_sheet( name )
+    @current_sheet_name = name
+    ::YTed::SHEETS[name] = []
+    ::YTed::SHEETS
+      .define_singleton_method name.to_sym do ::YTed::SHEETS[name] end
+    return ::YTed::SHEETS[name]
+  end
+
+  def make_transitions
+    # require 'debug'
+    # LATER: When walking around the sheets, currently, there is no
+    # protection against references to empty cells
+    @transitions_to_make.map { |prescription|
+      sheet = prescription[:sheet]
+      type = prescription[:type]
+      place = prescription[:place]
+      block = prescription[:assignment_closure]
+
+      case type
+      when :unary_codomain_w_magic_block
+        # PARAMETER MAGIC:
+        # Blocks with specially named input arguments
+        domain = block.parameters.map{ |e| e[1].to_s }.map{ |param|
+          point = ZzPoint.new( place )
+          if SHEETS.keys.include? sheet_name = param.split('_')[0] then
+            # if the name consists of a sheet and parameter name, then ok
+            rest = param[sheet_name.size + 1..-1]
+            point = ZzPoint.new( SHEETS[sheet_name][0][0] )
+            col = [*('a'..'z')].index rest[0]
+            point.rewind_negward! :x
+            if rest.size > 1 then # also change row, asssuming "a0" style
+              point.rewind_negward! :y
+              row = rest[1..-1].to_i
+              row.times { point.step_posward :y }
+            end
+            col.times { point.step_posward :x }
+            point.cell
+          elsif [*('a'..'z')].include? param[0] then
+            # if the name consists of an alphabetic letter...
+            col = [*('a'..'z')].index param[0]
+            point.rewind_negward! :x
+            if param.size > 1 then # also change row, assuming "a0" style
+              point.rewind_negward! :y
+              row = param[1..-1].to_i
+              row.times { point.step_posward :y }
+            end
+            col.times { point.step_posward :x }
+            point.cell
+          elsif param[0] = '_' then
+            # Params named '_1', '_2', ... refer to different rows, same :col,
+            # param named '__' refers to same cell
+            if param == '__' then cell else
+              i = param[1..-1].to_i
+              point.rewind_negward! :y
+              i.times { point.step_posward :x }
+              point.cell
+            end
+          else
+            raise TypeError, "unrecognized magic block parameter: #{param}"
+          end
+        } # block.parameters.map
+        
+        # Instantiate the new transition (do not fire it yet):
+        Transition( domain: domain,
+                    codomain: [ place ],
+                    action_closure: block,
+                    assignment_action: true )
+      when :downstream_copy
+        # DOWNSTREAM COPY
+        # A single transition assigning upstream value to the downstream cell
+        Transition( domain: prescription[:domain],
+                                  codomain: [ place ],
+                                  action_closure: λ {|v| v },
+                                  assignment_action: true )
+      else raise "Unknown transition prescription type: #{prescription[:type]}"
+      end
+    } # @transitions_to_make.map
+  end
+
+  # Places an order for a spreadsheet-like assignment transition. The order
+  # will be fullfilled later when #make_transitions method is called.
+  # 
+  def new_downstream_cell &block
+    # The place can be instatiated right away
+    place = ZzCell( nil )
+
+    # Transition making requests get remembered in @transitions_to_make:
+    ( @transitions_to_make ||= [] ) <<
+      { place: place,
+        sheet: @current_sheet_name,
+        assignment_closure: block,
+        type: :unary_codomain_w_magic_block }
+    return place
+  end
+  alias :ϝ :new_downstream_cell
+
+  # Places an order for a spreadsheet-lie pure reference to another cell.
+  # 
+  def new_downstream_copy( cell )
+    # Again, the place can be instantiated immediately
+    p = ZzCell( nil )
+
+    # And put the transition making request to @transitions_to_make:
+    ( @transitions_to_make ||= [] ) <<
+      { place: p, sheet: @current_sheet_name, domain: cell,
+        type: :downstream_copy }
+    return p
+  end
+  alias :↱ :new_downstream_copy
+end

data/lib/y_nelson/net.rb

@@ -0,0 +1,12 @@
+# Represents Petri nets inside the Nelson net.
+# 
+class YNelson::Net < YPetri::Net
+
+  private
+
+  # Place, Transition, Net class
+  # 
+  def Place; ::YNelson::Place end
+  def Transition; ::YNelson::Transition end
+  def Net; ::YNelson::Net end
+end # class YNelson::Net

data/lib/y_nelson/place.rb

@@ -0,0 +1,28 @@
+# YNelson::Place is analogical to a spreadsheet cell. It is based on
+# YPetri::Place and offers simlar interace.
+# 
+class YNelson::Place < YPetri::Place
+  include YNelson::Yzz
+  alias call along # .( :dim ) instead of .along( :dim )
+
+  class << self
+  end
+
+  # Subclass of YTed::Zz::Side.
+  # 
+  class Side < Side
+    # "Budding": creation of new cells from the cell sides
+    def bud( value: L!, f: nil )
+      # FIXME
+    end
+    alias :>> :bud
+  end
+
+  private
+
+  # Place, Transition, Net class
+  # 
+  def Place; ::YNelson::Place end
+  def Transition; ::YNelson::Transition end
+  def Net; ::YNelson::Net end
+end

data/lib/y_nelson/transition.rb

@@ -0,0 +1,38 @@
+# YNelson::Transition is based on YPetri::Transition and offers similar
+# interface. "Functions", on which transitions of a functional Petri net
+# are based, are analogical to 'formulas' of a spreadsheet.
+# 
+class YNelson::Transition < YPetri::Transition
+  include YNelson::Yzz
+  alias call along # .( :dim ) rather than .along( :dim )
+
+  private
+
+  # YNelson extends this YPetri::Transition private method, so that a zz
+  # connection is automatically created along dimension [:domain, i] for
+  # i-th domain place of the transition.
+  # 
+  def inform_upstream_places
+    upstream_places.each_with_index { |p, i|
+      along( YNelson.Dimension self, :domain, i ) >> p
+    }
+    super
+  end
+
+  # YNelson extends this YPetri::Transition private method, so that a zz
+  # connection is autimatically created along along dimension [:codomain, i]
+  # for i-th codomain place of the transition.
+  # 
+  def inform_downstream_places
+    downstream_places.each_with_index { |p, i|
+      along( YNelson.Dimension self, :codomain, i ) >> p
+    }
+    super
+  end
+
+  # Place, Transition, Net class.
+  # 
+  def Place; ::YNelson::Place end
+  def Transition; ::YNelson::Transition end
+  def Net; ::YNelson::Net end
+end

data/lib/y_nelson/version.rb

@@ -0,0 +1,4 @@
+module YNelson
+  DEBUG = false
+  VERSION = "0.1.5"
+end

data/lib/y_nelson/yzz.rb

@@ -0,0 +1,11 @@
+# Represents Petri nets inside the Nelson net.
+# 
+module YNelson::Yzz
+  include Yzz
+
+  def along *args
+    return super( args[0] ) if
+      args.size == 1 && args[0].is_a?( ::YNelson::Dimension )
+    super( ::YNelson.Dimension *args )
+  end
+end # module YzzPrepend

data/lib/y_nelson/zz_point.rb

@@ -0,0 +1,136 @@
+#encoding: utf-8
+
+# A pointer to a Zz object. A glorified variable, basically.
+# 
+class YNelson::ZzPoint
+  attr_accessor :zz
+
+  # Initialization has one optional argument :zz -- zz object at which the
+  # point should be initialized.
+  # 
+  def initialize( zz: nil )
+    @zz = zz
+  end
+
+  delegate :marking, :value, :υ,
+           :marking=, :value=, :υ=,
+           :test_arcs, :codomain, :downstream_transitions,
+           :action_arcs, :domain, :upstream_transitions, :ϝ, # digamma: ϝ
+           :arcs, # :connectivity alias not delegated to avoid confusion
+           :upstream_places, # :precedents, :← not delegated, same reason
+           :downstream_places, # :dependents, :→ aliases not delegated
+           to: :zz
+  alias :v :value
+
+  def default_dimension; YNelson.primary_dimension end
+
+  # Quasi-delegation to zz
+
+  def along dimension=default_dimension
+    zz.along dimension
+  end
+
+  def posward( along: default_dimension )
+    along( along ).posward
+  end
+  alias p posward
+
+  def negward( along: default_dimension )
+    along( along ).negward_side
+  end
+  alias n negward
+
+  def posward_neighbor( along: default_dimension )
+    posward( along: along ).neighbor
+  end
+  alias P posward_neighbor
+
+  def negward_neighbor( along: default_dimension )
+    negward( along: along ).neighbor
+  end
+  alias N negward_neighbor
+
+  def redefine_posward_neighbor( neighbor, along: default_dimension )
+    posward( along: along ) << neighbor
+  end
+  alias P! :redefine_posward_neighbor
+
+  def redefine_negward_neighbor( neighbor, along: default_dimension )
+    negward( along: along ) << neighbor
+  end
+  alias N! :redefine_negward_neighbor
+
+  def bud_posward( value=nil, along: default_dimension )
+    posward( along: along ).bud value
+  end
+  alias bud bud_posward
+
+  def bud_negward( value=nil, along: default_dimension )
+    negward( along: along ).bud value
+  end
+
+  def rank( along: default_dimension )
+    zz.get_rank along: along
+  end
+
+  # Walkers
+
+  def step_posward( along: default_dimension )
+    neighbor = posward_neighbor along: along
+    if neighbor.is_a_zz? then @zz = neighbor else false end
+  end
+  alias step step_posward
+  alias p! step_posward
+
+  def step_negward( along: default_dimension )
+    neighbor = negward_neighbor along: along
+    if neighbor.is_a_zz? then @zz = neighbor else false end
+  end
+  alias n! step_negward
+
+  # Rewinders
+
+  def rewind_posward( along: default_dimension )
+    origin = zz
+    if block_given? then
+      loop { yield zz
+             return :end unless posward_neighbor( along: along ).is_a_zz?
+             return :loop if posward_neighbor( along: along ) == origin
+             step_posward along: along }
+    else # no block given, returns enumerator
+      Enumerator.new { |y|
+        loop { y << zz
+               break :end unless posward_neighbor( along: along ).is_a_zz?
+               break :loop if posward_neighbor( along: along ) == origin
+               step_posward along: along }
+      }
+    end
+  end
+
+  def rewind_negward( along: default_dimension )
+    origin = zz
+    if block_given? then
+      loop { yield zz
+             return :end unless negward_neighbor( along: along ).is_a_zz?
+             return :loop if negward_neighbor( along: along ) == origin
+             step_negward along: along }
+    else
+      Enumerator.new { |y|
+        loop { y << zz
+               break :end unless negward_neighbor( along: along ).is_a_zz?
+               break :loop if negward_neighbor( along: along ) == origin
+               step_negward along: along }
+      }
+    end
+  end
+
+  # Simple unconditional rewind.
+
+  def rewind_posward!( along: default_dimension )
+    rewind_posward( along: along ) {} # implemented using empty block
+  end
+
+  def rewind_negward!( along: default_dimension )
+    rewind_negward( along: along ) {}
+  end
+end # class YNelson::ZzPoint

data/lib/y_nelson.rb

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+require 'yzz'
+require 'y_petri'
+require 'y_support/kde'
+
+require 'graphviz'
+
+require_relative 'y_nelson/version'
+require_relative 'y_nelson/yzz'
+require_relative 'y_nelson/dimension'
+require_relative 'y_nelson/place'
+require_relative 'y_nelson/transition'
+require_relative 'y_nelson/net'
+require_relative 'y_nelson/zz_point'
+require_relative 'y_nelson/dimension_point'
+require_relative 'y_nelson/manipulator'
+
+# YNelson is an implementation of a cross between Ted Nelson's Zz structure, and
+# a functional Petri net (FPN). The resulting data structure, which combines
+# qualities of FPNs with those of relational databases, I refer to as Nelson net
+# throughout this text.
+# 
+# One way to understand Nelson nets is as a genralization of a spreadsheet. In
+# his explanations of Zz structures, Ted Nelson makes wide use of spreadsheet
+# metaphors: cells, ranks, rows, columns, cursors, selections... Nelson net
+# implemented here adds "formulas" to the mix, represented by FPN transitions.
+# 
+# Nelson net disposes of the arbitrary constraints on FPNs as well as the
+# orthogonal structure of "cells" seen in most practical spreadsheet
+# implementations:
+# 
+# 1. Both places and transitions of the FPN take part in zz structure.
+# 2. Formula-based transitions are upgraded to standalone FPN transitions.
+# 
+# The implications of the zz structure differences from ordinary hyperorthogonal
+# structures hav been, to a degree, explained by Ted Nelson himself. There is a
+# growing body of literature on zz structure applications, including in
+# bioinformatics.
+#
+# As for functional Petri nets, their power in computing is well recognized (eg.
+# Funnel, Odersky 2000). FPNs are sometimes just called functional nets, because
+# Petri originally described his nets as timeless and functionless. However, in
+# special-purpose applications, such as biochemical applications, to which I
+# incline, it is appropriate to honor Petri, who designed his nets specifically
+# with chemical modeling in mind as one of their main applications. In
+# biochemistry, it is common to call functional nets Petri nets (Miyano, 200?).
+# 
+module YNelson
+  # Singleton class of YNelson is partial descendant of YPetri::Workspace. More
+  # specifically, it mixes in most YPetri::Workspace instance methods and
+  # provides interface, which should be a superset of YPetri::Workspace. The
+  # difference is, that while YPetri::Workspace can have multiple instances,
+  # representing workdesks, YNelson is a singleton representing relational
+  # database.
+  # 
+  class << self
+    # YNelson metaclass includes instance methods of YPetri::Workspace.
+    include YPetri::Workspace::PetriNetRelatedMethods
+    include YPetri::Workspace::SimulationRelatedMethods
+
+    # Allows summoning DSL by 'include YNelson' (like YPetri does).
+    # 
+    def included receiver
+      # receiver.instance_variable_set :@NelsonManipulator, Manipulator.new
+      # puts "included in #{receiver}"
+      receiver.module_exec {
+        define_method :nelson_manipulator do
+          singleton_class.instance_variable_get :@NelsonManipulator or
+            ( puts "defining Manipulator for #{self} singleton class" if YNelson::DEBUG
+              singleton_class.instance_variable_set :@NelsonManipulator, Manipulator.new )
+        end
+      }
+    end
+
+    def dimensions; @dimensions end
+  end # class << self
+
+  # Instance variables @Place, @Transition, @Net are expected by
+  # YPetri::Workspace module.
+  @Place, @Transition, @Net = self::Place, self::Transition, self::Net
+
+  # Atypical call to #initialize in the course of module execution.
+  initialize
+  
+  delegate( :workspace, to: :nelson_manipulator )
+
+  # Petri net aspect.
+  delegate( :Place, :Transition, :Net,
+            :place, :transition, :pl, :tr,
+            :places, :transitions, :nets,
+            :pp, :tt, :nn,
+            :net_point,
+            :net_selection,
+            :net, :ne,
+            :net_point_reset,
+            :net_point_set,
+            to: :nelson_manipulator )
+
+  # Simulation aspect.
+  delegate( :simulation_point, :ssc_point, :cc_point, :imc_point,
+            :simulation_selection, :ssc_selection,
+            :cc_selection, :imc_selection,
+            :simulations,
+            :clamp_collections,
+            :initial_marking_collections,
+            :simulation_settings_collections,
+            :clamp_collection_names, :cc_names,
+            :initial_marking_collection_names, :imc_names,
+            :simulation_settings_collection_names, :ssc_names,
+            :set_clamp_collection, :set_cc,
+            :set_initial_marking_collection, :set_imc,
+            :set_simulation_settings_collection, :set_ssc,
+            :new_timed_simulation,
+            :clamp_cc, :initial_marking_cc, :simulation_settings_cc,
+            :simulation_point_position,
+            :simulation,
+            :clamp_collection, :cc,
+            :initial_marking_collection, :imc,
+            :simulation_settings_collection, :ssc,
+            :clamp,
+            :initial_marking,
+            :set_step, :set_step_size,
+            :set_time, :set_target_time,
+            :set_sampling,
+            :set_simulation_method,
+            :new_timed_simulation,
+            :run!,
+            :print_recording,
+            :plot,
+            :plot_selected,
+            :plot_state,
+            :plot_flux,
+            to: :nelson_manipulator )
+
+  # Zz aspect.
+  delegate( :Dimension,
+            :ϝ,
+            :default_dimension,
+            :primary_point, :p1,
+            :secondary_point, :p2,
+            :primary_dimension_point, :d1,
+            :secondary_dimension_point, :d2,
+            :visualize,
+            :graphviz,
+            to: :nelson_manipulator )
+end

data/test/y_nelson_test.rb

@@ -0,0 +1,121 @@
+#! /usr/bin/ruby
+# -*- coding: utf-8 -*-
+
+require 'minitest/spec'
+require 'minitest/autorun'
+# tested component itself
+require './../lib/y_nelson'
+
+# **************************************************************************
+# Nelson net test
+# **************************************************************************
+#
+describe YNelson do
+  before do
+    skip
+    @m = YNelson::Manipulator.new
+    @p = @m.Place default_marking: 3.2,
+                  marking: 1.1,
+                  quantum: 0.1
+  end
+
+  describe YNelson::Dimension do
+    it "should give same instance for same object" do
+      assert_equal YNelson.Dimension( :xxx ), @m.Dimension( :xxx )
+    end
+  end
+
+  describe "new transition form correct zz connections with places" do
+    it "should work as expected" do
+      assert_equal [], @p.neighbors
+      assert_equal [], @p.connectivity # 'connectivity' now exclusively a zz keyword
+      t = @m.Transition codomain: @p, action: lambda { 0.1 }, assignment: true
+      assert_equal [ @p ], t.neighbors
+      dim = @m.Dimension( :codomain, 0 )
+      assert_equal @p, t.along( dim ).posward.neighbor
+      # And then, it would be the job of dimension reduction to determine if
+      # some dimensions should be visualized or otherwise used together.
+    end
+  end
+
+  it "should work" do
+    # TODO:
+    # has point
+    # has dimension point
+    # can create places
+    @m.Place
+    # can remove places
+  end
+
+  describe "small Nelson net" do
+    before do
+      # TODO:
+      # Create a net of several places and transition
+    end
+
+    it "should work" do
+      # TODO:
+      # exercise the created Nelson net to make sure it works
+      # #set_posward_neighbor
+      # #set_negward_neighbor
+      # #along, #posward, #negward, etc...
+    end
+  end
+end
+
+describe YNelson::ZzPoint do
+  it "should work" do
+    # TODO
+  end
+end
+
+describe YNelson::DimensionPoint do
+  it "should work" do
+    # TODO
+  end
+end
+
+describe "visualization" do
+  before do
+    @m = YNelson::Manipulator.new
+    @m.Place name: :A, m!: 3.2
+    @m.Place name: :B, m!: 5
+    @m.Transition name: :T1, s: { A: -1, B: 1 }, rate: 1
+    @m.Place name: :C, m!: 7.0
+    @m.Transition name: :T2, s: { B: -1, C: 1 }, rate: 1
+  end
+
+  it "should work" do
+    dim1 = YNelson::Dimension( :domain, 0 )
+    dim2 = YNelson::Dimension( :codomain, 1 )
+    @m.visualize dim1, dim2
+  end
+end
+
+# describe "zz structure with a transition or two" do
+#   before do
+#     new_zz_sheet "koko"
+#     @c1, @c2, @c3 = ZzCell( 1 ), ZzCell( 2 ), ZzCell( 3 )
+#     new_zz_row @c1, @c2, @c3
+#     @c4 = ϝ { |a0, b0, c0| a0 + b0 + c0 }
+#     new_zz_row @c4
+#   end
+
+#   it "should have #make_transitions" do
+#     tt = make_transitions
+#     assert_equal 1, tt.size
+#     t = tt[0]
+#     assert_kind_of ::YPetri::Transition, t
+#     assert t.domain.include? @c1
+#     assert t.domain.include? @c2
+#     assert t.domain.include? @c3
+#     assert_equal nil, @c4.marking
+#     t.fire!
+#     assert_equal 6, @c4.marking
+#     new_zz_sheet "pipi"
+#     @c5 = ϝ { |koko_a0, koko_b0| koko_a0 + koko_b0 }
+#     tt = make_transitions
+#     tt.each &:fire!
+#     assert_equal 3, @c5.value
+#   end
+# end

data/y_nelson.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'y_nelson/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "y_nelson"
+  spec.version       = YNelson::VERSION
+  spec.authors       = ["boris"]
+  spec.email         = ["\"boris@iis.sinica.edu.tw\""]
+  spec.description   = %q{Formalization and generalization of a spreadsheet.}
+  spec.summary       = %q{A fusion of functional Petri net with a zz structure.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'yzz'
+  spec.add_dependency 'y_petri'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: y_nelson
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- boris
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yzz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: y_petri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Formalization and generalization of a spreadsheet.
+email:
+- '"boris@iis.sinica.edu.tw"'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/y_nelson.rb
+- lib/y_nelson/dimension.rb
+- lib/y_nelson/dimension_point.rb
+- lib/y_nelson/manipulator.rb
+- lib/y_nelson/net.rb
+- lib/y_nelson/place.rb
+- lib/y_nelson/transition.rb
+- lib/y_nelson/version.rb
+- lib/y_nelson/yzz.rb
+- lib/y_nelson/zz.png
+- lib/y_nelson/zz_point.rb
+- test/y_nelson_test.rb
+- test/zz.png
+- y_nelson.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '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: A fusion of functional Petri net with a zz structure.
+test_files:
+- test/y_nelson_test.rb
+- test/zz.png