sketchup-api-stubs 0.1.2 → 0.2.0

data/SketchUp/Geom/PolygonMesh.rb

@@ -1,17 +1,17 @@
 # Copyright:: Copyright 2017 Trimble Inc.
 # License:: The MIT License (MIT)
 
-# The PolygonMesh class contains methods to create polygon mesh structures.
-# This is useful if you need to write a custom importer/exporter in Ruby that
-# works at the level of triangulated polygons. For example, you can determine
-# the triangles that make up a 15-sided SketchUp face by using this class, or
-# write a SketchupImporter that reads a data file, creates a mesh from it,
-# and draws faces based on the mesh.
+# The {#Geom::PolygonMesh} class contains methods to create polygon mesh
+# structures. This is useful if you need to write a custom importer/exporter in
+# Ruby that works at the level of triangulated polygons. For example, you can
+# determine the triangles that make up a 15-sided {#Sketchup::Face} by using
+# this class, or write a {#Sketchup::Importer} that reads a data file, creates
+# a mesh from it, and draws faces based on the mesh.
 #
 # You can construct a mesh manually using the methods of this class, or you
 # can get a mesh from a face by calling the Face.mesh method. See
-# Entities.add_faces_from_mesh for an easy way to convert a mesh back into
-# faces.
+# {Sketchup::Entities#add_faces_from_mesh} for an easy way to convert a mesh
+# back into faces.
 #
 # @example
 #   # Grab a mesh from a given face.
@@ -19,7 +19,7 @@
 #
 #   # Create a new group that we will populate with the mesh.
 #   group = Sketchup.active_model.entities.add_group
-#   group.add_faces_from_mesh(my_mesh)
+#   group.entities.add_faces_from_mesh(my_mesh)
 #
 # @version SketchUp 6.0
 class Geom::PolygonMesh
@@ -32,6 +32,11 @@ class Geom::PolygonMesh
   SMOOTH_SOFT_EDGES = nil # Stub value.
   SOFTEN_BASED_ON_INDEX = nil # Stub value.
 
+  MESH_NORMALS = nil # Stub value.
+  MESH_POINTS = nil # Stub value.
+  MESH_UVQ_BACK = nil # Stub value.
+  MESH_UVQ_FRONT = nil # Stub value.
+
   # Instance Methods
 
   # The {#add_point} method is used to add a point to the mesh.
@@ -272,12 +277,11 @@ class Geom::PolygonMesh
   # The {#polygon_at} method is used to retrieve an array of vertex index values
   # for a polygon at a specific index.
   #
-  # Index is 1 based (starts at 1).  The returned array can contain negative
-  # values with the sign indicating a hidden edge. For example, a return value
-  # of +[-1, 2, 3]+ indicates that the edge from +1+ to +2+ is hidden.
-  # The negative values should not be used as an index for point_at, take the
-  # positive value of the index value in the polygon array.  So if you
-  # get +[-1, 2,3]+ use +1+ as the argument to {#point_at}.
+  # values with the sign indicating a hidden edge. For example, a return value of
+  # +[-1, 2, 3]+ indicates that the edge from +1+ to +2+ is hidden. The negative
+  # values should not be used as an index for point_at, take the positive value
+  # of the index value in the polygon array.  So if you get +[-1, 2,3]+ use +1+
+  # as the argument to {#point_at}.
   #
   # @example
   #   mesh = Geom::PolygonMesh.new
@@ -287,6 +291,8 @@ class Geom::PolygonMesh
   #   index = mesh.add_polygon(point1, point2, point3)
   #   polygon = mesh.polygon_at(index)
   #
+  # @note Index is 1 based (starts at 1).The returned array can contain negative
+  #
   # @param [Integer] index
   #   The index of the desired polygon.
   #
@@ -319,14 +325,14 @@ class Geom::PolygonMesh
   # The {#polygons} method is used to retrieve an array of all polygons in the
   # mesh.
   #
-  # The returned array can contain negative values with the sign indicating a
-  # hidden edge. For example, a return value of +[-1, 2, 3]+ indicates that the
-  # edge from +1+ to +2+ is hidden.
+  # The returned array contains an array that can have a negative value with the
+  # sign indicating a hidden edge. For example, a return value of +[-1, 2, 3]+
+  # indicates that the edge from +1+ to +2+ is hidden.
   #
   # @example
   #   polygons = polygonmesh.polygons
   #
