```module Geom
class Vector3d

# Creates a new 3D vector.
#   Creates a vector with all coordinates set to zero. Note that such a zero-length vector is not valid.
#   @param [Geom::Vector3d] vector  another vector
#   @param [Array<Numeric>] array  an array of two or three coordinates
#   @param [Numeric] x  the x coordinate
#   @param [Numeric] y  the y coordinate
#   @param [Numeric] z  the z coordinate
def initialize(*args)
end

# Dot product.
# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Float]
def %(vector)
end

# Computes the cross product between 2 Vectors.
# The cross product of two vectors produces a third vector which is perpendicular to the plane in which the first
# two lie.
# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Geom::Vector3d]
def *(vector)
end

# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Geom::Vector3d]
def +(vector)
end

# Vector subtraction
# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Geom::Vector3d]
def -(vector)
end

# Compare two vectors coordinate by coordinate. First the x coordinates are compared, if they are equal, the y
# coordinates are compared, if those are equal finally the z coordinates.
# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Boolean] true if this vector's x, y or z coordinate is less
# @example
#   v1 = Geom::Vector3d.new(10, 10, 90)
#   v2 = Geom::Vector3d.new(10, 20, 20)
#   v1 < v2 # ==> true
def <(vector)
end

# Compare {Vector3d}s using SketchUp tolerance.
# @params [Geom::Vector3d,Array<Numeric>] vector
# @return [Boolean]
def ==(vector)
end

# Retrieves the coordinate of the vector at the specified index.
# @param [Integer] index  The index 0, 1 or 2 for a specific x, y, or z value within the vector.
# @return [Numeric] The coordinate at the specified index.
# @raise IndexError Raised if the index is outside the range [0,2]. Note that negative indices [-3,-1] don't raise.
def [](index)
end

# Retrieves the coordinate of the vector at the specified index.
# @param [Integer] index  The index 0, 1 or 2 for a specific x, y, or z value within the vector.
# @param [Numeric] value  The new x, y or z value.
# @return [Numeric] The argument passed for the new value.
# @raise IndexError  Raised if the index is outside the range [0,2]. Note that negative indices [-3,-1] don't raise.
def []=(index, value)
end

# Compute the angle between this vector and another vector.
# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Float] The smallest angle between the vectors in radians.
def angle_between(vector)
end

# Compute an arbitrary set of orthogonal axes with this vector as the z-axis direction. If possible, the vector's
# x-axis is the up vector, being in plane with the global z-axis.
# @return [Array(Geom::Vector3d,Geom::Vector3d,Geom::Vector3d)] An array of normalized vectors for the x-axis,
#   y-axis and z-axis.
def axes
end

# Creates another vector identical to the vector being cloned.
# @return [Geom::Vector3d] A new vector that is a copy of this one.
def clone
end

# Computes the cross product between another vector.
# The cross product of two vectors produces a third vector which is perpendicular to the plane in which the first
# two lie.
# @param [Geom::Vector3d,Array<Numeric>] vector
# @return [Geom::Vector3d]
def cross(vector)
end

# Compute the dot product between another vector.
def dot(vector)
end

# Returns a string containing a human-readable representation of this vector.
# @return [String] A string representation of the vector
def inspect
end

# Retrieves the length of this vector.
# @return [Length]
def length
end

# Sets length of this vector.
# @param [Numeric] value  The new length.
# @return [Numeric] The argument passed for the new value.
def length=(value)
end

# Creates a new vector as a linear combination of two vectors. This method is generally used to get a vector at some
# percentage along a line connecting the two vectors. The weights should sum up to 1 if you want to get a on that
# line. The weights should be between 0 and 1 if you want to get a vector between the two vectors.
# @param [Numeric] weight1  The weight of vector1.
# @param [Geom::Vector3d,Array<Numeric>] vector1
# @param [Numeric] weight2  The weight of vector2.
# @param [Geom::Vector3d,Array<Numeric>] vector2
# @return [Geom::Vector3d]
def self.linear_combination(weight1, vector1, weight2, vector2)
end

# Creates a copy of this vector that is a unit vector, that means its length is 1.
# @return [Geom::Vector3d] The new normalized vector.
def normalize
end

# Modifies this vector into a unit vector, that means this vector's length becomes 1.
# @return [self]
def normalize!
end

# Determines whether this vector is parallel to another vector within tolerance.
# The vectors may have different length and be reversed but would still be parallel.
# @param [Geom::Vector3d,<Array<Numeric>] vector another vector
# @return [Boolean]
def parallel?(vector)
end

# Determines whether this vector is perpendicular to another vector within tolerance.
# @param [Geom::Vector3d,<Array<Numeric>] vector another vector
# @return [Boolean]
def perpendicular?(vector)
end

# Creates a copy of this vector in the opposite direction of same length.
# @return [Geom::Vector3d] The new vector
def reverse
end

# Turns this vector in the opposite direction. This is the same as multiplying its length with -1.
# @return [self]
def reverse!
end

# Determines if this vector is parallel to and in the same direction as another vector to within tolerance.
# @param [Geom::Vector3d,<Array<Numeric>] vector another vector
# @return [Boolean] true if this vector and vector are in the same direction, false if they are not in the same direction
def samedirection?(vector)
end

# Sets the values of this vector.
# @param [Numeric] x  The location along the x axis.
# @param [Numeric] y  The location along the y axis. If not given, this coordinate is not modified.
# @param [Numeric] z  The location along the z axis. If not given, this coordinate is not modified.
# @return [self]
def set!(x, y=self.x, z=self.y)
end

# Returns an array representation of this vector.
# @return [Array(Length,Length,Length)] An array containing its x, y, z coordinates
def to_a
end

# Returns a string representation of this vector.
# @return [String] A string of this vector in the current model units, using the user's locale's decimal delimiter.
def to_s
end

# Applies a transformation to a copy this vector to create a new vector.
# @param [Geom::Transformation] transformation  A Transformation object.
# @return [Geom::Vector3d] The new vector
def transform(transformation)
end

# Applies a transformation to this vector.
# Unlike the {#transform} method, the vector itself is modified.
# @param [Geom::Transformation] transformation  A Transformation object.
# @return [self]
def transform!(transformation)
end

# Determines if this vector is a unit vector, that means if its length is 1.0.
# @return [Boolean] true if the vector is a unit vector, false if it is not a unit vector.
def unitvector?
end

# Verifies if this vector is valid. A vector is valid if its length is not zero.
# @return [Boolean] true if the vector is valid, false if it is not valid
def valid?
end

# Retrieves the x coordinate of this vector.
# @return [Float]
def x
end

# Sets the x value of this vector.
# @param [Numeric] value  The new x coordinate.
# @return [Numeric] The argument passed for the new value.
def x=(value)
end

# Retrieves the y coordinate of this vector.
# @return [Float]
def y
end

# Sets the y value of this vector.
# @param [Numeric] value  The new y coordinate.
# @return [Numeric] The argument passed for the new value.
def y=(value)
end

# Retrieves the z  coordinate of this vector.
# @return [Float]
def z
end

# Sets the z value of this vector.
# @param [Numeric] value  The new z coordinate.
# @return [Numeric] The argument passed for the new value.
def z=(value)
end

end
end # module Geom```