opt_alg_framework 1.0.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTBlMTIwMTFlNmJhY2Q4YmEzYTdiNDdmYjA4NTgxOGM4NzlhNTI3NA==
+  data.tar.gz: !binary |-
+    ZmUwM2I2ZjM1YjBhNzY0YjBlOTNmYWVhM2JlY2Q5YTkyOTcwMGY1NA==
+SHA512:
+  metadata.gz: !binary |-
+    NWUwZjdjYjFkZDgwYTI4ZDM5NTUxNWVkZjZkNzRmMjE2OTc2ZTZhMjg3ZjY5
+    Y2NlNmRiYzdlNWIxYTc1MDBiMWEzODNmNzljYmU2Nzc1NDAwNTkwNWE4YTk1
+    MTE3ODY4YmQwYWJiM2NjMzc0OGJmYThmZTUyMDdmMzNlNmQ0NmI=
+  data.tar.gz: !binary |-
+    MDcwNmEzZDQ2NDFlN2NlMGFkMTAxYTllMDdlYjYzOWRiODU5MjY5MGEyM2Jh
+    NDAzZWZjYTQxZThhN2Y3YWIyNmQwMmNmOThmZWU5ODUzNDEzYWE0ODRmNTM1
+    NDQ0MzhlNGJkMDc4OTE1OTAyZjBlNWRmM2IwYTI1MmY0NjI1NmM=

data/.gitignore

@@ -0,0 +1,62 @@
+<<<<<<< HEAD
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+=======
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+>>>>>>> a7821ff49db723ae966f50a7686a6e443d19b148

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Rodrigo W. Ehresmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# OptAlgFramework
+
+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.
+
+What is already implemented:
+
+  * Problems:
+    * Flow Shop Permutation
+
+  * Algorithms:
+    * Local Searches:
+      * Hill-Climbing
+      * Simulated Annealing
+      * Tabu Search
+
+  * Operators
+    * Crossover:
+      * Two Point Crossover (permutational)
+    * Selector:
+      * Tournament Selection
+    * Tweak:
+      * Random Swap
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'opt_alg_framework'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opt_alg_framework
+
+## 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.
+
+```ruby
+operator = Operator::Tweak::RandomSwap.new
+problem = Problem::FSP.new
+problem.load_schedule(path)
+algorithm = Algorithm::LocalSearch::SimulatedAnnealing.new max_iterations: 10,
+                                                           cooling_rate: 0.009,
+                                                           problem: problem,
+                                                           tweak_operator: operator
+
+puts algorithm.start[: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
+
+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'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "opt_alg_framework"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

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

@@ -0,0 +1,34 @@
+module Algorithm
+  module LocalSearch
+    class HillClimbing
+      # 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
+      def start
+        best = encapsulate_solution(@problem.default_solution)
+        while true do
+          r = encapsulate_solution(@tweak_operator.tweak(best[:solution]))
+          if r[:fitness] < best[:fitness]
+            best = r.dup
+          else
+            break
+          end
+        end
+        best
+      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
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Algorithm
+  module LocalSearch
+    class SimulatedAnnealing
+      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.
+      def initialize(params)
+        @cooling_rate = params[:cooling_rate]
+        @problem = params[:problem]
+        @tweak_operator = params[:tweak_operator]
+        @max_iterations = params[:max_iterations]
+        @temperature = initial_temperature
+      end
+
+      # Main method.
+      def start
+        best = encapsulate_solution(@problem.default_solution.shuffle)
+        current = best.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]
+            iteration += 1
+          end
+          temperature *= 1 - @cooling_rate
+        end
+        best
+      end
+
+      private
+
+      # Calculate the initial temperature, generating N neighbors of an initial solution and
+      # setting as initial temperature the neighbor with the worst fitness.
+      def initial_temperature
+        solution = encapsulate_solution(@problem.default_solution.shuffle)
+        max = solution
+        @max_iterations.times do
+          neighbor = encapsulate_solution(@tweak_operator.tweak(solution[:solution]))
+          max = neighbor if neighbor[:fitness] > max[:fitness]
+        end
+        max[:fitness]
+      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
+      end
+
+      # Calculate the acceptance probability, if and only if the neighbor fitness is worst than
+      # the current fitness.
+      def accept?(fitness, neighbor_fitness, temperature)
+        return true if neighbor_fitness < fitness
+        probability = E ** - ((fitness - neighbor_fitness).abs.fdiv(temperature)) # E is the Euller number
+        r = Random.rand(0.0..1)
+        if r < probability
+          return true
+        else
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Algorithm
+  module LocalSearch
+    class TabuSearch
+
+      # 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)
+        @tabu_list = []
+        @list_max_size = params[:list_max_size]
+        @tweak_number = params[:tweak_number]
+        @iterations = params[:iterations]
+        @tweak_operator = params[:tweak_operator]
+        @problem = params[:problem]
+      end
+
+      # Main method.
+      def start
+        s = encapsulate_solution(@problem.default_solution.dup)
+        best = s.dup
+        @tabu_list << s[:solution]
+        @iterations.times do
+          @tabu_list.shift if @tabu_list.size == @list_max_size
+          r = encapsulate_solution(@tweak_operator.tweak(s[: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])
+          end
+          if !@tabu_list.include?(r[:solution])
+            s = r.dup
+            @tabu_list << r
+          end
+          best = s.dup if s[:fitness] < best[:fitness]
+        end
+        best
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Operator
+  module Crossover
+    module Permutation
+
+      class TwoPointCrossover
+        # Main method.
+        def cross(chromossome1, chromossome2)
+          point1 = Random.rand(0..chromossome1.size - 1)
+          point2 = Random.rand(point1..chromossome1.size - 1)
+          start_piece = Array.new
+          middle_piece = Array.new
+          end_piece = Array.new
+
+          point1.upto(point2) do |i| # Get the middle of the chromossome1, between the two points
+            middle_piece << chromossome1[i]
+          end
+          # After the tasks of the middle are choosed, there is no need of them in the chromossomes anymore
+          chromossome1 -= middle_piece
+          chromossome2 -= middle_piece
+          chromossome2.size.times do |i| # Loop to check the order of the remaining genes in the chromossome2
+            if start_piece.size <= point1 # Check if the chromossomes will be placed before or after the "middle" point
+              start_piece << chromossome1[i]
+            else
+              end_piece << chromossome1[i]
+            end
+          end
+          start_piece + middle_piece + end_piece
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Operator
+  module Selector
+
+    class TournamentSelection
+      # Initialize informing the tournament size.
+      def initialize(size)
+        @size = size
+      end
+
+      # Main method.
+      def select(population)
+        best_individual = population[Random.rand(0...population.size)]
+        0.upto(@size) do
+          individual = population[Random.rand(0...population.size)]
+          best_individual = individual if individual[:fitness] < best_individual[:fitness]
+        end
+        best_individual
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,18 @@
+module Operator
+  module Tweak
+
+    class RandomSwap
+      # Main method.
+      def tweak(solution)
+        copy = solution.dup
+        piece1 = Random.rand(0...copy.size)
+        piece2 = Random.rand(0...copy.size)
+        x = copy[piece1]
+        copy[piece1] = copy[piece2]
+        copy[piece2] = x
+        copy
+      end
+    end
+
+  end
+end

data/lib/opt_alg_framework/problem/README.md

@@ -0,0 +1,20 @@
+# About the instaces of the problems
+
+## 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.
+
+A valid instance example is shown bellow, with 5 tasks (lines) and 3 machines (columns):
+
+> 12 65 23 <br>
+> 45 25 12 <br>
+> 17 32 56 <br>
+> 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*:
+
+```ruby
+fsp.load_schedule(path_to_instance, true)
+```
+
+That will invert the matrix to the right format.

data/lib/opt_alg_framework/problem/fsp.rb

@@ -0,0 +1,88 @@
+module Problem
+
+  # 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
+        require 'matrix'
+
+        attr_reader :schedule
+
+        # Fill the schedule reading the an instance from a file
+        def build_from_file(path, transpose)
+          rows = Array.new
+          File.foreach(path).each do |line|
+            rows << line.split(" ").collect{ |e| e.to_i }
+          end
+          @schedule = transpose ? Matrix.rows(rows).transpose : Matrix.rows(rows)
+        end
+
+        # Given a sequence of tasks, reorder the schedule in this sequence
+        def reorder_schedule(tasks_sequence)
+          rows = Array.new
+          tasks_sequence.each do |task|
+            rows << @schedule.row(task)
+          end
+          Matrix.rows(rows)
+        end
+      end
+
+      attr_reader :default_solution # Is the sequence of tasks ordered from 0...N
+
+      # 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
+
+      # Initialize the FSP problem with a empty schedule
+      def initialize
+        @schedule = Schedule.new()
+      end
+
+      # 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
+      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
+      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)
+  end
+end

data/lib/opt_alg_framework/version.rb

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

data/lib/opt_alg_framework.rb

@@ -0,0 +1,6 @@
+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/opt_alg_framework.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opt_alg_framework/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opt_alg_framework"
+  spec.version       = OptAlgFramework::VERSION
+  spec.authors       = ["rodrigo-ehresmann"]
+  spec.email         = ["igoehresmann@gmail.com"]
+
+  spec.summary       = %q{Gem with a optimization algorithm framework that implements problems, algorithms and operator classes.}
+  spec.homepage      = "https://github.com/rodrigo-ehresmann/opt_alg_framework"
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  end
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: opt_alg_framework
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+platform: ruby
+authors:
+- rodrigo-ehresmann
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !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'
+description: 
+email:
+- igoehresmann@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/opt_alg_framework.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/crossover/permutation/two_point_crossover.rb
+- lib/opt_alg_framework/operator/selector/tournament_selection.rb
+- lib/opt_alg_framework/operator/tweak/random_swap.rb
+- lib/opt_alg_framework/problem/README.md
+- lib/opt_alg_framework/problem/fsp.rb
+- lib/opt_alg_framework/version.rb
+- opt_alg_framework.gemspec
+homepage: https://github.com/rodrigo-ehresmann/opt_alg_framework
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.6.3
+signing_key: 
+specification_version: 4
+summary: Gem with a optimization algorithm framework that implements problems, algorithms
+  and operator classes.
+test_files: []