ai4r 1.12 → 2.0

data/examples/classifiers/zero_and_one_r_example.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/ai4r/classifiers/zero_r'
+require_relative '../../lib/ai4r/classifiers/one_r'
+require_relative '../../lib/ai4r/data/data_set'
+
+# Load tutorial data
+data_file = "#{File.dirname(__FILE__)}/zero_one_r_data.csv"
+data = Ai4r::Data::DataSet.new.load_csv_with_labels data_file
+
+puts "Data labels: #{data.data_labels.inspect}"
+puts
+
+# Build a default ZeroR classifier
+zero_default = Ai4r::Classifiers::ZeroR.new.build(data)
+puts "ZeroR default prediction: #{zero_default.eval(data.data_items.first)}"
+puts "Generated rule: #{zero_default.get_rules}"
+
+# Build ZeroR with custom tie strategy
+zero_random = Ai4r::Classifiers::ZeroR.new.set_parameters(tie_break: :random).build(data)
+puts "ZeroR random tie strategy prediction: #{zero_random.eval(data.data_items.first)}"
+
+puts
+
+# Build a default OneR classifier
+one_default = Ai4r::Classifiers::OneR.new.build(data)
+puts "OneR chose attribute index #{one_default.rule[:attr_index]}"
+puts "OneR rules:\n#{one_default.get_rules}"
+
+# Build OneR selecting the first attribute and using :last tie break
+one_custom = Ai4r::Classifiers::OneR.new.set_parameters(selected_attribute: 0,
+                                                        tie_break: :last).build(data)
+puts "OneR forced attribute: #{one_custom.rule[:attr_index]}"
+puts "Custom rules:\n#{one_custom.get_rules}"

data/examples/classifiers/zero_one_r_data.csv

@@ -0,0 +1,8 @@
+city,age_range,gender,marketing_target
+New York,[30-50),F,N
+New York,<30,M,Y
+Chicago,<30,M,Y
+New York,<30,M,Y
+Chicago,[30-50),F,Y
+New York,[30-50),F,N
+Chicago,[50-80],M,N

data/examples/clusterers/clusterer_example.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Author::    Sergio Fierens (implementation)
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://www.ai4r.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+# In this example we group results from a post-training survey into 4 groups.
+# The Diana algorithm is used, but you can try other algorithms by changing
+# the word "Diana" by "KMeans", "AverageLinkage", or any other cluster implementation.
+# The cluster API is the same, so you can play around and observe different results.
+
+require 'ai4r'
+
+# 5 Questions on a post training survey
+questions = ['The material covered was appropriate for someone with my level of ' \
+             'knowledge of the subject.',
+             'The material was presented in a clear and logical fashion',
+             'There was sufficient time in the session to cover the material that was presented',
+             'The instructor was respectful of students',
+             'The instructor provided good examples']
+
+# Answers to each question go from 1 (bad) to 5 (excellent)
+# The answers array has an element per survey complemented.
+# Each survey completed is in turn an array with the answer of each question.
+answers = [[1, 2, 3, 2, 2],	# Answers of person 1
+           [5, 5, 3, 2, 2],	# Answers of person 2
+           [1, 2, 3, 2, 2],	# Answers of person 3
+           [1, 2, 2, 2, 2],	# ...
+           [1, 2, 5, 5, 2],
+           [3, 3, 3, 3, 3],
+           [1, 2, 3, 2, 2],
+           [3, 2, 3, 5, 5],
+           [3, 3, 3, 5, 2],
+           [4, 4, 3, 1, 1],
+           [5, 5, 5, 5, 5],
+           [4, 2, 4, 2, 1],
+           [4, 4, 5, 5, 5],
+           [4, 4, 3, 2, 2],
+           [2, 2, 3, 2, 3],
+           [3, 3, 3, 1, 1]]	# Answers of person 16
+
+data_set = Ai4r::Data::DataSet.new(data_items: answers, data_labels: questions)
+
+# Let's group answers in 4 groups
+clusterer = Ai4r::Clusterers::Diana.new.build(data_set, 4)
+
+clusterer.clusters.each_with_index do |cluster, index|
+  puts "Group #{index + 1}"
+  p cluster.data_items
+end
+
+# Check if this algorithm supports evaluating new data items
+if clusterer.supports_eval?
+  puts "First survey belongs to group #{clusterer.eval(answers.first)}"
+else
+  puts 'This algorithm does not support eval on unseen data.'
+end

