pretty_round 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81b0efd5424a3bcdeacf134caec4d82801f241ab
-  data.tar.gz: 5a3e997f35204b86c08c3e65566cfde0bdcf5389
+  metadata.gz: d43638c5621ed6510153ba224064c8e72a20265d
+  data.tar.gz: e0a4bf7bc31b3abde7ec213e0391d8f88f94b243
 SHA512:
-  metadata.gz: e7873f9c7ee8c9e129bf565ed0938421892bad9fecfa8b473d20e1bfe6be0e91be532a367e18c674ed54c1d12a032dc6e5cb38924e6192bdd88d98ba3b3e76fd
-  data.tar.gz: de9fa9b940b5246a221e2be45485a49cc6fe9051b04a60b209d9cab2ea17979708384981b5ee0c6e1323175d3eafe448ee91a293b987b815b9fa214331f779f1
+  metadata.gz: e6abde717b245bdc2eba773eb7cc7fa09f221dbc09803fe6ee96376f812eb7fea0de0e3521a654e32f4308171f879ba7f926b2baa68f358ce83b37e5098f5834
+  data.tar.gz: 2d607ad3107cc7890bedac69a1e96c7d8d774c3b99679b64646a8855986d0ed7f21fb6ef4f51cc2e154575f2920d6b9a86f70283b6c7863003b8fc69f3661715

data/README.md

@@ -1,6 +1,6 @@
 ruby-pretty-round
 ================
-This gem add useful numerical rounding methods to `Numeric` class as shown below...
+This gem add useful numerical rounding methods to `Numeric` class as shown below.
 - round to nearest multiple
 - round with significant digits
 
@@ -16,7 +16,7 @@ require "pretty_round"
 x = 123.456
 
 # round with precision
-x.roundup(2) #=> 123.46
+x.roundup #=> 124
 x.rounddown(2) #=> 123.45
 
 # round to nearest multiple
@@ -36,59 +36,54 @@ x.sround(5) #=> 123.46
 
 Rounding direction
 ================
-Also, try to run `examples/example.rb`
+- `#*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`.
 
-`#mceil`, `#sceil`
-----------------
-These methods round up to the positive infinity direction.
-Its behavior is same as built-in #ceil.
-```rb
- 1.9.mceil(1) #=> 2
- 1.1.mceil(1) #=> 2
--1.1.mceil(1) #=> -1
--1.9.mceil(1) #=> -1
+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.
 ```
-
-`#mfloor`, `#sfloor`
-----------------
-These methods round down to the negative infinity direction.
-Its behavior is same as built-in #floor.
-```rb
- 1.9.mfloor(1) #=> 1
- 1.1.mfloor(1) #=> 1
--1.1.mfloor(1) #=> -2
--1.9.mfloor(1) #=> -2
+              |  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
 ```
 
-`#roundup`, `#mroundup`, `#sroundup`
+Also, try to run `examples/example.rb`
+
+
+Known Bugs
+================
+Float presision
 ----------------
-These methods round up to far from 0 direction.
 ```rb
- 1.9.mroundup(1) #=> 2
- 1.1.mroundup(1) #=> 2
--1.1.mroundup(1) #=> -2
--1.9.mroundup(1) #=> -2
+1.2.mrounddown(0.1) #=> 1.1
 ```
+Oops... Resulting 1.2 is expected.
 
-`#rounddown`, `#mrounddown`, `#srounddown`
-----------------
-These methods round down to near from 0 direction.
+Becouse, 
 ```rb
- 1.9.mrounddown(1) #=> 1
- 1.1.mrounddown(1) #=> 1
--1.1.mrounddown(1) #=> -1
--1.9.mrounddown(1) #=> -1
+1.2.divmod(0.1) #=> [11, 0.0999999999999999]
 ```
 
-
-`#mround`, `#sround`
-----------------
-These methods round off the absolute value, dos not round even.
-Its behavior is same as built-in #round.
+To avoid this bug, please use `Rational`.
 ```rb
- 1.9.mround(1) #=> 2
- 1.1.mround(1) #=> 1
--1.1.mround(1) #=> -1
--1.9.mround(1) #=> -2
+1.2r.mrounddown(0.1r) #=> (6/5)
 ```
-

data/examples/example2.rb

@@ -0,0 +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

data/lib/pretty_round.rb

@@ -26,49 +26,52 @@ class Numeric
   # 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)
-    #
-    # MEMO: maybe ruby bug: 
-    #   123.456.divmod(1/10r) => [123456, 4.996003610813204e-16]
-    #
-    #div, mod = divmod(num)
-    div = self.div(num); mod = self - div*num
-    x = num * div; y = x + (mod.zero? ? 0 : num)
-    [x, y].max
+    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)
-    div = self.div(num); mod = self - div*num
-    x = num * div; y = x + (mod.zero? ? 0 : num)
-    [x, y].min
+    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)
-    div = self.div(num); mod = self - div*num
-    x = num * div; y = x + (mod.zero? ? 0 : num)
-    [x, y].max_by(&:abs)
+    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)
-    div = self.div(num); mod = self - div*num
-    x = num * div; y = x + (mod.zero? ? 0 : num)
-    [x, y].min_by(&:abs)
+    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)
-    div = self.div(num); mod = self - div*num
-    x = num * div; y = x + (mod.zero? ? 0 : num)
-    if mod.quo(num).abs * 2 == 1
-      [x, y].max_by(&:abs)
+    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, y].min_by{|t| (t - self).abs}
+      [x, x+num].min_by{|t| (t - self).abs}
     end
   end
   
@@ -77,32 +80,32 @@ class Numeric
   
   # Ceiling with given significant digit.
   def sceil(digit)
-    numdigit = Math.log10(abs).floor + 1
-    mceil(10**(numdigit - digit))
+    selfdigit = Math.log10(abs).floor + 1
+    mceil(10**(selfdigit - digit))
   end
   
   # Flooring with given significant digit.
   def sfloor(digit)
-    numdigit = Math.log10(abs).floor + 1
-    mfloor(10**(numdigit - digit))
+    selfdigit = Math.log10(abs).floor + 1
+    mfloor(10**(selfdigit - digit))
   end
   
   # Rounding up with given significant digit.
   def sroundup(digit)
-    numdigit = Math.log10(abs).floor + 1
-    mroundup(10**(numdigit - digit))
+    selfdigit = Math.log10(abs).floor + 1
+    mroundup(10**(selfdigit - digit))
   end
   
   # Rounding down with given significant digit.
   def srounddown(digit)
-    numdigit = Math.log10(abs).floor + 1
-    mrounddown(10**(numdigit - digit))
+    selfdigit = Math.log10(abs).floor + 1
+    mrounddown(10**(selfdigit - digit))
   end
   
   # Rounding off with given significant digit.
   def sround(digit)
-    numdigit = Math.log10(abs).floor + 1
-    mround(10**(numdigit - digit))
+    selfdigit = Math.log10(abs).floor + 1
+    mround(10**(selfdigit - digit))
   end
   
   alias :struncate :srounddown

data/test/test_pretty_round.rb

@@ -10,8 +10,10 @@ class TEST_PrettyRound < Minitest::Test
   
   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
@@ -27,8 +29,10 @@ class TEST_PrettyRound < Minitest::Test
 
   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
@@ -42,10 +46,13 @@ class TEST_PrettyRound < Minitest::Test
     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
@@ -61,8 +68,10 @@ class TEST_PrettyRound < Minitest::Test
   
   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
@@ -78,8 +87,10 @@ class TEST_PrettyRound < Minitest::Test
   
   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
@@ -92,11 +103,13 @@ class TEST_PrettyRound < Minitest::Test
     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
@@ -112,8 +125,10 @@ class TEST_PrettyRound < Minitest::Test
   
   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
@@ -127,6 +142,25 @@ class TEST_PrettyRound < Minitest::Test
     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
@@ -172,16 +206,12 @@ class TEST_PrettyRound < Minitest::Test
 
   def test_srounddown
     x = 123.456
-    assert_ep 0, x.srounddown(-1)
-    assert_ep 0, x.srounddown(0)
     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 0, x.srounddown(-1)
-    assert_ep 0, x.srounddown(0)
     assert_ep -100, x.srounddown(1)
     assert_ep -123, x.srounddown(3)
     assert_ep -123.4, x.srounddown(4)
@@ -189,6 +219,9 @@ class TEST_PrettyRound < Minitest::Test
   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)
@@ -201,4 +234,18 @@ class TEST_PrettyRound < Minitest::Test
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pretty_round
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - diaphragm
@@ -19,6 +19,7 @@ files:
 - LICENSE
 - README.md
 - examples/example.rb
+- examples/example2.rb
 - lib/pretty_round.rb
 - test/test_pretty_round.rb
 homepage: https://github.com/diaphragm/ruby-pretty-round