mageo 0.0.1 → 0.0.2

data/test/test_cylinder.rb

@@ -1,19 +1,20 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-require "test/unit"
 require "helper"
-require "mageo/cylinder.rb"
-require "mageo/vector3d.rb"
+#require "test/unit"
+#require 'mageo.rb'
+#require "mageo/cylinder.rb"
+#require "mageo/vector3d.rb"
 
 class TC_Cylinder < Test::Unit::TestCase
   def setup
-    @c00 = Cylinder.new([[0.0, 1.0, 2.0], [1.0, 2.0, 3.0]], 3.0)
+    @c00 = Mageo::Cylinder.new([[0.0, 1.0, 2.0], [1.0, 2.0, 3.0]], 3.0)
   end
 
   def test_initialize
-    assert_equal(Vector3D[0.0, 1.0, 2.0], @c00.positions[0])
-    assert_equal(Vector3D[1.0, 2.0, 3.0], @c00.positions[1])
+    assert_equal(Mageo::Vector3D[0.0, 1.0, 2.0], @c00.positions[0])
+    assert_equal(Mageo::Vector3D[1.0, 2.0, 3.0], @c00.positions[1])
     assert_equal(3.0, @c00.radius)
   end
 end

data/test/test_octahedron.rb

@@ -1,34 +1,32 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-require "test/unit"
 require "helper"
-require "mageo/octahedron.rb"
-gem "builtinextension"
-  require "array_include_eql.rb"
+#gem "builtinextension"
+#require "array/includeeql.rb"
 
-class Octahedron
+class Mageo::Octahedron
   public :center
 end
 
 class TC_Octahedron < Test::Unit::TestCase
   $tolerance = 10**(-10)
 
-  V_X_PLUS  = Vector3D[  1,  0,  0 ]
-  V_Y_PLUS  = Vector3D[  0,  1,  0 ]
-  V_Z_PLUS  = Vector3D[  0,  0,  1 ]
+  V_X_PLUS  = Mageo::Vector3D[  1,  0,  0 ]
+  V_Y_PLUS  = Mageo::Vector3D[  0,  1,  0 ]
+  V_Z_PLUS  = Mageo::Vector3D[  0,  0,  1 ]
 
-  V_X_MINUS = Vector3D[ -1,  0,  0 ]
-  V_Y_MINUS = Vector3D[  0, -1,  0 ]
-  V_Z_MINUS = Vector3D[  0,  0, -1 ]
+  V_X_MINUS = Mageo::Vector3D[ -1,  0,  0 ]
+  V_Y_MINUS = Mageo::Vector3D[  0, -1,  0 ]
+  V_Z_MINUS = Mageo::Vector3D[  0,  0, -1 ]
 
   def setup