data/examples/clusterers/dbscan_example.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Example showcasing DBSCAN clustering with custom parameters.
+require 'ai4r'
+
+points = [
+  [1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3],
+  [8, 8], [8, 9], [8, 10], [9, 8], [9, 9], [9, 10],
+  [5, 5], [1, 9], [10, 0]
+]
+set = Ai4r::Data::DataSet.new(data_items: points)
+
+clusterer = Ai4r::Clusterers::DBSCAN.new
+clusterer.set_parameters(epsilon: 10, min_points: 2).build(set)
+
+pp clusterer.labels
+pp clusterer.clusters.map(&:data_items)

data/examples/clusterers/dendrogram_example.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'ai4r'
+require 'dendrograms'
+
+points = [[0, 0], [0, 1], [1, 0], [1, 1]]
+data = Ai4r::Data::DataSet.new(data_items: points)
+
+clusterer = Ai4r::Clusterers::WardLinkage.new.build(data, 1)
+
+# Convert stored tree to a simple array of point sets
+steps = clusterer.cluster_tree.map do |clusters|
+  clusters.map(&:data_items)
+end
+
+Dendrograms::Dendrogram.new(steps).draw('dendrogram.png')
+puts 'Dendrogram saved to dendrogram.png'

data/examples/clusterers/hierarchical_dendrogram_example.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Demonstrates recording the merge tree using WardLinkageHierarchical
+# and printing a simple dendrogram.
+
+require 'ai4r'
+
+points = [[1, 1], [1, 2], [2, 1], [2, 2], [8, 8], [8, 9], [9, 8], [9, 9]]
+data_set = Ai4r::Data::DataSet.new(data_items: points)
+
+clusterer = Ai4r::Clusterers::WardLinkageHierarchical.new
+clusterer.build(data_set, 1)
+
+puts 'Dendrogram:'
+clusterer.cluster_tree.each_with_index do |clusters, level|
+  puts "Level #{level}:"
+  clusters.each_with_index do |cluster, idx|
+    puts "  Cluster #{idx}: #{cluster.data_items.inspect}"
+  end
+end

data/examples/clusterers/kmeans_custom_example.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This example shows KMeans with a custom distance function and deterministic initialization.
+# It also prints the number of iterations and the sum of squared errors (SSE).
+
+require 'ai4r'
+
+# Simple two-cluster data set
+points = [[1, 1], [1, 2], [2, 1], [2, 2], [8, 8], [8, 9], [9, 8], [9, 9]]
+data_set = Ai4r::Data::DataSet.new(data_items: points)
+
+# Manhattan distance instead of the default squared Euclidean distance
+manhattan = lambda do |a, b|
+  a.zip(b).map { |x, y| (x - y).abs }.reduce(:+)
+end
+
+kmeans = Ai4r::Clusterers::KMeans.new
+kmeans.set_parameters(distance_function: manhattan, random_seed: 1)
+      .build(data_set, 2)
+
+kmeans.clusters.each_with_index do |cluster, idx|
+  puts "Cluster #{idx}: #{cluster.data_items.inspect}"
+end
+
+puts "Iterations: #{kmeans.iterations}"
+puts "SSE: #{kmeans.sse}"

