glmath 0.0.1.dev

data/lib/glmath/rect.rb

@@ -0,0 +1,135 @@
+module GLMath
+  class Rect
+    attr_accessor :x, :y, :width, :height
+
+    def initialize(x = 0, y = 0, width = 0, height = 0)
+      self.x, self.y, self.width , self.height = x, y, width, height
+    end
+
+    def [](v)
+      send v
+    end
+
+    def []=(k, v)
+      send("#{k}=", v)
+    end
+
+    def ==(r)
+      return false unless r.is_a? Rect
+      %w(x y width height).map{ |v| self[v] == r[v] }.all?{ |v| v }
+    end
+
+    def bottom
+      y
+    end
+
+    def bottom=(v)
+      self.y = v
+    end
+
+    def center
+      [center_x, center_y]
+    end
+
+    def center_x
+      x + width/2
+    end
+
+    def center_y
+      y + height/2
+    end
+
+    def center=(c)
+      cx, cy = c
+      self.x, self.y = cx - width/2, cy - height/2
+    end
+
+    def include?(x, y)
+      (left..right).include?(x) && (bottom..top).include?(y)
+    end
+
+    def left
+      x
+    end
+
+    def left=(v)
+      self.x = v
+    end
+
+    def outside?(x, y)
+      !include?(x, y)
+    end
+
+    def right
+      x+width
+    end
+
+    def right=(v)
+      self.width = v - x
+    end
+
+    def to_a
+      [left, bottom, width, height]
+    end
+
+    def area
+      width * height
+    end
+
+    def perimeter
+      2 * width + 2 * area
+    end
+
+    def diagonals
+      [diagonal_top_left, diagonal_top_right]
+    end
+
+    def diagonal_top_left
+      LineSegment.new(top, left, bottom, right)
+    end
+
+    def diagonal_top_right
+      LineSegment.new(top, right, bottom, left)
+    end
+
+    def diagonal_length
+      Math.sqrt(width ** 2 + height ** 2)
+    end
+
+    def to_s
+      "<Rect #{%w'left bottom width height'.map { |name| "#{name} = #{send(name)}" }.join(', ')}>"
+    end
+
+    def top
+      y + height
+    end
+
+    def top=(v)
+      self.height = v - y
+    end
+
+    def vertices(format = :strip)
+      case format
+      when :strip then [[left, top], [right, top], [left, bottom], [right, bottom]]
+      when :cycle then [[left, top], [right, top], [right, bottom], [left, bottom]]
+      else nil
+      end
+    end
+
+    def self.from_center(cx, cy, width, height)
+      new do
+        self.x, self.y, self.width, self.height = cx - width/2, cy - height/2, width, height
+      end
+    end
+
+    alias_method :to_ary, :to_a
+    alias_method :inside?, :include?
+
+  end
+
+  class Square < Rect
+    def initialize(x, y, size)
+      super(x, y, size, size)
+    end
+  end
+end

data/lib/glmath/scalar.rb

@@ -0,0 +1,33 @@
+module GLMath
+  class Scalar
+
+    def initialize(n)
+      raise ArgumentError, 'Must be numeric' unless n.is_a?(Numeric)
+      @n = n
+    end
+
+    def *(other)
+      case other
+        when Vector2, Vector3, Vector4, Matrix2, Matrix3, Matrix4
+          other.map { |e| @n * e }
+        else raise ArgumentError
+      end
+    end
+
+    def /(other)
+      case other
+        when Matrix2, Matrix3, Matrix4
+          self * other.inverse
+        else raise ArgumentError
+      end
+    end
+
+    def ==(other)
+      case other
+        when Scalar  then @n == other.instance_variable_get(:@n)
+        when Numeric then @n == other
+        else false
+      end
+    end
+  end
+end

data/lib/glmath/vector.rb

