opt_alg_framework 1.0.3 → 1.0.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NTBlMTIwMTFlNmJhY2Q4YmEzYTdiNDdmYjA4NTgxOGM4NzlhNTI3NA==
-  data.tar.gz: !binary |-
-    ZmUwM2I2ZjM1YjBhNzY0YjBlOTNmYWVhM2JlY2Q5YTkyOTcwMGY1NA==
+SHA1:
+  metadata.gz: e5238e0506bf85414aee3fb138a49038c83ebb2d
+  data.tar.gz: e0f07c319a8d4f8e8bac291f1a9f73862153d370
 SHA512:
-  metadata.gz: !binary |-
-    NWUwZjdjYjFkZDgwYTI4ZDM5NTUxNWVkZjZkNzRmMjE2OTc2ZTZhMjg3ZjY5
-    Y2NlNmRiYzdlNWIxYTc1MDBiMWEzODNmNzljYmU2Nzc1NDAwNTkwNWE4YTk1
-    MTE3ODY4YmQwYWJiM2NjMzc0OGJmYThmZTUyMDdmMzNlNmQ0NmI=
-  data.tar.gz: !binary |-
-    MDcwNmEzZDQ2NDFlN2NlMGFkMTAxYTllMDdlYjYzOWRiODU5MjY5MGEyM2Jh
-    NDAzZWZjYTQxZThhN2Y3YWIyNmQwMmNmOThmZWU5ODUzNDEzYWE0ODRmNTM1
-    NDQ0MzhlNGJkMDc4OTE1OTAyZjBlNWRmM2IwYTI1MmY0NjI1NmM=
+  metadata.gz: 1f4296bb2cc65002a2e1409c674f76e249790c316d61c91ef214e83b18b4658ea82cadb22548f22816c7c779d7ee1fae38e401ec0ea2fe86e598149ade080b9b
+  data.tar.gz: 9551a80e24e9967b52f44490d9d4c8a95236ed955f5acea96d53698d5d03bf94834bbe8dee8d8c5ac91e50185e97ce9e7e4e964ecf449ea58617e3dfec230b9f

data/Gemfile

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'rint'
 # Specify your gem's dependencies in opt_alg_framework.gemspec
 gemspec

data/README.md

@@ -1,6 +1,6 @@
-# OptAlgFramework
+# opt-alg-framework (Optimization Algorithm Framework)
 
-Opt-Alg-Framework is a framework to work and build optimization algorithm. The basic idea is: you will have a codificated problem with a method to calculate its fitnes, an algorithm to improve the this fitness and operators used with the algorithm to build new solutions.
+**opt-alg-framework** is a framework to work with and build optimization algorithm. The basic idea is: you will have a codificated problem with a method to calculate its fitness, an algorithm to improve this fitness and operators used with the algorithm to build new solutions.
 
 What is already implemented:
 
@@ -31,7 +31,7 @@ gem 'opt_alg_framework'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
@@ -39,46 +39,28 @@ Or install it yourself as:
 
 ## Usage
 
-Example: read two instances of FSP problem (about the instances format, read README in *problem* directory!) and get its best results with Simulated Annealing algorithm, using RandomSwap operator.
+Example: Read two instances of FSP problem (about the instances format, read README in *problem* directory!) and get its best results with SimulatedAnnealing algorithm, using RandomSwap operator.
 
 ```ruby
 operator = Operator::Tweak::RandomSwap.new
 problem = Problem::FSP.new
-problem.load_schedule(path)
+problem.load_schedule("path to instance file")
 algorithm = Algorithm::LocalSearch::SimulatedAnnealing.new max_iterations: 10,
                                                            cooling_rate: 0.009,
                                                            problem: problem,
                                                            tweak_operator: operator
 
-puts algorithm.start[:fitness]
+puts algorithm.start # It will return a hash with the best solution found and its fitness
 ```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` or, alternatively, `bundle console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-####Some conventions must be followed:
-
-  * All problem classes need to have its fitness method acessible with the name *fitness*;
-  * All swap operator classes need to have its swap method acessible with the name *tweak*;
-  * All crossover operator classes need to have its crossover method named *cross*;
-  * All selector operator classes need to have its selection method names *select*;
-  * All algorithm classes need to have its main method names *start*;
-  * In the algorithms, a solution is represent with a hash structure, and it's mandatory have at least the pair key-value *:solution* with the representation of the solution and *:fitness* with the fitness of the solution.
-
-####TODO:
-
-   * Treatments to verify if the conventions are being followed;
-   * General implementations, like:
-     * Local search algorithms;
-     * Population based algorithms;
-     * Operators (crossover, swap, selector) to any type of problem (permutational, binary, etc);
-     * Different type of problems.
-
 ## Contributing
 
+**This gem can deal with a lot of stuff, and everything must be simple to use (a.k.a *generic*). Before start to code, take a look in the README inside the folder of what you want to code (algorithms, problems, etc), some tips of what your class should have are there. Sugestions are welcome too! (;** 
+
 1. Fork it ( https://github.com/[my-github-username]/opt_alg_framework/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)

data/lib/opt_alg_framework.rb

@@ -1,6 +1,16 @@
-valid_files = Dir["#{File.dirname(__FILE__)}/**/*.rb"].reject {|f| File.directory?(f) }
-valid_files.each { |f| require f }
+require 'opt_alg_framework/algorithm/algorithm_interface'
+require 'opt_alg_framework/problem/problem_interface'
+require 'opt_alg_framework/operator/tweak/tweak_interface'
+require 'opt_alg_framework/operator/selector/selector_interface'
+require 'opt_alg_framework/operator/crossover/crossover_interface'
+
+Dir[File.dirname(__FILE__) + "/opt_alg_framework/problem/**/*.rb"].each { |f| require f }
+Dir[File.dirname(__FILE__) + "/opt_alg_framework/operator/**/*.rb"].each { |f| require f }
+Dir[File.dirname(__FILE__) + "/opt_alg_framework/algorithm/**/*.rb"].each { |f| require f }
+
+#valid_files = Dir["#{File.dirname(__FILE__)}/**/*.rb"].reject {|f| File.directory?(f) }
+#valid_files.each { |f| require f }
 
 module OptAlgFramework
-  # Write your code here
+
 end

data/lib/opt_alg_framework/algorithm/README.md

@@ -0,0 +1,8 @@
+# Implementation Details
+
+  * Inside your class, use `implements AlgorithmInterface`. That provides an interface behavior, enforcing
+  the implementation of mandatory methods;
+  * Organize algorithm class inside modules (e.g., `HillClimbing` class);
+  * `initialize` have only a hash like argument, where the configurations used in algorithm are specifyied;
+  * A solution is represented like a hash, with at least `:solution` and `:fitness` keys. The best solution should be 
+  returned by the main method.

data/lib/opt_alg_framework/algorithm/algorithm_interface.rb

@@ -0,0 +1,10 @@
+require 'interface'
+
+module AlgorithmInterface
+  include Interface
+
+  def initialize(params = {})
+    must_implement start: 0
+    super(params)
+  end
+end

data/lib/opt_alg_framework/algorithm/local_search/hill_climbing.rb

@@ -1,34 +1,36 @@
 module Algorithm
   module LocalSearch
     class HillClimbing
+      implements AlgorithmInterface
+
       # Initialize passing a instantiated class of a problem and tweak operator
       def initialize(params)
         @tweak_operator = params[:tweak_operator]
         @problem = params[:problem]
       end
 
-      # Main method
+      # solution_b = best solution
+      # solution_n = neighbor solution
       def start
-        best = encapsulate_solution(@problem.default_solution)
+        solution_b = encapsulate_solution(@problem.default_solution.shuffle)
         while true do
-          r = encapsulate_solution(@tweak_operator.tweak(best[:solution]))
-          if r[:fitness] < best[:fitness]
-            best = r.dup
+          solution_n = encapsulate_solution(@tweak_operator.tweak(solution_b[:solution]))
+          if solution_n[:fitness] < solution_b[:fitness]
+            solution_b = solution_n.dup
           else
             break
           end
         end
-        best
+        solution_b
       end
 
       # Solution is a hash, with the keys :solution and :fitness
       def encapsulate_solution(solution)
         hash = Hash.new
         hash[:solution] = solution
-        hash[:fitness] = @problem.fitness(tasks_sequence: solution)
+        hash[:fitness] = @problem.fitness(solution)
         hash
       end
-
     end
   end
 end

data/lib/opt_alg_framework/algorithm/local_search/simulated_annealing.rb

@@ -1,8 +1,8 @@
 module Algorithm
   module LocalSearch
     class SimulatedAnnealing
+      include AlgorithmInterface
       include Math
-      attr_reader :temperature
 
       # Initialize specifying the cooling rate percentage (@cooling_rate), number of iterations in each
       # temperature (@max_iterations) and passing an instantiated problem and tweak operator class.
@@ -14,22 +14,24 @@ module Algorithm
         @temperature = initial_temperature
       end
 
-      # Main method.
+      # solution_b = best solution
+      # solution_n = neighbor solution
+      # solution_c = current solution
       def start
-        best = encapsulate_solution(@problem.default_solution.shuffle)
-        current = best.dup
+        solution_b = encapsulate_solution(@problem.default_solution.shuffle)
+        solution_c = solution_b.dup
         temperature = @temperature
         while temperature > 1 do
           iteration = 1
           while iteration < @max_iterations do
-            neighbor = encapsulate_solution(@tweak_operator.tweak(current[:solution]))
-            current = neighbor.dup if accept?(current[:fitness], neighbor[:fitness], temperature)
-            best = current.dup if current[:fitness] < best[:fitness]
+            solution_n = encapsulate_solution(@tweak_operator.tweak(solution_c[:solution]))
+            solution_c = solution_n.dup if accept?(solution_c[:fitness], solution_n[:fitness], temperature)
+            solution_b = solution_c.dup if solution_c[:fitness] < solution_b[:fitness]
             iteration += 1
           end
           temperature *= 1 - @cooling_rate
         end
-        best
+        solution_b
       end
 
       private
@@ -50,7 +52,7 @@ module Algorithm
       def encapsulate_solution(solution)
         hash = Hash.new
         hash[:solution] = solution
-        hash[:fitness] = @problem.fitness(tasks_sequence: solution)
+        hash[:fitness] = @problem.fitness(solution)
         hash
       end
 

data/lib/opt_alg_framework/algorithm/local_search/tabu_search.rb

@@ -1,8 +1,9 @@
 module Algorithm
   module LocalSearch
     class TabuSearch
+      implements AlgorithmInterface
 
-      # Initialize specifying as parameters the tabu list size (@list_max_size), number of tweaks in each 
+      # Initialize specifying as parameters the tabu list size (@list_max_size), number of tweaks in each
       # current solution (@tweak_number), number of iteratiions to perform in the algorithm (@iterations)
       # and an instantiated problem and tweak operator class.
       def initialize(params)
@@ -16,30 +17,32 @@ module Algorithm
 
       # Main method.
       def start
-        s = encapsulate_solution(@problem.default_solution.dup)
-        best = s.dup
-        @tabu_list << s[:solution]
+        solution_c = encapsulate_solution(@problem.default_solution.dup)
+        solution_s = solution_c.dup
+        @tabu_list << solution_c[:solution]
         @iterations.times do
           @tabu_list.shift if @tabu_list.size == @list_max_size
-          r = encapsulate_solution(@tweak_operator.tweak(s[:solution]))
+          solution_bn = solution_n1 = encapsulate_solution(@tweak_operator.tweak(solution_c[:solution]))
           (@tweak_number - 1).times do
-            w = encapsulate_solution(@tweak_operator.tweak(s[:solution]))
-            r = w.dup if !@tabu_list.include?(w) && w[:fitness] < r[:fitness] || @tabu_list.include?(r[:solution])
+            solution_n2 = encapsulate_solution(@tweak_operator.tweak(solution_c[:solution]))
+            solution_bn = solution_n2.dup if !@tabu_list.include?(solution_n2) &&
+                          solution_n2[:fitness] < solution_n1[:fitness] ||
+                          @tabu_list.include?(solution_n1[:solution])
           end
-          if !@tabu_list.include?(r[:solution])
-            s = r.dup
-            @tabu_list << r
+          if !@tabu_list.include?(solution_bn[:solution])
+            solution_c = solution_bn.dup
+            @tabu_list << solution_n1
           end
-          best = s.dup if s[:fitness] < best[:fitness]
+          solution_s = solution_c.dup if solution_c[:fitness] < solution_s[:fitness]
         end
-        best
+        solution_s
       end
 
       # A solution is a hash, with the keys :solution and :fitness.
       def encapsulate_solution(solution)
         hash = Hash.new
         hash[:solution] = solution
-        hash[:fitness] = @problem.fitness(tasks_sequence: solution)
+        hash[:fitness] = @problem.fitness(solution)
         hash
       end
     end

data/lib/opt_alg_framework/operator/README.md

@@ -0,0 +1,8 @@
+# Implementation Details
+
+  * Inside your class, use `implements [interface class name]`. That provides an interface behavior, enforcing
+  the implementation of mandatory methods. Different operators, different interfaces, take a look inside the folder of your
+  type of operator and see what is being used (you can identify it looking for a file who name ends with `interface`);
+  * Organize algorithm class inside modules (e.g., `RandomSwap` class);
+  * `initialize` have no arguments.
+  

data/lib/opt_alg_framework/operator/crossover/crossover_interface.rb

@@ -0,0 +1,10 @@
+require 'interface'
+
+module CrossoverInterface
+  include Interface
+
+  def initialize
+    must_implement cross:2
+    super
+  end
+end

data/lib/opt_alg_framework/operator/crossover/permutation/two_point_crossover.rb

@@ -1,8 +1,9 @@
 module Operator
   module Crossover
     module Permutation
-
       class TwoPointCrossover
+        implements CrossoverInterface
+
         # Main method.
         def cross(chromossome1, chromossome2)
           point1 = Random.rand(0..chromossome1.size - 1)
@@ -27,7 +28,7 @@ module Operator
           start_piece + middle_piece + end_piece
         end
       end
-      
+
     end
   end
 end

data/lib/opt_alg_framework/operator/selector/selector_interface.rb

@@ -0,0 +1,10 @@
+require 'interface'
+
+module SelectorInterface
+  include Interface
+
+  def initialize(param)
+    must_implement select:1
+    super(param)
+  end
+end

data/lib/opt_alg_framework/operator/selector/tournament_selection.rb

@@ -1,7 +1,8 @@
 module Operator
   module Selector
-
     class TournamentSelection
+      implements SelectorInterface
+
       # Initialize informing the tournament size.
       def initialize(size)
         @size = size
@@ -17,6 +18,5 @@ module Operator
         best_individual
       end
     end
-
   end
 end

data/lib/opt_alg_framework/operator/tweak/random_swap.rb

@@ -1,8 +1,8 @@
 module Operator
   module Tweak
-
     class RandomSwap
-      # Main method.
+      implements TweakInterface
+
       def tweak(solution)
         copy = solution.dup
         piece1 = Random.rand(0...copy.size)
@@ -13,6 +13,5 @@ module Operator
         copy
       end
     end
-
   end
 end

data/lib/opt_alg_framework/operator/tweak/tweak_interface.rb

@@ -0,0 +1,10 @@
+require 'interface'
+
+module TweakInterface
+  include Interface
+
+  def initialize
+    must_implement tweak:1
+    super
+  end
+end

data/lib/opt_alg_framework/problem/README.md

@@ -1,7 +1,15 @@
-# About the instaces of the problems
+# Implementation Details
+
+  * Inside your class, use `implements ProblemInterface`. That provides an interface behavior, enforcing
+  the implementation of mandatory methods;
+  * Organize algorithm class inside modules (e.g., `FSP` class);
+  * `initialize` have no arguments;
+  * Make sure that you have `attr_reader :default_solution` in your class and fill this instance variable with an initial solution. This variable will be called inside algorithm classes.  
+
+# About the problem instances
 
 ## FSP (Flow Shop Permutation)
-The instance of this kind of problem is a matrix, specifically a matrix where the rows are tasks and columns are machines. The fitness method need that to work properly.
+The instance of this kind of problem is a matrix, specifically a matrix where the rows are tasks and columns are machines. This order need to be preserved to the fitness method work properly.
 
 A valid instance example is shown bellow, with 5 tasks (lines) and 3 machines (columns):
 
@@ -11,10 +19,8 @@ A valid instance example is shown bellow, with 5 tasks (lines) and 3 machines (c
 > 33 21 22 <br>
 > 10 9 11 <br>
 
-However, if your instance file is an inverted matrix (rows are machines and columns are tasks), just set the *transpose* parameter of *load_schedule* method to *true*:
+However, if your instance file is an inverted matrix (rows are machines and columns are tasks), just pass *true* in a block to transpose the matrix.
 
 ```ruby
-fsp.load_schedule(path_to_instance, true)
+fsp.load_schedule(path_to_instance) { true }
 ```
-
-That will invert the matrix to the right format.

data/lib/opt_alg_framework/problem/fsp.rb

@@ -1,10 +1,13 @@
 module Problem
-
+  #require 'opt_alg_framework/problem/problem_interface'
   # FSP class have a inner class Schedule
   class FSP
-      # Inner class who represents the production schedule, that is, a matrix were the rows are the tasks
-      # and the columns the machines.
-      class Schedule
+    implements ProblemInterface
+    attr_reader :default_solution
+
+      # Inner class who represents the production schedule, that is, a matrix
+      # were the rows are the tasks and the columns the machines.
+      class Production
         require 'matrix'
 
         attr_reader :schedule
@@ -28,61 +31,62 @@ module Problem
         end
       end
 
-      attr_reader :default_solution # Is the sequence of tasks ordered from 0...N
+    # Initialize the FSP problem with a empty schedule
+    def initialize
+      @production = Production.new
+    end
 
-      # Used in makespan function to compare two execution times (also if one of them or the two are blank)
-      @@bigger = Proc.new do |a, b|
-        a ||= b ||= 0
-        if a > b ||= 0 then a else b end
-      end
+    # Load the production schedule from a file
+    def load_instance(path)
+      transpose = block_given? ? yield : false
+      @production.build_from_file(path, transpose)
+      @default_solution = (0...@production.schedule.row_size).to_a
+    end
 
-      # Initialize the FSP problem with a empty schedule
-      def initialize
-        @schedule = Schedule.new()
-      end
+    def fitness(solution)
+      schedule = @production.reorder_schedule(solution)
+      makespan(schedule: schedule, task: schedule.row_size - 1,
+                machine: schedule.column_size - 1, memory: {})
+    end
+
+    private
+
+    def bigger(num1 = 0, num2 = 0)
+      num1 ||= num2 ||= 0
+      if num1 > num2 ||= 0 then num1 else num2 end
+    end
+
+    # The hash options are:
+    # - schedule: matrix of the production schedule;
+    # - task: task index;
+    # - machine: machine index;
+    # - memory: store the total time spent at the point where the task index X is processed at the machine index Y
+    #   (that avoid desnecessary recursive calls).
+    def makespan(options = {})
+      schedule = options[:schedule]
+      task = options[:task]
+      machine = options[:machine]
+      memory = options[:memory]
+      key = "#{task},#{machine}"
+      time = schedule[task, machine]
 
-      # Load the production schedule from a file
-      def load_schedule(path, transpose = false)
-        @schedule.build_from_file(path, transpose)
-        @default_solution = (0...@schedule.schedule.row_size).to_a
+      return time if task == 0 && machine == 0
+
+      if task > 0 # Before everithing, calculate the time spent in the tasks from N to 0
+        time_task_before = memory["#{task - 1},#{machine}"]
+        time_task_before = makespan(schedule: schedule, task: task - 1,
+                           machine: machine, memory: memory) if memory["#{task - 1},#{machine}"].nil?
       end
 
-      # Fitness function. The hash options are:
-      # - schedule: matrix of the production schedule;
-      # - task: task index;
-      # - machine: machine index;
-      # - memory: store the total time spent at the point where the task index X is processed at the machine index Y
-      #   (that avoid desnecessary recursive calls);
-      # - tasks_sequence: sequence of tasks used to reorganize the schedule after calculate its makespan.
-      # The default use of the method is: inform the tasks sequence as parameter and the method do all the work,
-      # returning the makespan as result.
-      def makespan(options = {}, block = @@bigger)
-        if options[:tasks_sequence]
-          schedule = @schedule.reorder_schedule(options[:tasks_sequence])
-          makespan({schedule: schedule, task: schedule.row_size - 1, machine: schedule.column_size - 1, memory: {}}, block)
-        else
-          schedule = options[:schedule]
-          task = options[:task]
-          machine = options[:machine]
-          memory = options[:memory]
-          key = "#{task},#{machine}"
-          time = schedule[task, machine]
-          if task == 0 && machine == 0
-            return time
-          end
-          if task > 0 # Before everithing, calculate the time spent in the tasks from N to 0
-            time_task_before = memory["#{task - 1},#{machine}"]
-            time_task_before = makespan({schedule: schedule, task: task - 1, machine: machine, memory: memory}, block) if memory["#{task - 1},#{machine}"].nil?
-          end
-          if machine > 0 # Calculate the time spent  at the machines from N to 0
-            time_machine_before = memory["#{task},#{machine - 1}"]
-            time_machine_before = makespan({schedule: schedule, task: task, machine: machine - 1, memory: memory}, block) if memory["#{task},#{machine - 1}"].nil?
-          end
-          total_time = block.call(time_task_before, time_machine_before) + time # Calculate the total time
-          memory[key] = total_time # Store the total time
-          total_time
-        end
+      if machine > 0 # Calculate the time spent of the same task at the machines from N to 0
+        time_machine_before = memory["#{task},#{machine - 1}"]
+        time_machine_before = makespan(schedule: schedule, task: task,
+                              machine: machine - 1, memory: memory) if memory["#{task},#{machine - 1}"].nil?
       end
-      alias :fitness :makespan # Needed because, in the algorithm classes, to be generic we call  the 'fitness' function (all problem classes need to have a 'fitness' function)
+
+      total_time = bigger(time_task_before, time_machine_before) + time # Calculate the total time
+      memory[key] = total_time # Store the total time
+      total_time
+    end
   end
 end

data/lib/opt_alg_framework/problem/problem_interface.rb

@@ -0,0 +1,10 @@
+require 'interface'
+
+module ProblemInterface
+  include Interface
+
+  def initialize
+    must_implement load_instance: 1, fitness: 1
+    super
+  end
+end

data/lib/opt_alg_framework/version.rb

@@ -1,3 +1,3 @@
 module OptAlgFramework
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/opt_alg_framework.gemspec

@@ -6,10 +6,10 @@ require 'opt_alg_framework/version'
 Gem::Specification.new do |spec|
   spec.name          = "opt_alg_framework"
   spec.version       = OptAlgFramework::VERSION
-  spec.authors       = ["rodrigo-ehresmann"]
+  spec.authors       = ["rwehresmann"]
   spec.email         = ["igoehresmann@gmail.com"]
 
-  spec.summary       = %q{Gem with a optimization algorithm framework that implements problems, algorithms and operator classes.}
+  spec.summary       = %q{Gem with an optimization algorithm framework who implements problems, algorithms and operators classes.}
   spec.homepage      = "https://github.com/rodrigo-ehresmann/opt_alg_framework"
   spec.license       = 'MIT'
 
@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
     spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   end
 
-  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: opt_alg_framework
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
-- rodrigo-ehresmann
+- rwehresmann
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-16 00:00:00.000000000 Z
+date: 2016-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: 
 email:
 - igoehresmann@gmail.com
@@ -45,9 +59,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -55,14 +69,21 @@ files:
 - bin/console
 - bin/setup
 - lib/opt_alg_framework.rb
+- lib/opt_alg_framework/algorithm/README.md
+- lib/opt_alg_framework/algorithm/algorithm_interface.rb
 - lib/opt_alg_framework/algorithm/local_search/hill_climbing.rb
 - lib/opt_alg_framework/algorithm/local_search/simulated_annealing.rb
 - lib/opt_alg_framework/algorithm/local_search/tabu_search.rb
+- lib/opt_alg_framework/operator/README.md
+- lib/opt_alg_framework/operator/crossover/crossover_interface.rb
 - lib/opt_alg_framework/operator/crossover/permutation/two_point_crossover.rb
+- lib/opt_alg_framework/operator/selector/selector_interface.rb
 - lib/opt_alg_framework/operator/selector/tournament_selection.rb
 - lib/opt_alg_framework/operator/tweak/random_swap.rb
+- lib/opt_alg_framework/operator/tweak/tweak_interface.rb
 - lib/opt_alg_framework/problem/README.md
 - lib/opt_alg_framework/problem/fsp.rb
+- lib/opt_alg_framework/problem/problem_interface.rb
 - lib/opt_alg_framework/version.rb
 - opt_alg_framework.gemspec
 homepage: https://github.com/rodrigo-ehresmann/opt_alg_framework
@@ -76,19 +97,19 @@ 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.6.3
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Gem with a optimization algorithm framework that implements problems, algorithms
-  and operator classes.
+summary: Gem with an optimization algorithm framework who implements problems, algorithms
+  and operators classes.
 test_files: []