data/examples/genetic_algorithm/bitstring_example.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Example using a custom chromosome to maximise ones in a bit string
+require_relative '../../lib/ai4r/genetic_algorithm/genetic_algorithm'
+
+# Represents a chromosome consisting of a bit string.
+class BitStringChromosome < Ai4r::GeneticAlgorithm::ChromosomeBase
+  LENGTH = 16
+
+  def fitness
+    @data.count(1)
+  end
+
+  def self.seed
+    new(Array.new(LENGTH) { rand(2) })
+  end
+
+  def self.reproduce(parent_a, parent_b, crossover_rate = 0.4)
+    point = rand(LENGTH)
+    data = parent_a.data[0...point] + parent_b.data[point..]
+    data = parent_b.data[0...point] + parent_a.data[point..] if rand < crossover_rate
+    new(data)
+  end
+
+  def self.mutate(chromosome, mutation_rate = 0.3)
+    chromosome.data.map!.with_index do |bit, _|
+      if rand < ((1 - chromosome.normalized_fitness.to_f) * mutation_rate)
+        1 - bit
+      else
+        bit
+      end
+    end
+    chromosome.instance_variable_set(:@fitness, nil)
+  end
+end
+
+search = Ai4r::GeneticAlgorithm::GeneticSearch.new(
+  30, 50, BitStringChromosome, 0.2, 0.7, BitStringChromosome::LENGTH
+)
+best = search.run
+puts "Best fitness #{best.fitness}: #{best.data.join}"

data/examples/genetic_algorithm/genetic_algorithm_example.rb

@@ -1,37 +1,45 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # License::   MPL 1.1
 # Project::   ai4r
 # Url::       http://www.ai4r.org/
 #
-# You can redistribute it and/or modify it under the terms of 
-# the Mozilla Public License version 1.1  as published by the 
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
 # Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
 
-require File.dirname(__FILE__) + '/../../lib/ai4r/genetic_algorithm/genetic_algorithm'
-require File.dirname(__FILE__) + '/../../lib/ai4r/data/data_set'
+require_relative '../../lib/ai4r/genetic_algorithm/genetic_algorithm'
+require_relative '../../lib/ai4r/data/data_set'
 require 'csv'
 
 # Load data from data_set.csv
 data_filename = "#{File.dirname(__FILE__)}/travel_cost.csv"
 data_set = Ai4r::Data::DataSet.new.load_csv_with_labels data_filename
-data_set.data_items.collect! {|column| column.collect {|element| element.to_f}}
+data_set.data_items.collect! { |column| column.collect(&:to_f) }
 
-Ai4r::GeneticAlgorithm::Chromosome.set_cost_matrix(data_set.data_items)
+Ai4r::GeneticAlgorithm::TspChromosome.set_cost_matrix(data_set.data_items)
 
-puts "Some random selected tours costs: "
+puts 'Some random selected tours costs: '
 3.times do
-  c = Ai4r::GeneticAlgorithm::Chromosome.seed
-  puts "COST #{-1 * c.fitness} TOUR: "+
-   "#{c.data.collect{|c| data_set.data_labels[c]} * ', '}"
+  c = Ai4r::GeneticAlgorithm::TspChromosome.seed
+  puts "COST #{-1 * c.fitness} TOUR: " \
+       "#{c.data.collect { |c| data_set.data_labels[c] } * ', '}"
 end
 
-puts "Beginning genetic search, please wait... "
-search = Ai4r::GeneticAlgorithm::GeneticSearch.new(800, 100)
+puts 'Beginning genetic search, please wait... '
+search = Ai4r::GeneticAlgorithm::GeneticSearch.new(
+  800, 100, Ai4r::GeneticAlgorithm::TspChromosome,
+  0.3, 0.4, nil, nil,
+  ->(generation, best) { puts "Generation #{generation}: best fitness #{best}" }
+)
 result = search.run
-puts "COST #{-1 * result.fitness} TOUR: "+
-  "#{result.data.collect{|c| data_set.data_labels[c]} * ', '}"
+puts "COST #{-1 * result.fitness} TOUR: " \
+     "#{result.data.collect { |c| data_set.data_labels[c] } * ', '}"
 
