quaternion_c2 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 11a23c8bee71f2eac9cdd28569ddbd060e1c78d6
+  data.tar.gz: 2da47444cd5b3c7f50da7f9cb0dfc281dcd187a1
+SHA512:
+  metadata.gz: 3504d452e7841683a890fb01c8ca3a82ce44c9c334aa3309b50329dd17415a99d021c6d2b56cf0358a5c04d9d09b1aaf44508d030cc75072a32626d4c1a8d1eb
+  data.tar.gz: 6348e89acb1f9a31923c03d9ea1fac21d10d2a849d55c198fd757021ad35243dce10c411502f4ea4b6e622d331e4e66dfd4b014e46c2774d290320a77507265b

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.14.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Masahiro Nomoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# Quaternion
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quaternion_c2'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+`Quaternion` is similar to a built-in class `Complex`.
+
+There are several methods to create a quaternion.  `Kernel.#Quaternion` accepts many patterns of arguments.
+
+```ruby
+require 'quaternion_c2'
+
+q1 = Quaternion.rect(Complex(1, 2), Complex(3, 4))  #=> (1+2i+3j+4k)
+q2 = Quaternion.hrect(1, -2, Rational(-3, 4), 0.56) #=> (1-2i-(3/4)*j+0.56k)
+vector = Vector[1, 1, 1].normalize
+q3 = Quaternion.polar(1, Math::PI / 3, vector)      #=> (0.5+0.5i+0.5j+0.5k)
+q4 = Quaternion(1, [2, 3, 4])                       #=> (1+2i+3j+4k)
+
+q1.rect  #=> [(1+2i), (3+4i)]
+q2.hrect #=> [1, -2, (-3/4), 0.56]
+q3.polar #=> [1.0, Math::PI / 3, vector]
+q4.real  #=> 1
+q4.imag  #=> Vector[2, 3, 4]
+
+Complex::I.to_q     #=> (0+1i+0j+0k)
+1 + 2.i + 3.j + 4.k #=> (1+2i+3j+4k)
+```
+
+`Quaternion` supports standard calculations between numeric instances.
+
+```ruby
+Complex::I * Quaternion::J  #=> (0+0i+0j+1k)
+1 / Quaternion::I           #=> ((0/1)-(1/1)*i+(0/0)*j+(0/0)*k)
+Quaternion(1, 1, 1, 1) ** 6 #=> (64+0i+0j+0k)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hmmnrst/quaternion_c2.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "quaternion_c2"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/quaternion_c2.rb

@@ -0,0 +1,10 @@
+require "quaternion_c2/base"
+require "quaternion_c2/classification"
+require "quaternion_c2/unary"
+require "quaternion_c2/units"
+require "quaternion_c2/equality"
+require "quaternion_c2/attributes"
+require "quaternion_c2/arithmetic"
+require "quaternion_c2/to_type"
+require "quaternion_c2/conversion"
+require "quaternion_c2/utils"

data/lib/quaternion_c2/arithmetic.rb

@@ -0,0 +1,75 @@
+require_relative 'base'
+require_relative 'classification'
+require_relative 'unary'
+
+#
+# Basic arithmetic operators (#+, #-, #*, #/)
+# and related methods
+#
+
+class Quaternion
+	def +(other)
+		if other.kind_of?(Quaternion)
+			__new__(@a + other.a, @b + other.b)
+		elsif other.kind_of?(Numeric) && other.complex?
+			__new__(@a + other, @b)
+		else
+			n1, n2 = other.coerce(self)
+			n1 + n2
+		end
+	end
+
+	def -(other)
+		if other.kind_of?(Quaternion)
+			__new__(@a - other.a, @b - other.b)
+		elsif other.kind_of?(Numeric) && other.complex?
+			__new__(@a - other, @b)
+		else
+			n1, n2 = other.coerce(self)
+			n1 - n2
+		end
+	end
+
+	def *(other)
+		if other.kind_of?(Quaternion)
+			_a = other.a
+			_b = other.b
+			__new__(@a * _a - _b.conj * @b, _b * @a + @b * _a.conj)
+		elsif other.kind_of?(Numeric) && other.complex?
+			__new__(@a * other, @b * other.conj)
+		else
+			n1, n2 = other.coerce(self)
+			n1 * n2
+		end
+	end
+
+	[:quo, :fdiv].each do |sym|
+		define_method(sym) do |other|
+			if other.kind_of?(Quaternion)
+				self * other.conj.send(sym, other.abs2)
+			elsif other.kind_of?(Numeric) && other.complex?
+				__new__(@a.send(sym, other), @b.send(sym, other.conj))
+			else
+				n1, n2 = other.coerce(self)
+				n1.send(sym, n2)
+			end
+		end
+	end
+	alias / quo
+	undef div, %, modulo, remainder, divmod
+
+	#
+	# Conversion
+	#
+
+	def coerce(other)
+		if other.kind_of?(Quaternion)
+			[other, self]
+		elsif other.kind_of?(Numeric) && other.complex?
+			[__new__(other, 0), self]
+		else
+			raise TypeError,
+			      "#{other.class} can't be coerced into #{self.class}"
+		end
+	end
+end

data/lib/quaternion_c2/attributes.rb

@@ -0,0 +1,25 @@
+require_relative 'unary'
+require_relative 'equality'
+
+class Quaternion
+	# defined by Numeric:
+	# * zero?    #=> self == 0
+	# * nonzero? #=> zero? ? nil : self
+
+	defined_methods = public_instance_methods
+
+	if defined_methods.include?(:finite?)
+		def finite?
+			abs.finite?
+		end
+	end
+
+	if defined_methods.include?(:infinite?)
+		def infinite?
+			abs.infinite?
+		end
+	end
+
+	undef positive? if defined_methods.include?(:positive?)
+	undef negative? if defined_methods.include?(:negative?)
+end

data/lib/quaternion_c2/base.rb

@@ -0,0 +1,18 @@
+class Quaternion < Numeric
+	attr_reader :a, :b
+	protected   :a, :b
+
+	def initialize(a, b)
+		@a = a.to_c
+		@b = b.to_c
+	end
+
+	private_class_method :new
+
+
+	private
+
+	def __new__(a, b)
+		Quaternion.send(:new, a, b)
+	end
+end

data/lib/quaternion_c2/classification.rb

@@ -0,0 +1,32 @@
+require_relative 'base'
+
+#
+# Number system classification
+# (N <) Z < Q < R < C < H (< ...)
+#
+# * quaternion?  : [H] Quaternion (*undefined*)
+# * && complex?  : [C] Complex
+# * && real?     : [R] Float, BigDecimal, Numeric
+# * && rational? : [Q] Rational (*undefined*)
+# * && integer?  : [Z] Fixnum, Bignum, Integer
+#
+
+class Numeric
+	# defined:
+	# * integer? #=> false
+	# * real?    #=> true
+
+	def complex?
+		true
+	end
+end
+
+class Quaternion
+	def real?
+		false
+	end
+
+	def complex?
+		false
+	end
+end

data/lib/quaternion_c2/conversion.rb

@@ -0,0 +1,166 @@
+require_relative 'base'
+require_relative 'classification'
+require_relative 'unary'
+require_relative 'units'
+require_relative 'arithmetic'
+require_relative 'to_type'
+
+require 'matrix'
+
+class Quaternion
+	#
+	# Constructors
+	#
+
+	class << self
+		def rect(a, b = 0)
+			unless [a, b].all? { |c| c.kind_of?(Numeric) && c.complex? }
+				raise TypeError, 'not a complex'
+			end
+			new(a, b)
+		end
+		alias rectangular rect
+
+		def hrect(w, x = 0, y = 0, z = 0)
+			a = Complex.rect(w, x)
+			b = Complex.rect(y, z)
+			new(a, b)
+		end
+		alias hyperrectangular hrect
+
+		# Quaternion.polar(r) == r
+		# Quaternion.polar(r, theta) == Complex.polar(r, theta)
+		def polar(r, theta = 0, vector = Vector[1, 0, 0])
+			unless vector.kind_of?(Enumerable) && vector.size == 3
+				raise TypeError, 'not a 3-D vector'
+			end
+			unless [r, theta, *vector].all? { |a| a.kind_of?(Numeric) && a.real? }
+				raise TypeError, 'not a real'
+			end
+
+			vector = Vector[*vector] unless vector.kind_of?(Vector)
+			norm = vector.norm
+			theta *= norm
+
+			r_cos = r * Math.cos(theta)
+			r_sin = r * Math.sin(theta)
+			r_sin /= norm if norm > 0
+			hrect(r_cos, *(r_sin * vector))
+		end
+	end
+
+	#
+	# Accessors
+	#
+
+	def rect
+		[@a, @b]
+	end
+	alias rectangular rect
+
+	def hrect
+		rect.flat_map(&:rect)
+	end
+	alias hyperrectangular hrect
+
+	def real
+		@a.real
+	end
+	alias scalar real
+
+	def imag
+		Vector[*hrect.drop(1)]
+	end
+	alias imaginary imag
+	alias vector imag
+
+	# defined in unary.rb:
+	# * abs
+	# * magnitude
+
+	def arg
+		r_cos = real
+		r_sin = imag.norm
+		Math.atan2(r_sin, r_cos)
+	end
+	alias angle arg
+	alias phase arg
+
+	def axis
+		v = imag
+		norm = v.norm
+		if norm.zero?
+			# imag[0] == +0.0 -> q = r exp(+I PI)
+			# imag[0] ==  0/1 -> q = r exp(+I PI)
+			# imag[0] == -0.0 -> q = r exp(-I PI)
+			sign = (1.0 / imag[0] >= 0) ? 1 : -1
+			Vector[sign, 0, 0]
+		else
+			v / norm
+		end
+	end
+
+	def polar
+		[abs, arg, axis]
+	end
+end
+
+#
+# Generic constructor
+#
+# This accepts various arguments:
+# * (Numeric)          -> real quaternion
+# * (Numeric, Numeric) -> a+bj
+# * (Numeric, Vector)  -> scalar and 3-D vector
+# * (Numeric, Numeric, Numeric[, Numeric]) -> w+xi+yj+zk
+# and String instead of Numeric.
+#
+module Kernel
+	module_function
+
+	def Quaternion(*args)
+		argc = args.size
+
+		unless (1..4).cover?(argc)
+			raise ArgumentError,
+			      "wrong number of arguments (given #{argc}, expected 1..4)"
+		end
+
+		if args.any?(&:nil?)
+			raise TypeError, "can't convert nil into Quaternion"
+		end
+
+		# convert String into Numeric (strictly)
+		args.collect! do |arg|
+			case arg
+			when String
+				Quaternion.send(:parse, arg, true)
+			else
+				arg
+			end
+		end
+
+		case argc
+		when 2
+			if args[1].kind_of?(Enumerable)
+				# scalar and 3-D vector
+				if args[1].size != 3
+					raise TypeError, "not a 3-D vector"
+				end
+				args = [args[0], *args[1]]
+			else
+				# a pair of complex numbers
+				return args[0] + args[1] * Quaternion::J
+			end
+		end
+
+		# maximum four real numbers
+		i = Quaternion::I
+		j = Quaternion::J
+		k = Quaternion::K
+		zero = Quaternion.send(:new, 0, 0)
+		args.zip([1, i, j, k]).inject(zero) do |sum,(num,base)|
+			sum + num * base
+		end
+	end
+end

data/lib/quaternion_c2/equality.rb

@@ -0,0 +1,30 @@
+require_relative 'base'
+require_relative 'classification'
+
+class Quaternion
+	undef <=>
+	undef_method(*Comparable.instance_methods)
+
+	def ==(other)
+		if other.kind_of?(Quaternion)
+			@a == other.a && @b == other.b
+		elsif other.kind_of?(Numeric) && other.complex?
+			@a == other && @b == 0
+		else
+			other == self
+		end
+	end
+
+	def eql?(other)
+		if other.kind_of?(Quaternion)
+			@a.eql?(other.a) && @b.eql?(other.b)
+		else
+			false
+		end
+	end
+
+	# q1.eql?(q2) => q1.hash == q2.hash
+	def hash
+		[@a, @b].hash
+	end
+end

data/lib/quaternion_c2/to_type.rb

@@ -0,0 +1,108 @@
+require_relative 'base'
+require_relative 'unary'
+
+#
+# to_xxx
+#
+
+class Quaternion
+	# defined by Numeric:
+	# * to_int #=> to_i
+
+	def to_q
+		self
+	end
+
+	def to_c
+		unless __exact_zero__(@b)
+			raise RangeError, "can't convert #{self} into Complex"
+		end
+		@a
+	end
+
+	[:to_f, :to_r, :to_i, :rationalize].each do |sym|
+		define_method(sym) { |*args| to_c.send(sym, *args) }
+	end
+
+	def to_s
+		__format__(:to_s)
+	end
+
+	def inspect
+		"(#{__format__(:inspect)})"
+	end
+
+	private
+
+	def __format__(sym)
+		w, *xyz = [@a, @b].flat_map(&:rect)
+		sw = w.send(sym)
+		sx, sy, sz = xyz.zip(%w[i j k]).collect do |num,base|
+			if num.kind_of?(Float)
+				str = num.send(sym)
+				str[0,0] = '+' if str[0] != '-'
+			elsif num < 0
+				str = '-' + (-num).send(sym)
+			else
+				str = '+' + num.send(sym)
+			end
+			str << '*' if str[-1] !~ /\d/
+			str << base
+		end
+		[sw, sx, sy, sz].join
+	end
+
+	class << self
+		def parse(str, strict = false)
+			regexp = %r{
+				\A
+				\s*+
+				(?:(?'real'   [+-]?+           \g'rational'  ) (?![ijk]))?+
+				(?:(?'imag_i' \g'head_or_sign' \g'rational'?+) i        )?+
+				(?:(?'imag_j' \g'head_or_sign' \g'rational'?+) j        )?+
+				(?:(?'imag_k' \g'head_or_sign' \g'rational'?+) k        )?+
+				\s*+
+				|\z
+				(?'head_or_sign' (?<=^|\s) [+-]?+ | [+-])
+				(?'digits'       \d++ (?:#{strict ? "_" : "_++"} \d++)*+)
+				(?'int_or_float' (?:\g'digits')?+ (?:\. \g'digits')?+ (?<=\d) (?:e [+-]?+ \g'digits')?+)
+				(?'rational'     \g'int_or_float' (?:/ \g'digits')?+)
+			}xi
+
+			match_data = regexp.match(str)
+			if strict && (!$'.empty? || match_data.captures[0,4].all?(&:nil?))
+				raise ArgumentError, "invalid value for convert(): #{str.inspect}"
+			end
+
+			w, x, y, z = match_data.captures[0,4].collect do |s|
+				case s
+				when %r{/}     then s.to_r
+				when %r{[.eE]} then s.to_f
+				when '+', ''   then 1
+				when '-'       then -1
+				else                s.to_i # Integer or nil
+				end
+			end
+
+			new(Complex.rect(w, x), Complex.rect(y, z))
+		end
+	end
+end
+
+class Numeric
+	def to_q
+		Quaternion.send(:new, self, 0)
+	end
+end
+
+class String
+	def to_q
+		Quaternion.send(:parse, self, false)
+	end
+end
+
+class NilClass
+	def to_q
+		Quaternion.send(:new, 0, 0)
+	end
+end

data/lib/quaternion_c2/unary.rb

@@ -0,0 +1,43 @@
+require_relative 'base'
+
+#
+# Unary operations
+#
+
+class Quaternion
+	# defined by Numeric:
+	# * +@ #=> self
+	# * -@ #=> 0 - self
+
+	def conj
+		__new__(@a.conj, -@b)
+	end
+	alias conjugate conj
+
+	def abs2
+		@a.abs2 + @b.abs2
+	end
+
+	def abs
+		a_abs = @a.abs
+		b_abs = @b.abs
+		if    __exact_zero__(a_abs)
+			b_abs
+		elsif __exact_zero__(b_abs)
+			a_abs
+		else
+			Math.hypot(a_abs, b_abs)
+		end
+	end
+	alias magnitude abs
+
+	private
+
+	def __exact_zero__(x)
+		1 / x
+	rescue ZeroDivisionError
+		true
+	else
+		false
+	end
+end

data/lib/quaternion_c2/units.rb

@@ -0,0 +1,40 @@
+require_relative 'base'
+
+#
+# Fundamental quaternion units
+#
+
+class Quaternion
+	i = Complex::I
+	I = new(i, 0)
+	J = new(0, 1)
+	K = new(0, i)
+end
+
+#
+# Convert to an imaginary part
+#
+
+class Numeric
+	# defined:
+	# * #i #=> Complex.rect(0, self)
+
+	def j
+		Quaternion.send(:new, 0, self)
+	end
+
+	def k
+		Quaternion.send(:new, 0, self.i)
+	end
+end
+
+class Complex
+	# undefined:
+	# * #i
+
+	undef k
+end
+
+class Quaternion
+	undef i, j, k
+end

data/lib/quaternion_c2/utils.rb

@@ -0,0 +1,71 @@
+require_relative 'base'
+require_relative 'classification'
+require_relative 'unary'
+require_relative 'arithmetic'
+require_relative 'conversion'
+
+class Quaternion
+	def **(index)
+		if index.kind_of?(Numeric)
+			if __exact_zero__(index)
+				return __new__(1, 0)
+			end
+
+			# complex -> real
+			begin
+				index.to_f
+			rescue
+			else
+				index = index.real
+			end
+
+			# rational -> integer
+			if index.kind_of?(Rational) && index.denominator == 1
+				index = index.numerator
+			end
+
+			if index.integer?
+				# binary method
+				x = (index >= 0) ? self : 1 / self
+				n = index.abs
+
+				z = __new__(1, 0)
+				while true
+					n, i = n.divmod(2)
+					z *= x if i == 1
+					return z if n == 0
+					x *= x
+				end
+			elsif index.real?
+				r, theta, vector = polar
+				return Quaternion.polar(r ** index, theta * index, vector)
+			elsif index.complex? || index.kind_of?(Quaternion)
+				r, theta, vector = polar
+				q = Math.log(r) + Quaternion.hrect(0, *(theta * vector))
+				q *= index
+				return Quaternion.polar(Math.exp(q.real), 1, q.imag)
+			end
+		end
+
+		num1, num2 = other.coerce(self)
+		num1 ** num2
+	end
+
+	def denominator
+		ad = @a.denominator
+		bd = @b.denominator
+		ad.lcm(bd)
+	end
+
+	def numerator
+		an = @a.numerator
+		bn = @b.numerator
+		ad = @a.denominator
+		bd = @b.denominator
+		abd = ad.lcm(bd)
+		__new__(an * (abd / ad), bn * (abd / bd))
+	end
+
+	undef step
+	undef ceil, floor, round, truncate
+end

data/quaternion_c2.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "quaternion_c2"
+  spec.version       = "0.1.1"
+  spec.authors       = ["Masahiro Nomoto"]
+  spec.email         = ["hmmnrst@users.noreply.github.com"]
+
+  spec.summary       = %q{Quaternion class}
+  spec.description   = %q{This provides a numeric class Quaternion which is similar to a built-in class Complex.}
+  spec.homepage      = "https://github.com/hmmnrst/quaternion_c2"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: quaternion_c2
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Masahiro Nomoto
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: This provides a numeric class Quaternion which is similar to a built-in
+  class Complex.
+email:
+- hmmnrst@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/quaternion_c2.rb
+- lib/quaternion_c2/arithmetic.rb
+- lib/quaternion_c2/attributes.rb
+- lib/quaternion_c2/base.rb
+- lib/quaternion_c2/classification.rb
+- lib/quaternion_c2/conversion.rb
+- lib/quaternion_c2/equality.rb
+- lib/quaternion_c2/to_type.rb
+- lib/quaternion_c2/unary.rb
+- lib/quaternion_c2/units.rb
+- lib/quaternion_c2/utils.rb
+- quaternion_c2.gemspec
+homepage: https://github.com/hmmnrst/quaternion_c2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: Quaternion class
+test_files: []