eight_corner 0.0.1

data/lib/eight_corner/bounds.rb

@@ -0,0 +1,38 @@
+# A bounding box.
+module EightCorner
+  class Bounds
+
+    # width
+    attr_accessor :x
+
+    # height
+    attr_accessor :y
+
+    def initialize(x=nil, y=nil)
+      @x = x
+      @y = y
+    end
+
+    def x_from_pct(percent)
+      @x * percent
+    end
+    def y_from_pct(percent)
+      @y * percent
+    end
+
+    def quadrant(point)
+      current = [
+        point.x < x/2 ? 0 : 1,
+        point.y < y/2 ? 0 : 1
+      ]
+
+      {
+        [0,0] => Quadrant::UPPER_LEFT,
+        [1,0] => Quadrant::UPPER_RIGHT,
+        [0,1] => Quadrant::LOWER_LEFT,
+        [1,1] => Quadrant::LOWER_RIGHT
+      }[current]
+    end
+
+  end
+end

data/lib/eight_corner/figure.rb

@@ -0,0 +1,18 @@
+module EightCorner
+
+  # a Figure is 8 connected points
+  class Figure
+
+    attr_accessor :points
+    def initialize
+      @points = []
+    end
+
+    # an overall potential based on the points in this figure
+    # for use as an input for another Base#plot
+    def potential
+      points.last.potential
+    end
+
+  end
+end

data/lib/eight_corner/point.rb

@@ -0,0 +1,64 @@
+module EightCorner
+
+  # A point on a 2D plane.
+  class Point
+
+    attr_accessor :x, :y,
+      # distance from previous point to this one
+      :distance_from_last,
+      # the distance % used to build this distance
+      :distance_pct,
+      # angle from previous point to this one
+      :angle_from_last,
+      # the angle % used to build this angle
+      :angle_pct,
+      # the bounds object that the point exists in
+      :bounds,
+      # the potential value used to create this point
+      :created_by_potential
+
+    def initialize(x=nil, y=nil)
+      @x = x
+      @y = y
+    end
+
+    # which quadrant of the Bounds is this point in?
+    def quadrant
+      raise "cannot calculate quadrant. bounds is nil" if bounds.nil?
+      @quadrant ||= bounds.quadrant(self)
+    end
+
+    def angle_range
+      Quadrant.angle_range_for(quadrant)
+    end
+
+    # a single % value based on the data in this point
+    # used as an input for another Base#plot call
+    # TODO: what is distribution of values of this function?
+    # we want something reasonably gaussian, i think.
+    #
+    # w/o created_by_potential, rearranging the initial string in a series of figures
+    # alters the first 10 figures or so, and then they eventually converge back to
+    # being identical. (The ~11th figure shows no dependence on this initial change in ordering.)
+    def potential
+      (x/bounds.x.to_f + y/bounds.y.to_f + distance_pct.to_f + angle_pct.to_f + created_by_potential.to_f) % 1
+    end
+
+    def max
+      [@x,@y].max
+    end
+
+    def max_is
+      @x > @y ? :x : :y
+    end
+
+    def ==(other)
+      x == other.x && y == other.y
+    end
+
+    def valid?
+      x >= 0 && y >= 0 && x <= bounds.x && y <= bounds.y
+    end
+
+  end
+end

data/lib/eight_corner/quadrant.rb

@@ -0,0 +1,23 @@
+module EightCorner
+
+  # a Bounds has 4 quadrants.
+  # TODO: singleton instance for each quadrant?
+  # would allow each to return their own angle_range_for.
+  module Quadrant
+    UPPER_LEFT  = 0
+    UPPER_RIGHT = 1
+    LOWER_RIGHT = 2
+    LOWER_LEFT  = 3
+
+    def self.angle_range_for(quad)
+      # the valid range of angles (to the next point)
+      # based on the quadrant the current point is in.
+      {
+        UPPER_LEFT  => 30..240,
+        UPPER_RIGHT => 120..330,
+        LOWER_LEFT  => 300..(330+180),
+        LOWER_RIGHT => 210..(330+90)
+      }[quad]
+    end
+  end
+end

data/lib/eight_corner/string_mapper.rb