-# $7611.99 TOUR: Moscow, Kiev, Warsaw, Hamburg, Berlin, Vienna, Munich, Milan, Rome, Barcelona, Madrid, Paris, Brussels, London, Dublin
-# $7659.81 TOUR: Moscow, Kiev, Warsaw, Vienna, Munich, Berlin, Hamburg, Brussels, Dublin, London, Paris, Milan, Rome, Barcelona, Madrid
-# $7596.74 TOUR: Moscow, Kiev, Warsaw, Berlin, Hamburg, Vienna, Munich, Milan, Rome, Barcelona, Madrid, Paris, Brussels, London Dublin
- 
+# $7611.99 TOUR: Moscow, Kiev, Warsaw, Hamburg, Berlin, Vienna, Munich, Milan,
+#               Rome, Barcelona, Madrid, Paris, Brussels, London, Dublin
+# $7659.81 TOUR: Moscow, Kiev, Warsaw, Vienna, Munich, Berlin, Hamburg, Brussels,
+#               Dublin, London, Paris, Milan, Rome, Barcelona, Madrid
+# $7596.74 TOUR: Moscow, Kiev, Warsaw, Berlin, Hamburg, Vienna, Munich, Milan,
+#               Rome, Barcelona, Madrid, Paris, Brussels, London Dublin

data/examples/genetic_algorithm/kmeans_seed_tuning.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../../lib/ai4r/genetic_algorithm/genetic_algorithm'
+require_relative '../../lib/ai4r/clusterers/k_means'
+require_relative '../som/som_data'
+
+##
+# Running the genetic search without a fixed random seed leads to
+# different SSE results each time, which causes flaky tests in CI.
+# Explicitly seed Ruby's random number generator so that the script
+# behaves deterministically across runs.
+srand 1
+
+# Chromosome used to search for a good random seed for KMeans.
+class SeedChromosome < Ai4r::GeneticAlgorithm::ChromosomeBase
+  RANGE = (0..10)
+  DATA = Ai4r::Data::DataSet.new(data_items: SOM_DATA.first(30))
+
+  def fitness
+    return @fitness if @fitness
+
+    kmeans = Ai4r::Clusterers::KMeans.new.set_parameters(random_seed: @data).build(DATA, 3)
+    @fitness = -kmeans.sse
+  end
+
+  def self.seed
+    new(RANGE.to_a.sample)
+  end
+
+  def self.reproduce(parent_a, parent_b, _rate = 0.7)
+    new([parent_a.data, parent_b.data].sample)
+  end
+
+  def self.mutate(chrom, rate = 0.3)
+    return unless rand < rate
+
+    chrom.data = RANGE.to_a.sample
+    chrom.instance_variable_set(:@fitness, nil)
+  end
+end
+
+search = Ai4r::GeneticAlgorithm::GeneticSearch.new(6, 5, SeedChromosome, 0.1, 0.7)
+best = search.run
+puts(-best.fitness)

data/examples/neural_network/backpropagation_example.rb

@@ -1,67 +1,68 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # License::   MPL 1.1
 # Project::   ai4r
 # Url::       http://www.ai4r.org/
 #
-# You can redistribute it and/or modify it under the terms of 
-# the Mozilla Public License version 1.1  as published by the 
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
 # Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
 
-require File.dirname(__FILE__) + '/training_patterns'
-require File.dirname(__FILE__) + '/patterns_with_noise'
-require File.dirname(__FILE__) + '/patterns_with_base_noise'
-require File.dirname(__FILE__) + '/../../lib/ai4r/neural_network/backpropagation'
+require_relative 'training_patterns'
+require_relative 'patterns_with_noise'
+require_relative 'patterns_with_base_noise'
+require_relative '../../lib/ai4r/neural_network/backpropagation'
 require 'benchmark'
 
 times = Benchmark.measure do
-  
-    srand 1
-  
-    net = Ai4r::NeuralNetwork::Backpropagation.new([256, 3])
-  
-    tr_input = TRIANGLE.flatten.collect { |input| input.to_f / 5.0}
-    sq_input = SQUARE.flatten.collect { |input| input.to_f / 5.0}
-    cr_input = CROSS.flatten.collect { |input| input.to_f / 5.0}
+  srand 1
 
-    tr_with_noise = TRIANGLE_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0}
-    sq_with_noise = SQUARE_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0}
-    cr_with_noise = CROSS_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0}
+  # creating network with 256 input-neurons, 3-neurons and 0 hidden layers
+  net = Ai4r::NeuralNetwork::Backpropagation.new([256, 3])
 
