tonal-tools 1.3.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 850c95dbdd71dec89c67eb9b1d709a4f009c4ab48b90d8c3ee7d7553bb27515b
-  data.tar.gz: 450b9ee2401a947857beedb052933d567f1321bef3d6c16e26f3120604105c12
+  metadata.gz: 340dc7220c5ab24c65486eefc2ebb457d76c7c1ac64fd91a428b94a4fd84cd7d
+  data.tar.gz: 5721937407c18951a5b72eb075ffdbbfe8765abb3ae98695fc2af40e55277c3a
 SHA512:
-  metadata.gz: d5d7e3540e77d04fe847cf8da7de9766481bc6e74183438466ab6d1e42b3b156ff60397ca319ad3d7a2cf5780dbe94e7c01c1da10518b22de2e4c96ff7e9ea7d
-  data.tar.gz: 075bab07ea64ce20d70b3e131d74d39349c5e15f89f00e44df16c3a3de95e691a795230fed9225433e56a7aeec159b43ec4b46766d96e6714cd8206912fb752c
+  metadata.gz: def0ab4830c3f5b3e82b919fcf8242899539a32e554acd2b260d3f37f87df6dbd7899cb8a6f9c045c98805bba69a10efc1f974d88e7f3107f641033c862acdc8
+  data.tar.gz: 72601d465253ab599188b0f15a241b30e9824754c076bf260f69d4fa5b92309ac85dbb677a1e9e03bff0c29b42302a064b8d73a14ac92e0c0f5f7c9c8c84af8c

data/lib/tonal/approximation.rb