-  # @return [Array<Integer>]
+  # @return [Array<Array<Integer>>, Array<nil>]
   #
   # @version SketchUp 6.0
   def polygons
@@ -397,6 +403,9 @@ class Geom::PolygonMesh
   # @note If you don't specify how many points you will be adding to the mesh
   #   when you initiate it you may risk the UV data becoming out of sync.
   #
+  # @param [Boolean] front
+  #   A boolean representing the front or back.
+  #
   # @param [Geom::Point3d] point
   #   A Point3d object representing UV coordinates.
   #
@@ -406,7 +415,7 @@ class Geom::PolygonMesh
   # @return [nil]
   #
   # @version SketchUp 2014
-  def set_uv(index, point)
+  def set_uv(index, point, front)
   end
 
   # The {#transform!} method is used to apply a transformation to a mesh.
@@ -465,7 +474,7 @@ class Geom::PolygonMesh
   # @example
   #   # Get a mesh with front and back UVs.
   #   mesh = face.mesh(1 | 2)
-  #   uvs = mesh.uvs
+  #   uvs = mesh.uvs(true)
   #
   # @param [Boolean] front
   #

data/SketchUp/Geom/Transformation.rb

@@ -112,7 +112,8 @@ class Geom::Transformation
   #
   # @overload scaling(scale)
   #
-  #   @note This might yield an unexpected transformation. It sets the 16th value
+  #   @note This has been fixed in SketchUp 2018 but in previous versions it
+  #     might yield an unexpected transformation. It sets the 16th value
   #     to the scaling factor. Something not all extensions reading the
   #     transformation expects. Consider using +scaling(xscale, yscale, zscale)+
   #     instead.
@@ -250,9 +251,10 @@ class Geom::Transformation
   #   # Returns false.
   #   status = tr.identity?
   #
-  # @note This only looks at the flag to see if the transform has not been
-  #   modified. If the transform has been changed, this will return false even if
-  #   it is really the identity.
+  # @note As of SketchUp 2018, this now looks at the data to determine if the
+  #   transformation is identity. Prior to SU2018, this only looks at the flag to
+  #   see if the transform has not been modified. If the transform has been
+  #   changed, this will return false even if it is really the identity.
   #
   # @return [Boolean] +true+ if the transformation is the identity
   #
@@ -334,6 +336,8 @@ class Geom::Transformation
   # @overload initialize(scale)
   #
   #   Creates a transformation that does uniform scaling.
+  #   @note Versions prior to SU2018 would produce transformations which
+  #     didn't always work right in SketchUp. See {.scaling} for more info.
   #   @param [Float] scale
   #   @return [Geom::Transformation]
   #

data/SketchUp/Geom/Transformation2d.rb

