pretty_round 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 715c35c7f940f136ab635fefb6f253f72ce4e712
-  data.tar.gz: 6ff79a9c50c397001a2f12ac00d7076d03316162
+  metadata.gz: 81b0efd5424a3bcdeacf134caec4d82801f241ab
+  data.tar.gz: 5a3e997f35204b86c08c3e65566cfde0bdcf5389
 SHA512:
-  metadata.gz: 6987805eeb0bb0183f77ef2a5605d8da58e5dcf5bc030548681269ddc36d93f9cb491de404d66626f5228100a321cef8c70c7c24fb8fe192d5ca696517deed77
-  data.tar.gz: c4e508d1aaec2a2fa399ad5fdf597088d1d7407b5640ff852bb06237a48b1f97de66848725b9f643cb0bb4ab689f248d540e544ee94ce2ec9b90bfea49f91aa3
+  metadata.gz: e7873f9c7ee8c9e129bf565ed0938421892bad9fecfa8b473d20e1bfe6be0e91be532a367e18c674ed54c1d12a032dc6e5cb38924e6192bdd88d98ba3b3e76fd
+  data.tar.gz: de9fa9b940b5246a221e2be45485a49cc6fe9051b04a60b209d9cab2ea17979708384981b5ee0c6e1323175d3eafe448ee91a293b987b815b9fa214331f779f1

data/README.md

@@ -16,47 +16,75 @@ require "pretty_round"
 x = 123.456
 
 # round with precision
-x.round(2) #=> 123.46 (ruby built-in)
 x.roundup(2) #=> 123.46
 x.rounddown(2) #=> 123.45
 
 # round to nearest multiple
-x.mroundup(10) #=> 130
-x.mrounddown(0.01) #=> 123.45
-x.mround(50) #=> 100
-x.mround(0.02) #=> 123.46
+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.sround(2) #=> 120
-x.sround(4) #=> 123.5
+x.sceil(1) #=> 200
+x.sfloor(2) #=> 120
+x.sroundup(3) #=> 124
+x.srounddown(4) #=> 123.4
+x.sround(5) #=> 123.46
 ```
 
 Rounding direction
 ================
+Also, try to run `examples/example.rb`
 
-`#roundup`, `#mroundup`
+`#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
+```
+
+`#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
+```
+
+`#roundup`, `#mroundup`, `#sroundup`
+----------------
+These methods round up to far from 0 direction.
 ```rb
  1.9.mroundup(1) #=> 2
  1.1.mroundup(1) #=> 2
--1.1.mroundup(1) #=> -1
--1.9.mroundup(1) #=> -1
+-1.1.mroundup(1) #=> -2
+-1.9.mroundup(1) #=> -2
 ```
 
-`#rounddown`, `#mrounddown`
+`#rounddown`, `#mrounddown`, `#srounddown`
 ----------------
-These methods round down to the negative infinity direction.
+These methods round down to near from 0 direction.
 ```rb
  1.9.mrounddown(1) #=> 1
  1.1.mrounddown(1) #=> 1
--1.1.mrounddown(1) #=> -2
--1.9.mrounddown(1) #=> -2
+-1.1.mrounddown(1) #=> -1
+-1.9.mrounddown(1) #=> -1
 ```
 
+
 `#mround`, `#sround`
 ----------------
 These methods round off the absolute value, dos not round even.
+Its behavior is same as built-in #round.
 ```rb
  1.9.mround(1) #=> 2
  1.1.mround(1) #=> 1
@@ -64,7 +92,3 @@ These methods round off the absolute value, dos not round even.
 -1.9.mround(1) #=> -2
 ```
 
-----
-Also, try to run `examples/example.rb`
-
-

data/examples/example.rb

@@ -1,39 +1,32 @@
 
 require "pretty_round"
 
-xs = %w[2.1 2.5 2.9 -2.1 -2.5 -2.9].map(&:to_r)
+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)
 