@@ -0,0 +1,189 @@
+class Tonal::Ratio
+  class Approximation
+    DEFAULT_MAX_PRIME = Float::INFINITY
+    DEFAULT_MAX_GRID_SCALE = 100
+    DEFAULT_MAX_GRID_BOUNDARY = 5
+    DEFAULT_DEPTH = Float::INFINITY
+    DEFAULT_COMPLEXITY_AMOUNT = 50.0
+    CONVERGENT_LIMIT = 10
+
+    extend Forwardable
+    def_delegators :@ratio, :antecedent, :consequent, :to_cents, :to_basic_ratio, :to_f
+
+    attr_reader :ratio
+
+    def initialize(ratio:)
+      raise ArgumentError, "Tonal::Ratio required" unless ratio.kind_of?(Tonal::Ratio)
+      @ratio = ratio
+    end
+
+    # @return [Tonal::Ratio::Approximation::Set] of ratios within cent tolerance of self found using continued fraction approximation
+    # @example
+    #   Tonal::Ratio.ed(12,1).approximate.by_continued_fraction
+    #   => (4771397596969315/4503599627370496): [(18/17), (196/185), (1657/1564), (7893/7450), (18904/17843), (3118/2943), (1461/1379), (89/84), (17/16)]
+    # @param cents_tolerance the cents tolerance used to scope the collection
+    # @param depth the maximum number of ratios in the collection
+    # @param max_prime the maximum prime number to allow in the collection
+    # @param conv_limit the number of convergents to limit the ContinuedFraction method
+    #
+    def by_continued_fraction(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, conv_limit: CONVERGENT_LIMIT)
+      self_in_cents = to_cents
+      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
+      Set.new(ratio: ratio).tap do |set|
+        ContinuedFraction.new(antecedent.to_f/consequent, conv_limit).convergents.each do |convergent|
+          ratio2 = ratio.class.new(convergent.numerator,convergent.denominator)
+          set.ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
+          break if set.length >= depth
+        end
+      end
+    end
+
+    # @return [Tonal::Ratio::Approximation::Set] of ratios within cent tolerance of self found using a quotient walk on the fraction tree
+    # @example
+    #   Tonal::Ratio.ed(12,1).approximate.by_quotient_walk(max_prime: 89)
+    #   => (4771397596969315/4503599627370496): [(18/17), (196/185), (89/84), (71/67), (53/50), (35/33), (17/16)]
+    # @param cents_tolerance the cents tolerance used to scope the collection
+    # @param depth the maximum number of ratios in the collection
+    # @param max_prime the maximum prime number to allow in the collection
+    # @param conv_limit the number of convergents to limit the ContinuedFraction method
+    #
+    def by_quotient_walk(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, conv_limit: CONVERGENT_LIMIT)
+      self_in_cents = to_cents
+      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
+
+      Set.new(ratio: ratio).tap do |set|
+        FractionTree.quotient_walk(to_f, limit: conv_limit).each do |node|
+          ratio2 = ratio.class.new(node.weight)
+          set.ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
+          break if set.length >= depth
+        end
+      end
+    end
+
+    # @return [Tonal::Ratio::Approximation::Set] of fraction tree ratios within cent tolerance of self
+    # @example
+    #   Tonal::Ratio.ed(12,1).approximate.by_tree_path(max_prime: 17)
+    #   => (4771397596969315/4503599627370496): [(18/17), (35/33), (17/16)]
+    # @param cents_tolerance the cents tolerance used to scope the collection
+    # @param depth the maximum number of ratios in the collection
+    # @param max_prime the maximum prime number to allow in the collection
+    #
+    def by_tree_path(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME)
+      self_in_cents = to_cents
+      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
+      Set.new(ratio: ratio).tap do |set|
+        FractionTree.path_to(to_f).each do |node|
+          ratio2 = ratio.class.new(node.weight)
+          set.ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
+          break if set.length >= depth
+        end
+      end
+    end
+
+    # @return [Tonal::Ratio::Approximation::Set] of superparticular approximations within cent tolerance of self
+    # @example
+    #   Tonal::Ratio.new(3/2r).approximate.by_superparticular
+    #   => (3/2): [(1098/730), (1095/728), (1092/726), (1089/724), (1086/722), (1083/720), (1080/718), (1077/716), (1074/714), (1071/712), (1068/710), (1065/708), (1062/706), (1059/704), (1056/702), (1053/700), (1050/698), (1047/696), (1044/694), (1041/692)]
+    # @param cents_tolerance the cents tolerance used to scope the collection
+    # @param depth the maximum number of ratios in the collection
+    # @param max_prime the maximum prime number to allow in the collection
+    # @param superpart if the superior part is the numerator or denominator
+    #
+    def by_superparticular(cents_tolerance: Tonal::Cents::TOLERANCE, depth: 20, max_prime: DEFAULT_MAX_PRIME, superpart: :upper)
+      self_in_cents = to_cents
+      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
+      Set.new(ratio: ratio).tap do |set|
+        n = 1
+        while true do
+          ratio2 = ratio.class.superparticular(n, factor: ratio.to_r, superpart:)
+          set.ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime) && ratio2 != ratio
+          break if set.length >= depth
+          n += 1
+        end
+      end
+    end
+
+    # @return [Array] of ratios within cent tolerance of self found on the ratio grid
+    # @example
+    #   Tonal::Ratio.new(3,2).approximate.by_neighborhood(max_prime: 23, cents_tolerance: 5, max_boundary: 10, max_scale: 60)
+    #   => (3/2): [(175/117), (176/117)]
+    # @param cents_tolerance the cents tolerance used to scope the collection
+    # @param depth the maximum number of ratios in the collection
+    # @param max_prime the maximum prime number to allow in the collection
+    # @param max_boundary the maximum distance grid ratios will be from the scaled ratio
+    # @param max_scale the maximum self will be scaled
+    #
+    def by_neighborhood(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, max_boundary: DEFAULT_MAX_GRID_BOUNDARY, max_scale: DEFAULT_MAX_GRID_SCALE)
+      self_in_cents = to_cents
+      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
+      Set.new(ratio: ratio).tap do |set|
+        scale = 1
+        boundary = 1
+
+        while set.length <= depth && scale <= max_scale do
+          while boundary <= max_boundary
+            vacinity = ratio.respond_to?(:to_basic_ratio) ? to_basic_ratio.scale(scale) : ratio.scale(scale)
+            self.class.neighbors(away: boundary, vacinity: vacinity).each do |neighbor|
+              set.ratios << neighbor if ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && neighbor.within_prime?(max_prime) && neighbor != ratio
+            end
+            boundary += 1
+          end
+          boundary = 1
+          scale += 1
+        end
+      end
+    end
+
+    # @return [Array] of bounding ratios in the ratio grid vacinity of antecedent/consequent scaled by scale
+    # @example
+    #   Tonal::ReducedRatio.new(3,2).neighborhood(scale: 256, boundary: 2)
+    #     => [(768/514), (766/512), (768/513), (767/512), (768/512), (769/512), (768/511), (770/512), (768/510)]
+    # @param scale [Integer] used to scale antecedent/consequent on coordinate system
+    # @param boundary [Integer] limit within which to calculate neighboring ratios
+    #
+    def neighborhood(scale: 2**0, boundary: 1)
+      scale = scale.round
+      vacinity = ratio.respond_to?(:to_basic_ratio) ? to_basic_ratio.scale(scale) : ratio.scale(scale)
+      SortedSet.new([].tap do |ratio_list|
+                      1.upto(boundary) do |away|
+                        ratio_list << self.class.neighbors(away: away, vacinity: vacinity)
+                      end
+                    end.flatten).to_a
+    end
+
+    # @return [Array] an array of Tonal::Ratio neighbors in the scaled ratio's grid neighborhood
+    # @example
+    #   Tonal::Ratio::Approximation.neighbors(vacinity: (3/2r).ratio(reduced:false).scale(256), away: 1)
+    #     => [(768/513), (767/512), (768/512), (769/512), (768/511)]
+    # @param away [Integer] the neighbors distance away from self's antecedent and consequent
+    #
+    def self.neighbors(vacinity:, away: 1)
+      [vacinity,
+       vacinity.class.new(vacinity.antecedent+away, vacinity.consequent),
+       vacinity.class.new(vacinity.antecedent-away, vacinity.consequent),
+       vacinity.class.new(vacinity.antecedent, vacinity.consequent+away),
+       vacinity.class.new(vacinity.antecedent, vacinity.consequent-away),
+       vacinity.class.new(vacinity.antecedent+away, vacinity.consequent+away),
+       vacinity.class.new(vacinity.antecedent+away, vacinity.consequent-away),
+       vacinity.class.new(vacinity.antecedent-away, vacinity.consequent+away),
+       vacinity.class.new(vacinity.antecedent-away, vacinity.consequent-away)]
+    end
+
+    class Set
+      extend Forwardable
+      def_delegators :@ratios, :count, :length, :min, :max, :entries, :all?, :any?, :reject, :map
+
+      attr_reader :ratios, :ratio
+
+      def initialize(ratio:)
+        @ratio = ratio
+        @ratios = SortedSet.new
+      end
+      alias :approximations :entries
+
+      def inspect
+        "#{ratio}: #{entries}"
+      end
+    end
+  end
+end

data/lib/tonal/attributions.rb

@@ -0,0 +1,4 @@
+module Tonal
+  TOOLS_PRODUCER = "mTonal"
+  TOOLS_VERSION = "2.0.1"
+end

data/lib/tonal/cents.rb

@@ -9,7 +9,6 @@ class Tonal::Cents
   CENT_SCALE = 1200.0
   TOLERANCE = 5
   PRECISION = 2
-  DEFAULT_ROUNDING_PRECISION = 2
 
   attr_reader :log, :ratio
 
@@ -100,7 +99,7 @@ class Tonal::Cents
   # https://embeddeduse.com/2019/08/26/qt-compare-two-floats/
   #
   def <=>(rhs)
-    rhs.kind_of?(self.class) ? value.round(2) <=> rhs.value.round(2) : value.round(2) <=> rhs.round(2)
+    rhs.kind_of?(self.class) ? value.round(PRECISION) <=> rhs.value.round(PRECISION) : value.round(PRECISION) <=> rhs.round(PRECISION)
   end
 
   private

data/lib/tonal/extensions.rb

@@ -324,11 +324,11 @@ class Array
   def denominators = self.map(&:denominator)
   alias :consequents :denominators
 
-  # @return [Array] an array of normalized ratios
+  # @return [Array] an array of ratios with equalized denominators
   # @example
-  #   [4/3r, 3/2r].normalize => [(8/6), (9/6)]
+  #   [4/3r, 3/2r].denominize => [(8/6), (9/6)]
   #
-  def normalize
+  def denominize
     l = denominators.lcm
     map{|r| Tonal::Ratio.new(l / r.denominator * r.numerator, l)}
   end
@@ -349,8 +349,9 @@ class Array
   # @return [Tonal::ReducedRatio] ratio reconstructed from the result of a prime factor decomposition
   # @example
   #   [[[3, 1]], [[2, 1]]].ratio_from_prime_divisions => (3/2)
+  # @reduced [Boolean] if a reduced or unreduced ratio is returned
   #
-  def ratio_from_prime_divisions = Tonal::Ratio.new(Prime.int_from_prime_division(self.first), Prime.int_from_prime_division(self.last))
+  def ratio_from_prime_divisions(reduced: false) = reduced ? Tonal::ReducedRatio.new(Prime.int_from_prime_division(self.first), Prime.int_from_prime_division(self.last)) : Tonal::Ratio.new(Prime.int_from_prime_division(self.first), Prime.int_from_prime_division(self.last))
 
   # @return [Array] translated by value
   # @example

data/lib/tonal/interval.rb

@@ -2,7 +2,7 @@ class Tonal::Interval
   extend Forwardable
   include Comparable
 
-  def_delegators :@interval, :to_r, :antecedent, :consequent
+  def_delegators :@interval, :to_r, :antecedent, :consequent, :to_cents
 
   attr_reader :lower_ratio, :upper_ratio, :interval
 
@@ -13,6 +13,7 @@ class Tonal::Interval
     @upper_ratio = upper_ratio.ratio
     @interval = @upper_ratio / @lower_ratio
   end
+  alias :ratio :interval
   alias :lower :lower_ratio
   alias :upper :upper_ratio
   alias :numerator :antecedent
@@ -22,7 +23,7 @@ class Tonal::Interval
     [lower_ratio, upper_ratio]
   end
 
-  def normalize
+  def denominize
     ratios = to_a
     lcm = ratios.denominators.lcm
     ratios.map{|r| Tonal::Ratio.new(lcm / r.denominator * r.numerator, lcm)}

data/lib/tonal/ratio.rb

@@ -2,7 +2,7 @@ class Tonal::Ratio
   extend Forwardable
   include Comparable
 
-  def_delegators :@approximations, :neighborhood
+  def_delegators :@approximation, :neighborhood
 
   attr_reader :antecedent, :consequent, :equave, :reduced_antecedent, :reduced_consequent
 
@@ -27,29 +27,38 @@ class Tonal::Ratio
     @equave = equave
     @reduced_antecedent, @reduced_consequent = _equave_reduce(equave)
     @label = label
-    @approximations = Approximations.new(ratio: self)
+    @approximation = Approximation.new(ratio: self)
   end
 
   alias :numerator :antecedent
   alias :denominator :consequent
 
-  # @return [Tonal::Ratio] ratio who's numerator and denominator are 1 apart
+  # @return [Tonal::Ratio] ratio who's numerator and denominator are seperated by a difference of 1
   # @example
-  #   Tonal::Ratio.superparticular(100) = (100/99)
-  # @param n numerator of ratio
+  #   Tonal::Ratio.superparticular(100) = (101/100)
+  # @param n [Integer] number from which the superior part is calculated
+  # @param factor [Rational] multiplied into the resulting ratio, default 1/1
+  # @param superpart [Symbol] assigning the superior part to the antecedent or consequent
   #
-  def self.superparticular(n)
-    superpartient(n, 1)
+  def self.superparticular(n, factor: 1/1r, superpart: :upper)
+    superpartient(n, summand: 1, factor:, superpart:)
   end
 
-  # @return [Tonal::Ratio] ratio who's numerator and denominator are a partient apart
+  # @return [Tonal::Ratio] ratio who's numerator and denominator are separated by a summand difference
   # @example
-  #   Tonal::Ratio.superpartient(100, 5) => (100/95)
-  # @param n numerator of ratio
-  # @param part partient separating the numerator and denominator
+  #   Tonal::Ratio.superpartient(23, summand: 3) => (26/23)
+  # @param n [Integer] number from which the superior part is calculated
+  # @param summand [Integer] term added to the superior part
+  # @param factor [Rational] multiplied into the resulting ratio, default 1/1
+  # @param superpart [Symbol] assigning the superior part to the antecedent or consequent
   #
-  def self.superpartient(n, part)
-    self.new(n, n-part)
+  def self.superpartient(n, summand:, factor: 1/1r, superpart: :upper)
+    case superpart.to_sym.downcase
+    when :lower, :consequent, :denominator
+      self.new(n*factor.numerator, (n+summand)*factor.denominator)
+    else
+      self.new((n+summand)*factor.numerator, n*factor.denominator)
+    end
   end
 
   # @return [Tonal::Ratio] a randomly generated ratio
@@ -58,7 +67,7 @@ class Tonal::Ratio
   # @param number_of_factors
   # @param within
   #
-  def self.random_ratio(number_of_factors = 2, within: 100)
+  def self.random_ratio(number_of_factors = 2, within: 100, reduced: false)
     primes = Prime.each(within).to_a
     nums = []
     dens = []
@@ -66,7 +75,7 @@ class Tonal::Ratio
       nums << [primes[rand(10)], rand(3)]
       dens << [primes[rand(10)], rand(3)]
     end
-    [nums, dens].ratio_from_prime_divisions
+    [nums, dens].ratio_from_prime_divisions(reduced:)
   end
 
   # @return [Tonal::Ratio] the ratio of step in the modulo
@@ -98,10 +107,10 @@ class Tonal::Ratio
     self
   end
 
-  # @return [Tonal::Ratio::Approximations] self's approximation instance
+  # @return [Tonal::Ratio::Approximation] self's approximation instance
   #
-  def approx
-    @approximations
+  def approximate
+    @approximation
   end
 
   # ==================================
@@ -264,15 +273,6 @@ class Tonal::Ratio
     (self.class.new(axis) ** 2) / self
   end
 
-  # @return [Tonal::Ratio]
-  # @example
-  #   Tonal::Ratio.new(4/3r).mirror2(4/2r) => (3/8)
-  # @param ratio
-  #
-  def mirror2(ratio)
-    self.class.new(invert.to_r / ratio)
-  end
-
   # @return Tonal::ReducedRatio the Ernst Levy negative of self
   # @example
   #   Tonal::ReducedRatio.new(7/4r).negative => (12/7)
@@ -434,7 +434,7 @@ class Tonal::Ratio
   # @param modulo
   #
   def efficiency(modulo)
-    (Tonal::Cents::CENT_SCALE * step(modulo).step / modulo.to_f) - to_cents
+    ((Tonal::Cents::CENT_SCALE * step(modulo).step / modulo.to_f) - to_cents).round(Tonal::Cents::PRECISION)
   end
 
   # @return [Array] the results of ratio dividing and multiplying self
@@ -473,7 +473,7 @@ class Tonal::Ratio
     # Return label, if defined; or,
     # Return the "antecedent/consequent", if antecedent is less than 7 digits long; or
     # Return the floating point representation rounded to 2 digits of precision
-    (@label || ((Math.log10(antecedent).to_i + 1) <= 6 ? "#{antecedent}/#{consequent}" : to_f.round(2))).to_s
+    (@label || ((Math.log10(antecedent).to_i + 1) <= 6 ? "#{antecedent}/#{consequent}" : to_f.round(Tonal::Cents::PRECISION))).to_s
   end
 
   # @return [String] the string representation of Tonal::Ratio