@@ -0,0 +1,125 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+#
+# @version LayOut 2018
+class Geom::Transformation2d
+
+  # Instance Methods
+
+  # The {#==} method checks to see if the two {Geom::Transformation2d}s are equal.
+  # This checks whether the values of the transformations are the same.
+  #
+  # @example
+  #   tr = Geom::Transformation2d.new({1.0, 0.0, 0.0, 1.0, 1.0, 1.0})
+  #   tr == tr.clone
+  #
+  # @param [Geom::Transformation2d] other
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def ==(other)
+  end
+
+  # The {#clone} method creates a copy of the {Geom::Transformation2d}.
+  #
+  # @example
+  #   tr1 = Geom::Transformation2d.new
+  #   tr2 = tr1.clone
+  #
+  # @return [Geom::Transformation2d]
+  #
+  # @version LayOut 2018
+  def clone
+  end
+
+  # The {#identity?} method determines if the {Geom::Transformation2d} is the
+  # {IDENTITY_2D} transform.
+  #
+  # @example
+  #   tr = Geom::Transformation2d.new
+  #   # Returns true.
+  #   status = tr.identity?
+  #
+  # @example
+  #   # Returns true.
+  #   status = IDENTITY.identity?
+  #
+  # @example
+  #   array = {1.0, 0.0, 0.0, 1.0, 1.0, 0.0}
+  #   tr = Geom::Transformation2d.new(array)
+  #   # Returns false.
+  #   status = tr.identity?
+  #
+  # @return [Boolean] +true+ if the transform is the identity
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def identity?
+  end
+
+  # The {#initialize} method creates a new {Geom::Transformation2d}. You can use
+  # this method or one of the more specific methods for creating specific kinds
+  # of {Geom::Transformation2d}.
+  #
+  # @example
+  #   tr = Geom::Transformation2d.new({1.0, 0.0, 0.0, 1.0, 1.0, 1.0})
+  #
+  # @overload initialize
+  #
+  #   @return [Geom::Transformation2d] identity Transformation2d.
+  #
+  # @overload initialize(array)
+  #
+  #   @param [Array<Float>] array A 6 element Array.
+  #   @return [Geom::Transformation2d]
+  #
+  # @overload initialize(transformation)
+  #
+  #   Creates a Transformation2d that is a copy of another Transformation2d.
+  #   This is equivalent to {#clone}.
+  #   @param [Geom::Transformation2d] transform
+  #   @return [Geom::Transformation2d]
+  #
+  # @version LayOut 2018
+  def initialize(*args)
+  end
+
+  # The {#set!} method sets the {Geom::Transformation2d} to match another one.
+  # The argument is anything that can be converted into a {Geom::Transformation2d}.
+  #
+  # @example
+  #   tr1 = Geom::Transformation2d.new
+  #   array = {2.0, 0.0, 0.0, 2.0, 0.0, 0.0}
+  #   tr1.set!(array)
+  #
+  # @overload set!(transformation)
+  #
+  #   @param [Geom::Transformation2d] transformation
+  #   @return [Geom::Transformation2d]
+  #
+  # @overload set!(matrix)
+  #
+  #   @param [Array<Float>] matrix An array of 6 floats.
+  #   @return [Geom::Transformation2d]
+  #
+  # @version LayOut 2018
+  def set!(arg)
+  end
+
+  # The {#to_a} method returns a 6 element array which contains the values that
+  # define the Transformation2d.
+  #
+  # @example
+  #   tr = Geom::Transformation2d.new
+  #   tr.to_a.each_slice(2) {|a| p a}
+  #
+  # @return [Array<Float>] an array of 6 elements
+  #
+  # @version LayOut 2018
+  def to_a
+  end
+
+end

data/SketchUp/Geom/UTM.rb

@@ -3,130 +3,136 @@
 
 # The UTM class lets you work with UTM map coordinates.
 #
+# @note Valid ranges for {#zone_number} and {#zone_letter} are 1-60 and C-X
+#   (omitting I and O). Valid ranges for {#x} and {#y} are 100000-899999.
+#
 # @version SketchUp 6.0
 class Geom::UTM
 
   # Instance Methods
 
-  # The new method is used to create a new UTM coordinate. You will often create
-  # UTM objects by calling the method Model.point_to_utm instead of calling this
-  # method.
+  # The {#initialize} method is used to create a new UTM coordinate. You will
+  # often create UTM objects by calling the method {Sketchup::Model#point_to_utm}
+  # instead of calling this method.
   #
   # @example
   #   # Create a copy of an existing UTM object.
-  #   utm = Geom::UTM.new utm2
+  #   utm = Geom::UTM.new(utm2)
   #
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
+  #
+  # @overload initialize(zone_number, zone_letter, x, y)
+  #
+  #   @param [Integer] zone_number A zone number or a UTM object.
+  #   @param [String] zone_letter A zone letter.
+  #   @param [Float] x The x position.
+  #   @param [Float] y The y position.
   #
-  # @param zone_number
-  #   A zone number or a UTM object. If this first parameter
-  #   is a UTM object, then the other parameters are ignored.
+  # @overload initialize(utm)
   #
-  # @param zone_letter
-  #   A zone letter.
+  #   @param [Geom::UTM] utm A UTM object.
   #
-  # @param y
-  #   The y position.
+  # @overload initialize(array)
   #
-  # @param x
-  #   The x position.
+  #   @param [Array(Integer, String, Float, Float)] An array containing the zone
+  #     number, zone letter, x and y positions.
   #
-  # @return utm - a utm coordinate if successful
+  # @return [Geom::UTM]
   #
   # @version SketchUp 6.0
-  def initialize(zone_number, zone_letter, x, y)
+  def initialize(*args)
   end
 
-  # The to_a method returns a UTM coordinate as a 4 element array. The Array
+  # The {#to_a} method returns a UTM coordinate as a 4 element array. The Array
   # elements are the zone number, the zone letter, the x coordinate and the y
   # coordinate.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   a = utm.to_a
   #
