easy_encoding 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a62cc2da992ee357341aa084ed2296458fdb71ca
-  data.tar.gz: f9e3254396fb2c1e53e180e9bcb17826fd68bba0
+  metadata.gz: 657a415e4bace49a68960ffb9d60a5046f43f8dc
+  data.tar.gz: 82fb47f7af8a5c8a95b679a05cc6dbb433083410
 SHA512:
-  metadata.gz: 6572c24d1047e650d3ced32ce5c804d461aa7ceabb13f9af2d7f569907f1e00008038e849ef5ef8629606a886bdd3d6262589cd76960548754347963f8b306df
-  data.tar.gz: 7ac1460d65857fb94091103ae36ebb2239cb2816187aaaa71eeed6f0faee58e26bf9ec8eae62bbe3b12e2474790773d3a695f0c813521db7a611b0b100044d58
+  metadata.gz: b2bc4d087b8f8a135e45a053db2fb34ae9c6a6f0fba234cef3d10980f5d4945aa1cfa0f1ff3585b832ac09f064965101b10d9d4bae4d904bccf26a3c5eecbcd7
+  data.tar.gz: 3a85acd7d59eba8b3428e4b6ae0d61870c203f363992b69f3e16226e47b415958012178279ca1e7a79878e2c9f9aae1bee4ba8d73d43f355a29f262af10cb7c4

data/.rubocop.yml

@@ -1,6 +1,8 @@
 AllCops:
   Include:
     - !ruby/regexp /\.rb$/
+  Exclude:
+   - 'spec/*'
 Documentation:
   Enabled: false
 Style/FrozenStringLiteralComment:
@@ -10,4 +12,6 @@ Style/Semicolon:
 Metrics/LineLength:
   Max: 120
 Metrics/MethodLength:
-  Max: 15
+  Max: 20
+Metrics/AbcSize:
+  Max: 30

data/README.md

@@ -20,7 +20,7 @@ And then execute:
 Or install it yourself as:
 
     $ gem install easy_encoding
-    
+
 ## Configuration
 You can configure symbol for left and right node of tree.
 ```ruby
@@ -47,6 +47,21 @@ huffman.frequencies            #=> {:x7=>0.42, :x3=>0.28, :x6=>0.1, :x5=>0.1, :x
 huffman.char_codes             #=> {:x7=>"1", :x3=>"01", :x5=>"0000", :x6=>"0001", :x4=>"0011", :x2=>"00100", :x1=>"00101"}
 ```
 
