nreadable 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5bb6bbeb440968a93c8c4d6793f2300035f08a24
+  data.tar.gz: abdc648a16522cffb06a68c81e46c81bd29da066
+SHA512:
+  metadata.gz: 2b4ffb5497654d593406fd3d673de0ff9f35cd6fcdc380c86f2db977ce84e5a4644bc626200d7431d51d54b7b266968e66a843b8456b90d8401c2d4f9b12403d
+  data.tar.gz: 276da97917d7135d6815ee93847211c7328357bdb0dac52b749105637af2015b6973a3bb47cdd861d1b7df7bed98542f81bb4980917e263097559a7959fba7c0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Markus Anders
+
+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,13 @@
+# Rubygem nreadable
+Extends the Numeric Class with the ability to create better readable representations of numeric values as a String.
+
+## Features
+- thousands separated numbers ( e.g. 1,000,000 )
+- exponential notation with self-adjusting precision ( e.g. 1e+06 )
+- SI-Prefixes ( e.g. 1000000 = 1M )
+- Binary Prefixes ( e.g. 1048576 = 1Mi )
+- large-number naming system ( e.g. 1 million )
+
+## License
+The MIT license. See LICENSE file.
+

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test
+

data/lib/nreadable.rb

@@ -0,0 +1,194 @@
+# Adds the ability to create various readable representations of numbers to
+# the Numeric Class.
+class Numeric
+
+  # Length of symbol arrays - 1.
+  MAX_NREADABLE_EXP = 8
+
+  # SI-Prefix symbols for positive exponents.
+  SI_PREFIXES_BIG   = ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
+
+  # SI-Prefix symbols for negative exponents.
+  SI_PREFIXES_SMALL = ['', 'm', 'µ', 'n', 'p', 'f', 'a', 'z', 'y']
+
+  # Binary Prefix symbols for positive exponents.
+  BINARY_PREFIXES   = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi']
+
+  # English short scale names of numeric values. If you need a different
+  # scale or language, just replace the content of this array.
+  # Make sure it has MAX_NREADABLE_EXP + 1 fields.
+  NUMBER_NAMING = ['', 'thousand', 'million', 'billion', 'trillion',
+        'quadrillion', 'quintillion', 'sextillion', 'septillion']
+
+
+  # Creates a better readable representation of the number by adding thousands
+  # separators.
+  # @param delimiter [String] the character(s) to use as the thousands
+  #   separator.
+  # @param separator [String] the character(s) to use as the decimal point.
+  # @return [String] the number with thousands separator.
+  # @example
+  #   12345678.readable #=> "12,345,678"
+
+  def delimited( delimiter = ',', separator = '.' )
+    return self.to_s if self.is_a? Rational
+    return self.to_s if self.is_a? Float and !self.finite?
+
+    negative = self < 0
+    result   = self.abs.to_s
+    length   = result.length
+    rounds   = 0
+    decimal_position = result.index('.')
+
+    pointer = if decimal_position
+      result[decimal_position] = separator
+      decimal_position - length - 4
+    else
+      -4
+    end
+
+    while pointer.abs <= length + rounds
+      result.insert(pointer, delimiter)
+      pointer -= 4
+      rounds  += 1
+    end
+
+    result = "-" + result if negative
+    result
+  end
+
+
+  # Creates a scientific representation of the number.
+  # An exponential notation is used if the number is >= 1000 or < 0.01.
+  # @param precision [Integer] the maximum precision. Only applies if the
+  #   exponential notation is used. Must be >= 0.
+  # @return [String] the formated number.
+  # @example
+  #   12.55.scientific #=> "12.55"
+  #   10000.scientific #=> "1e+04"
+  #   12345.scientific #=> "1.2345e+04"
+
+  def scientific( precision = 6 )
+    raise ArgumentError, "negative precision" if precision < 0
+    return self.to_s if (self < 1000 and self >= 0.01) or (self == 0) or
+        (self > -1000 and self <= -0.01)
+    return self.to_s if self.is_a? Float and !self.finite?
+
+    result = sprintf("%.#{ precision }e", self)
+    position = result.index('e') - 1
+    
+    strip_insignificant_digits( result, position )
+  end
+
+
+  # Creates a representation of the number with a SI prefix attached.
+  # @param precision [Integer] maximum precision. Must be >= 0.
+  # @return [String] the formated number.
+  # @example
+  #   0.0000012.si_prefixed #=> "1.2µ"
+  #   1000.si_prefixed #=> "1k"
+
+  def si_prefixed( precision = 6 )
+    raise ArgumentError, "negative precision" if precision < 0
+    return self.to_s if (self < 1000 and self >= 1) or (self == 0) or
+        (self > -1000 and self <= -1)
+    return self.to_s if self.is_a? Float and !self.finite?
+
+    number, exponent = base_and_exponent(1000)
+    unit = if exponent >= 0
+      SI_PREFIXES_BIG[exponent]
+    else
+      SI_PREFIXES_SMALL[exponent.abs]
+    end
+
+    result = nreadable_base_s( number, precision )
+    result + unit
+  end
+  
+
+  # Creates a representation of the number with a binary prefix attached.
+  # @param precision [Integer] maximum precision. Must be >= 0.
+  # @return [String] the formatted number.
+  # @example
+  #   1024.bin_prefixed #=> "1Ki"
+  #   1_048_576.bin_prefixed + "B" #=> "1MiB" 
+
+  def bin_prefixed( precision = 1 )
+    raise ArgumentError, "negative precision" if precision < 0
+    return self.to_s if self < 1024 and self > -1024
+    return self.to_s if self.is_a? Float and !self.finite?
+
+    number, exponent = base_and_exponent(1024)
+    result = nreadable_base_s( number, precision )
+    result + BINARY_PREFIXES[exponent]
+  end
+
+
+  # Creates a representation of the number using the short scale large-number
+  # naming system with english words. You can change this by modifying the
+  # NUMBER_NAMING constant.
+  # @param precision [Integer] maximum precision. Must be >= 0.
+  # @return [String] the formatted number.
+  # @example
+  #   2000.named #=> "2 tousand"
+  #   2_310_000.named #=> "2.3 million"
+
+  def named( precision = 1 )
+    raise ArgumentError, "negative precision" if precision < 0
+    return self.to_s if self < 1000 and self > -1000
+    return self.to_s if self.is_a? Float and !self.finite?
+
+    number, exponent = base_and_exponent(1000)
+    result = nreadable_base_s( number, precision )
+    "#{result} #{NUMBER_NAMING[exponent]}"
+  end
+
+  private
+
+  # calculates the base and the exponent of self and returns it in an array.
+  # @param base [Integer] base to use in the calculation.
+  def base_and_exponent( base )
+    return [0, 0] if self == 0
+
+    f = self.to_f
+    exponent = (Math.log(f.abs) / Math.log(base)).floor
+    if exponent > MAX_NREADABLE_EXP
+      exponent = MAX_NREADABLE_EXP
+      number = self / (base ** exponent)
+    elsif exponent < -MAX_NREADABLE_EXP
+      exponent = -MAX_NREADABLE_EXP
+      number = self / (base ** exponent)
+    else
+      number = (f / (base ** exponent)).round(8) #round to counter float errors
+    end
+    
+    [number, exponent]
+  end
+
+  # converts number to string with given precision and thousands separator.
+  def nreadable_base_s( number, precision )
+    number = number.round(precision) if number.is_a? Float
+    result = number.delimited
+    strip_insignificant_digits(result) if number.is_a? Float
+
+    result
+  end
+
+  # strips trailing zeros and the . if it's the last character
+  def strip_insignificant_digits( string, index = nil )
+    index = string.length - 1 if index.nil?
+
+    while string[index] == '0' 
+      string[index] = ''
+      index -= 1
+    end
+
+    if string[index] == '.'
+      string[index] = ''
+    end
+
+    string
+  end
+
+end
+

data/test/test_nreadable.rb

@@ -0,0 +1,98 @@
+require 'test/unit'
+require 'nreadable'
+
+class NreadableTest < Test::Unit::TestCase
+    def test_delimited_int
+        assert_equal "0", 0.delimited
+        assert_equal "999", 999.delimited
+        assert_equal "1,234,567", 1234567.delimited
+        assert_equal "-1,000", -1000.delimited
+        assert_equal "-100", -100.delimited
+    end
+
+    def test_delimited_float
+        assert_equal "1.234", 1.234.delimited
+        assert_equal "1,234.5678", 1234.5678.delimited
+        assert_equal "-1,000.1", -1000.1.delimited
+        assert_equal "Infinity", Float::INFINITY.delimited
+        assert_equal "-Infinity", (-Float::INFINITY).delimited
+    end
+
+    def test_scientific_int
+        assert_equal "0", 0.scientific
+        assert_equal "1.234567e+06", 1234567.scientific
+        assert_equal "-1.234567e+06", -1234567.scientific
+        assert_equal "999", 999.scientific
+        assert_equal "1e+03", 1000.scientific
+        assert_equal "1.1e+03", 1100.scientific
+        assert_equal "-999", -999.scientific
+        assert_equal "-1e+03", -1000.scientific
+    end
+
+    def test_scientific_float
+        assert_equal "0.01", 0.01.scientific
+        assert_equal "9.11e-03", 0.00911.scientific
+        assert_equal "-0.01", -0.01.scientific
+        assert_equal "-9.11e-03", -0.00911.scientific
+        assert_equal "1.234567e+03", 1234.567.scientific
+        assert_equal "-1.234567e+03", -1234.567.scientific
+        assert_equal "Infinity", Float::INFINITY.scientific
+        assert_equal "-Infinity", (-Float::INFINITY).scientific
+    end
+
+    def test_si_prefixed_multi
+        assert_equal "0", 0.si_prefixed
+        assert_equal "999.999", 999.999.si_prefixed
+        assert_equal "1k", 1000.si_prefixed
+        assert_equal "1.23k", 1230.si_prefixed
+        assert_equal "-999.999", -999.999.si_prefixed
+        assert_equal "-1k", -1000.si_prefixed
+        assert_equal "1Y", (10**24).si_prefixed
+        assert_equal "1,000Y", (10**27).si_prefixed
+        assert_equal "Infinity", Float::INFINITY.si_prefixed
+        assert_equal "-Infinity", (-Float::INFINITY).si_prefixed
+    end
+
+    def test_si_prefixed_fraction
+        assert_equal "10m", 0.01.si_prefixed
+        assert_equal "-10m", -0.01.si_prefixed
+        assert_equal "1m", 0.001.si_prefixed
+        assert_equal "100µ", 0.0001.si_prefixed
+        assert_equal "-100.1µ", -0.0001001.si_prefixed
+        assert_equal "1y", (10**-24).si_prefixed
+        assert_equal "1/10y", (10**-25).si_prefixed
+    end
+
+    def test_bin_prefixed
+        assert_equal "0", 0.bin_prefixed
+        assert_equal "1023.999", 1023.999.bin_prefixed
+        assert_equal "1Ki", 1024.bin_prefixed
+        assert_equal "-1023.999", -1023.999.bin_prefixed
+        assert_equal "-1Ki", -1024.bin_prefixed
+        assert_equal "Infinity", Float::INFINITY.bin_prefixed
+        assert_equal "-Infinity", (-Float::INFINITY).bin_prefixed
+    end
+
+    def test_named_int
+        assert_equal "0", 0.named
+        assert_equal "999", 999.named
+        assert_equal "1 thousand", 1000.named
+        assert_equal "2 thousand", 1990.named
+        assert_equal "-999", -999.named
+        assert_equal "-1 thousand", -1000.named
+        assert_equal "3.4 million", 3_430_000.named
+        assert_equal "1 septillion", (10**24).named
+        assert_equal "1,000 septillion", (10**27).named
+    end
+
+    def test_named_float
+        assert_equal "0.5", 0.5.named
+        assert_equal "0.004", 0.004.named
+        assert_equal "999.999", 999.999.named
+        assert_equal "2 thousand", 1999.99.named
+        assert_equal "1.23456 thousand", 1234.56.named(5)
+        assert_equal "Infinity", Float::INFINITY.named
+        assert_equal "-Infinity", (-Float::INFINITY).named
+    end
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: nreadable
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Markus Anders
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-01 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Extends the Numeric Class with the ability to create better readable
+  representations of numeric values as a String.
+  In the current version it supports thousands separated numbers,
+  an exponential notation with self-adjusting precision, SI-Prefixes,
+  Binary Prefixes and a large-number naming system.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/nreadable.rb
+- test/test_nreadable.rb
+homepage: http://github.com/wups/nreadable
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Create various readable representations of numeric values.
+test_files: []
+has_rdoc: