pretty_round 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d43638c5621ed6510153ba224064c8e72a20265d
-  data.tar.gz: e0a4bf7bc31b3abde7ec213e0391d8f88f94b243
+SHA256:
+  metadata.gz: 7686e8cacf564521de57d2e567b3621bae97da5bad44581ea6741d004b9d49f3
+  data.tar.gz: '0018d0c5354ddc58f816675d3c40dfb5c43e276db6d831413a6e6214762409ef'
 SHA512:
-  metadata.gz: e6abde717b245bdc2eba773eb7cc7fa09f221dbc09803fe6ee96376f812eb7fea0de0e3521a654e32f4308171f879ba7f926b2baa68f358ce83b37e5098f5834
-  data.tar.gz: 2d607ad3107cc7890bedac69a1e96c7d8d774c3b99679b64646a8855986d0ed7f21fb6ef4f51cc2e154575f2920d6b9a86f70283b6c7863003b8fc69f3661715
+  metadata.gz: 9bbd6edc1553103440c5efb95b047024d7fa0ddebd30a837d7d5bf346cad72f101cf722baf5c593bd50081aaea046c009690a5a83ae075cf95a3bf4a85c91b2b
+  data.tar.gz: 35f4e8496f1733bae06955c74c6ae1422d48fc3e9d2ee85797734d73ad0847159736eae135ec7fb024e941be786bb6325b4a45677f683a4411fc20a8cc5446a0

data/LICENSE

@@ -1,22 +1,22 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 diaphragm
-
-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.
-
+The MIT License (MIT)
+
+Copyright (c) 2015 diaphragm
+
+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

@@ -1,89 +1,98 @@
-ruby-pretty-round
-================
-This gem add useful numerical rounding methods to `Numeric` class as shown below.
-- round to nearest multiple
-- round with significant digits
-
-Install
-================
-`$ gem install pretty_round`
-
-Usage
-================
-```rb
-require "pretty_round"
-
-x = 123.456
-
-# round with precision
-x.roundup #=> 124
-x.rounddown(2) #=> 123.45
-
-# round to nearest multiple
-x.mceil(50) #=> 150
-x.mfloor(25) #=> 100
-x.mroundup(2) #=> 124
-x.mrounddown(0.3) #=> 123.3
-x.mround(9.87) #=> 128.31
-
-# round with significant digit
-x.sceil(1) #=> 200
-x.sfloor(2) #=> 120
-x.sroundup(3) #=> 124
-x.srounddown(4) #=> 123.4
-x.sround(5) #=> 123.46
-```
-
-Rounding direction
-================
-- `#*ceil` / `#*floor`: These methods round to the positive / negative infinity direction. Its behavior is same as built-in `#ceil`, `#floor`.
-- `#*roundup` / `#*rounddown`: These methods round to far from / near to 0 direction.
-- `#*round`: These methods round off the absolute value, does not round even. Its behavior is same as built-in `#round`.
-- `#*truncate`: These methods are alias of `#*rounddown`.
-
-Result table is shown below, including ruby built-in rounding methods for comparison.
-An axis of abscissas refers to the receiver and an axis of ordinates refers to the methods.
-```
-              |  1.9  1.1 -1.1 -1.9
------------------------------------
-.ceil         |    2    2   -1   -1 (ruby built-in)
-.floor        |    1    1   -2   -2 (ruby built-in)
-.roundup      |    2    2   -2   -2
-.rounddown    |    1    1   -1   -1
-.round        |    2    1   -1   -2 (ruby built-in)
-.truncate     |    1    1   -1   -1 (ruby built-in)
-.mceil(1)     |    2    2   -1   -1
-.mfloor(1)    |    1    1   -2   -2
-.mroundup(1)  |    2    2   -2   -2
-.mrounddown(1)|    1    1   -1   -1
-.mround(1)    |    2    1   -1   -2
-.mtruncate(1) |    1    1   -1   -1
-.sceil(1)     |    2    2   -1   -1
-.sfloor(1)    |    1    1   -2   -2
-.sroundup(1)  |    2    2   -2   -2
-.srounddown(1)|    1    1   -1   -1
-.sround(1)    |    2    1   -1   -2
-.struncate(1) |    1    1   -1   -1
-```
-
-Also, try to run `examples/example.rb`
-
-
-Known Bugs
-================
-Float presision
-----------------
-```rb
-1.2.mrounddown(0.1) #=> 1.1
-```
-Oops... Resulting 1.2 is expected.
-
-Becouse, 
-```rb
-1.2.divmod(0.1) #=> [11, 0.0999999999999999]
-```
-
-To avoid this bug, please use `Rational`.
-```rb
-1.2r.mrounddown(0.1r) #=> (6/5)
-```
+ruby-pretty-round
+================
+This gem add useful numerical rounding methods to `Numeric` class as shown below.
+- round to nearest multiple
+- round with significant digits
+
+Install
+================
+`$ gem install pretty_round`
+
+Usage
+================
+```rb
+require "pretty_round"
+
+x = 123.456
+
+# round with precision
+x.roundup #=> 124
+x.rounddown(2) #=> 123.45
+
+# round to nearest multiple
+x.mceil(50) #=> 150
+x.mfloor(25) #=> 100
+x.mroundup(2) #=> 124
+x.mrounddown(0.3) #=> 123.3
+x.mround(9.87) #=> 128.31
+
+# round with significant digit
+x.sceil(1) #=> 200
+x.sfloor(2) #=> 120
+x.sroundup(3) #=> 124
+x.srounddown(4) #=> 123.4
+x.sround(5) #=> 123.46
+```
+
+Refinements
+----------------
+When `require 'pretty_round'`, rounding methods are included in **global scope**.
+To include in limited scope, please load `pretty_round/core` and use refinements.
+```rb
+require 'pretty_round/core'
+using PrettyRound
+```
+
+Rounding direction
+================
+- `#*ceil` / `#*floor`: These methods round to the positive / negative infinity direction. Its behavior is same as built-in `#ceil`, `#floor`.
+- `#*roundup` / `#*rounddown`: These methods round to far from / near to 0 direction.
+- `#*round`: These methods round off the absolute value, does not round even. Its behavior is same as built-in `#round`.
+- `#*truncate`: These methods are alias of `#*rounddown`.
+
+Result table is shown below, including ruby built-in rounding methods for comparison.
+An axis of abscissas refers to the receiver and an axis of ordinates refers to the methods.
+```
+              |  1.9  1.1 -1.1 -1.9
+-----------------------------------
+.ceil         |    2    2   -1   -1 (ruby built-in)
+.floor        |    1    1   -2   -2 (ruby built-in)
+.roundup      |    2    2   -2   -2
+.rounddown    |    1    1   -1   -1
+.round        |    2    1   -1   -2 (ruby built-in)
+.truncate     |    1    1   -1   -1 (ruby built-in)
+.mceil(1)     |    2    2   -1   -1
+.mfloor(1)    |    1    1   -2   -2
+.mroundup(1)  |    2    2   -2   -2
+.mrounddown(1)|    1    1   -1   -1
+.mround(1)    |    2    1   -1   -2
+.mtruncate(1) |    1    1   -1   -1
+.sceil(1)     |    2    2   -1   -1
+.sfloor(1)    |    1    1   -2   -2
+.sroundup(1)  |    2    2   -2   -2
+.srounddown(1)|    1    1   -1   -1
+.sround(1)    |    2    1   -1   -2
+.struncate(1) |    1    1   -1   -1
+```
+
+Also, try to run `examples/example.rb`
+
+
+Known Bugs
+================
+Float presision
+----------------
+```rb
+1.2.mrounddown(0.1) #=> 1.1
+```
+Oops... Resulting 1.2 is expected.
+
+Becouse,
+```rb
+1.2.divmod(0.1) #=> [11, 0.0999999999999999]
+```
+
+To avoid this bug, please use `Rational`.
+```rb
+1.2r.mrounddown(0.1r) #=> (6/5)
+```

data/examples/example.rb

@@ -1,32 +1,32 @@
-
-require "pretty_round"
-
-puts "* Rounding to nearerst multiple"
-xs = %w[2.9 2.5 2.1 -2.1 -2.5 -2.9].map(&:to_r)
-ns = %w[0.1 0.2 1 2 -0.1 -0.2 -1 -2].map(&:to_r)
-
-%i[mceil mfloor mroundup mrounddown mround].each do |mthd|
-  puts "##{mthd}"
-  puts " "*6  + "|" + ns.map{|x| x.to_f.to_s.rjust(6)}.join
-  puts "-"*(6+1+6*ns.size)
-  xs.each do |x|
-    puts ("%6.1f"%x) + "|" + ns.map{|n| x.send(mthd, n)}.map{|n| ("%6.1f"%n)}.join
-  end
-  puts
-end
-puts
-
-
-puts "* Rounding with significant digit"
-xs = [0.12345, 123.45, 12345, -0.12345, -123.45, -12345]
-ns = [*1..5]
-
-%i[sceil sfloor sroundup srounddown sround].each do |mthd|
-  puts "##{mthd}"
-  puts " "*13  + "|" + ns.map{|x| x.to_s.center(13)}.join
-  puts "-"*(13+1+13*ns.size)
-  xs.each do |x|
-    puts ("% 13.5f"%x) + "|" + ns.map{|n| x.send(mthd, n)}.map{|n| ("% 13.5f"%n)}.join
-  end
-  puts
-end
+
+require "pretty_round"
+
+puts "* Rounding to nearerst multiple"
+xs = %w[2.9 2.5 2.1 -2.1 -2.5 -2.9].map(&:to_r)
+ns = %w[0.1 0.2 1 2 -0.1 -0.2 -1 -2].map(&:to_r)
+
+%i[mceil mfloor mroundup mrounddown mround].each do |mthd|
+  puts "##{mthd}"
+  puts " "*6  + "|" + ns.map{|x| x.to_f.to_s.rjust(6)}.join
+  puts "-"*(6+1+6*ns.size)
+  xs.each do |x|
+    puts ("%6.1f"%x) + "|" + ns.map{|n| x.send(mthd, n)}.map{|n| ("%6.1f"%n)}.join
+  end
+  puts
+end
+puts
+
+
+puts "* Rounding with significant digit"
+xs = [0.12345, 123.45, 12345, -0.12345, -123.45, -12345]
+ns = [*1..5]
+
+%i[sceil sfloor sroundup srounddown sround].each do |mthd|
+  puts "##{mthd}"
+  puts " "*13  + "|" + ns.map{|x| x.to_s.center(13)}.join
+  puts "-"*(13+1+13*ns.size)
+  xs.each do |x|
+    puts ("% 13.5f"%x) + "|" + ns.map{|n| x.send(mthd, n)}.map{|n| ("% 13.5f"%n)}.join
+  end
+  puts
+end

data/examples/example2.rb

@@ -1,19 +1,19 @@
-
-require "pretty_round"
-
-xs = [1.9, 1.1, -1.1, -1.9]
-
-puts " "*14 + "|" + xs.map{|x| x.to_s.rjust(5)}.join
-puts "-"*(14+1+xs.size*5)
-
-%i[ceil floor roundup rounddown round truncate].each do |mthd|
-  puts ".#{mthd}".ljust(14)+ "|" + xs.map{|x| x.send(mthd)}.map{|x| x.to_i.to_s.rjust(5)}.join
-end
-
-%i[mceil mfloor mroundup mrounddown mround mtruncate].each do |mthd|
-  puts ".#{mthd}(1)".ljust(14)+ "|" + xs.map{|x| x.send(mthd,1)}.map{|x| x.to_i.to_s.rjust(5)}.join
-end
-
-%i[sceil sfloor sroundup srounddown sround struncate].each do |mthd|
-  puts ".#{mthd}(1)".ljust(14)+ "|" + xs.map{|x| x.send(mthd,1)}.map{|x| x.to_i.to_s.rjust(5)}.join
-end
+
+require "pretty_round"
+
+xs = [1.9, 1.1, -1.1, -1.9]
+
+puts " "*14 + "|" + xs.map{|x| x.to_s.rjust(5)}.join
+puts "-"*(14+1+xs.size*5)
+
+%i[ceil floor roundup rounddown round truncate].each do |mthd|
+  puts ".#{mthd}".ljust(14)+ "|" + xs.map{|x| x.send(mthd)}.map{|x| x.to_i.to_s.rjust(5)}.join
+end
+
+%i[mceil mfloor mroundup mrounddown mround mtruncate].each do |mthd|
+  puts ".#{mthd}(1)".ljust(14)+ "|" + xs.map{|x| x.send(mthd,1)}.map{|x| x.to_i.to_s.rjust(5)}.join
+end
+
+%i[sceil sfloor sroundup srounddown sround struncate].each do |mthd|
+  puts ".#{mthd}(1)".ljust(14)+ "|" + xs.map{|x| x.send(mthd,1)}.map{|x| x.to_i.to_s.rjust(5)}.join
+end

data/lib/pretty_round/core.rb

@@ -0,0 +1,113 @@
+
+module PrettyRound
+  # Rounding up with given precision.
+  # This method round up to far from 0 direction.
+  def roundup(digit=0)
+    abs.ceil(digit) * (positive? ? 1 : -1)
+  end
+
+  # Rounding down with given precision.
+  # This method round down to near to 0 direction.
+  def rounddown(digit=0)
+    abs.floor(digit) * (positive? ? 1 : -1)
+  end
+
+
+  # Return nearest multiple of given number that is equal to or greater than self.
+  # This method round up to the positive infinity direction.
+  def mceil(num)
+    if (x = num * div(num)) == self
+      self
+    else
+      [x, x+num].max
+    end
+  end
+
+  # Return nearest multiple of given number that is equal to or less than self.
+  # This method round down to the negative infinity direction.
+  def mfloor(num)
+    if (x = num * div(num)) == self
+      self
+    else
+      [x, x+num].min
+    end
+  end
+
+  # Return nearest multiple of given number that the absolute is equal to or greater than self.
+  # This method round up to far from 0 direction.
+  def mroundup(num)
+    if (x = num * div(num)) == self
+      self
+    else
+      [x, x+num].max_by(&:abs)
+    end
+  end
+
+  # Return nearest multiple of given number that the absolute is equal to or less than self.
+  # This method round down to near to 0 direction.
+  def mrounddown(num)
+    if (x = num * div(num)) == self
+      self
+    else
+      [x, x+num].min_by(&:abs)
+    end
+  end
+
+  # Retuen nearest multiple of given number.
+  # When self is median of multiple of given number, return the multiple that have greater absolute.
+  def mround(num)
+    if (x = num * div(num)) == self
+      self
+    elsif x + x+num == self + self # if self is median
+      [x, x+num].max_by(&:abs)
+    else
+      [x, x+num].min_by{|t| (t - self).abs}
+    end
+  end
+
+  alias_method :mtruncate, :mrounddown
+
+
+  # Ceiling with given significant digit.
+  def sceil(digit)
+    return self if zero?
+    selfdigit = Math.log10(abs).floor + 1
+    ceil(digit - selfdigit)
+  end
+
+  # Flooring with given significant digit.
+  def sfloor(digit)
+    return self if zero?
+    selfdigit = Math.log10(abs).floor + 1
+    floor(digit - selfdigit)
+  end
+
+  # Rounding up with given significant digit.
+  def sroundup(digit)
+    return self if zero?
+    selfdigit = Math.log10(abs).floor + 1
+    abs.ceil(digit - selfdigit) * (positive? ? 1 : -1)
+  end
+
+  # Rounding down with given significant digit.
+  def srounddown(digit)
+    return self if zero?
+    selfdigit = Math.log10(abs).floor + 1
+    abs.floor(digit - selfdigit) * (positive? ? 1 : -1)
+  end
+
+  # Rounding off with given significant digit.
+  def sround(digit)
+    return self if zero?
+    selfdigit = Math.log10(abs).floor + 1
+    round(digit - selfdigit)
+  end
+
+  alias_method :struncate, :srounddown
+end
+
+module PrettyRound
+  refine Numeric do
+    include(PrettyRound)
+  end
+end

