mageo 0.0.0 → 0.0.1

data/test/test_polar3d.rb

@@ -7,89 +7,87 @@ require "mageo/polar3d.rb"
 require "mageo/vector3d.rb"
 
 class TC_Polar3D < Test::Unit::TestCase
-	$tolerance = 10**(-10)
+  $tolerance = 10**(-10)
 
-	include Math
+  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)
-	end
+  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)
+  end
 
-	def test_to_v3d
-		assert_equal( 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 )
+  def test_to_v3d
+    assert_equal( 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_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, @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_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, @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 )
-		#√2 * cos(0.25PI)
-		assert_in_delta( 1.0 , @p3d03.to_v3d[0], $tolerance)
-		assert_in_delta( 1.0 , @p3d03.to_v3d[1], $tolerance)
-		assert_in_delta( Math::sqrt(2.0), @p3d03.to_v3d[2], $tolerance )
+    assert_equal( 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)
+    assert_in_delta( Math::sqrt(2.0), @p3d03.to_v3d[2], $tolerance )
 
-	end
+  end
 
-	def test_minimize_phi!
-		p2pA = Polar3D.new( 2.0, 0.5*PI, -2.5*PI )
-		p2pA.minimize_phi!
-		assert_in_delta( 1.5*PI, p2pA.phi, $tolerance )
+  def test_minimize_phi!
+    p2pA = 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.minimize_phi!
-		assert_in_delta( 1.5*PI, p2pB.phi, $tolerance )
+    p2pB = 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.minimize_phi!
-		assert_in_delta( 1.5*PI, p2pC.phi, $tolerance )
+    p2pC = 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.minimize_phi!
-		assert_in_delta( 1.5*PI, p2pD.phi, $tolerance )
+    p2pD = 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.minimize_phi!
-		assert_in_delta( 1.5*PI, p2pE.phi, $tolerance )
+    p2pE = 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.minimize_phi!
-		assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
+    p2pF = Polar3D.new( 2.0, 0.5*PI,  4.5*PI )
+    p2pF.minimize_phi!
+    assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
 
-	end
+  end
 
-	def test_minimize_phi
-		p2pA = Polar3D.new( 2.0, 0.5*PI, -2.5*PI ).minimize_phi
-		assert_in_delta( 1.5*PI, p2pA.phi, $tolerance )
+  def test_minimize_phi
+    p2pA = 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
-		assert_in_delta( 1.5*PI, p2pB.phi, $tolerance )
+    p2pB = 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
-		assert_in_delta( 1.5*PI, p2pC.phi, $tolerance )
+    p2pC = 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
-		assert_in_delta( 1.5*PI, p2pD.phi, $tolerance )
+    p2pD = 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
-		assert_in_delta( 1.5*PI, p2pE.phi, $tolerance )
-
-		p2pF = Polar3D.new( 2.0, 0.5*PI,  4.5*PI ).minimize_phi
-		assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
-
-	end
+    p2pE = 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
+    assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
 
+  end
 end
 

data/test/test_polyhedron.rb

@@ -8,7 +8,7 @@ require "mageo/polyhedron.rb"
 # initialize でインスタンスを生成できないことのみテストする。
 # その他の機能はサブクラスでテスト。
 class TC_Polyhedron < Test::Unit::TestCase
-	def test_initialize
-		assert_raise( NotImplementedError ) { Polyhedron.new }
-	end
+  def test_initialize
+    assert_raise( NotImplementedError ) { Polyhedron.new }
+  end
 end

data/test/test_segment.rb

@@ -6,77 +6,76 @@ require "helper"
 require "mageo/segment.rb"
 
 class TC_Segment < Test::Unit::TestCase
