gmath3D 0.1.1 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/gmath3D.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gmath3D}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Toshiyasu Shimizu"]
-  s.date = %q{2011-09-24}
+  s.date = %q{2011-10-09}
   s.description = %q{This library defines 3D geometric elements(point, line, plane etc..). It can get two(or more) elements relation, like distance between two elements.}
   s.email = %q{toshi0328@gmail.com}
   s.extra_rdoc_files = [

data/lib/box.rb

@@ -1,11 +1,19 @@
 require 'gmath3D'
 
 module GMath3D
+  #
+  # Box represents an axitially aligned box on 3D space.
+  #
   class Box < Geom
 public
     attr_accessor :min_point
     attr_accessor :max_point
 
+    # [Input]
+    #  _point1_ and _point2_ should be Vector3.
+    #  Each points are opposing corners.
+    # [Output]
+    #  return new instance of Box.
     def initialize(point1 = Vector3.new(0,0,0), point2 = Vector3.new(1,1,1))
       Util.check_arg_type(Vector3, point1)
       Util.check_arg_type(Vector3, point2)
@@ -20,21 +28,36 @@ public
       @max_point.z = [ point1.z, point2.z ].max
     end
 
+    def to_s
+      "Box[min#{min_point.to_element_s}, max#{max_point.to_element_s}]"
+    end
+
     def ==(rhs)
       equals_inner(rhs)
     end
+
+    # [Input]
+    #  _rhs_ shold be Vector3 or Box or Array of them.
+    # [Output]
+    #  return added result as Box.
     def +(rhs)
       add(rhs)
     end
 
+    # [Output]
+    #  return cente point of Box as Vector3.
     def center
       return (@min_point + @max_point) * 0.5
     end
 
+    # [Output]
+    #  return x length, y lenght and z length as [Numeric, Numeric, Numeric]
     def length
       return max_point.x - min_point.x, max_point.y - min_point.y, max_point.z - min_point.z
     end
 
+    # [Output]
+    #  return volume of Box as Numeric.
     def volume
       width, height, depth = self.length
       return width*height*depth

data/lib/finite_line.rb

@@ -1,11 +1,18 @@
 require 'gmath3D'
 
 module GMath3D
+  #
+  # FiniteLine represents a finite line on 3D space.
+  #
   class FiniteLine < Geom
 public
     attr_accessor :start_point
     attr_accessor :end_point
 
+    # [Input]
+    #  _start_point_arg_ and _end_point_arg_ should be Vector3.
+    # [Output]
+    #  return new instance as FiniteLine
     def initialize(start_point_arg = Vector3.new(0.0,0.0,0.0), end_point_arg = Vector3.new(1.0,0.0,0.0))
       Util.check_arg_type(Vector3, start_point_arg)
       Util.check_arg_type(Vector3, end_point_arg)
@@ -14,10 +21,20 @@ public
       @end_point  = end_point_arg
     end
 
+    def to_s
+      "FiniteLine[from#{start_point.to_element_s}, to#{end_point.to_element_s}]"
+    end
+
+    # [Output]
+    #  return direction as vector from start_point to end_point as Vector3
     def direction
       @end_point - @start_point
     end
 
+    # [Input]
+    #  _parameter_ should be Numeric.
+    # [Output]
+    #  return a point on line at input parameter position as Vector3
     def point(parameter)
       if(parameter < 0.0 or 1.0 < parameter)
         return nil
@@ -26,10 +43,22 @@ public
       end
     end
 
+    # [Output]
+    #  return length as Numeric
     def length
       @start_point.distance(@end_point)
     end
 
+    # This function returns closest distance between FiniteLine and anothor element.
+    # [Input]
+    #  _target_ should be Vector3 or Line or FiniteLine
+    #
+    # [Output]
+    #  [in case _target_ is Vector3]
+    #   return "distance, closest point on myself, parameter on myself" as [Numeric, Vector3, Numeric]
+    #  [in case _target_ is Line or FiniteLine]
+    #   return "distance, point on myself, point on target, parameter on myself, parameter on tatget" 
+    #   as [Numeric, Vector3, Vector3, Numeric, Numeric]
     def distance(target)
       # with Point
       if(target.kind_of?(Vector3))
@@ -58,7 +87,6 @@ public
       closest_point = points_ary[distance_ary.index(distance)]
       return distance, closest_point
     end
-
 private
     def distance_to_point(target)
       # get distance using infinite line
@@ -81,7 +109,7 @@ private
       end
       return distance, closest_point, parameter
     end
-    
+
     def distance_to_line(target_infinite_line)
       self_infinite_line = Line.new(self.start_point, self.direction)
       distance, point1, point2, parameter1, parameter2 = self_infinite_line.distance(target_infinite_line)
@@ -99,7 +127,7 @@ private
         return distance_to_end_point, self.end_point, closest_point_to_end_point, 1.0, parameter_to_end_point
       end
     end
-    
+
     def distance_to_finite_line(target_finite_line)
       line1 = Line.new(self.start_point, self.direction)
       line2 = Line.new(target_finite_line.start_point, target_finite_line.direction)

data/lib/line.rb

@@ -1,11 +1,18 @@
 require 'gmath3D'
 
 module GMath3D
+  #
+  # Line represents a infinite line on 3D space.
+  #
   class Line < Geom
     public
     attr_accessor :base_point
     attr_accessor :direction
-    
+
+    # [Input]
+    #  _point_ and _direction_ should be Vector3.
+    # [Output]
+    #  return new instance of Line.
     def initialize(point = Vector3.new(0.0,0.0,0.0), direction = Vector3.new(1.0,0.0,0.0))
       Util.check_arg_type(Vector3, point)
       Util.check_arg_type(Vector3, direction)
@@ -13,12 +20,30 @@ module GMath3D
       @base_point = point
       @direction  = direction
     end
-    
+
+    def to_s
+      "Line[point#{@base_point.to_element_s}, vector#{@direction.to_element_s}"
+    end
+
+    # [Input]
+    #  _parameter_ should be Numeric.
+    # [Output]
+    #  return a point on line at input parameter position as Vector3
     def point(parameter)
-                  Util.check_arg_type(::Numeric, parameter)
+      Util.check_arg_type(::Numeric, parameter)
       @base_point + @direction*parameter
     end
-    
+
+    # This function returns closest distance between Line and anothor element.
+    # [Input]
+    #  _target_ should be Vector3 or Line.
+    #
+    # [Output]
+    #  [in case _target_ is Vector3]
+    #   return "distance, closest point on myself, parameter on myself" as [Numeric, Vector3, Numeric]
+    #  [in case _target_ is Line]
+    #   return "distance, point on myself, point on target, parameter on myself, parameter on tatget" 
+    #   as [Numeric, Vector3, Vector3, Numeric, Numeric]
     def distance(target)
       # with Point
       if(target.kind_of?(Vector3))
@@ -29,7 +54,7 @@ module GMath3D
       end
       Util.raise_argurment_error(target)
     end
-    
+
     private
     def distance_to_point(target_point)
       point_on_line1 = self.base_point
@@ -42,7 +67,7 @@ module GMath3D
       vecPQ = vecAQ - vecAP
       return vecPQ.length, cross_point, parameter
     end
-    
+
     def distance_to_line(target_line)
       if(self.direction.parallel?(target_line.direction)) then
         distanceInfo = self.distance(target_line.base_point)
@@ -52,23 +77,23 @@ module GMath3D
         line1_point2 = self.base_point + self.direction
         line2_point1 = target_line.base_point
         line2_point2 = target_line.base_point + target_line.direction
-        
+
         vec_da = line1_point2 - line1_point1
         vec_db = line2_point2 - line2_point1
         vec_ab = line2_point1 - line1_point1
-        
-        abs_vec_db = vec_db.length*vec_db.length 
-        abs_vec_da = vec_da.length*vec_da.length 
-        
+
+        abs_vec_db = vec_db.length*vec_db.length
+        abs_vec_da = vec_da.length*vec_da.length
+
         delta = (abs_vec_da*abs_vec_db - vec_da.dot( vec_db )*vec_da.dot( vec_db ))
-        
+
         if( delta < self.tolerance )
           # TODO ASSERT(false)
           return nil
         end
         parameter1 = (abs_vec_db*vec_ab.dot(vec_da) - vec_da.dot( vec_db )*vec_ab.dot( vec_db ) ) / delta
         parameter2 = (vec_da.dot( vec_db )*vec_ab.dot( vec_da ) - abs_vec_da*vec_ab.dot( vec_db ))/ delta
-        
+
         line1_closest_point = line1_point1 + vec_da*parameter1
         line2_closest_point = line2_point1 + vec_db*parameter2
         distance = line1_closest_point.distance( line2_closest_point )

data/lib/plane.rb

@@ -1,19 +1,45 @@
 require 'gmath3D'
 
 module GMath3D
+  #
+  # Plane represents a infinite plane on 3D space.
+  #
   class Plane < Geom
 public
     attr_accessor:base_point
     attr_accessor:normal
 
-    def initialize(base_point_arg = Vector3.new(), normal_arg = Vector3.new(0,0,1))
-      Util.check_arg_type(::Vector3, normal_arg)
-      Util.check_arg_type(::Vector3, base_point_arg)
+    # [Input]
+    #  _base_point_ and _normal_ should be Vector3.
+    # [Output]
+    #  returns new instance of Plane.
+    def initialize(base_point = Vector3.new(), normal = Vector3.new(0,0,1))
+      Util.check_arg_type(::Vector3, normal)
+      Util.check_arg_type(::Vector3, base_point)
       super()
-      @base_point = base_point_arg
-      @normal = normal_arg.normalize()
+      @base_point = base_point
+      @normal = normal.normalize()
     end
 
+    def to_s
+      "Plane[point#{@base_point.to_element_s}, normal#{@normal.to_element_s}]"
+    end
+
+    # This function returns closest distance between Line and anothor element.
+    # [Input]
+    #  _target_ should be Vector3 or Line or FiniteLine or Plane.
+    #
+    # [Output]
+    #  [in case _target_ is Vector3]
+    #   return "distance, closest point on myself" as [Numeric, Vector3].
+    #  [in case _target_ is Line]
+    #   return "distance, intersect point, parameter on tatget" as [Numeric, Vector3, Numeric].
+    #  [in case _target_ is FiniteLine]
+    #   return "distance, point on plane, point on target, parameter on target"
+    #   as [Numeric, Vector3, Vector3, Numeric].
+    #  [in case _target_ is Plane]
+    #   return "distance, intersect line" as [Numeric, Vector3].
+
     def distance(target)
       # with Point
       if(target.kind_of?(Vector3))
@@ -31,6 +57,10 @@ public
       Util.raise_argurment_error(target)
     end
 
+    # [Input]
+    #  _target_point_ should be Vector3.
+    # [Output]
+    #  retrun projected point on plane as Vector3.
     def project( target_point )
       Util.check_arg_type(::Vector3, target_point)
       distance, closest_point = self.distance( target_point )

data/lib/rectangle.rb

@@ -3,12 +3,20 @@ require 'matrix'
 require 'gmath3D'
 
 module GMath3D
+  #
+  # Rectangle represents a four edged finite plane on 3D space.
+  #
   class Rectangle < Geom
 public
     attr_accessor:base_point
     attr_accessor:u_vector
     attr_accessor:v_vector
 
+    # [Input]
+    #  _base_point_ , _u_vector_, _v_vector_ should be Vector3.
+    # _u_vector_ and _v_vector_ should be orthogonalized.
+    # [Output]
+    #  return new instance of Rectangle.
     def initialize(base_point_arg = Vector3.new(), u_vector_arg = Vector3.new(1,0,0), v_vector_arg = Vector3.new(0,1,0))
       Util.check_arg_type(::Vector3, base_point_arg)
       Util.check_arg_type(::Vector3, u_vector_arg)
@@ -19,12 +27,22 @@ public
       self.v_vector = v_vector_arg
     end
 
+    def to_s
+      "Rectangle[base#{@base_point.to_element_s}, u#{@u_vector.to_element_s}, v#{@v_vector.to_element_s}"
+    end
+
+    # [Input]
+    #  _u_, _v_ should be Numeric.
+    # [Output]
+    #  return point on rectangle as Vector3.
     def point(u, v)
       Util.check_arg_type(::Numeric, u)
       Util.check_arg_type(::Numeric, v)
       return base_point + u_vector*u + v_vector*v
     end
 
+    # [Output]
+    #  return edges of rectangle as Array of FiniteLine.
     def edges
       edge_ary = Array.new(4)
       edge_ary[0] = FiniteLine.new( base_point, base_point+u_vector)
@@ -34,22 +52,34 @@ public
       return edge_ary
     end
 
+    # [Output]
+    #  return normal of rectangle as Vector3.
     def normal
       return (u_vector.cross(v_vector)).normalize()
     end
 
+    # [Output]
+    #  return point of opposite to base_point as Vector3.
     def opposite_point
       return base_point + u_vector + v_vector
     end
 
+    # [Output]
+    #  return center point as Vector3.
     def center_point
       return base_point + u_vector*0.5 + v_vector*0.5
     end
 
+    # [Output]
+    #  return rectangle area as Numeric.
     def area
       return (u_vector.cross(v_vector)).length
     end
 
+    # [Input]
+    #  _check_point_ shold be Vector3.
+    # [Output]
+    #  return u, v parametes on check_point as [Numeric, Numeric].
     def uv_parameter(check_point)
       Util.check_arg_type(::Vector3, check_point)
       mat = Matrix[[u_vector.x, u_vector.y, u_vector.z],
@@ -60,6 +90,10 @@ public
       return ans[0,0], ans[1,0]
     end
 
+    # [Input]
+    #  _target_ shold be Vector3.
+    # [Output]
+    #  return "distance, point on rectangle" as [Numeric, Vector3].
     def distance(target)
       # with Point
       if(target.kind_of?(Vector3))

data/lib/triangle.rb

@@ -1,24 +1,41 @@
 require 'gmath3D'
 
 module GMath3D
+  #
+  # Triangle represents a three edged finite plane on 3D space.
+  #
   class Triangle < Geom
 public
     attr_accessor:vertices
 
-    def initialize(vertex_arg1 = Vector3.new(), vertex_arg2 = Vector3.new(1,0,0), vertex_arg3 = Vector3.new(0,1,0))
-      Util.check_arg_type(::Vector3, vertex_arg1)
-      Util.check_arg_type(::Vector3, vertex_arg2)
-      Util.check_arg_type(::Vector3, vertex_arg3)
+    # [Input]
+    #  _vertex1_, _vertex2_, _vertex3_ should be Vector3.
+    # [Output]
+    #  return new instance of Triangle.
+    def initialize(vertex1 = Vector3.new(), vertex2 = Vector3.new(1,0,0), vertex3 = Vector3.new(0,1,0))
+      Util.check_arg_type(::Vector3, vertex1)
+      Util.check_arg_type(::Vector3, vertex2)
+      Util.check_arg_type(::Vector3, vertex3)
       super()
-      @vertices = Array.new([vertex_arg1, vertex_arg2, vertex_arg3])
+      @vertices = Array.new([vertex1, vertex2, vertex3])
     end
 
+    def to_s
+      "Triangle[#{@vertices[0].to_element_s}, #{@vertices[1].to_element_s}, #{@vertices[2].to_element_s}]"
+    end
+
+    # [Input]
+    #  _parameter_ should be three element Array of Numeric.
+    # [Output]
+    #  return point on triangle at parameter position as Vector3.
     def point( parameter )
       Util.check_arg_type(::Array, parameter )
       # TODO Argument check
       return self.vertices[0]*parameter[0] + self.vertices[1]*parameter[1] + self.vertices[2]*parameter[2]
     end
 
+    # [Output]
+    #  return edges as three element Array of Vector3.
     def edges
       return_edges = Array.new(3)
       return_edges[0] = FiniteLine.new(self.vertices[0], self.vertices[1])
@@ -27,6 +44,8 @@ public
       return return_edges
     end
 
+    # [Output]
+    #  return area as Numeric.
     def area
       vec1 = vertices[1] - vertices[0]
       vec2 = vertices[2] - vertices[0]
@@ -34,16 +53,24 @@ public
       return outer_product.length / 2.0
     end
 
+    # [Output]
+    #  return center point as Vector3.
     def center
       return vertices.avg
     end
 
+    # [Output]
+    #  return normal vector as Vector3.
     def normal
       vec1 = self.vertices[1] - self.vertices[0]
       vec2 = self.vertices[2] - self.vertices[0]
       return (vec1.cross(vec2).normalize)
     end
 
+    # [Input]
+    #  _check_point_ should be Vector3.
+    # [Output]
+    #  return barycentric_coordinate on check_point as three element Array of Numeric.
     def barycentric_coordinate( check_point )
       Util.check_arg_type(::Vector3, check_point)
 
@@ -95,6 +122,10 @@ public
       return b;
     end
 
+    # [Input]
+    #  _target_ shold be Vector3.
+    # [Output]
+    #  return "distance, point on triangle" as [Numeric, Vector3].
     def distance(target)
       # with Point
       if(target.kind_of?(Vector3))
@@ -106,7 +137,11 @@ public
       Util.raise_argurment_error(target)
     end
 
-    def contains( check_point )
+    # [Input]
+    #  _check_point_ shold be Vector3.
+    # [Output]
+    #  return true if triangle contains _check_point_.
+    def contains?( check_point )
       Util.check_arg_type(Vector3, check_point )
       plane = Plane.new( vertices[0], self.normal)
       distance, projected_point = plane.distance(check_point)
@@ -117,11 +152,12 @@ public
       end
       return true
     end
+
 private
     def distance_to_point(target_point)
       plane = Plane.new( vertices[0], self.normal)
       distance, projected_point = plane.distance(target_point)
-      if( self.contains(projected_point))
+      if( self.contains?(projected_point))
         return distance, projected_point
       end
       #check distance to FiniteLines

data/lib/vector3.rb

@@ -1,38 +1,90 @@
 require 'gmath3D'
 
 module GMath3D
+  #
+  # Vector3 represents a point or a vector on 3D space.
+  #
   class Vector3 < Geom
 public
     attr_accessor :x
     attr_accessor :y
     attr_accessor :z
 
+    # [Input]
+    #  _x_, _y_, _z_ should be Numeric.
+    # [Output]
+    #  return new instance as Vector3.
     def initialize(x=0.0,y=0.0,z=0.0)
+      Util.check_arg_type(Numeric, x)
+      Util.check_arg_type(Numeric, y)
+      Util.check_arg_type(Numeric, z)
       super()
       @x = x
       @y = y
       @z = z
     end
+
+    def to_element_s
+      "[#{@x}, #{@y}, #{@z}]"
+    end
+
+    def to_s
+      "Vector3" + to_element_s
+    end
+
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return true if rhs equals myself.
     def ==(rhs)
       equals_inner(rhs)
     end
+
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return added result as Vector3.
     def +(rhs)
       add(rhs)
     end
+
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return subtracted result as Vector3.
     def -(rhs)
       subtract(rhs)
     end
+
+    # [Input]
+    #  _rsh_ should be Numeric.
+    # [Output]
+    #  return multiplyed result as Vector3.
     def *(rhs)
       multiply(rhs)
     end
+
+    # [Input]
+    #  _rhs_ should be Numeric.
+    # [Output]
+    #  return divided result as Vector3.
     def /(rhs)
       divide(rhs)
     end
 
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return inner product as Numeric
     def dot(rhs)
       Util.check_arg_type(Vector3, rhs)
       self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
     end
+
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return cross product as Vector3.
     def cross(rhs)
       Util.check_arg_type(Vector3, rhs)
       Vector3.new(
@@ -41,18 +93,25 @@ public
               self.x*rhs.y - self.y*rhs.x)
     end
 
+    # [Output]
+    #  return vector length as Numeric
     def length
       Math::sqrt(self.x*self.x + self.y*self.y + self.z*self.z)
     end
-    def distance(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      Math::sqrt((self.x - rhs.x)*(self.x - rhs.x) + (self.y - rhs.y)*(self.y - rhs.y) + (self.z - rhs.z)*(self.z - rhs.z))
-    end
+
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return distance between two points as Numeric.
     def distance(rhs)
       Util.check_arg_type(Vector3, rhs)
       Math::sqrt((self.x - rhs.x)*(self.x - rhs.x) + (self.y - rhs.y)*(self.y - rhs.y) + (self.z - rhs.z)*(self.z - rhs.z))
     end
 
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return two vectors angle as Numeric (rad).
     def angle(rhs)
       Util.check_arg_type(Vector3, rhs)
       vec1Length = self.length ;
@@ -61,16 +120,28 @@ public
       v = self.dot(rhs)/(vec1Length*vec2Length)
       Math::acos( v )
     end
+
+    # [Output]
+    #  return normalized vector as Vector3
     def normalize()
       self / self.length.to_f
     end
 
+    # [Input]
+    #  _rhs_ should be Vector3
+    # [Output]
+    #  return true if myself and rhs is parallel as boolean
     def parallel?(rhs)
       Util.check_arg_type(Vector3, rhs)
       return false if(self.length < self.tolerance or rhs.length < rhs.tolerance)
       return false if(self.cross(rhs).length > self.tolerance)
       return true
     end
+
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return true if myself and rhs have same direction as boolean.
     def same_direction?(rhs)
       Util.check_arg_type(Vector3, rhs)
       return false if(!parallel?(rhs))
@@ -78,15 +149,24 @@ public
       return true
     end
 
+    # This function projects self vector to rhs vector.
+    # [Input]
+    #  _rhs_ should be Vector3.
+    # [Output]
+    #  return projected result as Vector3.
     def project_to(rhs)
       Util.check_arg_type(Vector3, rhs)
       return Vector3.new, 0.0 if( rhs.length < rhs.tolerance )
       parameter = self.dot( rhs ) / ( rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z ).to_f
       return rhs*parameter, parameter
     end
+
+    # [Output]
+    #  return column vector as Matrix
     def to_column_vector
       return Matrix.column_vector([x,y,z])
     end
+
     private
     def equals_inner(rhs)
       return false if( !rhs.kind_of?(Vector3) )

data/test/test_box.rb

@@ -1,4 +1,5 @@
-require 'box'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
 
 include GMath3D
 
@@ -10,6 +11,10 @@ class BoxTestCase < MiniTest::Unit::TestCase
     @box = Box.new(Vector3.new(-3,2,5), Vector3.new(2,-2.5, 0))
   end
 
+  def test_to_s
+    assert_equal( "Box[min[-3, -2.5, 0], max[2, 2, 5]]", @box.to_s)
+  end
+
   def test_initalize
     assert_equal(0, @box_default.min_point.x)
     assert_equal(0, @box_default.min_point.y)

data/test/test_finite_line.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun
@@ -7,15 +10,20 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     start_point_tmp = Vector3.new(1.0,  0.0, 2.0)
     end_point_tmp   = Vector3.new(1.0, -3.5, 1.0)
     line = FiniteLine.new(start_point_tmp, end_point_tmp)
-    
+
     assert_equal(start_point_tmp ,line.start_point)
     assert_equal(end_point_tmp   ,line.end_point  )
-    
+
     lineDefault = FiniteLine.new()
     assert_equal(Vector3.new(0,0,0), lineDefault.start_point)
     assert_equal(Vector3.new(1,0,0), lineDefault.end_point  )
   end
-  
+
+  def test_to_s
+    line = FiniteLine.new(Vector3.new(1,0,2), Vector3.new(1,-3.5,2))
+    assert_equal("FiniteLine[from[1, 0, 2], to[1, -3.5, 2]]", line.to_s)
+  end
+
   def test_direction
     start_point_tmp = Vector3.new(1.0,  0.0, 2.0)
     end_point_tmp   = Vector3.new(1.0, -3.5, 1.0)
@@ -37,32 +45,32 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal( nil, line.point(-1.0))
     assert_equal( nil, line.point(1.2))
   end
-  
+
   def test_length
     start_point_tmp = Vector3.new(0.0, 0.0, 2.0)
     end_point_tmp   = Vector3.new(2.0, 2.0, 2.0)
     line = FiniteLine.new(start_point_tmp, end_point_tmp)
-    
+
     assert_in_delta(Math::sqrt(8), line.length, line.tolerance)
   end
-  
+
   def test_distance_to_point
     start_point_tmp = Vector3.new(0.0, 0.0, 2.0)
     end_point_tmp   = Vector3.new(2.0, 2.0, 2.0)
     line = FiniteLine.new(start_point_tmp, end_point_tmp)
-    
+
     targetPoint = Vector3.new(1.0, 1.0, -4.0)
     distance, pointOnLine, parameter = line.distance(targetPoint)
     assert_in_delta(6.0, distance, targetPoint.tolerance)
     assert_equal( Vector3.new(1.0, 1.0, 2.0), pointOnLine)
     assert_in_delta(0.5, parameter, targetPoint.tolerance)
-    
+
     targetPoint2 = Vector3.new(3.0, 3.0, 2.0)
     distance, pointOnLine, parameter = line.distance(targetPoint2)
     assert_in_delta(Math::sqrt(2), distance, targetPoint.tolerance)
     assert_equal( end_point_tmp, pointOnLine)
     assert_in_delta(1.0, parameter, targetPoint.tolerance)
-    
+
     targetPoint3 = Vector3.new(0.0, -1.0, 3.0)
     distance, pointOnLine, parameter = line.distance(targetPoint3)
     assert_in_delta(Math::sqrt(2), distance, targetPoint.tolerance)
@@ -74,7 +82,7 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     distance, point_on_line, parameter = line.distance( target_point4 )
     assert_in_delta( 1, distance, line.tolerance )
     assert_equal( Vector3.new(1,3,3), point_on_line )
-    assert_in_delta( 0.5, parameter, line.tolerance ) 
+    assert_in_delta( 0.5, parameter, line.tolerance )
   end
 
   def test_distance_to_line
@@ -148,7 +156,7 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal( Vector3.new(1,1,2), point2)
     assert_in_delta(0.5, parameter1, target_finite_line.tolerance)
     assert_in_delta(0.5, parameter2, target_finite_line.tolerance)
-    
+
     #not intersect case1
     target_finite_line = FiniteLine.new(Vector3.new(2.0, 0.0, 4.0), Vector3.new(0.0, 2.0, 4.0))
     distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
@@ -157,7 +165,7 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal( Vector3.new(1,1,4), point2)
     assert_in_delta(0.5, parameter1, target_finite_line.tolerance)
     assert_in_delta(0.5, parameter2, target_finite_line.tolerance)
-    
+
     #not intersect case2
     target_finite_line = FiniteLine.new(Vector3.new(3.0, 2.0, 2.0), Vector3.new(5.0, 0.0, 2.0))
     distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
@@ -184,7 +192,7 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal( Vector3.new(-2,2,0), point2)
     assert_in_delta(0, parameter1, target_finite_line.tolerance)
     assert_in_delta(1, parameter2, target_finite_line.tolerance)
-    
+
     #parallel case1
     target_finite_line = FiniteLine.new(Vector3.new(4,4,0),Vector3.new(5,5,0))
     distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
@@ -211,7 +219,7 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal( nil, point2)
     assert_equal( nil, parameter1)
     assert_equal( nil, parameter2)
-        
+
     #including case1
     target_finite_line = FiniteLine.new(Vector3.new(2,2,2),Vector3.new(5,5,2))
     distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
@@ -229,9 +237,8 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal( nil, point2)
     assert_equal( nil, parameter1)
     assert_equal( nil, parameter2)
-    
   end
-  
+
   def test_distance_to_invalid_value
     finite_line = FiniteLine.new(Vector3.new(0,1,2), Vector3.new(2,3,4))
     assert_raises ArgumentError do

data/test/test_geom.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun

data/test/test_line.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun
@@ -16,6 +19,11 @@ class LineTestCase < MiniTest::Unit::TestCase
     assert(Vector3.new(1,0,0) == lineDefault.direction )
   end
 
+  def test_to_s
+    line =  Line.new(Vector3.new(2.0, 3, 5), Vector3.new(1.0, 1.0, 1.0))
+    assert_equal("Line[point[2.0, 3, 5], vector[1.0, 1.0, 1.0]", line.to_s);
+  end
+
   def test_point
     base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
     direction_tmp  = Vector3.new(1.0, 1.0, 0.0)

data/test/test_plane.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun
@@ -18,6 +21,10 @@ class PlaneTestCase < MiniTest::Unit::TestCase
     assert_equal(Geom.default_tolerance, @plane_default.tolerance)
   end
 
+  def test_to_s
+    assert_equal("Plane[point[0, 0, 1], normal[0.0, 0.0, 1.0]]", @plane.to_s)
+  end
+
   def test_distance_to_point
     target_point = Vector3.new(1,2,3)
     distance, closest_point = @plane.distance(target_point)

data/test/test_rectangle.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun
@@ -18,6 +21,10 @@ class RectangleTestCase < MiniTest::Unit::TestCase
     assert_equal(Vector3.new(0,1,0), @rectangle_default.v_vector)
   end
 
+  def test_to_s
+    assert_equal("Rectangle[base[1, 2, 3], u[0, -0.5, 0], v[0, 0, 2]", @rectangle.to_s)
+  end
+
   def test_point
     point = @rectangle.point(0.2, 1.0)
     assert_equal(Vector3.new(1, 1.9, 5), point)

data/test/test_triangle.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun
@@ -18,6 +21,10 @@ class TriangleTestCase < MiniTest::Unit::TestCase
     assert_equal(Vector3.new(0,1,0), @triangle_default.vertices[2])
   end
 
+  def test_to_s
+    assert_equal("Triangle[[1, 2, 2], [1, 4, 2], [-1, 3, 0]]", @triangle.to_s)
+  end
+
   def test_point
     assert_equal(@triangle.vertices[0], @triangle.point( Array.new([1,0,0])))
     assert_equal(@triangle.vertices[1], @triangle.point( Array.new([0,1,0])))
@@ -109,13 +116,13 @@ class TriangleTestCase < MiniTest::Unit::TestCase
 
   def test_contains
     check_point = @triangle.center + @triangle.normal*3.0
-    assert( !@triangle.contains( check_point) )
-    assert( @triangle.contains( @triangle.center) )
-    assert( @triangle.contains( Vector3.new( 1,3,2)))
-    assert( @triangle.contains( Vector3.new(-1,3,0)))
-    assert( @triangle_default.contains( Vector3.new( 0.5, 0.5, 0.0 ) ))
-    assert( !@triangle_default.contains( Vector3.new( -1.0, 2.0, 0.0 )))
-    assert( !@triangle_default.contains( Vector3.new( 1.0, 1.0, 0.0 )))
+    assert( !@triangle.contains?( check_point) )
+    assert( @triangle.contains?( @triangle.center) )
+    assert( @triangle.contains?( Vector3.new( 1,3,2)))
+    assert( @triangle.contains?( Vector3.new(-1,3,0)))
+    assert( @triangle_default.contains?( Vector3.new( 0.5, 0.5, 0.0 ) ))
+    assert( !@triangle_default.contains?( Vector3.new( -1.0, 2.0, 0.0 )))
+    assert( !@triangle_default.contains?( Vector3.new( 1.0, 1.0, 0.0 )))
   end
 
   def test_distance_to_point

data/test/test_util.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun

data/test/test_vector3.rb

@@ -1,3 +1,6 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
 include GMath3D
 
 MiniTest::Unit.autorun
@@ -5,7 +8,7 @@ MiniTest::Unit.autorun
 class Vector3TestCase < MiniTest::Unit::TestCase
   def setup
     @vector_init_zero = Vector3.new()
-    @vector = Vector3.new(1.0, 2.0, 3.0)
+    @vector = Vector3.new(1, 2.0, 3.0)
   end
 
   def test_initalize
@@ -18,6 +21,18 @@ class Vector3TestCase < MiniTest::Unit::TestCase
     assert_equal(3.0, @vector.z)
 
     assert_equal(Geom.default_tolerance, @vector.tolerance)
+
+    assert_raises ArgumentError do
+      invalidResult = Vector3.new( "hoge" )
+    end
+  end
+
+  def test_to_s
+    assert_equal("Vector3[1, 2.0, 3.0]", @vector.to_s)
+  end
+
+  def test_to_element_s
+    assert_equal("[1, 2.0, 3.0]", @vector.to_element_s)
   end
 
   def test_assign_value

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmath3D
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-24 00:00:00.000000000 +09:00
+date: 2011-10-09 00:00:00.000000000 +09:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2164436460 !ruby/object:Gem::Requirement
+  requirement: &2176871500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2164436460
+  version_requirements: *2176871500
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2164435040 !ruby/object:Gem::Requirement
+  requirement: &2176871020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *2164435040
+  version_requirements: *2176871020
 description: This library defines 3D geometric elements(point, line, plane etc..).
   It can get two(or more) elements relation, like distance between two elements.
 email: toshi0328@gmail.com
@@ -88,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1522515577061844315
+      hash: 3189821684836837166
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: