entropy 0.0.2

data/entropy.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "entropy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "entropy"
+  s.version     = Entropy::VERSION
+  s.authors     = ["hiraedd"]
+  s.email       = ["hiraedd@hiraedd.com"]
+  s.homepage    = "https://github.com/hiraedd/entropy_gem"
+  s.summary     = %q{Computes the entropy of a finite probability space}
+  s.description = %q{This little gem calculates the entropy and ( the cardinality) of a finite probability space, defined by a probability vector; and of a finite probability metric space, defined by a probability vector and metric function.}
+
+  s.rubyforge_project = "entropy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/example/metric_prob_space.rb

@@ -0,0 +1,42 @@
+require 'entropy'
+require 'pp'
+
+obj = Entropy::ProbabilityMetricSpace.new
+obj.add_stream("000000000")
+obj.define_distance {|i, j| Math.sqrt(i*i + j*j) }
+pp obj.prob_space # [1.0]
+
+obj = Entropy::ProbabilityMetricSpace.new
+obj.add_stream("0123")
+obj.define_distance {|i, j| Math.sqrt(i*i + j*j) }
+m = Matrix.build(4, 4) {|i, j| Math.sqrt(i*i + j*j) }
+pp obj.distance_matrix  # = m
+pp m
+
+# redefine prob_space
+#
+puts "redefine prob_space and distance matrix"
+obj.prob_space = [0.25, 0.75]
+distance = Matrix[[2, 2], [4, 4]]
+obj.define_distance(distance)
+pp obj.prob_space # [0.25, 0.25, 0.25, 0.25]
+pp distance
+puts obj.cardinality(2) 
+puts obj.diversity(2) 
+puts obj.renyi_entropy(2) 
+puts obj.renyi_entropy(0) 
+puts obj.renyi_entropy(:infinite) 
+
+# setting infinite distance means having a discrete set
+puts "setting infinite distance means having a discrete set"
+distance = Matrix[[:infinite, :infinite], [:infinite, :infinite]]
+obj.define_distance(distance)
+pp obj.prob_space # [0.25, 0.25, 0.25, 0.25]
+pp distance
+puts obj.cardinality(2) 
+puts obj.diversity(2) 
+puts obj.renyi_entropy(2) 
+puts obj.renyi_entropy(0) 
+puts obj.renyi_entropy(:infinite) 
+
+

data/example/prob_space.rb

@@ -0,0 +1,31 @@
+require 'entropy'
+require 'pp'
+
+obj = Entropy::ProbabilitySpace.new
+obj.add_stream("000000000")
+pp obj.prob_space   # [1.0]
+puts obj.cardinality(2) # 1 equal to shannon entropy
+puts obj.diversity(2).round # 0
+puts obj.renyi_entropy(2).round # 0
+puts obj.renyi_entropy(:infinite).round # 0
+  
+obj = Entropy::ProbabilitySpace.new
+obj.add_stream("1234")
+pp obj.prob_space # [0.25, 0.25, 0.25, 0.25]
+puts obj.cardinality(2) # 4 equal to shannon entropy
+puts obj.diversity(2) # 3/4
+puts obj.renyi_entropy(2) # 2 
+puts obj.renyi_entropy(:infinite) 
+
+# redefine prob_space
+puts "redefine prob_space"
+obj.prob_space = [0.25, 0.75]
+pp obj.prob_space # [0.25, 0.25, 0.25, 0.25]
+puts obj.cardinality(2) # 1.6
+puts obj.diversity(2) # 0.375
+puts obj.renyi_entropy(2) 
+puts obj.renyi_entropy(0) 
+puts obj.renyi_entropy(:infinite) 
+
+
+

data/lib/entropy.rb

@@ -0,0 +1,13 @@
+require "entropy/version"
+require "entropy/stream"
+require "entropy/dict"
+require "entropy/probability_space.rb"
+require "entropy/metric_space.rb"
+
+module Entropy
+
+  def self.version_string
+    "Entropy version #{Entropy::VERSION}"
+  end
+
+end

data/lib/entropy/dict.rb

@@ -0,0 +1,30 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+
+module Entropy
+  class Dict
+
+    def initialize
+      @bucket = Hash.new(0)
+      @space_size = 0
+    end
+
+    # Add an element to the space
+    def upd(k)
+      @bucket[k] += 1
+      @space_size += 1
+    end
+
+    # Compute frequency of the element
+    def freq(k)
+      (@bucket[k].to_d / @space_size)
+    end
+
+    # Return all the elements of the space
+    def scan_keys
+      @bucket.keys
+    end
+
+  end
+end

data/lib/entropy/metric_space.rb

@@ -0,0 +1,116 @@
+require "matrix"
+
+module Entropy
+
+  # Entropy::ProbabilityMetricSpace defines a finite probability metric space
+  class ProbabilityMetricSpace < ProbabilitySpace
+
+    attr_reader :distance_matrix, :distance_function
+
+    def initialize
+      @distance_matrix = nil
+      @density = nil
+      super
+    end
+
+    # Adds a set of elements (char, bit) to the space
+    def add_stream(stream)
+      super(stream)
+    end
+
+    # Defines the distance among the elements of the set.
+    # The method accepts a block, so you can use your
+    # function to calculate the distance. The function should
+    # accept two parameters, viz. the ordinals i,j of the elements
+    # and should return a decimal number, the distance between 
+    # element i and j.
+    # In alternative you could pass a matrix of numbers defining
+    # the distances among i's and j's.
+    def define_distance(*args, &blk)
+      if !blk.nil?
+        @distance_function = blk
+        update_distance_matrix
+      else
+        mat = args[0]
+        raise "distance matrix is not a matrix object" if !mat.respond_to?("square?") 
+        raise "distance matrix is not square" if !mat.square?
+        raise "distance matrix has wrong dimensions" if mat.to_a.size != @prob_space.size
+        @distance_matrix = mat
+      end
+      z = @distance_matrix.map { |d| d == :infinite ? 0 : Math.exp(-d) }
+      @density = z * Matrix.column_vector(@prob_space)
+      @density = @density.column(0).to_a
+    end
+
+    # Computes the Shannon Entropy of the space
+    def shannon_entropy
+      diversity(1)
+    end
+
+    # Computes the Rao Entropy of the space
+    def rao_entropy
+      diversity(2)
+    end
+
+
+    # Computes the Renyi Entropy (α-Entropy) of the space
+    def renyi_entropy(alpha)
+      raise "Warning: distance metric not defined..." if @distance_matrix.nil?
+      h = 0
+        if alpha == 1
+          @prob_space.each_index do |i| 
+            h += -@prob_space[i] * Math.log(@density[i])
+          end
+        elsif alpha == :infinite
+          h = -Math.log(@density.max)
+        else
+          @prob_space.each_index do |i| 
+            h += @prob_space[i] * (@density[i]**(alpha - 1))
+          end
+          h = 1.0 / (1 - alpha) * Math.log(h)
+        end
+      h
+    end
+
+    # Computes the α-Diversity of the space
+    def diversity(alpha)
+      raise "Warning: distance metric not defined..." if @distance_matrix.nil?
+      div = []
+      @prob_space.each_index do |i| 
+        p = @prob_space[i]
+        div[i] = p *  surprise(alpha, @density[i])
+      end
+      div.inject(:+)
+    end
+    
+    # Computes the α-Cardinality of the space
+    def cardinality(alpha)
+      raise "Warning: distance metric not defined..." if @distance_matrix.nil?
+      card = 0
+      if alpha == 1
+        card = 1
+        @prob_space.each_index do |i| 
+          card = card * (@density[i] ** (-@prob_space[i]))
+        end
+      elsif alpha == :infinite
+        card = 1.0/@density.max
+      else
+        @prob_space.each_index do |i| 
+          card += @prob_space[i] * (@density[i]**(alpha - 1))
+        end
+        card = card ** (1.0 / (1 - alpha)) if card != 0
+      end
+      card
+    end
+
+    private
+    def update_distance_matrix
+      if !@distance_function.nil?
+        puts "Applying function #{@distance_function.to_s} to the probability space..."
+        @distance_matrix = Matrix.build (@prob_space.size) { |i, j| @distance_function.call(i, j) }
+      end
+    end
+
+  end
+
+end

data/lib/entropy/probability_space.rb