@@ -0,0 +1,133 @@
+module EightCorner
+
+  # StringMapper provides various methods for converting strings to
+  # percentage/potential values, which can then be mapped to (x,y) points.
+  class StringMapper
+
+    def initialize(options={})
+      defaults = {
+        group_count: 7,
+        min_group_size: 3
+      }
+      Base.validate_options!(options, defaults)
+      options = defaults.merge(options)
+
+      @group_count = options[:group_count]
+      @group_max_idx = @group_count - 1
+      @min_group_size = options[:min_group_size]
+
+      @frequencies = {"E"=>0.103202, "A"=>0.095238, "R"=>0.092638, "N"=>0.087925, "O"=>0.075898, "S"=>0.065659, "L"=>0.064196, "I"=>0.046481, "T"=>0.040793, "H"=>0.03868, "C"=>0.038193, "D"=>0.03413, "M"=>0.033317, "B"=>0.023891, "G"=>0.023566, "Y"=>0.022103, "U"=>0.021615, "W"=>0.019178, "K"=>0.016252, "P"=>0.015602, "F"=>0.011539, "V"=>0.010889, "Z"=>0.010076, "J"=>0.003738, " "=>0.00195, "X"=>0.00195, "Q"=>0.000975}
+    end
+
+    # return an array of 2-float arrays.
+    # provide method symbols for and percentizing method for constructing the 2 array elements.
+    def potentials(groups, percentizeA, percentizeB)
+      [percentizeA, percentizeB].each do |arg|
+        raise ArgumentError, "Invalid method #{arg}" if ! respond_to?(arg)
+      end
+
+      out = []
+      groups.each do |i|
+        # puts send(groupA, str, i)
+        out << [
+          send(percentizeA, i),
+          send(percentizeB, i),
+        ]
+      end
+
+      out
+    end
+
+    # split a string into groups, via :method
+    def groups(str, method)
+      raise ArgumentError, "Invalid method #{arg}" if ! respond_to?(method)
+
+      out = []
+      @group_count.times do |i|
+        out << send(method, str, i)
+      end
+      out
+    end
+
+    # sequential series of characters extracted from string.
+    # loops back to beginning for short strings
+    def group1(str, idx)
+      range = 0..@group_max_idx
+      return ArgumentError, "argument must be in #{range}" if ! range.include?(idx)
+
+      str_size = str.size
+      g_size = group_size str
+
+      out = ""
+
+      start_idx = (idx * g_size)
+      end_idx = start_idx + g_size
+
+      (start_idx...end_idx).each do |x|
+        out += str[x % str_size]
+      end
+
+      out
+    end
+
+    # builds a group from every nth character in the string.
+    def group2(str, idx)
+      str_size = str.size
+
+      out = ''
+      group_size(str).times do |i|
+        out += str[(i * @group_count + idx) % str_size]
+      end
+      out
+    end
+
+    # how many characters should be in each group?
+    def group_size(str)
+      [
+        str.size / @group_count,
+        @min_group_size
+      ].max
+    end
+
+    def percentize_modulus(str)
+      # i+memo just to add some order-dependency. "alex" != "xela"
+      (str.each_byte.inject(0){|memo,i| memo += i + memo; memo} % 100)/100.to_f
+    end
+
+    def percentize_modulus_exp(str)
+      (str.each_byte.inject(0){|memo,i| memo += i^2 + memo; memo} % 100)/100.to_f
+    end
+
+    # turn a string into a float 0..1
+    # a string with common letters should be near 0.5.
+    # a string with uncommon letters should be near 0 or 1.
+    def percentize_frequency(str)
+      # letters aren't evenly distributed.
+      # a string that has every letter once would add up to 1.
+
+      # totally common: sum would be E*3
+
+      common = @frequencies.first[1] * str.size
+
+      sum = 0
+      str.upcase.each_char {|c| sum += @frequencies[c].to_f }
+
+      distance = common - sum # distance from common.
+
+      # add or subtract from 0.5?
+      # all letters are positive/negative based on order in frequency distribution.
+      m = 1
+      @frequencies.keys.each do |i|
+        m *= -1
+        break if str[0].upcase == i
+      end
+
+      interp = Interpolate::Points.new({0=>0, common=>0.5})
+      pct_distance = interp.at(distance)
+      # interpolate (0 .. common) => (0 .. 0.5)
+      # multiply by m and add to 0.5
+
+      pct_distance * m + 0.5
+    end
+  end
+end

data/lib/eight_corner/svg_printer.rb

