metaheuristic_algorithms 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3dd2ffc0aa34514ddb6b911b08301698c1651fff
-  data.tar.gz: 7cb81d28bee88c63d10ed5835b3f762b0a89728b
+  metadata.gz: 27858264b3ec8d6e8f908c77b72aaf02bb4fe520
+  data.tar.gz: 7f4fd083bb8a261f2ac48f8e50d7df18a714b28b
 SHA512:
-  metadata.gz: b2c0db5f019af8720c407ff8ab1d8859041baa8bd9293a822734edc8892d56423dd6204798f565b7031d76fdf5ce882088f92fc7188444742afb1039ae907001
-  data.tar.gz: 15f10112749131b6e775385228c8985207017ebe13550380c67b06b194940e746566c68fbb14e0a803767ed04c896b39f01e67152008403f19fe62da3d80673e
+  metadata.gz: 943a04193e2133c5cdc2aac48d5f1d6dddf5184363f6f38cd62e4d5d88abbf5f042a1935f4c92b4cf02e69823206e3492ed9d4acb31fd67d58bc07658096235b
+  data.tar.gz: 3a7ded6b05592213c574a06ed2019c7a5524f39e99723f0f12f27859b4b132088e3455740dbc861f84276e73a93a56fed338f1bcb30efaef4c73ae9a8da8e65f

data/.ruby-version

@@ -1 +1 @@
-2.2.2
+2.2.3

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in metaheuristic_algorithms.gemspec
 gemspec
+
+gem "pry-byebug", group: [:development, :test], platforms: :ruby # In order to exclude jruby

data/README.md

@@ -18,6 +18,32 @@ Or install it yourself as:
 
     $ gem install metaheuristic_algorithms
 
+## Supported Platforms
+
+* MRI Ruby 2.2 or above. 
+
+* JRuby 9.0.0.0 or above. (In an attempt to have better speed, if not fast.)
+
+## Available Algorithms
+
+In alphabetical order:
+
+* Firefly Algorithm
+        MetaheuristicAlgorithms::FireflyAlgorithm
+* Genetic Algorithm
+        MetaheuristicAlgorithms::GeneticAlgorithm
+* Harmony Search
+        MetaheuristicAlgorithms::HarmonySearch
+* Simplified Particle Swarm Optimization
+        MetaheuristicAlgorithms::SimplifiedParticleSwarmOptimization
+* Simulated Annealing
+        MetaheuristicAlgorithms::SimulatedAnnealing
+
+Algorithms under construction:
+
+* Ant Colony Optimization
+* Virtual Bee Algorithm
+
 ## Usage
 
 Step 1. Create a Function Wrapper for your objective function by extending MetaheuristicAlgorithms::FunctionWrappers::AbstractWrapper
@@ -26,25 +52,24 @@ Step 1. Create a Function Wrapper for your objective function by extending Metah
 
 ```ruby
    require 'metaheuristic_algorithms'
-   require 'bigdecimal'
 
    class RosenbrookFunctionWrapper < MetaheuristicAlgorithms::FunctionWrappers::AbstractWrapper
 
       def maximum_decision_variable_values
-        [BigDecimal('5'), BigDecimal('5')]
+        [5, 5]
       end
 
       def miminum_decision_variable_values
-        [BigDecimal('-5'), BigDecimal('-5')]
+        [-5, -5]
       end
 
       def objective_function_value(decision_variable_values)
-        (BigDecimal('1') - decision_variable_values[0]).power(2) + BigDecimal('100') * (decision_variable_values[1] - decision_variable_values[0].power(2)).power(2)
+        (1 - decision_variable_values[0])**2 + 100 * (decision_variable_values[1] - decision_variable_values[0]**2)**2
       end
 
       # For the algorithm that requires initial estimate that is depending on the particular objective function:
       def initial_decision_variable_value_estimates
-        [BigDecimal('2'), BigDecimal('2')]
+        [2, 2]
       end
 
     end
@@ -58,25 +83,24 @@ Step 2. Instantiate the created Function Wrapper and pass it as the first argume
 
 ```ruby
    require 'metaheuristic_algorithms'
-   require 'bigdecimal'
 
    rosenbrook_function_wrapper = RosenbrookFunctionWrapper.new
 
    harmony_search = MetaheuristicAlgorithms::HarmonySearch.new(rosenbrook_function_wrapper, number_of_variables: 2, objective: :minimization)
 
    maximum_attempt = 25000
-   pitch_adjusting_range = BigDecimal('100')
+   pitch_adjusting_range = 100
    harmony_search_size = 20
-   harmony_memory_acceping_rate = BigDecimal('0.95')
-   pitch_adjusting_rate = BigDecimal('0.7')    
+   harmony_memory_acceping_rate = 0.95
+   pitch_adjusting_rate = 0.7    
 
    result = harmony_search.search(maximum_attempt: maximum_attempt, pitch_adjusting_range: pitch_adjusting_range, 
                                   harmony_search_size: harmony_search_size, harmony_memory_acceping_rate: harmony_memory_acceping_rate, 
                                   pitch_adjusting_rate: pitch_adjusting_rate)
 
-   puts result[:best_decision_variable_values][0] # x value: Example: BigDecimal('1.0112')
-   puts result[:best_decision_variable_values][1] # y value: Example: BigDecimal('0.9988')
-   puts result[:best_objective_function_value]    # f(x,y) value: Example: BigDecimal('0.0563')    
+   puts result[:best_decision_variable_values][0] # x value: Example: 1.0112
+   puts result[:best_decision_variable_values][1] # y value: Example: 0.9988
+   puts result[:best_objective_function_value]    # f(x,y) value: Example: 0.0563    
 ```
 
 ## Development
@@ -87,7 +111,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/metaheuristic_algorithms. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/tadatoshi/metaheuristic_algorithms. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
 
 ## License

data/lib/metaheuristic_algorithms/base_algorithm_module.rb

@@ -3,10 +3,23 @@ module MetaheuristicAlgorithms
   module BaseAlgorithmModule
 
     def get_decision_variable_value_by_randomization(decision_variable_index)
+      # @function_wrapper.miminum_decision_variable_values[decision_variable_index] 
+      # + (@function_wrapper.maximum_decision_variable_values[decision_variable_index] - @function_wrapper.miminum_decision_variable_values[decision_variable_index]) * bigdecimal_rand
       @function_wrapper.miminum_decision_variable_values[decision_variable_index] 
-      + (@function_wrapper.maximum_decision_variable_values[decision_variable_index] - @function_wrapper.miminum_decision_variable_values[decision_variable_index]) * bigdecimal_rand
+      + (@function_wrapper.maximum_decision_variable_values[decision_variable_index] - @function_wrapper.miminum_decision_variable_values[decision_variable_index]) * rand
     end
 
+    # Based on the code by antonakos on http://stackoverflow.com/questions/5825680/code-to-generate-gaussian-normally-distributed-random-numbers-in-ruby
+    # His code is under CC0 1.0 Universal (CC0 1.0)
+    def gaussian(mean, stddev)
+      theta = 2 * Math::PI * Kernel.rand
+      rho = Math.sqrt(-2 * Math.log(1 - Kernel.rand))
+      scale = stddev * rho
+      x = mean + scale * Math.cos(theta)
+      # y = mean + scale * Math.sin(theta)
+      return x
+    end  
+
   end
 
 end

data/lib/metaheuristic_algorithms/calculation_helper.rb

@@ -1,13 +1,17 @@
+require 'bigdecimal'
+
 module MetaheuristicAlgorithms
 
   module CalculationHelper
 
     def degree_to_radian(degree)
-      degree * BigDecimal(Math::PI.to_s) / BigDecimal('180')
+      # degree * BigDecimal(Math::PI.to_s) / BigDecimal('180')
+      degree * Math::PI / 180
     end
 
     def radian_to_degree(radian)
-      radian * BigDecimal('180') / BigDecimal(Math::PI.to_s)
+      # radian * BigDecimal('180') / BigDecimal(Math::PI.to_s)
+      radian * 180 / Math::PI
     end
 
     def bigdecimal_exp(bigdecimal_value)

data/lib/metaheuristic_algorithms/firefly_algorithm.rb

@@ -1,5 +1,5 @@
-require 'bigdecimal'
-require 'bigdecimal/math'
+# require 'bigdecimal'
+# require 'bigdecimal/math'
 
 module MetaheuristicAlgorithms
 
@@ -42,17 +42,19 @@ module MetaheuristicAlgorithms
                                end
     end
 
-    def search(number_of_fireflies: 10, maximun_generation: 10, randomization_parameter_alpha: BigDecimal('0.2'), absorption_coefficient_gamma: BigDecimal('1.0'))
+    # def search(number_of_fireflies: 10, maximun_generation: 10, randomization_parameter_alpha: BigDecimal('0.2'), absorption_coefficient_gamma: BigDecimal('1.0'))
+    def search(number_of_fireflies: 10, maximun_generation: 10, randomization_parameter_alpha: 0.2, absorption_coefficient_gamma: 1.0)
 
       number_of_fireflies = number_of_fireflies.to_i unless number_of_fireflies.kind_of?(Integer)
       maximun_generation = maximun_generation.to_i unless maximun_generation.kind_of?(Integer)
-      randomization_parameter_alpha = BigDecimal(randomization_parameter_alpha.to_s) unless randomization_parameter_alpha.kind_of?(BigDecimal)
-      absorption_coefficient_gamma = BigDecimal(absorption_coefficient_gamma.to_s) unless absorption_coefficient_gamma.kind_of?(BigDecimal)
+      # randomization_parameter_alpha = BigDecimal(randomization_parameter_alpha.to_s) unless randomization_parameter_alpha.kind_of?(BigDecimal)
+      # absorption_coefficient_gamma = BigDecimal(absorption_coefficient_gamma.to_s) unless absorption_coefficient_gamma.kind_of?(BigDecimal)
+      randomization_parameter_alpha = randomization_parameter_alpha.to_f unless randomization_parameter_alpha.kind_of?(Float)
+      absorption_coefficient_gamma = absorption_coefficient_gamma.to_f unless absorption_coefficient_gamma.kind_of?(Float)
 
       initialize_fireflies(number_of_fireflies)
 
-      # 0 to maximun_generation-1
-      (0...maximun_generation).each do |generation|
+      maximun_generation.times do |generation|
 
         @fireflies.each { |firefly| firefly.update_light_intensity }
 
@@ -76,7 +78,8 @@ module MetaheuristicAlgorithms
             get_decision_variable_value_by_randomization(variable_index)
           end
 
-          firefly = Firefly.new(@function_wrapper, decision_variable_values, BigDecimal('0'))
+          # firefly = Firefly.new(@function_wrapper, decision_variable_values, BigDecimal('0'))
+          firefly = Firefly.new(@function_wrapper, decision_variable_values, 0)
           @fireflies << firefly
         end
 
@@ -84,7 +87,8 @@ module MetaheuristicAlgorithms
 
       def move_fireflies(randomization_parameter_alpha, absorption_coefficient_gamma)
 
-        attractiveness_beta_at_distance_0 = BigDecimal('1')
+        # attractiveness_beta_at_distance_0 = BigDecimal('1')
+        attractiveness_beta_at_distance_0 = 1
 
         fireflies_copy = @fireflies.map(&:deep_clone)
 
@@ -98,12 +102,16 @@ module MetaheuristicAlgorithms
 
               distance_of_two_fireflies = distance_of_two_fireflies(firefly_i, firefly_j)
 
-              attractiveness_beta = attractiveness_beta_at_distance_0 * BigMath.exp(-absorption_coefficient_gamma * distance_of_two_fireflies.power(2), 10)
+              # attractiveness_beta = attractiveness_beta_at_distance_0 * BigMath.exp(-absorption_coefficient_gamma * distance_of_two_fireflies.power(2), 10)
+              attractiveness_beta = attractiveness_beta_at_distance_0 * Math.exp(-absorption_coefficient_gamma * distance_of_two_fireflies**2)
 
-              (0...@number_of_variables).each do |variable_index|
-                new_location_coordinate = firefly_i.location_coordinates[variable_index] * (BigDecimal('1') - attractiveness_beta) 
+              @number_of_variables.times do |variable_index|
+                # new_location_coordinate = firefly_i.location_coordinates[variable_index] * (BigDecimal('1') - attractiveness_beta) 
+                #                           + firefly_j.location_coordinates[variable_index] * attractiveness_beta 
+                #                           + randomization_parameter_alpha * (bigdecimal_rand - BigDecimal('0.5'))
+                new_location_coordinate = firefly_i.location_coordinates[variable_index] * (1 - attractiveness_beta) 
                                           + firefly_j.location_coordinates[variable_index] * attractiveness_beta 
-                                          + randomization_parameter_alpha * (bigdecimal_rand - BigDecimal('0.5'))
+                                          + randomization_parameter_alpha * (rand - 0.5)                
                 new_location_coordinate = constrain_within_range(new_location_coordinate, variable_index)
 
                 firefly_i.location_coordinates[variable_index] = new_location_coordinate
@@ -129,11 +137,12 @@ module MetaheuristicAlgorithms
 
       def distance_of_two_fireflies(firefly_1, firefly_2)
 
-        sum_of_squares = (0...@number_of_variables).inject(BigDecimal('0')) do |sum, variable_index|
-          sum + (firefly_1.location_coordinates[variable_index] - firefly_2.location_coordinates[variable_index]).power(2)
+        # sum_of_squares = (0...@number_of_variables).inject(BigDecimal('0')) do |sum, variable_index|
+        sum_of_squares = (0...@number_of_variables).inject(0) do |sum, variable_index|
+          sum + (firefly_1.location_coordinates[variable_index] - firefly_2.location_coordinates[variable_index])**2
         end
 
-        sum_of_squares.sqrt(10)
+        Math.sqrt(sum_of_squares)
 
       end       
 

data/lib/metaheuristic_algorithms/function_wrappers/easom_function_wrapper.rb

@@ -1,4 +1,4 @@
-require 'bigdecimal/math'
+# require 'bigdecimal/math'
 
 module MetaheuristicAlgorithms
 
@@ -8,15 +8,18 @@ module MetaheuristicAlgorithms
       include MetaheuristicAlgorithms::CalculationHelper
 
       def maximum_decision_variable_values
-        [BigDecimal('10')]
+        # [BigDecimal('10')]
+        [10]
       end
 
       def miminum_decision_variable_values
-        [BigDecimal('-10')]
+        # [BigDecimal('-10')]
+        [-10]
       end
 
       def objective_function_value(decision_variable_values)
-        -bigdecimal_cos(decision_variable_values[0]) * BigMath.exp((-(decision_variable_values[0] - BigMath.PI(10)).power(2)), 10)
+        # -bigdecimal_cos(decision_variable_values[0]) * BigMath.exp((-(decision_variable_values[0] - BigMath.PI(10)).power(2)), 10)
+        -Math.cos(decision_variable_values[0]) * Math.exp(-(decision_variable_values[0] - Math::PI)**2)
       end
 
       def initial_decision_variable_value_estimates

data/lib/metaheuristic_algorithms/function_wrappers/michaelwicz_function_wrapper.rb

@@ -1,4 +1,4 @@
-require 'bigdecimal/math'
+# require 'bigdecimal/math'
 
 module MetaheuristicAlgorithms
 
@@ -8,16 +8,20 @@ module MetaheuristicAlgorithms
       include MetaheuristicAlgorithms::CalculationHelper
 
       def maximum_decision_variable_values
-        [BigDecimal('4'), BigDecimal('4')]
+        # [BigDecimal('4'), BigDecimal('4')]
+        [4, 4]
       end
 
       def miminum_decision_variable_values
-        [BigDecimal('0'), BigDecimal('0')]
+        # [BigDecimal('0'), BigDecimal('0')]
+        [0, 0]
       end
 
       def objective_function_value(decision_variable_values)
-        -bigdecimal_sin(decision_variable_values[0]) * bigdecimal_sin(decision_variable_values[0].power(2) / BigMath.PI(10)).power(20) - 
-        bigdecimal_sin(decision_variable_values[1]) * bigdecimal_sin(decision_variable_values[1].power(2) / BigMath.PI(10)).power(20)
+        # -bigdecimal_sin(decision_variable_values[0]) * bigdecimal_sin(decision_variable_values[0].power(2) / BigMath.PI(10)).power(20) - 
+        # bigdecimal_sin(decision_variable_values[1]) * bigdecimal_sin(decision_variable_values[1].power(2) / BigMath.PI(10)).power(20)
+        -Math.sin(decision_variable_values[0]) * (Math.sin(decision_variable_values[0]**2 / Math::PI))**20 - 
+        Math.sin(decision_variable_values[1]) * (Math.sin(decision_variable_values[1]**2 / Math::PI))**20
       end
 
       def initial_decision_variable_value_estimates

data/lib/metaheuristic_algorithms/function_wrappers/nonsmooth_multipeak_function_wrapper.rb

@@ -1,4 +1,4 @@
-require 'bigdecimal/math'
+# require 'bigdecimal/math'
 
 module MetaheuristicAlgorithms
 
@@ -7,15 +7,18 @@ module MetaheuristicAlgorithms
     class NonsmoothMultipeakFunctionWrapper < AbstractWrapper
 
       def maximum_decision_variable_values
-        [BigDecimal('5'), BigDecimal('5')]
+        # [BigDecimal('5'), BigDecimal('5')]
+        [5, 5]
       end
 
       def miminum_decision_variable_values
-        [BigDecimal('-5'), BigDecimal('-5')]
+        # [BigDecimal('-5'), BigDecimal('-5')]
+        [-5, -5]
       end
 
       def objective_function_value(decision_variable_values)
-        (decision_variable_values[0].abs + decision_variable_values[1].abs) * BigMath.exp((BigDecimal('-0.0625') * (decision_variable_values[0].power(2) + decision_variable_values[1].power(2))), 10)     
+        # (decision_variable_values[0].abs + decision_variable_values[1].abs) * BigMath.exp((BigDecimal('-0.0625') * (decision_variable_values[0].power(2) + decision_variable_values[1].power(2))), 10) 
+        (decision_variable_values[0].abs + decision_variable_values[1].abs) * Math.exp(-0.0625 * (decision_variable_values[0]**2 + decision_variable_values[1]**2))    
       end
 
       def initial_decision_variable_value_estimates

data/lib/metaheuristic_algorithms/function_wrappers/rosenbrook_function_wrapper.rb

@@ -5,19 +5,23 @@ module MetaheuristicAlgorithms
     class RosenbrookFunctionWrapper < AbstractWrapper
 
       def maximum_decision_variable_values
-        [BigDecimal('5'), BigDecimal('5')]
+        # [BigDecimal('5'), BigDecimal('5')]
+        [5, 5]
       end
 
       def miminum_decision_variable_values
-        [BigDecimal('-5'), BigDecimal('-5')]
+        # [BigDecimal('-5'), BigDecimal('-5')]
+        [-5, -5]
       end
 
       def objective_function_value(decision_variable_values)
-        (BigDecimal('1') - decision_variable_values[0]).power(2) + BigDecimal('100') * (decision_variable_values[1] - decision_variable_values[0].power(2)).power(2)
+        # (BigDecimal('1') - decision_variable_values[0]).power(2) + BigDecimal('100') * (decision_variable_values[1] - decision_variable_values[0].power(2)).power(2)
+        (1 - decision_variable_values[0])**2 + 100 * (decision_variable_values[1] - decision_variable_values[0]**2)**2
       end
 
       def initial_decision_variable_value_estimates
-        [BigDecimal('2'), BigDecimal('2')]
+        # [BigDecimal('2'), BigDecimal('2')]
+        [2, 2]
       end
 
     end

data/lib/metaheuristic_algorithms/genetic_algorithm.rb

@@ -19,23 +19,28 @@ module MetaheuristicAlgorithms
       # @string_length_in_bits = 16
     end
 
-    def search(population_size: 20, maximum_number_of_generations: 100, number_of_mutation_sites: BigDecimal('2'), crossover_probability: BigDecimal('0.95'), mutation_probability: BigDecimal('0.05'))
+    # def search(population_size: 20, maximum_number_of_generations: 100, number_of_mutation_sites: BigDecimal('2'), crossover_probability: BigDecimal('0.95'), mutation_probability: BigDecimal('0.05'))
+    def search(population_size: 20, maximum_number_of_generations: 100, number_of_mutation_sites: 2, crossover_probability: 0.95, mutation_probability: 0.05)
 
       population_size = population_size.to_i unless population_size.kind_of?(Integer)
       maximum_number_of_generations = maximum_number_of_generations.to_i unless maximum_number_of_generations.kind_of?(Integer)
-      number_of_mutation_sites = BigDecimal(number_of_mutation_sites.to_s) unless number_of_mutation_sites.kind_of?(BigDecimal)
-      crossover_probability = BigDecimal(crossover_probability.to_s) unless crossover_probability.kind_of?(BigDecimal)
-      mutation_probability = BigDecimal(mutation_probability.to_s) unless mutation_probability.kind_of?(BigDecimal)
+      # number_of_mutation_sites = BigDecimal(number_of_mutation_sites.to_s) unless number_of_mutation_sites.kind_of?(BigDecimal)
+      # crossover_probability = BigDecimal(crossover_probability.to_s) unless crossover_probability.kind_of?(BigDecimal)
+      # mutation_probability = BigDecimal(mutation_probability.to_s) unless mutation_probability.kind_of?(BigDecimal)
+      number_of_mutation_sites = number_of_mutation_sites.to_i unless number_of_mutation_sites.kind_of?(Integer)
+      crossover_probability = crossover_probability.to_f unless crossover_probability.kind_of?(Float)
+      mutation_probability = mutation_probability.to_f unless mutation_probability.kind_of?(Float)      
 
       initialize_population(population_size)
 
-      (0...maximum_number_of_generations).each do |generation_index|
+      maximum_number_of_generations.times do |generation_index|
 
         @population_copy = deep_clone_population
 
-        (0...population_size).each do |individual_index|
+        population_size.times do |individual_index|
 
-          if bigdecimal_rand < crossover_probability
+          # if bigdecimal_rand < crossover_probability
+          if rand < crossover_probability
 
             # Crossover pair:
             crossover_pair_1_index = generate_random_index(population_size)
@@ -45,7 +50,8 @@ module MetaheuristicAlgorithms
 
           end
 
-          if bigdecimal_rand < mutation_probability
+          # if bigdecimal_rand < mutation_probability
+          if rand < mutation_probability
 
             mutation_individual_index = generate_random_index(population_size)
 
@@ -71,8 +77,7 @@ module MetaheuristicAlgorithms
         @population = []
         @population_fitness = []
 
-        # 0 to population_size-1
-        (0...population_size).each do |individual_index|
+        population_size.times do |individual_index|
           decision_variable_values = (0...@number_of_variables).map do |variable_index|
             get_decision_variable_value_by_randomization(variable_index)
           end
@@ -91,7 +96,7 @@ module MetaheuristicAlgorithms
         crossover_pair_1_decimal_values = []
         crossover_pair_2_decimal_values = []
 
-        (0...@number_of_variables).each do |variable_index|
+        @number_of_variables.times do |variable_index|
 
           crossover_pair_1_decimal_value = @population_copy[crossover_pair_1_index][variable_index]
           crossover_pair_2_decimal_value = @population_copy[crossover_pair_2_index][variable_index]
@@ -143,7 +148,7 @@ module MetaheuristicAlgorithms
 
       def binary_32_string_to_decimal(binary_32_string)
         decimal_float_value = [binary_32_string].pack("B*").unpack('g')[0].round(4)
-        BigDecimal(decimal_float_value.to_s)
+        # BigDecimal(decimal_float_value.to_s)
       end
 
       def mutate(individual_index, number_of_mutation_sites)
@@ -155,7 +160,7 @@ module MetaheuristicAlgorithms
 
           mutated_binary_32_string = binary_32_string.clone
 
-          (0...number_of_mutation_sites).each do |i|
+          number_of_mutation_sites.to_i.times do |i|
             mutation_site_index = generate_mutation_site_index
             # Flips 1 to 0 or 0 to 1:
             mutated_binary_32_string[mutation_site_index] = ((binary_32_string[mutation_site_index].to_i + 1).modulo(2)).to_s

data/lib/metaheuristic_algorithms/harmony_search.rb

@@ -20,22 +20,23 @@ module MetaheuristicAlgorithms
                                when :minimization
                                  :<
                              end 
-
-      @decision_variable_range = [@function_wrapper.miminum_decision_variable_values, @function_wrapper.maximum_decision_variable_values]   
     end
 
-    def search(maximum_attempt: 2500, pitch_adjusting_range: BigDecimal('100'), harmony_search_size: 20, harmony_memory_acceping_rate: BigDecimal('0.95'), pitch_adjusting_rate: BigDecimal('0.7'))
+    # def search(maximum_attempt: 2500, pitch_adjusting_range: BigDecimal('100'), harmony_search_size: 20, harmony_memory_acceping_rate: BigDecimal('0.95'), pitch_adjusting_rate: BigDecimal('0.7'))
+    def search(maximum_attempt: 2500, pitch_adjusting_range: 100, harmony_search_size: 20, harmony_memory_acceping_rate: 0.95, pitch_adjusting_rate: 0.7)
 
       maximum_attempt = maximum_attempt.to_i unless maximum_attempt.kind_of?(Integer)
-      pitch_adjusting_range = BigDecimal(pitch_adjusting_range.to_s) unless pitch_adjusting_range.kind_of?(BigDecimal)
+      # pitch_adjusting_range = BigDecimal(pitch_adjusting_range.to_s) unless pitch_adjusting_range.kind_of?(BigDecimal)
+      pitch_adjusting_range = pitch_adjusting_range.to_f unless pitch_adjusting_range.kind_of?(Float)
       harmony_search_size = harmony_search_size.to_i unless harmony_search_size.kind_of?(Integer)
-      harmony_memory_acceping_rate = BigDecimal(harmony_memory_acceping_rate.to_s) unless harmony_memory_acceping_rate.kind_of?(BigDecimal)
-      pitch_adjusting_rate = BigDecimal(pitch_adjusting_rate.to_s) unless pitch_adjusting_rate.kind_of?(BigDecimal)
+      # harmony_memory_acceping_rate = BigDecimal(harmony_memory_acceping_rate.to_s) unless harmony_memory_acceping_rate.kind_of?(BigDecimal)
+      # pitch_adjusting_rate = BigDecimal(pitch_adjusting_rate.to_s) unless pitch_adjusting_rate.kind_of?(BigDecimal)
+      harmony_memory_acceping_rate = harmony_memory_acceping_rate.to_f unless harmony_memory_acceping_rate.kind_of?(Float)
+      pitch_adjusting_rate = pitch_adjusting_rate.to_f unless pitch_adjusting_rate.kind_of?(Float)
 
       initialize_harmony_memory(harmony_search_size)
 
-      # 0 to maximum_attempt-1
-      (0...maximum_attempt).each do |count|
+      maximum_attempt.times do |count|
 
         decision_variable_values = (0...@number_of_variables).map do |variable_index|
 
@@ -43,12 +44,15 @@ module MetaheuristicAlgorithms
             decision_variable_value = get_decision_variable_value_by_randomization(variable_index)
           else
             # Since the array index starts with 0 unlike MatLab, 1 is not added as in the code example in MatLab:
-            harmony_memory_random_index = (harmony_search_size * bigdecimal_rand).fix
+            # harmony_memory_random_index = (harmony_search_size * bigdecimal_rand).fix
+            harmony_memory_random_index = (harmony_search_size * rand).to_i
             decision_variable_value = @harmony_memory[harmony_memory_random_index][variable_index]
             
-            if bigdecimal_rand < pitch_adjusting_rate
+            # if bigdecimal_rand < pitch_adjusting_rate
+            if rand < pitch_adjusting_rate
               pitch_adjusting = (@function_wrapper.maximum_decision_variable_values[variable_index] - @function_wrapper.miminum_decision_variable_values[variable_index]) / pitch_adjusting_range
-              decision_variable_value = decision_variable_value + pitch_adjusting * (bigdecimal_rand - BigDecimal('0.5'))
+              # decision_variable_value = decision_variable_value + pitch_adjusting * (bigdecimal_rand - BigDecimal('0.5'))
+              decision_variable_value = decision_variable_value + pitch_adjusting * (rand -0.5)
             end
           end
 

data/lib/metaheuristic_algorithms/simplified_particle_swarm_optimization.rb

@@ -15,20 +15,22 @@ module MetaheuristicAlgorithms
                                end        
     end
 
-    def search(number_of_particiles: 20, number_of_iterations: 15, social_coefficient: BigDecimal('0.5'), random_variable_coefficient: BigDecimal('0.2'))
+    # def search(number_of_particiles: 20, number_of_iterations: 15, social_coefficient: BigDecimal('0.5'), random_variable_coefficient: BigDecimal('0.2'))
+    def search(number_of_particiles: 20, number_of_iterations: 15, social_coefficient: 0.5, random_variable_coefficient: 0.2)
 
       number_of_particiles = number_of_particiles.to_i unless number_of_particiles.kind_of?(Integer)
       number_of_iterations = number_of_iterations.to_i unless number_of_iterations.kind_of?(Integer)
-      social_coefficient = BigDecimal(social_coefficient.to_s) unless social_coefficient.kind_of?(BigDecimal)
-      random_variable_coefficient = BigDecimal(random_variable_coefficient.to_s) unless random_variable_coefficient.kind_of?(BigDecimal)        
+      # social_coefficient = BigDecimal(social_coefficient.to_s) unless social_coefficient.kind_of?(BigDecimal)
+      # random_variable_coefficient = BigDecimal(random_variable_coefficient.to_s) unless random_variable_coefficient.kind_of?(BigDecimal)        
+      social_coefficient = social_coefficient.to_f unless social_coefficient.kind_of?(Float)
+      random_variable_coefficient = random_variable_coefficient.to_f unless random_variable_coefficient.kind_of?(Float)        
 
       initialize_particles(number_of_particiles)
 
       global_best_position = nil
       best_function_value = nil
 
-      # 0 to number_of_iterations-1
-      (0...number_of_iterations).each do |iteration|
+      number_of_iterations.times do |iteration|
 
         function_values = @particle_locations.map do |particle_location|
           @function_wrapper.objective_function_value(particle_location)
@@ -50,8 +52,7 @@ module MetaheuristicAlgorithms
 
         @particle_locations = []
 
-        # 0 to number_of_particiles-1
-        (0...number_of_particiles).each do |individual_index|
+        number_of_particiles.times do |individual_index|
           decision_variable_values = (0...@number_of_variables).map do |variable_index|
             get_decision_variable_value_by_randomization(variable_index)
           end
@@ -68,10 +69,12 @@ module MetaheuristicAlgorithms
           (0...@number_of_variables).map do |variable_index|
 
             # The value out-of-range in order to enter while loop
-            new_particle_location_coordinate = @function_wrapper.miminum_decision_variable_values[variable_index] - BigDecimal('1')
+            # new_particle_location_coordinate = @function_wrapper.miminum_decision_variable_values[variable_index] - BigDecimal('1')
+            new_particle_location_coordinate = @function_wrapper.miminum_decision_variable_values[variable_index] - 1
 
             while new_particle_location_coordinate < @function_wrapper.miminum_decision_variable_values[variable_index] || new_particle_location_coordinate > @function_wrapper.maximum_decision_variable_values[variable_index]
-              new_particle_location_coordinate = (BigDecimal('1') - social_coefficient) * particle_location[variable_index] + social_coefficient * global_best_position[variable_index] + random_variable_coefficient * (bigdecimal_rand - BigDecimal('0.5'))
+              # new_particle_location_coordinate = (BigDecimal('1') - social_coefficient) * particle_location[variable_index] + social_coefficient * global_best_position[variable_index] + random_variable_coefficient * (bigdecimal_rand - BigDecimal('0.5'))
+              new_particle_location_coordinate = (1 - social_coefficient) * particle_location[variable_index] + social_coefficient * global_best_position[variable_index] + random_variable_coefficient * (rand - 0.5)
             end
 
             new_particle_location_coordinate

data/lib/metaheuristic_algorithms/simulated_annealing.rb

@@ -1,10 +1,12 @@
-require 'bigdecimal/math'
-require 'distribution'
+# require 'bigdecimal/math'
+# In order to support JRuby, decided not to use distribution gem:
+# require 'distribution'
 
 module MetaheuristicAlgorithms
 
   class SimulatedAnnealing
     include MetaheuristicAlgorithms::Helper
+    include MetaheuristicAlgorithms::BaseAlgorithmModule
 
     def initialize(function_wrapper, number_of_variables: 1, objective: :maximization)
       @function_wrapper = function_wrapper
@@ -17,21 +19,32 @@ module MetaheuristicAlgorithms
                              end        
     end
 
-    def search(temperature: BigDecimal('100.0'), minimal_temperature: BigDecimal('1'), maximum_number_of_rejections: 2500, 
+    # def search(temperature: BigDecimal('100.0'), minimal_temperature: BigDecimal('1'), maximum_number_of_rejections: 2500, 
+    #            maximum_number_of_runs: 500, maximum_number_of_acceptances: 15, 
+    #            bolzmann_constant: BigDecimal('1'), cooling_factor: BigDecimal('0.95'), energy_norm: BigDecimal('10'), 
+    #            standard_diviation_for_estimation: BigDecimal('6'), ratio_of_energy_delta_over_evaluation_delta: BigDecimal('10'))
+    def search(temperature: 100.0, minimal_temperature: 1, maximum_number_of_rejections: 2500, 
                maximum_number_of_runs: 500, maximum_number_of_acceptances: 15, 
-               bolzmann_constant: BigDecimal('1'), cooling_factor: BigDecimal('0.95'), energy_norm: BigDecimal('10'), 
-               standard_diviation_for_estimation: BigDecimal('6'), ratio_of_energy_delta_over_evaluation_delta: BigDecimal('10'))
+               bolzmann_constant: 1, cooling_factor: 0.95, energy_norm: 10, 
+               standard_diviation_for_estimation: 6, ratio_of_energy_delta_over_evaluation_delta: 10)
 
-      temperature = BigDecimal(temperature.to_s) unless temperature.kind_of?(BigDecimal)
-      minimal_temperature = BigDecimal(minimal_temperature.to_s) unless minimal_temperature.kind_of?(BigDecimal)
+      # temperature = BigDecimal(temperature.to_s) unless temperature.kind_of?(BigDecimal)
+      # minimal_temperature = BigDecimal(minimal_temperature.to_s) unless minimal_temperature.kind_of?(BigDecimal)
+      temperature = temperature.to_f unless temperature.kind_of?(Float)
+      minimal_temperature = minimal_temperature.to_f unless minimal_temperature.kind_of?(Float)      
       maximum_number_of_rejections = maximum_number_of_rejections.to_i unless maximum_number_of_rejections.kind_of?(Integer)
       maximum_number_of_runs = maximum_number_of_runs.to_i unless maximum_number_of_runs.kind_of?(Integer)
       maximum_number_of_acceptances = maximum_number_of_acceptances.to_i unless maximum_number_of_acceptances.kind_of?(Integer)
-      bolzmann_constant = BigDecimal(bolzmann_constant.to_s) unless bolzmann_constant.kind_of?(BigDecimal)
-      cooling_factor = BigDecimal(cooling_factor.to_s) unless cooling_factor.kind_of?(BigDecimal)
-      energy_norm = BigDecimal(energy_norm.to_s) unless energy_norm.kind_of?(BigDecimal)
-      standard_diviation_for_estimation = BigDecimal(standard_diviation_for_estimation.to_s) unless standard_diviation_for_estimation.kind_of?(BigDecimal)
-      ratio_of_energy_delta_over_evaluation_delta = BigDecimal(ratio_of_energy_delta_over_evaluation_delta.to_s) unless ratio_of_energy_delta_over_evaluation_delta.kind_of?(BigDecimal)
+      # bolzmann_constant = BigDecimal(bolzmann_constant.to_s) unless bolzmann_constant.kind_of?(BigDecimal)
+      # cooling_factor = BigDecimal(cooling_factor.to_s) unless cooling_factor.kind_of?(BigDecimal)
+      # energy_norm = BigDecimal(energy_norm.to_s) unless energy_norm.kind_of?(BigDecimal)
+      # standard_diviation_for_estimation = BigDecimal(standard_diviation_for_estimation.to_s) unless standard_diviation_for_estimation.kind_of?(BigDecimal)
+      # ratio_of_energy_delta_over_evaluation_delta = BigDecimal(ratio_of_energy_delta_over_evaluation_delta.to_s) unless ratio_of_energy_delta_over_evaluation_delta.kind_of?(BigDecimal)
+      bolzmann_constant = bolzmann_constant.to_f unless bolzmann_constant.kind_of?(Float)
+      cooling_factor = cooling_factor.to_f unless cooling_factor.kind_of?(Float)
+      energy_norm = energy_norm.to_f unless energy_norm.kind_of?(Float)
+      standard_diviation_for_estimation = standard_diviation_for_estimation.to_f unless standard_diviation_for_estimation.kind_of?(Float)
+      ratio_of_energy_delta_over_evaluation_delta = ratio_of_energy_delta_over_evaluation_delta.to_f unless ratio_of_energy_delta_over_evaluation_delta.kind_of?(Float)
 
       number_of_runs = 0
       number_of_rejections = 0
@@ -66,13 +79,15 @@ module MetaheuristicAlgorithms
         # Accept if improved:
         # When objective = :maximization, "if evaluation_delta > 0 && evaluation_delta > energy_norm"
         # When objective = :minimization, "if evaluation_delta < 0 && -evaluation_delta > energy_norm"
-        if evaluation_delta.send(@objective_comparison_operator, BigDecimal('0')) && evaluation_delta.abs > energy_norm
+        # if evaluation_delta.send(@objective_comparison_operator, BigDecimal('0')) && evaluation_delta.abs > energy_norm
+        if evaluation_delta.send(@objective_comparison_operator, 0) && evaluation_delta.abs > energy_norm
           best_solution = new_estimates
           best_evaluation = new_evaluation
           number_of_acceptances = number_of_acceptances + 1
           number_of_rejections = 0
         # Accept with a small probability if not improved
-        elsif acceptance_probability(evaluation_delta, temperature, bolzmann_constant) > bigdecimal_rand
+        # elsif acceptance_probability(evaluation_delta, temperature, bolzmann_constant) > bigdecimal_rand
+      elsif acceptance_probability(evaluation_delta, temperature, bolzmann_constant) > rand
           best_solution = new_estimates
           best_evaluation = new_evaluation
           number_of_acceptances = number_of_acceptances + 1            
@@ -92,13 +107,17 @@ module MetaheuristicAlgorithms
         (0...@number_of_variables).map do |variable_index|
 
           # The value out-of-range in order to enter while loop
-          new_estimate = @function_wrapper.miminum_decision_variable_values[variable_index] - BigDecimal('1')
+          # new_estimate = @function_wrapper.miminum_decision_variable_values[variable_index] - BigDecimal('1')
+          new_estimate = @function_wrapper.miminum_decision_variable_values[variable_index] - 1
 
           while new_estimate < @function_wrapper.miminum_decision_variable_values[variable_index] || new_estimate > @function_wrapper.maximum_decision_variable_values[variable_index]
 
             # MatLab example code uses newGuess = initialGuess + rand(1,2) * randn;
             # But in our case, the value range is different. 
-            new_estimate = BigDecimal(Distribution::Normal.rng(previous_estimates[variable_index], standard_diviation_for_estimation).call.to_s)
+            # In order to support JRuby, decided not to use Distribution::Normal.rng:
+            # new_estimate = BigDecimal(Distribution::Normal.rng(previous_estimates[variable_index], standard_diviation_for_estimation).call.to_s)
+            # new_estimate = BigDecimal(gaussian(previous_estimates[variable_index], standard_diviation_for_estimation).to_s)
+            new_estimate = gaussian(previous_estimates[variable_index], standard_diviation_for_estimation)
 
           end
 

data/lib/metaheuristic_algorithms/version.rb

@@ -1,3 +1,3 @@
 module MetaheuristicAlgorithms
-  VERSION = "0.1.3"
-end
+  VERSION = "0.2.1"
+end

data/lib/metaheuristic_algorithms/virtual_bee_algorithm.rb

@@ -1,4 +1,4 @@
-require 'bigdecimal'
+# require 'bigdecimal'
 
 module MetaheuristicAlgorithms
 

data/lib/metaheuristic_algorithms.rb

@@ -1,9 +1,9 @@
 require 'metaheuristic_algorithms/version'
-require 'bigdecimal'
+# require 'bigdecimal'
 require 'metaheuristic_algorithms/calculation_helper'
 require 'metaheuristic_algorithms/function_wrappers'
-require 'metaheuristic_algorithms/base_algorithm_module'
 require 'metaheuristic_algorithms/helper'
+require 'metaheuristic_algorithms/base_algorithm_module'
 require 'metaheuristic_algorithms/harmony_search'
 require 'metaheuristic_algorithms/firefly_algorithm'
 require 'metaheuristic_algorithms/genetic_algorithm'

data/metaheuristic_algorithms.gemspec

@@ -32,5 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "pry-byebug"  
+  # Requires native C extension. Doesn't work with JRuby. Hence moved to Gemfile:
+  #spec.add_development_dependency "pry-byebug" 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metaheuristic_algorithms
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 platform: ruby
 authors:
 - Tadatoshi Takahashi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-09 00:00:00.000000000 Z
+date: 2015-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: distribution
@@ -66,20 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Various metaheuristic algorithms implemented in Ruby.
 email:
 - tadatoshi@gmail.com
@@ -139,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Various metaheuristic algorithms implemented in Ruby.