mageo 0.0.0

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mageo'
+
+class Test::Unit::TestCase
+end

data/test/test_axes.rb

@@ -0,0 +1,209 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+require "test/unit"
+require "mageo/axes.rb"
+
+class TC_Axes < Test::Unit::TestCase
+	$tolerance = 1.0 * 10.0**(-10)
+
+	def setup
+		@a10 = Axes.new([[1.0]])
+		@a20 = Axes.new([[1.0, 0.0], [0.0, 1.0]])
+		@a30 = Axes.new([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])
+		@a40 = Axes.new([
+				[1.0, 0.0, 0.0, 0.0],
+				[0.0, 1.0, 0.0, 0.0],
+				[0.0, 0.0, 1.0, 0.0],
+				[0.0, 0.0, 0.0, 1.0]
+			]
+		)
+
+		@a31 = Axes.new( [ [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ] )
+		@a32 = Axes.new( [ [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5] ] )
+		@a33 = Axes.new( [ [1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0] ] )
+		@a34 = Axes.new( [ [0.5, 0.5, 0.0], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0] ] )
+		@a35 = Axes.new( [ [1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0] ] )
+		@a36 = Axes.new( [ [1.0, 1.0, 1.0], [0.0,-1.0,-1.0], [0.0, 0.0, 1.0] ] )
+
+		@vec_x = Vector[ 1.0, 0.0, 0.0 ]
+		@vec_y = Vector[ 0.0, 1.0, 0.0 ]
+		@vec_z = Vector[ 0.0, 0.0, 1.0 ]
+		@vec_0 = Vector[ 0.0, 0.0, 0.0 ]
+		@vec_1 = Vector[ 1.0, 1.0, 0.0 ]
+	end
+
+	def test_initialize
+		assert_raise(Axes::InitializeError) { Axes.new([[]]) }
+		assert_raise(Axes::InitializeError) { Axes.new([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) }
+		assert_raise(Axes::InitializeError) { Axes.new([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 1.0]]) }
+		assert_raise(Axes::InitializeError) { Axes.new([[1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]) }
+		assert_raise(Axes::InitializeError) { Axes.new([[1.0, 0.0, 0.0], [0.0, 1.0], [0.0, 0.0, 1.0]]) }
+		assert_raise(Axes::InitializeError) { Axes.new([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0]]) }
+		assert_raise(Axes::InitializeError) { Axes.new([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]]) }
+
+		assert_nothing_raised{ Axes.new([["1.0", "0.0", "0.0"], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]]) }
+		assert_nothing_raised{ Axes.new([[1, 0, 0], [0, 1, 0], [0, 0, 0]]) }
+	end
+
+	def test_self_dependent?
+		# Righthand
+		assert_equal( false, Axes.dependent?( [ @vec_x, @vec_y, @vec_z ] ) )
+		assert_equal( false, Axes.dependent?( [ @vec_y, @vec_z, @vec_x ] ) )
+		assert_equal( false, Axes.dependent?( [ @vec_z, @vec_x, @vec_y ] ) )
+		
+		# Lefthand
+		assert_equal( false, Axes.dependent?( [ @vec_z, @vec_y, @vec_x ] ) )
+		assert_equal( false, Axes.dependent?( [ @vec_x, @vec_z, @vec_y ] ) )
+		assert_equal( false, Axes.dependent?( [ @vec_y, @vec_x, @vec_z ] ) )
+		
+		# Including zero vector.
+		assert_equal( true , Axes.dependent?( [ @vec_0, @vec_y, @vec_z ] ) )
+		assert_equal( true , Axes.dependent?( [ @vec_0, @vec_z, @vec_x ] ) )
+		assert_equal( true , Axes.dependent?( [ @vec_0, @vec_x, @vec_y ] ) )
+
+		# One vector is on the plane of residual two vectors.
+		assert_equal( true , Axes.dependent?( [ @vec_x, @vec_y, @vec_1 ] ) )
+	end
+
+	def test_self_independent?
+		# Righthand
+		assert_equal( true , Axes.independent?( [ @vec_x, @vec_y, @vec_z ] ) )
+		assert_equal( true , Axes.independent?( [ @vec_y, @vec_z, @vec_x ] ) )
+		assert_equal( true , Axes.independent?( [ @vec_z, @vec_x, @vec_y ] ) )
+		
+		# Lefthand
+		assert_equal( true , Axes.independent?( [ @vec_z, @vec_y, @vec_x ] ) )
+		assert_equal( true , Axes.independent?( [ @vec_x, @vec_z, @vec_y ] ) )
+		assert_equal( true , Axes.independent?( [ @vec_y, @vec_x, @vec_z ] ) )
+		
+		# Including zero vector.
+		assert_equal( false, Axes.independent?( [ @vec_0, @vec_y, @vec_z ] ) )
+		assert_equal( false, Axes.independent?( [ @vec_0, @vec_z, @vec_x ] ) )
+		assert_equal( false, Axes.independent?( [ @vec_0, @vec_x, @vec_y ] ) )
+
+		# One vector is on the plane of residual two vectors.
+		assert_equal( false, Axes.independent?( [ @vec_x, @vec_y, @vec_1 ] ) )
+	end
+
+	def test_size
+		assert_equal( 1, @a10.size )
+		assert_equal( 2, @a20.size )
+		assert_equal( 3, @a30.size )
+		assert_equal( 4, @a40.size )
+	end
+
+	def test_equal
+		assert_equal( true , @a31 == Axes.new( [ [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ] ))
+		assert_equal( false, @a31 == Axes.new( [ [0.5, 0.5, 0.0], [0.0, 0.5, 0.5], [0.5, 0.0, 0.5] ] ))
+		assert_equal( false, @a31 == Axes.new( [ [1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0] ] ))
+
+		assert_equal( false, @a32 == Axes.new( [ [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ] ))
+		assert_equal( true , @a32 == Axes.new( [ [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5] ] ))
+		assert_equal( false, @a32 == Axes.new( [ [1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0] ] ))
+
+		assert_equal( false, @a35 == Axes.new( [ [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ] ))
+		assert_equal( false, @a35 == Axes.new( [ [0.5, 0.5, 0.0], [0.0, 0.5, 0.5], [0.5, 0.0, 0.5] ] ))
+		assert_equal( true , @a35 == Axes.new( [ [1.0, 1.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0] ] ))
+	end
+
+	def test_dependent?
+		assert_equal( false, @a31.dependent? )
+		assert_equal( false, @a32.dependent? )
+		assert_equal( true , @a33.dependent? )
+		assert_equal( true , @a34.dependent? )
+	end
+
+	def test_independent?
+		assert_equal( true , @a31.independent? )
+		assert_equal( true , @a32.independent? )
+		assert_equal( false, @a33.independent? )
+		assert_equal( false, @a34.independent? )
+	end
+
+	def test_to_a
+		assert_equal( Array, @a31.to_a.class )
+		assert_equal( Array, @a31.to_a[0].class )
+		assert_equal( Array, @a31.to_a[1].class )
+		assert_equal( Array, @a31.to_a[2].class )
+		assert_in_delta( 1.0, @a31.to_a[0][0], $tolerance )
+		assert_in_delta( 0.0, @a31.to_a[0][1], $tolerance )
+		assert_in_delta( 0.0, @a31.to_a[0][2], $tolerance )
+		assert_in_delta( 0.0, @a31.to_a[1][0], $tolerance )
+		assert_in_delta( 1.0, @a31.to_a[1][1], $tolerance )
+		assert_in_delta( 0.0, @a31.to_a[1][2], $tolerance )
+		assert_in_delta( 0.0, @a31.to_a[2][0], $tolerance )
+		assert_in_delta( 0.0, @a31.to_a[2][1], $tolerance )
+		assert_in_delta( 1.0, @a31.to_a[2][2], $tolerance )
+
+		assert_equal( Array, @a35.to_a.class )
+		assert_equal( Array, @a35.to_a[0].class )
+		assert_equal( Array, @a35.to_a[1].class )
+		assert_equal( Array, @a35.to_a[2].class )
+		assert_in_delta( 1.0, @a35.to_a[0][0], $tolerance )
+		assert_in_delta( 1.0, @a35.to_a[0][1], $tolerance )
+		assert_in_delta( 1.0, @a35.to_a[0][2], $tolerance )
+		assert_in_delta( 0.0, @a35.to_a[1][0], $tolerance )
+		assert_in_delta( 1.0, @a35.to_a[1][1], $tolerance )
+		assert_in_delta( 1.0, @a35.to_a[1][2], $tolerance )
+		assert_in_delta( 0.0, @a35.to_a[2][0], $tolerance )
+		assert_in_delta( 0.0, @a35.to_a[2][1], $tolerance )
+		assert_in_delta( 1.0, @a35.to_a[2][2], $tolerance )
+	end
+
+	def test_paren # []
+		assert_equal( Vector, @a31[0].class )
+		assert_equal( Vector, @a31[1].class )
+		assert_equal( Vector, @a31[2].class )
+		assert_in_delta( 1.0, @a31[0][0], $tolerance )
+		assert_in_delta( 0.0, @a31[0][1], $tolerance )
+		assert_in_delta( 0.0, @a31[0][2], $tolerance )
+		assert_in_delta( 0.0, @a31[1][0], $tolerance )
+		assert_in_delta( 1.0, @a31[1][1], $tolerance )
+		assert_in_delta( 0.0, @a31[1][2], $tolerance )
+		assert_in_delta( 0.0, @a31[2][0], $tolerance )
+		assert_in_delta( 0.0, @a31[2][1], $tolerance )
+		assert_in_delta( 1.0, @a31[2][2], $tolerance )
+	end
+
+	def test_each
+		i = 0
+		@a31.each { |vec|
+			assert_equal( @a31[i], vec )
+			i += 1
+		}
+
+		assert_raise( NoMethodError ) { @a31.map{ |vec| vec * 2.0 } }
+	end
+
+	def test_to_a
+		t = @a10.to_a
+		assert_equal(Array, t.class)
+		assert_equal([[1.0]], t)
+
+		t = @a20.to_a
+		assert_equal(Array, t.class)
+		assert_equal([[1.0, 0.0], [0.0, 1.0]], t)
+
+		t = @a30.to_a
+		assert_equal(Array, t.class)
+		assert_equal([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] , t)
+
+		t = @a40.to_a
+		assert_equal(Array, t.class)
+		assert_equal( [
+				[1.0, 0.0, 0.0, 0.0],
+				[0.0, 1.0, 0.0, 0.0],
+				[0.0, 0.0, 1.0, 0.0],
+				[0.0, 0.0, 0.0, 1.0]
+			], t
+		)
+
+		t = @a32.to_a
+		assert_equal(Array, t.class)
+		assert_equal( [ [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5] ] , t)
+	end
+
+end
+

data/test/test_cylinder.rb

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "helper"
+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)
+	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(3.0, @c00.radius)
+	end
+
+end
+

data/test/test_octahedron.rb

@@ -0,0 +1,157 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "helper"
+require "mageo/octahedron.rb"
+gem "builtinextension"
+  require "array_include_eql.rb"
+
+class 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_MINUS = Vector3D[ -1,  0,  0 ]
+	V_Y_MINUS = Vector3D[  0, -1,  0 ]
+	V_Z_MINUS = Vector3D[  0,  0, -1 ]
+
+	def setup
+		@o00 = Octahedron.new(
+			[ [V_X_MINUS, V_X_PLUS ],
+				[V_Y_MINUS, V_Y_PLUS ],
+				[V_Z_MINUS, V_Z_PLUS ] ]
+		)
+		@o01 = 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 ] ] ]
+		)
+	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( 
+				[ [ V_X_MINUS, V_X_PLUS ],
+					[ V_Y_MINUS, V_Y_PLUS ],
+					[ V_Z_MINUS, [  0,  0 ] ]
+				]
+			)
+		}
+		assert_raise( Octahedron::InitializeError ){
+			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( 
+				[ [ V_X_MINUS, V_X_PLUS ],
+					[ V_Y_MINUS, V_Y_PLUS ],
+					[ V_Z_MINUS, V_Z_PLUS ],
+					[ [ -5, -5, -5 ], [  5,  5,  5 ] ]
+				]
+			)
+		}
+
+		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_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 ] ] ]
+			)
+		}
+	end
+
+	def test_inside?
+		assert_equal( true , @o00.inside?( [0.0, 0.2, 0.4] ) )
+		assert_equal( false, @o00.inside?( [1.0, 0.0, 0.0] ) ) #境界上
+		assert_equal( false, @o00.inside?( [2.0, 0.2, 0.4] ) )
+	end
+
+	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( false, @o00.include?( [2.0, 0.2, 0.4], $tolerance ) )
+	end
+
+	def test_volume
+		assert_in_delta( 8.0/6.0 , @o00.volume, $tolerance )
+	end
+
+	def test_center
+		assert_in_delta( 0.0, @o00.center[0], $tolerance)
+		assert_in_delta( 0.0, @o00.center[1], $tolerance)
+		assert_in_delta( 0.0, @o00.center[2], $tolerance)
+
+		assert_in_delta( 0.5, @o01.center[0], $tolerance)
+		assert_in_delta( 0.5, @o01.center[1], $tolerance)
+		assert_in_delta( 0.5, @o01.center[2], $tolerance)
+	end
+
+	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 ))
+	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])))
+	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))))
+	end
+
+
+end
+

data/test/test_polar2d.rb

@@ -0,0 +1,153 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "helper"
+require "mageo/vector.rb"
+require "mageo/polar2d.rb"
+
+
+class TC_Vector < Test::Unit::TestCase
+	include Math
+
+	$tolerance = 10.0**(-10)
+
+	def setup
+		@v0 = Vector[ 1.0, 2.0, 3.0 ]
+		@v1 = Vector[ 1.0, 1.0 ]
+		@v2 = Vector[ 1.0, 2.0, 3.0, 4.0 ]
+	end
+
+	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( Math::sqrt(2.0), @v1.to_p2d.r )
+		assert_equal( 0.25*PI        , @v1.to_p2d.theta )
+
+		assert_in_delta( 0.00*PI, Vector[  0.0,  0.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 0.00*PI, Vector[  2.0,  0.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 0.25*PI, Vector[  2.0,  2.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 0.50*PI, Vector[  0.0,  2.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 0.75*PI, Vector[ -2.0,  2.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 1.00*PI, Vector[ -2.0,  0.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 1.25*PI, Vector[ -2.0, -2.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 1.50*PI, Vector[  0.0, -2.0 ].to_p2d.theta, $tolerance )
+		assert_in_delta( 1.75*PI, Vector[  2.0, -2.0 ].to_p2d.theta, $tolerance )
+	end
+end
+
+
+class TC_Polar2D < Test::Unit::TestCase
+	$tolerance = 10**(-10)
+
+	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)
+	end
+
+	def test_to_v
+		assert_equal( Vector[ 0.0, 0.0 ], @p2d00.to_v )
+		assert_equal( Vector[ 0.0, 0.0 ], @p2d01.to_v )
+		assert_equal( Vector[ 2.0, 0.0 ], @p2d02.to_v )
+		assert_equal( Vector[ 2.0*cos(0.1*PI), 2.0*sin(0.1*PI) ], @p2d03.to_v )
+	end
+
+	def test_rotate
+		assert_equal( 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 )
+		assert_in_delta( 0.0   , @p2d01.rotate( 0.2 * PI ).r    , $tolerance )
+		assert_in_delta( 2.2*PI, @p2d01.rotate( 0.2 * PI ).theta, $tolerance )
+		assert_in_delta( 2.0   , @p2d02.rotate( 0.2 * PI ).r    , $tolerance )
+		assert_in_delta( 0.2*PI, @p2d02.rotate( 0.2 * PI ).theta, $tolerance )
+		assert_in_delta( 2.0   , @p2d03.rotate( 0.2 * PI ).r    , $tolerance )
+		assert_in_delta( 0.3*PI, @p2d03.rotate( 0.2 * PI ).theta, $tolerance )
+
+		#変化していないことを確認
+		assert_equal( Vector[ 0.0, 0.0 ], @p2d00.to_v )
+		assert_equal( Vector[ 0.0, 0.0 ], @p2d01.to_v )
+		assert_equal( Vector[ 2.0, 0.0 ], @p2d02.to_v )
+		assert_equal( Vector[ 2.0*cos(0.1*PI), 2.0*sin(0.1*PI) ], @p2d03.to_v )
+	end
+
+	def test_rotate!
+		@p2d00.rotate!( 0.2 * PI )
+		@p2d01.rotate!( 0.2 * PI )
+		@p2d02.rotate!( 0.2 * PI )
+		@p2d03.rotate!( 0.2 * PI )
+
+		assert_in_delta( 0.0   , @p2d00.r    , $tolerance )
+		assert_in_delta( 0.2*PI, @p2d00.theta, $tolerance )
+		assert_in_delta( 0.0   , @p2d01.r    , $tolerance )
+		assert_in_delta( 2.2*PI, @p2d01.theta, $tolerance )
+		assert_in_delta( 2.0   , @p2d02.r    , $tolerance )
+		assert_in_delta( 0.2*PI, @p2d02.theta, $tolerance )
+		assert_in_delta( 2.0   , @p2d03.r    , $tolerance )
+		assert_in_delta( 0.3*PI, @p2d03.theta, $tolerance )
+	end
+
+	def test_minimize_theta!
+		p2pA = 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.minimize_theta!
+		assert_in_delta( 1.5*PI, p2pB.theta, $tolerance )
+
+		p2pC = 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.minimize_theta!
+		assert_in_delta( 1.5*PI, p2pD.theta, $tolerance )
+
+		p2pE = 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.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
+		assert_in_delta( 1.5*PI, p2pA.theta, $tolerance )
+
+		p2pB = 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
+		assert_in_delta( 1.5*PI, p2pC.theta, $tolerance )
+
+		p2pD = 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
+		assert_in_delta( 1.5*PI, p2pE.theta, $tolerance )
+
+		p2pF = 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 )
+	end
+
+end
+