rugal 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96e1028fc4474ef75947b5ebf8651de4069c16a8ed9c866f87fb9069e88e6dbc
+  data.tar.gz: ce64b85b190763f57d1e82883bba6ad02c1473e3862831bbe7fe545be9bf19b7
+SHA512:
+  metadata.gz: e7e625f0dadad4179733793b23e10fd0c1dd01d2a97bb19b0d4b5c8147a77234720ad0994ae8d2a8e02f1d67b91096c937c22267e62eb6e85618b547f3223b3b
+  data.tar.gz: 073ff9d28d33a60082b070758e10742bad476366e49669228147d8420a87b8bd79d08a529359ecc9d9f5c0233e625ec79fd801f9654a75f04de62428912bb07c

data/lib/genetic_algorithm.rb

@@ -0,0 +1,110 @@
+require_relative "operators"
+require_relative "rugal"
+require_relative "solution"
+
+module GA
+    class Algorithm
+        def initialize(factory, options={})
+            @factory = factory
+            
+            @selection = options[:selection] || GA::Operators::Selection::RouletteWheel.new
+            @crossover = options[:crossover] || GA::Operators::Crossover::SinglePoint.new
+            @mutation  = options[:mutation]  || GA::Operators::Mutation::Uniform.new
+            @operators = options[:operators] || []
+            
+            @population_size    = options[:population_size] || 100
+            @elite              = options[:elite]           || 0.1
+            
+            GA.contract("Factory must not be nil") { factory }
+            GA.contract("Factory must be a SolutionFactory") { factory.is_a?(GA::Solutions::SolutionFactory) }
+            GA.contract("Elite must be non-negative (#@elite given)") { @elite >= 0 }
+            GA.contract("All the additional operators must be Operator") { @operators.all? { |op| op.is_a? GA::Operators::Operator } }
+        end
+    end
+    
+    class ClassicGenetic < Algorithm
+        def initialize(factory, options={})
+            super
+        end
+        
+        def maximize(iterations, options = {}, &fitness)
+            optimize(iterations, options, &fitness)
+        end
+        
+        def minimize(iterations, options = {}, &fitness)
+            optimize(iterations, options) { |chromosome| -fitness.call(chromosome) }
+        end
+        
+        def optimize(iterations, options = {}, &fitness)
+            GA.contract("You must pass the fitness function as a block") { fitness }
+            optimum = options[:optimum] || nil
+            
+            GA.contract("Iterations must be more than 0") { iterations & iterations > 0 }
+            GA.contract("Optimum must be numeric (or nil)") { !optimum || optimum.is_a?(Numeric) }
+            
+            population = @factory.population(@population_size)
+            
+            elite = []
+            iterations.times do |i|
+                GA::Logger.info "Generation #{i}"
+                population.each { |chromosome| chromosome.fitness = fitness.call(chromosome) }
+                
+                population = population - population.min(elite.size) { |chromosome| chromosome.fitness } + elite 
+                
+                elite = population.max(@elite * @population_size) { |chromosome| chromosome.fitness }
+                if optimum
+                    return elite[0] if elite[0].fitness == optimum
+                end
+
+                population = @selection.apply(population)
+                population = @crossover.apply(population)                
+                population =  @mutation.apply(population)
+                
+                # Uses additional operators
+                @operators.each do |operator|
+                    population = operator.apply(population)
+                end
+                
+                GA::Logger.info { "Average fitness: #{population.map { |c| c.fitness }.sum.to_f / population.size}" }
+            end
+            
+            return population.max { |chromosome| fitness.call(chromosome) }
+        end
+    end
+    
+    class RandomSearch
+        def initialize(factory, options = {})
+            @factory = factory
+            @population_size = options[:population_size] || 1
+        end
+        
+        def maximize(iterations, options = {}, &fitness)
+            optimize(iterations, options, &fitness)
+        end
+        
+        def minimize(iterations, options = {}, &fitness)
+            optimize(iterations, options) { |chromosome| -fitness.call(chromosome) }
+        end
+        
+        def optimize(iterations, options = {}, &fitness)
+            optimum = options[:optimum] || nil
+            
+            GA.contract("Iterations must be more than 0") { iterations > 0 }
+            GA.contract("Optimum must be numeric (or nil)") { !optimum || optimum.is_a?(Numeric) }
+            
+            best = nil
+            iterations.times do |i|
+                GA::Logger.info "Generation #{i}"
+                population = @factory.population(@population_size)
+                population.each { |chromosome| chromosome.fitness = fitness.call(chromosome) }
+                
+                current_best = population.max { |chromosome| chromosome.fitness}
+                best = current_best if !best || current_best.fitness > best.fitness
+                
+                GA::Logger.info { "Average fitness: #{population.map { |c| c.fitness }.sum.to_f / population.size}" }
+            end
+            
+            return best
+        end
+    end
+end

data/lib/operators.rb

@@ -0,0 +1,295 @@
+require_relative "genetic_algorithm"
+require_relative "rugal"
+require_relative "solution"
+
+module GA::Operators
+    class Operator
+    end
+end
+
+module GA::Operators::Selection
+    class Basic < GA::Operators::Operator
+    end
+    
+    class RouletteWheel < Basic
+        def apply(population)
+            min_fitness = population.map(&:fitness).min.abs + 1
+            fitnesses = population.map { |chromosome| chromosome.fitness != 0 ? chromosome.fitness + min_fitness : 0}
+            
+            total_fitness = fitnesses.sum
+            
+            return population.dup if total_fitness == 0
+            
+            current_total = 0.0
+            selection_array = []
+            fitnesses.each do |fitness|
+                current_total += fitness.to_f / total_fitness
+                selection_array.push current_total
+            end
+            
+            offspring = []
+            population.size.times do
+                value = GA::Random.rand
+                selected_index = selection_array.index { |v| value <= v }
+                offspring.push population[selected_index].dup
+            end
+            
+            return offspring
+        end
+    end
+    
+    class Random < Basic
+        def apply(population)
+            offspring = []
+            population.size.times do
+                index = GA::Random.rand(population.size)
+                offspring.push population[index].dup
+            end
+            return offspring
+        end
+    end
+end
+
+module GA::Operators::Crossover
+    class Basic < GA::Operators::Operator
+        def initialize(options = {})
+            @forbidden = []
+        end
+        
+        protected
+        def crossover(population)
+            result = []
+            
+            shuffled = GA::Random.shuffle(population)
+            shuffled.each_slice(2) do |c1, c2|
+                crossed = yield(c1, c2)
+                result += crossed
+            end
+            
+            return result
+        end
+        
+        def forbid(type)
+            @forbidden.push type
+        end
+        
+        def apply(population)
+            check_population(population)
+        end
+        
+        def check_population(population)
+            GA.contract("#{self.class} crossover does not accept #{@forbidden.join(", ")}") { population.none? { |c| @forbidden.include?(c.class) } }
+        end
+    end
+    
+    class SinglePoint < Basic
+        def initialize(options = {})
+            super
+            
+            @probability = options[:probability] || 0.8
+            GA.contract("Probability must be in the range [0, 1]") { @probability.between?(0, 1) }
+            
+            forbid GA::Solutions::PermutationSolution
+        end
+        
+        def apply(population)
+            super
+            
+            crossover(population) do |c1, c2|
+                c1 = c1.dup
+                c2 = c2.dup
+                
+                unless c2
+                    [c1]
+                else
+                    if GA::Random.with_probability(@probability)
+                        crossover_position = GA::Random.rand([c1.size, c2.size].min)
+                        
+                        for i in 0...crossover_position
+                            c1.data[i], c2.data[i] = c2.data[i], c1.data[i]
+                        end
+                    end
+                    
+                    [c1, c2]
+                end
+            end
+        end
+    end
+    
+    class PMX < Basic
+        def initialize(options = {})
+            super
+            
+            @probability = options[:probability] || 0.8
+            @percent     = options[:size]        || 0.5
+            
+            GA.contract("Probability must be in the range [0, 1]") { @probability.between?(0, 1) }
+            GA.contract("Swath size percentage must be in the range (0, 1)") { @percent > 0 && @percent < 1 }
+            
+            forbid GA::Solutions::IntegerSolution
+            forbid GA::Solutions::FloatSolution
+            forbid GA::Solutions::StringSolution
+        end
+        
+        def apply(population)
+            super
+            
+            crossover(population) do |c1, c2|                
+                unless c2
+                    [c1]
+                else
+                    t1 = c1
+                    t2 = c2
+                    if GA::Random.with_probability(@probability)
+                        size = GA::Random.rand_int(@percent * c1.size)
+                        from = GA::Random.rand_int(c1.size - size)
+                        to = from + size
+                        
+                        c1, c2 = pmx(t1, t2, from, to)
+                    end
+                    
+                    [c1, c2]
+                end
+            end
+        end
+        
+        private
+        def pmx(c1, c2, from, to)
+            range = from...to
+            
+            child1 = c1.dup
+            child2 = c2.dup
+            
+            swath1 = child1.data[range]
+            swath2 = child2.data[range]
+            
+            uswath1 = swath1 - swath2
+            uswath2 = swath2 - swath1
+            
+            mapping1to2 = {}
+            mapping2to1 = {}
+            for i in 0...uswath1.size
+                mapping1to2[uswath1[i]] = uswath2[i]
+                mapping2to1[uswath2[i]] = uswath1[i]
+            end
+                        
+            child1.data[range], child2.data[range] = child2.data[range], child1.data[range]
+            
+            changed_indices = ((0...child1.size).to_a - range.to_a)
+            for i in changed_indices
+                child1.data[i] = mapping2to1[child1.data[i]] if swath2.include?(child1.data[i])
+                child2.data[i] = mapping1to2[child2.data[i]] if swath1.include?(child2.data[i])
+            end
+            
+#             for i in ((0...child1.size).to_a - range.to_a)
+#                 v = child2.data[i]
+#                 
+#                 if swath1.include?(v)
+#                     rep = swath2[swath1.index(v)]
+#                     child2.data[i] = rep
+#                 end
+#             end
+            
+            GA.postcondition("All data in the permutation must be used: #{child1.to_s}") { child1.valid? }
+            GA.postcondition("All data in the permutation must be used: #{child2.to_s}") { child2.valid? }
+            
+            return child1, child2
+        end
+    end
+end
+
+module GA::Operators::Mutation
+    class Basic < GA::Operators::Operator
+        protected
+        def mutation(population)
+            result = []
+            
+            population.each do |chromosome|
+                result.push yield(chromosome)
+            end
+            
+            return result
+        end
+    end
+    
+    class Uniform < Basic
+        def initialize(options = {})
+            @probability = options[:probability]  || 0.01
+            @radius      = options[:radius]       || 1
+            @epsilon     = options[:epsilon]      || 0.01
+            
+            @epsilon = @epsilon.to_f
+            
+            GA.contract("Probability must be in the range [0, 1]") { @probability.between?(0, 1) }
+            GA.contract("Epsilon must be greater than 0") { @epsilon > 0 }
+        end
+        
+        def apply(population)
+            mutation(population) do |chromosome|
+                if GA::Random.with_probability(@probability)
+                    chromosome = chromosome.mutate(GA::Random.rand(chromosome.size)) do |v| 
+                        GA::Random.random_sign * [GA::Random.rand * @radius, @epsilon].max
+                    end
+                end
+                
+                chromosome
+            end
+        end
+    end
+    
+    class Positional < Basic
+        def initialize(options = {})
+            @probability = options[:probability] || 0.01
+            @radius      = options[:radius]      || 1
+            @epsilon     = options[:epsilon]     || 1
+            
+            GA.contract("Probability must be in the range [0, 1]") { @probability.between?(0, 1) }
+            GA.contract("Epsilon must be greater than 0") { @epsilon > 0 }
+        end
+        
+        def apply(population)
+            mutation(population) do |chromosome|
+                if GA::Random.with_probability(@probability)
+                    chromosome = chromosome.dup
+                    
+                    i1 = GA::Random.rand(chromosome.size)
+                    i2 = (i1 + [GA::Random.rand(@epsilon+1), @epsilon].max) % chromosome.size
+                    
+                    chromosome.data[i1], chromosome.data[i2] = chromosome.data[i2], chromosome.data[i1]
+                end
+                
+                chromosome
+            end
+        end
+    end
+end
+
+module GA::Operators::Additional
+    class Injector < GA::Operators::Operator
+        def initialize(factory, options = {})
+            @factory = factory
+            
+            @probability = options[:probability] || 0.01
+            @size        = options[:size]        || 1
+            
+            GA.contract("Factory cannot be nil") { @factory }
+            GA.contract("Factory must be a SolutionFactory") { @factory.is_a?(GA::Solutions::SolutionFactory) }
+            GA.contract("Probability must be in the range [0, 1]") { @probability.between?(0, 1) }
+            GA.contract("Size must be greater than 0") { @size > 0 }
+        end
+        
+        def apply(population)
+            if GA::Random.with_probability @probability
+                population = population.dup
+                size = [GA::Random.rand(@size + 1), 1].max
+                
+                to_remove = population.sample size
+                
+                population -= to_remove
+                population += @factory.population size
+            end
+            
+            return population
+        end
+    end
+end

data/lib/rugal.rb

@@ -0,0 +1,179 @@
+module Math
+    Random = Random
+end
+
+module GA
+    module Random
+        @@random = Math::Random.new
+        
+        def self.set_seed(i)
+            @@random = Math::Random.new i
+        end
+        
+        def self.random
+            @@random
+        end
+        
+        def self.shuffle(array)
+            GA.contract("Shuffle needs an array") { array.is_a?(Array) }
+            
+            return array.shuffle(random: @@random)
+        end
+        
+        def self.rand(*args)
+            @@random.rand *args
+        end
+        
+        def self.rand_int(*args)
+            self.rand(*args).to_i
+        end
+        
+        def self.with_probability(probability)
+            GA.contract("The probability must be in the range [0, 1] (#{probability} given)") { probability.between?(0, 1) }
+            
+            return self.rand <= probability
+        end
+        
+        def self.random_sign
+            value = self.rand(2)
+            
+            return value == 0 ? -1 : 1
+        end
+    end
+    
+    module Logger
+        LEVEL_DEBUG     = 0
+        LEVEL_INFO      = 1
+        LEVEL_WARNING   = 2
+        LEVEL_SEVERE    = 3
+        
+        @@level = 0
+        def self.debug(*data, &block)
+            return if @@level > LEVEL_DEBUG
+            self.log "DEBUG", *data, &block
+        end
+        
+        def self.info(*data, &block)
+            return if @@level > LEVEL_INFO
+            self.log "INFO", *data, &block
+        end
+        
+        def self.warning(*data, &block)
+            return if @@level > LEVEL_WARNING
+            self.log "WARNING", *data, &block
+        end
+        
+        def self.severe(*data, &block)
+            return if @@level > LEVEL_SEVERE
+            self.log "SEVERE", *data, &block
+        end
+        
+        def self.level=(level)
+            GA.contract("The logger level must be between 0 and 3 (#{level} given)") { level.between?(0, 3) }
+            @@level = level
+        end
+        
+        private
+        def self.log(type, *data, &block)
+            if block_given?
+                d = block.call
+                puts "#{type}: #{d}"
+            else
+                data.each do |d|
+                    puts "#{type}: #{d}"
+                end
+            end
+        end
+    end
+    
+    def self.profile(profile)
+        case profile
+        when :development
+            @@assumptions_checking = :hard
+            GA::Logger.level = GA::Logger::LEVEL_DEBUG
+            
+        when :testing
+            @@assumptions_checking = :hard
+            GA::Logger.level = GA::Logger::LEVEL_INFO
+            
+        when :production
+            @@assumptions_checking = :soft
+            GA::Logger.level = GA::Logger::LEVEL_WARNING
+            
+        when :stable_production
+            @@assumptions_checking = false
+            GA::Logger.level = GA::Logger::LEVEL_SEVERE
+            
+        else
+            raise "Illegal profile #{profile}"
+        end
+    end
+    
+    class ContractException < StandardError; end
+    class PostConditionException < StandardError; end
+    def self.contract(message = "Contract violated", condition = false, &block)
+        return unless @@assumptions_checking
+        
+        raise TypeError, "no implicit conversion of #{message.class} into String" unless message.is_a? String
+        
+        any_problem = false
+        if block_given?
+            any_problem = true unless yield
+        else
+            any_problem = true unless condition
+        end
+        
+        if any_problem
+            case @@assumptions_checking
+            when :hard
+                raise ContractException, message
+            when :soft
+                GA::Logger.severe(message)
+            end
+        end
+    end
+    
+    def self.postcondition(message = "Postcondition violated", condition = false, &block)
+        return unless @@assumptions_checking
+        
+        raise TypeError, "no implicit conversion of #{message.class} into String" unless message.is_a? String
+                
+        any_problem = false
+        if block_given?
+            any_problem = true unless yield
+        else
+            any_problem = true unless condition
+        end
+        
+        if any_problem
+            case @@assumptions_checking
+            when :hard
+                raise ContractException, message
+            when :soft
+                GA::Logger.severe(message)
+            end
+        end
+    end
+    
+    GA.profile :testing
+end
+
+def gadebug(*data)
+    GA::Logger.debug(*data)
+end
+
+def gainfo(*data)
+    GA::Logger.info(*data)
+end
+
+def gawarn(*data)
+    GA::Logger.warning(*data)
+end
+
+def gasevere(*data)
+    GA::Logger.severe(*data)
+end
+
+require_relative "genetic_algorithm"
+require_relative "operators"
+require_relative "solution"

