```module Geom
class Transformation

# Creates a new transformation object.
#   Creates a new identity transformation.
#   Creates a transformation that translates by the vector from the origin to the given point.
#   @param [Geom::Point3d] point
#   Creates a transformation that translates by the given vector.
#   @param [Geom::Vector3d, Array<Numeric>] vector
#   Creates a transformation that is a copy of the given transformation.
#   This is equivalent to {clone}.
#   @param [Geom::Transformation] transformation
#   Creates a transformation from a 16 element array that represents a
#   transformation matrix in row major ordering.
#   @param [Array<Numeric>] array
#   Creates a transformation that does uniform scaling.
#   @param [Numeric] scale
#   Creates an axis transformation where where xaxis and yaxis are arbitrarily chosen.
#   @param [Geom::Point3d, Array<Numeric>] origin
#   @param [Geom::Vector3d, Array<Numeric>] zaxis
#   Creates an axis transformation from origin, xaxis and yaxis. The zaxis
#   is set orthogonal to the given axis according to the right-hand rule.
#   @param [Geom::Point3d, Array<Numeric>] origin
#   @param [Geom::Vector3d, Array<Numeric>] xaxis
#   @param [Geom::Vector3d, Array<Numeric>] yaxis
#   Creates a transformation that rotates counter-clockwise about an axis by given angle.
#   @param [Geom::Point3d, Array<Numeric>] point
#   @param [Geom::Vector3d, Array<Numeric>] axis
#   @param [Numeric] angle  The angle in radians
# @overload initialize(xaxis, yaxis, zaxis, origin)
#   Creates a transformation from 3 axis and an origin.
#   @param [Geom::Vector3d, Array<Numeric>] xaxis
#   @param [Geom::Vector3d, Array<Numeric>] yaxis
#   @param [Geom::Vector3d, Array<Numeric>] zaxis
#   @param [Geom::Point3d] origin
def initialize(*args)
end

# Matrix multiplication
#   @param [Geom::Point3d] point
#   @param [Geom::Vector3d] vector
#   @param [Geom::Transformation] transformation
# @return [Geom::Transformation]
def *(arg)
end

# Creates a transformation from 3 axis and an origin.
# @param [Geom::Point3d, Array<Numeric>] origin
# @param [Geom::Vector3d, Array<Numeric>] xaxis
# @param [Geom::Vector3d, Array<Numeric>] yaxis
# @param [Geom::Vector3d, Array<Numeric>] zaxis
# @return [Geom::Transformation]
def self.axes(origin, xaxis, yaxis, zaxis)
end

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

# Determines if this transformation is an identity transformation, that means that applying it to a geometry
# won't modify it.
# @return [Boolean] true if this transformation is an identity transformation
# @note There is an issue that this method returns only true for transformations initialized as
#   identity, either with {Transformation.new} or from the constant Geom::Transformation::Identity
def identity?
end

# Create a new transformation that is the result of interpolating between two other transformations.
# Creates a new point as a linear combination of two points. This method is generally used to get a point at some
# percentage along a line connecting the two points. 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 point between the two points.
# @param [Numeric] weight1  The weight of point1.
# @param [Geom::Point3d, Array<Numeric>] point1
# @param [Numeric] parameter  The weight of point2.
# @param [Geom::Point3d, Array<Numeric>] point2
# @return [Geom::Point3d]
# @note This method fails to interpolate if a uniform scaling is not realized by the three diagonal matrix elements
#   but by the last matrix element. In that case, it would return the first transformation for parameter 0 and
#  otherwise the second transformation.
# @note Note transformation matrices are not suited for interpolating rotations: An rotation by 180 would "squeeze"
#   the transformed object through the rotation axis and then expand to the final state instead of rotating either
#   left way or right way.
def self.interpolate
end

# Creates a new transformation that is the inverse of this transformation.
# @return [Geom::Transformation]
def inverse
end

# Modifies this transformation to its inverse.
# @return [self]
def invert!
end

# Retrieves the origin of a transformation.
# @return [Geom::Point3d]
def origin
end

# Creates a new transformation that does a counter-clockwise rotation about an axis by given angle.
# @param [Geom::Point3d, Array<Numeric>] point  A point on the axis of rotation
# @param [Geom::Vector3d, Array<Numeric>] vector  A vector defining the direction of the axis
# @param [Numeric] angle  The angle in radians
# @return [Geom::Transformation] The new rotation transformation
def self.rotation(point, vector, angle)
end

# Creates a new transformation that does a scaling.
#   Uniform scaling about the origin.
#   @param [Numeric] scale  Uniform scaling factor for all three axes
#   Uniform scaling about a given point.
#   @param [Geom::Point3d, Array<Numeric>] point
#   @param [Numeric] scale  Uniform scaling factor for all three axes
#   Non-uniform scaling about the origin.
#   @param [Numeric] xscale  Scaling factor along the x-axis
#   @param [Numeric] yscale  Scaling factor along the y-axis
#   @param [Numeric] zscale  Scaling factor along the z-axis
#   Non-uniform scaling about a given point.
#   @param [Geom::Point3d, Array<Numeric>] point
#   @param [Numeric] xscale  Scaling factor along the x-axis
#   @param [Numeric] yscale  Scaling factor along the y-axis
#   @param [Numeric] zscale  Scaling factor along the z-axis
# @return [Geom::Transformation] The new scaling transformation
def self.scaling
end

# Sets this transformation to match another one.
#   @param [Geom::Transformation] transformation  Another transformation object
#   @param [Array<Numeric>] array  A 16 element array of a transformation matrix in row major ordering.
# @return [self]
def set!(transformation)
end

# Returns an array representation of this transformation.
# @return [Array<Float>] A 16 element array the matrix elements.
def to_a
end

# Creates a new transformation that translates by the given vector.
# @param [Geom::Vector3d, Geom::Point3d, Array<Numeric>] vector
# @return [Geom::Transformation] The new rotation transformation
def self.translation(vector)
end

#  Retrieves the x-axis of this transformation.
# @return [Geom::Vector3d]
def xaxis
end

#  Retrieves the y-axis of this transformation.
# @return [Geom::Vector3d]
def yaxis
end

#  Retrieves the z-axis of this transformation.
# @return [Geom::Vector3d]
def zaxis
end

end
end```