@@ -0,0 +1,155 @@
+module GLMath
+  module Vector
+    module ClassMethods
+      def [](*array)
+        new(*array)
+      end
+
+      def zero
+        new(*([0.0] * size))
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def initialize(*args)
+      raise ArgumentError, "wrong number of arguments (#{args.size} for #{size})" if args.size != size
+      raise ArgumentError, "It's not numeric" unless args.all? { |e| Numeric === e }
+      @v = args
+    end
+
+    %w'+ -'.each do |s|
+      define_method(s, ->(v) do
+        raise ArgumentError unless self.class === v
+        v = v.instance_variable_get(:@v)
+        self.class.new(*[@v, v].transpose.map!{ |a, b| a.send(s, b) })
+      end)
+    end
+
+    def -@
+      self.class.new(*@v.map(&:-@))
+    end
+
+    def /(v)
+      case v
+        when Numeric
+          self.class.new *@v.map{ |e| e / v }
+        else
+          raise ArgumentError, "Operation '/' not valid for #{v.class}"
+      end
+    end
+
+    def ==(other)
+      return false unless self.class === other
+      @v == other.instance_variable_get(:@v)
+    end
+
+    def [](i)
+      @v[i]
+    end
+
+    def angle(other)
+      raise ArgumentError, "argument must be a #{self.class}" unless self.class === other
+      Math.acos(dot(other) / Math.sqrt(square_norm * other.square_norm))
+    end
+
+    def coerce(v)
+      case v
+        when Numeric then return Scalar.new(v), self
+        else raise TypeError, "#{self.class} can't be coerced into #{v.class}"
+      end
+    end
+
+    def collect(&block)
+      return to_enum(__method__) unless block_given?
+      self.class.new(*@v.collect(&block))
+    end
+
+    def dup
+      self.class.new(*@v)
+    end
+
+    def each(&block)
+      return to_enum(__method__) unless block_given?
+      @v.each(&block)
+      self
+    end
+
+    def eql?(other)
+      return false unless self.class === other
+      @v.eql? other.instance_variable_get(:@v)
+    end
+
+    def hash
+      @v.hash
+    end
+
+    def inner_product(v)
+      raise ArgumentError unless self.class === v
+      v = v.instance_variable_get(:@v)
+      [@v, v].transpose.map!{ |a, b| a * b }.reduce(&:+)
+    end
+
+    def magnitude
+      Math.sqrt(inner_product(self))
+    end
+
+    def normalize
+      self / magnitude
+    end
+
+    def normalize!
+      mag = magnitude
+      @v.map! { |e| e / mag }
+      self
+    end
+
+    def size
+      self.class.size
+    end
+
+    def square_magnitude
+      dot(self)
+    end
+
+    def zero?
+      @v.all?(&:zero?)
+    end
+
+    %w'x y'.each_with_index do |s, i|
+      define_method s, ->(){ @v[i] }
+      define_method "#{s}=", ->(v){ @v[i] = v }
+    end
+
+    def to_a
+      @v.dup
+    end
+
+    def to_ary
+      to_a
+    end
+
+    def to_s(notation = nil)
+      case notation
+        when nil        then inspect
+        when :row       then "[#{@v.join("\t")}]"
+        when :column    then @v.join("\n")
+        when :cartesian then "(#{@v.join(", ")})"
+      end
+    end
+
+    def inspect
+      "Vector#{size}#{@v.inspect}"
+    end
+
+    alias_method :dot,           :inner_product
+    alias_method :r,             :magnitude
+    alias_method :length,        :magnitude
+    alias_method :norm,          :magnitude
+    alias_method :map,           :collect
+    alias_method :square_length, :square_magnitude
+    alias_method :square_norm,   :square_magnitude
+  end
+end

data/lib/glmath/vector2.rb

@@ -0,0 +1,45 @@
+module GLMath
+  class Vector2
+
+    class << self
+      def size
+        2
+      end
+
+      def X
+        new(1.0, 0.0)
+      end
+
+      def Y
+        new(0.0, 1.0)
+      end
+    end
+
+    include Vector
+
+    def *(v)
+      case v
+        when Numeric
+          self.class.new(*@v.map{ |e| e * v })
+        when Matrix2
+          self.class.new(x * v[0] + y * v[2], x * v[1] + y * v[3])
+        else
+          raise ArgumentError
+      end
+    end
+
+    def expand(*args)
+      args.flatten!
+      case
+        when args.length == 1 && args.is_a?(Vector2)
+          Vector4.new(*(@v + args[0].to_a))
+        when args.length == 1 && args[0].is_a?(Numeric)
+          Vector3.new(*(@v + args))
+        when args.length == 2 && args.all? { |e| e.is_a?(Numeric) }
+          Vector4.new(*(@v + args))
+        else
+          raise ArgumentError
+      end
+    end
+  end
+end

data/lib/glmath/vector3.rb

@@ -0,0 +1,66 @@
+module GLMath
+  class Vector3
+
+    include Vector
+
+    class << self
+      def size
+        3
+      end
+
+      def X
+        new(1.0, 0.0, 0.0)
+      end
+
+      def Y
+        new(0.0, 1.0, 0.0)
+      end
+
+      def Z
+        new(0.0, 0.0, 1.0)
+      end
+    end
+
+    def *(v)
+      case v
+        when Numeric
+          self.class.new(*@v.map{ |e| e * v })
+        when Matrix3
+          self.class.new(v[0] * x + v[3] * y + v[6] * z,
+                         v[1] * x + v[4] * y + v[7] * z,
+                         v[2] * x + v[5] * y + v[8] * z)
+        else
+          raise ArgumentError
+      end
+    end
+
+    def expand(w)
+      raise ArgumentError unless w.is_a? Numeric
+      Vector4.new(*(@v + [w]))
+    end
+
+    def outer_product(v)
+      v = v.instance_variable_get(:@v)
+      self.class.new(@v[2] * v[1] - @v[1] * v[2], @v[0] * v[2] - @v[2] * v[0], @v[1] * v[0] - @v[0] * v[1])
+    end
+
+    def z
+      @v[2]
+    end
+
+    def xy
+      Vector2.new(*@v[0, 2])
+    end
+
+    def xz
+      Vector2.new(@v[0], @v[2])
+    end
+
+    def yz
+      Vector2.new(*@v[1, 2])
+    end
+
+    alias_method :cross_product, :outer_product
+    alias_method :cross,         :outer_product
+  end
+end

data/lib/glmath/vector4.rb

@@ -0,0 +1,54 @@
+module GLMath
+  class Vector4
+
+    class << self
+      def size
+        4
+      end
+
+      def X
+        new(1.0, 0.0, 0.0, 0.0)
+      end
+
+      def Y
+        new(0.0, 1.0, 0.0, 0.0)
+      end
+
+      def Z
+        new(0.0, 0.0, 1.0, 0.0)
+      end
+
+      def W
+        new(0.0, 0.0, 0.0, 1.0)
+      end
+    end
+
+    include Vector
+
+    def *(v)
+      case v
+        when Numeric
+          self.class.new(*@v.map{ |e| e * v })
+        when Matrix4
+          self.class.new(x * v[0] + y * v[4] + z * v[ 8] + w * v[12],
+                         x * v[1] + y * v[5] + z * v[ 9] + w * v[13],
+                         x * v[2] + y * v[6] + z * v[10] + w * v[14],
+                         x * v[3] + y * v[7] + z * v[11] + w * v[15])
+        else
+          raise ArgumentError
+      end
+    end
+
+    def z
+      @v[2]
+    end
+
+    def w
+      @v[3]
+    end
+
+    %w(xy xz xw yz yw zw xyz xyw xzw yzw).each do |m|
+      instance_eval("def #{m}() Vector#{m.length}.new(#{m.each_char.to_a.join(', ')}) end")
+    end
+  end
+end