-	$tolerance = 1.0 * 10.0 ** (-10)
-
-	VEC_00 = Vector3D[1.0, 2.0, 3.0]
-	VEC_01 = Vector3D[4.0, 6.0, 8.0]
-
-	VEC_10 = Vector3D[0.0, 0.0, 1.0]
-	VEC_11 = Vector3D[0.0, 0.0, 3.0]
-
-	VEC_20 = Vector3D[1.0, 1.0, 1.0]
-	VEC_21 = Vector3D[0.0, 0.0, 0.0]
-	def setup
-		@s00 = Segment.new(VEC_00, VEC_01)
-		@s01 = Segment.new(VEC_10, VEC_11)
-		@s02 = Segment.new(VEC_20, VEC_21)
-	end
-
-	def test_initialize
-		vec00 = [1.0, 2.0, 3.0]
-		vec01 = [4.0, 6.0, 8.0]
-		assert_raise(Segment::InitializeError){
-			Segment.new(vec00, vec01)
-		}
-		assert_raise(Segment::InitializeError){
-			Segment.new(VEC_00, VEC_00)
-		}
-	end
-
-	def test_endpoints
-		assert_equal(VEC_00, @s00.endpoints[0])
-		assert_equal(VEC_01, @s00.endpoints[1])
-	end
-
-	def test_include?
-		assert_raise(Segment::TypeError){
-			@s02.include?([0.0, 0.0, 0.0], $tolerance)
-		}
-
-		#直線上
-		assert_equal(false, @s02.include?(Vector3D[-1.0,-1.0,-1.0], $tolerance))
-		assert_equal(true , @s02.include?(Vector3D[ 0.0, 0.0, 0.0], $tolerance))
-		assert_equal(true , @s02.include?(Vector3D[ 0.3, 0.3, 0.3], $tolerance))
-		assert_equal(true , @s02.include?(Vector3D[ 1.0, 1.0, 1.0], $tolerance))
-		assert_equal(false, @s02.include?(Vector3D[ 2.0, 2.0, 2.0], $tolerance))
-
-		#横に出てる
-		assert_equal(false, @s02.include?(Vector3D[0.1, 0.1, 0.2], $tolerance))
-		assert_equal(true , @s02.include?(Vector3D[0.1, 0.1, 0.2], 1.0))
-	end
-
-	def test_to_v3d
-		assert_equal(Vector3D[ 3.0, 4.0, 5.0], @s00.to_v3d)
-		assert_equal(Vector3D[ 0.0, 0.0, 2.0], @s01.to_v3d)
-		assert_equal(Vector3D[-1.0,-1.0,-1.0], @s02.to_v3d)
-	end
-
-	def test_eql?
-		assert_raise(Segment::TypeError){ @s00.eql?([[0,0,0],[1,1,1]])}
-
-		assert_equal(true , @s00.eql?(Segment.new(VEC_01, VEC_00)))
-		assert_equal(false, @s00.eql?(@s01))
-	end
-
-	def test_equal2
-		assert_raise(Segment::TypeError){ @s00.eql?([[0,0,0],[1,1,1]])}
-
-		assert_equal(true , @s00 == Segment.new(VEC_00, VEC_01))
-		assert_equal(false, @s00 == Segment.new(VEC_01, VEC_00))
-		assert_equal(false, @s00 == @s01)
-	end
-
-	#undef test_include?
-
+  $tolerance = 1.0 * 10.0 ** (-10)
+
+  VEC_00 = Vector3D[1.0, 2.0, 3.0]
+  VEC_01 = Vector3D[4.0, 6.0, 8.0]
+
+  VEC_10 = Vector3D[0.0, 0.0, 1.0]
+  VEC_11 = Vector3D[0.0, 0.0, 3.0]
+
+  VEC_20 = Vector3D[1.0, 1.0, 1.0]
+  VEC_21 = Vector3D[0.0, 0.0, 0.0]
+  def setup
+    @s00 = Segment.new(VEC_00, VEC_01)
+    @s01 = Segment.new(VEC_10, VEC_11)
+    @s02 = Segment.new(VEC_20, VEC_21)
+  end
+
+  def test_initialize
+    vec00 = [1.0, 2.0, 3.0]
+    vec01 = [4.0, 6.0, 8.0]
+    assert_raise(Segment::InitializeError){
+      Segment.new(vec00, vec01)
+    }
+    assert_raise(Segment::InitializeError){
+      Segment.new(VEC_00, VEC_00)
+    }
+  end
+
+  def test_endpoints
+    assert_equal(VEC_00, @s00.endpoints[0])
+    assert_equal(VEC_01, @s00.endpoints[1])
+  end
+
+  def test_include?
+    assert_raise(Segment::TypeError){
+      @s02.include?([0.0, 0.0, 0.0], $tolerance)
+    }
+
+    #直線上
+    assert_equal(false, @s02.include?(Vector3D[-1.0,-1.0,-1.0], $tolerance))
+    assert_equal(true , @s02.include?(Vector3D[ 0.0, 0.0, 0.0], $tolerance))
+    assert_equal(true , @s02.include?(Vector3D[ 0.3, 0.3, 0.3], $tolerance))
+    assert_equal(true , @s02.include?(Vector3D[ 1.0, 1.0, 1.0], $tolerance))
+    assert_equal(false, @s02.include?(Vector3D[ 2.0, 2.0, 2.0], $tolerance))
+
+    #横に出てる
+    assert_equal(false, @s02.include?(Vector3D[0.1, 0.1, 0.2], $tolerance))
+    assert_equal(true , @s02.include?(Vector3D[0.1, 0.1, 0.2], 1.0))
+  end
+
+  def test_to_v3d
+    assert_equal(Vector3D[ 3.0, 4.0, 5.0], @s00.to_v3d)
+    assert_equal(Vector3D[ 0.0, 0.0, 2.0], @s01.to_v3d)
+    assert_equal(Vector3D[-1.0,-1.0,-1.0], @s02.to_v3d)
+  end
+
+  def test_eql?
+    assert_raise(Segment::TypeError){ @s00.eql?([[0,0,0],[1,1,1]])}
+
+    assert_equal(true , @s00.eql?(Segment.new(VEC_01, VEC_00)))
+    assert_equal(false, @s00.eql?(@s01))
+  end
+
+  def test_equal2
+    assert_raise(Segment::TypeError){ @s00.eql?([[0,0,0],[1,1,1]])}
+
+    assert_equal(true , @s00 == Segment.new(VEC_00, VEC_01))
+    assert_equal(false, @s00 == Segment.new(VEC_01, VEC_00))
+    assert_equal(false, @s00 == @s01)
+  end
+
+  #undef test_include?
 end
 

