glmath 0.0.1.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 66841450cf95c7713843605f3c656821a45057fd
+  data.tar.gz: 38ce2be773aa7000ab1bd2eef22c454fa2fe856a
+SHA512:
+  metadata.gz: 1c3b27612f24dfb30f9a1af21b92acf5cce1d015ffed5dd3889159f4c37e4b0ec2c59dcc57e764a74d9bd011a0a3e354e15acf134e2364f94e80b10b569ee03f
+  data.tar.gz: bcaec488839a917334e4e407f730d06b219a071d5e04e62c1939fd2dd5ac1b5eec6d7dd469571e81e30d5528482a5658ec12f6cda91eaf426fcbe1809ae5935f

data/lib/glmath.rb

@@ -0,0 +1,21 @@
+module Math
+  TAU = 2 * PI
+end
+
+require_relative 'version'
+
+%w'
+   matrix
+   matrix2
+   matrix3
+   matrix4
+   vector
+   vector2
+   vector3
+   vector4
+   scalar
+   quaternion
+   euler_angle
+   matrix_stack
+'.each { |f| require_relative "glmath/#{f}" }
+

data/lib/glmath/euler_angle.rb

@@ -0,0 +1,60 @@
+module GLMath
+  class EulerAngle
+    def initialize(y, r, p)
+      @e = y, r, p
+    end
+
+    %w'y r p'.each.each_with_index do |m, i|
+      define_method m, ->(){ @e[i] }
+      define_method "#{m}=", ->(v){ @e[i] = v }
+    end
+
+    def ==(other)
+      return false unless self.class === other
+      @e == other.instance_variable_get(:@e)
+    end
+
+    def to_matrix(*args)
+      args = [:y, :p, :r] if args.length == 0
+      cy, sy, cp, sp, cr, sr = nil
+      args.map do |i|
+        case i
+          when :y, :yaw, :h, :heading
+            cy ||= cos(y)
+            sy ||= sin(y)
+            Matrix4[cy, 0, -sy, 0, 0, 1, 0, 0, sy, 0, cy, 0, 0, 0, 0, 1]
+          when :p, :pitch
+            cp ||= cos(p)
+            sp ||= sin(p)
+            Matrix4[1, 0, 0, 0, 0, cp, sp, 0, 0, -sp, cp, 0, 0, 0, 0, 1]
+          when :r, :roll, :b, :bank
+            cr ||= cos(r)
+            sr ||= sin(r)
+            Matrix4[cr, sr, 0, 0, -sr, cr, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+          else
+            1
+        end
+      end.reduce(&:*)
+    end
+
+    def to_quaternion
+      Quaternion.new(a, b, c, d)
+    end
+
+    def inspect
+      "Euler Angle (#{@e.join(', ')})"
+    end
+
+    def dup
+      self.class.new(*@e)
+    end
+
+    alias_method :h,       :y
+    alias_method :heading, :y
+    alias_method :yaw,     :y
+    alias_method :b,       :r
+    alias_method :bank,    :r
+    alias_method :pitch,   :p
+    alias_method :roll,    :r
+  end
+end

data/lib/glmath/line.rb

@@ -0,0 +1,19 @@
+module GLMath
+  class Line
+
+  end
+
+  class LineSegment
+    def initialize(x1, y1, z1 = 0, x2, y2, z2 = 0)
+      @start_point = Vector3[x1, y1, z1]
+      @end_point = Vector3[x2, y2, z2]
+      @vector = @end_point - @start_point
+    end
+
+    def length
+      @vector.length
+    end
+
+
+  end
+end

data/lib/glmath/matrix.rb

@@ -0,0 +1,413 @@
+
+module GLMath
+  module Matrix
+    module ClassMethods
+      def [](*rows)
+        new(*rows)
+      end
+
+      def build
+        new(*dim.times.flat_map { |r| dim.times.map { |c| yield r, c } })
+      end
+
+      def columns(*args)
+        raise ArgumentError, "wrong number of arguments #{args.length} for #{dim}" unless args.length == dim
+        raise ArgumentError, "wrong array size. All arrays must have size #{dim}" unless args.all? { |arg| arg.length == dim }
+        new(*args.transpose.flatten(1))
+      end
+
+      def diagonal(*args)
+        raise ArgumentError, "wrong number of arguments (#{args.length} for #{dim})" if args.length != dim
+        build { |r, c| r == c ? args[r] : 0.0 }
+      end
+
+      def dim
+        dimension
+      end
+
+      def identity
+        scalar(1.0)
+      end
+
+      def length
+        dim * dim
+      end
+
+      def rows(*args)
+        raise ArgumentError, "wrong number of arguments #{args.length} for #{dim}" unless args.length == dim
+        raise ArgumentError, "wrong array size. All arrays must have size #{dim}" unless args.all? { |arg| arg.length == dim }
+        new(*args.flatten(1))
+      end
+
+      def scalar(n)
+        build { |r, c| r == c ? n : 0.0 }
+      end
+
+      def zero
+        new(*[0.0]*(dim*dim))
+      end
+
+      alias_method :I,    :identity
+      alias_method :unit, :identity
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def initialize(*args)
+      raise ArgumentError, "wrong number of arguments (#{args.length} for #{dim * dim})" unless args.length == dim * dim
+      raise ArgumentError, "It's not numeric" unless args.all? { |e| Numeric === e }
+      @m = args
+    end
+
+    %w'+ -'.each do |s|
+      define_method(s, ->(m) do
+        raise ArgumentError unless self.class === m
+        m = m.instance_variable_get(:@m)
+        self.class.new(*[@m, m].transpose.map { |a, b| a.send(s, b) })
+      end)
+    end
+
+    def *(v)
+      raise ArgumentError, v.class unless v.is_a?(Numeric)
+      self.class.new(*@m.map { |e| e * v })
+    end
+
+    def /(other)
+      case other
+        when Numeric
+          self.class.new(*@m.map { |v| v / other })
+        when self.class
+          # transpose(A) = A'.
+          # A / B = X (=) A = XB (=) B'X' = A'
+          other.transpose.solve(self.transpose).transpose
+        else
+          raise ArgumentError, "Invalid type #{other.class}"
+      end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @m == other.instance_variable_get(:@m)
+    end
+
+    def [](r, c = nil)
+      @m[c ? r * dim + c : r]
+    end
+
+    def []= (r, c = nil, n)
+      @m[c ? r * dim + c : r] = n
+    end
+
+    def adjoint
+      clone.adjoint!
+    end
+
+    def adjoint!
+      conjugate!
+      transpose!
+    end
+
+    def adjugate
+      clone.adjugate!
+    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)
+      block_given? ? self.class.new(*@m.collect(&block)) : to_enum(:collect)
+    end
+
+    def column(c)
+      raise ArgumentError, "can only be an Integer between 0 and #{dim - 1}:#{c}" unless c.is_a?(Integer) && (0...dim).include?(c)
+      dim.times.map { |r| @m[r * dim + c] }
+    end
+
+    def columns
+      dim.times.map { |c| column(c) }
+    end
+
+    def conjugate
+      clone.conjugate!
+    end
+
+    def conjugate!
+      @m.map!(&:conjugate)
+      self
+    end
+
+    def clone
+      self.class.new(*@m)
+    end
+
+    def diagonal
+      dim.times.map { |r| self[r, r] }
+    end
+
+    def diagonal?
+      each(:off_diagonal).all?(&:zero?)
+    end
+
+    def dimension
+      self.class.dimension
+    end
+
+    def dup
+      self.class.new(*@m)
+    end
+
+    def each(which = :all)
+      return to_enum :each, which unless block_given?
+      case which
+        when :all
+          @m.each { |e| yield e }
+        when :diagonal
+          dim.times.each { |r| yield self[r, r] }
+        when :off_diagonal
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c] unless r == c } }
+        when :lower
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c] if r >= c } }
+        when :strict_lower
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c] if r > c } }
+        when :strict_upper
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c] if r < c } }
+        when :upper
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c] if r <= c } }
+        else
+          raise ArgumentError, which
+      end
+      self
+    end
+
+    def each_with_index(which = :all)
+      return to_enum :each_with_index, which unless block_given?
+      case which
+        when :all
+          @m.each_with_index { |e, i| yield e, i / dim, i % dim }
+        when :diagonal
+          dim.times.each { |r| yield self[r, r], r, r }
+        when :off_diagonal
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c], r, c unless r == c } }
+        when :lower
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c], r, c if r >= c } }
+        when :strict_lower
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c], r, c if r > c } }
+        when :strict_upper
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c], r, c if r < c } }
+        when :upper
+          dim.times.each { |r| dim.times.each { |c| yield self[r, c], r, c if r <= c } }
+        else
+          raise ArgumentError, which
+      end
+      self
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && @m.eql?(other.to_a)
+    end
+
+    def hash
+      @m.hash
+    end
+
+    def hermitian?
+      transpose.conjugate! == self
+    end
+
+    def imaginary
+      map(&:imaginary)
+    end
+
+    def inspect
+      "Matrix#{dim}#{@m.inspect}"
+    end
+
+    def inverse
+      # the inverse is solution to the equation AX = I
+      solve(self.class.identity)
+    end
+
+    def length
+      @m.length
+    end
+
+    def lower_triangular?
+      each(:strict_upper).all?(&:zero?)
+    end
+
+    def lup
+      raise ArgumentError, "Determinant is zero" if singular?
+
+      # get pivot
+      p = self.class.identity.rows
+      rows = self.rows
+      (dim - 1).times do |i|
+        max, row = rows[i][i], i
+        (i+1...dim).each { |j| max, row = rows[j][i], j if rows[j][i] > max }
+        p[i], p[row] = p[row], p[i]
+        rows[i], rows[row] = rows[row], rows[i]
+      end
+      p = self.class.new(*p.flatten(1))
+      pivoted = self.class.new(*rows.flatten(1))
+
+      # calculate L and U matrices
+      l = self.class.identity
+      u = self.class.zero
+
+      dim.times.each do |i|
+        dim.times.each do |j|
+          if j >= i
+            # upper
+            u[i, j] = pivoted[i, j] - i.times.map { |k| u[k, j] * l[i, k] }.reduce(0.0, &:+)
+          else
+            # lower
+            l[i, j] = (pivoted[i, j] - j.times.map { |k| u[k, j] * l[i, k] }.reduce(0.0, &:+)) / u[j, j]
+          end
+        end
+      end
+
+      [ l, u, p ]
+    end
+
+    def normal?
+      n = transpose.conjugate!
+      self * n == n * self
+    end
+
+    def permutation?
+      rows.each do |r|
+        return false unless r.select { |v| v.abs < 1e-14 }.count == dim - 1
+        return false unless r.index { |v| (1.0 - v).abs < 1e-14 }
+      end
+
+      columns.each do |c|
+        return false unless c.select { |v| v.abs < 1e-14 }.count == dim - 1
+        return false unless c.index { |v| (1.0 - v).abs < 1e-14 }
+      end
+
+      true
+    end
+
+    def real
+      map(&:real)
+    end
+
+    def real?
+      @m.all?(&:real?)
+    end
+
+    def round(ndigits = 0)
+      map { |e| e.round(ndigits) }
+    end
+
+    def row(r)
+      raise ArgumentError, "can only be between 0 and #{dim}:#{r}" unless (0...dim).include? r
+      @m[r * dim, dim]
+    end
+
+    def rows
+      dim.times.map { |i| row(i) }
+    end
+
+    def scalar?
+      diag = []
+      each_with_index do |v, r, c|
+        return false if r != c && !v.zero?
+        diag << v if r == c
+      end
+      diag.uniq.size == 1
+    end
+
+    def singular?
+      determinant.zero?
+    end
+
+    # Solves *AX = B*, where *A* is `self` and *B* is the argument
+    def solve(matrix)
+      raise ArgumentError, "expected class #{ self.class }, but got #{ matrix.class }" unless self.class === matrix
+
+      l, u, p = lup
+
+      # Ax = b (=) LUx = b (=) Ly = b && Ux = y
+      # If y is defined to be Ux: Ly = b
+      y = self.class.zero
+      matrix = p * matrix
+      # Forward solve Ly = b
+      dim.times do |c|
+        dim.times do |r|
+          y[r, c] = matrix[r, c]
+          (0...r).each { |j| y[r, c] -= l[r, j] * y[j, c] }
+          y[r, c] /= l[r, r]
+        end
+      end
+
+      # Backward solve Ux = y
+      x = self.class.zero
+
+      dim.times do |c|
+        (dim - 1).downto(0) do |i|
+          x[i, c] = y[i, c]
+          (i+1...dim).each { |j| x[i, c] -= u[i, j] * x[j, c] }
+          x[i, c] /= u[i, i]
+        end
+      end
+
+      x
+    end
+
+    def symmetric?
+      each_with_index(:strict_upper).all? { |e, r, c| e == self[c, r] }
+    end
+
+    def to_a
+      @m.dup
+    end
+
+    def to_s(notation = nil)
+      case notation
+        when nil     then "#{self.class.name.gsub(/^.*::/,'')}#{@m}"
+        when :matrix then (dim*dim).times.each_slice(dim).map { |s| s.map { |i| self[i] }.join("\t") }.join("\n")
+        else raise ArgumentError, "unknown notation #{notation.inspect}"
+      end
+    end
+
+    def trace
+      diagonal.reduce(&:+)
+    end
+
+    def transpose
+      clone.transpose!
+    end
+
+    def transpose!
+      @m = @m.each_slice(dim).to_a.transpose.flatten!(1)
+      self
+    end
+
+    def upper_triangular?
+      each(:strict_lower).all?(&:zero?)
+    end
+
+    def zero?
+      @m.all?(&:zero?)
+    end
+
+    alias_method :component,         :[]
+    alias_method :conj,              :conjugate
+    alias_method :conj!,             :conjugate!
+    alias_method :dim,               :dimension
+    alias_method :element,           :[]
+    alias_method :imag,              :imaginary
+    alias_method :inv,               :inverse
+    alias_method :lup_decomposition, :lup
+    alias_method :map,               :collect
+    alias_method :t,                 :transpose
+    alias_method :t!,                :transpose!
+    alias_method :tr,                :trace
+  end
+end