quadratic_number 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 705d8a42df709867ad6b91d3640cef83984ef48b
+  data.tar.gz: 34a4ac05039bdbbc0a79b8b5d3b3f3e9a22a9fd0
+SHA512:
+  metadata.gz: a324310465b08035e341a90d58fe1eefcfa89fce53c2e16384794090a7a1cc8c78f6d628dcaeede2e39d9d0c7b63f545443618c31b597596075344e361de9165
+  data.tar.gz: 29bd1b248cffc3b4fb7678ae609186323fd30851bac9fec0414e116981b40cd7f408f0d26fb9b93216cb66acceaac76fe732f76d952266ada9cbde0f64b5e408

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.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in quadratic_number.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,56 @@
+# Quadratic
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quadratic_number'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quadratic_number
+
+## Usage
+
+```ruby
+require 'quadratic_number'
+
+### construction ###
+phi   = Quadratic[5].new(1, 1) / 2     #=> ((1/2)+(1/2)*√5)
+omega = Quadratic[-3].new(-1, 1) / 2   #=> ((-1/2)+(1/2)*√-3)
+
+### type conversion ###
+phi.to_f      #=> 1.618033988749895
+omega.to_c    #=> ((-1/2)+(0+(1/2)*√3)*i)
+omega * 1.0   #=> (-0.5+0.8660254037844386i)
+
+### calculation ###
+phi ** 2 == phi + 1      #=> true
+omega ** 2 + omega + 1   #=> ((0/1)+(0/1)*√-3)
+phi * omega              #=> (-0.8090169943749475+1.4012585384440734i)
+
+### quadratic equation ###
+puts "x^2 - #{phi.trace} x + #{phi.norm} = 0  <-->  x = #{phi}, #{phi.qconj}"
+```
+
+## 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/quadratic_number.
+
+
+## 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 "quadratic_number"
+
+# 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/quadratic_number/imag.rb

@@ -0,0 +1,81 @@
+require_relative '../quadratic_number'
+
+class Quadratic::Imag # < Quadratic < Numeric
+	### Classification ###
+
+	# defined by Numeric:
+	# * integer? #=> false
+
+	def real?
+		false
+	end
+
+	### Basic arithmetic operations ###
+
+	undef div, modulo, %, remainder, divmod
+	undef floor, ceil, round, truncate
+
+	### Comparisons ###
+
+	undef <=>
+	undef_method(*Comparable.public_instance_methods(false))
+	def ==(other)
+		if other.kind_of?(Numeric)
+			self.to_c - other == 0
+		else
+			other == self
+		end
+	end
+
+	defined_methods = public_instance_methods
+	undef positive? if defined_methods.include?(:positive?)
+	undef negative? if defined_methods.include?(:negative?)
+
+	undef step
+
+	### Type conversions ###
+
+	def to_c
+		d = self.class::D
+		if d == -1
+			Complex.rect(@a, @b)
+		else
+			rev_class = Quadratic[-d]
+			Complex.rect(@a, rev_class.new(0, @b))
+		end
+	end
+
+	{
+		:to_f => Float,
+		:to_r => Rational,
+		:rationalize => Rational,
+		:to_i => Integer
+	}.each do |sym,klass|
+		define_method(sym) do |*args|
+			if @b != 0
+				raise RangeError,
+				      "can't convert #{self} into #{klass}"
+			end
+			@a.send(sym, *args)
+		end
+	end
+
+	### Complex operations ###
+
+	alias conj qconj
+	alias conjugate conj
+	alias abs2 norm
+
+	[:rect, :real, :imag, :abs, :arg, :polar].each do |sym|
+		define_method(sym) do
+			to_c.send(sym)
+		end
+	end
+	alias rectangular rect
+	alias imaginary imag
+	alias magnitude abs
+	alias angle arg
+	alias phase arg
+
+	undef i
+end

data/lib/quadratic_number/real.rb

@@ -0,0 +1,78 @@
+require_relative '../quadratic_number'
+
+class Quadratic::Real # < Quadratic < Numeric
+	### Classification ###
+
+	# defined by Numeric:
+	# * integer? #=> false
+	# * real?    #=> true
+
+	### Basic arithmetic operations ###
+
+	# defined by Numeric:
+	# * div #=> (self / other).floor
+	# * modulo, % #=> self - self.div(other) * other
+	# * remainder
+	# * divmod
+	# * floor #=> to_f.floor
+	# * ceil
+	# * round
+	# * truncate
+
+	### Comparisons ###
+
+	def <=>(other)
+		if other.kind_of?(Numeric)
+			if other.real?
+				(self - other).to_f <=> 0
+			else
+				n1, n2 = other.coerce(self)
+				n1 <=> n2
+			end
+		else
+			nil
+		end
+	end
+
+	def ==(other)
+		if other.kind_of?(Numeric) && other.real?
+			(self - other).to_f == 0
+		else
+			other == self
+		end
+	end
+
+	### Type conversions ###
+
+	# defined by Numeric:
+	# * to_c #=> Complex.rect(self, 0)
+
+	def to_f
+		d = self.class::D
+		if @a * @b < 0
+			# Using #fdiv instead of #/
+			# because Rational#/ returns Rational for a big Float divisor in ruby2.0
+			(@a * @a - @b * @b * d).fdiv(@a - @b * Math.sqrt(d))
+		else
+			@a + @b * Math.sqrt(d)
+		end
+	end
+
+	[:to_r, :rationalize, :to_i].each do |sym|
+		define_method(sym) do |*args|
+			(@b == 0 ? @a : to_f).send(sym, *args)
+		end
+	end
+
+	### Complex operations ###
+
+	# defined by Numeric:
+	# * conj, conjugate   #=> self
+	# * abs2              #=> self * self
+	# * rect, rectangular #=> [self, 0]
+	# * real              #=> self
+	# * imag, imaginary   #=> 0
+	# * abs, magnitude    #=> self.negative? ? -self : self
+	# * arg, angle, phase #=> self.to_f >= +0.0 ? 0 : Math::PI
+	# * polar             #=> [abs, arg]
+end