data/test/test_sphere.rb

@@ -7,14 +7,13 @@ require "mageo/sphere.rb"
 require "mageo/vector3d.rb"
 
 class TC_Sphere < Test::Unit::TestCase
-	def setup
-		@s00 = Sphere.new([0.0, 1.0, 2.0], 3.0)
-	end
-
-	def test_initialize
-		assert_equal(Vector3D[0.0, 1.0, 2.0], @s00.position)
-		assert_equal(3.0, @s00.radius)
-	end
+  def setup
+    @s00 = Sphere.new([0.0, 1.0, 2.0], 3.0)
+  end
 
+  def test_initialize
+    assert_equal(Vector3D[0.0, 1.0, 2.0], @s00.position)
+    assert_equal(3.0, @s00.radius)
+  end
 end
 

data/test/test_tetrahedron.rb

@@ -8,125 +8,123 @@ require "array_include_eql.rb"
 require "mageo/tetrahedron.rb"
 
 class Tetrahedron
-	public :center
+  public :center
 end
 
 class TC_Tetrahedron < Test::Unit::TestCase
-	$tolerance = 10**(-10)
-
-	V_00 = Vector3D[ 0.0, 0.0, 0.0]
-	V_01 = Vector3D[10.0, 0.0, 0.0]
-	V_02 = Vector3D[ 0.0,10.0, 0.0]
-	V_03 = Vector3D[ 0.0, 0.0,10.0]
-
-	V_10 = Vector3D[10.0,20.0,30.0]
-	V_11 = Vector3D[ 0.0,20.0,30.0]
-	V_12 = Vector3D[10.0, 0.0,30.0]
-	V_13 = Vector3D[10.0,20.0, 0.0]
-
-	def setup
-		@t00 = Tetrahedron.new( [ V_00, V_01, V_02, V_03 ])
-		@t01 = Tetrahedron.new( [ V_10, V_11, V_12, V_13 ])
-	end
-
-	def test_initialize
-		assert_raise( ArgumentError ){ Tetrahedron.new }
-		assert_raise( ArgumentError ){ Tetrahedron.new() }
-		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( nil ) }
-		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [] ) }
-		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [ 0, 1, 2, 3 ] ) }
-		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [ [], [], [], [] ] ) }
-		assert_raise( Tetrahedron::InitializeError ){
-			Tetrahedron.new( [ V_00, V_01, V_02, [ 0.0, 0.0 ] ])
-		}
-		assert_raise( Tetrahedron::InitializeError ){
-			Tetrahedron.new( [ V_00, V_01, V_02, [ 0.0, 0.0, 1.0, 0.0 ] ])
-		}
-
-		# 5点ある
-		assert_raise( Tetrahedron::InitializeError ){
-			Tetrahedron.new( [ V_00, V_01, V_02, V_03, [ 1.0, 1.0, 1.0] ])
-		}
-	
-		# 体積が 0.0 になるのはエラー
-		assert_raise( Tetrahedron::InitializeError ){
-			Tetrahedron.new( [ V_00, V_01, V_02, [ 2.0, 2.0, 0.0] ])
-		}
-
-		# Vector3DInternal なら 例外
-		assert_raise( Tetrahedron::InitializeError ){
-			Tetrahedron.new( 
-				[ Vector3DInternal[ 0.0, 0.0, 0.0],
-					Vector3DInternal[ 1.0, 0.0, 0.0],
-					Vector3DInternal[ 0.0, 1.0, 0.0],
-					Vector3DInternal[ 0.0, 0.0, 1.0]
-				]
-			)
-		}
-	
-		# Vector3D なら OK
-		assert_nothing_raised{
-			Tetrahedron.new( [ V_00, V_01, V_02, V_03 ])
-		}
-	end
-
-	def test_inside?
-		assert_equal( true , @t00.inside?( [ 1.0, 1.0, 1.0] ) )
-		assert_equal( false, @t00.inside?( [ 5.0, 5.0, 5.0] ) )
-		assert_equal( false, @t00.inside?( [-5.0,-5.0,-5.0] ) )
-		assert_equal( false, @t00.inside?( [ 0.0, 0.0, 0.0] ) ) #頂点上
-
-		assert_raise(Polyhedron::TypeError){@t00.inside?(Vector3DInternal[1.0, 1.0, 1.0])}
-		assert_raise(Tetrahedron::TypeError){@t00.inside?(Vector3DInternal[1.0, 1.0, 1.0])}
-		#pp Polyhedron::TypeError.ancestors
-		#pp Tetrahedron::TypeError.ancestors
-	end
-
-	def test_include?
-		assert_equal( true , @t00.include?([ 1.0, 1.0, 1.0], $tolerance))
-		assert_equal( false, @t00.include?([ 5.0, 5.0, 5.0], $tolerance))
-		assert_equal( false, @t00.include?([-5.0,-5.0,-5.0], $tolerance))
-		assert_equal( true , @t00.include?([ 0.0, 0.0, 0.0], $tolerance)) #頂点上
-
-		assert_equal( false, @t01.include?(Vector3D[ 3.0, 6.0, 30.0], $tolerance))
-
-		assert_raise(Polyhedron::TypeError){@t00.include?(Vector3DInternal[1.0, 1.0, 1.0], $tolerance)}
-	end
-
-	def test_volume
-		assert_in_delta( 1000.0/6.0 , @t00.volume, $tolerance )
-	end
-
-	def test_center
-		assert_in_delta( 10.0/4.0, @t00.center[0], $tolerance)
-		assert_in_delta( 10.0/4.0, @t00.center[1], $tolerance)
-		assert_in_delta( 10.0/4.0, @t00.center[2], $tolerance)
-	end
-
-	def test_vertices
-		assert_equal( [ V_00, V_01, V_02, V_03 ], @t00.vertices)
-	end
-
-	def test_triangles
-		t = @t00.triangles
-		assert_equal(4, t.size)
-		assert_equal(Triangle.new([V_00, V_01, V_02]) ,t[0])
-		assert_equal(Triangle.new([V_01, V_02, V_03]) ,t[1])
-		assert_equal(Triangle.new([V_02, V_03, V_00]) ,t[2])
-		assert_equal(Triangle.new([V_03, V_00, V_01]) ,t[3])
-	end
-
-	def test_edges
-		t = @t00.edges
-		assert_equal(6, t.size)
-		assert_equal(true, (t.include_eql?(Segment.new(V_00, V_01))))
-		assert_equal(true, (t.include_eql?(Segment.new(V_00, V_02))))
-		assert_equal(true, (t.include_eql?(Segment.new(V_00, V_03))))
-		assert_equal(true, (t.include_eql?(Segment.new(V_01, V_02))))
-		assert_equal(true, (t.include_eql?(Segment.new(V_01, V_03))))
-		assert_equal(true, (t.include_eql?(Segment.new(V_02, V_03))))
-	end
-
-
+  $tolerance = 10**(-10)
+
+  V_00 = Vector3D[ 0.0, 0.0, 0.0]
+  V_01 = Vector3D[10.0, 0.0, 0.0]
+  V_02 = Vector3D[ 0.0,10.0, 0.0]
+  V_03 = Vector3D[ 0.0, 0.0,10.0]
+
+  V_10 = Vector3D[10.0,20.0,30.0]
+  V_11 = Vector3D[ 0.0,20.0,30.0]
+  V_12 = Vector3D[10.0, 0.0,30.0]
+  V_13 = Vector3D[10.0,20.0, 0.0]
+
+  def setup
+    @t00 = Tetrahedron.new( [ V_00, V_01, V_02, V_03 ])
+    @t01 = Tetrahedron.new( [ V_10, V_11, V_12, V_13 ])
+  end
+
+  def test_initialize
+    assert_raise( ArgumentError ){ Tetrahedron.new }
+    assert_raise( ArgumentError ){ Tetrahedron.new() }
+    assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( nil ) }
+    assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [] ) }
+    assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [ 0, 1, 2, 3 ] ) }
+    assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [ [], [], [], [] ] ) }
+    assert_raise( Tetrahedron::InitializeError ){
+      Tetrahedron.new( [ V_00, V_01, V_02, [ 0.0, 0.0 ] ])
+    }
+    assert_raise( Tetrahedron::InitializeError ){
+      Tetrahedron.new( [ V_00, V_01, V_02, [ 0.0, 0.0, 1.0, 0.0 ] ])
+    }
+
+    # 5点ある
+    assert_raise( Tetrahedron::InitializeError ){
+      Tetrahedron.new( [ V_00, V_01, V_02, V_03, [ 1.0, 1.0, 1.0] ])
+    }
+  
+    # 体積が 0.0 になるのはエラー
+    assert_raise( Tetrahedron::InitializeError ){
+      Tetrahedron.new( [ V_00, V_01, V_02, [ 2.0, 2.0, 0.0] ])
+    }
+
+    # Vector3DInternal なら 例外
+    assert_raise( Tetrahedron::InitializeError ){
+      Tetrahedron.new( 
+        [ Vector3DInternal[ 0.0, 0.0, 0.0],
+          Vector3DInternal[ 1.0, 0.0, 0.0],
+          Vector3DInternal[ 0.0, 1.0, 0.0],
+          Vector3DInternal[ 0.0, 0.0, 1.0]
+        ]
+      )
+    }
+  
+    # Vector3D なら OK
+    assert_nothing_raised{
+      Tetrahedron.new( [ V_00, V_01, V_02, V_03 ])
+    }
+  end
+
+  def test_inside?
+    assert_equal( true , @t00.inside?( [ 1.0, 1.0, 1.0] ) )
+    assert_equal( false, @t00.inside?( [ 5.0, 5.0, 5.0] ) )
+    assert_equal( false, @t00.inside?( [-5.0,-5.0,-5.0] ) )
+    assert_equal( false, @t00.inside?( [ 0.0, 0.0, 0.0] ) ) #頂点上
+
+    assert_raise(Polyhedron::TypeError){@t00.inside?(Vector3DInternal[1.0, 1.0, 1.0])}
+    assert_raise(Tetrahedron::TypeError){@t00.inside?(Vector3DInternal[1.0, 1.0, 1.0])}
+    #pp Polyhedron::TypeError.ancestors
+    #pp Tetrahedron::TypeError.ancestors
+  end
+
+  def test_include?
+    assert_equal( true , @t00.include?([ 1.0, 1.0, 1.0], $tolerance))
+    assert_equal( false, @t00.include?([ 5.0, 5.0, 5.0], $tolerance))
+    assert_equal( false, @t00.include?([-5.0,-5.0,-5.0], $tolerance))
+    assert_equal( true , @t00.include?([ 0.0, 0.0, 0.0], $tolerance)) #頂点上
+
+    assert_equal( false, @t01.include?(Vector3D[ 3.0, 6.0, 30.0], $tolerance))
+
+    assert_raise(Polyhedron::TypeError){@t00.include?(Vector3DInternal[1.0, 1.0, 1.0], $tolerance)}
+  end
+
+  def test_volume
+    assert_in_delta( 1000.0/6.0 , @t00.volume, $tolerance )
+  end
+
+  def test_center
+    assert_in_delta( 10.0/4.0, @t00.center[0], $tolerance)
+    assert_in_delta( 10.0/4.0, @t00.center[1], $tolerance)
+    assert_in_delta( 10.0/4.0, @t00.center[2], $tolerance)
+  end
+
+  def test_vertices
+    assert_equal( [ V_00, V_01, V_02, V_03 ], @t00.vertices)
+  end
+
+  def test_triangles
+    t = @t00.triangles
+    assert_equal(4, t.size)
+    assert_equal(Triangle.new([V_00, V_01, V_02]) ,t[0])
+    assert_equal(Triangle.new([V_01, V_02, V_03]) ,t[1])
+    assert_equal(Triangle.new([V_02, V_03, V_00]) ,t[2])
+    assert_equal(Triangle.new([V_03, V_00, V_01]) ,t[3])
+  end
+
+  def test_edges
+    t = @t00.edges
+    assert_equal(6, t.size)
+    assert_equal(true, (t.include_eql?(Segment.new(V_00, V_01))))
+    assert_equal(true, (t.include_eql?(Segment.new(V_00, V_02))))
+    assert_equal(true, (t.include_eql?(Segment.new(V_00, V_03))))
+    assert_equal(true, (t.include_eql?(Segment.new(V_01, V_02))))
+    assert_equal(true, (t.include_eql?(Segment.new(V_01, V_03))))
+    assert_equal(true, (t.include_eql?(Segment.new(V_02, V_03))))
+  end
 end