stylet_support 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 12e01d3fd7833198068d5740bff66a76001630134c6987f496617ba499a5beb3
+  data.tar.gz: 40630818ff1a9324a7536f0372d8efcb6927e0bc8cd70e761090b9f2c6a8622d
+SHA512:
+  metadata.gz: 123937855380833c85ee6f40318ddcf31f9372a5f5cd1d74e305acbcf4d42fae1407ede0ef370ee5ce400132f8fedf9d134aa5214d020e5a38fc8de299498df1
+  data.tar.gz: b9e199aa2dc1ec62c47451050f636632f58bfb9f057d2db55108ce55f9ad2c35566190ce173f96e84fd4527b053eb1152b1b1bfcc886021919f9165a36fa6822

data/.gitignore

@@ -0,0 +1,6 @@
+/README.html
+/Gemfile.lock
+/*.gem
+/doc
+/.yardoc
+/TODO

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.5.1
+script: bundle exec rake

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.org

@@ -0,0 +1,106 @@
+* GUIに依存しない数学関連ライブラリ
+
+#+BEGIN_SRC ruby
+Point.new                                      # => [0.0, 0.0]
+Point[1, 2]                                    # => [1, 2]
+Point[1, 2].members                            # => [:x, :y]
+Point[1, 2].values                             # => [1, 2]
+Point[1, 2]                                    # => [1, 2]
+
+Vector.superclass                              # => Stylet::Point2
+
+Point.new(Point[1,2])                          # => [1, 2]
+Point[Point[1,2]]                              # => [1, 2]
+
+Vector.new                                     # => [0.0, 0.0]
+Vector.new                                     # => [0.0, 0.0]
+Vector.new(1, 2)                               # => [1, 2]
+
+Vector.zero                                    # => [0.0, 0.0]
+Vector.one                                     # => [1.0, 1.0]
+
+a = Vector[1, 2]
+b = Vector[3, 4]
+
+a + b                                          # => [4.0, 6.0]
+a - b                                          # => [-2.0, -2.0]
+a * 2                                          # => [2.0, 4.0]
+a / 2                                          # => [0.5, 1.0]
+
+a.add(b)                                       # => [4.0, 6.0]
+a.sub(b)                                       # => [-2.0, -2.0]
+a.scale(2)                                     # => [2.0, 4.0]
+a.mul(2)                                       # => [2.0, 4.0]
+a.div(2)                                       # => [0.5, 1.0]
+
+a + [3, 4]                                     # => [4.0, 6.0]
+a - [3, 4]                                     # => [-2.0, -2.0]
+
+Vector.one.reverse                             # => [-1.0, -1.0]
+-Vector.one                                    # => [-1.0, -1.0]
+
+Vector[3, 4].normalize                         # => [0.6, 0.8]
+
+Vector.one.normalize                           # => [0.7071067811865475, 0.7071067811865475]
+Vector.one.magnitude                           # => 1.4142135623730951
+Vector.one.magnitude_sq                        # => 2.0
+
+v = Vector.rand
+v.round(2)                                     # => [-1.0, -0.88]
+v.round                                        # => [-1, -1]
+v.floor                                        # => [-1, -1]
+v.ceil                                         # => [0, 0]
+v.truncate                                     # => [0, 0]
+
+Vector.rand                                    # => [-0.5758140223421724, -0.23276547457672714]
+Vector.rand(3)                                 # => [1, 1]
+Vector.rand(3..4)                              # => [4, 4]
+Vector.rand(3.0..4)                            # => [3.9402342251571714, 3.550203689124972]
+Vector.rand(-2.0..2.0)                         # => [-1.181268220930995, 1.4942116900421252]
+
+Vector[1, 0].dot_product(Vector[1, 0])       # => 1
+Vector[1, 0].dot_product(Vector[-1, 0])      # => -1
+
+Vector.cross_product(Vector.rand, Vector.rand) # => -0.7348374986070235
+
+Vector.rand.distance_to(Vector.rand)           # => 1.7226903872525836
+
+v = Vector.new
+v.object_id                                    # => 70298637530620
+v.replace(Vector.rand)                         # => [-0.2619785178209082, -0.4396795163426983]
+v.object_id                                    # => 70298637530620
+
+Vector.zero.distance_to(Vector.one)            # => 1.4142135623730951
+
+Vector.zero.zero?                              # => true
+Vector.one.nonzero?                            # => true
+
+Vector.zero.inspect                            # => "[0.0, 0.0]"
+Vector.zero.to_s                               # => "[0.0, 0.0]"
+
+Vector[1,2].prep                               # => [-2, 1]
+#+END_SRC
+
+** TIPS
+
+*** 当たり判定を高速化するには？
+
+当たり判定を次のようにしているとき
+
+#+BEGIN_SRC ruby
+if v.magnitude < r
+end
+#+END_SRC
+
+次のようにすると sqrt を省略できる
+
+#+BEGIN_SRC ruby
+if v.magnitude_sq < r ** 2
+end
+#+END_SRC
+
+*** a地点からb地点へのベクトルを求めるには？
+
+#+BEGIN_SRC ruby
+b - a
+#+END_SRC

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+end
+
+task :default => :test

data/examples/0100_vector.rb

@@ -0,0 +1,85 @@
+require "./setup"
+include Stylet
+
+Point.new                                      # => [0.0, 0.0]
+Point.new(1, 2)                                # => [1, 2]
+Point[1, 2]                                    # => [1, 2]
+Point[1, 2].members                            # => [:x, :y]
+Point[1, 2].values                             # => [1, 2]
+Point[1, 2]                                    # => [1, 2]
+
+Point[1, 2] == Point[1, 2]                     # => true
+Point[1, 2] == Point[3, 4]                     # => false
+
+Vector.superclass                              # => Stylet::Point2
+
+Point.new(Point[1, 2])                          # => [1, 2]
+Point[Point[1, 2]]                              # => [1, 2]
+
+Vector.new                                     # => [0.0, 0.0]
+Vector.new                                     # => [0.0, 0.0]
+Vector.new(1, 2)                               # => [1, 2]
+
+Vector.zero                                    # => [0.0, 0.0]
+Vector.one                                     # => [1.0, 1.0]
+
+a = Vector[1, 2]
+b = Vector[3, 4]
+
+a + b                                          # => [4.0, 6.0]
+a - b                                          # => [-2.0, -2.0]
+a * 2                                          # => [2.0, 4.0]
+a / 2                                          # => [0.5, 1.0]
+
+a.add(b)                                       # => [4.0, 6.0]
+a.sub(b)                                       # => [-2.0, -2.0]
+a.scale(2)                                     # => [2.0, 4.0]
+a.mul(2)                                       # => [2.0, 4.0]
+a.div(2)                                       # => [0.5, 1.0]
+
+a + [3, 4]                                     # => [4.0, 6.0]
+a - [3, 4]                                     # => [-2.0, -2.0]
+
+Vector.one.reverse                             # => [-1.0, -1.0]
+-Vector.one                                    # => [-1.0, -1.0]
+
+Vector[3, 4].normalize                         # => [0.6, 0.8]
+
+Vector.one.normalize                           # => [0.7071067811865475, 0.7071067811865475]
+Vector.one.magnitude                           # => 1.4142135623730951
+Vector.one.magnitude_sq                        # => 2.0
+
+v = Vector.rand
+v.round(2)                                     # => [0.48, 0.6]
+v.round                                        # => [0, 1]
+v.floor                                        # => [0, 0]
+v.ceil                                         # => [1, 1]
+v.truncate                                     # => [0, 0]
+
+Vector.rand                                    # => [0.37182089855094613, -0.99052832152511]
+Vector.rand(3)                                 # => [1, 1]
+Vector.rand(3..4)                              # => [4, 4]
+Vector.rand(3.0..4)                            # => [3.655724436092496, 3.3356907533135023]
+Vector.rand(-2.0..2.0)                         # => [-0.6592404423144278, 1.5211933133588427]
+
+Vector[1, 0].dot_product(Vector[1, 0])         # => 1
+Vector[1, 0].dot_product(Vector[-1, 0])        # => -1
+
+Vector.cross_product(Vector.rand, Vector.rand) # => 0.7501561461552074
+
+Vector.rand.distance_to(Vector.rand)           # => 0.7463133439748652
+
+v = Vector.new
+v.object_id                                    # => 70119757980160
+v.replace(Vector.rand)                         # => [0.29626268422451485, 0.8924141847532647]
+v.object_id                                    # => 70119757980160
+
+Vector.zero.distance_to(Vector.one)            # => 1.4142135623730951
+
+Vector.zero.zero?                              # => true
+Vector.one.nonzero?                            # => true
+
+Vector.zero.inspect                            # => "[0.0, 0.0]"
+Vector.zero.to_s                               # => "[0.0, 0.0]"
+
+Vector[1, 2].prep                               # => [-2, 1]

data/examples/setup.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift "#{__dir__}/../lib"
+require "stylet_support"

data/lib/stylet_support.rb

@@ -0,0 +1,5 @@
+require "stylet_support/version"
+
+require "stylet_support/vector"
+require "stylet_support/chore"
+require "stylet_support/magic"

data/lib/stylet_support/chore.rb

@@ -0,0 +1,40 @@
+module Stylet
+  module Chore
+    extend self
+
+    def clamp(v, range = (0.0..1.0))
+      v.clamp(range.min, range.max)
+    end
+
+    def max_clamp(v, r = 1.0)
+      [v, r].min
+    end
+
+    def min_clamp(v, r = 0.0)
+      [v, r].max
+    end
+
+    def abs_clamp(v, r = 1.0)
+      clamp(v, (-r..r))
+    end
+
+    # b から a へ行きたいときの最短の角度差
+    def shortest_angular_difference(a, b)
+      d = a.modulo(1.0) - b.modulo(1.0)
+      if d < -1.0 / 2
+        d = 1.0 + d
+      elsif d > 1.0 / 2
+        d = -1.0 + d
+      end
+      d
+    end
+  end
+end
+
+if $0 == __FILE__
+  Stylet::Chore.clamp(0.5)                            # => 0.5
+  Stylet::Chore.max_clamp(1.5)                        # => 1.0
+  Stylet::Chore.min_clamp(-0.5)                       # => 0.0
+  Stylet::Chore.shortest_angular_difference(0.2, 0.5) # => -0.3
+  Stylet::Chore.shortest_angular_difference(0.8, 1.2) # => -0.3999999999999999
+end

data/lib/stylet_support/magic.rb

@@ -0,0 +1,246 @@
+require "singleton"
+
+module Stylet
+  ONE    = 4096     # sin cos の精度
+  AROUND = 4096 * 2 # 4096の場合、64分割以上のときにズレが生じる。8092なら256分割でズレるようだ
+
+  class Magic
+    include Singleton
+
+    def initialize
+      @dir_offset = 0
+    end
+
+    prepend Module.new {
+      def initialize
+        super
+        @sin_table = AROUND.times.collect { |i| (Math.sin(2 * Math::PI * i / AROUND) * ONE).round }
+      end
+
+      def _rsin(a)
+        @sin_table[a.modulo(@sin_table.size)]
+      end
+
+      def _rcos(a)
+        _rsin(a + @sin_table.size / 4)
+      end
+
+      def rsin(a)
+        a = a.modulo(1.0) # ruby の場合、一周せずに a * @sin_table.size で無限に桁がでかくなる、のを防ぐため
+        @sin_table[(a * @sin_table.size).modulo(@sin_table.size)] * 1.0 / ONE
+      end
+
+      def rcos(a)
+        rsin(a + 1.0 / 4)
+      end
+    }
+
+    prepend Module.new {
+      AtanAreaInfo = Struct.new(:base_dir, :sign)
+
+      def initialize
+        super
+        part = AROUND / 8
+        @atan_table = (0..part).collect {|i|
+          (Math.atan2(i, part) * part / (2 * Math::PI / 8)).round
+        }
+        @atan_area_info_table = [
+          AtanAreaInfo.new(AROUND / 4 * 3 + @dir_offset, +1),
+          AtanAreaInfo.new(AROUND / 4 * 4 + @dir_offset, -1),
+          AtanAreaInfo.new(AROUND / 4 * 1 + @dir_offset, -1),
+          AtanAreaInfo.new(AROUND / 4 * 0 + @dir_offset, +1),
+          AtanAreaInfo.new(AROUND / 4 * 3 + @dir_offset, -1),
+          AtanAreaInfo.new(AROUND / 4 * 2 + @dir_offset, +1),
+          AtanAreaInfo.new(AROUND / 4 * 1 + @dir_offset, +1),
+          AtanAreaInfo.new(AROUND / 4 * 2 + @dir_offset, -1),
+        ]
+      end
+
+      def angle(ox, oy, tx, ty)
+        iangle(ox, oy, tx, ty).to_f / AROUND
+        # v % 1.0 # 一周したとき 1.0 にならないようにするため
+      end
+
+      #    4 0
+      #  5     1
+      #  7     3
+      #    6 2
+      def iangle(ox, oy, tx, ty)
+        dir = nil
+
+        sx = tx - ox
+        sy = ty - oy
+
+        dx = sx
+        dy = sy
+
+        dx = dx.abs
+        dy = dy.abs
+        if sx.zero? && sy.zero?
+          dir = 0
+        else
+          if sx >= 0
+            if sy <= 0
+              # p [sx, sy]
+              # p [dx, dy]
+              if dx < dy
+                # p :koko
+                dir = local_dir(dx, dy, 0)
+              else
+                dir = local_dir(dy, dx, 1)
+                # p dir
+              end
+            else
+              if dx < dy
+                dir = local_dir(dx, dy, 2)
+              else
+                dir = local_dir(dy, dx, 3)
+              end
+            end
+          else
+            if sy <= 0
+              if dx < dy
+                dir = local_dir(dx, dy, 4)
+              else
+                dir = local_dir(dy, dx, 5)
+              end
+            else
+              if dx < dy
+                dir = local_dir(dx, dy, 6)
+              else
+                dir = local_dir(dy, dx, 7)
+              end
+            end
+          end
+        end
+        # dir.modulo(AROUND)
+        dir
+      end
+
+      def local_dir(value, div_value, area_no)
+        # p [value, div_value, area_no]
+        unless value <= div_value
+          raise ArgumentError, "#{value} <= #{div_value}"
+        end
+        ip = @atan_area_info_table[area_no]
+        dir = ip.base_dir
+        if div_value.nonzero?
+          if value != div_value
+            index = (value.to_f * AROUND / 8 / div_value).round
+            raise unless index < @atan_table.size
+            dirsub = ip.sign * @atan_table[index]
+            dir += dirsub
+          else
+            dir += ip.sign * AROUND / 8
+          end
+        end
+        # dir.modulo(AROUND) の場合は、振り子の左右の移動量が均等にならない
+        # dir.round.modulo(AROUND)
+        dir.modulo(AROUND)
+      end
+    }
+
+    class << self
+      [:_rsin, :_rcos, :iangle, :rsin, :rcos, :angle].each do |method|
+        define_method(method) do |*args, &block|
+          instance.send(method, *args, &block)
+        end
+      end
+
+      def one
+        ONE
+      end
+
+      def one_round
+        AROUND
+      end
+
+      # 一周をアナログ時計の単位と考えたときの角度(抽象化のため)
+      def clock(hour = 6, minute = 0)
+        t = -(1.0 / 4) + (1.0 * (hour % 12) / 12)
+        t += minute.fdiv(60 * 12)
+        t.modulo(1.0) / 1.0
+      end
+
+      # 一周を360度と考えたときの角度(抽象化のため)
+      def r0;           0; end
+      def r45;  1.0 / 8.0; end
+      def r90;  1.0 / 4.0; end
+      def r180; 1.0 / 2.0; end
+      def r270;   r90 * 3; end
+
+      def degree(r)
+        r / 360.0
+      end
+
+      # 円の右側か？
+      def cright?(v)
+        !cleft?(v)
+      end
+
+      # 円の左側か？
+      def cleft?(v)
+        (r90...r270).include?(v % 1.0)
+      end
+
+      # from から to への差分
+      def angle_diff(from: nil, to: nil)
+        v = to.modulo(1.0) - from.modulo(1.0)
+        if v < -1.0 / 2
+          1.0 + v
+        elsif v > 1.0 / 2
+          -1.0 + v
+        else
+          v
+        end
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  require "pp"
+  # p Stylet::Magic.rcos(0)
+  # exit
+
+  # p Stylet::Magic._rsin(0)
+  # p Stylet::Magic._rcos(0)
+  # p Stylet::Magic.iangle(0, 0, 0, 1)
+  # p Stylet::Magic.rsin(0)
+  # p Stylet::Magic.rcos(0)
+  # p Stylet::Magic.iangle(320.0, 240.0, 447.990361835411, 240.429243)
+
+  # n = Stylet::AROUND
+  # pp (0..(n*2)).collect{|i|
+  #   if i == 4 || true
+  #     # r = (Stylet::Magic.one_round / n * i) % Stylet::Magic.one_round
+  #     r = (Stylet::Magic.one_round / n * i)
+  #     x = Stylet::Magic._rcos(r)
+  #     y = Stylet::Magic._rsin(r)
+  #     dir = Stylet::Magic.iangle(0, 0, x, y)
+  #     [i, [x, y], r, dir, (r == dir)]
+  #   end
+  # }.compact
+
+  # n = 32
+  # (0..n).collect{|i|
+  #   if true
+  #     r = ((Stylet::Magic.one_round.to_f * i / n) % Stylet::Magic.one_round)
+  #     x = Stylet::Magic._rcos(r)
+  #     y = Stylet::Magic._rsin(r)
+  #     dir = Stylet::Magic.iangle(0, 0, x, y)
+  #     p [x, y, r, dir, (r == dir)]
+  #     r == dir
+  #   end
+  # }
+
+  # pp (0..8).collect{|i|
+  #   r = 1.0 / 8 * i % 1.0
+  #   x = Stylet::Magic.rcos(r)
+  #   y = Stylet::Magic.rsin(r)
+  #   dir = Stylet::Magic.angle(0, 0, x, y)
+  #   [i, r, dir, (r == dir)]
+  # }
+  # pp 8.times.collect{|i|[i, Stylet::Magic.rsin(1.0 / 8 * i)]}
+  # pp (0..12).collect{|i|[i, Stylet::Magic.clock(i)]}
+end

data/lib/stylet_support/vector.rb

@@ -0,0 +1,439 @@
+require "active_support/concern"
+
+module Stylet
+  module Shared
+    # Point.new             # => [nil, nil]
+    # Point[1, 2]           # => [1, 2]
+    # Point[1, 2].members   # => [:x, :y]
+    # Point[1, 2].values    # => [1, 2]
+    # Point[1, 2]           # => [1, 2]
+    # Point.new(Point[1,2]) # => [1, 2]
+    # Point[Point[1,2]]     # => [1, 2]
+    # Vector.new.to_h       # => {:x=>0.0, :y=>0.0}
+    # Vector.new(1, 2).to_h # => {:x=>1, :y=>2}
+    def initialize(*args)
+      if args.empty?
+        args = [0.0] * members.size
+      elsif args.size == 1 && args.first.respond_to?(:values)
+        args = args.first.values
+      end
+      super(*args)
+    end
+
+    # Vector.zero.inspect # => "[0.0, 0.0]"
+    def inspect
+      values.inspect
+    end
+
+    # Vector.zero.to_s # => "[0.0, 0.0]"
+    def to_s
+      values.inspect
+    end
+  end
+
+  class Point2 < Struct.new(:x, :y)
+    include Shared
+  end
+
+  class Point3 < Struct.new(:x, :y, :z)
+    include Shared
+  end
+
+  Point = Point2
+
+  class ZeroVectorError < StandardError; end
+
+  module BasicVector
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    class_methods do
+      # ゼロベクトルを返す
+      #   Vector.zero.to_a # => [0.0, 0.0]
+      def zero
+        new(*Array.new(members.size) { 0.0 })
+      end
+
+      # メンバーが 1.0 のベクトルを返す
+      #   Vector.one.to_a # => [1.0, 1.0]
+      def one
+        new(*Array.new(members.size) { 1.0 })
+      end
+
+      # ランダムを返す
+      #   Vector.rand            # => [0.017480344343668852, 0.8764385584061907]
+      #   Vector.rand(3)         # => [2, 2]
+      #   Vector.rand(3..4)      # => [4, 3]
+      #   Vector.rand(3.0..4)    # => [3.969678485069191, 3.4220406563055144]
+      #   Vector.rand(-2.0..2.0) # => [-1.6587999052626938, 0.5996185615991392]
+      def rand(*args)
+        if args.empty?
+          args = [-1.0..1.0]
+        end
+        new(*members.collect { Kernel.rand(*args) })
+      end
+
+      # ゼロベクトルを作ろうとすると例外を出す new
+      def safe_new(*args)
+        new(*args).tap do |obj|
+          raise ZeroVectorError if obj.zero?
+        end
+      end
+
+      # # 1.0 と -1.0 で構成したランダム値
+      # def nonzero_random_new
+      #   new(*members.collect{Chore.nonzero_random})
+      # end
+
+      # 内積
+      def dot_product(a, b)
+        members.collect { |m| a.send(m) * b.send(m) }.reduce(0, :+)
+      end
+
+      # # 外積
+      # def cross_product(a, b)
+      #   members.collect {|m|
+      #     (members - [m]).collect {|n| a.send(m) * b.send(n) }
+      #   }.flatten.reduce(0, :+)
+      # end
+    end
+
+    [
+      { :name => :add, :sym => :+ },
+      { :name => :sub, :sym => :- },
+    ].each do |attr|
+      define_method(attr[:name]) do |o|
+        unless o.is_a? self.class
+          o = self.class.new(*o.to_ary)
+        end
+        self.class.new(*members.collect { |m| Float(send(m)).send(attr[:sym], o.send(m)) })
+      end
+      define_method("#{attr[:name]}!") do |*args|
+        replace(send(attr[:name], *args))
+      end
+      alias_method attr[:sym], attr[:name]
+    end
+
+    [
+      { :name => :scale, :sym => :* },
+      { :name => :div,   :sym => :/ },
+    ].each do |attr|
+      define_method(attr[:name])       { |*args| apply(attr[:sym], *args)  }
+      define_method("#{attr[:name]}!") { |*args| apply!(attr[:sym], *args) }
+      alias_method attr[:sym], attr[:name]
+    end
+
+    alias mul scale
+    alias mul! scale!
+
+    # Vector.rand.round.to_a    # => [1, 0]
+    # Vector.rand.round(2).to_a # => [0.37, 0.92]
+    # Vector.rand.floor.to_a    # => [0, 0]
+    # Vector.rand.ceil.to_a     # => [1, 1]
+    # Vector.rand.truncate.to_a # => [0, 0]
+    [:ceil, :floor, :round, :truncate].each do |name|
+      define_method(name)        { |*args| apply(name, *args)  }
+      define_method("#{name}!")  { |*args| apply!(name, *args) }
+    end
+
+    # メンバーだけ更新(主に内部用)
+    #
+    #   v = Vector.new
+    #   v.object_id            # => 70228805905160
+    #   v.replace(Vector.rand) # => [-0.5190386805455354, -0.5679474000175717]
+    #   v.object_id            # => 70228805905160
+    #
+    def replace(other)
+      tap { members.each { |m| send("#{m}=", other.send(m)) } }
+    end
+
+    # 単位ベクトル化
+    #   Vector.one.normalize       # => [0.7071067811865475, 0.7071067811865475]
+    def normalize
+      raise ZeroVectorError if zero?
+      c = magnitude
+      self.class.safe_new(*values.collect { |v| Float(v) / c })
+    end
+
+    def normalize!
+      replace(normalize)
+    end
+
+    # ベクトルの大きさを返す
+    #   Vector.one.magnitude       # => 1.4142135623730951
+    def magnitude
+      Math.sqrt(magnitude_sq)
+    rescue Errno::EDOM => error
+      warn "(p - p).magnitude と書いているコードがあるはず。それをやると sqrt(0) になるので if p != p を入れよう: #{values.inspect}"
+      raise error
+    end
+
+    def magnitude_sq
+      values.collect { |v| v**2 }.inject(0, &:+)
+    end
+
+    alias length magnitude
+    alias length_sq magnitude_sq
+
+    # 反対方向のベクトルを返す
+    #   Vector.one.reverse # => [-1.0, -1.0]
+    def reverse
+      self.class.new(*values.collect(&:-@))
+    end
+
+    # -Vector.one # => [-1.0, -1.0]
+    alias -@ reverse
+
+    # 内積
+    #   Vector[1, 0].dot_product(Vector[1, 0])   # => 1.0
+    #   Vector[1, 0].dot_product(Vector[-1, 0])  # => -1.0
+    def dot_product(other)
+      self.class.send(__method__, self, other)
+    end
+
+    # 相手との距離を取得
+    #   Vector.zero.distance_to(Vector.one) # => 1.4142135623730951
+    def distance_to(target)
+      (target - self).magnitude
+    end
+
+    # 0ベクトルか？
+    #   Vector.zero.zero? # => true
+    def zero?
+      values.all?(&:zero?)
+    end
+
+    # 0ベクトルではない？
+    #   Vector.one.nonzero? # => true
+    def nonzero?
+      !zero?
+    end
+
+    private
+
+    def apply(method, *args)
+      self.class.new(*apply_values(method, *args))
+    end
+
+    def apply!(method, *args)
+      replace(apply(method, *args))
+    end
+
+    def apply_values(method, *args)
+      members.collect { |m| Float(send(m)).send(method, *args) }
+    end
+  end
+
+  #
+  # ベクトル
+  #
+  # 移動制限のつけ方
+  #
+  #   if vec.magnitude > n
+  #     vec.normalize.scale(n)
+  #   end
+  #
+  # 摩擦
+  #
+  #   vec.scale(0.9)
+  #
+  class Vector < Point
+    include BasicVector
+
+    # 外積
+    # x1*y2-x2*y1 = |v1||v2|sin(θ)
+    def self.cross_product(a, b)
+      a.x * b.y - b.x * a.y
+    end
+
+    def cross_product(b)
+      self.class.cross_product(self, b)
+    end
+
+    # 方向ベクトル
+    #
+    #   これを使うと次のように簡単に書ける
+    #   cursor.x += Stylet::Magic.rcos(dir) * speed
+    #   cursor.y += Stylet::Magic.rsin(dir) * speed
+    #     ↓
+    #   cursor += Stylet::Magic.angle_at(dir) * speed
+    #
+    def self.angle_at(x, y = x)
+      new(Magic.rcos(x), Magic.rsin(y))
+    end
+
+    # 反射ベクトルの取得
+    #
+    #   s: スピードベクトル
+    #   n: 法線ベクトル
+    #
+    #   定石
+    #     速度ベクトル += 速度ベクトル.reflect(法線ベクトル).scale(反射係数)
+    #     @speed += @speed.reflect(@normal).scale(0.5)
+    #
+    #   反射係数
+    #     ×1.5: 謎の力によってありえない反射をする
+    #     ◎1.0: 摩擦なし(標準)
+    #     ◎0.8: 少し滑る
+    #     ○0.6: かなり滑ってほんの少しだけ反射する
+    #     ○0.5: 線に沿って滑る
+    #     ×0.4: 線にわずかにめり込んだまま滑る
+    #     ○0.0: 線に沿って滑る(突き抜けるかと思ったけど滑る)
+    #
+    #   hakuhin.jp/as/collide.html#COLLIDE_02 の方法だと x + t * n.x * 2.0 * 0.8 と一気に書いていたけど
+    #   メソッド化するときには分解した方がわかりやすそうなのでこうした。
+    #
+    #   参考: 反射ベクトルと壁ずりベクトル
+    #   http://marupeke296.com/COL_Basic_No5_WallVector.html
+    #
+    def reflect(n)
+      slide(n) * 2.0
+    end
+
+    # スライドベクトル
+    #
+    # self: スピードベクトル
+    #    n: 法線ベクトル
+    #
+    def slide(n)
+      t = -(n.x * x + n.y * y) / (n.x**2 + n.y**2)
+      n * t
+    end
+
+    # p: 現在地点
+    # s: スピードベクトル
+    # a: 線の片方
+    # n: 法線ベクトル
+    #
+    # としたとき何倍したら線にぶつかるか
+    #
+    # 式の意味がまだ理解できてない
+    #
+    def self.collision_power_scale(p, s, a, n)
+      d = -(a.x * n.x + a.y * n.y)
+      -(n.x * p.x + n.y * p.y + d) / (n.x * s.x + n.y * s.y)
+    end
+
+    # 法線ベクトルの取得(方法1)
+    # どう見ても遅い
+    def slowly_normal(t)
+      a = angle(t) + Magic.r90
+      self.class.new(Magic.rcos(a), Magic.rsin(a))
+    end
+
+    # 法線ベクトルの取得(方法2)
+    def normal(t)
+      dx = t.x - x
+      dy = t.y - y
+      self.class.new(-dy, dx)
+    end
+
+    # 法線ベクトルの取得
+    def prep
+      self.class.new(-y, x)
+    end
+
+    #
+    # 相手の方向を取得
+    #
+    def angle_to(target)
+      (target - self).angle
+    end
+
+    # ベクトルから角度に変換
+    #
+    #   Math.atan2(y, x) * 180 / Math.PI に相当する
+    #
+    def angle
+      Magic.angle(0, 0, x, y)
+    end
+
+    # 線分 A B の距離 1.0 をしたとき途中の位置ベクトルを取得
+    #
+    #   a と b の位置が同じ場合いろいろおかしくなる
+    #
+    def self.pos_vector_ratio(a, b, rate)
+      a + angle_at(a.angle_to(b)) * (a.distance_to(b) * rate) # FIXME: ダメなコード
+    end
+
+    # 指定の角度だけ回転する
+    #
+    #   自分で最初に考えた方法
+    #
+    def rotate(a)
+      self.class.angle_at(angle + a) * magnitude
+    end
+
+    def rotate!(*args)
+      replace(rotate(*args))
+    end
+
+    # 指定の角度だけ回転する(方法2)
+    #   他のいくつかのライブラリで使われている方法。
+    def rotate2(a)
+      tx = (x * Magic.rcos(a)) - (y * Magic.rsin(a))
+      ty = (x * Magic.rsin(a)) + (y * Magic.rcos(a))
+      self.class.new(tx, ty)
+    end
+
+    def rotate2!(*args)
+      replace(rotate2(*args))
+    end
+
+    def to_2dv
+      self
+    end
+
+    def to_3dv
+      Vector3.new(*values, 0)
+    end
+  end
+
+  class Vector3 < Point3
+    include BasicVector
+
+    def to_2dv
+      Vector.new(*values.take(2))
+    end
+
+    def to_3dv
+      self
+    end
+  end
+end
+
+if $0 == __FILE__
+  # Stylet::Vector.rand * 2
+
+  p0 = Stylet::Vector.new(1, 1)
+  p1 = Stylet::Vector.new(1, 1)
+  p(p0 + p1)
+  p(p0.add(p1))
+  p(p0.add!(p1))
+  p(p0)
+  p(Stylet::Vector.new(3, 4).magnitude)
+  p(Stylet::Vector.new(3, 4).normalize.scale(5))
+  p(-Stylet::Vector.new(3, 4))
+
+  # p0 = Stylet::Vector.new(1, 1)
+  # p1 = Stylet::Vector.new(1, 1)
+  # p(p0 == p1)
+  # p p0
+  # p p0 + p1
+  # p p0.add(p1)
+  # p p0
+  # p p0.add!(p1)
+  # p p0
+  #
+  # p0 = Stylet::Vector.zero
+  # p p0.normalize
+end
+# >> [2.0, 2.0]
+# >> [2.0, 2.0]
+# >> [2.0, 2.0]
+# >> [2.0, 2.0]
+# >> 5.0
+# >> [3.0, 4.0]
+# >> [-3, -4]

data/lib/stylet_support/version.rb

@@ -0,0 +1,3 @@
+module StyletSupport
+  VERSION = "0.0.5"
+end

data/stylet_support.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "stylet_support/version"
+
+Gem::Specification.new do |s|
+  s.name          = "stylet_support"
+  s.version       = StyletSupport::VERSION
+  s.summary       = "Vector library"
+  s.description   = "Vector library"
+  s.author        = "akicho8"
+  s.homepage      = "http://github.com/akicho8/stylet_support"
+  s.email         = "akicho8@gmail.com"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {s,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport"
+  s.add_development_dependency "test-unit"
+end

data/test/test_etc.rb

@@ -0,0 +1,16 @@
+require "test_helper"
+
+class TestEtc < Test::Unit::TestCase
+  test "all" do
+    assert { Stylet::Chore.clamp(0.5) == 0.5 }
+
+    assert { Stylet::Chore.clamp(0.5) == 0.5 }
+    assert { Stylet::Chore.max_clamp(1.5) == 1.0 }
+    assert { Stylet::Chore.min_clamp(-0.5) == 0.0 }
+    assert { Stylet::Chore.abs_clamp(-1.5) == -1.0 }
+
+    assert { Stylet::Chore.shortest_angular_difference(0.2, 0.8).round(3) == 0.4 }
+    assert { Stylet::Chore.shortest_angular_difference(0.3, 0.8).round(3) == -0.5 }
+    assert { Stylet::Chore.shortest_angular_difference(0.4, 0.8).round(3) == -0.4 }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'stylet_support'
+
+include Stylet

data/test/test_magic.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class TestMagic < Test::Unit::TestCase
+  sub_test_case "整数系" do
+    test "sin/cos" do
+      assert_equal 0, Magic._rsin(0)
+      assert_equal Magic.one, Magic._rcos(0)
+    end
+
+    test "sinとcosとatan2の整合性確認" do
+      n = 64
+      r = (0..n).collect {|i|
+        r = (Magic.one_round * i / n) % Magic.one_round
+        x = Magic._rcos(r)
+        y = Magic._rsin(r)
+        dir = Magic.iangle(0, 0, x, y)
+        r == dir
+      }.all?
+
+      assert { r }
+    end
+
+    test "二点間の角度を求める" do
+      assert_equal Magic.one_round / 4, Magic.iangle(0, 0, 0, 1)
+    end
+  end
+
+  sub_test_case "一周も角度も小数で表す系" do
+    test "sin/cos" do
+      assert { Magic.rsin(0) == 0.0 }
+      assert { Magic.rcos(0) == 1.0 }
+    end
+
+    test "sinとcosとatan2の整合性確認" do
+      n = 32
+      r = (0..n).collect {|i|
+        r = 1.0 * i / n % 1.0
+        x = Magic.rcos(r)
+        y = Magic.rsin(r)
+        dir = Magic.angle(0, 0, x, y)
+        r == dir
+      }.all?
+      assert { r }
+    end
+  end
+
+  test "時計の時で方向指定" do
+    assert { Magic.clock(0) == 0.75 }
+    assert { Magic.clock(3) == 0.0 }
+    assert { Magic.clock(6) == 0.25 }
+    assert { Magic.clock(9) == 0.5 }
+    assert { Magic.clock(12) == 0.75 }
+  end
+
+  test "方向を抽象化" do
+    assert { Magic.r0 == Magic.clock(3) }
+    assert { Magic.r45 * 10000 == (Magic.clock(4, 30) * 10000).round }
+    assert { Magic.r90 == Magic.clock(6) }
+    assert { Magic.r180 == Magic.clock(9) }
+  end
+
+  test "左右どちらにいるか？" do
+    assert { Magic.cright?(Magic.clock(3)) }
+    assert { Magic.cleft?(Magic.clock(9)) }
+  end
+end

data/test/test_vector.rb

@@ -0,0 +1,69 @@
+require "test_helper"
+
+class TestVector < Test::Unit::TestCase
+  setup do
+    @p0 = Vector.new(10, 20)
+    @p1 = Vector.new(100, 200)
+    @obj = Vector.new(3, 4)
+  end
+
+  test "ランダム" do
+    Vector.rand
+  end
+
+  sub_test_case "加減演算" do
+    test "加減算" do
+      assert { (@obj + @obj) == Vector.new(6, 8) }
+      assert { (@obj - @obj) ==  Vector.zero }
+    end
+
+    test "右辺は配列でも可" do
+      assert { (@obj + [3, 4]) == Vector.new(6, 8) }
+      assert { (@obj - [3, 4]) == Vector.zero }
+    end
+  end
+
+  test "スケーリング" do
+    assert { @obj.scale(2) == Vector.new(6, 8) }
+    assert { (@obj * 2) == Vector.new(6, 8) }
+    assert { (@obj * 0.5) == Vector.new(1.5, 2.0) }
+  end
+
+  test "正規化" do
+    assert { Vector.new(3, 4).normalize == Vector.new(0.6, 0.8) }
+  end
+
+  sub_test_case "破壊的メソッド" do
+    test "add!" do
+      @p0.add!(@p1)
+      assert { @p0 == Vector.new(110, 220) }
+    end
+
+    test "sub!" do
+      @p0.sub!(@p1)
+      assert { @p0 == Vector.new(-90, -180) }
+    end
+
+    test "scale!" do
+      @p0.scale!(2)
+      assert { @p0 == Vector.new(20, 40) }
+    end
+
+    test "normalize!" do
+      @p0.normalize!
+      @p0
+    end
+  end
+
+  test "長さ" do
+    assert { Vector.new(3, 4).magnitude == 5 }
+  end
+
+  test "距離" do
+    assert { @p0.distance_to(@p1).to_i == 201 }
+  end
+
+  test "方向" do
+    assert { @p0.angle_to(@p1) < 1.0 }
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: stylet_support
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- akicho8
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: test-unit
+  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: Vector library
+email: akicho8@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.org
+- Rakefile
+- examples/0100_vector.rb
+- examples/setup.rb
+- lib/stylet_support.rb
+- lib/stylet_support/chore.rb
+- lib/stylet_support/magic.rb
+- lib/stylet_support/vector.rb
+- lib/stylet_support/version.rb
+- stylet_support.gemspec
+- test/test_etc.rb
+- test/test_helper.rb
+- test/test_magic.rb
+- test/test_vector.rb
+homepage: http://github.com/akicho8/stylet_support
+licenses: []
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Vector library
+test_files: []