-    tr_with_base_noise = TRIANGLE_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0}
-    sq_with_base_noise = SQUARE_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0}
-    cr_with_base_noise = CROSS_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0}
+  tr_input = TRIANGLE.flatten.collect { |input| input.to_f / 5.0 }
+  sq_input = SQUARE.flatten.collect { |input| input.to_f / 5.0 }
+  cr_input = CROSS.flatten.collect { |input| input.to_f / 5.0 }
 
-    puts "Training the network, please wait."
-    101.times do |i|
-      error = net.train(tr_input, [1,0,0])
-      error = net.train(sq_input, [0,1,0])
-      error = net.train(cr_input, [0,0,1])
-      puts "Error after iteration #{i}:\t#{error}" if i%20 == 0
-    end
+  tr_with_noise = TRIANGLE_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0 }
+  sq_with_noise = SQUARE_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0 }
+  cr_with_noise = CROSS_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0 }
+
+  tr_with_base_noise = TRIANGLE_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0 }
+  sq_with_base_noise = SQUARE_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0 }
+  cr_with_base_noise = CROSS_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0 }
+
+  puts 'Training the network, please wait.'
+  101.times do |i|
+    net.train(tr_input, [1, 0, 0])
+    net.train(sq_input, [0, 1, 0])
+    error = net.train(cr_input, [0, 0, 1])
+    puts "Error after iteration #{i}:\t#{error}" if (i % 20).zero?
+  end
 
-    def result_label(result)
-      if result[0] > result[1] && result[0] > result[2]
-        "TRIANGLE"
-      elsif result[1] > result[2] 
-        "SQUARE"
-      else    
-        "CROSS"
-      end
+  def result_label(result)
+    if result[0] > result[1] && result[0] > result[2]
+      'TRIANGLE'
+    elsif result[1] > result[2]
+      'SQUARE'
+    else
+      'CROSS'
     end
+  end
 
-    puts "Training Examples"
-    puts "#{net.eval(tr_input).inspect} => #{result_label(net.eval(tr_input))}"
-    puts "#{net.eval(sq_input).inspect} => #{result_label(net.eval(sq_input))}"
-    puts "#{net.eval(cr_input).inspect} => #{result_label(net.eval(cr_input))}"
-    puts "Examples with noise"
-    puts "#{net.eval(tr_with_noise).inspect} => #{result_label(net.eval(tr_with_noise))}"
-    puts "#{net.eval(sq_with_noise).inspect} => #{result_label(net.eval(sq_with_noise))}"
-    puts "#{net.eval(cr_with_noise).inspect} => #{result_label(net.eval(cr_with_noise))}"
-    puts "Examples with base noise"
-    puts "#{net.eval(tr_with_base_noise).inspect} => #{result_label(net.eval(tr_with_base_noise))}"
-    puts "#{net.eval(sq_with_base_noise).inspect} => #{result_label(net.eval(sq_with_base_noise))}"
-    puts "#{net.eval(cr_with_base_noise).inspect} => #{result_label(net.eval(cr_with_base_noise))}"
-  
+  puts 'Training Examples'
+  puts "#{net.eval(tr_input).inspect} => #{result_label(net.eval(tr_input))}"
+  puts "#{net.eval(sq_input).inspect} => #{result_label(net.eval(sq_input))}"
+  puts "#{net.eval(cr_input).inspect} => #{result_label(net.eval(cr_input))}"
+  puts 'Examples with noise'
+  puts "#{net.eval(tr_with_noise).inspect} => #{result_label(net.eval(tr_with_noise))}"
+  puts "#{net.eval(sq_with_noise).inspect} => #{result_label(net.eval(sq_with_noise))}"
+  puts "#{net.eval(cr_with_noise).inspect} => #{result_label(net.eval(cr_with_noise))}"
+  puts 'Examples with base noise'
+  puts "#{net.eval(tr_with_base_noise).inspect} => #{result_label(net.eval(tr_with_base_noise))}"
+  puts "#{net.eval(sq_with_base_noise).inspect} => #{result_label(net.eval(sq_with_base_noise))}"
+  puts "#{net.eval(cr_with_base_noise).inspect} => #{result_label(net.eval(cr_with_base_noise))}"
 end
 
 puts "Elapsed time: #{times}"