-header = " "*6  + "|" + ns.map{|x| x.to_f.to_s.rjust(6)}.join + "\n" + "-"*(6+1+6*ns.size)
-
-puts "#mroundup"
-puts header
-xs.each do |x|
-  puts ("%6.1f"%x) + "|" + ns.map{|n| x.mroundup(n)}.map{|n| ("%6.1f"%n)}.join
+%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 "#mrounddown"
-puts header
-xs.each do |x|
-  puts ("%6.1f"%x) + "|" + ns.map{|n| x.mrounddown(n)}.map{|n| ("%6.1f"%n)}.join
-end
-puts
-
-puts "#mround"
-puts header
-xs.each do |x|
-  puts ("%6.1f"%x) + "|" + ns.map{|n| x.mround(n)}.map{|n| ("%6.1f"%n)}.join
-end
-puts
 
+puts "* Rounding with significant digit"
+xs = [0.12345, 123.45, 12345, -0.12345, -123.45, -12345]
+ns = [*1..5]
 
-puts "#sround"
-xs = [0.1234, 12.34, 1234, -0.1234, -12.34, -1234]
-ns = [*-1..5]
-puts " "*10  + "|" + ns.map{|x| x.to_s.center(10)}.join
-puts "-"*(10+1+10*ns.size)
-xs.each do |x|
-  puts ("% 10.4f"%x) + "|" + ns.map{|n| x.sround(n)}.map{|n| ("% 10.4f"%n)}.join
+%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/lib/pretty_round.rb

@@ -1,38 +1,69 @@
 
 class Numeric
-  # Ceiling with given precision.
-  def roundup(d=0)
-    x = 10**(-d)
-    self.quo(x).ceil * x
+  # 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
 
-  # Flooring with given precision.
-  def rounddown(d=0)
-    x = 10**(-d)
-   self.quo(x).floor * x
+  # 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 mroundup(num)
-    div, mod = divmod(num)
+  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
   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 mrounddown(num)
-    div, mod = divmod(num)
+  def mfloor(num)
+    div = self.div(num); mod = self - div*num
     x = num * div; y = x + (mod.zero? ? 0 : num)
     [x, y].min
   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)
+  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)
+  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, mod = divmod(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)
@@ -41,9 +72,38 @@ class Numeric
     end
   end
   
-  # Rounding with given significant digit.
-  def sround(digit, base=10)
-    numdigit = Math.log(abs, base).floor + 1
-    mround(base**(numdigit-digit))
+  alias :mtruncate :mrounddown
+  
+  
+  # Ceiling with given significant digit.
+  def sceil(digit)
+    numdigit = Math.log10(abs).floor + 1
+    mceil(10**(numdigit - digit))
+  end
+  
+  # Flooring with given significant digit.
+  def sfloor(digit)
+    numdigit = Math.log10(abs).floor + 1
+    mfloor(10**(numdigit - digit))
+  end
+  
+  # Rounding up with given significant digit.
+  def sroundup(digit)
+    numdigit = Math.log10(abs).floor + 1
+    mroundup(10**(numdigit - digit))
+  end
+  
+  # Rounding down with given significant digit.
+  def srounddown(digit)
+    numdigit = Math.log10(abs).floor + 1
+    mrounddown(10**(numdigit - digit))
   end
+  
+  # Rounding off with given significant digit.
+  def sround(digit)
+    numdigit = Math.log10(abs).floor + 1
+    mround(10**(numdigit - digit))
+  end
+  
+  alias :struncate :srounddown
 end

data/test/test_pretty_round.rb

@@ -11,8 +11,8 @@ class TEST_PrettyRound < Minitest::Test
   def test_roundup
     assert_ep  2,  1.9.roundup
     assert_ep  2,  1.1.roundup
-    assert_ep -1, -1.1.roundup
-    assert_ep -1, -1.9.roundup
+    assert_ep -2, -1.1.roundup
+    assert_ep -2, -1.9.roundup
     
     x = 123.456
     assert_ep 124, x.roundup
@@ -20,16 +20,16 @@ class TEST_PrettyRound < Minitest::Test
     assert_ep 200, x.roundup(-2)
     
     x = -123.456
-    assert_ep -123, x.roundup
-    assert_ep -123.45, x.roundup(2)
-    assert_ep -100, x.roundup(-2)
+    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.1.rounddown
-    assert_ep -2, -1.1.rounddown
-    assert_ep -2, -1.9.rounddown
+    assert_ep -1, -1.1.rounddown
+    assert_ep -1, -1.9.rounddown
     
     x = 123.456
     assert_ep 123, x.rounddown
@@ -37,43 +37,77 @@ class TEST_PrettyRound < Minitest::Test
     assert_ep 100, x.rounddown(-2)
     
     x = -123.456
-    assert_ep -124, x.rounddown
-    assert_ep -123.46, x.rounddown(2)
-    assert_ep -200, x.rounddown(-2)
+    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.1.mceil(1)
+    assert_ep -1, -1.1.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.1.mfloor(1)
+    assert_ep -2, -1.1.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.1.mroundup(1)
-    assert_ep -1, -1.1.mroundup(1)
-    assert_ep -1, -1.9.mroundup(1)
+    assert_ep -2, -1.1.mroundup(1)
+    assert_ep -2, -1.9.mroundup(1)
     
     x = 123.456
-    assert_ep 124, x.mroundup(-1)
+    assert_ep 124, x.mroundup(-2)
     assert_ep 123.46, x.mroundup(-0.01)
-    assert_ep 200, x.mroundup(100)
+    assert_ep 125, x.mroundup(25)
     
     x = -123.456
-    assert_ep -123, x.mroundup(-1)
-    assert_ep -123.45, x.mroundup(-0.01)
-    assert_ep -100, x.mroundup(100)
+    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.1.mrounddown(1)
-    assert_ep -2, -1.1.mrounddown(1)
-    assert_ep -2, -1.9.mrounddown(1)
+    assert_ep -1, -1.1.mrounddown(1)
+    assert_ep -1, -1.9.mrounddown(1)
     
     x = 123.456
-    assert_ep 123, x.mrounddown(-1)
+    assert_ep 122, x.mrounddown(-2)
     assert_ep 123.45, x.mrounddown(-0.01)
-    assert_ep 100, x.mrounddown(100)
+    assert_ep 100, x.mrounddown(25)
     
     x = -123.456
-    assert_ep -124, x.mrounddown(-1)
-    assert_ep -123.46, x.mrounddown(-0.01)
-    assert_ep -200, x.mrounddown(100)
+    assert_ep -122, x.mrounddown(-2)
+    assert_ep -123.45, x.mrounddown(-0.01)
+    assert_ep -100, x.mrounddown(25)
   end
   
   def test_mround
@@ -83,28 +117,85 @@ class TEST_PrettyRound < Minitest::Test
     assert_ep -2, -1.9.mround(1)
     
     x = 123.456
-    assert_ep 123, x.mround(-1)
+    assert_ep 124, x.mround(-2)
     assert_ep 123.46, x.mround(-0.01)
-    assert_ep 100, x.mround(100)
+    assert_ep 125, x.mround(25)
     
     x = -123.456
-    assert_ep -123, x.mround(-1)
+    assert_ep -124, x.mround(-2)
     assert_ep -123.46, x.mround(-0.01)
-    assert_ep -100, x.mround(100)
+    assert_ep -125, x.mround(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 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)
+    assert_ep -123.456, x.srounddown(6)
+  end
+
   def test_sround
     x = 123.456
-    assert_ep 0, x.sround(-1)
-    assert_ep 0, x.sround(0)
     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 0, x.sround(-1)
-    assert_ep 0, x.sround(0)
     assert_ep -100, x.sround(1)
     assert_ep -123, x.sround(3)
     assert_ep -123.5, x.sround(4)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pretty_round
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - diaphragm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-10-22 00:00:00.000000000 Z
 dependencies: []
 description: This gem provide useful numerical rounding methods.
 email: 
@@ -41,7 +41,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: pretty rounding methods library