-    @o00 = Octahedron.new(
+    @o00 = Mageo::Octahedron.new(
       [ [V_X_MINUS, V_X_PLUS ],
         [V_Y_MINUS, V_Y_PLUS ],
         [V_Z_MINUS, V_Z_PLUS ] ]
     )
-    @o01 = Octahedron.new(
+    @o01 = Mageo::Octahedron.new(
       [ [ [ -0.5,  0.5,  0.5 ], [  1.5,  0.5,  0.5 ] ],
         [ [  0.5, -0.5,  0.5 ], [  0.5,  1.5,  0.5 ] ],
         [ [  0.5,  0.5, -0.5 ], [  0.5,  0.5,  1.5 ] ] ]
@@ -36,30 +34,30 @@ class TC_Octahedron < Test::Unit::TestCase
   end
 
   def test_initialize
-    assert_raise( ArgumentError ){ Octahedron.new }
-    assert_raise( ArgumentError ){ Octahedron.new() }
-    assert_raise( Octahedron::InitializeError ){ Octahedron.new( nil ) }
-    assert_raise( Octahedron::InitializeError ){ Octahedron.new( [] ) }
-    assert_raise( Octahedron::InitializeError ){ Octahedron.new( [ 0, 1, 2 ] ) }
-    assert_raise( Octahedron::InitializeError ){ Octahedron.new( [ [], [], [] ] ) }
-    assert_raise( Octahedron::InitializeError ){
-      Octahedron.new( 
+    assert_raise( ArgumentError ){ Mageo::Octahedron.new }
+    assert_raise( ArgumentError ){ Mageo::Octahedron.new() }
+    assert_raise( Mageo::Octahedron::InitializeError ){ Mageo::Octahedron.new( nil ) }
+    assert_raise( Mageo::Octahedron::InitializeError ){ Mageo::Octahedron.new( [] ) }
+    assert_raise( Mageo::Octahedron::InitializeError ){ Mageo::Octahedron.new( [ 0, 1, 2 ] ) }
+    assert_raise( Mageo::Octahedron::InitializeError ){ Mageo::Octahedron.new( [ [], [], [] ] ) }
+    assert_raise( Mageo::Octahedron::InitializeError ){
+      Mageo::Octahedron.new( 
         [ [ V_X_MINUS, V_X_PLUS ],
           [ V_Y_MINUS, V_Y_PLUS ],
           [ V_Z_MINUS, [  0,  0 ] ]
         ]
       )
     }
-    assert_raise( Octahedron::InitializeError ){
-      Octahedron.new( 
+    assert_raise( Mageo::Octahedron::InitializeError ){
+      Mageo::Octahedron.new( 
         [ [ V_X_MINUS, V_X_PLUS],
           [ V_Y_MINUS, [  0,  1,  0, 2 ] ],
           [ V_Z_MINUS, V_Z_PLUS ]
         ]
       )
     }
-    assert_raise( Octahedron::InitializeError ){
-      Octahedron.new( 
+    assert_raise( Mageo::Octahedron::InitializeError ){
+      Mageo::Octahedron.new( 
         [ [ V_X_MINUS, V_X_PLUS ],
           [ V_Y_MINUS, V_Y_PLUS ],
           [ V_Z_MINUS, V_Z_PLUS ],
@@ -68,19 +66,19 @@ class TC_Octahedron < Test::Unit::TestCase
       )
     }
 
-    assert_raise( Octahedron::InitializeError ){
-      Octahedron.new(
-        [ [ Vector3DInternal[ -0.5,  0.5,  0.5 ], Vector3DInternal[  1.5,  0.5,  0.5 ] ],
-          [ Vector3DInternal[  0.5, -0.5,  0.5 ], Vector3DInternal[  0.5,  1.5,  0.5 ] ],
-          [ Vector3DInternal[  0.5,  0.5, -0.5 ], Vector3DInternal[  0.5,  0.5,  1.5 ] ] ]
+    assert_raise( Mageo::Octahedron::InitializeError ){
+      Mageo::Octahedron.new(
+        [ [ Mageo::Vector3DInternal[ -0.5,  0.5,  0.5 ], Mageo::Vector3DInternal[  1.5,  0.5,  0.5 ] ],
+          [ Mageo::Vector3DInternal[  0.5, -0.5,  0.5 ], Mageo::Vector3DInternal[  0.5,  1.5,  0.5 ] ],
+          [ Mageo::Vector3DInternal[  0.5,  0.5, -0.5 ], Mageo::Vector3DInternal[  0.5,  0.5,  1.5 ] ] ]
       )
     }
 
     assert_nothing_raised{
-      Octahedron.new(
-        [ [ Vector3D[ -0.5,  0.5,  0.5 ], Vector3D[  1.5,  0.5,  0.5 ] ],
-          [ Vector3D[  0.5, -0.5,  0.5 ], Vector3D[  0.5,  1.5,  0.5 ] ],
-          [ Vector3D[  0.5,  0.5, -0.5 ], Vector3D[  0.5,  0.5,  1.5 ] ] ]
+      Mageo::Octahedron.new(
+        [ [ Mageo::Vector3D[ -0.5,  0.5,  0.5 ], Mageo::Vector3D[  1.5,  0.5,  0.5 ] ],
+          [ Mageo::Vector3D[  0.5, -0.5,  0.5 ], Mageo::Vector3D[  0.5,  1.5,  0.5 ] ],
+          [ Mageo::Vector3D[  0.5,  0.5, -0.5 ], Mageo::Vector3D[  0.5,  0.5,  1.5 ] ] ]
       )
     }
   end
@@ -94,6 +92,7 @@ class TC_Octahedron < Test::Unit::TestCase
   def test_include?
     assert_equal( true , @o00.include?( [0.0, 0.2, 0.4], $tolerance ) )
     assert_equal( true , @o00.include?( [1.0, 0.0, 0.0], $tolerance ) ) #境界上
+    assert_equal( true , @o00.include?( [1.0, 0.0, 0.0] ) ) #境界上, no tolerance
     assert_equal( false, @o00.include?( [2.0, 0.2, 0.4], $tolerance ) )
   end
 
@@ -114,42 +113,42 @@ class TC_Octahedron < Test::Unit::TestCase
   def test_vertices
     t = @o00.vertices
     assert_equal(6, t.size)
-    assert_equal(true , t.include_eql?(V_X_MINUS))
-    assert_equal(true , t.include_eql?(V_X_PLUS ))
-    assert_equal(true , t.include_eql?(V_Y_MINUS))
-    assert_equal(true , t.include_eql?(V_Y_PLUS ))
-    assert_equal(true , t.include_eql?(V_Z_MINUS))
-    assert_equal(true , t.include_eql?(V_Z_PLUS ))
+    assert_equal(V_X_MINUS, t[0])
+    assert_equal(V_X_PLUS , t[1])
+    assert_equal(V_Y_MINUS, t[2])
+    assert_equal(V_Y_PLUS , t[3])
+    assert_equal(V_Z_MINUS, t[4])
+    assert_equal(V_Z_PLUS , t[5])
   end
 
   def test_triangles
     t = @o00.triangles
     assert_equal(8, t.size)
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_PLUS, V_Y_PLUS, V_Z_PLUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_PLUS, V_Y_PLUS, V_Z_MINUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_PLUS, V_Y_MINUS, V_Z_PLUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_PLUS, V_Y_MINUS, V_Z_MINUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_MINUS, V_Y_PLUS, V_Z_PLUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_MINUS, V_Y_PLUS, V_Z_MINUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_MINUS, V_Y_MINUS, V_Z_PLUS])))
-    assert_equal(true, t.include_eql?(Triangle.new([V_X_MINUS, V_Y_MINUS, V_Z_MINUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_PLUS, V_Y_PLUS, V_Z_PLUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_PLUS, V_Y_PLUS, V_Z_MINUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_PLUS, V_Y_MINUS, V_Z_PLUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_PLUS, V_Y_MINUS, V_Z_MINUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_MINUS, V_Y_PLUS, V_Z_PLUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_MINUS, V_Y_PLUS, V_Z_MINUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_MINUS, V_Y_MINUS, V_Z_PLUS])))
+    assert_equal(true, t.include_eql?(Mageo::Triangle.new([V_X_MINUS, V_Y_MINUS, V_Z_MINUS])))
   end
 
   def test_edges
     t = @o00.edges
     assert_equal(12, t.size)
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_PLUS , V_Y_PLUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_PLUS , V_Y_MINUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_PLUS , V_Z_PLUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_PLUS , V_Z_MINUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_MINUS, V_Y_PLUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_MINUS, V_Y_MINUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_MINUS, V_Z_PLUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_X_MINUS, V_Z_MINUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_Y_PLUS , V_Z_PLUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_Y_PLUS , V_Z_MINUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_Y_MINUS, V_Z_PLUS))))
-    assert_equal(true, (t.include_eql?(Segment.new(V_Y_MINUS, V_Z_MINUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_PLUS , V_Y_PLUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_PLUS , V_Y_MINUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_PLUS , V_Z_PLUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_PLUS , V_Z_MINUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_MINUS, V_Y_PLUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_MINUS, V_Y_MINUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_MINUS, V_Z_PLUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_X_MINUS, V_Z_MINUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_Y_PLUS , V_Z_PLUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_Y_PLUS , V_Z_MINUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_Y_MINUS, V_Z_PLUS))))
+    assert_equal(true, (t.include_eql?(Mageo::Segment.new(V_Y_MINUS, V_Z_MINUS))))
   end
 end
 

data/test/test_polar2d.rb

@@ -1,10 +1,12 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-require "test/unit"
 require "helper"
-require "mageo/vector.rb"
-require "mageo/polar2d.rb"
+#require "test/unit"
+#require "helper"
+#require 'mageo.rb'
+#require "mageo/vector.rb"
+#require "mageo/polar2d.rb"
 
 
 class TC_Vector < Test::Unit::TestCase
@@ -21,7 +23,7 @@ class TC_Vector < Test::Unit::TestCase
   def test_to_p2d
     assert_raise( Vector::SizeError ){ @v0.to_p2d }
     assert_raise( Vector::SizeError ){ @v2.to_p2d }
-    assert_equal( Polar2D        , @v1.to_p2d.class )
+    assert_equal( Mageo::Polar2D        , @v1.to_p2d.class )
     assert_equal( Math::sqrt(2.0), @v1.to_p2d.r )
     assert_equal( 0.25*PI        , @v1.to_p2d.theta )
 
@@ -44,10 +46,10 @@ class TC_Polar2D < Test::Unit::TestCase
   include Math
 
   def setup
-    @p2d00 = Polar2D.new( 0.0, 0.0*PI)
-    @p2d01 = Polar2D.new( 0.0, 2.0*PI)
-    @p2d02 = Polar2D.new( 2.0, 0.0*PI)
-    @p2d03 = Polar2D.new( 2.0, 0.1*PI)
+    @p2d00 = Mageo::Polar2D.new( 0.0, 0.0*PI)
+    @p2d01 = Mageo::Polar2D.new( 0.0, 2.0*PI)
+    @p2d02 = Mageo::Polar2D.new( 2.0, 0.0*PI)
+    @p2d03 = Mageo::Polar2D.new( 2.0, 0.1*PI)
   end
 
   def test_to_v
@@ -58,7 +60,7 @@ class TC_Polar2D < Test::Unit::TestCase
   end
 
   def test_rotate
-    assert_equal( Polar2D, @p2d00.rotate( 0.2 * PI ).class )
+    assert_equal( Mageo::Polar2D, @p2d00.rotate( 0.2 * PI ).class )
 
     assert_in_delta( 0.0   , @p2d00.rotate( 0.2 * PI ).r    , $tolerance )
     assert_in_delta( 0.2*PI, @p2d00.rotate( 0.2 * PI ).theta, $tolerance )
@@ -93,60 +95,60 @@ class TC_Polar2D < Test::Unit::TestCase
   end
 
   def test_minimize_theta!
-    p2pA = Polar2D.new( 2.0, -2.5*PI )
+    p2pA = Mageo::Polar2D.new( 2.0, -2.5*PI )
     p2pA.minimize_theta!
     assert_in_delta( 1.5*PI, p2pA.theta, $tolerance )
 
-    p2pB = Polar2D.new( 2.0, -0.5*PI )
+    p2pB = Mageo::Polar2D.new( 2.0, -0.5*PI )
     p2pB.minimize_theta!
     assert_in_delta( 1.5*PI, p2pB.theta, $tolerance )
 
-    p2pC = Polar2D.new( 2.0,  1.5*PI )
+    p2pC = Mageo::Polar2D.new( 2.0,  1.5*PI )
     p2pC.minimize_theta!
     assert_in_delta( 1.5*PI, p2pC.theta, $tolerance )
 
-    p2pD = Polar2D.new( 2.0,  3.5*PI )
+    p2pD = Mageo::Polar2D.new( 2.0,  3.5*PI )
     p2pD.minimize_theta!
     assert_in_delta( 1.5*PI, p2pD.theta, $tolerance )
 
-    p2pE = Polar2D.new( 2.0,  5.5*PI )
+    p2pE = Mageo::Polar2D.new( 2.0,  5.5*PI )
     p2pE.minimize_theta!
     assert_in_delta( 1.5*PI, p2pE.theta, $tolerance )
 
-    p2pF = Polar2D.new( 2.0,  4.5*PI )
+    p2pF = Mageo::Polar2D.new( 2.0,  4.5*PI )
     p2pF.minimize_theta!
     assert_in_delta( 0.5*PI, p2pF.theta, $tolerance )
 
   end
 
   def test_minimize_theta
-    p2pA = Polar2D.new( 2.0, -2.5*PI ).minimize_theta
+    p2pA = Mageo::Polar2D.new( 2.0, -2.5*PI ).minimize_theta
     assert_in_delta( 1.5*PI, p2pA.theta, $tolerance )
 
-    p2pB = Polar2D.new( 2.0, -0.5*PI ).minimize_theta
+    p2pB = Mageo::Polar2D.new( 2.0, -0.5*PI ).minimize_theta
     assert_in_delta( 1.5*PI, p2pB.theta, $tolerance )
 
-    p2pC = Polar2D.new( 2.0,  1.5*PI ).minimize_theta
+    p2pC = Mageo::Polar2D.new( 2.0,  1.5*PI ).minimize_theta
     assert_in_delta( 1.5*PI, p2pC.theta, $tolerance )
 
-    p2pD = Polar2D.new( 2.0,  3.5*PI ).minimize_theta
+    p2pD = Mageo::Polar2D.new( 2.0,  3.5*PI ).minimize_theta
     assert_in_delta( 1.5*PI, p2pD.theta, $tolerance )
 
-    p2pE = Polar2D.new( 2.0,  5.5*PI ).minimize_theta
+    p2pE = Mageo::Polar2D.new( 2.0,  5.5*PI ).minimize_theta
     assert_in_delta( 1.5*PI, p2pE.theta, $tolerance )
 
-    p2pF = Polar2D.new( 2.0,  4.5*PI ).minimize_theta
+    p2pF = Mageo::Polar2D.new( 2.0,  4.5*PI ).minimize_theta
     assert_in_delta( 0.5*PI, p2pF.theta, $tolerance )
 
   end
 
   def test_minimum_radian
-    assert_in_delta( 1.5*PI, Polar2D.minimum_radian( -2.5*PI ), $tolerance )
-    assert_in_delta( 1.5*PI, Polar2D.minimum_radian( -0.5*PI ), $tolerance )
-    assert_in_delta( 1.5*PI, Polar2D.minimum_radian(  1.5*PI ), $tolerance )
-    assert_in_delta( 1.5*PI, Polar2D.minimum_radian(  3.5*PI ), $tolerance )
-    assert_in_delta( 0.5*PI, Polar2D.minimum_radian(  4.5*PI ), $tolerance )
-    assert_in_delta( 1.5*PI, Polar2D.minimum_radian(  5.5*PI ), $tolerance )
+    assert_in_delta( 1.5*PI, Mageo::Polar2D.minimum_radian( -2.5*PI ), $tolerance )
+    assert_in_delta( 1.5*PI, Mageo::Polar2D.minimum_radian( -0.5*PI ), $tolerance )
+    assert_in_delta( 1.5*PI, Mageo::Polar2D.minimum_radian(  1.5*PI ), $tolerance )
+    assert_in_delta( 1.5*PI, Mageo::Polar2D.minimum_radian(  3.5*PI ), $tolerance )
+    assert_in_delta( 0.5*PI, Mageo::Polar2D.minimum_radian(  4.5*PI ), $tolerance )
+    assert_in_delta( 1.5*PI, Mageo::Polar2D.minimum_radian(  5.5*PI ), $tolerance )
   end
 end
 

data/test/test_polar3d.rb

@@ -1,10 +1,11 @@
 #! /usr/bin/env ruby
 # coding: utf-8
 
-require "test/unit"
+#require "test/unit"
 require "helper"
-require "mageo/polar3d.rb"
-require "mageo/vector3d.rb"
+#require 'mageo.rb'
+#require "mageo/polar3d.rb"
+#require "mageo/vector3d.rb"
 
 class TC_Polar3D < Test::Unit::TestCase
   $tolerance = 10**(-10)
@@ -12,29 +13,29 @@ class TC_Polar3D < Test::Unit::TestCase
   include Math
 
   def setup
-    @p3d00 = Polar3D.new( 0.0, 0.00*PI, 0.00*PI)
-    @p3d01 = Polar3D.new( 2.0, 0.00*PI, 0.25*PI)
-    @p3d02 = Polar3D.new( 2.0, 0.25*PI, 0.00*PI)
-    @p3d03 = Polar3D.new( 2.0, 0.25*PI, 0.25*PI)
+    @p3d00 = Mageo::Polar3D.new( 0.0, 0.00*PI, 0.00*PI)
+    @p3d01 = Mageo::Polar3D.new( 2.0, 0.00*PI, 0.25*PI)
+    @p3d02 = Mageo::Polar3D.new( 2.0, 0.25*PI, 0.00*PI)
+    @p3d03 = Mageo::Polar3D.new( 2.0, 0.25*PI, 0.25*PI)
   end
 
   def test_to_v3d
-    assert_equal( Vector3D, @p3d00.to_v3d.class )
+    assert_equal( Mageo::Vector3D, @p3d00.to_v3d.class )
     assert_in_delta( 0.0, @p3d00.to_v3d[0], $tolerance )
     assert_in_delta( 0.0, @p3d00.to_v3d[1], $tolerance )
     assert_in_delta( 0.0, @p3d00.to_v3d[2], $tolerance )
 
-    assert_equal( Vector3D, @p3d01.to_v3d.class )
+    assert_equal( Mageo::Vector3D, @p3d01.to_v3d.class )
     assert_in_delta( 0.0, @p3d01.to_v3d[0], $tolerance )
     assert_in_delta( 0.0, @p3d01.to_v3d[1], $tolerance )
     assert_in_delta( 2.0, @p3d01.to_v3d[2], $tolerance )
 
-    assert_equal( Vector3D, @p3d02.to_v3d.class )
+    assert_equal( Mageo::Vector3D, @p3d02.to_v3d.class )
     assert_in_delta( Math::sqrt(2.0), @p3d02.to_v3d[0], $tolerance )
     assert_in_delta( 0.0            , @p3d02.to_v3d[1], $tolerance )
     assert_in_delta( Math::sqrt(2.0), @p3d02.to_v3d[2], $tolerance )
 
-    assert_equal( Vector3D, @p3d03.to_v3d.class )
+    assert_equal( Mageo::Vector3D, @p3d03.to_v3d.class )
     #√2 * cos(0.25PI)
     assert_in_delta( 1.0 , @p3d03.to_v3d[0], $tolerance)
     assert_in_delta( 1.0 , @p3d03.to_v3d[1], $tolerance)
@@ -43,49 +44,49 @@ class TC_Polar3D < Test::Unit::TestCase
   end
 
   def test_minimize_phi!
-    p2pA = Polar3D.new( 2.0, 0.5*PI, -2.5*PI )
+    p2pA = Mageo::Polar3D.new( 2.0, 0.5*PI, -2.5*PI )
     p2pA.minimize_phi!
     assert_in_delta( 1.5*PI, p2pA.phi, $tolerance )
 
-    p2pB = Polar3D.new( 2.0, 0.5*PI, -0.5*PI )
+    p2pB = Mageo::Polar3D.new( 2.0, 0.5*PI, -0.5*PI )
     p2pB.minimize_phi!
     assert_in_delta( 1.5*PI, p2pB.phi, $tolerance )
 
-    p2pC = Polar3D.new( 2.0, 0.5*PI,  1.5*PI )
+    p2pC = Mageo::Polar3D.new( 2.0, 0.5*PI,  1.5*PI )
     p2pC.minimize_phi!
     assert_in_delta( 1.5*PI, p2pC.phi, $tolerance )
 
-    p2pD = Polar3D.new( 2.0, 0.5*PI,  3.5*PI )
+    p2pD = Mageo::Polar3D.new( 2.0, 0.5*PI,  3.5*PI )
     p2pD.minimize_phi!
     assert_in_delta( 1.5*PI, p2pD.phi, $tolerance )
 
-    p2pE = Polar3D.new( 2.0, 0.5*PI,  5.5*PI )
+    p2pE = Mageo::Polar3D.new( 2.0, 0.5*PI,  5.5*PI )
     p2pE.minimize_phi!
     assert_in_delta( 1.5*PI, p2pE.phi, $tolerance )
 
-    p2pF = Polar3D.new( 2.0, 0.5*PI,  4.5*PI )
+    p2pF = Mageo::Polar3D.new( 2.0, 0.5*PI,  4.5*PI )
     p2pF.minimize_phi!
     assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
 
   end
 
   def test_minimize_phi
-    p2pA = Polar3D.new( 2.0, 0.5*PI, -2.5*PI ).minimize_phi
+    p2pA = Mageo::Polar3D.new( 2.0, 0.5*PI, -2.5*PI ).minimize_phi
     assert_in_delta( 1.5*PI, p2pA.phi, $tolerance )
 
-    p2pB = Polar3D.new( 2.0, 0.5*PI, -0.5*PI ).minimize_phi
+    p2pB = Mageo::Polar3D.new( 2.0, 0.5*PI, -0.5*PI ).minimize_phi
     assert_in_delta( 1.5*PI, p2pB.phi, $tolerance )
 
-    p2pC = Polar3D.new( 2.0, 0.5*PI,  1.5*PI ).minimize_phi
+    p2pC = Mageo::Polar3D.new( 2.0, 0.5*PI,  1.5*PI ).minimize_phi
     assert_in_delta( 1.5*PI, p2pC.phi, $tolerance )
 
-    p2pD = Polar3D.new( 2.0, 0.5*PI,  3.5*PI ).minimize_phi
+    p2pD = Mageo::Polar3D.new( 2.0, 0.5*PI,  3.5*PI ).minimize_phi
     assert_in_delta( 1.5*PI, p2pD.phi, $tolerance )
 
-    p2pE = Polar3D.new( 2.0, 0.5*PI,  5.5*PI ).minimize_phi
+    p2pE = Mageo::Polar3D.new( 2.0, 0.5*PI,  5.5*PI ).minimize_phi
     assert_in_delta( 1.5*PI, p2pE.phi, $tolerance )
 
-    p2pF = Polar3D.new( 2.0, 0.5*PI,  4.5*PI ).minimize_phi
+    p2pF = Mageo::Polar3D.new( 2.0, 0.5*PI,  4.5*PI ).minimize_phi
     assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
 
   end