-  # @return utm_as_array - a utm array if successful
+  # @return [Array(Integer, String, Float, Float)]
   #
   # @version SketchUp 6.0
   def to_a
   end
 
-  # The to_latlong method is used to convert UTM coordinates to latitude
+  # The {#to_latlong} method is used to convert UTM coordinates to latitude
   # and longitude. See the LatLong class for more information.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   ll = utm.to_latlong
   #
-  # @return utm_as_latlong - a LatLong object if successful
+  # @return [Geom::LatLong]
   #
   # @version SketchUp 6.0
   def to_latlong
   end
 
-  # The to_s method is used to retrieve a string representation of a UTM.
+  # The {#to_s} method is used to retrieve a string representation of a UTM.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   string = utm.to_s
   #
-  # @return utm_as_string - a utm string if successful
+  # @return [String]
   #
   # @version SketchUp 6.0
   def to_s
   end
 
-  # The x method returns the UTM x coordinate.
+  # The {#x} method returns the UTM x coordinate.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   x = utm.x
   #
-  # @return x - the UTM x coordinate
+  # @return [Float]
   #
   # @version SketchUp 6.0
   def x
   end
 
-  # The x method returns the UTM y coordinate.
+  # The {#y} method returns the UTM y coordinate.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   y = utm.y
   #
-  # @return y - the UTM y coordinate
+  # @return [Float]
   #
   # @version SketchUp 6.0
   def y
   end
 
-  # The zone_letter method returns the UTM zone letter.
+  # The {#zone_letter} method returns the UTM zone letter.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   zl = utm.zone_letter
   #
-  # @return zone_letter - the UTM zone letter
+  # @return [String]
   #
   # @version SketchUp 6.0
   def zone_letter
   end
 
-  # The zone_number method returns the UTM zone number.
+  # The {#zone_number} method returns the UTM zone number.
   #
   # @example
   #   # Create a new UTM object from scratch.
-  #   utm = Geom::UTM.new 13, "T", 475849.37521, 4429682.73749
+  #   utm = Geom::UTM.new(13, "T", 475849.37521, 4429682.73749)
   #   zn = utm.zone_number
   #
-  # @return zone_number - the UTM zone number
+  # @return [Integer]
   #
   # @version SketchUp 6.0
   def zone_number

data/SketchUp/Geom/Vector2d.rb

