rmath3d_plain 1.0.1

data/sample/opengl-bindings/load_matrix.rb

@@ -0,0 +1,174 @@
+# require 'rmath3d/rmath3d_plain'
+require 'rmath3d/rmath3d'
+include RMath3D
+
+require 'glfw'
+require 'opengl'
+
+include GLFW
+include OpenGL
+
+case OpenGL.get_platform
+when :OPENGL_PLATFORM_WINDOWS
+  OpenGL.load_dll('opengl32.dll', 'C:/Windows/System32')
+  GLFW.load_dll('glfw3.dll', '.')
+when :OPENGL_PLATFORM_MACOSX
+  OpenGL.load_dll('libGL.dylib', '/System/Library/Frameworks/OpenGL.framework/Libraries')
+  GLFW.load_dll('libglfw.dylib', '.')
+else
+  raise RuntimeError, "Unsupported platform."
+end
+
+
+def drawCube
+  size = 1.0
+  scale = 0.2
+  delta = 0.1
+
+  v = [
+       [ size,  size,  size * scale + delta ], 
+       [ size,  size, -size * scale + delta ], 
+       [ size, -size, -size * scale ], 
+       [ size, -size,  size * scale ],
+       [-size,  size,  size * scale + delta ],
+       [-size,  size, -size * scale + delta ],
+       [-size, -size, -size * scale ],
+       [-size, -size,  size * scale ]
+      ]
+
+  cube = [
+          [ [1,0,0], v[3],v[2],v[1],v[0] ], # normal, vertices
+          [ [-1,0,0], v[6],v[7],v[4],v[5] ],
+          [ [0,0,-1], v[2],v[6],v[5],v[1] ],
+          [ [0,0,1], v[7],v[3],v[0],v[4] ],
+          [ [0,1,0], v[4],v[0],v[1],v[5] ],
+          [ [0,-1,0], v[6],v[2],v[3],v[7] ]
+         ]
+
+  glBegin(GL_QUADS)
+  cube.each do |side|
+    glNormal3fv(side[0].pack('F*'))
+
+    glTexCoord2f(1,1)
+    glVertex3fv(side[1].pack('F*'))
+    glTexCoord2f(0,1)
+    glVertex3fv(side[2].pack('F*'))
+    glTexCoord2f(0,0)
+    glVertex3fv(side[3].pack('F*'))
+    glTexCoord2f(1,0)
+    glVertex3fv(side[4].pack('F*'))
+  end
+  glEnd()
+end
+
+
+class App
+
+  def draw
+    glPushAttrib( GL_ALL_ATTRIB_BITS )
+
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
+
+    glMatrixMode( GL_MODELVIEW )
+    glLoadMatrixf( @mtxLookAt.to_a.pack('F16') )
+
+    glLightfv( GL_LIGHT0, GL_POSITION, @light_pos.pack('F*') )
+    glLightfv( GL_LIGHT0, GL_DIFFUSE,  @light_diffuse.pack('F*') )
+    glLightfv( GL_LIGHT0, GL_SPECULAR, @light_specular.pack('F*') )
+    glLightfv( GL_LIGHT0, GL_AMBIENT,  @light_ambient.pack('F*') )
+
+    glPushMatrix()
+
+    @mtxTeapotRotY.rotationY( @teapot_rad_y )
+    glMultMatrixf( @mtxTeapotRotY.to_a.pack('F16') )
+    @teapot_rad_y += 2.0*Math::PI/60.0
+
+    glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE,   @teapot_diffuse.pack('F*') )
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR,  @teapot_specular.pack('F*') )
+    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT,   @teapot_ambient.pack('F*') )
+    glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, @teapot_shininess )
+    drawCube() # glutSolidTeapot( 2.0 )
+
+    glPopMatrix()
+
+    glPopAttrib()
+  end
+
+  def key_callback( window_handle, key, scancode, action, mods )
+    case key
+    when GLFW_KEY_ESCAPE, GLFW_KEY_Q
+      glfwSetWindowShouldClose(window_handle, 1)
+    end
+  end
+
+  def size_callback( window_handle, w, h )
+    glViewport( 0, 0, w, h )
+    glMatrixMode( GL_PROJECTION )
+    @mtxProj.perspectiveFovRH( 30.0*Math::PI/180.0, w.to_f/h.to_f, 0.1, 1000.0 )
+    glLoadMatrixf( @mtxProj.to_a.pack('F16') )
+
+    @window_width  = w
+    @window_height = h
+  end
+
+  def initialize
+    @window_width  = 320
+    @window_height = 240
+
+    @eye = RVec3.new(0.0, 15.0, 15.0)
+    @at  = RVec3.new(0.0,  0.0,  0.0)
+    @up  = RVec3.new(0.0,  1.0,  0.0)
+    @mtxLookAt = RMtx4.new.lookAtRH( @eye, @at, @up )
+    @mtxProj = RMtx4.new.perspectiveFovRH( 30.0*Math::PI/180.0, @window_width.to_f/@window_height.to_f, 0.1, 1000.0 )
+
+    @light_pos = [2.5,0,5,1]
+    @light_diffuse  = [1,1,1,1]
+    @light_specular = [1,1,1,1]
+    @light_ambient  = [1,1,1,1]
+
+    @teapot_diffuse = [0.8,1,0,1]
+    @teapot_specular = [1,1,1,1]
+    @teapot_ambient = [0.2,0.2,0,1]
+    @teapot_shininess = 32.0
+
+    @teapot_rad_y = 0.0
+    @mtxTeapotRotY = RMtx4.new.rotationY( @teapot_rad_y )
+
+    glfwInit()
+
+    @window_handle = glfwCreateWindow( @window_width, @window_height, self.class.to_s, nil, nil )
+    glfwMakeContextCurrent( @window_handle )
+    # glfwSetKeyCallback( $window_handle, $key_callback )
+    glfwSetKeyCallback( @window_handle, GLFW::create_callback(:GLFWkeyfun, method(:key_callback).to_proc) )
+    # glfwSetWindowSizeCallback( $window_handle, $size_callback )
+    glfwSetWindowSizeCallback( @window_handle, GLFW::create_callback(:GLFWwindowsizefun, method(:size_callback).to_proc ) )
+
+    width_ptr = '    '
+    height_ptr = '    '
+    glfwGetFramebufferSize(@window_handle, width_ptr, height_ptr)
+    width = width_ptr.unpack('L')[0]
+    height = height_ptr.unpack('L')[0]
+    size_callback( @window_handle, width, height )
+
+    # Common rendering state : reused by PushAttrib/PopAttrib
+    glEnable( GL_DEPTH_TEST )
+    glEnable( GL_LIGHTING )
+    glEnable( GL_LIGHT0 )
+    glEnable( GL_NORMALIZE )
+    glClearColor( 0.0, 0.0, 0.0, 1 )
+  end
+
+  def start
+    while glfwWindowShouldClose( @window_handle ) == 0
+      draw()
+      glfwSwapBuffers( @window_handle )
+      glfwPollEvents()
+    end
+
+    glfwDestroyWindow( @window_handle )
+    glfwTerminate()
+  end
+
+end
+
+App.new.start