data/examples/neural_network/hopfield_example.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://www.ai4r.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require_relative '../../lib/ai4r/neural_network/hopfield'
+require_relative '../../lib/ai4r/data/data_set'
+
+patterns = [
+  [1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1],
+  [-1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1],
+  [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1],
+  [1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1]
+]
+
+noisy_patterns = [
+  [1, 1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1],
+  [-1, -1, 1, 1, 1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1],
+  [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1],
+  [-1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1]
+]
+
+data = Ai4r::Data::DataSet.new(data_items: patterns)
+
+# Use random asynchronous updates instead of the default sequential
+# strategy.  Random updates are closer to the original Hopfield
+# formulation and may help the network escape shallow local minima.
+net = Ai4r::NeuralNetwork::Hopfield.new
+net.set_parameters(update_strategy: :async_random)
+net.train(data)
+
+puts 'Evaluation of noisy patterns:'
+noisy_patterns.each do |p|
+  # Pass `trace: true` to record the energy of each iteration so we can
+  # inspect how the network converges to a memorized pattern.
+  trace = net.eval(p, trace: true)
+  puts "#{p.inspect} => #{trace[:states].last.inspect}"
+  puts "Energy trace: #{trace[:energies].inspect}"
+end

data/examples/neural_network/patterns_with_base_noise.rb

@@ -1,31 +1,32 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # License::   MPL 1.1
 # Project::   ai4r
 # Url::       http://www.ai4r.org/
 #
-# You can redistribute it and/or modify it under the terms of 
-# the Mozilla Public License version 1.1  as published by the 
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
 # Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
- 
 
 TRIANGLE_WITH_BASE_NOISE = [
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  4, 10, 10,  4,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  8,  8,  8,  8,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  4, 10,  4,  4, 10,  4,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  8,  8,  3,  3,  8,  8,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  4, 10,  4,  3,  3,  4, 10,  4,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3],
-  [ 3,  3,  3,  4, 10,  4,  3,  3,  3,  3,  4, 10,  4,  3,  3,  3],
-  [ 3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3],
-  [ 3,  3,  4, 10,  4,  3,  3,  3,  3,  3,  3,  4, 10,  4,  3,  3],
-  [ 3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3],
-  [ 3,  4, 10,  4,  3,  3,  3,  3,  3,  3,  3,  3,  4, 10,  4,  3],
-  [ 3,  8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8,  3],
-  [ 4, 10,  4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  4, 10,  4],
-  [ 8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8],
+  [3,  3,  3,  3,  3,  3,  3, 8, 8, 3, 3, 3, 3, 3, 3, 3],
+  [3,  3,  3,  3,  3,  3,  4, 10, 10,  4,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  8,  8,  8,  8,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  4, 10,  4,  4, 10,  4,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  8,  8,  3,  3,  8,  8,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  4, 10,  4,  3,  3,  4, 10,  4,  3,  3,  3,  3],
+  [3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3],
+  [3,  3,  3,  4, 10,  4,  3,  3,  3,  3,  4, 10,  4,  3,  3,  3],
+  [3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3],
+  [3,  3,  4, 10,  4,  3,  3,  3,  3,  3,  3,  4, 10,  4,  3,  3],
+  [3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3],
+  [3,  4, 10,  4,  3,  3,  3,  3,  3,  3,  3,  3,  4, 10,  4,  3],
+  [3,  8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8,  3],
+  [4, 10,  4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  4, 10,  4],
+  [8, 8, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 8, 8],
   [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
-]
+].freeze
 
 SQUARE_WITH_BASE_NOISE = [
   [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
@@ -44,25 +45,24 @@ SQUARE_WITH_BASE_NOISE = [
   [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
   [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
   [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
-  
-]
+
+].freeze
 
 CROSS_WITH_BASE_NOISE = [
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8],
-  [ 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
-  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3]
-]
-  
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8],
+  [8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3]
+].freeze