base62-rb 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41ababc33c9761ec527aa12e739ee3a3335fae10
-  data.tar.gz: 7e9d24d5da22aef6f43a02aad978d9654eb2728d
+  metadata.gz: 299f76e841055f3d30cc34ff3795eac2e212e283
+  data.tar.gz: 80b78e4e05f4c5740050e753cca18e7def48fe7b
 SHA512:
-  metadata.gz: 096fc1a781be8088931c95b83f33d42c415535f10f3de2a9331461831ba709a2e330afa81100f2025cd512b8f612782aed1d7ad904e9e53586d9c6b3928161c9
-  data.tar.gz: f495b8ef1151b4e842b8af79cfd237a4120c9b73180c083c78078f3c03c80d99668f37da33e067dc47becfa15675488d544ed6b814a2fc373c1b00c19fd08a73
+  metadata.gz: 214f81b6a1919b075db0924bbd1f80dedab436f14a4b699421f838d2eeae24f0e2b17626b3e10d2706ae9cad3770dc8063e5a487f1fcc1f734aae787cb81ef8d
+  data.tar.gz: d1b0000f0512a29e98b3f5f0556079b3f81e8ccfe39cb30013e4d4532dd083dee4ba85ebc0b5ae7b8eb8b68427a993df30c12122843ed4d780e791b95e2eb229

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Steven Yue
+Copyright (c) 2016 Steven Yue
 
 MIT License
 

data/README.md

@@ -1,6 +1,6 @@
 # Base62 in Ruby
 
-A simple and fast implementation of base62 in pure Ruby without too much sugar and magic. 
+A simple and fast implementation of base62 in pure Ruby without too much sugar and magic.
 
 It uses character set: `0-9`, `a-z`, `A-Z` for encoding and decoding.
 
@@ -41,4 +41,4 @@ See the comparison [here](benchmarks/comparison.rb)
 
 ## License
 
-MIT License - Copyright (c) 2014 Steven Yue
+MIT License - Copyright (c) 2016 Steven Yue

data/benchmarks/comparison.rb

@@ -15,7 +15,6 @@ time = Benchmark.measure do
 end
 puts time # => 3.280000   0.010000   3.290000 (  3.311349))
 
-
 # gem radix62 v1.0.1
 # https://github.com/matiaskorhonen/radix62
 require 'radix62'
@@ -28,7 +27,6 @@ time = Benchmark.measure do
 end
 puts time # => 6.790000   0.020000   6.810000 (  6.842925)
 
-
 # gem base62 v1.0.0
 # https://github.com/jtzemp/base62
 require 'base62'
@@ -39,4 +37,4 @@ time = Benchmark.measure do
     raise "Assertion error!" unless i == decode
   end
 end
-puts time # => 10.370000   0.030000  10.400000 ( 10.452976)
+puts time # => 10.370000   0.030000  10.400000 ( 10.452976)

data/benchmarks/decode_bench.rb

@@ -0,0 +1,161 @@
+require 'benchmark/ips'
+
+KEYS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+KEYS_HASH = KEYS.each_char.with_index.inject({}){|h,(k,v)| h[k]=v;h}
+BASE = KEYS.length
+
+### Decode Method Candidates =====
+
+# The one that is used in base62-rb library
+# Use 'while' loop, and define a variable i as the counter
+def decode(str)
+  num = 0
+  i = 0
+  len = str.length - 1
+  while i < str.length
+    pow = BASE ** (len - i)
+    num += KEYS_HASH[str[i]] * pow
+    i += 1
+  end
+  return num
+end
+
+# Use KEYS.index to get the index
+# instead of using a predefined Hash Map(KEYS_HASH)
+def decode1(str)
+  num = 0
+  i = 0
+  while i < str.length
+    pow = BASE ** (str.length - i -1)
+    num += KEYS.index(str[i]) * pow
+    i += 1
+  end
+  return num
+end
+
+# Use 'for...in...' loop
+def decode2(str)
+  num = 0
+  for i in 0...str.length
+    pow = BASE ** (str.length - i -1)
+    num += KEYS_HASH[str[i]] * pow
+  end
+  return num
+end
+
+# Use String#each_char, and #with_index
+# Use block to do the calcuation
+def decode3(str)
+  num = 0
+  str.each_char.with_index do |char, i|
+    pow = BASE ** (str.length - i -1)
+    num += KEYS.index(char) * pow
+  end
+  return num
+end
+
+# Similar as above, but use KEYS_HASH to get the index
+def decode4(str)
+  num = 0
+  str.each_char.with_index do |char, i|
+    pow = BASE ** (str.length - i -1)
+    num += KEYS_HASH[char] * pow
+  end
+  return num
+end
+
+# Similar as above, but explicitly define the counter
+# without using #with_index
+def decode5(str)
+  num = 0
+  i = 0
+  str.each_char do |char|
+    pow = BASE ** (str.length - i -1)
+    num += KEYS_HASH[char] * pow
+    i += 1
+  end
+  return num
+end
+
+# same thing but with less variable
+def decode6(str)
+  num = 0
+  i = 0
+  while i < str.length
+    num += KEYS_HASH[str[i]] * (BASE ** (str.length - 1 - i))
+    i += 1
+  end
+  return num
+end
+
+### ==================
+
+### Testing =====
+
+tests = ["A", "Jr", "DFL", "2B5S", "8zTZmv", "1AnE6bpNA", "hjNv8tS3K"]
+
+Benchmark.ips do |x|
+  x.report("decode") do
+    tests.each do |test|
+      decode(test)
+    end
+  end
+
+  x.report("decode1") do
+    tests.each do |test|
+      decode1(test)
+    end
+  end
+
+  x.report("decode2") do
+    tests.each do |test|
+      decode2(test)
+    end
+  end
+
+  x.report("decode3") do
+    tests.each do |test|
+      decode3(test)
+    end
+  end
+
+  x.report("decode4") do
+    tests.each do |test|
+      decode4(test)
+    end
+  end
+
+  x.report("decode5") do
+    tests.each do |test|
+      decode5(test)
+    end
+  end
+
+  x.report("decode6") do
+    tests.each do |test|
+      decode6(test)
+    end
+  end
+end
+
+### Results
+
+# Results tested on Macbook Air 1.4 GHz Intel Core i5, 8 GB 1600 MHz DDR3
+# Using Ruby 2.1.3p242
+
+# Calculating -------------------------------------
+#               decode      6677 i/100ms
+#              decode1      5962 i/100ms
+#              decode2      5535 i/100ms
+#              decode3      4378 i/100ms
+#              decode4      4502 i/100ms
+#              decode5      5915 i/100ms
+#              decode6      6443 i/100ms
+# -------------------------------------------------
+#               decode    67891.4 (±9.7%) i/s -     340527 in   5.069726s
+#              decode1    62385.4 (±7.8%) i/s -     310024 in   5.000584s
+#              decode2    57033.8 (±8.5%) i/s -     287820 in   5.082882s
+#              decode3    45356.5 (±6.5%) i/s -     227656 in   5.041103s
+#              decode4    47708.3 (±6.5%) i/s -     238606 in   5.023164s
+#              decode5    64856.4 (±6.6%) i/s -     325325 in   5.038748s
+#              decode6    67880.8 (±7.4%) i/s -     341479 in   5.059089s

data/benchmarks/encode_bench.rb

@@ -0,0 +1,129 @@
+require 'benchmark/ips'
+
+KEYS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+KEYS_HASH = KEYS.each_char.with_index.inject({}){|h,(k,v)| h[k]=v;h}
+BASE = KEYS.length
+
+### Encode Method Candidates =====
+
+# The one that is used in base62-rb library
+# Use '+' to prepend string
+def encode(num)
+  return "0" if num == 0
+  return nil if num < 0
+
+  str = ""
+  while num > 0
+    str = KEYS[num % BASE] + str
+    num = num / BASE
+  end
+  return str
+end
+
+# Use String#reverse method at the end
+def encode1(num)
+  return "0" if num == 0
+  return nil if num < 0
+
+  str = ""
+  while num > 0
+    str = str + KEYS[num % BASE]
+    num = num / (BASE)
+  end
+  return str.reverse
+end
+
+# Use String#prepend method
+def encode2(num)
+  return "0" if num == 0
+  return nil if num < 0
+
+  str = ""
+  while num > 0
+    str.prepend KEYS[num % BASE]
+    num = num / (BASE)
+  end
+  return str
+end
+
+# Use the '/=' way
+def encode3(num)
+  return "0" if num == 0
+  return nil if num < 0
+
+  str = ""
+  while num > 0
+    str = KEYS[num % BASE] + str
+    num /= BASE
+  end
+  return str
+end
+
+# Use #<< to append string
+def encode4(num)
+  return "0" if num == 0
+  return nil if num < 0
+
+  str = ""
+  while num > 0
+    str << KEYS[num % BASE]
+    num /= BASE
+  end
+  return str.reverse
+end
+
+### ==================
+
+### Testing =====
+
+tests_encode = [630, 1231, 902323, 3781504209452600, 18446744073709551615]
+
+Benchmark.ips do |x|
+  x.report("encode") do
+    tests_encode.each do |test|
+      encode(test)
+    end
+  end
+
+  x.report("encode1") do
+    tests_encode.each do |test|
+      encode1(test)
+    end
+  end
+
+  x.report("encode2") do
+    tests_encode.each do |test|
+      encode2(test)
+    end
+  end
+
+  x.report("encode3") do
+    tests_encode.each do |test|
+      encode3(test)
+    end
+  end
+
+  x.report("encode4") do
+    tests_encode.each do |test|
+      encode4(test)
+    end
+  end
+end
+
+### Results
+
+# Results tested on Macbook Air 1.4 GHz Intel Core i5, 8 GB 1600 MHz DDR3
+# Using Ruby 2.1.3p242
+
+# Calculating -------------------------------------
+#               encode      9141 i/100ms
+#              encode1      8231 i/100ms
+#              encode2      7222 i/100ms
+#              encode3      9040 i/100ms
+#              encode4      8660 i/100ms
+# -------------------------------------------------
+#               encode    97414.2 (±8.1%) i/s -     484473 in   5.008219s
+#              encode1    89976.1 (±6.5%) i/s -     452705 in   5.053138s
+#              encode2    76680.4 (±6.8%) i/s -     382766 in   5.015263s
+#              encode3    94348.1 (±8.2%) i/s -     470080 in   5.016213s
+#              encode4    86996.4 (±8.7%) i/s -     433000 in   5.016085s

data/lib/base62-rb.rb

@@ -1,35 +1,35 @@
 require "base62/version"
 
 module Base62
-	KEYS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	KEYS_HASH = KEYS.each_char.with_index.inject({}){ |h,(k,v)| h[k]=v; h }
-	BASE = KEYS.length
+  KEYS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
+  KEYS_HASH = KEYS.each_char.with_index.inject({}) { |h, (k, v)| h[k] = v; h }
+  BASE = KEYS.length
 
-	# Encodes base10 (decimal) number to base62 string.
-	def self.encode(num)
-		return "0" if num == 0
-		return nil if num < 0
+  # Encodes base10 (decimal) number to base62 string.
+  def self.encode(num)
+    return "0" if num == 0
+    return nil if num < 0
 
-		str = ""
-		while num > 0
-			# prepend base62 charaters
-			str = KEYS[num % BASE] + str
-			num = num / BASE
-		end
-		return str
-	end
+    str = ""
+    while num > 0
+      # prepend base62 charaters
+      str = KEYS[num % BASE] + str
+      num = num / BASE
+    end
+    str
+  end
 
-	# Decodes base62 string to a base10 (decimal) number.
-	def self.decode(str)
-		num = 0
-		i = 0
-		len = str.length - 1
-		# while loop is faster than each_char or other 'idiomatic' way
-		while i < str.length
-			pow = BASE ** (len - i)
-			num += KEYS_HASH[str[i]] * pow
-			i += 1
-		end
-		return num
-	end
-end
+  # Decodes base62 string to a base10 (decimal) number.
+  def self.decode(str)
+    num = 0
+    i = 0
+    len = str.length - 1
+    # while loop is faster than each_char or other 'idiomatic' way
+    while i < str.length
+      pow = BASE**(len - i)
+      num += KEYS_HASH[str[i]] * pow
+      i += 1
+    end
+    num
+  end
+end

data/lib/base62/version.rb

@@ -1,3 +1,3 @@
 module Base62
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/test/base62_test.rb

@@ -2,27 +2,27 @@ require "base62-rb"
 require "test/unit"
 
 class Base62Test < Test::Unit::TestCase
-	def test_encode
-		{ 
-			0 => "0",
-			3781504209452600 => "hjNv8tS3K",
-			18446744073709551615 => "lYGhA16ahyf"
-		}.each do |int, base62|
-			assert_equal base62, Base62.encode(int)
-		end
-	end
+  def test_encode
+    {
+      0 => "0",
+      3781504209452600 => "hjNv8tS3K",
+      18446744073709551615 => "lYGhA16ahyf"
+    }.each do |int, base62|
+      assert_equal base62, Base62.encode(int)
+    end
+  end
 
-	def test_decode
-		{
-			"0" => 0,
-			"hjNv8tS3K" => 3781504209452600,
-			"lYGhA16ahyf" => 18446744073709551615
-		}.each do |base62, int|
-			assert_equal int, Base62.decode(base62)
-		end
-	end
+  def test_decode
+    {
+      "0" => 0,
+      "hjNv8tS3K" => 3781504209452600,
+      "lYGhA16ahyf" => 18446744073709551615
+    }.each do |base62, int|
+      assert_equal int, Base62.decode(base62)
+    end
+  end
 
-	def test_negative_numbers
-		assert_nil Base62.encode(-123)
-	end
- end
+  def test_negative_numbers
+    assert_nil Base62.encode(-123)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: base62-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Steven Yue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-27 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,8 @@ files:
 - Rakefile
 - base62-rb.gemspec
 - benchmarks/comparison.rb
+- benchmarks/decode_bench.rb
+- benchmarks/encode_bench.rb
 - lib/base62-rb.rb
 - lib/base62/version.rb
 - test/base62_test.rb
@@ -75,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Fast Base62 encoding and decoding in Ruby