rmath3d_plain 1.0.2 → 1.1.0

data/test/test.rb

@@ -11,8 +11,10 @@ include RMath3D
 require 'minitest/autorun'
 
 # Test cases
+require_relative 'test_RVec2.rb'
 require_relative 'test_RVec3.rb'
 require_relative 'test_RVec4.rb'
 require_relative 'test_RQuat.rb'
+require_relative 'test_RMtx2.rb'
 require_relative 'test_RMtx3.rb'
 require_relative 'test_RMtx4.rb'

data/test/test_RMtx2.rb

@@ -0,0 +1,363 @@
+class TC_RMtx2 < Minitest::Test
+
+  def setup
+    @tolerance = RMath3D::TOLERANCE
+    @mZero = RMtx2.new.setZero
+    @mIdentity = RMtx2.new.setIdentity
+  end
+
+  def teardown
+  end
+
+  def test_RMtx_initialize
+    m0 = RMtx2.new
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( 0.0, m0.getElement(r,c) )
+      end
+    end
+
+    m1 = RMtx2.new( 0, 1,
+                    2, 3 )
+    assert_equal( 0, m1.getElement(0,0) )
+    assert_equal( 1, m1.getElement(0,1) )
+    assert_equal( 2, m1.getElement(1,0) )
+    assert_equal( 3, m1.getElement(1,1) )
+
+    m2 = RMtx2.new( m1 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( 2*r+c, m2.getElement(r,c) )
+      end
+    end
+  end
+
+  def test_to_s
+    assert_respond_to( @mZero, :to_s )
+  end
+
+  def test_coerce
+    assert_respond_to( @mZero, :coerce )
+  end
+
+  def test_setElements
+    @mZero.setElements( 0, 1, 2, 3 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( 2*r+c, @mZero.getElement(r,c) )
+      end
+    end
+  end
+
+  def test_setElement
+    for r in 0...2 do
+      for c in 0...2 do
+        @mZero.setElement( r, c, 2*r+c )
+      end
+    end
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( 2*r+c, @mZero.getElement(r,c) )
+      end
+    end
+
+    for r in 0...2 do
+      for c in 0...2 do
+        @mZero[r, c] = 2*c+r
+      end
+    end
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( 2*c+r, @mZero[r,c] )
+      end
+    end
+  end
+
+  def test_getElement
+    assert_respond_to( @mIdentity, :getElement )
+    for r in 0...2 do
+      for c in 0...2 do
+        e = @mIdentity.getElement( r, c )
+        if ( r == c )
+          assert_equal( 1.0, e )
+        else
+          assert_equal( 0.0, e )
+        end
+      end
+    end
+
+    for r in 0...2 do
+      for c in 0...2 do
+        e = @mIdentity[ r, c ]
+        if ( r == c )
+          assert_equal( 1.0, e )
+        else
+          assert_equal( 0.0, e )
+        end
+      end
+    end
+
+    mtx = RMtx2.new(1,2,
+                    3,4)
+    assert_equal( mtx.e00, 1 )
+    assert_equal( mtx.e01, 2 )
+    assert_equal( mtx.e10, 3 )
+    assert_equal( mtx.e11, 4 )
+  end
+
+  def test_getRowColumn
+    mtx = RMtx2.new(1,2,
+                    3,4)
+
+    v = mtx.getRow(0)
+    assert_equal( v.x, 1 )
+    assert_equal( v.y, 2 )
+
+    v = mtx.getRow(1)
+    assert_equal( v.x, 3 )
+    assert_equal( v.y, 4 )
+
+    v = mtx.getColumn(0)
+    assert_equal( v.x, 1 )
+    assert_equal( v.y, 3 )
+
+    v = mtx.getColumn(1)
+    assert_equal( v.x, 2 )
+    assert_equal( v.y, 4 )
+  end
+
+  def test_setRowColumn
+    mtx = RMtx2.new
+
+    vr = [RVec2.new(1,2),RVec2.new(3,4)]
+    mtx.setRow(vr[0],0)
+    mtx.setRow(vr[1],1)
+    assert_equal( mtx.e00, 1 )
+    assert_equal( mtx.e01, 2 )
+    assert_equal( mtx.e10, 3 )
+    assert_equal( mtx.e11, 4 )
+
+    vc = [RVec2.new(1,2),RVec2.new(3,4)]
+    mtx.setColumn(vc[0],0)
+    mtx.setColumn(vc[1],1)
+    assert_equal( mtx.e00, 1 )
+    assert_equal( mtx.e01, 3 )
+    assert_equal( mtx.e10, 2 )
+    assert_equal( mtx.e11, 4 )
+  end
+
+  def test_setZero
+    m = RMtx2.new( 1, 2, 3, 4 )
+    m.setZero
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( 0.0, m.getElement( r, c ) )
+      end
+    end
+  end
+
+  def test_setIdentity
+    m = RMtx2.new( 1, 2, 3, 4 )
+    m.setIdentity
+    for r in 0...2 do
+      for c in 0...2 do
+        e = @mIdentity.getElement( r, c )
+        if ( r == c )
+          assert_equal( 1.0, e )
+        else
+          assert_equal( 0.0, e )
+        end
+      end
+    end
+  end
+
+  def test_getDeterminant
+    m1 = RMtx2.new( 2, -3,
+                    1,  3 )
+    assert_equal( 9.0, m1.getDeterminant )
+  end
+
+  def test_transpose
+    m0 = RMtx2.new( -2, -3,
+                    -1,  3 )
+    # RMtx2#getTransposed
+    m1 = m0.getTransposed
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( m0.getElement(c,r), m1.getElement(r,c) )
+      end
+    end
+
+    # RMtx2#transpose!
+    m0.transpose!
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_equal( m0.getElement(r,c), m1.getElement(r,c) )
+      end
+    end
+  end
+
+  def test_inverse
+    # RMtx2#getInverse
+    m0 = RMtx2.new( 1, 2,
+                    3, 4 )
+
+    m0inv = RMtx2.new(-2.0,  1.0,
+                       1.5, -0.5 )
+    m1 =  m0.getInverse
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0inv.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx2#invert!
+    m0.invert!
+
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0inv.getElement(r,c), m0.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_rotation
+    m0 = RMtx2.new(  Math::sqrt(2)/2, -Math::sqrt(2)/2,
+                     Math::sqrt(2)/2,  Math::sqrt(2)/2 )
+    m1 = RMtx2.new.rotation( Math::PI/4.0 )
+
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_scaling
+    m0 = RMtx2.new( 10.0,  0.0,
+                     0.0, 20.0 )
+    m1 = RMtx2.new.scaling( 10.0, 20.0 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_unary_operators
+    # RMtx2#+@
+    m0 = RMtx2.new( 0, 1, 2, 3 )
+    m1 = RMtx2.new( 0, 1, 2, 3 )
+    m2 = +m0
+
+    assert_same( m0, m2 )
+    assert( m1 == m2 )
+
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( 2*r+c, m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx2#-@
+    m2 = -m0
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0.getElement(r,c), -m2.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_binary_plus
+    m0 = RMtx2.new( 0, 1, 2, 3 )
+    m1 = RMtx2.new( 9,10,11,12 )
+    m2 = RMtx2.new( 9,11,13,15 )
+
+    # RMtx2#+
+    m3 = m0 + m1
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx2#add!
+    m0.add!( m1 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m2.getElement(r,c), m0.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_binary_minus
+    m0 = RMtx2.new( 0, 1, 2, 3 )
+    m1 = RMtx2.new( 9,10,11,12 )
+    m2 = RMtx2.new(-9,-9,-9,-9 )
+
+    # RMtx2#-
+    m3 = m0 - m1
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx2#sub!
+    m0.sub!( m1 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m2.getElement(r,c), m0.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_binary_mult
+    m0 = RMtx2.new( 0, 1, 2, 3 )
+    m1 = RMtx2.new( 9,10,11,12 )
+    m0x1 = RMtx2.new( 11, 12, 51, 56)
+    m1x0 = RMtx2.new( 20, 39, 24, 47)
+
+    # RMtx2#*
+    m2 = m0 * m1
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0x1.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    m2 = m1 * m0
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m1x0.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx2#mul!
+    m2 = RMtx2.new( m0 )
+    m2.mul!( m1 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m0x1.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    m2 = RMtx2.new( m1 )
+    m2.mul!( m0 )
+    for r in 0...2 do
+      for c in 0...2 do
+        assert_in_delta( m1x0.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_equality_operators
+    m0 = RMtx2.new( 0, 1, 2, 3 )
+    m1 = RMtx2.new( 0, 1, 2, 3 )
+    m2 = RMtx2.new( 9,10,11,12 )
+
+    assert( m0 == m1 )
+    assert( m0 != m2 )
+  end
+
+end

data/test/test_RVec2.rb

@@ -0,0 +1,187 @@
+require 'minitest/autorun'
+class TC_RVec2 < Minitest::Test
+  def setup
+    @tolerance = RMath3D::TOLERANCE
+    @zero = RVec2.new( 0, 0 )
+    @ax   = RVec2.new( 1, 0 )
+    @ay   = RVec2.new( 0, 1 )
+  end
+
+  def teardown
+  end
+
+  def test_initialize
+    v0 = RVec2.new
+    assert_in_delta( 0, v0.x, @tolerance )
+    assert_in_delta( 0, v0.y, @tolerance )
+
+    v1 = RVec2.new( 1, 2 )
+    assert_in_delta( 1, v1.x, @tolerance )
+    assert_in_delta( 2, v1.y, @tolerance )
+
+    v2 = RVec2.new( v1 )
+    assert_in_delta( 1, v2.x, @tolerance )
+    assert_in_delta( 2, v2.y, @tolerance )
+  end
+
+  def test_to_s
+    assert_respond_to( @zero, :to_s )
+  end
+
+  def test_coerce
+    assert_respond_to( @zero, :coerce )
+  end
+
+  def test_setElements
+    v = RVec2.new
+    v.setElements( 1, 2 )
+    assert_in_delta( 1, v.x, @tolerance )
+    assert_in_delta( 2, v.y, @tolerance )
+  end
+
+  def test_setElement
+    v = RVec2.new
+
+    # x=
+    v.x = 1
+    assert_in_delta( 1, v.x, @tolerance )
+    v[0] = 2
+    assert_in_delta( 2, v.x, @tolerance )
+
+    # y=
+    v.y = 1
+    assert_in_delta( 1, v.y, @tolerance )
+    v[1] = 2
+    assert_in_delta( 2, v.y, @tolerance )
+  end
+
+  def test_getElement
+    assert_in_delta( 1, @ax[0], @tolerance )
+    assert_in_delta( 1, @ay[1], @tolerance )
+
+    assert_in_delta( 1, @ax.x, @tolerance )
+    assert_in_delta( 1, @ay.y, @tolerance )
+  end
+
+  def test_getLength
+    len_sq = 1.0*1.0 + 2.0*2.0 # == 5.0
+    len = Math.sqrt( len_sq ) # == 2.23606797749979
+
+    v = RVec2.new( 1, 2 )
+    assert_in_delta( len_sq, v.getLengthSq, @tolerance )
+    assert_in_delta( len   , v.getLength  , @tolerance )
+  end
+
+  def test_normalize
+    len_sq = 1.0*1.0 + 2.0*2.0 # == 5.0
+    len = Math.sqrt( len_sq ) # == 2.23606797749979
+    x = 1.0 / len
+    y = 2.0 / len
+    v = RVec2.new( 1, 2 )
+    # getNormalized
+    v0 = v.getNormalized
+    assert_in_delta( x, v0.x, @tolerance )
+    assert_in_delta( y, v0.y, @tolerance )
+
+    # normalize!
+    v.normalize!
+    assert_in_delta( x, v.x, @tolerance )
+    assert_in_delta( y, v.y, @tolerance )
+  end
+
+  def test_unary_operators
+    v = RVec2.new( 1, 2 )
+
+    # RVec2#+@
+    vp = +v
+    assert_in_delta( 1, vp.x, @tolerance )
+    assert_in_delta( 2, vp.y, @tolerance )
+
+    # RVec2#-@
+    vm = -v
+    assert_in_delta( -1, vm.x, @tolerance )
+    assert_in_delta( -2, vm.y, @tolerance )
+  end
+
+  def test_plus_operations
+    v0 = RVec2.new( 1, 1 )
+    v1 = RVec2.new( 2, 2 )
+
+    # RVec2#+
+    vr = v0 + v1
+    assert_in_delta( 3, vr.x, @tolerance )
+    assert_in_delta( 3, vr.y, @tolerance )
+
+    # RVec2#add!
+    v0.add!( v1 )
+    assert_in_delta( 3, v0.x, @tolerance )
+    assert_in_delta( 3, v0.y, @tolerance )
+
+    assert_raises( TypeError ) { v0 + 1.0 }
+    assert_raises( TypeError ) { 1.0 + v0 }
+  end
+
+  def test_minus_operations
+    v0 = RVec2.new( 1, 1 )
+    v1 = RVec2.new( 2, 2 )
+
+    # RVec2#-
+    vr = v0 - v1
+    assert_in_delta( -1, vr.x, @tolerance )
+    assert_in_delta( -1, vr.y, @tolerance )
+
+    # RVec2#sub!
+    v0.sub!( v1 )
+    assert_in_delta( -1, v0.x, @tolerance )
+    assert_in_delta( -1, v0.y, @tolerance )
+
+    assert_raises( TypeError ) { v0 - 1.0 }
+    assert_raises( TypeError ) { 1.0 - v0 }
+  end
+
+  def test_mult_operations
+    v0 = RVec2.new( 1, 1 )
+
+    vr = v0 * 2.0
+    assert_in_delta( 2.0, vr.x, @tolerance )
+    assert_in_delta( 2.0, vr.y, @tolerance )
+
+    vr = 2.0 * v0
+    assert_in_delta( 2.0, vr.x, @tolerance )
+    assert_in_delta( 2.0, vr.y, @tolerance )
+
+    v0.mul!( 2.0 )
+    assert_in_delta( 2.0, v0.x, @tolerance )
+    assert_in_delta( 2.0, v0.y, @tolerance )
+
+    assert_raises( TypeError ) { v0 * @zero }
+  end
+
+  def test_equality_operations
+    v = RVec2.new
+    assert( v == @zero )
+    assert( v != @ax )
+  end
+
+  def test_dot
+    v0 = RVec2.new( 1, 1 )
+    v1 = RVec2.new( 2, 2 )
+    assert_in_delta( 4.0, RVec2.dot(v0, v1), @tolerance )
+    assert_in_delta( 0.0, RVec2.dot(@ax, @ay), @tolerance )
+  end
+
+  def test_cross
+    c = RVec2.cross( @ax, @ay )
+    assert_in_delta( c, 1.0, @tolerance )
+  end
+
+  def test_transform
+    m = RMtx2.new.rotation( Math::PI/4.0 )
+    va = RVec2.new( Math.sqrt(2)/2, Math.sqrt(2)/2 )
+
+    vr = @ax.transform( m )
+    assert_kind_of( RVec2, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+  end
+end