data/lib/solution.rb

@@ -0,0 +1,181 @@
+require_relative "operators"
+require_relative "rugal"
+require_relative "genetic_algorithm"
+
+module GA::Solutions
+    class Solution
+        attr_accessor   :fitness
+        attr_reader     :data
+        
+        def initialize
+            @data = nil
+            @fitness = nil
+        end
+        
+        def size
+            @data.size
+        end
+        
+        def mutate(i, &block)
+            duplicate = self.dup
+            duplicate.mutate!(i, &block)
+            return duplicate
+        end
+        
+        def mutate!(i)
+            @data[i] = neighbour(@data[i], yield(@data[i]))
+        end
+        
+        def neighbour(value, by)
+            raise "Cannot infer the neighbours. Must be implemented in #{self.class}."
+        end
+        
+        def dup
+            duplicate = super
+            duplicate.internal_dup!
+            
+            return duplicate
+        end
+        
+        def inspect
+            "<" + self.class.to_s + " " + @data.inspect + ": #@fitness>"
+        end
+        
+        def to_s
+            @data.to_s
+        end
+        
+        protected
+        def internal_dup!
+            @data = @data.dup
+            @fitness
+        end
+    end
+        
+    class IntegerSolution < Solution
+        def initialize(size, options = {})
+            @min = options[:min] || 0
+            @max = options[:max] || 999999999
+            
+            GA.contract("Min must be an Integer") { @min.is_a?(Integer) }
+            GA.contract("Max must be an Integer") { @max.is_a?(Integer) }
+            GA.contract("Max must be greater than min") { @max > @min }
+            
+            
+            @data = size.times.map { GA::Random.rand(@max+1) + @min }
+        end
+        
+        def neighbour(value, by)
+            GA.contract("Value value must be an Integer") { value.is_a?(Integer) }
+            GA.contract("By must be a Numeric (#{by.class} given)") { by.is_a?(Numeric) }
+            GA.contract("By cannot be 0") { by != 0 }
+            by = by > 0 ? by.ceil : by.floor
+            
+            return [[value + by, @max].min, @min].max
+        end
+    end
+    
+    class FloatSolution < Solution
+        def initialize(size, options = {})
+            @min = (options[:min] || 0.0).to_f
+            @max = (options[:max] || 1.0).to_f
+            
+            GA.contract("Max and min must not be equal") { @max > @min }
+            
+            @data = size.times.map { ((@max-@min) * GA::Random.rand) + @min }
+        end
+        
+        def neighbour(value, by)
+            GA.contract("Value value must be a Float") { value.is_a?(Float) }
+            GA.contract("By must be a Numeric (#{by.class} given)") { by.is_a?(Numeric) }
+            GA.contract("By cannot be 0") { by != 0 }
+            
+            return [[value + by, @max].min, @min].max
+        end
+    end
+        
+    class StringSolution < Solution
+        def initialize(size, options = {})
+            @allowed = options[:allowed] || [('A'..'Z'), ('a'..'z'), ('0'..'9')].map { |e| e.to_a }.flatten
+            
+            GA.contract("Allowed must be an array (#{@allowed.class} given)") { @allowed.is_a?(Array) }
+            GA.contract("Allowed must be an array of characters, i.e., 1-sized Strings") { @allowed.all? { |c| c.is_a?(String) && c.size == 1 } }
+            GA.contract("There must be at least an allowed character") { @allowed.size > 0 }
+            
+            @data = size.times.map { @allowed[GA::Random.rand(@allowed.size)]}
+        end
+        
+        def neighbour(value, by)
+            GA.contract("Value must be a character (1-sized String)") { value.is_a?(String) && value.length == 1 }
+            GA.contract("Value must be an allowed character: <#{@allowed.join(", ")}>") { @allowed.include?(value) }
+            GA.contract("By must be a Numeric (#{by.class} given)") { by.is_a?(Numeric) }
+            GA.contract("By cannot be 0") { by != 0 }
+            
+            by = by > 0 ? by.ceil : by.floor
+            
+            return @allowed[@allowed.index(value) % @allowed.size]
+        end
+        
+        def to_s
+            @data.join ""
+        end
+    end
+    
+    class PermutationSolution < Solution
+        def self.force(data)
+            chromosome = self.new(data)
+            for i in 0...chromosome.size
+                chromosome.data[i] = data[i]
+            end
+            
+            GA.postcondition("Invalid forced chromosome") { chromosome.valid? }
+            
+            return chromosome
+        end
+        
+        def initialize(content)
+            @content = content
+            
+            GA.contract("Content must not be nil") { @content }
+            GA.contract("Content must contain at least an element") { @content.size > 0 }
+            
+            @data = GA::Random.shuffle @content
+        end
+        
+        def mutate!(index)
+            by = yield(@data[index])
+            
+            switch_with = (index + by) % @data.size
+            switch_with = (index + 1) % @data.size if switch_with == index
+            
+            GA.contract("By must be a Numeric (#{by.class} given)") { by.is_a?(Numeric) }
+            GA.contract("By cannot be 0") { by != 0 }
+            
+            @data[index], @data[switch_with] = @data[switch_with], @data[index]
+        end
+        
+        def valid?
+            ((@data - @content) + (@content - @data)) == []
+        end
+    end
+    
+    class SolutionFactory
+        def initialize(&block)
+            @generator = block
+        end
+        
+        def chromosome
+            return @generator.call
+        end
+        
+        def population(size)
+            size.times.map { chromosome }
+        end
+    end
+end
+
+class Array
+    def sample(n)
+        GA::Random.shuffle(self)[0...n]
+    end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: rugal
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Simone Scalabrino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-18 00:00:00.000000000 Z
+dependencies: []
+description: Pure-ruby implementation of genetic algorithms
+email: s.scalabrino9@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/genetic_algorithm.rb
+- lib/operators.rb
+- lib/rugal.rb
+- lib/solution.rb
+homepage: 
+licenses:
+- GPL-2.0
+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.7.7
+signing_key: 
+specification_version: 4
+summary: Genetic algorithms for ruby
+test_files: []