dual_number 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 061ec78cf2429f13404c06c8e8a4bdb36af51462
+  data.tar.gz: 695f42175ea733d454f68ae949282cecf7ffd96b
+SHA512:
+  metadata.gz: c015b6626198929c32cbf8fa8ee9b0d2998db960e751939ba74c0aec214871e7266d2c134603212fb7bff8ab5a5aeb606dc34b0510f1825d42634145a25ca538
+  data.tar.gz: a076c9c95b69cc4c1d1e06e58468fd3e28683dc1bb331d03f4d86636729109cbe042b68f9163319b1f644c65fbf368f03ba9f89e2493a13b23c8083173e8ae18

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org/'
+
+gemspec

data/LICENSE

@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>

data/README.md

@@ -0,0 +1,51 @@
+# dual_number
+
+This library provides a Ruby implementation of [dual numbers](https://en.wikipedia.org/wiki/Automatic_differentiation), which are useful for forward mode [automatic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation).
+
+It is intended to accompany the article [“Automatic differentiation in Ruby”](http://codon.com/automatic-differentiation-in-ruby).
+
+That article explains the details, but here’s a brief demonstration:
+
+```irb
+$ irb -Ilib
+>> require 'dual_number'
+=> true
+
+>> x = DualNumber(1, 2)
+=> (1+2ε)
+
+>> y = DualNumber(3, 4)
+=> (3+4ε)
+
+>> x + y
+=> (4+6ε)
+
+>> x * y
+=> (3+10ε)
+
+>> (x + 3) * 4
+=> (16+8ε)
+
+>> 3 + (4 * x)
+=> (7+8ε)
+```
+
+One application of dual numbers is to use the second (“dual”) component to represent the derivative of the first (“real”) component. This lets us find the derivative of a function at a particular value by just passing in a dual number instead of a normal number:
+
+```irb
+>> def distance(time:)
+     time * Math.sin(time * time) + 1
+   end
+=> :distance
+
+>> value_and_derivative = distance(time: DualNumber(3, 1))
+=> (2.2363554557252696-15.988226228682427ε)
+
+>> value_and_derivative.real
+=> 2.2363554557252696
+
+>> value_and_derivative.dual
+=> -15.988226228682427
+```
+
+If you have any questions, please get in touch via [Twitter](http://twitter.com/tomstuart) or [email](mailto:tom@codon.com). If you find any bugs or other problems with the code, please [open an issue](https://github.com/tomstuart/dual_number/issues/new).

data/dual_number.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dual_number/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dual_number'
+  spec.version       = DualNumber::VERSION
+  spec.author        = 'Tom Stuart'
+  spec.email         = 'tom@codon.com'
+
+  spec.summary       = 'A Ruby implementation of dual numbers.'
+  spec.homepage      = 'https://github.com/tomstuart/dual_number'
+  spec.license       = 'CC0-1.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rspec', '~> 3.4'
+end

data/lib/dual_number.rb

@@ -0,0 +1,129 @@
+class DualNumber
+  attr_accessor :real, :dual
+  private :real=, :dual=
+
+  def initialize(real:, dual:)
+    self.real = real
+    self.dual = dual
+  end
+
+  def to_s
+    [real, (dual < 0 ? '-' : '+'), dual.abs, 'ε'].join
+  end
+
+  def inspect
+    "(#{to_s})"
+  end
+
+  def ==(other)
+    other.instance_of?(DualNumber) && [real, dual] == [other.real, other.dual]
+  end
+
+  def +(argument)
+    with_dual_number(argument) do |other|
+      DualNumber.new \
+        real: real + other.real,
+        dual: dual + other.dual
+    end
+  end
+
+  def -(argument)
+    with_dual_number(argument) do |other|
+      DualNumber.new \
+        real: real - other.real,
+        dual: dual - other.dual
+    end
+  end
+
+  def *(argument)
+    with_dual_number(argument) do |other|
+      DualNumber.new \
+        real: real * other.real,
+        dual: real * other.dual + dual * other.real
+    end
+  end
+
+  def /(argument)
+    with_dual_number(argument) do |other|
+      DualNumber.new \
+        real: real / other.real,
+        dual: (dual * other.real - real * other.dual) / (other.real * other.real)
+    end
+  end
+
+  def -@
+    self * -1
+  end
+
+  def **(power)
+    DualNumber.new \
+      real: real ** power,
+      dual: power * dual * (real ** (power - 1))
+  end
+
+  def coerce(other)
+    [DualNumber(other), self]
+  end
+
+  private
+
+  def with_dual_number(argument)
+    yield DualNumber(argument)
+  end
+end
+
+module Kernel
+  def DualNumber(real, dual = 0)
+    case real
+    when DualNumber
+      real
+    else
+      DualNumber.new(real: real, dual: dual)
+    end
+  end
+end
+
+Math.singleton_class.prepend Module.new {
+  def self.def_for_dual_number(method_name, &block)
+    define_method method_name do |arg, *args|
+      case arg
+      when DualNumber
+        instance_exec arg, *args, &block
+      else
+        super arg, *args
+      end
+    end
+  end
+
+  def_for_dual_number :sin do |x|
+    DualNumber.new \
+      real: sin(x.real),
+      dual: x.dual * cos(x.real)
+  end
+
+  def_for_dual_number :cos do |x|
+    DualNumber.new \
+      real: cos(x.real),
+      dual: -x.dual * sin(x.real)
+  end
+
+  def_for_dual_number :exp do |x|
+    DualNumber.new \
+      real: exp(x.real),
+      dual: exp(x.real) * x.dual
+  end
+
+  def_for_dual_number :log do |x, base = Math::E|
+    DualNumber.new \
+      real: log(x.real, base),
+      dual: x.dual / (x.real * log(base))
+  end
+
+  def_for_dual_number :sqrt do |x|
+    DualNumber.new \
+      real: sqrt(x.real),
+      dual: x.dual / (2 * sqrt(x.real))
+  end
+}
+
+require 'dual_number/version'

data/lib/dual_number/version.rb

@@ -0,0 +1,3 @@
+class DualNumber
+  VERSION = '0.1.0'
+end

data/spec/dual_number_spec.rb

@@ -0,0 +1,290 @@
+require 'dual_number'
+
+RSpec.describe 'dual numbers' do
+  describe 'constructor (and getters)' do
+    context 'with a real argument' do
+      let(:result) { DualNumber(2) }
+
+      it 'creates a dual number' do
+        expect(result).to be_a DualNumber
+      end
+
+      it 'uses the real part' do
+        expect(result.real).to eq 2
+      end
+
+      it 'uses zero for the dual part' do
+        expect(result.dual).to be_zero
+      end
+    end
+
+    context 'with real and dual arguments' do
+      let(:result) { DualNumber(2, 3) }
+
+      it 'creates a dual number' do
+        expect(result).to be_a DualNumber
+      end
+
+      it 'uses the real part' do
+        expect(result.real).to eq 2
+      end
+
+      it 'uses the dual part' do
+        expect(result.dual).to eq 3
+      end
+    end
+
+    context 'with an argument that’s already a dual number' do
+      let(:result) { DualNumber(DualNumber(2, 3)) }
+
+      it 'creates a dual number' do
+        expect(result).to be_a DualNumber
+      end
+
+      it 'uses the real part' do
+        expect(result.real).to eq 2
+      end
+
+      it 'uses the dual part' do
+        expect(result.dual).to eq 3
+      end
+    end
+  end
+
+  describe 'string representation' do
+    specify { expect(DualNumber(2, 3).to_s).to eq '2+3ε' }
+    specify { expect(DualNumber(2, -3).to_s).to eq '2-3ε' }
+
+    specify { expect(DualNumber(2, 3).inspect).to eq '(2+3ε)' }
+    specify { expect(DualNumber(2, -3).inspect).to eq '(2-3ε)' }
+  end
+
+  describe 'equality' do
+    context 'when the real and dual parts are equal' do
+      it 'returns true' do
+        expect(DualNumber(2, 3)).to eq DualNumber(2, 3)
+      end
+    end
+
+    context 'when the real parts are not equal' do
+      it 'returns false' do
+        expect(DualNumber(2, 3)).not_to eq DualNumber(5, 3)
+      end
+    end
+
+    context 'when the dual parts are not equal' do
+      it 'returns false' do
+        expect(DualNumber(2, 3)).not_to eq DualNumber(2, 5)
+      end
+    end
+
+    context 'when the other object is not a dual number' do
+      it 'returns false' do
+        expect(DualNumber(2, 3)).not_to eq 5
+      end
+    end
+  end
+
+  describe 'arithmetic' do
+    describe 'addition' do
+      let(:result) { DualNumber(2, 3) + DualNumber(5, 7) }
+
+      it 'adds the real parts' do
+        expect(result.real).to eq 2 + 5
+      end
+
+      it 'adds the dual parts' do
+        expect(result.dual).to eq 3 + 7
+      end
+    end
+
+    describe 'subtraction' do
+      let(:result) { DualNumber(2, 3) - DualNumber(5, 7) }
+
+      it 'subtracts the real parts' do
+        expect(result.real).to eq 2 - 5
+      end
+
+      it 'subtracts the dual parts' do
+        expect(result.dual).to eq 3 - 7
+      end
+    end
+
+    describe 'multiplication' do
+      let(:result) { DualNumber(2, 3) * DualNumber(5, 7) }
+
+      it 'multiplies the real parts' do
+        expect(result.real).to eq 2 * 5
+      end
+
+      it 'multiplies opposite parts and sums them to get the dual part' do
+        expect(result.dual).to eq (2 * 7) + (3 * 5)
+      end
+    end
+
+    describe 'division' do
+      let(:result) { DualNumber(2.0, 3.0) / DualNumber(5.0, 7.0) }
+
+      it 'divides the real parts' do
+        expect(result.real).to be_roughly 2.0 / 5.0
+      end
+
+      it 'multiplies opposite parts, subtracts them and divides by the square of the real divisor to get the dual part' do
+        expect(result.dual).to be_roughly ((3.0 * 5.0) - (2.0 * 7.0)) / (5.0 * 5.0)
+      end
+    end
+
+    describe 'unary negation' do
+      let(:result) { -DualNumber(2, 3) }
+
+      it 'negates the real part' do
+        expect(result.real).to eq(-2)
+      end
+
+      it 'negates the dual part' do
+        expect(result.dual).to eq(-3)
+      end
+    end
+
+    describe 'exponentiation' do
+      let(:result) { DualNumber(2, 3) ** 5 }
+
+      it 'raises the real part to the power' do
+        expect(result.real).to eq 32
+      end
+
+      it 'multiplies the power, the dual part and the real part raised to the previous power to get the dual part' do
+        expect(result.dual).to eq 240
+      end
+    end
+
+    describe 'automatic coercion' do
+      context 'of the left operand' do
+        let(:a) { 2.0 }
+        let(:b) { DualNumber(3.0, 5.0) }
+
+        specify { expect(a + b).to eq DualNumber(a) + b }
+        specify { expect(a - b).to eq DualNumber(a) - b }
+        specify { expect(a * b).to eq DualNumber(a) * b }
+        specify { expect(a / b).to eq DualNumber(a) / b }
+      end
+
+      context 'of the right operand' do
+        let(:a) { DualNumber(2.0, 3.0) }
+        let(:b) { 5.0 }
+
+        specify { expect(a + b).to eq a + DualNumber(b) }
+        specify { expect(a - b).to eq a - DualNumber(b) }
+        specify { expect(a * b).to eq a * DualNumber(b) }
+        specify { expect(a / b).to eq a / DualNumber(b) }
+      end
+    end
+  end
+
+  describe 'mathematical functions' do
+    describe 'sine' do
+      def position_at(time:)
+        Math.sin(time)
+      end
+
+      specify { expect(position_at(time: 0)).to be_roughly 0 }
+      specify { expect(position_at(time: Math::PI / 2)).to be_roughly 1 }
+      specify { expect(position_at(time: Math::PI)).to be_roughly 0 }
+      specify { expect(position_at(time: 3 * (Math::PI / 2))).to be_roughly(-1) }
+
+      specify { expect(position_at(time: DualNumber(0, 1)).real).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(Math::PI / 2, 1)).real).to be_roughly 1 }
+      specify { expect(position_at(time: DualNumber(Math::PI, 1)).real).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(3 * (Math::PI / 2), 1)).real).to be_roughly(-1) }
+
+      specify { expect(position_at(time: DualNumber(0, 1)).dual).to be_roughly 1 }
+      specify { expect(position_at(time: DualNumber(Math::PI / 2, 1)).dual).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(Math::PI, 1)).dual).to be_roughly(-1) }
+      specify { expect(position_at(time: DualNumber(3 * (Math::PI / 2), 1)).dual).to be_roughly 0 }
+    end
+
+    describe 'cosine' do
+      def position_at(time:)
+        Math.cos(time)
+      end
+
+      specify { expect(position_at(time: 0)).to be_roughly 1 }
+      specify { expect(position_at(time: Math::PI / 2)).to be_roughly 0 }
+      specify { expect(position_at(time: Math::PI)).to be_roughly(-1) }
+      specify { expect(position_at(time: 3 * (Math::PI / 2))).to be_roughly 0 }
+
+      specify { expect(position_at(time: DualNumber(0, 1)).real).to be_roughly 1 }
+      specify { expect(position_at(time: DualNumber(Math::PI / 2, 1)).real).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(Math::PI, 1)).real).to be_roughly(-1) }
+      specify { expect(position_at(time: DualNumber(3 * (Math::PI / 2), 1)).real).to be_roughly 0 }
+
+      specify { expect(position_at(time: DualNumber(0, 1)).dual).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(Math::PI / 2, 1)).dual).to be_roughly(-1) }
+      specify { expect(position_at(time: DualNumber(Math::PI, 1)).dual).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(3 * (Math::PI / 2), 1)).dual).to be_roughly 1 }
+    end
+
+    describe 'natural exponential' do
+      def position_at(time:)
+        Math.exp(time)
+      end
+
+      specify { expect(position_at(time: 0)).to be_roughly Math::E ** 0 }
+      specify { expect(position_at(time: 1)).to be_roughly Math::E ** 1 }
+      specify { expect(position_at(time: 2)).to be_roughly Math::E ** 2 }
+      specify { expect(position_at(time: 3)).to be_roughly Math::E ** 3 }
+
+      specify { expect(position_at(time: DualNumber(0, 1)).real).to be_roughly Math::E ** 0 }
+      specify { expect(position_at(time: DualNumber(1, 1)).real).to be_roughly Math::E ** 1 }
+      specify { expect(position_at(time: DualNumber(2, 1)).real).to be_roughly Math::E ** 2 }
+      specify { expect(position_at(time: DualNumber(3, 1)).real).to be_roughly Math::E ** 3 }
+
+      specify { expect(position_at(time: DualNumber(0, 1)).dual).to be_roughly Math::E ** 0 }
+      specify { expect(position_at(time: DualNumber(1, 1)).dual).to be_roughly Math::E ** 1 }
+      specify { expect(position_at(time: DualNumber(2, 1)).dual).to be_roughly Math::E ** 2 }
+      specify { expect(position_at(time: DualNumber(3, 1)).dual).to be_roughly Math::E ** 3 }
+    end
+
+    describe 'natural logarithm' do
+      def position_at(time:)
+        Math.log(time)
+      end
+
+      specify { expect(position_at(time: Math::E ** 0)).to be_roughly 0 }
+      specify { expect(position_at(time: Math::E ** 1)).to be_roughly 1 }
+      specify { expect(position_at(time: Math::E ** 2)).to be_roughly 2 }
+      specify { expect(position_at(time: Math::E ** 3)).to be_roughly 3 }
+
+      specify { expect(position_at(time: DualNumber(Math::E ** 0, 1)).real).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(Math::E ** 1, 1)).real).to be_roughly 1 }
+      specify { expect(position_at(time: DualNumber(Math::E ** 2, 1)).real).to be_roughly 2 }
+      specify { expect(position_at(time: DualNumber(Math::E ** 3, 1)).real).to be_roughly 3 }
+
+      specify { expect(position_at(time: DualNumber(Math::E ** 0, 1)).dual).to be_roughly Math::E ** 0 }
+      specify { expect(position_at(time: DualNumber(Math::E ** 1, 1)).dual).to be_roughly Math::E ** -1 }
+      specify { expect(position_at(time: DualNumber(Math::E ** 2, 1)).dual).to be_roughly Math::E ** -2 }
+      specify { expect(position_at(time: DualNumber(Math::E ** 3, 1)).dual).to be_roughly Math::E ** -3 }
+    end
+
+    describe 'square root' do
+      def position_at(time:)
+        Math.sqrt(time)
+      end
+
+      specify { expect(position_at(time: 0 ** 2)).to be_roughly 0 }
+      specify { expect(position_at(time: 1 ** 2)).to be_roughly 1 }
+      specify { expect(position_at(time: 2 ** 2)).to be_roughly 2 }
+      specify { expect(position_at(time: 3 ** 2)).to be_roughly 3 }
+
+      specify { expect(position_at(time: DualNumber(0 ** 2, 1)).real).to be_roughly 0 }
+      specify { expect(position_at(time: DualNumber(1 ** 2, 1)).real).to be_roughly 1 }
+      specify { expect(position_at(time: DualNumber(2 ** 2, 1)).real).to be_roughly 2 }
+      specify { expect(position_at(time: DualNumber(3 ** 2, 1)).real).to be_roughly 3 }
+
+      specify { expect(position_at(time: DualNumber(0 ** 2, 1)).dual).to eq 1.0 / 0 }
+      specify { expect(position_at(time: DualNumber(1 ** 2, 1)).dual).to be_roughly 1.0 / 2 }
+      specify { expect(position_at(time: DualNumber(2 ** 2, 1)).dual).to be_roughly 1.0 / 4 }
+      specify { expect(position_at(time: DualNumber(3 ** 2, 1)).dual).to be_roughly 1.0 / 6 }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  config.include Module.new {
+    def be_roughly(expected)
+      be_within(1e-10).of(expected)
+    end
+  }
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: dual_number
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Stuart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: 
+email: tom@codon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- dual_number.gemspec
+- lib/dual_number.rb
+- lib/dual_number/version.rb
+- spec/dual_number_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tomstuart/dual_number
+licenses:
+- CC0-1.0
+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.1
+signing_key: 
+specification_version: 4
+summary: A Ruby implementation of dual numbers.
+test_files:
+- spec/dual_number_spec.rb
+- spec/spec_helper.rb