@@ -0,0 +1,497 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The Vector2d class represents vectors in a 2 dimensional space.
+# Vectors in LayOut have a direction and a length, but not a starting point.
+#
+# There are numerous tutorials on 2D vectors available on the internet.
+#
+# @version LayOut 2018
+class Geom::Vector2d
+
+  # Instance Methods
+
+  # The {#%} method returns the dot product between two {Geom::Vector2d}. This is
+  # an alias of the dot method.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 2)
+  #   vector2 = Geom::Vector2d.new(1, 0)
+  #   d2 = vector % vector2
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return The dot product of the vectors
+  #
+  # @version LayOut 2018
+  def %(vector)
+  end
+
+  # The {#*} method returns the cross product between two {Geom::Vector2d}. This
+  # is an alias of the cross method.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 0)
+  #   vector2 = Geom::Vector2d.new(0, 1)
+  #   cross = vector * vector
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def *(vector)
+  end
+
+  # The {#+} method adds a {Geom::Vector2d} to this one.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 2)
+  #   vector2 = Geom::Vector2d.new(1, 0)
+  #   new_vector = vector + vector2
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def +(vector)
+  end
+
+  # The {#-} method subtracts a {Geom::Vector2d} from this one.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 2)
+  #   vector2 = Geom::Vector2d.new(1, 0)
+  #   new_vector = vector - vector2
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def -(vector)
+  end
+
+  # The {#==} method returns whether two {Geom::Vector2d} are equal within
+  # tolerance.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 0)
+  #   vector2 = Geom::Vector2d.new(0,1)
+  #   # Returns false
+  #   status = vector == vector2
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def ==(vector)
+  end
+
+  # The {#[]} method returns the value of the {Geom::Vector2d} at the specified
+  # index.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   # retrieves the y value of 2
+  #   yvalue = vector[1]
+  #
+  # @param [Numeric] index
+  #   The index into an array of two coordinates.
+  #
+  # @return [Numeric] The value for the x or y coordinate.
+  #
+  # @version LayOut 2018
+  def [](index)
+  end
+
+  # The {#[]=} method sets the x or y value of the {Geom::Vector2d} based on the
+  # specific index of the value.
+  #
+  # @example
+  #   point = Geom::Vector2d.new(1,2)
+  #   point[1] = 4
+  #
+  # @param [Numeric] index
+  #   The index for a specific x or y value in the
+  #   {Geom::Vector2d} to set
+  #
+  # @param [Numeric] value
+  #   The value to set for x or y
+  #
+  # @return [Numeric] The new x or y value if successful
+  #
+  # @version LayOut 2018
+  def []=(index, value)
+  end
+
+  # The {#angle_between} method computes the angle in radians between
+  # the {Geom::Vector2d} and another {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 0)
+  #   vector2 = Geom::Vector2d.new(-1, 0)
+  #   # returns PI
+  #   angle = vector.angle_between(vector2)
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Numeric] The angle (in radians)
+  #
+  # @version LayOut 2018
+  def angle_between(vector)
+  end
+
+  # The {#clone} method makes a copy of the {Geom::Vector2d}. This method is
+  # equivalent to vec2 = Geom::Vector2d.new(vec).
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 0)
+  #   vector2 = vector.clone
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def clone
+  end
+
+  # The {#*} method returns the cross product between two {Geom::Vector2d}. This
+  # is an alias of the cross method.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 0)
+  #   vector2 = Geom::Vector2d.new(0, 1)
+  #   cross = vector * vector
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def cross(vector)
+  end
+
+  # The {#%} method returns the dot product between two {Geom::Vector2d}. This is
+  # an alias of the dot method.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 2)
+  #   vector2 = Geom::Vector2d.new(1, 0)
+  #   d2 = vector % vector2
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return The dot product of the vectors
+  #
+  # @version LayOut 2018
+  def dot(vector)
+  end
+
+  # The {.new} method creates a new {Geom::Vector2d}.
+  #
+  # @example
+  #   # A vector that runs along the X axis.
+  #   vector = Geom::Vector2d.new(1, 0)
+  #
+  # @overload initialize
+  #
+  #   @return [Geom::Vector2d]
+  #
+  # @overload initialize(vector)
+  #
+  #   @param [Geom::Vector2d, Array(Numeric, Numeric)] vector
+  #   @return [Geom::Vector2d]
+  #
+  # @overload initialize(x, y)
+  #
+  #   @param [Numeric] x The length in the x direction
+  #   @param [Numeric] y The length in the y direction
+  #   @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def initialize(*args)
+  end
+
+  # The {#inspect} method formats the {Geom::Vector2d} as a string.
+  #
+  # @example
+  #   point = Geom::Point2d.new(1, 2)
+  #   string = point.inspect
+  #
+  # @return [String] the string representation of the {Geom::Vector2d}
+  #
+  # @version LayOut 2018
+  def inspect
+  end
+
+  # The {#length} method returns the length of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 4)
+  #   # returns 4
+  #   l = vector.length
+  #
+  # @return [Numeric] The length of the {Geom::Vector2d}
+  #
+  # @version LayOut 2018
+  def length
+  end
+
+  # The {#length=} method sets the length of the {Geom::Vector2d}. The new length
+  # must be greater than 0.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 4)
+  #   l = vector.length
+  #   vector.length = 2
+  #
+  # @param [Numeric] length
+  #   The new length for the {Geom::Vector2d}
+  #
+  # @return [Numeric] The new length
+  #
+  # @version LayOut 2018
+  def length=(length)
+  end
+
+  # The {#normalize} method returns a {Geom::Vector2d} that is a unit vector
+  # of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 4)
+  #   # returns a new Vector2d(0, 1)
+  #   vector2 = vector.normalize
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def normalize
+  end
+
+  # The {#normalize!} method converts a {Geom::Vector2d} vector into a unit
+  # vector. Another way to do this is vector.length = 1
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 4)
+  #   # modifies vector to be the Vector2d(0, 1)
+  #   vector.normalize!
+  #
+  # @version LayOut 2018
+  def normalize!
+  end
+
+  # The {#parallel?} method determines if the {Geom::Vector2d} is parallel to
+  # another {Geom::Vector2d} to within tolerance.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 1)
+  #   vector2 = Geom::Vector2d.new(1, 2)
+  #   # returns true
+  #   status = vector.parallel?(vector2)
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Boolean]
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def parallel?(vector)
+  end
+
+  # The {#perpendicular?} method determines if the {Geom::Vector2d} is
+  # perpendicular to another {Geom::Vector2d} to within tolerance.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 1)
+  #   vector2 = Geom::Vector2d.new(1, 2)
+  #   # returns false
+  #   status = vector.perpendicular?(vector2)
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Boolean]
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def perpendicular?(vector)
+  end
+
+  # The {#reverse} method returns a new {Geom::Vector2d} that is the reverse of
+  # the {Geom::Vector2d}, leaving the original unchanged.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   # returns the Vector2d(-1, -2)
+  #   vector2 = vector.reverse
+  #
+  # @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def reverse
+  end
+
+  # The {#reverse!} method reverses the {Geom::Vector2d} in place.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   # modifies vector to be the Vector2d(-1, -2)
+  #   vector.reverse!
+  #
+  # @version LayOut 2018
+  def reverse!
+  end
+
+  # The {#same_direction?} method determines if the {Geom::Vector2d} is parallel
+  # to and in the same direction as another {Geom::Vector2d} within tolerance.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 1)
+  #   vector2 = Geom::Vector2d.new(1, 2)
+  #   # returns true
+  #   status = vector.sime_direction?(vector2)
+  #
+  # @param [Geom::Vector2d] vector
+  #
+  # @return [Boolean]
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def same_direction?(vector)
+  end
+
+  # The {#set!} method sets the values of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   vector = vector.set!([4, 5])
+  #
+  # @overload set!(vector)
+  #
+  #   @param [Geom::Vector2d, Array(Numeric, Numeric)] vector
+  #   @return [Geom::Vector2d]
+  #
+  # @overload set!(x, y)
+  #
+  #   @param [Numeric] x
+  #   @param [Numeric] y
+  #   @return [Geom::Vector2d]
+  #
+  # @version LayOut 2018
+  def set!(*args)
+  end
+
+  # The {#to_a} method retrieves the coordinates of the {Geom::Vector2d} in an
+  # Array.
+  #
+  # @example
+  #   a = vector.to_a
+  #
+  # @return [Array(Numeric, Numeric)]
+  #
+  # @version LayOut 2018
+  def to_a
+  end
+
+  # The {#to_s} method returns a string representation of the {Geom::Vector2d}.
+  #
+  # @example
+  #   point = Geom::Vector2d.new(1, 2)
+  #   str = point.to_s
+  #
+  # @return [String] the string representation of the {Geom::Vector2d}
+  #
+  # @version LayOut 2018
+  def to_s
+  end
+
+  # The {#unit_vector?} method returns whether the {Geom::Vector2d} is a unit
+  # vector. This is equivalent to vector.length == 1.0
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 0)
+  #   # returns true
+  #   status = vector.unit_vector
+  #
+  # @return [Boolean]
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def unit_vector?
+  end
+
+  # The {#valid?} method verifies if a {Geom::Vector2d} is valid. A
+  # {Geom::Vector2d} is valid if its length is not zero.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(0, 4)
+  #   status = vector.valid
+  #
+  # @return [Boolean]
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def valid?
+  end
+
+  # The {#x} method retrieves the x value of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   x = vector.x
+  #
+  # @return [Numeric]
+  #
+  # @version LayOut 2018
+  def x
+  end
+
+  # The {#x=} method sets the x coordinate of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   vector.x = 7
+  #
+  # @param [Numeric] x
+  #   The desired x value of the {Geom::Vector2d}
+  #
+  # @return [Numeric] The new x value of the {Geom::Vector2d}
+  #
+  # @version LayOut 2018
+  def x=(x)
+  end
+
+  # The {#y} method retrieves the y value of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   y = vector.y
+  #
+  # @return [Numeric]
+  #
+  # @version LayOut 2018
+  def y
+  end
+
+  # The {#y=} method sets the y coordinate of the {Geom::Vector2d}.
+  #
+  # @example
+  #   vector = Geom::Vector2d.new(1, 2)
+  #   vector.y = 7
+  #
+  # @param [Numeric] y
+  #   The desired y value of the {Geom::Vector2d}
+  #
+  # @return [Numeric] The new y value of the {Geom::Vector2d}
+  #
+  # @version LayOut 2018
+  def y=(y)
+  end
+
+end