@@ -0,0 +1,89 @@
+module EightCorner
+
+  # print a figure or collection of figures as an svg document
+  class SvgPrinter
+
+    def initialize(options={})
+      options[:incremental_colors] ||= false
+
+      @options = options
+    end
+
+    def svg(width, height)
+      out = "<svg xmlns='http://www.w3.org/2000/svg' version='1.1' width='#{width}' height='#{height}'>\n"
+      out += yield(self)
+      out += '</svg>'
+
+      out
+    end
+
+    def print(points)
+      svg do
+        @options[:incremental_colors] ? incremental_colors(points) : solid(points)
+      end
+    end
+
+    def draw(figure, options={})
+      defaults = {
+        x_offset: 0,
+        y_offset: 0,
+        width: 200,
+        height: 200,
+        show_border: false,
+        mark_initial_point: false,
+        label: nil,
+        method: :solid
+      }
+      Base.validate_options!(options, defaults)
+      options = defaults.merge(options)
+      raise ArgumentError, "invalid :method" if ! respond_to?(options[:method])
+
+      points = figure.points
+
+      out = "<g transform='translate(#{options[:x_offset]}, #{options[:y_offset]})'>"
+      if options[:show_border]
+        out += "<rect width='#{options[:width]}' height='#{options[:height]}' style='stroke:black; stroke-width:1; fill:none'></rect>"
+      end
+      out += send(options[:method], points)
+      if options[:mark_initial_point]
+        out += point(points[0].x, points[0].y, 5, '#ff0000')
+      end
+      if options[:label]
+        out += "<text x='5' y='#{options[:height]-5}' style='font-family: sans-serif'>#{options[:label]}</text>"
+      end
+
+      out += "</g>\n"
+      out
+    end
+
+    def solid(points)
+      out = '<polygon points="'
+      out += points.map{|p| "#{p.x},#{p.y}"}.join(' ')
+      out += '" style="fill:none; stroke:black; stroke-width:4"/>'
+      out
+    end
+
+    def incremental_colors(points, options={})
+      out = ''
+      interp = Interpolate::Points.new(1 => 0, (points.size-1) => 12)
+      1.upto(points.size-1) do |i|
+        prev = points[i-1]
+        curr = points[i]
+
+        hex_str = interp.at(i).to_i.to_s(16) * 6
+        out += line(prev, curr,  hex_str)
+      end
+      out += line(points.last, points.first, interp.at(points.size-1).to_i.to_s(16) * 6)
+      out
+    end
+
+    def line(from, to, color)
+      "<line x1='#{from.x}' y1='#{from.y}' x2='#{to.x}' y2='#{to.y}' style='stroke:##{color}; stroke-width:4'/>\n"
+    end
+
+    def point(x, y, r, color)
+      "<circle cx='#{x}' cy='#{y}' r='#{r}' fill='#{color}' stroke='none' />"
+    end
+
+  end
+end

data/lib/eight_corner/version.rb

@@ -0,0 +1,3 @@
+module EightCorner
+  VERSION = "0.0.1"
+end

data/spec/lib/eight_corner/base_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'eight_corner'
+include EightCorner
+
+describe Base do
+  let(:subject) {Base.new(10,10)}
+
+  describe "next_point" do
+    it "should work" do
+      expect(
+        subject.next_point(Point.new(3,3), 45, 2.8)
+      ).to eq (Point.new(5,1))
+    end
+  end
+
+  describe "angle" do
+    it 'should always return an integer'
+    # D, [2014-08-09T16:09:53.857347 #12486] DEBUG -- : ["current", #<EightCorner::Point:0x007fcfd427d7f0 @x=10, @y=78>]
+    # D, [2014-08-09T16:09:53.857372 #12486] DEBUG -- : ["angle_to_next", 180.9]
+    # D, [2014-08-09T16:09:53.857394 #12486] DEBUG -- : ["distance_to_boundary", nil]
+  end
+
+  describe "distance_to_boundary" do
+
+    describe "for 0 degrees" do
+      it "should return x" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,6), 0)
+        ).to eq(5)
+      end
+    end
+
+    describe "between 1 and 89 degrees" do
+      it "should return distance to top boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(2,2), 45).round(4)
+        ).to eq(2.8284)
+      end
+      it "should return distance to right boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(9,5), 45).round(4)
+        ).to eq(1.4142)
+      end
+      it "should return a value when hitting upper-right corner" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,5), 45).round(4)
+        ).to eq(7.0711)
+      end
+    end
+
+    describe "for 90 degrees" do
+      it "should return distance to right boundary" do
+        expect(
+          subject.distance_to_boundary(Point.new(1,1), 90)
+        ).to eq(9)
+      end
+    end
+
+    describe "for 91 to 179 degrees" do
+      it "should return distance to right boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(9,7), 135).round(4)
+        ).to eq(1.4142)
+      end
+      it "should return distance to bottom boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(3,8), 135).round(4)
+        ).to eq(2.8284)
+      end
+      it "should return a value when hitting lower-right corner" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,5), 135).round(4)
+        ).to eq(7.0711)
+      end
+    end
+
+    describe "for 180 degrees" do
+      it "should return distance to bottom boundary" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,7), 180)
+        ).to eq(3)
+      end
+    end
+
+    describe "for 181 to 269 degrees" do
+      it "should return distance to bottom boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,8), 225).round(4)
+        ).to eq(2.8284)
+      end
+      it "should return distance to left boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(2,5), 225).round(4)
+        ).to eq(2.8284)
+      end
+      it "should return a value when hitting lower-left corner" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,5), 225).round(4)
+        ).to eq(7.0711)
+      end
+    end
+
+    describe "for 270 degrees" do
+      it "should return distance to left boundary" do
+        expect(
+          subject.distance_to_boundary(Point.new(3,7), 270)
+        ).to eq(3)
+      end
+    end
+
+    describe "for 271 to 359 degrees" do
+      it "should return distance to left boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(2,5), 315).round(4)
+        ).to eq(2.8284)
+      end
+      it "should return distance to top boundary when that is closest" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,2), 315).round(4)
+        ).to eq(2.8284)
+      end
+      it "should return a value when hitting upper-left corner" do
+        expect(
+          subject.distance_to_boundary(Point.new(5,5), 315).round(4)
+        ).to eq(7.0711)
+      end
+    end
+
+  end
+
+end