data/sample/opengl2/load_matrix.rb

@@ -0,0 +1,118 @@
+# require 'rmath3d/rmath3d_plain'
+require 'rmath3d/rmath3d'
+include RMath3D
+
+require 'opengl'
+
+class App
+
+  def draw
+    glPushAttrib( GL_ALL_ATTRIB_BITS )
+
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
+
+    glMatrixMode( GL_MODELVIEW )
+    glLoadMatrix( @mtxLookAt )
+
+    glLightfv( GL_LIGHT0, GL_POSITION, @light_pos )
+    glLightfv( GL_LIGHT0, GL_DIFFUSE,  @light_diffuse )
+    glLightfv( GL_LIGHT0, GL_SPECULAR, @light_specular )
+    glLightfv( GL_LIGHT0, GL_AMBIENT,  @light_ambient )
+
+    glPushMatrix()
+
+    @mtxTeapotRotY.rotationY( @teapot_rad_y )
+    glMultMatrix( @mtxTeapotRotY )
+    @teapot_rad_y += 2.0*Math::PI/60.0
+
+    glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE,   @teapot_diffuse )
+    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR,  @teapot_specular )
+    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT,   @teapot_ambient )
+    glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, @teapot_shininess )
+    glutSolidTeapot( 2.0 )
+
+    glPopMatrix()
+
+    glPopAttrib()
+
+    glutSwapBuffers()
+  end
+
+
+  def reshape( width, height )
+    glViewport( 0, 0, width, height )
+    glMatrixMode( GL_PROJECTION )
+    @mtxProj.perspectiveFovRH( 30.0*Math::PI/180.0, width.to_f/height.to_f, 0.1, 1000.0 )
+    glLoadMatrix( @mtxProj )
+
+    @window_width  = width
+    @window_height = height
+
+    glutPostRedisplay()
+  end
+
+
+  def timer( value )
+    glutPostRedisplay()
+    glutTimerFunc( 1000/60, method(:timer).to_proc, 0 )
+  end
+
+
+  def key( key, x, y )
+    case key
+    when ?\e, ?q
+      exit
+    end
+  end
+
+
+  def initialize
+    @window_width  = 320
+    @window_height = 240
+
+    @eye = RVec3.new(0.0, 15.0, 15.0)
+    @at  = RVec3.new(0.0,  0.0,  0.0)
+    @up  = RVec3.new(0.0,  1.0,  0.0)
+    @mtxLookAt = RMtx4.new.lookAtRH( @eye, @at, @up )
+    @mtxProj = RMtx4.new.perspectiveFovRH( 30.0*Math::PI/180.0, @window_width.to_f/@window_height.to_f, 0.1, 1000.0 )
+
+    @light_pos = [2.5,0,5,1]
+    @light_diffuse  = [1,1,1,1]
+    @light_specular = [1,1,1,1]
+    @light_ambient  = [1,1,1,1]
+
+    @teapot_diffuse = [0.8,1,0,1]
+    @teapot_specular = [1,1,1,1]
+    @teapot_ambient = [0.2,0.2,0,1]
+    @teapot_shininess = 32.0
+
+    @teapot_rad_y = 0.0
+    @mtxTeapotRotY = RMtx4.new.rotationY( @teapot_rad_y )
+
+    glutInit()
+
+    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE )
+    glutInitWindowPosition( 0, 0 )
+    glutInitWindowSize( @window_width, @window_height )
+    glutCreateWindow( self.class.to_s )
+
+    glutDisplayFunc( method(:draw).to_proc )
+    glutReshapeFunc( method(:reshape).to_proc )
+    glutKeyboardFunc( method(:key).to_proc )
+    glutTimerFunc( 0, method(:timer).to_proc, 0 )
+
+    # Common rendering state : reused by PushAttrib/PopAttrib
+    glEnable( GL_DEPTH_TEST )
+    glEnable( GL_LIGHTING )
+    glEnable( GL_LIGHT0 )
+    glEnable( GL_NORMALIZE )
+    glClearColor( 0.0, 0.0, 0.0, 1 )
+  end
+
+  def start
+    glutMainLoop()
+  end
+
+end
+
+App.new.start

data/sample/simple/transform.rb

@@ -0,0 +1,11 @@
+# require 'rmath3d/rmath3d_plain'
+require 'rmath3d/rmath3d'
+include RMath3D
+
+99999.times do
+  v = RVec3.new( rand(), rand(), rand() )
+  m = RMtx3.new.rotationX( Math::PI/4.0 )
+  p v
+  v2 = v.transformRS( m )
+  p v2
+end

data/test/test.rb

@@ -0,0 +1,18 @@
+begin 
+  require 'rmath3d/rmath3d'
+rescue LoadError
+  require 'rmath3d/rmath3d_plain'
+end
+# require_relative '../ext/rmath3d/rmath3d'
+# require_relative '../lib/rmath3d/rmath3d_plain'
+include RMath3D
+
+# Test::Unit
+require 'minitest/autorun'
+
+# Test cases
+require_relative 'test_RVec3.rb'
+require_relative 'test_RVec4.rb'
+require_relative 'test_RQuat.rb'
+require_relative 'test_RMtx3.rb'
+require_relative 'test_RMtx4.rb'

data/test/test_RMtx3.rb

@@ -0,0 +1,517 @@
+class TC_RMtx3 < Minitest::Test
+
+  def setup
+    @tolerance = RMath3D::TOLERANCE
+    @mZero = RMtx3.new.setZero
+    @mIdentity = RMtx3.new.setIdentity
+  end
+
+  def teardown
+  end
+
+  def test_RMtx_initialize
+    m0 = RMtx3.new
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( 0.0, m0.getElement(r,c) )
+      end
+    end
+
+    m1 = RMtx3.new( 0, 1, 2,
+                    3, 4, 5,
+                    6, 7, 8 )
+    assert_equal( 0, m1.getElement(0,0) )
+    assert_equal( 1, m1.getElement(0,1) )
+    assert_equal( 2, m1.getElement(0,2) )
+    assert_equal( 3, m1.getElement(1,0) )
+    assert_equal( 4, m1.getElement(1,1) )
+    assert_equal( 5, m1.getElement(1,2) )
+    assert_equal( 6, m1.getElement(2,0) )
+    assert_equal( 7, m1.getElement(2,1) )
+    assert_equal( 8, m1.getElement(2,2) )
+
+    m2 = RMtx3.new( m1 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( 3*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, 4, 5, 6, 7, 8 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( 3*r+c, @mZero.getElement(r,c) )
+      end
+    end
+  end
+
+  def test_setElement
+    for r in 0...3 do
+      for c in 0...3 do
+        @mZero.setElement( r, c, 3*r+c )
+      end
+    end
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( 3*r+c, @mZero.getElement(r,c) )
+      end
+    end
+
+    for r in 0...3 do
+      for c in 0...3 do
+        @mZero[r, c] = 3*c+r
+      end
+    end
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( 3*c+r, @mZero[r,c] )
+      end
+    end
+  end
+
+  def test_getElement
+    assert_respond_to( @mIdentity, :getElement )
+    for r in 0...3 do
+      for c in 0...3 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...3 do
+      for c in 0...3 do
+        e = @mIdentity[ r, c ]
+        if ( r == c )
+          assert_equal( 1.0, e )
+        else
+          assert_equal( 0.0, e )
+        end
+      end
+    end
+
+    mtx = RMtx3.new(1,2,3,
+                    4,5,6,
+                    7,8,9)
+    assert_equal( mtx.e00, 1 )
+    assert_equal( mtx.e01, 2 )
+    assert_equal( mtx.e02, 3 )
+    assert_equal( mtx.e10, 4 )
+    assert_equal( mtx.e11, 5 )
+    assert_equal( mtx.e12, 6 )
+    assert_equal( mtx.e20, 7 )
+    assert_equal( mtx.e21, 8 )
+    assert_equal( mtx.e22, 9 )
+  end
+
+  def test_getRowColumn
+    mtx = RMtx3.new(1,2,3,
+                    4,5,6,
+                    7,8,9)
+
+    v = mtx.getRow(0)
+    assert_equal( v.x, 1 )
+    assert_equal( v.y, 2 )
+    assert_equal( v.z, 3 )
+
+    v = mtx.getRow(1)
+    assert_equal( v.x, 4 )
+    assert_equal( v.y, 5 )
+    assert_equal( v.z, 6 )
+
+    v = mtx.getRow(2)
+    assert_equal( v.x, 7 )
+    assert_equal( v.y, 8 )
+    assert_equal( v.z, 9 )
+
+    v = mtx.getColumn(0)
+    assert_equal( v.x, 1 )
+    assert_equal( v.y, 4 )
+    assert_equal( v.z, 7 )
+
+    v = mtx.getColumn(1)
+    assert_equal( v.x, 2 )
+    assert_equal( v.y, 5 )
+    assert_equal( v.z, 8 )
+
+    v = mtx.getColumn(2)
+    assert_equal( v.x, 3 )
+    assert_equal( v.y, 6 )
+    assert_equal( v.z, 9 )
+  end
+
+  def test_setRowColumn
+    mtx = RMtx3.new
+
+    vr = [RVec3.new(1,2,3),RVec3.new(4,5,6),RVec3.new(7,8,9)]
+    mtx.setRow(vr[0],0)
+    mtx.setRow(vr[1],1)
+    mtx.setRow(vr[2],2)
+    assert_equal( mtx.e00, 1 )
+    assert_equal( mtx.e01, 2 )
+    assert_equal( mtx.e02, 3 )
+    assert_equal( mtx.e10, 4 )
+    assert_equal( mtx.e11, 5 )
+    assert_equal( mtx.e12, 6 )
+    assert_equal( mtx.e20, 7 )
+    assert_equal( mtx.e21, 8 )
+    assert_equal( mtx.e22, 9 )
+
+    vc = [RVec3.new(1,2,3),RVec3.new(4,5,6),RVec3.new(7,8,9)]
+    mtx.setColumn(vc[0],0)
+    mtx.setColumn(vc[1],1)
+    mtx.setColumn(vc[2],2)
+    assert_equal( mtx.e00, 1 )
+    assert_equal( mtx.e01, 4 )
+    assert_equal( mtx.e02, 7 )
+    assert_equal( mtx.e10, 2 )
+    assert_equal( mtx.e11, 5 )
+    assert_equal( mtx.e12, 8 )
+    assert_equal( mtx.e20, 3 )
+    assert_equal( mtx.e21, 6 )
+    assert_equal( mtx.e22, 9 )
+  end
+
+  def test_setZero
+    m = RMtx3.new( 1, 2, 3, 4, 5, 6, 7, 8, 9 )
+    m.setZero
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( 0.0, m.getElement( r, c ) )
+      end
+    end
+  end
+
+  def test_setIdentity
+    m = RMtx3.new( 1, 2, 3, 4, 5, 6, 7, 8, 9 )
+    m.setIdentity
+    for r in 0...3 do
+      for c in 0...3 do
+        e = @mIdentity.getElement( r, c )
+        if ( r == c )
+          assert_equal( 1.0, e )
+        else
+          assert_equal( 0.0, e )
+        end
+      end
+    end
+  end
+
+  # http://en.wikipedia.org/wiki/Determinant
+  def test_getDeterminant
+    m0 = RMtx3.new( -2, 2, -3,
+                    -1, 1,  3,
+                     2, 0, -1 )
+    assert_equal( 18.0, m0.getDeterminant )
+
+    m1 = RMtx3.new( 0, 2, -3,
+                    0, 1,  3,
+                    2, 0, -1 )
+    assert_equal( 18.0, m1.getDeterminant )
+
+    m2 = RMtx3.new( Math::sqrt(2)/2, -Math::sqrt(2)/2, 0.0,
+                    Math::sqrt(2)/2,  Math::sqrt(2)/2, 0.0,
+                    0.0,              0.0,             1.0 )
+    assert_in_delta( 1.0, m2.getDeterminant, @tolerance )
+  end
+
+  def test_transpose
+    m0 = RMtx3.new( -2, 2, -3,
+                    -1, 1,  3,
+                     2, 0, -1 )
+    # RMtx3#getTransposed
+    m1 = m0.getTransposed
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( m0.getElement(c,r), m1.getElement(r,c) )
+      end
+    end
+
+    # RMtx3#transpose!
+    m0.transpose!
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_equal( m0.getElement(r,c), m1.getElement(r,c) )
+      end
+    end
+  end
+
+  # http://people.hofstra.edu/Stefan_waner/RealWorld/tutorialsf1/frames3_3.html
+  # http://numericalmethods.eng.usf.edu/mws/gen/04sle/mws_gen_sle_bck_system.pdf
+  def test_inverse
+    # RMtx3#getInverse
+    m0 = RMtx3.new( 1, 0, -2,
+                    4, 1,  0,
+                    1, 1,  7 )
+
+    m0inv = RMtx3.new(  7, -2,  2,
+                      -28,  9, -8,
+                        3, -1,  1 )
+    m1 =  m0.getInverse
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0inv.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx3#invert!
+    m2 = RMtx3.new( 25,  5, 1,
+                    64,  8, 1,
+                   144, 12, 1 )
+
+    m2inv = RMtx3.new(  -4,   7,  -3,
+                        80,-119,  39,
+                      -384, 420,-120 )
+    m2inv *= -1.0 / 84.0
+
+    m2.invert!
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2inv.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_rotationX
+    m0 = RMtx3.new( 1.0, 0.0,              0.0,
+                    0.0, Math::sqrt(2)/2, -Math::sqrt(2)/2,
+                    0.0, Math::sqrt(2)/2,  Math::sqrt(2)/2 )
+    m1 = RMtx3.new.rotationX( Math::PI/4.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+
+    m2 = RMtx3.new( 1.0, 0.0,              0.0,
+                    0.0, 0.5,             -Math::sqrt(3)/2,
+                    0.0, Math::sqrt(3)/2,  0.5 );
+    m3 = RMtx3.new.rotationX( Math::PI/3.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_rotationY
+    m0 = RMtx3.new(  Math::sqrt(2)/2, 0.0, Math::sqrt(2)/2,
+                     0.0,             1.0, 0.0,
+                    -Math::sqrt(2)/2, 0.0, Math::sqrt(2)/2 )
+    m1 = RMtx3.new.rotationY( Math::PI/4.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+    m2 = RMtx3.new(  0.5,             0.0, Math::sqrt(3)/2,
+                     0.0,             1.0, 0.0,
+                    -Math::sqrt(3)/2, 0.0, 0.5 )
+    m3 = RMtx3.new.rotationY( Math::PI/3.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_rotationZ
+    m0 = RMtx3.new(  Math::sqrt(2)/2, -Math::sqrt(2)/2, 0.0,
+                     Math::sqrt(2)/2,  Math::sqrt(2)/2, 0.0,
+                     0.0,              0.0,             1.0 )
+    m1 = RMtx3.new.rotationZ( Math::PI/4.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+    m2 = RMtx3.new(  0.5,             -Math::sqrt(3)/2, 0.0,
+                     Math::sqrt(3)/2,  0.5,             0.0,
+                     0.0,              0.0,             1.0 )
+    m3 = RMtx3.new.rotationZ( Math::PI/3.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_rotationAxis
+    m0 = RMtx3.new(  0.5,             -Math::sqrt(3)/2, 0.0,
+                     Math::sqrt(3)/2,  0.5,             0.0,
+                     0.0,              0.0,             1.0 )
+    m1 = RMtx3.new.rotationAxis( RVec3.new(0,0,1), Math::PI/3.0 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_rotationQuaternion
+    q = RQuat.new.rotationAxis( RVec3.new(0,0,1), Math::PI/3.0 )
+    m0 = RMtx3.new(  0.5,             -Math::sqrt(3)/2, 0.0,
+                     Math::sqrt(3)/2,  0.5,             0.0,
+                     0.0,              0.0,             1.0 )
+    m1 = RMtx3.new.rotationQuaternion( q )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_scaling
+    m0 = RMtx3.new( 10.0,  0.0,  0.0,
+                     0.0, 20.0,  0.0,
+                     0.0,  0.0, 30.0 )
+    m1 = RMtx3.new.scaling( 10.0, 20.0, 30.0 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_unary_operators
+    # RMtx3#+@
+    m0 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m1 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m2 = +m0
+
+    assert_same( m0, m2 )
+    assert( m1 == m2 )
+
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( 3*r+c, m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx3#-@
+    m2 = -m0
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0.getElement(r,c), -m2.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_binary_plus
+    m0 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m1 = RMtx3.new( 9,10,11,12,13,14,15,16,17 )
+    m2 = RMtx3.new( 9,11,13,15,17,19,21,23,25 )
+
+    # RMtx3#+
+    m3 = m0 + m1
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx3#add!
+    m0.add!( m1 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m0.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_binary_minus
+    m0 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m1 = RMtx3.new( 9,10,11,12,13,14,15,16,17 )
+    m2 = RMtx3.new(-9,-9,-9,-9,-9,-9,-9,-9,-9 )
+
+    # RMtx3#-
+    m3 = m0 - m1
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx3#sub!
+    m0.sub!( m1 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m2.getElement(r,c), m0.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_binary_mult
+    m0 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m1 = RMtx3.new( 9,10,11,12,13,14,15,16,17 )
+    m0x1 = RMtx3.new( 42, 45, 48, 150, 162, 174, 258, 279, 300 )
+    m1x0 = RMtx3.new( 96, 126, 156, 123, 162, 201, 150, 198, 246 )
+
+    # RMtx3#*
+    m2 = m0 * m1
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0x1.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    m2 = m1 * m0
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m1x0.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx3#mul!
+    m2 = RMtx3.new( m0 )
+    m2.mul!( m1 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m0x1.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+
+    m2 = RMtx3.new( m1 )
+    m2.mul!( m0 )
+    for r in 0...3 do
+      for c in 0...3 do
+        assert_in_delta( m1x0.getElement(r,c), m2.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
+  def test_equality_operators
+    m0 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m1 = RMtx3.new( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
+    m2 = RMtx3.new( 9,10,11,12,13,14,15,16,17 )
+
+    assert( m0 == m1 )
+    assert( m0 != m2 )
+  end
+
+end