@@ -0,0 +1,91 @@
+module Entropy
+
+  # Entropy::ProbabilitySpace defines a finite probability space
+  class ProbabilitySpace
+
+    attr_accessor :prob_space
+
+    def initialize
+      @space = Entropy::Stream.new
+      @dict = Entropy::Dict.new()
+      @prob_space = []
+    end
+
+    # Adds a set of elements (char, bit) to the space
+    def add_stream(stream)
+      puts "Adding a set in the probability space..."
+      @space.add_stream(stream)
+      update_probability_space(stream)
+    end
+
+    # Computes the Shannon Entropy of the space
+    def shannon_entropy
+      diversity(1)
+    end
+
+    # Computes the Renyi Entropy (α-Entropy) of the space
+    def renyi_entropy(alpha)
+      h = 0
+        if alpha == 1
+          h = @prob_space.map {|p| -p * Math.log(p)}.inject(:+)
+        elsif alpha == :infinite
+          h = -Math.log(@prob_space.max)
+        else
+          h =  @prob_space.map {|p| p**alpha}.inject(:+)
+          h = 1.0 / (1 - alpha) * Math.log(h)
+        end
+      h
+    end
+
+    # Computes the α-Diversity of the space
+    def diversity(alpha)
+      @prob_space.map {|p| p * surprise(alpha, p) }.inject(:+)
+    end
+    
+    # Surprise function
+    def surprise(alpha, p)
+      s = 0
+      if alpha == 1
+        s = -Math.log(p)
+      elsif alpha == :infinite
+        s = 0
+      else
+        e = alpha - 1
+        s = 1.0 / e * (1 - p**e)
+      end
+      s
+    end
+
+    # Computes the α-Cardinality of the space
+    def cardinality(alpha)
+      card = 0
+      if alpha == 1
+        card = @prob_space.map {|p| p**(-p)}.inject(1, :*)
+      elsif alpha == :infinite
+        card = 1.0/@prob_space.max
+      else
+        card = @prob_space.map {|p| p**alpha}.inject(:+)
+        card = card ** (1.0 / (1 - alpha))
+      end
+      card
+    end
+
+    private
+    def update_probability_space(stream)
+      @prob_space = []
+      it = @space.streams[stream]
+      stream.send(it).each do |b|
+        c = b
+        if it == :each_char
+            c.chomp!
+            next if c.empty?
+        end
+        @dict.upd(c)
+      end
+      @dict.scan_keys.each do |k|
+        @prob_space << @dict.freq(k)
+      end
+    end
+  end
+
+end

data/lib/entropy/stream.rb

@@ -0,0 +1,37 @@
+module Entropy
+
+  # Class used to define a stream inside the space
+  class Stream
+
+    attr_reader :streams
+
+    def initialize
+      @streams = Hash.new
+    end
+
+    # Adds a stream (a File or a String) to the space
+    def add_stream(stream)
+      iter = nil 
+      if stream.respond_to?("binmode?")
+        if stream.binmode?
+          puts "Binary File Stream Initialization..."
+          iter = :each_byte
+        else
+          puts "Char File Stream Initialization..."
+          iter = :each_char
+        end
+      elsif  stream.respond_to?("each_char")
+        puts "Char Stream Initialization..."
+        iter = :each_char
+      elsif  stream.respond_to?("each_byte")
+        puts "Binary Stream Initialization..."
+        iter = :each_byte
+      else
+        raise "Wrong type of stream"
+      end
+      @streams[stream] = iter
+    end
+
+  end
+
+end

data/lib/entropy/version.rb

@@ -0,0 +1,3 @@
+module Entropy
+  VERSION = "0.0.2"
+end

data/test/stream0.txt

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000000000000

data/test/stream1.txt

@@ -0,0 +1 @@
+0123456789

data/test/stream2.txt

@@ -0,0 +1 @@
+00000010

data/test/stream_random.bin

@@ -0,0 +1,2 @@
+<k?^��پ�G�}B��p�h�OV�}^�k��}�"of�p��.���
+p+�I�G7�������ͩ=�G���1��F�2���#r�W�

data/test/test_entropy_def.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'entropy'
+
+class TestEntropy < Test::Unit::TestCase
+
+  def test_version_string
+    assert_equal Entropy.version_string, "Entropy version #{Entropy::VERSION}"
+  end
+end
+

data/test/test_entropy_metr.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'entropy'
+
+class TestEntropy < Test::Unit::TestCase
+
+  def test_string_metr
+    obj = Entropy::ProbabilityMetricSpace.new
+    obj.add_stream("000000000")
+    obj.define_distance {|i, j| Math.sqrt(i*i + j*j) }
+    assert_equal obj.prob_space, [1.0]
+  end
+  
+  def test_string_metr_2
+    obj = Entropy::ProbabilityMetricSpace.new
+    obj.add_stream("1000")
+    obj.define_distance {|i, j| Math.sqrt(i*i + j*j) }
+    assert_equal obj.prob_space.sort, [0.25, 0.75]
+  end
+
+  def test_distance_metr
+    obj = Entropy::ProbabilityMetricSpace.new
+    obj.add_stream("0123")
+    obj.define_distance {|i, j| Math.sqrt(i*i + j*j) }
+    m = Matrix.build(4, 4) {|i, j| Math.sqrt(i*i + j*j) }
+    assert_equal obj.distance_matrix, m
+  end
+
+  def test_entropy_metr
+    obj = Entropy::ProbabilityMetricSpace.new
+    obj.add_stream("0123")
+    obj.define_distance {|i, j| 1 }
+    assert_equal obj.diversity(1), 1
+  end
+
+end
+