+#### Shannon-Fano coding
+
+Using with string:
+```ruby
+shannon_fano = EasyEncoding::ShannonFano.new('Code')
+shannon_fano.frequencies       #=> {"e"=>0.25, "d"=>0.25, "o"=>0.25, "c"=>0.25}
+shannon_fano.char_codes        #=> {"e"=>"11", "d"=>"10", "o"=>"01", "c"=>"00"}
+```
+Using with frequencies:
+```ruby
+shannon_fano = EasyEncoding::ShannonFano.new({ x7: 0.42, x3: 0.28, x5: 0.1, x6: 0.1, x4: 0.05, x2: 0.03, x1: 0.02 })
+shannon_fano.frequencies       #=> {:x7=>0.42, :x3=>0.28, :x5=>0.1, :x6=>0.1, :x4=>0.05, :x2=>0.03, :x1=>0.02}
+shannon_fano.char_codes        #=> {:x7=>"1", :x3=>"01", :x6=>"0011", :x5=>"0010", :x4=>"0001", :x2=>"00001", :x1=>"00000"}
+```
+
 ## Contributing
 
 See [CONTRIBUTING.md](https://github.com/floor114/easy_encoding/blob/master/CONTRIBUTING.md).

data/lib/easy_encoding.rb

@@ -1,6 +1,7 @@
 require 'easy_encoding/version'
 require 'easy_encoding/configuration'
 require 'easy_encoding/huffman'
+require 'easy_encoding/shannon_fano'
 
 module EasyEncoding
   class << self

data/lib/easy_encoding/base.rb

@@ -0,0 +1,48 @@
+module EasyEncoding
+  class Base
+    attr_reader :input
+
+    def initialize(input)
+      @input = input
+    end
+
+    def char_codes
+      @char_codes ||= generate_codes!
+    end
+
+    def frequencies
+      @frequencies ||= calculate_frequencies!
+    end
+
+    private
+
+    def generate_codes!; end
+
+    def calculate_frequencies!
+      case input
+      when Hash
+        raise ArgumentError, 'summ of frequencies should eq 1' if valid_hash_frequencies?
+        hash_frequencies
+      when String
+        string_frequencies
+      else
+        raise ArgumentError, 'you must provide a hash or a string'
+      end
+    end
+
+    def string_frequencies
+      frequencies = Hash.new(0.0)
+      frequencies.tap { |freq| input.each_char { |char| freq[char.to_sym] += 1 } }
+                 .each { |key, value| frequencies[key] = value / input.size }
+                 .sort_by { |_, value| value }.reverse.to_h
+    end
+
+    def hash_frequencies
+      input.sort_by(&:last).reverse.to_h
+    end
+
+    def valid_hash_frequencies?
+      input.values.reduce(:+) > 1
+    end
+  end
+end

data/lib/easy_encoding/configuration.rb

@@ -3,8 +3,8 @@ module EasyEncoding
     attr_accessor :right_node_symbol, :left_node_symbol
 
     def initialize
-      @right_node_symbol = 1
-      @left_node_symbol = 0
+      @right_node_symbol = '1'
+      @left_node_symbol  = '0'
     end
   end
 end

data/lib/easy_encoding/huffman.rb

@@ -1,40 +1,21 @@
 require 'easy_encoding/node'
+require 'easy_encoding/base'
 
 module EasyEncoding
-  class Huffman
-    attr_reader :input, :char_codes, :frequencies, :root
-
-    def initialize(input)
-      case input
-      when Hash
-        raise ArgumentError, 'summ of frequencies should eq 1' if input.values.reduce(:+) > 1
-        @frequencies = input.sort_by { |_, value| value }.reverse.to_h
-      when String
-        @input = input
-        @frequencies = calculate_frequencies(input)
-      else
-        raise ArgumentError, 'you must provide a hash or a string'
-      end
-      @root = create_tree(frequencies)
-      @char_codes = generate_codes(root)
+  class Huffman < Base
+    def root
+      @root ||= create_tree!
     end
 
     private
 
-    def generate_codes(root)
-      {}.tap { |result| root.walk { |node, code| result[node.symbol] = code unless node.merged? } }
+    def generate_codes!
+      {}.tap { |res| root.walk { |node, code| res[node.symbol] = code unless node.merged? } }
         .sort_by { |_, value| value.length }.to_h
     end
 
-    def calculate_frequencies(string)
-      frequencies = Hash.new(0.0)
-      frequencies.tap { |freq| string.each_char { |char| freq[char.to_sym] += 1 } }
-                 .each { |key, value| frequencies[key] = value / string.size }
-                 .sort_by { |_, value| value }.reverse.to_h
-    end
-
-    def create_tree(frequencies)
-      nodes = [].tap { |result| frequencies.each { |sym, freq| result << Node.new(symbol: sym, frequency: freq) } }
+    def create_tree!
+      nodes = [].tap { |res| frequencies.each { |sym, freq| res << Node.new(symbol: sym, frequency: freq) } }
 
       while nodes.size > 1
         nodes.sort!

data/lib/easy_encoding/node.rb

@@ -9,10 +9,10 @@ module EasyEncoding
 
     def initialize(params)
       @frequency = params.fetch(:frequency, 0)
-      @symbol = params.fetch(:symbol, '')
-      @left = params.fetch(:left, nil)
-      @right = params.fetch(:right, nil)
-      @parent = params.fetch(:parent, nil)
+      @symbol    = params.fetch(:symbol, '')
+      @left      = params[:left]
+      @right     = params[:right]
+      @parent    = params[:parent]
     end
 
     def walk(&block)
@@ -21,13 +21,11 @@ module EasyEncoding
 
     def walk_node(code, &block)
       yield(self, code)
-      left&.walk_node(code + EasyEncoding.configuration.left_node_symbol.to_s, &block)
-      right&.walk_node(code + EasyEncoding.configuration.right_node_symbol.to_s, &block)
+      left&.walk_node(code + EasyEncoding.configuration.left_node_symbol, &block)
+      right&.walk_node(code + EasyEncoding.configuration.right_node_symbol, &block)
     end
 
     def <=>(other)
-      return nil unless other.is_a?(self.class)
-
       frequency <=> other.frequency
     end
 

data/lib/easy_encoding/shannon_fano.rb

@@ -0,0 +1,66 @@
+require 'easy_encoding/base'
+
+module EasyEncoding
+  class ShannonFano < Base
+    private
+
+    def generate_codes!
+      divide_and_encode(frequencies)
+    end
+
+    def divide_and_encode(hash)
+      return if hash.size == 1
+      return_hash = Hash.new('')
+
+      right_hash = hash.clone
+      left_hash  = {}
+
+      old_diff = right_hash.values.reduce(:+)
+      move_key_value!(left_hash, right_hash)
+      right_summ = right_hash.values.reduce(:+)
+      left_summ  = left_hash.values.reduce(:+)
+
+      new_diff = (left_summ - right_summ).abs
+
+      while new_diff < old_diff
+        break if right_hash.size == 1
+        left_summ, right_summ = left_right_summ(left_hash, right_hash)
+        old_diff, new_diff = recalculate_diffs(left_summ, right_summ, new_diff)
+        move_key_value!(left_hash, right_hash) if old_diff >= new_diff
+      end
+
+      merge_codes!(left_hash, right_hash, return_hash)
+      walk_hash!(left_hash, return_hash)
+      walk_hash!(right_hash, return_hash)
+
+      return_hash
+    end
+
+    def move_key_value!(left_hash, right_hash)
+      left_hash[right_hash.keys[0]] = right_hash.delete(right_hash.keys[0])
+    end
+
+    def left_right_summ(left_hash, right_hash)
+      right_summ = right_hash.values[1..-1].reduce(:+)
+      left_summ  = left_hash.values.reduce(:+) + right_hash.values[0]
+
+      [left_summ, right_summ]
+    end
+
+    def recalculate_diffs(left_summ, right_summ, diff)
+      old_diff = diff
+      new_diff = (left_summ - right_summ).abs
+
+      [old_diff, new_diff]
+    end
+
+    def merge_codes!(left_hash, right_hash, return_hash)
+      left_hash.keys.each { |key| return_hash[key] += EasyEncoding.configuration.left_node_symbol }
+      right_hash.keys.each { |key| return_hash[key] += EasyEncoding.configuration.right_node_symbol }
+    end
+
+    def walk_hash!(hash, return_hash)
+      return_hash.merge!(divide_and_encode(hash)) { |_, val1, val2| val1 + val2 } if hash.size != 1
+    end
+  end
+end

data/lib/easy_encoding/version.rb

@@ -1,3 +1,3 @@
 module EasyEncoding
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_encoding
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Taras Shpachenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
+date: 2017-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,9 +87,11 @@ files:
 - Rakefile
 - easy_encoding.gemspec
 - lib/easy_encoding.rb
+- lib/easy_encoding/base.rb
 - lib/easy_encoding/configuration.rb
 - lib/easy_encoding/huffman.rb
 - lib/easy_encoding/node.rb
+- lib/easy_encoding/shannon_fano.rb
 - lib/easy_encoding/version.rb
 homepage: https://github.com/floor114/easy_encoding
 licenses: