phonetics 3.2.0 → 4.0.0

data/ext/c_levenshtein/phonetic_cost.h

@@ -1 +0,0 @@
-float phonetic_cost(int64_t phoneme1, int64_t phoneme2);

data/lib/phonetics/code_generator.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../phonetics'
-require 'json'
-
-module Phonetics
-  class CodeGenerator
-    attr_reader :writer
-
-    def initialize(writer = $stdout)
-      @writer = writer
-    end
-
-    def generate_phonetic_cost_c_code
-      generator = PhoneticCost.new(writer)
-      generator.generate
-      writer.flush
-    end
-
-    def generate_next_phoneme_length_c_code
-      generator = NextPhonemeLength.new(writer)
-      generator.generate
-      writer.flush
-    end
-
-    private
-
-    def binary(str)
-      "0b#{str.bytes.map { |byte| byte.to_s(2).rjust(8, '0') }.join}"
-    end
-
-    # Turn the bytes of all phonemes into a lookup trie where a sequence of
-    # bytes can find a phoneme in linear time.
-    def phoneme_byte_trie
-      phoneme_byte_trie_for(Phonetics.phonemes)
-    end
-
-    def phoneme_byte_trie_for(phonemes)
-      phonemes.each_with_object({}) do |phoneme, trie|
-        phoneme.bytes.each_with_index.reduce(trie) do |subtrie, (byte, idx)|
-          subtrie[byte] ||= {}
-
-          # If we've reached the end of the byte string
-          if phoneme.bytes.length - 1 == idx
-            # Check if this is a duplicate lookup path. If there's a collision
-            # then this whole approach makes no sense.
-            if subtrie[byte].key?(:source)
-              source = subtrie[byte][:source]
-              raise "Duplicate byte sequence on #{phoneme.inspect} & #{source.inspect} (#{phoneme.bytes.inspect})"
-            else
-              subtrie[byte][:source] = phoneme
-            end
-          end
-          subtrie[byte]
-        end
-      end
-    end
-
-    def describe(phoneme, depth = 0)
-      indent depth, "// Phoneme: '#{phoneme}', bytes: #{phoneme.bytes.inspect}"
-      if Phonetics::Consonants.features.key?(phoneme)
-        indent depth, "// consonant features: #{Phonetics::Consonants.features[phoneme].to_json}"
-      else
-        indent depth, "// vowel features: #{Phonetics::Vowels::FormantFrequencies[phoneme].to_json}"
-      end
-    end
-
-    def ruby_source
-      location = caller_locations.first
-      "#{location.path.split('/')[-4..].join('/')}:#{location.lineno}"
-    end
-
-    def indent(depth, line)
-      write "    #{' ' * depth}#{line}"
-    end
-
-    def write(line)
-      writer.puts line
-    end
-  end
-
-  class PhoneticCost < CodeGenerator
-    # We find the phonetic distance between two phonemes using a compiled
-    # lookup table. This is implemented as a set of nested switch statements.
-    # Hard to read when compiled, but simple to generate and fast at runtime.
-    #
-    # We generate a `phonetic_cost` function that takes four arguments: Two
-    # strings, and the lengths of those strings. Each string should be exactly
-    # one valid phoneme, which is possible thanks to the (also generated)
-    # next_phoneme_length() function.
-    #
-    # This will print a C code file with a function that implements a multil-level C
-    # switch like the following:
-    #
-    #    switch (phoneme1) {
-    #      case 'ɪ': // two bytes: [201, 170]
-    #                // vowel features: {"F1":300,"F2":2100,"rounded":false}
-    #
-    #         switch(phoneme2) {
-    #            'i': // one byte: [105]
-    #                 // vowel features: {"F1":240,"F2":2400,"rounded":false}
-    #              return (float) 0.14355381904337383;
-    #              break;
-    #
-    #  the distance of ("ɪ", "i")2 is therefore 0.14355
-    #
-    def generate
-      write(<<-HEADER.gsub(/^ {6}/, ''))
-
-      // This is compiled from Ruby, in #{ruby_source}
-      #include <stdint.h>
-      #include <stdio.h>
-      #include <inttypes.h>
-      float phonetic_cost(int64_t phoneme1, int64_t phoneme2) {
-        if (phoneme1 == phoneme2) {
-          return (float) 0.0;
-        }
-
-      HEADER
-
-      write '  switch (phoneme1) {'
-      Phonetics.phonemes.each do |phoneme1|
-        write "    case #{binary(phoneme1)}:"
-        describe(phoneme1, 2)
-        write '      switch(phoneme2) {'
-        Phonetics.distance_map[phoneme1].each do |phoneme2, distance|
-          write "        case #{binary(phoneme2)}:"
-          describe(phoneme2, 6)
-          write "          return (float) #{distance};"
-          write '          break;'
-        end
-        write '      }'
-        write '      break;'
-      end
-      write '  }'
-      write '  return (float) 1.0;'
-      write '};'
-      write ''
-    end
-  end
-
-  class NextPhonemeLength < CodeGenerator
-    # There's no simple way to break a string of IPA characters into phonemes.
-    # We do it by generating a function that, given a string of IPA characters,
-    # the starting index in that string, and the length of the string, returns
-    # the length of the next phoneme, or zero if none is found.
-    #
-    # Pseudocode:
-    #   - return 0 if length - index == 0
-    #   - switch on first byte, matching on possible first bytes of phonemes
-    #     within the selected case statement:
-    #     - return 1 if length - index == 1
-    #     - switch on second byte, matching on possible second bytes of phonemes
-    #       within the selected case statement:
-    #       - return 2 if length - index == 1
-    #       ...
-    #       - default case: return 2 iff a phoneme terminates here
-    #     - default case: return 1 iff a phoneme terminates here
-    #   - return 0
-    #
-    def generate
-      write(<<-HEADER.gsub(/^ {6}/, ''))
-      // This is compiled from Ruby, in #{ruby_source}
-      #include <stdio.h>
-      int next_phoneme_length(int *string, int cursor, int length) {
-
-        int max_length;
-        max_length = length - cursor;
-
-      HEADER
-
-      next_phoneme_switch(phoneme_byte_trie, 0)
-
-      # If we fell through all the cases, return 0
-      write '  return 0;'
-      write '}'
-    end
-
-    private
-
-    # Recursively build switch statements for the body of next_phoneme_length
-    def next_phoneme_switch(trie, depth)
-      # switch (string[cursor + depth]) {
-      #   case N: // for N in subtrie.keys
-      #     // if a case statement matches the current byte AND there's chance
-      #     // that a longer string might match, recurse.
-      #     if (max_length >= depth) {
-      #       // recurse
-      #     }
-      #     break;
-      #   // if there's a :source key here then a phoneme terminates at this
-      #   // point and this depth is a valid return value.
-      #   default:
-      #     return depth;
-      #     break;
-      # }
-      indent depth, "switch(string[cursor + #{depth}]) {"
-      write ''
-      trie.each do |key, subtrie|
-        next if key == :source
-        next if subtrie.empty?
-
-        indent depth, "case #{key}:"
-
-        # Add a comment to help understand the dataset
-        describe(subtrie[:source], depth + 1) if subtrie[:source]
-
-        if subtrie.keys == [:source]
-          indent depth, " return #{depth + 1};"
-        else
-          indent depth, " if (max_length > #{depth + 1}) {"
-          next_phoneme_switch(subtrie, depth + 1)
-          indent depth, ' } else {'
-          indent depth, "   return #{depth + 1};"
-          indent depth, ' }'
-        end
-
-        indent depth, '    break;'
-      end
-
-      if trie.key?(:source)
-        indent depth, '  default:'
-        indent depth, "    return #{depth};"
-      end
-      indent depth, '}'
-    end
-  end
-end

data/lib/phonetics/distances.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'set'
-
-module Phonetics
-  extend self
-
-  # This subclass of the stdlib's String allows us to iterate over each phoneme
-  # in a string without monkeypatching
-  #
-  # Usage:
-  #   Phonetics::String.new("wətɛvɝ").each_phoneme.to_a
-  #   => ["w", "ə", "t", "ɛ", "v", "ɝ"]
-  class String < SimpleDelegator
-    # Group all phonemes by how many characters they have. Use this to walk
-    # through a string finding phonemes (looking for longest ones first)
-    def self.phonemes_by_length
-      @phonemes_by_length ||= Phonetics.phonemes.each_with_object(
-        # This relies on the impicit stable key ordering of Hash objects in Ruby
-        # 2+ to keep the keys in descending order.
-        4 => Set.new, 3 => Set.new, 2 => Set.new, 1 => Set.new
-      ) do |str, acc|
-        acc[str.chars.size] << str
-      end
-    end
-
-    def each_phoneme
-      idx = 0
-      Enumerator.new do |y|
-        while idx < chars.length
-          found = false
-          self.class.phonemes_by_length.each do |size, phonemes|
-            next unless idx + size <= chars.length
-
-            candidate = chars[idx..idx + size - 1].join
-            next unless phonemes.include?(candidate)
-
-            y.yield candidate
-            idx += size
-            found = true
-            break
-          end
-          idx += 1 unless found
-        end
-      end
-    end
-  end
-
-  module Vowels
-    extend self
-
-    FormantFrequencies = {
-      # https://en.wikipedia.org/wiki/Formant#Phonetics
-      'i' => { F1: 240, F2: 2400, rounded: false },
-      'y' => { F1: 235, F2: 2100, rounded: false },
-      'ɪ' => { F1: 300, F2: 2100, rounded: false }, # Guessing From other vowels
-      'e' => { F1: 390, F2: 2300, rounded: false },
-      'ø' => { F1: 370, F2: 1900, rounded: true },
-      'ɛ' => { F1: 610, F2: 1900, rounded: false },
-      'œ' => { F1: 585, F2: 1710, rounded: true },
-      'a' => { F1: 850, F2: 1610, rounded: false },
-      'ɶ' => { F1: 820, F2: 1530, rounded: true },
-      'ɑ' => { F1: 750, F2: 940,  rounded: false },
-      'ɒ' => { F1: 700, F2: 760,  rounded: true },
-
-      'ʌ' => { F1: 600, F2: 1170, rounded: false },
-      # copying 'ʌ' for other mid-vowel formants
-      'ə' => { F1: 600, F2: 1170, rounded: false },
-      'ɝ' => { F1: 600, F2: 1170, rounded: false, rhotic: true },
-
-      'ɔ' => { F1: 500, F2: 700,  rounded: true },
-      'ɤ' => { F1: 460, F2: 1310, rounded: false },
-      'o' => { F1: 360, F2: 640,  rounded: true },
-      'ɯ' => { F1: 300, F2: 1390, rounded: false },
-      'æ' => { F1: 800, F2: 1900, rounded: false }, # Guessing From other vowels
-      'u' => { F1: 350, F2: 650,  rounded: true }, # Guessing From other vowels
-      'ʊ' => { F1: 350, F2: 650,  rounded: true },
-      # Frequencies from http://videoweb.nie.edu.sg/phonetic/vowels/measurements.html
-    }.freeze
-
-    def phonemes
-      @phonemes ||= FormantFrequencies.keys
-    end
-
-    # Given two vowels, calculate the (pythagorean) distance between them using
-    # their F1 and F2 frequencies as x/y coordinates.
-    # The return value is scaled to a value between 0 and 1
-    # TODO: account for rhoticity (F3)
-    def distance(phoneme1, phoneme2)
-      formants1 = FormantFrequencies.fetch(phoneme1)
-      formants2 = FormantFrequencies.fetch(phoneme2)
-
-      @minmax_f1 ||= FormantFrequencies.values.minmax { |a, b| a[:F1] <=> b[:F1] }.map { |h| h[:F1] }
-      @minmax_f2 ||= FormantFrequencies.values.minmax { |a, b| a[:F2] <=> b[:F2] }.map { |h| h[:F2] }
-
-      # Get an x and y value for each input phoneme scaled between 0.0 and 1.0
-      # We'll use the scaled f1 as the 'x' and the scaled f2 as the 'y'
-      scaled_phoneme1_f1 = (formants1[:F1] - @minmax_f1[0]) / @minmax_f1[1].to_f
-      scaled_phoneme1_f2 = (formants1[:F2] - @minmax_f2[0]) / @minmax_f2[1].to_f
-      scaled_phoneme2_f1 = (formants2[:F1] - @minmax_f1[0]) / @minmax_f1[1].to_f
-      scaled_phoneme2_f2 = (formants2[:F2] - @minmax_f2[0]) / @minmax_f2[1].to_f
-
-      f1_distance = (scaled_phoneme1_f1 - scaled_phoneme2_f1).abs
-      f2_distance = (scaled_phoneme1_f2 - scaled_phoneme2_f2).abs
-
-      # When we have four values we can use the pythagorean theorem on them
-      # (order doesn't matter)
-      sqrt = Math.sqrt((f1_distance**2) + (f2_distance**2))
-
-      # Vowels are more similiar to each other than consonants, so we apply a
-      # penalty softening here
-      sqrt / 2.0
-    end
-  end
-
-  module Consonants
-    extend self
-
-    # This chart (columns 2 through the end, anyway) is a direct port of
-    # https://en.wikipedia.org/wiki/International_Phonetic_Alphabet#Letters
-    # We store the consonant table in this format to make updating it easier.
-    #
-    # rubocop:disable Layout/TrailingWhitespace
-    ChartData = %(           | Labio-velar | Bi-labial | Labio-dental | Linguo-labial | Dental | Alveolar | Post-alveolar | Retro-flex | Palatal | Velar | Uvular | Pharyngeal | Glottal
-      Nasal                  |             | m̥  m      |    ɱ         |    n̼          |        | n̥  n     |               | ɳ̊  ɳ       | ɲ̊  ɲ    | ŋ̊  ŋ  |    ɴ   |            |        
-      Stop                   |             | p  b      | p̪  b̪         | t̼  d̼          |        | t  d     |               | ʈ  ɖ       | c  ɟ    | k  g  | q  ɢ   | ʡ          | ʔ      
-      Sibilant fricative     |             |           |              |               |        | s  z     | ʃ  ʒ          | ʂ  ʐ       | ɕ  ʑ    |       |        |            |        
-      Non-sibilant fricative |             | ɸ  β      | f  v         | θ̼  ð̼          | θ  ð   | θ̠  ð̠     | ɹ̠̊˔ ɹ̠˔         |    ɻ˔      | ç  ʝ    | x  ɣ  | χ  ʁ   | ħ  ʕ       | h  ɦ   
-      Approximant            |   w         |           | ʋ̥  ʋ         |               |        | ɹ̥  ɹ     |               | ɻ̊  ɻ       | j̊  j    | ɰ̊  ɰ  |        |            |    ʔ̞   
-      Tap/flap               |             |    ⱱ̟      |    ⱱ         |    ɾ̼          |        | ɾ̥  ɾ     |               | ɽ̊  ɽ       |         |       |    ɢ̆   |    ʡ̆       |        
-      Trill                  |             | ʙ̥  ʙ      |              |               |        | r̥  r     |               |            |         |       | ʀ̥  ʀ   | ʜ  ʢ       |        
-      Lateral fricative      |             |           |              |               |        | ɬ  ɮ     |               | ɭ̊˔ ɭ˔      | ʎ̝̊  ʎ̝    | ʟ̝̊  ʟ̝  |        |            |        
-      Lateral approximant    |             |           |              |               |        | l̥  l     |               | ɭ̊  ɭ       | ʎ̥  ʎ    | ʟ̥  ʟ  |    ʟ̠   |            |        
-      Lateral tap/flap       |             |           |              |               |        |    ɺ     |               |    ɭ̆       |    ʎ̆    |    ʟ̆  |        |            |         
-    )
-    # rubocop:enable Layout/TrailingWhitespace
-
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/PerceivedComplexity
-    # Parse the ChartData into a lookup table where we can retrieve attributes
-    # for each phoneme
-    def features
-      @features ||= begin
-        header, *manners = ChartData.lines
-
-        _, *positions = header.chomp.split(' | ')
-        positions.map(&:strip!)
-
-        # Remove any trailing blank lines
-        manners.pop while manners.last.to_s.strip.empty?
-
-        position_indexes = Hash[*positions.each_with_index.to_a.flatten]
-
-        @position_count = positions.size
-
-        manners.each_with_object({}) do |row, phonemes|
-          manner, *columns = row.chomp.split(' | ')
-          manner.strip!
-          positions.zip(columns).each do |position, phoneme_text|
-            data = {
-              position: position,
-              position_index: position_indexes[position],
-              manner: manner,
-            }
-            # If there is a character in the first byte then this articulation
-            # has a voiceless phoneme. The symbol may use additional characters
-            # as part of the phoneme symbol.
-            unless phoneme_text[0] == ' '
-              # Take the first non-blank character string
-              symbol = phoneme_text.chars.take_while { |char| char != ' ' }.join
-              phoneme_text = phoneme_text[symbol.chars.size..]
-
-              phonemes[symbol] = data.merge(voiced: false)
-            end
-            # If there's a character anywhere left in the string then this
-            # articulation has a voiced phoneme
-            unless phoneme_text.strip.empty?
-              symbol = phoneme_text.strip
-              phonemes[symbol] = data.merge(voiced: true)
-            end
-          end
-        end
-      end
-    end
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    def phonemes
-      @phonemes ||= features.keys
-    end
-
-    # Given two consonants, calculate their difference by summing the
-    # following:
-    #   * 0.3 if they are not voiced the same
-    #   * 0.3 if they are different manners
-    #   * Up to 0.4 if they are the maximum position difference
-    def distance(phoneme1, phoneme2)
-      features1 = features[phoneme1]
-      features2 = features[phoneme2]
-
-      penalty = 0
-      penalty += 0.3 if features1[:voiced] != features2[:voiced]
-
-      penalty += 0.3 if features1[:manner] != features2[:manner]
-
-      # Use up to the remaining 0.4 for penalizing differences in manner
-      penalty += 0.4 * ((features1[:position_index] - features2[:position_index]).abs / @position_count.to_f)
-      penalty
-    end
-  end
-
-  def phonemes
-    Vowels.phonemes + Consonants.phonemes
-  end
-
-  Symbols = Consonants.phonemes.reduce({}) { |acc, p| acc.update p => :consonant }.merge(
-    Vowels.phonemes.reduce({}) { |acc, p| acc.update p => :vowel }
-  )
-
-  def distance(phoneme1, phoneme2)
-    return 0 if phoneme1 == phoneme2
-
-    distance_map.fetch(phoneme1).fetch(phoneme2)
-  end
-
-  def distance_map
-    @distance_map ||= phonemes.permutation(2).each_with_object(Hash.new { |h, k| h[k] = {} }) do |pair, scores|
-      p1, p2 = *pair
-      score = _distance(p1, p2)
-      scores[p1][p2] = score
-      scores[p2][p1] = score
-    end
-  end
-
-  private
-
-  def _distance(phoneme1, phoneme2)
-    types = [Symbols.fetch(phoneme1), Symbols.fetch(phoneme2)].sort
-    case types
-    when %i[consonant vowel]
-      1.0
-    when %i[vowel vowel]
-      Vowels.distance(phoneme1, phoneme2)
-    when %i[consonant consonant]
-      Consonants.distance(phoneme1, phoneme2)
-    end
-  end
-end

data/lib/phonetics/levenshtein.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../phonetics'
-require_relative 'c_levenshtein'
-
-# Using the Damerau version of the Levenshtein algorithm, with phonetic feature
-# count used instead of a binary edit distance calculation
-#
-# This implementation was dually inspired by the damerau-levenshtein gem
-# (https://github.com/GlobalNamesArchitecture/damerau-levenshtein/tree/master/ext/damerau_levenshtein).
-# and "Using Phonologically Weighted Levenshtein Distances for the Prediction
-# of Microscopic Intelligibility" by Lionel Fontan, Isabelle Ferrané, Jérôme
-# Farinas, Julien Pinquier, Xavier Aumont, 2016
-# https://hal.archives-ouvertes.fr/hal-01474904/document
-module Phonetics
-  module Levenshtein
-    extend ::PhoneticsLevenshteinCBinding
-
-    # rubocop:disable Style/OptionalBooleanParameter
-    def self.distance(str1, str2, verbose = false)
-      return if str1.nil? || str2.nil?
-
-      internal_phonetic_distance(str1, str2, verbose)
-    end
-    # rubocop:enable Style/OptionalBooleanParameter
-  end
-end

data/lib/phonetics/ruby_levenshtein.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../phonetics'
-
-# Using the Damerau version of the Levenshtein algorithm, with phonetic feature
-# count used instead of a binary edit distance calculation
-#
-# This Ruby implementation is almost entirely taken from the damerau-levenshtein gem
-# (https://github.com/GlobalNamesArchitecture/damerau-levenshtein/tree/master/ext/damerau_levenshtein).
-# The implementation is modified based on "Using Phonologically Weighted
-# Levenshtein Distances for the Prediction of Microscopic Intelligibility" by
-# Lionel Fontan, Isabelle Ferrané, Jérôme Farinas, Julien Pinquier, Xavier
-# Aumont, 2016
-# https://hal.archives-ouvertes.fr/hal-01474904/document
-module Phonetics
-  class RubyLevenshtein
-    attr_reader :str1, :str2, :len1, :len2, :matrix
-
-    # rubocop:disable Style/OptionalBooleanParameter
-    def initialize(ipa_str1, ipa_str2, verbose = false)
-      @str1 = ipa_str1.each_char.select { |c| Phonetics.phonemes.include?(c) }.join
-      @str2 = ipa_str2.each_char.select { |c| Phonetics.phonemes.include?(c) }.join
-      @len1 = @str1.size
-      @len2 = @str2.size
-      @verbose = verbose
-      prepare_matrix
-      set_edit_distances(@str1, @str2)
-    end
-
-    def self.distance(str1, str2, verbose = false)
-      new(str1, str2, verbose).distance
-    end
-    # rubocop:enable Style/OptionalBooleanParameter
-
-    def distance
-      return 0 if walk.empty?
-
-      print_matrix if @verbose
-      walk.last[:distance]
-    end
-
-    private
-
-    def walk
-      res = []
-      i = len2
-      j = len1
-      return res if i == 0 && j == 0
-
-      loop do
-        i, j, char = char_data(i, j)
-        res.unshift char
-        break if i == 0 || j == 0
-      end
-      res
-    end
-
-    def set_edit_distances(str1, str2)
-      i = 0
-      while (i += 1) <= len2
-        j = 0
-        while (j += 1) <= len1
-          options = [
-            ins(i, j),
-            del(i, j),
-            subst(i, j)
-          ]
-          # This is where we implement the modifications to Damerau-Levenshtein
-          # according to https://hal.archives-ouvertes.fr/hal-01474904/document
-          phonetic_cost = Phonetics.distance(str1[j - 1], str2[i - 1])
-          matrix[i][j] = options.min + phonetic_cost
-          puts "------- #{j}/#{i} #{j + (i * (len1 + 1))}" if @verbose
-          print_matrix if @verbose
-        end
-      end
-    end
-
-    def char_data(i, j)
-      char = { distance: matrix[i][j] }
-      operation, move = find_previous(i, j)
-      previous_value = move[:value]
-      char[:type] = previous_value == char[:distance] ? :same : operation
-      i, j = move[:move_to]
-      [i, j, char]
-    end
-
-    def find_previous(i, j)
-      [
-        [:insert, { cost: ins(i, j), move_to: [i, j - 1] }],
-        [:delete, { cost: del(i, j), move_to: [i, j - 1] }],
-        [:substitute, { cost: subst(i, j), move_to: [i, j - 1] }]
-      ].select do |_operation, data|
-        # Don't send us out of bounds
-        data[:move_to][0] >= 0 && data[:move_to][1] >= 0
-      end.min_by do |_operation, data|
-        # pick the cheapest one
-        data[:value]
-      end
-    end
-
-    # TODO: Score the edit distance lower if sonorant sounds are found in sequence.
-    def del(i, j)
-      matrix[i - 1][j]
-    end
-
-    def ins(i, j)
-      matrix[i][j - 1]
-    end
-
-    def subst(i, j)
-      matrix[i - 1][j - 1]
-    end
-
-    # Set the minimum scores equal to the distance between each phoneme,
-    # sequentially.
-    #
-    # The first value is always zero, the second is always 1.
-    # Subsequent values are the cumulative phonetic distance between each
-    # phoneme within the same string.
-    # "aek" -> [0, 1, 1.61, 2.61]
-    def initial_distances(str1, str2)
-      starting_distance = 1
-      starting_distance = 0 if len1 == 0 || len2 == 0
-
-      distances1 = (1..(str1.length - 1)).reduce([0, starting_distance]) do |acc, i|
-        acc << acc.last + Phonetics.distance(str1[i - 1], str1[i])
-      end
-      distances2 = (1..(str2.length - 1)).reduce([0, starting_distance]) do |acc, i|
-        acc << acc.last + Phonetics.distance(str2[i - 1], str2[i])
-      end
-
-      [distances1, distances2]
-    end
-
-    def prepare_matrix
-      str1_initial, str2_initial = initial_distances(str1, str2)
-
-      @matrix = Array.new(len2 + 1) { Array.new(len1 + 1) { nil } }
-      # The first row is the initial values for str2
-      @matrix[0] = str1_initial
-      # The first column is the initial values for str1
-      (len2 + 1).times { |n| @matrix[n][0] = str2_initial[n] }
-    end
-
-    # This is a helper method for developers to use when exploring this
-    # algorithm.
-    def print_matrix
-      puts "           #{str1.chars.map { |c| c.ljust(9, ' ') }.join}"
-      matrix.each_with_index do |row, ridx|
-        print '  ' if ridx == 0
-        print "#{str2[ridx - 1]} " if ridx > 0
-        row.each_with_index do |cell, _cidx|
-          cell ||= 0.0
-          print cell.to_s[0, 8].ljust(8, '0')
-          print ' '
-        end
-        puts ''
-      end
-      ''
-    end
-  end
-end