tonal-tools 7.7.0 → 8.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e36a8220009cf3f4982c50b114d288841da16f32e79baa8657f2e4a9f12c1ac8
-  data.tar.gz: 924bf36d40bf9c12049b2f0e5deab9650bb2ec6994316ac8c782e56dc275f965
+  metadata.gz: bc114e39cee0bcffd5b39e0e22cdc572ae7671d2ab5f5f7cfeccfe0015eb9e98
+  data.tar.gz: 4cb0a21f72168e3d7c9949642866498f85fde445a7f2cf3b5ad8022008f4c8b8
 SHA512:
-  metadata.gz: 41d3c29bc92a809485fb36aba2ebe4bd43a443d33ccaac337e305d815b8117787ab3802ffd824c5e157917f74fc36244f5644042d1081bbba85cd2b402a974dc
-  data.tar.gz: 144334ceb98fba4bd5e5d8fdbd211e31c1fa9da4af0342fb4ff9b3be117167acc1f388d0e971b13a6ae36590bc89a0ecf4a9b4ea793165fa731e2b934c2d777c
+  metadata.gz: c1558d6093e5b624e53e1ab474695d68d1b07338663c9dcf6752fd89760b9c5a4f7651b82298dda850cc79dcdca9697b99079ba37f81f607b5079ec0bce0ede2
+  data.tar.gz: 0f744bd6f5f153a2cd3e3ca6434ee5dae5c0da5b02e58eea2f3e89b4abee0af52e419afbe0b69bfa45cfe61e5c0c343f80f7235be426b80637cae4fed809fee0

data/lib/tonal/approximation.rb

@@ -1,10 +1,11 @@
 class Tonal::Ratio
   class Approximation
+    DEFAULT_MIN_PRIME = 2
     DEFAULT_MAX_PRIME = Float::INFINITY
     DEFAULT_MAX_GRID_SCALE = 100
     DEFAULT_MAX_GRID_BOUNDARY = 5
     DEFAULT_DEPTH = Float::INFINITY
-    DEFAULT_FRACTION_TREE_DEPTH = 10
+    DEFAULT_TREE_PATH_DEPTH = 10
     DEFAULT_SUPERPART_DEPTH = 20
     DEFAULT_NEIGHBORHOOD_DEPTH = 10
     DEFAULT_COMPLEXITY_AMOUNT = 50.0
@@ -23,19 +24,21 @@ class Tonal::Ratio
     # @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): [(17/16), (18/17), (89/84), (196/185), (1461/1379), (1657/1564), (3118/2943), (7893/7450), (18904/17843)]
+    #   => 1.06: [17/16, 18/17, 89/84, 196/185, 1461/1379, 1657/1564, 3118/2943, 7893/7450, 18904/17843]
     # @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 min_prime the minimum 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)
+    def by_continued_fraction(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_DEPTH, max_prime: DEFAULT_MAX_PRIME, min_prime: DEFAULT_MIN_PRIME, conv_limit: CONVERGENT_LIMIT)
+      return Set.new(ratio: ratio){|ratios| ratios << ratio} if (antecedent == 1) && (consequent == 1)
       self_in_cents = to_cents
       within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
       Set.new(ratio: ratio) do |ratios|
         ContinuedFraction.new(antecedent.to_f/consequent, conv_limit).convergents.each do |convergent|
           ratio2 = ratio.class.new(convergent.numerator,convergent.denominator)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.max_prime_within?(max_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2.max_prime <= max_prime) && (ratio2.min_prime >= min_prime)
           break if ratios.length >= depth
         end
       end
@@ -43,19 +46,22 @@ class Tonal::Ratio
 
     # @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): [(17/16), (18/17), (35/33)]
+    #   Tonal::Ratio.ed(12,1).approximate.by_tree_path
+    #   => 1.06: [17/16, 18/17, 35/33, 53/50, 71/67, 89/84, 107/101, 196/185, 285/269, 481/454]
     # @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 min_prime the minimum prime number to allow in the collection
     #
-    def by_tree_path(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_FRACTION_TREE_DEPTH, max_prime: DEFAULT_MAX_PRIME)
+    def by_tree_path(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_TREE_PATH_DEPTH, max_prime: DEFAULT_MAX_PRIME, min_prime: DEFAULT_MIN_PRIME)
+      return Set.new(ratio: ratio){|ratios| ratios << ratio} if (antecedent == 1) && (consequent == 1)
       self_in_cents = to_cents
       within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
       Set.new(ratio: ratio) do |ratios|
         FractionTree.node(to_f).path.each do |node|
+          next if node.number.infinite?
           ratio2 = ratio.class.new(node.number)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.max_prime_within?(max_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2.max_prime <= max_prime) && (ratio2.min_prime >= min_prime)
           break if ratios.length >= depth
         end
       end
@@ -64,20 +70,21 @@ class Tonal::Ratio
     # @return [Tonal::Ratio::Approximation::Set] of superparticular approximations within cent tolerance of self
     # @example
     #   Tonal::Ratio.new(3/2r).approximate.by_superparticular
-    #   => (3/2): [(1041/692), (1044/694), (1047/696), (1050/698), (1053/700), (1056/702), (1059/704), (1062/706), (1065/708), (1068/710), (1071/712), (1074/714), (1077/716), (1080/718), (1083/720), (1086/722), (1089/724), (1092/726), (1095/728), (1098/730)]
+    #   => 3/2: [1041/692, 1044/694, 1047/696, 1050/698, 1053/700, 1056/702, 1059/704, 1062/706, 1065/708, 1068/710, 1071/712, 1074/714, 1077/716, 1080/718, 1083/720, 1086/722, 1089/724, 1092/726, 1095/728, 1098/730]
     # @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 min_prime the minimum 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: DEFAULT_SUPERPART_DEPTH, max_prime: DEFAULT_MAX_PRIME, superpart: :upper)
+    def by_superparticular(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_SUPERPART_DEPTH, max_prime: DEFAULT_MAX_PRIME, min_prime: DEFAULT_MIN_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) do |ratios|
         n = 1
         while true do
           ratio2 = ratio.class.superparticular(n, factor: ratio.to_r, superpart:)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.max_prime_within?(max_prime) && ratio2 != ratio
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2 != ratio) && (ratio2.max_prime <= max_prime) && (ratio2.min_prime <= min_prime)
           break if ratios.length >= depth
           n += 1
         end
@@ -86,15 +93,16 @@ class Tonal::Ratio
 
     # @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)]
+    #   Tonal::Ratio.new(3,2).approximate.by_neighborhood
+    #   => 3/2: [175/117, 178/119, 176/117, 181/121, 179/119, 184/123, 182/121, 187/125, 185/123, 190/127, 188/125]
     # @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 min_prime the minimum 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_NEIGHBORHOOD_DEPTH, max_prime: DEFAULT_MAX_PRIME, max_boundary: DEFAULT_MAX_GRID_BOUNDARY, max_scale: DEFAULT_MAX_GRID_SCALE)
+    def by_neighborhood(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_NEIGHBORHOOD_DEPTH, max_prime: DEFAULT_MAX_PRIME, min_prime: DEFAULT_MIN_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) do |ratios|
@@ -105,7 +113,7 @@ class Tonal::Ratio
           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|
-              ratios << neighbor if ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && neighbor.max_prime_within?(max_prime) && neighbor != ratio
+              ratios << neighbor if (neighbor != ratio) && ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && (neighbor.max_prime <= max_prime) && (neighbor.min_prime >= min_prime)
             end
             boundary += 1
           end
@@ -118,7 +126,7 @@ class Tonal::Ratio
     # @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)]
+    #     => [766/514, 768/514, 767/513, 766/512, 768/513, 767/512, 770/514, 769/513, 768/512, 767/511, 769/512, 766/510, 768/511, 770/512, 769/511, 768/510, 770/510]
     # @param scale [Integer] used to scale antecedent/consequent on coordinate system
     # @param boundary [Integer] limit within which to calculate neighboring ratios
     #
@@ -126,16 +134,16 @@ class Tonal::Ratio
       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
+                         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)]
+    #     => [768/512, 769/512, 767/512, 768/513, 768/511, 769/513, 769/511, 767/513, 767/511]
     # @param away [Integer] the neighbors distance away from self's antecedent and consequent
     #
     def self.neighbors(vacinity:, away: 1)
@@ -149,10 +157,9 @@ class Tonal::Ratio
        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, :find_index, :to_a
+      def_delegators :@ratios, :count, :length, :min, :max, :entries, :all?, :any?, :reject, :map, :find_index, :to_a, :include?
 
       attr_reader :ratios, :ratio
 
@@ -167,6 +174,26 @@ class Tonal::Ratio
         "#{ratio}: #{entries}"
       end
 
+      def to_cents
+        entries.map(&:to_cents)
+      end
+
+      def max_primes
+        entries.map(&:max_prime)
+      end
+
+      def min_primes
+        entries.map(&:min_prime)
+      end
+
+      def prime_divisions
+        entries.map(&:prime_divisions)
+      end
+
+      def [](index)
+        entries[index]
+      end
+
       def sort_by(&)
         self.class.new(ratio: ratio) do |ratios|
           entries.sort_by(&).each do |ratio|

data/lib/tonal/attributions.rb

@@ -1,4 +1,4 @@
 module Tonal
   TOOLS_PRODUCER = "mTonal"
-  TOOLS_VERSION = "7.7.0"
+  TOOLS_VERSION = "8.3.1"
 end

data/lib/tonal/cents.rb

@@ -95,7 +95,44 @@ class Tonal::Cents
   end
   alias :to_s :inspect
 
+  # Operator overloads
   #
+  # @return [Tonal::Cents, Numeric] result of operation
+  # @example
+  #   Tonal::Cents.new(cents: 200) - Tonal::Cents.new(cents: 100) => 100.0
+  # @param rhs [Tonal::Cents, Numeric]
+  #
+  def -(rhs)
+    method_missing(:-, rhs)
+  end
+
+  # @return [Tonal::Cents, Numeric] result of operation
+  # @example
+  #   Tonal::Cents.new(cents: 100) + Tonal::Cents.new(cents: 200) => 300.0
+  # @param rhs [Tonal::Cents, Numeric]
+  #
+  def +(rhs)
+    method_missing(:+, rhs)
+  end
+
+  # @return [Tonal::Cents, Numeric] result of operation
+  # @example
+  #  Tonal::Cents.new(cents: 200) * 2 => 400.0
+  # @param rhs [Tonal::Cents, Numeric]
+  #
+  def *(rhs)
+    method_missing(:*, rhs)
+  end
+
+  # @return [Tonal::Cents, Numeric] result of operation
+  # @example
+  #   Tonal::Cents.new(cents: 400) / 2 => 200.0
+  # @param rhs [Tonal::Cents, Numeric]
+  #
+  def /(rhs)
+    method_missing(:/, rhs)
+  end
+
   # Challenges to comparing floats
   # https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/FloatComparison
   # https://embeddeduse.com/2019/08/26/qt-compare-two-floats/

data/lib/tonal/extensions.rb

@@ -45,15 +45,15 @@ class Numeric
   # @param reduced
   # @param equave
   #
-  def to_ratio(reduced: false, equave: 2/1r) = reduced ? Tonal::ReducedRatio.new(self, equave: equave) : Tonal::Ratio.new(self, equave: equave)
+  def to_ratio(reduced: false, equave: 2/1r) = reduced ? Tonal::ReducedRatio.new(self, equave:) : Tonal::Ratio.new(self, equave:)
   alias :ratio :to_ratio
 
   # @return [Tonal::ReducedRatio]
   # @example
-  #   {4/5r}.to_reduced_ratio => 8/5
+  #   (4/5r).to_reduced_ratio => 8/5
   # @param equave
   #
-  def to_reduced_ratio(equave: 2/1r) = to_ratio(reduced: true, equave: equave)
+  def to_reduced_ratio(equave: 2/1r) = to_ratio(reduced: true, equave:)
 
   # @return [Float], the degrees on a circle of self
   # @example
@@ -63,9 +63,10 @@ class Numeric
 
   # @return [Tonal::Log] the log of self to the given base
   # @example
-  #   (3/2r).log(10) => 0.17609125905568124
+  #   (3/2r).log(10) => 0.18
   #
-  def log(base) = Tonal::Log.new(logarithmand: self, base: base)
+  def log(base) = Tonal::Log.new(logarithmand: self, base:)
+  alias :to_log :log
 
   # @return [Tonal::Log2] the log2 of self
   # @example
@@ -94,16 +95,18 @@ class Numeric
   def to_cents = Tonal::Cents.new(ratio: self)
 
   # @return [Tonal::Hertz] of self