data/lib/quadratic_number.rb

@@ -0,0 +1,324 @@
+require 'prime' # Prime.prime_division
+
+class Quadratic < Numeric
+	@@classes = {}
+
+	def self.[](d)
+		# return a memoized subclass if exists
+		return @@classes[d] if @@classes[d]
+
+		unless d.kind_of?(Integer)
+			raise TypeError, 'not an integer'
+		end
+
+		if d == 0 || d == 1 ||
+		   Prime.prime_division(d).any? { |p,k| k > 1 }
+			raise RangeError, 'd must be square-free other than 0 or 1'
+		end
+
+		# memoize a new subclass and return it
+		base = (d >= 0) ? Real : Imag
+		@@classes[d] = Class.new(base) do
+			# In this scope, `self` indicates a concrete subclass.
+			self.const_set(:D, d)
+
+			class << self
+				def name
+					"Quadratic[#{self::D}]"
+				end
+				alias to_s name
+				alias inspect name
+
+				public :new
+			end
+		end
+	end
+
+	Real = Class.new(self) { class << self; undef []; end }
+	Imag = Class.new(self) { class << self; undef []; end }
+
+	attr_reader :a, :b
+	protected   :a, :b
+
+	def initialize(a, b = 0)
+		unless [a, b].all? { |x| __rational__(x) }
+			raise TypeError, "not a rational"
+		end
+		@a = a
+		@b = b
+	end
+	private_class_method :new
+
+	### Basic arithmetic operations ###
+
+	def coerce(other)
+		my_class = self.class
+		if other.kind_of?(my_class)
+			# my_class
+			[other, self]
+		elsif __rational__(other)
+			# Integer and Rational
+			[my_class.new(other, 0), self]
+		elsif other.kind_of?(Quadratic)
+			# Quadratic::Real and Quadratic::Imag
+			if self.real? && other.real?
+				[other.to_f, self.to_f]
+			else
+				[other.to_c, self.to_c]
+			end
+		elsif __real__(other)
+			# Float and BigDecimal
+			[other, self.to_builtin]
+		elsif __complex__(other)
+			# Complex
+			[other, self.to_c]
+		else
+			# others
+			raise TypeError,
+			      "#{other.class} can't be coerced into #{self.class}"
+		end
+	end
+
+	def +(other)
+		my_class = self.class
+		if other.kind_of?(my_class)
+			my_class.new(@a + other.a, @b + other.b)
+		elsif __rational__(other)
+			my_class.new(@a + other, @b)
+		else
+			__coerce_exec__(:+, other)
+		end
+	end
+
+	def -(other)
+		my_class = self.class
+		if other.kind_of?(my_class)
+			my_class.new(@a - other.a, @b - other.b)
+		elsif __rational__(other)
+			my_class.new(@a - other, @b)
+		else
+			__coerce_exec__(:-, other)
+		end
+	end
+
+	def *(other)
+		my_class = self.class
+		if other.kind_of?(my_class)
+			_a = other.a
+			_b = other.b
+			my_class.new(@a * _a + @b * _b * my_class::D, @a * _b + @b * _a)
+		elsif __rational__(other)
+			my_class.new(@a * other, @b * other)
+		else
+			__coerce_exec__(:*, other)
+		end
+	end
+
+	def quo(other)
+		my_class = self.class
+		if other.kind_of?(my_class)
+			_a = other.a
+			_b = other.b
+			d = _a * _a - _b * _b * my_class::D
+			self * my_class.new(_a.quo(d), -_b.quo(d))
+		elsif __rational__(other)
+			my_class.new(@a.quo(other), @b.quo(other))
+		else
+			__coerce_exec__(:quo, other)
+		end
+	end
+	alias / quo
+
+	def fdiv(other)
+		if other.kind_of?(Quadratic)
+			self.to_builtin.fdiv(other.to_builtin)
+		elsif other.kind_of?(Numeric)
+			self.to_builtin.fdiv(other)
+		else
+			n1, n2 = other.coerce(self)
+			n1.fdiv(other)
+		end
+	end
+
+	def **(index)
+		unless index.kind_of?(Numeric)
+			num1, num2 = other.coerce(self)
+			return num1 ** num2
+		end
+
+		# return 1 if index is exactly zero
+		begin
+			1 / index
+		rescue ZeroDivisionError
+			return self.class.new(1, 0)
+		end
+
+		# complex -> real
+		begin
+			index.to_f
+		rescue
+		else
+			index = index.real
+		end
+
+		# quadratic -> rational or integer / float or complex
+		if index.kind_of?(Quadratic) && index.b == 0
+			if index.b == 0
+				index = index.a
+			else
+				index = index.to_builtin
+			end
+		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 = self.class.new(1, 0)
+			while true
+				n, i = n.divmod(2)
+				z *= x if i == 1
+				return z if n == 0
+				x *= x
+			end
+		else
+			return self.to_builtin ** index
+		end
+	end
+
+	### Comparisons ###
+
+	def eql?(other)
+		if other.kind_of?(self.class)
+			@a.eql?(other.a) && @b.eql?(other.b)
+		else
+			false
+		end
+	end
+
+	def hash
+		[@a, @b, self.class::D].hash
+	end
+
+	# defined by Numeric:
+	# * zero?     #=> self == 0
+	# * nonzero?  #=> zero? ? nil : self
+	# * positive? #=> self > 0
+	# * negative? #=> self < 0
+	# * finite?   #=> true
+	# * infinite? #=> nil
+
+	### Type conversions ###
+
+	def to_builtin
+		real? ? to_f : to_c
+	end
+	protected :to_builtin
+
+	def inspect
+		'(' << __format__(:inspect) << ')'
+	end
+	alias to_s inspect
+
+	### Utilities ###
+
+	def denominator
+		ad = @a.denominator
+		bd = @b.denominator
+		ad.lcm(bd)
+	end
+
+	def numerator
+		an = @a.numerator
+		ad = @a.denominator
+		bn = @b.numerator
+		bd = @b.denominator
+		abd = ad.lcm(bd)
+		self.class.new(an * (abd / ad), bn * (abd / bd))
+	end
+
+	### Extensions for Quadratic ###
+
+	def qconj
+		self.class.new(@a, -@b)
+	end
+	alias quadratic_conjugate qconj
+
+	def trace
+		# self + self.qconj
+		@a * 2
+	end
+
+	def norm
+		# self * self.qconj
+		@a * @a - @b * @b * self.class::D
+	end
+	alias qabs2 norm
+	alias quadratic_abs2 qabs2
+
+	def discriminant
+		# trace ** 2 - 4 * norm
+		@b * @b * (self.class::D * 4)
+	end
+
+	private
+
+	# Integer and Rational
+	def __rational__(x)
+		x.kind_of?(Integer) || x.kind_of?(Rational)
+	end
+
+	# Integer, Rational,
+	# Quadratic::Real, Float, and BigDecimal
+	def __real__(x)
+		x.kind_of?(Numeric) && x.real?
+	end
+
+	# Complex and Quadratic::Imag
+	def __complex__(x)
+		x.kind_of?(Complex) || x.kind_of?(Imag)
+	end
+
+	def __coerce_exec__(op, other)
+		if other.kind_of?(Quadratic)
+			if self.real? && other.real?
+				n1 = self.to_f
+				n2 = other.to_f
+			else
+				n1 = self.to_c
+				n2 = other.to_c
+			end
+		elsif __real__(other)
+			n1 = self.to_builtin
+			n2 = other
+		elsif __complex__(other)
+			n1 = self.to_c
+			n2 = other
+		else
+			n1, n2 = other.coerce(self)
+		end
+
+		n1.send(op, n2)
+	end
+
+	def __format__(sym)
+		str = ''
+		str << @a.send(sym)
+		if @b >= 0
+			str << '+' << @b.send(sym)
+		else
+			str << '-' << (-@b).send(sym)
+		end
+		str << "*" if /\D\z/ === str
+		str << "\u221a#{self.class::D}"
+	end
+end
+
+require_relative 'quadratic_number/real'
+require_relative 'quadratic_number/imag'

data/quadratic_number.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          = "quadratic_number"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Masahiro Nomoto"]
+  spec.email         = ["hmmnrst@users.noreply.github.com"]
+
+  spec.summary       = %q{Quadratic class}
+  spec.description   = %q{Provides a numeric class Quadratic to represent a+b\u221ad exactly}
+  spec.homepage      = "https://github.com/hmmnrst/quadratic_number"
+  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,99 @@
+--- !ruby/object:Gem::Specification
+name: quadratic_number
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Masahiro Nomoto
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-05-01 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: Provides a numeric class Quadratic to represent a+b\u221ad exactly
+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/quadratic_number.rb
+- lib/quadratic_number/imag.rb
+- lib/quadratic_number/real.rb
+- quadratic_number.gemspec
+homepage: https://github.com/hmmnrst/quadratic_number
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Quadratic class
+test_files: []