data/lib/tonal/tools.rb

@@ -11,7 +11,7 @@ module Tonal
   require "tonal/hertz"
   require "tonal/log"
   require "tonal/log2"
-  require "tonal/approximations"
+  require "tonal/approximation"
   require "tonal/ratio"
   require "tonal/reduced_ratio"
   require "tonal/interval"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tonal-tools
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Jose Hales-Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-23 00:00:00.000000000 Z
+date: 2024-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yaml
@@ -158,7 +158,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - data/commas.yml
-- lib/tonal/approximations.rb
+- lib/tonal/approximation.rb
+- lib/tonal/attributions.rb
 - lib/tonal/cents.rb
 - lib/tonal/comma.rb
 - lib/tonal/extensions.rb
@@ -191,7 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '3.1'
 requirements: []
-rubygems_version: 3.5.4
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: Tonal tools

data/lib/tonal/approximations.rb

@@ -1,148 +0,0 @@
-class Tonal::Ratio
-  class Approximations
-    DEFAULT_MAX_PRIME = Float::INFINITY
-    DEFAULT_MAX_GRID_SCALE = 100
-    DEFAULT_MAX_GRID_BOUNDARY = 5
-    DEFAULT_DEPTH = Float::INFINITY
-    DEFAULT_COMPLEXITY_AMOUNT = 50.0
-    CONVERGENT_LIMIT = 10
-
-    extend Forwardable
-    def_delegators :@ratio, :antecedent, :consequent, :to_cents, :to_basic_ratio, :to_f
-
-    attr_reader :ratio
-
-    def initialize(ratio:)
-      raise ArgumentError, "Tonal::Ratio required" unless ratio.kind_of?(Tonal::Ratio)
-      @ratio = ratio
-    end
-
-    # @return [Array] of ratios within cent tolerance of self found using continued fraction approximation
-    # @example
-    #   Tonal::Ratio.ed(12,1).by_continued_fraction
-    #   => [(18/17), (196/185), (1657/1564), (7893/7450), (18904/17843), (3118/2943), (1461/1379), (89/84), (17/16)]
-    # @param cents_tolerance
-    # @param depth
-    # @param max_prime
-    # @param conv_limit
-    #
-    def by_continued_fraction(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, conv_limit: CONVERGENT_LIMIT)
-      self_in_cents = to_cents
-      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
-      [].tap do |results|
-        ContinuedFraction.new(antecedent.to_f/consequent, conv_limit).convergents.each do |convergent|
-          ratio2 = ratio.class.new(convergent.numerator,convergent.denominator)
-          results << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
-          break if results.length >= depth
-        end
-      end.sort
-    end
-
-    # @return [Array] of ratios within cent tolerance of self found using a quotient walk on the fraction tree
-    # @example
-    #   Tonal::Ratio.ed(12,1).by_quotient_walk(max_prime: 89)
-    #   => [(18/17), (196/185), (89/84), (71/67), (53/50), (35/33), (17/16)]
-    # @param cents_tolerance
-    # @param depth
-    # @param max_prime
-    #
-    def by_quotient_walk(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, conv_limit: CONVERGENT_LIMIT)
-      self_in_cents = to_cents
-      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
-
-      [].tap do |results|
-        FractionTree.quotient_walk(to_f, limit: conv_limit).each do |node|
-          ratio2 = ratio.class.new(node.weight)
-          results << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
-          break if results.length >= depth
-        end
-      end.sort
-    end
-
-    # @return [Array] of fraction tree ratios within cent tolerance of self
-    # @example
-    #   Tonal::Ratio.ed(12,1).by_tree_path(max_prime: 17)
-    #   => [(18/17), (35/33), (17/16)]
-    # @param cents_tolerance
-    # @param depth
-    # @param max_prime
-    #
-    def by_tree_path(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME)
-      self_in_cents = to_cents
-      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
-      [].tap do |results|
-        FractionTree.path_to(to_f).each do |node|
-          ratio2 = ratio.class.new(node.weight)
-          results << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
-          break if results.length >= depth
-        end
-      end.sort
-    end
-
-    # @return [Array] of ratios within cent tolerance of self found on the ratio grid
-    # @example
-    #   Tonal::Ratio.new(3,2).by_neighborhood(max_prime: 23, cents_tolerance: 5, max_boundary: 10, max_scale: 60)
-    #   => [(175/117), (176/117)]
-    # @param cents_tolerance the maximum cents self is allowed from grid ratios
-    # @param depth the maximum depth the array will get
-    # @param max_prime the maximum prime the grid ratios will contain
-    # @param max_boundary the maximum distance grid ratios will be from the scaled ratio
-    # @param max_scale the maximum self will be scaled
-    #
-    def by_neighborhood(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, max_boundary: DEFAULT_MAX_GRID_BOUNDARY, max_scale: DEFAULT_MAX_GRID_SCALE)
-      self_in_cents = to_cents
-      within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
-      [].tap do |results|
-        scale = 1
-        boundary = 1
-
-        while results.length <= depth && scale <= max_scale do
-          while boundary <= max_boundary
-            vacinity = ratio.respond_to?(:to_basic_ratio) ? to_basic_ratio.scale(scale) : ratio.scale(scale)
-            self.class.neighbors(away: boundary, vacinity: vacinity).each do |neighbor|
-              results << neighbor if ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && neighbor.within_prime?(max_prime)
-            end
-            boundary += 1
-          end
-          boundary = 1
-          scale += 1
-        end
-      end.uniq(&:to_r).reject{|r| r == ratio}.sort
-    end
-
-    # @return [Array] of bounding ratios in the ratio grid vacinity of antecedent/consequent scaled by scale
-    # @example
-    #   Tonal::ReducedRatio.new(3,2).neighborhood(scale: 256, boundary: 2)
-    #     => [(768/514), (766/512), (768/513), (767/512), (768/512), (769/512), (768/511), (770/512), (768/510)]
-    # @param scale [Integer] used to scale antecedent/consequent on coordinate system
-    # @param boundary [Integer] limit within which to calculate neighboring ratios
-    #
-    def neighborhood(scale: 2**0, boundary: 1)
-      scale = scale.round
-      vacinity = ratio.respond_to?(:to_basic_ratio) ? to_basic_ratio.scale(scale) : ratio.scale(scale)
-      SortedSet.new([].tap do |ratio_list|
-                      1.upto(boundary) do |away|
-                        ratio_list << self.class.neighbors(away: away, vacinity: vacinity)
-                      end
-                    end.flatten).to_a
-    end
-
-    # @return [Array] an array of Tonal::Ratio neighbors in the scaled ratio's grid neighborhood
-    # @example
-    #   Tonal::Ratio::Approximations.neighbors(vacinity: (3/2r).ratio(reduced:false).scale(256), away: 1)
-    #     => [(768/513), (767/512), (768/512), (769/512), (768/511)]
-    # @param away [Integer] the neighbors distance away from self's antecedent and consequent
-    #
-    def self.neighbors(vacinity:, away: 1)
-      [vacinity,
-       vacinity.class.new(vacinity.antecedent+away, vacinity.consequent),
-       vacinity.class.new(vacinity.antecedent-away, vacinity.consequent),
-       vacinity.class.new(vacinity.antecedent, vacinity.consequent+away),
-       vacinity.class.new(vacinity.antecedent, vacinity.consequent-away),
-       vacinity.class.new(vacinity.antecedent+away, vacinity.consequent+away),
-       vacinity.class.new(vacinity.antecedent+away, vacinity.consequent-away),
-       vacinity.class.new(vacinity.antecedent-away, vacinity.consequent+away),
-       vacinity.class.new(vacinity.antecedent-away, vacinity.consequent-away)]
-    end
-  end
-end