unit_quaternion 0.0.2

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+#*
+other/*
+Gemfile.lock
+pkg/*
+coverage

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unit_quaternion.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2016, Cory Crean
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * The name(s) of the author(s) may not be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CORY CREAN BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,103 @@
+# Quaternion
+
+This package provides a Quaternion class, along with a UnitQuaternion
+class that is designed to be used to represent rotations.
+
+## Installation
+
+This package is not available through any gem repository (yet).
+Install it using:
+
+$ sudo rake install
+
+## Usage
+
+To use the Quaternion and UnitQuaternion classes in your program,
+include the following line:
+
+require 'unit_quaternion'
+
+You can perform basic quaternion operations, such as addition and multiplication:
+
+q1 = Quaternion.new(1,2,3,4)
+=> (1, Vector[2, 3, 4])
+
+q2 = Quaternion.new(4,3,2,1)
+=> (4, Vector[3, 2, 1])
+
+q1 + q2
+=> (5, Vector[5, 5, 5])
+
+q1 * q2
+=> (-12, Vector[6, 24, 12])
+
+You can use the UnitQuaternion class to represent spatial rotations.
+The following represents a rotation of PI/2 radians about the x-axis:
+
+qx = UnitQuaternion.fromAngleAxis(Math::PI/2, Vector[1, 0, 0])
+=> (0.7071067811865476, Vector[0.7071067811865475, 0.0, 0.0])
+
+The following represents a rotation of PI/2 radians about the y-axis:
+
+qy = UnitQuaternion.fromAngleAxis(Math::PI/2, Vector[0, 1, 0])
+=> (0.7071067811865476, Vector[0.0, 0.7071067811865475, 0.0])
+
+You can use quaternion multiplication to compose rotations.  If we
+want to find the quaternion describing a rotation about the body-fixed
+x-axis, followed by a rotation about the body-fixed y-axis, we would
+do the following:
+
+q = qx * qy
+=> (0.5000000000000001, Vector[0.5, 0.5, 0.4999999999999999])
+
+Notice that this is the same as:
+
+q = UnitQuaternion.fromEuler(Math::PI/2, Math::PI/2, 0, 'xyz')
+=> (0.5000000000000001, Vector[0.5, 0.5, 0.4999999999999999])
+
+If we want to find the quaternion describing a rotation the inertial
+x-axis, followed by a rotation about the inertial y-axis, we would do
+the following:
+
+q = qy * qx
+=> (0.5000000000000001, Vector[0.5, 0.5, -0.4999999999999999])
+
+Notice that this is the same as:
+
+q = UnitQuaternion.fromEuler(Math::PI/2, Math::PI/2, 0, 'XYZ')
+=> (0.5000000000000001, Vector[0.5, 0.5, -0.4999999999999999])
+
+Additionally, you can use the method fromRotationMatrix to set the
+values of the quaternion from an orthonormal 3x3 matrix.  Finally, you
+can use the methods getAngleAxis, getEuler, and getRotationMatrix to
+find any of the corresponding representations of a spatial rotation
+from a given quaternion.
+
+The transform method takes a vector as an argument and returns the
+result of rotating that vector through the rotation described by the
+quaternion.  For example:
+
+q = UnitQuaternion.fromAngleAxis(Math::PI/2, Vector[0, 0, 1])
+=> (0.7071067811865476, Vector[0.0, 0.0, 0.7071067811865475])
+
+v = Vector[1, 0, 0]
+=> Vector[1, 0, 0]
+
+q.transform(v)
+=> Vector[2.220446049250313e-16, 1.0, 0.0]
+
+gives the result of rotating the vector (1, 0, 0) through PI/2 radians
+about the z-axis.
+
+The inverse method returns the inverse of a given Quaternion.  If we
+have a UnitQuaternion q representing a rotation of theta radians about
+the axis n, then q.inverse() represents a rotation of -theta about n
+or, equivalently, a rotation of theta about -n.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+task :test do
+     ruby "tests/tests.rb"
+end

data/lib/quaternion.rb

@@ -0,0 +1,127 @@
+# Author:: Cory Crean (mailto:cory.crean@gmail.com)
+# Copyright:: Copyright (c) 2016 Cory Crean
+# License:: BSD
+#
+# A basic quaternion class, which implements standard operations such
+# as addition, subtraction, multiplication, scalar division,
+# inversion, conjugation, etc.
+
+require 'matrix'
+
+class Quaternion
+
+  # Create new quaternion from 4 values.  If no arguments are
+  # provided, creates the zero quaternion.
+  def initialize(*args)
+    if args.length() == 4
+      set(*args)
+    elsif args.length() == 0
+      set(0, 0, 0, 0)
+    else
+      raise(ArgumentError, "wrong number of arguments (must be 0 or 4)")
+    end
+  end
+
+  # Set the quaternion's values.
+  # 
+  # Params:
+  # +w+:: the real part of the quaterion
+  # +x+:: the i-component
+  # +y+:: the j-component
+  # +z+:: the k-component
+  def set(w, x, y, z)
+    @beta0 = w
+    @beta_s = Vector[x,y,z]
+  end
+
+  # Returns the quaternion's values as a scalar and a vector.
+  def get
+    return @beta0, @beta_s
+  end
+
+  # Returns the magnitude of the quaternion
+  def norm
+    return Math.sqrt(@beta0**2 + @beta_s.norm()**2)
+  end
+
+  # Returns the conjugate of the quaternion
+  def conjugate
+    return Quaternion.new(@beta0, *(-1*@beta_s))
+  end
+
+  # Returns the multiplicative inverse of the quaterion
+  def inverse
+    return self.conjugate() / self.norm() ** 2
+  end
+
+  # Returns a normalized quaternion.  q.normalized() is equivalent to
+  # q/q.norm()
+  def normalized
+    return self / norm()
+  end
+
+  # Returns the sum of two quaternions
+  def +(q)
+    beta0, beta_s = q.get()
+    return Quaternion.new(@beta0 + beta0, *(@beta_s + beta_s))
+  end
+
+  # Returns the difference of two quaternions
+  def -(q)
+    beta0, beta_s = q.get()
+    return Quaternion.new(@beta0 - beta0, *(@beta_s - beta_s))
+  end
+
+  # Returns the additive inverse of the quaternion
+  def -@
+    Quaternion.new(-@beta0, -@beta_s[0], -@beta_s[1], -@beta_s[2])
+  end
+
+  # Returns the result of dividing the quaternion by a scalar
+  def /(s)
+    return Quaternion.new(@beta0 / s, *(@beta_s / s))
+  end
+
+  # Returns the result of multiplying the quaternion by a scalar or
+  # another quaternion
+  def *(q)
+    if q.is_a?(Numeric)
+      return Quaternion.new(@beta0 * q, *(@beta_s * q))
+    elsif q.is_a?(Quaternion)
+      q_beta0, q_beta_s = q.get()
+      beta0 = @beta0 * q_beta0 - @beta_s.inner_product(q_beta_s)
+      beta_s =  @beta0 * q_beta_s + q_beta0 * @beta_s +
+        cross_product(@beta_s, q_beta_s)
+      result = self.class.new(beta0, *beta_s)
+      return result
+    end
+  end
+
+  # Returns true if two quaternions are equal (meaning that their
+  # corresponding entries are equal to each other) and false otherwise
+  def ==(q)
+    if get() == q.get()
+      return true
+    else
+      return false
+    end
+  end
+
+  # Returns the string representation of the quaternion
+  def to_s
+    return "(" + @beta0.to_s + ", " + @beta_s.to_s + ")"
+  end
+
+  def coerce(other)
+    return self, other
+  end
+
+  private
+  def cross_product(v1, v2)
+    # returns the cross product of vectors v1 and v2
+    return Vector[ v1[1]*v2[2] - v1[2]*v2[1],
+                   v1[2]*v2[0] - v1[0]*v2[2],
+                   v1[0]*v2[1] - v1[1]*v2[0] ]
+  end
+
+end

data/lib/unit_quaternion/version.rb

@@ -0,0 +1,3 @@
+module Quaternion
+  VERSION = "0.0.2"
+end

data/lib/unit_quaternion.rb

@@ -0,0 +1,413 @@
+# Author:: Cory Crean (mailto:cory.crean@gmail.com)
+# Copyright:: Copyright (c) 2016 Cory Crean
+# License:: BSD
+#
+# A unit quaternion class, designed to represent spatial rotations.
+# Can convert between common representations of spatial rotations,
+# such as angle-axis, Euler angles, and rotation matrices.
+
+require 'matrix'
+require_relative 'quaternion'
+
+class UnitQuaternion < Quaternion
+
+  # Creates a new UnitQuaternion from 4 values.  If the resulting
+  # quaternion does not have magnitude 1, it will be normalized.  If
+  # no arguments are provided, creates the quaternion (1, 0, 0, 0).
+  def initialize(*args)
+    if args.length() == 4
+      set(*args)
+    elsif args.length() == 0
+      super(1, 0, 0, 0)
+    else
+      raise(ArgumentError, "wrong number of arguments (must be 0 or 4)")
+    end
+  end
+
+  # Initializes a quaternion from the angle-axis representation of a
+  # rotation.  The sense of the rotation is determined according to
+  # the right-hand rule.
+  # 
+  # Params:
+  # +angle+:: A scalar representing the angle of the rotation (in radians)
+  # +axis+:: A vector representing the axis of rotation (need not be a unit vector)
+  def self.fromAngleAxis(angle, axis)
+    # intializes a quaternion from the angle-axis representation of a
+    # rotation
+    q = UnitQuaternion.new()
+    q.setAngleAxis(angle, axis)
+    return q
+  end
+
+  # Initializes a quaternion from a set of 3 Euler angles.
+  # 
+  # Params:
+  # +theta1+:: The angle of rotation about the first axis
+  # +theta2+:: The angle of rotation about the second axis
+  # +theta3+:: The angle of rotation about the third axis
+  # +axes+:: A string of 3 letters ('X/x', 'Y/y', or 'Z/z') representing the three axes of rotation.  Must be all uppercase or all lowercase.  If the string is uppercase, the rotations are performed about the inertial axes.  If the string is lowercase, the rotations are performed about the body-fixed axes.  Repeated axes are allowed, but not in succession (for example, 'xyx' is fine, but 'xxy' is not allowed).
+  def self.fromEuler(theta1, theta2, theta3, axes)
+    q = UnitQuaternion.new()
+    q.setEuler(theta1, theta2, theta3, axes)
+    return q
+  end
+
+  # Initializes a quaternion from a rotation matrix
+  # 
+  # Params:
+  # +mat+:: A 3x3 orthonormal matrix.
+  def self.fromRotationMatrix(mat)
+    q = UnitQuaternion.new()
+    q.setRotationMatrix(mat)
+    return q
+  end
+
+  # Set the quaternion's values.  If the 4 arguments do not form an
+  # unit quaternion, the resulting quaternion is normalized.
+  # 
+  # Params:
+  # +w+:: the real part of the quaterion
+  # +x+:: the i-component
+  # +y+:: the j-component
+  # +z+:: the k-component
+  def set(w, x, y, z)
+    # sets the values of the quaternion
+    super(w, x, y, z)
+    @beta0, @beta_s = normalized().get()
+  end
+
+  # Sets the values of the quaternion from the angle-axis
+  # representation of a rotation.  The sense of the rotation is
+  # determined according to the right-hand rule.
+  # 
+  # Params:
+  # +angle+:: A scalar representing the angle of the rotation (in radians)
+  # +axis+:: A vector representing the axis of rotation (need not be a unit vector)
+  def setAngleAxis(angle, axis)
+    # sets the quaternion based on the angle-axis representation of a
+    # rotation
+    if axis == Vector[0,0,0]
+      raise(ArgumentError, "Axis must not be the zero vector")
+    end
+    if axis.size() != 3
+      raise(ArgumentError, "Axis must be a 3-dimensional vector")
+    end
+    axis = axis.normalize()
+    @beta0 = Math.cos(angle / 2.0)
+    beta1 = axis[0] * Math.sin(angle / 2.0)
+    beta2 = axis[1] * Math.sin(angle / 2.0)
+    beta3 = axis[2] * Math.sin(angle / 2.0)
+    @beta_s = Vector[beta1, beta2, beta3]
+  end
+
+  # Returns the angle-axis representation of the rotation represented
+  # by the quaternion.
+  # 
+  # Returns:
+  # +angle+:: A scalar representing the angle of rotation (in radians)
+  # +axis+:: A unit vector representing the axis of rotation
+  def getAngleAxis
+    # return the angle-axis representation of the rotation contained in
+    # this quaternion
+    angle = 2*Math.acos(@beta0)
+    
+    # if sin(theta/2) = 0, then theta = 2*n*PI, where n is any integer,
+    # which means that the object has performed a complete rotation, and
+    # any axis will do
+    if Math.sin(angle/2).abs() < 1e-15
+      axis = Vector[1, 0, 0]
+    else
+      axis = @beta_s / Math.sin(angle/2)
+    end
+    return angle, axis
+  end
+
+  # Sets the values of the quaternion from a set of 3 Euler angles.
+  # 
+  # Params:
+  # +theta1+:: The angle of rotation about the first axis
+  # +theta2+:: The angle of rotation about the second axis
+  # +theta3+:: The angle of rotation about the third axis
+  # +axes+:: A string of 3 letters ('X/x', 'Y/y', or 'Z/z') representing the three axes of rotation.  Must be all uppercase or all lowercase.  If the string is uppercase, the rotations are performed about the inertial axes.  If the string is lowercase, the rotations are performed about the body-fixed axes.  Repeated axes are allowed, but not in succession (for example, 'xyx' is fine, but 'xxy' is not allowed).
+  def setEuler(theta1, theta2, theta3, axes)
+    if axes.length() != 3
+      raise(ArgumentError, "Must specify exactly 3 axes")
+    end
+    quats = Array.new(3)
+    theta = [theta1, theta2, theta3]
+    for i in 0..2
+      if axes.upcase()[i] == 'X'
+        quats[i] = UnitQuaternion.fromAngleAxis(theta[i], Vector[1, 0, 0])
+      elsif axes.upcase()[i] == 'Y'
+        quats[i] = UnitQuaternion.fromAngleAxis(theta[i], Vector[0, 1, 0])
+      elsif axes.upcase()[i] == 'Z'
+        quats[i] = UnitQuaternion.fromAngleAxis(theta[i], Vector[0, 0, 1])
+      else
+        raise(ArgumentError, "Axes can only be X/x, Y/y, or Z/z")
+      end
+    end
+    if axes == axes.upcase()
+      @beta0, @beta_s = (quats[2] * quats[1] * quats[0]).get()
+    elsif axes == axes.downcase()
+      @beta0, @beta_s = (quats[0] * quats[1] * quats[2]).get()
+    else
+      raise(ArgumentError, "Axes must be either all uppercase or all " +
+            "lowercase")
+    end
+  end
+
+  # Returns the Euler angles corresponding to this quaternion.
+  # 
+  # Params:
+  # +axes+:: A string of 3 letters ('X/x', 'Y/y', or 'Z/z') representing the three axes of rotation.  Must be all uppercase or all lowercase.  If the string is uppercase, the rotations are performed about the inertial axes.  If the string is lowercase, the rotations are performed about the body-fixed axes.  Repeated axes are allowed, but not in succession (for example, 'xyx' is fine, but 'xxy' is not allowed).
+  # 
+  # Returns:
+  # +theta1+:: The angle of rotation about the first axis
+  # +theta2+:: The angle of rotation about the second axis
+  # +theta3+:: The angle of rotation about the third axis
+  def getEuler(axes)
+    # Returns the Euler angles about the specified axes.  The axes should
+    # be specified as a string, and can be any permutation (with
+    # replacement) of 'X', 'Y', and 'Z', as long as no letter is adjacent
+    # to itself (for example, 'XYX' is valid, but 'XXY' is not).
+    # If the axes are uppercase, this function returns the angles about
+    # the global axes.  If they are lowercase, this function returns the
+    # angles about the body-fixed axes.
+    #
+    # This method implements Shoemake's algorithm for finding the Euler
+    # angles from a rotation matrix, found in Graphics Gems IV (pg. 222).
+
+    if axes.length() != 3
+      raise(ArgumentError, "Exactly 3 axes must be specified in order to " +
+            "calculate the Euler angles")
+    end
+
+    if axes == axes.upcase()
+      # get angles about global axes
+      static = true
+    elsif axes == axes.downcase()
+      # get angles about body-fixes axes
+      static = false
+      axes = axes.reverse()
+    else
+      raise(ArgumentError, "Axes must either be all uppercase or all " +
+            "lowercase")
+    end
+
+    axes = axes.upcase()
+    if axes[0] == axes[2]
+      same = true
+    end
+
+    if not ('XYZ'.include?(axes[0]) and 'XYZ'.include?(axes[1]) and
+            'XYZ'.include?(axes[2]) )
+      raise(ArgumentError, 'Axes can only be X/x, Y/y, or Z/z')
+    end
+
+    if axes.include?('XX') or axes.include?('YY') or
+        axes.include?('ZZ')
+      raise(ArgumentError, "Cannot rotate about the same axis twice in " +
+            "succession")
+    end
+
+    # true if the axes specify a right-handed coordinate system, false
+    # otherwise
+    rh = isRightHanded(axes.upcase())
+
+    p_mat_rows = Array.new()
+    unused = [ 'X', 'Y', 'Z' ]
+    axes[0..1].each_char() do |a|
+      if a == 'X'
+        p_mat_rows << getUnitVector(a)
+      elsif a == 'Y'
+        p_mat_rows << getUnitVector(a)
+      elsif a == 'Z'
+        p_mat_rows << getUnitVector(a)
+      end
+      unused.delete(a)
+    end
+    p_mat_rows << getUnitVector(unused[0])
+    
+    p_mat = Matrix.rows(p_mat_rows)
+    rot_mat = p_mat * getRotationMatrix() * p_mat.transpose()
+
+    theta1, theta2, theta3 = parseMatrix(rot_mat, same)
+
+    if not static
+      theta1, theta3 = theta3, theta1
+    end
+
+    if not rh
+      theta1, theta2, theta3 = -theta1, -theta2, -theta3
+    end
+
+    return theta1, theta2, theta3
+  end
+
+  # Sets the values of the quaternion from a rotation matrix
+  # 
+  # Params:
+  # +mat+:: A 3x3 orthonormal matrix.
+  def setRotationMatrix(mat)
+    if mat.row_size() != 3 or mat.column_size() != 3
+      raise(ArgumentError, "Rotation matrix must be 3x3")
+    end
+    tol = 1e-15
+    if not isOrthonormalMatrix(mat, tol)
+      raise(ArgumentError, "Matrix is not orthonormal (to within " +
+            tol.to_s(), ")")
+    end
+    theta1, theta2, theta3 = parseMatrix(mat, false)
+    setEuler(theta1, theta2, theta3, 'XYZ')
+  end
+
+  # Returns the rotation matrix corresponding to this quaternion.
+  def getRotationMatrix
+    # returns the rotation matrix corresponding to this quaternion
+    return Matrix[ [ @beta0**2 + @beta_s[0]**2 - @beta_s[1]**2 - @beta_s[2]**2,
+                     2*(@beta_s[0]*@beta_s[1] - @beta0*@beta_s[2]),
+                     2*(@beta_s[0]*@beta_s[2] + @beta0*@beta_s[1]) ],
+                   [ 2*(@beta_s[0]*@beta_s[1] + @beta0*@beta_s[2]),
+                     @beta0**2 - @beta_s[0]**2 + @beta_s[1]**2 - @beta_s[2]**2,
+                     2*(@beta_s[1]*@beta_s[2] - @beta0*@beta_s[0]) ],
+                   [ 2*(@beta_s[0]*@beta_s[2] - @beta0*@beta_s[1]),
+                     2*(@beta0*@beta_s[0] + @beta_s[1]*@beta_s[2]),
+                     @beta0**2 - @beta_s[0]**2 - @beta_s[1]**2 + @beta_s[2]**2 ] ]
+  end
+
+  # Transforms a vector by applying to it the rotation represented by
+  # this quaternion, and returns the result.
+  # 
+  # Params:
+  # +vec+:: A 3-D vector in the unrotated frame.
+  def transform(vec)
+    return getRotationMatrix() * vec
+  end
+
+  # Returns the inverse of the quaternion
+  def inverse
+    result = UnitQuaternion.new
+    result.set(@beta0, *(-1*@beta_s))
+    return result
+  end
+
+  private
+  def isRightHanded(axes)
+    if axes.length() != 3
+      raise(ArgumentError, "Only 3 axes permitted")
+    end
+    axes == axes.upcase()
+    if axes[0..1] == "XY" or axes[0..1] == "YZ" or axes[0..1] == "ZX"
+      return true
+    else
+      return false
+    end
+  end
+
+  def getUnitVector(axis)
+    axis = axis.upcase()
+    if axis == 'X'
+      return Vector[1, 0, 0]
+    elsif axis == 'Y'
+      return Vector[0, 1, 0]
+    elsif axis == 'Z'
+      return Vector[0, 0, 1]
+    else
+      raise(ArgumentError, "Axis can only be X/x, Y/y, or Z/z")
+    end
+  end
+
+  def parseMatrix(rot_mat, same)
+    # Extracts the Euler angles corresponding to the given matrix.  If
+    # same = false, this method returns the angles about the global X,
+    # Y, and Z axes (in that order).  If same = true, this method
+    # returns the Euler angles about the global X, Y, and X axes (in
+    # that order).
+    tol = 1e-15
+    if same
+      # print("rot_mat = ", rot_mat, "\n")
+      begin
+        theta2 = Math.acos(rot_mat[0,0])
+      rescue Math::DomainError
+        # the value of rot_mat[0,0] may be off slightly due to truncation
+        # error
+        if rot_mat[0,0] > 0
+          theta2 = 0
+        else
+          theta2 = Math::PI
+        end
+      end
+      if Math.sin(theta2).abs() < Math.sqrt(tol)
+        # if sin(theta2) is 0, then the first and third axes are
+        # either parallel or antiparallel, so we can only find the sum
+        # theta3 + theta1, not the individual angles.  Here, we choose
+        # theta3 = 0 and solve for theta1.
+        theta3 = 0
+        y = rot_mat[2,1]
+        x = rot_mat[1,1]
+        sign = Math.cos(theta2) <=> 0
+        theta1 = Math.atan2(sign * y, x)
+      else
+        sign = Math.sin(theta2) <=> 0
+        theta1 = Math.atan2(sign * rot_mat[0,1], sign * rot_mat[0,2])
+        theta3 = Math.atan2(sign * rot_mat[1,0], -sign * rot_mat[2,0])
+      end
+    else
+      begin
+        theta2 = Math.asin(-rot_mat[2,0])
+      rescue Math::DomainError
+        # the value of rot_mat[2,0] may be off slightly due to truncation
+        # error
+        if -rot_mat[2,0] > 0
+          theta2 = Math::PI/2
+        else
+          theta2 = -Math::PI/2
+        end
+      end
+      if Math.cos(theta2).abs() < Math.sqrt(tol)
+        # if cos(theta2) is 0, then the first and third axes are
+        # either parallel or antiparallel, so we can only find the sum
+        # theta3 + theta1.  Here, we choose theta3 = 0 and solve for
+        # theta1.
+        y = -rot_mat[1,2]
+        x = rot_mat[0,2]
+        sign = Math.sin(theta2) <=> 0
+        theta1 = Math.atan2(y, sign * x)
+        theta3 = 0
+      else
+        sign = Math.cos(theta2) <=> 0
+        theta1 = Math.atan2(sign * rot_mat[2,1], sign * rot_mat[2,2])
+        theta3 = Math.atan2(sign * rot_mat[1,0], sign * rot_mat[0,0])
+      end
+    end
+
+    return theta1, theta2, theta3
+  end
+
+  def isOrthonormalMatrix(mat, tol)
+    # Determines if mat is orthonormal.  That is, determines whether
+    # mat.transpose() * mat is equal to the identity matrix (to within
+    # tol).
+
+    n_rows = mat.row_size()
+    n_cols = mat.column_size()
+    if (n_rows != n_cols)
+      return false
+    end
+    result = mat.transpose() * mat
+    for i in (0...n_rows)
+      for j in (0...n_cols)
+        if i == j
+          if result[i,j] - 1.abs() > tol
+            return false
+          end
+        else
+          if result[i,j] > tol
+            return false
+          end
+        end
+      end
+    end
+    return true
+  end
+end

data/tests/tests.rb

@@ -0,0 +1,12 @@
+# Name: tests.rb
+# Description: Runs all test cases for both the Quaternion and
+#              UnitQuaternion class, and produces code coverage information.
+# Author: Cory Crean
+# E-mail: cory.crean@gmail.com
+# Copyright (c) 2016, Cory Crean
+
+require 'simplecov'
+SimpleCov.start
+require 'test/unit'
+require_relative 'tests_Quaternion'
+require_relative 'tests_UnitQuaternion'

data/tests/tests_Quaternion.rb

@@ -0,0 +1,157 @@
+# Name: tests_Quaternion.rb
+# Description: Test cases for the Quaternion class.
+# Author: Cory Crean
+# E-mail: cory.crean@gmail.com
+# Copyright (c) 2016, Cory Crean
+
+require 'test/unit'
+require 'matrix'
+require_relative '../lib/quaternion'
+
+class TestQuaternion < Test::Unit::TestCase
+
+  def setup
+    @quats = [ ::Quaternion.new(1,2,3,4),
+               ::Quaternion.new(0.1, 0.01, 2.3, 4),
+               ::Quaternion.new(1234.4134, 689.6124, 134.124, 0.5),
+               ::Quaternion.new(1,1,1,1),
+             ]
+    nums = (0..1).step(0.2).to_a + (2..10).step(2).to_a
+    nums.product(nums, nums, nums).each() do |w, x, y, z|
+      @quats << Quaternion.new(w, x, y, z)
+    end
+  end
+
+  def test_initialize
+    q = ::Quaternion.new(1,1,1,1)
+    beta0, beta_s = q.get()
+    assert_equal(1, beta0)
+    assert_equal(Vector[1,1,1], beta_s)
+
+    q = ::Quaternion.new
+    beta0, beta_s = q.get()
+    assert_equal(0, beta0)
+    assert_equal(Vector[0,0,0], beta_s)
+
+    vals = [ [ 1 ], [ 1, 2 ], [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5, 6 ] ]
+    for v in vals
+      assert_raise(ArgumentError) do
+        q = ::Quaternion.new(*v)
+      end
+    end
+  end
+
+  def test_set
+    q = ::Quaternion.new(0,0,0,0)
+    beta0, beta_s = q.get()
+    assert_equal(0, beta0)
+    assert_equal(Vector[0,0,0], beta_s)
+
+    q.set(1,2,3,4)
+    beta0, beta_s = q.get()
+    assert_equal(1, beta0)
+    assert_equal(Vector[2,3,4], beta_s)
+  end
+
+  def test_norm
+    q = ::Quaternion.new(1, 0, 0, 0)
+    assert_equal(1, q.norm())
+
+    q = ::Quaternion.new(1, 2, 3, 4)
+    assert_equal(Math.sqrt(1**2 + 2**2 + 3**2 + 4**2), q.norm())
+
+    assert_equal(0, ::Quaternion.new(0,0,0,0).norm())
+
+    for q in @quats
+      assert_in_delta(q.norm(), Math.sqrt((q*q.conjugate()).get[0]), 1e-14)
+    end
+  end
+
+  def test_conjugate_multiply
+    # tests the conjugate and * methods
+    q = ::Quaternion.new(1, 1, 3, 1)
+    q_c = q.conjugate()
+    beta0, beta_s = q_c.get()
+    assert_equal(1, beta0)
+    assert_equal(Vector[-1,-3,-1], beta_s)
+
+    for q in @quats
+      assert_in_delta((q*q.conjugate()).get[1].norm(), 0, 1e-15)
+    end
+  end
+
+  def test_inverse
+    @quats.delete(Quaternion.new(0,0,0,0))
+    for q in @quats
+      q_inv = q.inverse()
+      q_result = q * q_inv
+      beta0, beta_s = q_result.get()
+      assert_in_delta(1, beta0, 1e-15)
+      assert_in_delta(beta_s.norm(), 0, 1e-15)
+    end
+  end
+
+  def test_add
+    for q, q2 in @quats.zip(@quats)
+      sum = q + q2
+      assert_in_delta(sum.get()[0], q.get()[0] + q2.get()[0], 1e-15)
+      assert_in_delta((sum.get()[1] - (q.get()[1] + q2.get()[1])).norm(),
+                      1e-15)
+    end
+  end
+
+  def test_subtract
+    for q, q2 in @quats.zip(@quats)
+      sum = q - q2
+      assert_in_delta(sum.get()[0], q.get()[0] - q2.get()[0], 1e-15)
+      assert_in_delta((sum.get()[1] - (q.get()[1] - q2.get()[1])).norm(),
+                      1e-15)
+    end
+  end
+
+  def test_normalized
+    q = ::Quaternion.new(1,1,1,1)
+    beta0, beta_s = q.normalized().get()
+    assert_in_delta(0.5, beta0, 1e-15)
+    assert_in_delta((Vector[0.5,0.5,0.5] - beta_s).norm(), 0, 1e-15)
+
+    @quats.delete(Quaternion.new(0,0,0,0))
+    for q in @quats
+      assert_in_delta(q.normalized().norm(), 1, 1e-15)
+    end
+  end
+
+  def test_equality
+    for q in @quats
+      assert_equal(q, q)
+    end
+
+    assert(Quaternion.new(1,2,3,4) != Quaternion.new(4,3,2,1))
+    assert(Quaternion.new(0,0,0,0) != Quaternion.new(1,1,1,1))
+  end
+
+  def test_scalarMult
+    q = ::Quaternion.new(1,1,1,1)
+    assert_equal(3 * q, Quaternion.new(3,3,3,3))
+    assert_equal(1.111 * q, Quaternion.new(1.111, 1.111, 1.111, 1.111))
+    assert_equal(q * 3, Quaternion.new(3,3,3,3))
+    assert_equal(q * 1.111, Quaternion.new(1.111, 1.111, 1.111, 1.111))
+  end
+
+  def test_string
+    q = Quaternion.new(1,1,1,1)
+    assert_equal(q.to_s,
+                 "(1, Vector[1, 1, 1])")
+
+    q = Quaternion.new(1,2,3,4)
+    assert_equal(q.to_s,
+                 "(1, Vector[2, 3, 4])")
+  end
+
+  def test_unaryMinus
+    for q in @quats
+      beta0, beta_s = q.get()
+      assert_equal(-q, Quaternion.new(-beta0, -beta_s[0], -beta_s[1], -beta_s[2]))
+    end
+  end
+end

data/tests/tests_UnitQuaternion.rb

@@ -0,0 +1,337 @@
+# Name: tests_UnitQuaternion.rb
+# Description: Test cases for the UnitQuaternion class.
+# Author: Cory Crean
+# E-mail: cory.crean@gmail.com
+# Copyright (c) 2016, Cory Crean
+
+require 'test/unit'
+require 'matrix'
+require_relative '../lib/unit_quaternion'
+
+def areEqualMatrices(m1, m2, tol)
+  m1.zip(m2).each() do |v1, v2|
+    if (v1 - v2).abs() > tol
+      return false
+    end
+  end
+  return true
+end
+
+def isIdentityMatrix(m, tol)
+  for i, j in [0,1,2].product([0,1,2])
+    if i == j
+      if (m[i,j] - 1).abs > tol
+        return false
+      end
+    else
+      if m[i,j].abs > tol
+        return false
+      end
+    end
+  end
+  return true
+end
+
+class TestUnitQuaternion < Test::Unit::TestCase
+
+  def setup
+    @quats = [ ::UnitQuaternion.new(1,2,3,4),
+               ::UnitQuaternion.new(0.1, 0.01, 2.3, 4),
+               ::UnitQuaternion.new(1234.4134, 689.6124, 134.124, 0.5),
+               ::UnitQuaternion.new(1,1,1,1),
+             ]
+    @angles = [ 2*Math::PI, Math::PI, Math::PI/2, Math::PI/4,
+                0.5,  0.25, 0.1234, 0, ]
+    # @angles = (0..2*Math::PI).step(0.2).to_a
+    # @angles << 2*Math::PI
+    # for i in 1..8
+    #   @angles << Math::PI/i
+    # end
+    @axes = [ Vector[ 1, 1, 1 ], Vector[ 1, 0, 0 ], Vector[ 0, 1, 0 ],
+              Vector[ 0, 0, 1 ], Vector[ 1, 2, 3 ], ]
+    # @euler = []
+    # ['x', 'y', 'z'].permutation() do |s|
+    #   @euler << s.join("")
+    #   @euler << s.join("").upcase()
+    # end
+    @euler = ['XYZ', 'XZY', 'XYX', 'XZX', 'YXZ', 'YZX', 'YXY', 'YZY',
+              'ZXY', 'ZYX', 'ZXZ', 'ZYZ', 'xyz', 'xzy', 'xyx', 'xzx',
+              'yxz', 'yzx', 'yxy', 'yzy', 'zxy', 'zyx', 'zxz', 'zyz']
+  end
+
+  def test_initialize
+    q = ::UnitQuaternion.new(0.9848857801796105, 0.1, 0.1, 0.1)
+    beta0, beta_s = q.get()
+    assert_equal(0.9848857801796105, beta0)
+    assert_equal(Vector[0.1, 0.1, 0.1], beta_s)
+    assert_equal(1, beta0**2 + beta_s.norm()**2)
+
+    assert_raise(ArgumentError) do
+      q = ::UnitQuaternion.new(1,1,1)
+    end
+
+    q = ::UnitQuaternion.new(1, 0, 0, 0)
+    beta0, beta_s = q.get()
+    assert_equal(1, beta0)
+    assert_equal(Vector[0,0,0], beta_s)
+
+    q = ::UnitQuaternion.new(1, 1, 1, 1)
+    beta0, beta_s = q.get()
+    assert_in_delta(0.5, beta0, 1e-15)
+    assert_in_delta((Vector[0.5, 0.5, 0.5] - beta_s).norm(), 0, 1e-15)
+  end
+
+  def test_set
+    q = ::UnitQuaternion.new
+    q.set(0.9848857801796105, 0.1, 0.1, 0.1)
+    beta0, beta_s = q.get()
+    assert_equal(0.9848857801796105, beta0)
+    assert_equal(Vector[0.1, 0.1, 0.1], beta_s)
+    assert_equal(1, beta0**2 + beta_s.norm()**2)
+
+    assert_raise(ArgumentError) do
+      q.set(1,1,1)
+    end
+
+    q.set(1, 0, 0, 0)
+    beta0, beta_s = q.get()
+    assert_equal(1, beta0)
+    assert_equal(Vector[0,0,0], beta_s)
+
+    q.set(1, 1, 1, 1)
+    beta0, beta_s = q.get()
+    assert_in_delta(0.5, beta0, 1e-15)
+    assert_in_delta((Vector[0.5, 0.5, 0.5] - beta_s).norm(), 0, 1e-15)
+  end
+
+  def test_setAngleAxis
+    axis = Vector[1, 0, 0]
+    angle = Math::PI/2
+    q = ::UnitQuaternion.new
+    q.setAngleAxis(angle, axis)
+    beta0, beta_s = q.get()
+    assert_equal(Math.cos(angle/2.0), beta0)
+    assert_equal(axis[0]*Math.sin(angle/2.0), beta_s[0])
+    assert_equal(axis[1]*Math.sin(angle/2.0), beta_s[1])
+    assert_equal(axis[2]*Math.sin(angle/2.0), beta_s[2])
+
+    for angle, axis in @angles.product(@axes)
+      q = ::UnitQuaternion.new
+      q.setAngleAxis(angle, axis)
+      beta0, beta_s = q.get()
+      assert_in_delta(Math.cos(angle/2), beta0, 1e-15)
+      assert_in_delta((beta_s - axis.normalize()*Math.sin(angle/2)).norm(),
+                      0, 1e-15)
+    end
+
+    q2 = ::UnitQuaternion.new
+    assert_raise(ArgumentError) do
+      q2.setAngleAxis(0, Vector[0,0,0])
+    end
+    assert_raise(ArgumentError) do
+      q2.setAngleAxis(0, Vector[1,1,1,1])
+    end
+    assert_raise(ArgumentError) do
+      q2 = ::UnitQuaternion.fromAngleAxis(0, Vector[0,0,0])
+    end
+    assert_raise(ArgumentError) do
+      q2 = ::UnitQuaternion.fromAngleAxis(0, Vector[1,1,1,1])
+    end
+  end
+
+  def test_getAngleAxis
+    axis = Vector[1, 2, 3]
+    angle = 0.4321
+    q = ::UnitQuaternion.fromAngleAxis(angle, axis)
+    result_angle, result_axis = q.getAngleAxis()
+
+    assert_in_delta((axis.normalize() - result_axis).norm(), 0, 1e-15)
+    assert_in_delta(angle, result_angle, 1e-15)
+
+    # The angle-axis representation of a rotation is not unique.  We could
+    # reverse the sign of both the angle and axis, or when the angle is a
+    # multiple of 2*PI, any axis will do.  Therefore, we compare rotation
+    # matrices instead of angles and axes.
+    for angle, axis in @angles.product(@axes)
+      q = ::UnitQuaternion.fromAngleAxis(angle, axis)
+      a, ax = q.getAngleAxis()
+      q2 = ::UnitQuaternion.fromAngleAxis(a, ax)
+      assert(areEqualMatrices(q.getRotationMatrix(), q2.getRotationMatrix(),
+                              1e-14))
+    end
+  end
+
+  def test_multiply_inverse
+    axis1 = Vector[1, 2, 3]
+    angle1 = 1.123
+    q1 = ::UnitQuaternion.fromAngleAxis(angle1, axis1)
+
+    axis2 = Vector[1, 2, 3]
+    angle2 = -1.123
+    q2 = ::UnitQuaternion.fromAngleAxis(angle2, axis2)
+
+    q3 = q1 * q2
+    beta0, beta_s = q3.get()
+    assert_in_delta(1, beta0, 1e-15)
+    assert_in_delta(0, beta_s.norm(), 1e-15)
+
+    for q in @quats
+      q_inv = q.inverse()
+      result = q * q_inv
+      beta0, beta_s = result.get()
+      assert_in_delta(1, beta0, 1e-15)
+      assert_in_delta(0, beta_s.norm(), 1e-14)
+    end
+  end
+
+  def test_multiply
+    axis1 = Vector[3, 1, 6]
+    angle1 = 1.32
+    q1 = ::UnitQuaternion.fromAngleAxis(angle1, axis1)
+
+    axis2 = Vector[1, 1, 1]
+    angle2 = Math::PI/4
+    q2 = ::UnitQuaternion.fromAngleAxis(angle2, axis2)
+
+    q_result = q2*q1
+    q_result_mat = q_result.getRotationMatrix()
+    
+    mat_result = q2.getRotationMatrix() * q1.getRotationMatrix()
+    
+    for i in 0..2
+      assert_in_delta((q_result_mat.row(i) - mat_result.row(i)).norm(),
+                      0, 1e-15)
+    end
+
+    for q1, q2 in @quats.product(@quats)
+      q_result = q2 * q1
+      q_result_mat = q_result.getRotationMatrix()
+      mat_result = q2.getRotationMatrix() * q1.getRotationMatrix()
+
+      for i in 0..2
+        assert_in_delta((q_result_mat.row(i) - mat_result.row(i)).norm(),
+                        0, 1e-14)
+      end
+    end
+  end
+
+  def test_transform
+    axis = Vector[1,1,1]
+    angle = 2*Math::PI/3
+    q1 = ::UnitQuaternion.fromAngleAxis(angle, axis)
+
+    v = Vector[1,0,0]
+    v_rot = q1.transform(v)
+    expected = Vector[0,1,0]
+
+    assert_in_delta((v_rot - expected).norm(), 0, 1e-15)
+
+    for q, v in @quats.product(@axes)
+      v_rot = q.transform(v)
+      v_expected = q.getRotationMatrix() * v
+      assert_in_delta((v_rot - v_expected).norm(), 0, 1e-15)
+    end
+  end
+
+  def test_inverse    
+    angles = [ 0, Math::PI/4, 0.1234, Math::PI/2, 2 ]
+    axes = [ Vector[1,1,1], Vector[1,2,3], Vector[0,0,1] ]
+    for angle, axis in (angles + @angles).product(axes + @axes)
+      q = ::UnitQuaternion.fromAngleAxis(angle, axis)
+      q_inv = q.inverse()
+
+      assert(isIdentityMatrix( q.getRotationMatrix() *
+                               q_inv.getRotationMatrix(),
+                               1e-15 )
+             )
+
+      result = q * q_inv
+      beta0, beta_s = result.get()
+      assert_in_delta(beta0, 1, 1e-15)
+      assert_in_delta((beta_s - Vector[0,0,0]).norm(), 0, 1e-15)
+    end
+  end
+
+  def test_Euler
+    # If we generate a quaternion using Euler angles and then ask for
+    # the Euler angles from that quaternion, we may get a different
+    # answer, since the Euler angles are not unique.  However, if we
+    # ask for the Euler angles from the first quaternion, then
+    # generate a second quaternion using those same Euler angles, the
+    # quaternions should be equal to each other.
+
+    @angles.product(@angles, @angles) do | theta1, theta2, theta3 |
+      q = UnitQuaternion.fromEuler(theta1, theta2, theta3, 'xyz')
+      @euler.each do |e|
+        q2 = UnitQuaternion.fromEuler(*q.getEuler(e), e)
+        tol = 1e-7
+        assert(areEqualMatrices(q.getRotationMatrix(),
+                                q2.getRotationMatrix(), tol))
+      end
+    end
+
+    q = UnitQuaternion.fromEuler(2 * Math::PI/2, 2 * Math::PI/2,
+                                 2 * Math::PI/2, 'xyz')
+    assert_in_delta((q - UnitQuaternion.new(-1,0,0,0)).norm(), 0, 1e-15)
+
+    assert_raise(ArgumentError) { q.getEuler('xy') }
+    assert_raise(ArgumentError) { q.getEuler('xyzx') }
+    assert_raise(ArgumentError) { q.getEuler('xYz') }
+    assert_raise(ArgumentError) { q.getEuler('xxy') }
+    assert_raise(ArgumentError) { q.getEuler('yyz') }
+    assert_raise(ArgumentError) { q.getEuler('xzz') }
+    assert_raise(ArgumentError) { q.getEuler('xzb') }
+
+    assert_raise(ArgumentError) { UnitQuaternion.fromEuler(0, 0, 0, 'xy') }
+    assert_raise(ArgumentError) { UnitQuaternion.fromEuler(1, 1, 1, 'x') }
+    assert_raise(ArgumentError) { UnitQuaternion.fromEuler(0, 0, 0, 'xyzx') }
+    assert_raise(ArgumentError) { UnitQuaternion.fromEuler(0, 0, 0, 'xya') }
+    assert_raise(ArgumentError) { UnitQuaternion.fromEuler(0, 0, 0, 'Xyz') }
+  end
+
+  def test_rotationMatrix
+    tol = 1e-7
+    @angles.product(@angles, @angles) do | theta1, theta2, theta3 |
+      q = ::UnitQuaternion.fromEuler(theta1, theta2, theta3, 'XYZ')
+
+      q_from = ::UnitQuaternion.fromRotationMatrix(q.getRotationMatrix())
+      q_set = ::UnitQuaternion.new()
+      q_set.setRotationMatrix(q.getRotationMatrix())
+
+      assert(areEqualMatrices(q.getRotationMatrix(),
+                              q_from.getRotationMatrix(), tol))
+      assert(areEqualMatrices(q.getRotationMatrix(),
+                              q_set.getRotationMatrix(), tol))
+    end
+
+    assert_raise(ArgumentError) do
+      UnitQuaternion.fromRotationMatrix(Matrix[ [1, 1, 0],
+                                                [0, 1, 0],
+                                                [0, 0, 1] ])
+    end
+    assert_raise(ArgumentError) do
+      UnitQuaternion.fromRotationMatrix(Matrix[ [1, 1e-8, 0],
+                                                [0, 1, 0],
+                                                [0, 0, 1] ])
+    end
+    assert_raise(ArgumentError) do
+      UnitQuaternion.fromRotationMatrix(Matrix[ [0, 1, 0],
+                                                [0, 1, 0],
+                                                [0, 0, 1] ])
+    end
+    assert_raise(ArgumentError) do
+      UnitQuaternion.fromRotationMatrix(Matrix[ [1, 0, 0],
+                                                [0, 1, 0] ])
+    end
+    assert_raise(ArgumentError) do
+      UnitQuaternion.fromRotationMatrix(Matrix[ [1, 0, 0, 0],
+                                                [0, 1, 0, 0],
+                                                [0, 0, 1, 0],
+                                                [0, 0, 0, 1] ])
+    end
+    assert_raise(ArgumentError) do
+      UnitQuaternion.fromRotationMatrix(Matrix[ [1, 0],
+                                                [0, 1] ])
+    end
+  end
+end

data/unit_quaternion.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unit_quaternion/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "unit_quaternion"
+  spec.version       = Quaternion::VERSION
+  spec.authors       = ["Cory Crean"]
+  spec.email         = ["cory.crean@gmail.com"]
+  spec.description   = %q{Provides a general Quaternion class, and UnitQuaternion class to represent rotations}
+  spec.summary       = spec.description
+  spec.homepage      = ""
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(tests|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov", "~> 0.11.2"
+  spec.add_development_dependency "simplecov-html", "~> 0.10.0"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: unit_quaternion
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Cory Crean
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: simplecov-html
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+description: Provides a general Quaternion class, and UnitQuaternion class to represent
+  rotations
+email:
+- cory.crean@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/quaternion.rb
+- lib/unit_quaternion.rb
+- lib/unit_quaternion/version.rb
+- tests/tests.rb
+- tests/tests_Quaternion.rb
+- tests/tests_UnitQuaternion.rb
+- unit_quaternion.gemspec
+homepage: ''
+licenses:
+- BSD
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides a general Quaternion class, and UnitQuaternion class to represent
+  rotations
+test_files:
+- tests/tests.rb
+- tests/tests_Quaternion.rb
+- tests/tests_UnitQuaternion.rb