data/lib/pretty_round.rb

@@ -1,112 +1,3 @@
-
-class Numeric
-  # Rounding up with given precision.
-  # This method round up to far from 0 direction.
-  def roundup(digit=0)
-    x = 10**(-digit)
-    if self > 0
-      quo(x).ceil * x
-    else
-      quo(x).floor * x
-    end
-  end
-
-  # Rounding down with given precision.
-  # This method round down to near to 0 direction.
-  def rounddown(digit=0)
-    x = 10**(-digit)
-    if self > 0
-      quo(x).floor * x
-    else
-      quo(x).ceil * x
-    end
-  end
-  
-  
-  # Return nearest multiple of given number that is equal to or greater than self.
-  # This method round up to the positive infinity direction.
-  def mceil(num)
-    if (x = num * div(num)) == self
-      self
-    else
-      [x, x+num].max
-    end
-  end
-  
-  # Return nearest multiple of given number that is equal to or less than self.
-  # This method round down to the negative infinity direction.
-  def mfloor(num)
-    if (x = num * div(num)) == self
-      self
-    else
-      [x, x+num].min
-    end
-  end
-  
-  # Return nearest multiple of given number that the absolute is equal to or greater than self.
-  # This method round up to far from 0 direction.
-  def mroundup(num)
-    if (x = num * div(num)) == self
-      self
-    else
-      [x, x+num].max_by(&:abs)
-    end
-  end
-  
-  # Return nearest multiple of given number that the absolute is equal to or less than self.
-  # This method round down to near to 0 direction.
-  def mrounddown(num)
-    if (x = num * div(num)) == self
-      self
-    else
-      [x, x+num].min_by(&:abs)
-    end
-  end
-  
-  # Retuen nearest multiple of given number.
-  # When self is median of multiple of given number, return the multiple that have greater absolute.
-  def mround(num)
-    if (x = num * div(num)) == self
-      self
-    elsif x + x +num == self + self # if self is median
-      [x, x+num].max_by(&:abs)
-    else
-      [x, x+num].min_by{|t| (t - self).abs}
-    end
-  end
-  
-  alias :mtruncate :mrounddown
-  
-  
-  # Ceiling with given significant digit.
-  def sceil(digit)
-    selfdigit = Math.log10(abs).floor + 1
-    mceil(10**(selfdigit - digit))
-  end
-  
-  # Flooring with given significant digit.
-  def sfloor(digit)
-    selfdigit = Math.log10(abs).floor + 1
-    mfloor(10**(selfdigit - digit))
-  end
-  
-  # Rounding up with given significant digit.
-  def sroundup(digit)
-    selfdigit = Math.log10(abs).floor + 1
-    mroundup(10**(selfdigit - digit))
-  end
-  
-  # Rounding down with given significant digit.
-  def srounddown(digit)
-    selfdigit = Math.log10(abs).floor + 1
-    mrounddown(10**(selfdigit - digit))
-  end
-  
-  # Rounding off with given significant digit.
-  def sround(digit)
-    selfdigit = Math.log10(abs).floor + 1
-    mround(10**(selfdigit - digit))
-  end
-  
-  alias :struncate :srounddown
-end
+
+require_relative './pretty_round/core'
+Numeric.include(PrettyRound)

data/test/test_pretty_round.rb

@@ -1,251 +1,273 @@
-require 'minitest'
-require 'pretty_round'
-
-Minitest.autorun
-
-class TEST_PrettyRound < Minitest::Test
-  def assert_ep(expect, target)
-    assert_in_epsilon(expect, target, Float::EPSILON)
-  end
-  
-  def test_roundup
-    assert_ep  2,  1.9.roundup
-    assert_ep  2,  1.5.roundup
-    assert_ep  2,  1.1.roundup
-    assert_ep -2, -1.1.roundup
-    assert_ep -2, -1.5.roundup
-    assert_ep -2, -1.9.roundup
-    
-    x = 123.456
-    assert_ep 124, x.roundup
-    assert_ep 123.46, x.roundup(2)
-    assert_ep 200, x.roundup(-2)
-    
-    x = -123.456
-    assert_ep -124, x.roundup
-    assert_ep -123.46, x.roundup(2)
-    assert_ep -200, x.roundup(-2)
-  end
-
-  def test_rounddown
-    assert_ep  1,  1.9.rounddown
-    assert_ep  1,  1.5.rounddown
-    assert_ep  1,  1.1.rounddown
-    assert_ep -1, -1.1.rounddown
-    assert_ep -1, -1.5.rounddown
-    assert_ep -1, -1.9.rounddown
-    
-    x = 123.456
-    assert_ep 123, x.rounddown
-    assert_ep 123.45, x.rounddown(2)
-    assert_ep 100, x.rounddown(-2)
-    
-    x = -123.456
-    assert_ep -123, x.rounddown
-    assert_ep -123.45, x.rounddown(2)
-    assert_ep -100, x.rounddown(-2)
-  end
-  
-  
-  def test_mceil
-    assert_ep  2,  1.9.mceil(1)
-    assert_ep  2,  1.5.mceil(1)
-    assert_ep  2,  1.1.mceil(1)
-    assert_ep -1, -1.1.mceil(1)
-    assert_ep -1, -1.5.mceil(1)
-    assert_ep -1, -1.9.mceil(1)
-    
-    x = 123.456
-    assert_ep 124, x.mceil(-2)
-    assert_ep 123.46, x.mceil(-0.01)
-    assert_ep 125, x.mceil(25)
-    
-    x = -123.456
-    assert_ep -122, x.mceil(-2)
-    assert_ep -123.45, x.mceil(-0.01)
-    assert_ep -100, x.mceil(25)
-  end
-  
-  def test_mfloor
-    assert_ep  1,  1.9.mfloor(1)
-    assert_ep  1,  1.5.mfloor(1)
-    assert_ep  1,  1.1.mfloor(1)
-    assert_ep -2, -1.1.mfloor(1)
-    assert_ep -2, -1.5.mfloor(1)
-    assert_ep -2, -1.9.mfloor(1)
-    
-    x = 123.456
-    assert_ep 122, x.mfloor(-2)
-    assert_ep 123.45, x.mfloor(-0.01)
-    assert_ep 100, x.mfloor(25)
-    
-    x = -123.456
-    assert_ep -124, x.mfloor(-2)
-    assert_ep -123.46, x.mfloor(-0.01)
-    assert_ep -125, x.mfloor(25)
-  end
-  
-  def test_mroundup
-    assert_ep  2,  1.9.mroundup(1)
-    assert_ep  2,  1.5.mroundup(1)
-    assert_ep  2,  1.1.mroundup(1)
-    assert_ep -2, -1.1.mroundup(1)
-    assert_ep -2, -1.5.mroundup(1)
-    assert_ep -2, -1.9.mroundup(1)
-    
-    x = 123.456
-    assert_ep 124, x.mroundup(-2)
-    assert_ep 123.46, x.mroundup(-0.01)
-    assert_ep 125, x.mroundup(25)
-    
-    x = -123.456
-    assert_ep -124, x.mroundup(-2)
-    assert_ep -123.46, x.mroundup(-0.01)
-    assert_ep -125, x.mroundup(25)
-  end
-  
-  def test_mrounddown
-    assert_ep  1,  1.9.mrounddown(1)
-    assert_ep  1,  1.5.mrounddown(1)
-    assert_ep  1,  1.1.mrounddown(1)
-    assert_ep -1, -1.1.mrounddown(1)
-    assert_ep -1, -1.5.mrounddown(1)
-    assert_ep -1, -1.9.mrounddown(1)
-    
-    x = 123.456
-    assert_ep 122, x.mrounddown(-2)
-    assert_ep 123.45, x.mrounddown(-0.01)
-    assert_ep 100, x.mrounddown(25)
-    
-    x = -123.456
-    assert_ep -122, x.mrounddown(-2)
-    assert_ep -123.45, x.mrounddown(-0.01)
-    assert_ep -100, x.mrounddown(25)
-  end
-  
-  def test_mround
-    assert_ep  2,  1.9.mround(1)
-    assert_ep  2,  1.5.mround(1)
-    assert_ep  1,  1.1.mround(1)
-    assert_ep -1, -1.1.mround(1)
-    assert_ep -2, -1.5.mround(1)
-    assert_ep -2, -1.9.mround(1)
-    
-    x = 123.456
-    assert_ep 124, x.mround(-2)
-    assert_ep 123.46, x.mround(-0.01)
-    assert_ep 125, x.mround(25)
-    
-    x = -123.456
-    assert_ep -124, x.mround(-2)
-    assert_ep -123.46, x.mround(-0.01)
-    assert_ep -125, x.mround(25)
-  end
-  
-  def test_mtruncate
-    assert_ep  1,  1.9.mtruncate(1)
-    assert_ep  1,  1.5.mtruncate(1)
-    assert_ep  1,  1.1.mtruncate(1)
-    assert_ep -1, -1.1.mtruncate(1)
-    assert_ep -1, -1.5.mtruncate(1)
-    assert_ep -1, -1.9.mtruncate(1)
-    
-    x = 123.456
-    assert_ep 122, x.mtruncate(-2)
-    assert_ep 123.45, x.mtruncate(-0.01)
-    assert_ep 100, x.mtruncate(25)
-    
-    x = -123.456
-    assert_ep -122, x.mtruncate(-2)
-    assert_ep -123.45, x.mtruncate(-0.01)
-    assert_ep -100, x.mtruncate(25)
-  end
-  
-  
-  def test_sceil
-    x = 123.456
-    assert_ep 200, x.sceil(1)
-    assert_ep 124, x.sceil(3)
-    assert_ep 123.5, x.sceil(4)
-    assert_ep 123.456, x.sceil(6)
-    
-    x = -123.456
-    assert_ep -100, x.sceil(1)
-    assert_ep -123, x.sceil(3)
-    assert_ep -123.4, x.sceil(4)
-    assert_ep -123.456, x.sceil(6)
-  end
-  
-  def test_sfloor
-    x = 123.456
-    assert_ep 100, x.sfloor(1)
-    assert_ep 123, x.sfloor(3)
-    assert_ep 123.4, x.sfloor(4)
-    assert_ep 123.456, x.sfloor(6)
-    
-    x = -123.456
-    assert_ep -200, x.sfloor(1)
-    assert_ep -124, x.sfloor(3)
-    assert_ep -123.5, x.sfloor(4)
-    assert_ep -123.456, x.sfloor(6)
-  end
-  
-  def test_sroundup
-    x = 123.456
-    assert_ep 200, x.sroundup(1)
-    assert_ep 124, x.sroundup(3)
-    assert_ep 123.5, x.sroundup(4)
-    assert_ep 123.456, x.sroundup(6)
-    
-    x = -123.456
-    assert_ep -200, x.sroundup(1)
-    assert_ep -124, x.sroundup(3)
-    assert_ep -123.5, x.sroundup(4)
-    assert_ep -123.456, x.sroundup(6)
-  end
-
-  def test_srounddown
-    x = 123.456
-    assert_ep 100, x.srounddown(1)
-    assert_ep 123, x.srounddown(3)
-    assert_ep 123.4, x.srounddown(4)
-    assert_ep 123.456, x.srounddown(6)
-    
-    x = -123.456
-    assert_ep -100, x.srounddown(1)
-    assert_ep -123, x.srounddown(3)
-    assert_ep -123.4, x.srounddown(4)
-    assert_ep -123.456, x.srounddown(6)
-  end
-
-  def test_sround
-    assert_ep  2,  1.5.sround(1)
-    assert_ep -2, -1.5.sround(1)
-    
-    x = 123.456
-    assert_ep 100, x.sround(1)
-    assert_ep 123, x.sround(3)
-    assert_ep 123.5, x.sround(4)
-    assert_ep 123.456, x.sround(6)
-    
-    x = -123.456
-    assert_ep -100, x.sround(1)
-    assert_ep -123, x.sround(3)
-    assert_ep -123.5, x.sround(4)
-    assert_ep -123.456, x.sround(6)
-  end
-  
-  def test_struncate
-    x = 123.456
-    assert_ep 100, x.struncate(1)
-    assert_ep 123, x.struncate(3)
-    assert_ep 123.4, x.struncate(4)
-    assert_ep 123.456, x.struncate(6)
-    
-    x = -123.456
-    assert_ep -100, x.struncate(1)
-    assert_ep -123, x.struncate(3)
-    assert_ep -123.4, x.struncate(4)
-    assert_ep -123.456, x.struncate(6)
-  end
-end
+require 'minitest'
+# require_relative '../lib/pretty_round'
+require_relative '../lib/pretty_round/core'
+using PrettyRound
+
+Minitest.autorun
+
+class TEST_PrettyRound < Minitest::Test
+  def assert_ep(expect, target)
+    assert_in_epsilon(expect, target, Float::EPSILON)
+  end
+
+  def test_roundup
+    assert_ep  2,  1.9.roundup
+    assert_ep  2,  1.5.roundup
+    assert_ep  2,  1.1.roundup
+    assert_ep -2, -1.1.roundup
+    assert_ep -2, -1.5.roundup
+    assert_ep -2, -1.9.roundup
+
+    x = 123.456
+    assert_ep 124, x.roundup
+    assert_ep 123.46, x.roundup(2)
+    assert_ep 200, x.roundup(-2)
+
+    x = -123.456
+    assert_ep -124, x.roundup
+    assert_ep -123.46, x.roundup(2)
+    assert_ep -200, x.roundup(-2)
+  end
+
+  def test_rounddown
+    assert_ep  1,  1.9.rounddown
+    assert_ep  1,  1.5.rounddown
+    assert_ep  1,  1.1.rounddown
+    assert_ep -1, -1.1.rounddown
+    assert_ep -1, -1.5.rounddown
+    assert_ep -1, -1.9.rounddown
+
+    x = 123.456
+    assert_ep 123, x.rounddown
+    assert_ep 123.45, x.rounddown(2)
+    assert_ep 100, x.rounddown(-2)
+
+    x = -123.456
+    assert_ep -123, x.rounddown
+    assert_ep -123.45, x.rounddown(2)
+    assert_ep -100, x.rounddown(-2)
+  end
+
+
+  def test_mceil
+    assert_ep  2,  1.9.mceil(1)
+    assert_ep  2,  1.5.mceil(1)
+    assert_ep  2,  1.1.mceil(1)
+    assert_ep -1, -1.1.mceil(1)
+    assert_ep -1, -1.5.mceil(1)
+    assert_ep -1, -1.9.mceil(1)
+
+    x = 123.456
+    assert_ep 124, x.mceil(-2)
+    assert_ep 123.46, x.mceil(-0.01)
+    assert_ep 125, x.mceil(25)
+
+    x = -123.456
+    assert_ep -122, x.mceil(-2)
+    assert_ep -123.45, x.mceil(-0.01)
+    assert_ep -100, x.mceil(25)
+  end
+
+  def test_mfloor
+    assert_ep  1,  1.9.mfloor(1)
+    assert_ep  1,  1.5.mfloor(1)
+    assert_ep  1,  1.1.mfloor(1)
+    assert_ep -2, -1.1.mfloor(1)
+    assert_ep -2, -1.5.mfloor(1)
+    assert_ep -2, -1.9.mfloor(1)
+
+    x = 123.456
+    assert_ep 122, x.mfloor(-2)
+    assert_ep 123.45, x.mfloor(-0.01)
+    assert_ep 100, x.mfloor(25)
+
+    x = -123.456
+    assert_ep -124, x.mfloor(-2)
+    assert_ep -123.46, x.mfloor(-0.01)
+    assert_ep -125, x.mfloor(25)
+  end
+
+  def test_mroundup
+    assert_ep  2,  1.9.mroundup(1)
+    assert_ep  2,  1.5.mroundup(1)
+    assert_ep  2,  1.1.mroundup(1)
+    assert_ep -2, -1.1.mroundup(1)
+    assert_ep -2, -1.5.mroundup(1)
+    assert_ep -2, -1.9.mroundup(1)
+
+    x = 123.456
+    assert_ep 124, x.mroundup(-2)
+    assert_ep 123.46, x.mroundup(-0.01)
+    assert_ep 125, x.mroundup(25)
+
+    x = -123.456
+    assert_ep -124, x.mroundup(-2)
+    assert_ep -123.46, x.mroundup(-0.01)
+    assert_ep -125, x.mroundup(25)
+  end
+
+  def test_mrounddown
+    assert_ep  1,  1.9.mrounddown(1)
+    assert_ep  1,  1.5.mrounddown(1)
+    assert_ep  1,  1.1.mrounddown(1)
+    assert_ep -1, -1.1.mrounddown(1)
+    assert_ep -1, -1.5.mrounddown(1)
+    assert_ep -1, -1.9.mrounddown(1)
+
+    x = 123.456
+    assert_ep 122, x.mrounddown(-2)
+    assert_ep 123.45, x.mrounddown(-0.01)
+    assert_ep 100, x.mrounddown(25)
+
+    x = -123.456
+    assert_ep -122, x.mrounddown(-2)
+    assert_ep -123.45, x.mrounddown(-0.01)
+    assert_ep -100, x.mrounddown(25)
+  end
+
+  def test_mround
+    assert_ep  2,  1.9.mround(1)
+    assert_ep  2,  1.5.mround(1)
+    assert_ep  1,  1.1.mround(1)
+    assert_ep -1, -1.1.mround(1)
+    assert_ep -2, -1.5.mround(1)
+    assert_ep -2, -1.9.mround(1)
+
+    x = 123.456
+    assert_ep 124, x.mround(-2)
+    assert_ep 123.46, x.mround(-0.01)
+    assert_ep 125, x.mround(25)
+
+    x = -123.456
+    assert_ep -124, x.mround(-2)
+    assert_ep -123.46, x.mround(-0.01)
+    assert_ep -125, x.mround(25)
+  end
+
+  def test_mtruncate
+    assert_ep  1,  1.9.mtruncate(1)
+    assert_ep  1,  1.5.mtruncate(1)
+    assert_ep  1,  1.1.mtruncate(1)
+    assert_ep -1, -1.1.mtruncate(1)
+    assert_ep -1, -1.5.mtruncate(1)
+    assert_ep -1, -1.9.mtruncate(1)
+
+    x = 123.456
+    assert_ep 122, x.mtruncate(-2)
+    assert_ep 123.45, x.mtruncate(-0.01)
+    assert_ep 100, x.mtruncate(25)
+
+    x = -123.456
+    assert_ep -122, x.mtruncate(-2)
+    assert_ep -123.45, x.mtruncate(-0.01)
+    assert_ep -100, x.mtruncate(25)
+  end
+
+
+  def test_sceil
+    x = 123.456
+    assert_ep 200, x.sceil(1)
+    assert_ep 124, x.sceil(3)
+    assert_ep 123.5, x.sceil(4)
+    assert_ep 123.456, x.sceil(6)
+
+    x = -123.456
+    assert_ep -100, x.sceil(1)
+    assert_ep -123, x.sceil(3)
+    assert_ep -123.4, x.sceil(4)
+    assert_ep -123.456, x.sceil(6)
+  end
+
+  def test_sfloor
+    x = 123.456
+    assert_ep 100, x.sfloor(1)
+    assert_ep 123, x.sfloor(3)
+    assert_ep 123.4, x.sfloor(4)
+    assert_ep 123.456, x.sfloor(6)
+
+    x = -123.456
+    assert_ep -200, x.sfloor(1)
+    assert_ep -124, x.sfloor(3)
+    assert_ep -123.5, x.sfloor(4)
+    assert_ep -123.456, x.sfloor(6)
+  end
+
+  def test_sroundup
+    x = 123.456
+    assert_ep 200, x.sroundup(1)
+    assert_ep 124, x.sroundup(3)
+    assert_ep 123.5, x.sroundup(4)
+    assert_ep 123.456, x.sroundup(6)
+
+    x = -123.456
+    assert_ep -200, x.sroundup(1)
+    assert_ep -124, x.sroundup(3)
+    assert_ep -123.5, x.sroundup(4)
+    assert_ep -123.456, x.sroundup(6)
+  end
+
+  def test_srounddown
+    x = 123.456
+    assert_ep 100, x.srounddown(1)
+    assert_ep 123, x.srounddown(3)
+    assert_ep 123.4, x.srounddown(4)
+    assert_ep 123.456, x.srounddown(6)
+
+    x = -123.456
+    assert_ep -100, x.srounddown(1)
+    assert_ep -123, x.srounddown(3)
+    assert_ep -123.4, x.srounddown(4)
+    assert_ep -123.456, x.srounddown(6)
+  end
+
+  def test_sround
+    assert_ep  2,  1.5.sround(1)
+    assert_ep -2, -1.5.sround(1)
+
+    x = 123.456
+    assert_ep 100, x.sround(1)
+    assert_ep 123, x.sround(3)
+    assert_ep 123.5, x.sround(4)
+    assert_ep 123.456, x.sround(6)
+
+    x = -123.456
+    assert_ep -100, x.sround(1)
+    assert_ep -123, x.sround(3)
+    assert_ep -123.5, x.sround(4)
+    assert_ep -123.456, x.sround(6)
+  end
+
+  def test_struncate
+    x = 123.456
+    assert_ep 100, x.struncate(1)
+    assert_ep 123, x.struncate(3)
+    assert_ep 123.4, x.struncate(4)
+    assert_ep 123.456, x.struncate(6)
+
+    x = -123.456
+    assert_ep -100, x.struncate(1)
+    assert_ep -123, x.struncate(3)
+    assert_ep -123.4, x.struncate(4)
+    assert_ep -123.456, x.struncate(6)
+  end
+
+  def test_zero
+    x = 0
+    assert_ep x, x.roundup
+    assert_ep x, x.rounddown
+    assert_ep x, x.mceil(1)
+    assert_ep x, x.mfloor(1)
+    assert_ep x, x.mroundup(1)
+    assert_ep x, x.mrounddown(1)
+    assert_ep x, x.mround(1)
+    assert_ep x, x.mround(1)
+    assert_ep x, x.mtruncate(1)
+    assert_ep x, x.sceil(1)
+    assert_ep x, x.sfloor(1)
+    assert_ep x, x.sroundup(1)
+    assert_ep x, x.srounddown(1)
+    assert_ep x, x.sround(1)
+    assert_ep x, x.sround(1)
+    assert_ep x, x.struncate(1)
+  end
+end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: pretty_round
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - diaphragm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-22 00:00:00.000000000 Z
+date: 2019-01-10 00:00:00.000000000 Z
 dependencies: []
-description: This gem provide useful numerical rounding methods.
+description: This gem provide useful numerical rounding methods such as nearest multiple
+  or significant digits.
 email: 
 executables: []
 extensions: []
@@ -21,6 +22,7 @@ files:
 - examples/example.rb
 - examples/example2.rb
 - lib/pretty_round.rb
+- lib/pretty_round/core.rb
 - test/test_pretty_round.rb
 homepage: https://github.com/diaphragm/ruby-pretty-round
 licenses:
@@ -34,7 +36,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.8'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -42,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: pretty rounding methods library