+  # @example
+  #  (440.0).hz => 440.0 Hz
   #
   def hz = Tonal::Hertz.new(self)
   alias :to_hz :hz
 
-  # @return [Tonal::Step] the step of self in the given modulo
+  # @return [Tonal::Scale::Step] the step of self in the given modulo
   # @example
   #   (5/4r).scale_step(12) => 4\12
   # @param modulo
   #
-  def scale_step(modulo=12) = Tonal::Step.new(ratio: self, modulo: modulo)
+  def scale_step(modulo=12) = Tonal::Scale::Step.new(ratio: self, modulo:)
 
   # @return [Float] the log product complexity of self
   # @example
@@ -137,22 +140,25 @@ class Numeric
   # @param equave
   # @param prime_rejects
   #
-  def wilson_height(reduced: false, equave: 2/1r, prime_rejects: [2]) = ratio(reduced: reduced, equave: equave).wilson_height(prime_rejects: prime_rejects)
+  def wilson_height(reduced: false, equave: 2/1r, prime_rejects: [2]) = ratio(reduced:, equave:).wilson_height(prime_rejects:)
 
   # @return [Float] the cents difference between self and its step in the given modulo
   # @example
   #   (3/2r).efficiency(12) => -1.96
   # @param modulo
+  # @param reduced
   #
-  # We want the efficiency from the ratio (self)
-  def efficiency(modulo, reduced: false) = ratio(reduced: reduced).efficiency(modulo)
+  def efficiency(modulo, reduced: false) = ratio(reduced:).efficiency(modulo)
 
   # @return [Tonal::Interval] beween self (upper) and ratio (lower)
   # @example
-  #   (133).interval_with(3/2r) => 133/96 (133/128 / 3/2)
-  # @param other_ratio
+  #   (3/2r).interval_with(4/3r) => 9/8 (3/2 / 4/3)
+  # @example
+  #   (3/2r).interval_with(4/3r, is_lower: false) => 16/9 (4/3 / 3/2)
+  # @param other_ratio the other ratio to form the interval with
+  # @param is_lower [Boolean] if other_ratio is the lower (true) or upper (false) ratio
   #
-  def interval_with(other_ratio) = Tonal::Interval.new(ratio, other_ratio)
+  def interval_with(other_ratio, is_lower: true) = Tonal::Ratio.new(self).interval_with(other_ratio, is_lower:)
 
   # @return [Tonal::Interval] between 1/1 (lower) and self (upper)
   # @example
@@ -162,8 +168,7 @@ class Numeric
 
   # @return [Tonal::Cents] difference between ratio (upper) and self (lower)
   # @example
-  #   (133).cents_difference_with(3/2r)
-  #   => 635.62
+  #   (133).cents_difference_with(3/2r) => 635.62
   # @param other_ratio
   #
   def cents_difference_with(other_ratio) = interval_with(other_ratio).to_cents
@@ -173,7 +178,7 @@ class Numeric
   #   (3/2r).prime_vector => Vector[-1, 1]
   # @param reduced
   #
-  def prime_vector(reduced: false) = ratio(reduced: reduced).prime_vector
+  def prime_vector(reduced: false) = ratio(reduced:).prime_vector
   alias :monzo :prime_vector
   alias :prime_exponent_vector :prime_vector
 
@@ -226,21 +231,30 @@ class Numeric
   # @example
   #   (3/2r).reciprocal => (2/3)
   #
-  def reciprocal = Rational(1,self)
+  def reciprocal = Rational(1, self)
 
   # @return [Numeric] self raised to the given power/root
   # @example
-  #   (3/2r).pr(3,2) => 1.8371173070873836
-  # @param power
-  # @param root
+  #   (3/2r).power(3,2) => 1.8371173070873832
+  # @param p the power
+  # @param r the root
   #
-  def pr(power, root=nil)
-    if root
-      self**(Rational(power, root))
+  def power(p, r=nil)
+    if r
+      (self.root(r))**p
     else
-      self**power
+      self**p
     end
   end
+
+  # @return [Numeric] self raised to the given root
+  # @example
+  #   (3/2r).root(2) => 1.224744871391589
+  # @param r the root
+  #
+  def root(r)
+    self**Rational(1, r)
+  end
 end
 
 class Integer
@@ -248,10 +262,11 @@ class Integer
 
   # @return [Tonal::ReducedRatio] the ratio 2**(self/modulo)
   # @example
-  #   1.edo(12) => 1.06
+  #   1.ed(12) => 1.06
   # @param modulo
+  # @param equave
   #
-  def edo(modulo) = (2**(Rational(self,modulo))).to_reduced_ratio
+  def ed(modulo, equave: 2/1r) = Tonal::ReducedRatio.ed(self, modulo, equave:)
 
   # @return [Integer] the maximum prime factor of self
   # @example
@@ -548,7 +563,7 @@ class Vector
   # @param reduced
   # @param equave
   #
-  def to_ratio(reduced: false, equave: 2/1r) = reduced ? Tonal::ReducedRatio.new(*self, equave: equave) : Tonal::Ratio.new(*self, equave: equave)
+  def to_ratio(reduced: false, equave: 2/1r) = reduced ? Tonal::ReducedRatio.new(*self, equave:) : Tonal::Ratio.new(*self, equave:)
   alias :ratio :to_ratio
 end
 

data/lib/tonal/hertz.rb

@@ -5,7 +5,7 @@ class Tonal::Hertz
 
   # @return [Tonal::Hertz]
   # @example
-  #   Tonal::Hertz.new(1000.0) => 1000.0
+  #   Tonal::Hertz.new(1000.0) => 1000.0 Hz
   # @param arg [Numeric, Tonal::Hertz]
   #
   def initialize(arg)
@@ -15,7 +15,7 @@ class Tonal::Hertz
 
   # @return [Tonal::Hertz] 440 Hz
   # @example
-  #   Tonal::Hertz.a440 => 440.0
+  #   Tonal::Hertz.a440 => 440.0 Hz
   #
   def self.a440
     self.new(440.0)
@@ -40,10 +40,10 @@ class Tonal::Hertz
 
   # @return [String] the string representation of Tonal::Hertz
   # @example
-  #   Tonal::Hertz(1000.0).inspect => "1000.0"
+  #   Tonal::Hertz(1000.0).inspect => "1000.0 Hz"
   #
   def inspect
-    "#{value}"
+    "#{value} Hz"
   end
 
   def <=>(rhs)

data/lib/tonal/interval.rb

@@ -2,61 +2,112 @@ class Tonal::Interval
   extend Forwardable
   include Comparable
 
-  def_delegators :@interval, :to_r, :antecedent, :consequent, :to_cents
+  def_delegators :@intervalic_ratio, :to_r, :antecedent, :consequent, :to_cents
 
-  attr_reader :lower_ratio, :upper_ratio, :interval
+  attr_reader :lower_ratio, :upper_ratio, :intervalic_ratio
 
   INTERVAL_OF_EQUIVALENCE = 2/1r
 
   # @return [Tonal::Interval] the interval of the given ratios
   # @example
-  #   Tonal::Interval.new(2,3) => (3/2) ((3/2) / (1/1))
+  #   Tonal::Interval.new(5) => 5/4 (5/4 / 1/1)
   # @example
-  #   Tonal::Interval.new(2,3,3,4) => (9/8) ((3/2) / (4/3))
+  #   Tonal::Interval.new(3/2r, 5/4r) => 6/5 (3/2 / 5/4)
   # @example
-  #   Tonal::Interval.new(3) => (3/1) ((3/1) / (1/1))
-  # @param args two arguments representing ratios or four arguments representing two pairs of numerator/denominator
+  #   Tonal::Interval.new(3,2,4,3) => 9/8 (3/2 / 4/3)
+  # @param args one argument representing a ratio, with 1/1r implied, or two arguments representing lower and upper ratios, or four arguments representing two numerator/denominator pairs for the lower and upper ratios
   # @param reduced boolean determining whether to use Tonal::ReducedRatio or Tonal::Ratio
   #
   def initialize(*args, reduced: true)
-    args = [1/1r, args[0]] if args.length == 1
+    raise(ArgumentError, "One, two or four arguments required. Either one ratio (the other defaulting to 1/1), two ratios, or two pairs of numerator, denominator", caller[0]) unless [1, 2, 4].include?(args.size)
+    args = [args[0],1/1r] if args.length == 1
     klass = reduced ? Tonal::ReducedRatio : Tonal::Ratio
-    raise(ArgumentError, "Two or four arguments required. Either two ratios, or two pairs of numerator, denominator", caller[0]) unless [2, 4].include?(args.size)
     @lower_ratio, @upper_ratio = case args.size
                                  when 2
-                                   [klass.new(args[0].antecedent, args[0].consequent), klass.new(args[1].antecedent, args[1].consequent)]
+                                   [klass.new(args[1].antecedent, args[1].consequent), klass.new(args[0].antecedent, args[0].consequent)]
                                  when 4
-                                   [klass.new(args[0],args[1]), klass.new(args[2], args[3])]
+                                   [klass.new(args[2], args[3]), klass.new(args[0], args[1])]
                                  end
-    @interval = @upper_ratio / @lower_ratio
+    @intervalic_ratio = @upper_ratio / @lower_ratio
   end
-  alias :ratio :interval
-  alias :lower :lower_ratio
-  alias :upper :upper_ratio
   alias :numerator :antecedent
   alias :denominator :consequent
 
+  # @return [Array<Tonal::Ratio>] the upper and lower ratios as an array
+  # @example
+  #   interval = Tonal::Interval.new(3,2) => 3/2 (3/2 / 1/1)
+  #   interval.to_a => [3/2, 1/1]
+  #
   def to_a
-    [lower_ratio, upper_ratio]
+    [upper_ratio, lower_ratio]
   end
 
+  # @return [Array<Tonal::Ratio>] the ratios with common denominators
+  # @example
+  #   interval = Tonal::Interval.new(3,4) => 4/3 (4/3 / 1/1)
+  #   interval.denominize => [3/2, 2/2]
+  #
   def denominize
     ratios = to_a
     lcm = ratios.denominators.lcm
     ratios.map{|r| Tonal::Ratio.new(lcm / r.denominator * r.numerator, lcm)}
   end
 
+  # @return [Tonal::Interval] the interval representing the root of self raised to a power
+  # @example
+  #   interval = Tonal::Interval.new(4/3r) => 4/3 (4/3 / 1/1)
+  #   interval.root_interval(power: 1, root: 2) => 1.15 (1.15 / 1/1)
+  # @param power [Integer] the power to which the root is raised
+  # @param root [Integer] the root to be taken
+  # @param approximant [Integer, nil] the index of the approximant to use
+  # @param by_method [Symbol] the method to use for approximation (:continued_fraction or :tree_path)
+  # @param from [Symbol] whether to return the interval calculated from the lower or upper ratio (:lower_ratio or :upper_ratio) of the interval
+  #
+  def root_interval(power: 1, root: 2, approximant: nil, by_method: :continued_fraction, from: :lower_ratio)
+    root_ratio = intervalic_ratio.class.new(intervalic_ratio.to_r.power(power, root))
+    resulting_ratio = approximant.nil? ? root_ratio : _approximate(root_ratio, by_method, approximant)
+    _returning_interval(resulting_ratio, from:)
+  end
+
+  # @return [Tonal::Interval] the interval selected by the approximant key, from a set of approximations generated by the by_method algorithm
+  # @example
+  #   interval = Tonal::Interval.new(1.2) => 1.2 (1.2 / 1/1)
+  #   interval.approximate => 6/5 (6/5 / 1/1)
+  # @param approximant [Integer] the index of the approximant to use
+  # @param by_method [Symbol] the method to use for approximation (:continued_fraction or :tree_path)
+  # @param from [Symbol] whether to return the interval calculated from the lower or upper ratio (:lower_ratio or :upper_ratio) of the interval
+  #
+  def approximate(approximant=0, by_method: :continued_fraction, from: :lower_ratio)
+    _returning_interval(_approximate(intervalic_ratio, by_method, approximant), from:)
+  end
+
+  # @return [String] a string representation of the interval
+  # @example
+  #   interval = Tonal::Interval.new(4,3) => 4/3 (4/3 / 1/1)
+  #   interval.inspect => "4/3 (4/3 / 1/1)"
+  #
   def inspect
-    "#{interval.label} (#{upper.label} / #{lower.label})"
+    "#{intervalic_ratio.label} (#{upper_ratio.label} / #{lower_ratio.label})"
   end
 
+  # @return [Integer] -1, 0, or 1 depending on whether this interval is less than, equal to, or greater than the other interval
+  # @example
+  #   interval1 = Tonal::Interval.new(4,3) => 4/3 (4/3 / 1/1)
+  #   interval2 = Tonal::Interval.new(3,2) => 3/2 (3/2 / 1/1)
+  #   interval1 <=> interval2 => -1
+  #
   def <=>(rhs)
-    interval.to_r <=> rhs.interval.to_r
+    intervalic_ratio.to_r <=> rhs.intervalic_ratio.to_r
+  end
+
+  private
+  def _returning_interval(resulting_ratio, from:)
+    from = [:lower_ratio, :upper_ratio].include?(from) ? from : :lower_ratio
+    from == :lower_ratio ? Tonal::Interval.new(resulting_ratio, lower_ratio) : Tonal::Interval.new(upper_ratio, resulting_ratio)
   end
-end
 
-module Interval
-  def self.[](l, u, reduced=true)
-    Tonal::Interval.new(l, u, reduced:)
+  def _approximate(ratio, by_method, approximant)
+    by_method = [:continued_fraction, :tree_path].include?(by_method) ? "by_#{by_method}".to_sym : :by_continued_fraction
+    ratio.approximate.send(by_method)[approximant]
   end
 end

data/lib/tonal/irb_helpers.rb

@@ -2,31 +2,33 @@ module Tonal
   module IRBHelpers
     # @return [Tonal::Ratio] an unreduced ratio
     # @example
-    #   r(3,3) => (3/3)
-    # @param arg1 the ratio if only argument provided, or the numerator if two argments are provided
-    # @param arg2 the denominator when two arguments are provided
+    #   r(3,3) => 3/3
+    # @example
+    #   r.ed(12,2) => 1.12
+    # @param args the ratio if only argument provided, or the numerator and denominator if two arguments are provided
     #
-    def r(arg1, arg2=nil)
-      Tonal::Ratio.new(arg1, arg2)
+    def r(*args)
+      args.empty? ? Tonal::Ratio : Tonal::Ratio.new(*args)
     end
 
     # @return [Tonal::ReducedRatio] a reduced ratio
     # @example
-    #   rr(3,3) => (1/1)
-    # @param arg1 the ratio if only argument provided, or the numerator if two argments are provided
-    # @param arg2 the denominator when two arguments are provided
+    #   rr(3,3) => 1/1
+    # @example
+    #   rr.ed(12,2) => 1.12
+    # @param args the ratio if only argument provided, or the numerator and denominator if two arguments are provided
     #
-    def rr(arg1, arg2=nil)
-      Tonal::ReducedRatio.new(arg1, arg2)
+    def rr(*args)
+      args.empty? ? Tonal::ReducedRatio : Tonal::ReducedRatio.new(*args)
     end
 
     # @return [Tonal::Interval] the interval between the given args
     # @example
-    #   i(2,3) => (3/2) ((3/2) / (1/1))
+    #   i(3,2) => 3/2 (3/2 / 1/1)
     # @example
-    #  i(2,3,3,4) => (9/8) ((3/2) / (4/3))
+    #  i(3,2,4,3) => 9/8 (3/2 / 4/3)
     # @example
-    #   i(3) => (3/1) ((3/1) / (1/1))
+    #   i(3) => 3/2 (3/2 / 1/1)
     # @param args two arguments representing ratios or four arguments representing two pairs of numerator/denominator
     # @param reduced boolean determining whether to use Tonal::ReducedRatio or Tonal::Ratio
     #

data/lib/tonal/log.rb

@@ -61,12 +61,12 @@ class Tonal::Log
     Tonal::Cents.new(log: self, precision: precision)
   end
 
-  # @return [Tonal::Step] the nearest step in the given modulo
+  # @return [Tonal::Scale::Step] the nearest step in the given modulo
   # @example
   #   Tonal::Log.new(logarithmand: 3/2r, base: 2).step(12) => 7\12
   #
   def step(modulo)
-    Tonal::Step.new(modulo: modulo, log: self)
+    Tonal::Scale::Step.new(modulo: modulo, log: self)
   end
 
   # @return [String] the string representation of Tonal::Log
@@ -115,4 +115,3 @@ class Tonal::Log
     end
   end
 end
-