tonal-tools 5.3.0 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf75078baac2ea863202aca76b6c00ab636971096fc676982dcb0114376bca8d
-  data.tar.gz: 85b5550ccf29103f87416eea33f8a01c865730eecb4396e482e659ead1e5bf9e
+  metadata.gz: 50cbd332f2e7aeb3da776868cd3bd27cd3fd4f25146de194781fa1f8032a3e93
+  data.tar.gz: 3cddb6f9f59e814afface6e739597653442b13f402bf5839784decff633b4662
 SHA512:
-  metadata.gz: aac11d2e96bda93047dea33f9e79be30f6db228b2fe4c01813544498740e21d82959a3678d0502ec9ee54e055fd96093d9135b244e37e9847de001ccb5a6a7ed
-  data.tar.gz: 1d71ebff05b9d1e83b0dc90f4968c4ffbc9ebc51f0d931e0627588a2ad4262fcf1c63413a519450367b46eafa9f48b65cb2d38373a43fc23be49b4bbfbb5447d
+  metadata.gz: 425f07aa55d053031df5bb092495ab88a82741964b3f56295868873b4a96e773ca0af9005352bdb289331d090331c8cb75c05aada7573db858b453002153a1fc
+  data.tar.gz: bb7871f1f9dcdcef36de328f9f839d50c9e9ceba6918b0d6bbd335a85803760461fb4a37a203149a3f7e629d53fcb3f80c56b1bd97d6249a781a0c433fd1ef23

data/lib/tonal/approximation.rb

@@ -35,7 +35,7 @@ class Tonal::Ratio
       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.within_prime?(max_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.max_prime_within?(max_prime)
           break if ratios.length >= depth
         end
       end
@@ -55,7 +55,7 @@ class Tonal::Ratio
       Set.new(ratio: ratio) do |ratios|
         FractionTree.node(to_f).path.each do |node|
           ratio2 = ratio.class.new(node.number)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.within_prime?(max_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.max_prime_within?(max_prime)
           break if ratios.length >= depth
         end
       end
@@ -77,7 +77,7 @@ class Tonal::Ratio
         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.within_prime?(max_prime) && ratio2 != ratio
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && ratio2.max_prime_within?(max_prime) && ratio2 != ratio
           break if ratios.length >= depth
           n += 1
         end
@@ -105,7 +105,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.within_prime?(max_prime) && neighbor != ratio
+              ratios << neighbor if ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && neighbor.max_prime_within?(max_prime) && neighbor != ratio
             end
             boundary += 1
           end

data/lib/tonal/attributions.rb

@@ -1,4 +1,4 @@
 module Tonal
   TOOLS_PRODUCER = "mTonal"
-  TOOLS_VERSION = "5.3.0"
+  TOOLS_VERSION = "6.1.1"
 end

data/lib/tonal/cents.rb

@@ -70,7 +70,7 @@ class Tonal::Cents
   # @return
   #   [Tonal::Cents] nearest hundredth cent difference
   # @example
-  #   Tonal::Cents.new(701.9550008653874).nearest_hundredth_difference => 1.955000865387433
+  #   Tonal::Cents.new(cents: 701.9550008653874).nearest_hundredth_difference => 1.96
   #
   def nearest_hundredth_difference
     self.class.new(cents: (value - nearest_hundredth))
@@ -108,7 +108,7 @@ class Tonal::Cents
   def derive_log(cents: nil, ratio: nil, log: nil)
     return Tonal::Log2.new(logarithm: cents / CENT_SCALE) if cents
     return Tonal::Log2.new(logarithmand: ratio) if ratio
-    log.kind_of?(Tonal::Log2) ? log : Tonal::Log2.new(logarithm: log)
+    log.kind_of?(Tonal::Log) ? log : Tonal::Log2.new(logarithm: log)
   end
 
   def derive_ratio(log: nil, ratio: nil)

data/lib/tonal/extensions.rb

@@ -9,6 +9,9 @@ class Prime
 end
 
 class Numeric
+  alias :antecedent :numerator
+  alias :consequent :denominator
+
   # @return [Numeric] translated modularly
   # @example
   #   Math::PI.modulo_translate(-3, 3) => -2.858407346410207
@@ -102,7 +105,7 @@ class Numeric
 
   # @return [Integer] the product complexity of self
   # @example
-  #   (3/2r).tenney_height => 2.584962500721156
+  #   (3/2r).tenney_height => 2.58
   #
   def tenney_height = self.ratio.tenney_height
   alias :log_product_complexity :tenney_height
@@ -115,7 +118,7 @@ class Numeric
 
   # @return [Tonal::Log2] the log of Weil height
   # @example
-  #   (3/2r).log_weil_height => 1.5849625007211563
+  #   (3/2r).log_weil_height => 1.58
   #
   def log_weil_height = self.ratio.log_weil_height
 
@@ -126,10 +129,11 @@ class Numeric
 
   # @return [Float] the cents difference between self and its step in the given modulo
   # @example
-  #   (3/2r).efficiency(12) => -1.955000865387433
+  #   (3/2r).efficiency(12) => -1.96
   # @param modulo
   #
-  def efficiency(modulo) = (Tonal::Cents::CENT_SCALE * step(modulo).step / modulo.to_f) - to_cents
+  # We want the efficiency from the ratio (self)
+  def efficiency(modulo) = to_ratio.efficiency(modulo)
 
   # @return [Tonal::Interval] beween self (upper) and ratio (lower)
   # @example
@@ -240,11 +244,11 @@ class Integer
   alias :totient :phi
 
   # @return [Array] of integers that are n-smooth with self
-  #   Adapted from https://rosettacode.org/wiki/N-smooth_numbers#Ruby
   # @example
   #   5.nsmooth(25)
   #   => [1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27, 30, 32, 36, 40, 45, 48, 50, 54]
   # @param limit
+  # @note Adapted from https://rosettacode.org/wiki/N-smooth_numbers#Ruby
   #
   def nsmooth(limit=2)
     ([0] * limit).tap do |ns|
@@ -267,6 +271,11 @@ class Integer
 end
 
 class Array
+  alias :numerator :first
+  alias :denominator :last
+  alias :antecedent :first
+  alias :consequent :last
+
   # @return [Array] self replaced by array padded to the right up to n, with value. value default is nil
   # @example
   #   [3,2].rpad!(3, 12) => [3, 2, 12]
@@ -379,6 +388,12 @@ class Array
       (value - lower) % range + lower
     end
   end
+
+  # @return [Rational] from first and last element of array. Ideally to be used with tuples.
+  # @example
+  #   [4,3].to_r => (4/3)
+  #
+  def to_r = Rational(numerator, denominator)
 end
 
 class Vector

data/lib/tonal/interval.rb

@@ -8,9 +8,21 @@ class Tonal::Interval
 
   INTERVAL_OF_EQUIVALENCE = 2/1r
 
-  def initialize(upper_ratio, lower_ratio)
-    @lower_ratio = lower_ratio.ratio
-    @upper_ratio = upper_ratio.ratio
+  # @return [Tonal::Interval] the interval of the given ratios
+  # @example
+  #   Tonal::Interval.new(2,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
+  #
+  def initialize(*args, reduced: true)
+    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)]
+                                 when 4
+                                   [klass.new(args[0],args[1]), klass.new(args[2], args[3])]
+                                 end
     @interval = @upper_ratio / @lower_ratio
   end
   alias :ratio :interval
@@ -30,10 +42,16 @@ class Tonal::Interval
   end
 
   def inspect
-    "#{self.to_r} (#{upper.to_r} / #{lower.to_r})"
+    "#{interval} (#{upper} / #{lower})"
   end
 
   def <=>(rhs)
     interval.to_r <=> rhs.interval.to_r
   end
 end
+
+module Interval
+  def self.[](l, u, reduced=true)
+    Tonal::Interval.new(l, u, reduced:)
+  end
+end

data/lib/tonal/irb_helpers.rb

@@ -0,0 +1,45 @@
+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
+    #
+    def r(arg1, arg2=nil)
+      Tonal::Ratio.new(arg1, arg2)
+    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
+    #
+    def rr(arg1, arg2=nil)
+      Tonal::ReducedRatio.new(arg1, arg2)
+    end
+
+    # @return [Tonal::Interval] the interval between the given args
+    # @example
+    #   i(2,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
+    #
+    def i(*args, reduced: true)
+      Tonal::Interval.new(*args, reduced:)
+    end
+  end
+
+  # @note
+  #   Intended for activation from +~/.irbrc+, by placing: +ENV["MTONAL_IRB_HELPERS" ] = "1"+, in the file
+  #
+  #   Invoking this command from the IRB will add the helper methods: +r+, +rr+, +i+ in +main+.
+  #   These methods represent {Tonal::Ratio}, {Tonal::ReducedRatio} and {Tonal::Interval} respectively.
+  #
+  # @see Tonal::IRBHelpers
+  #
+  def self.include_irb_helpers
+    Object.include(IRBHelpers)
+  end
+end

data/lib/tonal/log.rb

@@ -4,6 +4,8 @@ class Tonal::Log
 
   def_delegators :@logarithmand, :ratio, :to_ratio
 
+  PRECISION = 2
+
   attr_reader :logarithmand, :logarithm, :base
 
   # @return [Tonal::Log]
@@ -52,7 +54,7 @@ class Tonal::Log
 
   # @return [Tonal::Cents] the cents scale logarithm
   # @example
-  #   Tonal::Log.new(logarithmand: 3/2r, base: 2).to_cents => 701.9550008653874
+  #   Tonal::Log.new(logarithmand: 3/2r, base: 2).to_cents => 701.96
   # @see Tonal::Cents
   #
   def to_cents(precision: Tonal::Cents::PRECISION)
@@ -61,7 +63,7 @@ class Tonal::Log
 
   # @return [Tonal::Step] the nearest step in the given modulo
   # @example
-  #   Tonal::Log.new(3/2r, base: 2).step(12) => 7\12
+  #   Tonal::Log.new(logarithmand: 3/2r, base: 2).step(12) => 7\12
   #
   def step(modulo)
     Tonal::Step.new(modulo: modulo, log: self)
@@ -69,10 +71,10 @@ class Tonal::Log
 
   # @return [String] the string representation of Tonal::Log
   # @example
-  #   Tonal::Log.new(3/2r, base: 2).inspect => "0.5849625007211562"
+  #   Tonal::Log.new(logarithmand: 3/2r, base: 2).inspect => "0.58"
   #
   def inspect
-    "#{logarithm}"
+    "#{logarithm.round(PRECISION)}"
   end
 
   def <=>(rhs)

data/lib/tonal/ratio.rb

@@ -4,6 +4,8 @@ class Tonal::Ratio
 
   def_delegators :@approximation, :neighborhood
 
+  PRECISION = 2
+
   attr_reader :antecedent, :consequent, :equave, :reduced_antecedent, :reduced_consequent
 
   # @return [Tonal::Ratio]
@@ -81,7 +83,7 @@ class Tonal::Ratio
 
   # @return [Boolean] if pair of ratios are within the given cents limit
   # @example
-  #   Tonal::Ratio.within_cents?(100, 105, 2) => true
+  #   Tonal::Ratio.within_cents?(100, 105, 2) => false
   # @param cents1
   # @param cents2
   # @param within
@@ -141,7 +143,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Log] Math.log of self in given base
   # @example
-  #   Tonal::Ratio.new(3,2).log(3) => 0.3690702464285425
+  #   Tonal::Ratio.new(3,2).log(3) => 0.37
   # @param base
   #
   def to_log(base=2)
@@ -151,7 +153,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Log2] Math.log2 of self
   # @example
-  #   Tonal::ReducedRatio.new(3,2).to_log2 => 0.5849625007211562
+  #   Tonal::ReducedRatio.new(3,2).to_log2 => 0.58
   #
   def to_log2
     Tonal::Log2.new(logarithmand: to_r)
@@ -169,7 +171,7 @@ class Tonal::Ratio
 
   # @return [Integer] the step of self in the given modulo
   # @example
-  #   Tonal::ReducedRatio.new(3,2).step(12) => 7
+  #   Tonal::ReducedRatio.new(3,2).step(12) => 7\12
   #
   def step(modulo=12)
     Tonal::Step.new(ratio: to_r, modulo: modulo)
@@ -180,7 +182,7 @@ class Tonal::Ratio
   #   Tonal::Ratio.new(3,2).period_degrees => 210.59
   # @param round
   #
-  def period_degrees(round: 2)
+  def period_degrees(round: PRECISION)
     (360.0 * Math.log(to_f, equave)).round(round)
   end
 
@@ -189,7 +191,7 @@ class Tonal::Ratio
   #   Tonal::Ratio.new(3,2).period_radians => 3.68
   # @param round
   #
-  def period_radians(round: 2)
+  def period_radians(round: PRECISION)
     (2 * Math::PI * Math.log(to_f, equave)).round(round)
   end
 
@@ -254,7 +256,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] the mirror of self along the axis (default 1/1)
   # @example
-  #   Tonal::Ratio.new(4,3).mirror => (3/2)
+  #   Tonal::ReducedRatio.new(4,3).mirror => (3/2)
   # @param axis
   #
   def mirror(axis=1/1r)
@@ -299,7 +301,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] self sheared by given arguments
   # @example
-  #   Tonal::Ratio.new(3,2).shear(1, 3) => (9/11)
+  #   Tonal::Ratio.new(3,2).shear(1, 3) => (14/11)
   # @param a [Numeric]
   # @param b [Numeric]
   #
@@ -313,7 +315,7 @@ class Tonal::Ratio
   #    Tonal::Ratio.new(3,2).planar_degrees => 33.69
   # @param round
   #
-  def planar_degrees(round: 2)
+  def planar_degrees(round: PRECISION)
     (Math.atan2(consequent, antecedent) * 180/Math::PI).round(round)
   end
 
@@ -322,7 +324,7 @@ class Tonal::Ratio
   #   Tonal::Ratio.new(3,2).planar_radians => 0.59
   # @param round
   #
-  def planar_radians(round: 2)
+  def planar_radians(round: PRECISION)
     Math.atan2(consequent, antecedent).round(round)
   end
 
@@ -368,8 +370,13 @@ class Tonal::Ratio
     prime_divisions.flatten(1).map(&:first).min
   end
 
-  def within_prime?(prime)
-    max_prime <= prime
+  # @return [Boolean] whether self's max prime is within the given number
+  # @example
+  #   Tonal::Ratio.new(31/30r).max_prime_within?(7) => false
+  # @param number to compare max prime against
+  #
+  def max_prime_within?(number)
+    max_prime <= number
   end
 
   # @return [Integer] the product complexity of self
@@ -383,7 +390,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Log2] the log product complexity of self
   # @example
-  #   Tonal::ReducedRatio.new(3/2r).tenney_height => 2.584962500721156
+  #   Tonal::ReducedRatio.new(3/2r).tenney_height => 2.58
   #
   def tenney_height
     Tonal::Log2.new(logarithmand: benedetti_height)
@@ -402,7 +409,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Log2] the log of Weil height
   # @example
-  #   Tonal::ReducedRatio.new(3/2r).log_weil_height => 1.5849625007211563
+  #   Tonal::ReducedRatio.new(3/2r).log_weil_height => 1.58
   #
   def log_weil_height
     Tonal::Log2.new(logarithmand: weil_height)
@@ -418,33 +425,33 @@ class Tonal::Ratio
 
   # @return [Tonal::Cents] the cents difference between self and its step in the given modulo
   # @example
-  #   Tonal::ReducedRatio.new(3,2).efficiency(12) => -1.955000865387433
-  # @param modulo
+  #   Tonal::ReducedRatio.new(3,2).efficiency(12) => -1.96
+  # @param modulo against which the difference of self is compared
   #
   def efficiency(modulo)
-    # We want the efficiency from the ratio, instead of from the step.
-    # If step efficiency is X cents, then ratio efficiency is -X cents.
+    # We want the efficiency from the ratio (self).
+    # If the step efficiency is X cents, then the ratio efficiency is -X cents.
     step(modulo).efficiency * -1.0
   end
 
   # @return [Array] the results of ratio dividing and multiplying self
   # @example
   #   Tonal::ReducedRatio.new(3/2r).div_times(5/4r) => [(6/5), (15/8)]
-  # @param ratio
+  # @param other_ratio to divide and multiple on self
   #
-  def div_times(ratio)
-    ratio = ratio.ratio
-    [self / ratio, self * ratio]
+  def div_times(other_ratio)
+    other_ratio = self.class.new(other_ratio)
+    [self / other_ratio, self * other_ratio]
   end
 
   # @return [Array] the results of ratio subtracted and added to self
   # @example
   #   Tonal::ReducedRatio.new(3/2r).plus_minus(5/4r) => [(1/1), (11/8)]
-  # @param ratio
+  # @param other_ratio to add and subtract from self
   #
-  def plus_minus(ratio)
-    ratio = ratio.ratio
-    [self - ratio, self + ratio]
+  def plus_minus(other_ratio)
+    other_ratio = self.class.new(other_ratio)
+    [self - other_ratio, self + other_ratio]
   end
   alias :min_plus :plus_minus
 
@@ -463,7 +470,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(Tonal::Cents::PRECISION))).to_s
+    (@label || ((Math.log10(antecedent).to_i + 1) <= 6 ? "#{antecedent}/#{consequent}" : to_f.round(PRECISION))).to_s
   end
 
   # @return [String] the string representation of Tonal::Ratio
@@ -484,11 +491,11 @@ class Tonal::Ratio
   end
 
   def *(rhs)
-    self.class.new(antecedent * rhs.antecedent, consequent * rhs.consequent)
+    operate(rhs, :*)
   end
 
   def /(rhs)
-    self.class.new(antecedent * rhs.consequent, consequent * rhs.antecedent)
+    operate(rhs, :/)
   end
 
   def **(rhs)
@@ -519,6 +526,18 @@ class Tonal::Ratio
     [self.denominator, lhs.denominator].lcm
   end
 
+  # @return [Tonal::Interval] between ratio (upper) and self (lower)
+  # @example
+  #   Tonal::ReducedRatio.new(133).interval_with(3/2r)
+  #   => (192/133) ((3/2) / (133/128))
+  # @param antecedent
+  # @param consequent
+  #
+  def interval_with(antecedent, consequent=nil)
+    r = self.class.new(antecedent, consequent)
+    Tonal::Interval.new(self, r)
+  end
+
   # @return [Integer] the difference between antecedent and consequent
   # @example
   #   Tonal::ReducedRatio.new(3,2).difference => 1
@@ -579,32 +598,32 @@ class Tonal::Ratio
     end
   end
 
+  def coerce(other)
+    [self.class.new(other), self]
+  end
+
   def operate(rhs, op)
+    klass = (rhs.class == Tonal::ReducedRatio || self.class == Tonal::ReducedRatio) ? Tonal::ReducedRatio : Tonal::Ratio
+
     case op
-    when :+, :-
-      case rhs
-      when Tonal::Ratio
-        self.class.new((antecedent * rhs.consequent).send(op, rhs.antecedent * consequent).abs, consequent * rhs.consequent)
-      when Rational
-        self.class.new((antecedent * rhs.denominator).send(op, rhs.numerator * consequent).abs, consequent * rhs.denominator)
-      when Array
-        self.class.new((antecedent * rhs[1]).send(op, rhs[0] * consequent), consequent * rhs[1])
-      else
-        r = Rational(rhs)
-        self.class.new((antecedent * r.denominator).send(op, r.numerator * consequent), consequent * r.denominator)
-      end
     when :*
-      case rhs
-      when Rational
-        self.class.new(antecedent.send(op, rhs.numerator), consequent.send(op, rhs.denominator))
-      when Array
-        self.class.new(antecedent.send(op, rhs[0]), consequent.send(op, rhs[1]))
-      else
-        r = Rational(rhs)
-        self.class.new(antecedent.send(op, r.numerator), consequent.send(op, r.denominator))
-      end
+      klass.new(antecedent * rhs.antecedent, consequent * rhs.consequent)
+    when :/
+      klass.new(antecedent * rhs.consequent, consequent * rhs.antecedent)
+    when :+, :-
+      lcm = self.denominator.lcm(rhs.denominator)
+      left = (self.to_r * lcm).numerator
+      right = (rhs.to_r * lcm).numerator
+      klass.new((left).send(op, right).abs, lcm)
     when :**
-      self.class.new(antecedent.send(op, rhs), consequent.send(op, rhs))
+      klass.new(Rational(antecedent, consequent) ** rhs.to_r)
     end
   end
 end
+
+module Ratio
+  def self.[](u, l=nil)
+    Tonal::Ratio.new(u, l)
+  end
+end
+

data/lib/tonal/reduced_ratio.rb

@@ -25,17 +25,6 @@ class Tonal::ReducedRatio < Tonal::Ratio
     Tonal::Ratio.new(antecedent, consequent)
   end
 
-  # @return [Tonal::Interval] between ratio (upper) and self (lower)
-  # @example
-  #   Tonal::ReducedRatio.new(133).interval_with(3/2r)
-  #   => 192/133 (3/2 / 133/128)
-  # @param ratio
-  #
-  def interval_with(ratio)
-    r = ratio.is_a?(self.class) ? ratio : self.class.new(ratio)
-    Tonal::Interval.new(r, self)
-  end
-
   # @return [Tonal::ReducedRatio] with antecedent and precedent switched
   # @example
   #   Tonal::ReducedRatio.new(3,2).invert! => (4/3)
@@ -46,3 +35,9 @@ class Tonal::ReducedRatio < Tonal::Ratio
     self
   end
 end
+
+module ReducedRatio
+  def self.[](u, l=nil)
+    Tonal::ReducedRatio.new(u, l)
+  end
+end

data/lib/tonal/step.rb

@@ -40,7 +40,7 @@ class Tonal::Step
   # @return [Rational] of the step
   # @example
   #   Tonal::Step.new(ratio: 3/2r, modulo: 31).step_to_r
-  #   => 6735213777669305/4503599627370496
+  #   => (6735213777669305/4503599627370496)
   #
   def step_to_r
     tempered.to_r
@@ -50,7 +50,7 @@ class Tonal::Step
   # @return [Rational] of the ratio
   # @example
   #   Tonal::Step.new(ratio: 3/2r, modulo: 31).ratio_to_r
-  #   => 3/2
+  #   => (3/2)
   #
   def ratio_to_r
     ratio.to_r
@@ -81,6 +81,7 @@ class Tonal::Step
   #   => 5.19
   #
   def efficiency
+    # We want the efficiency from the step (self).
     ratio_to_cents - step_to_cents
   end
 
@@ -98,7 +99,7 @@ class Tonal::Step
     if ratio
       [Tonal::ReducedRatio.new(ratio), Tonal::Log2.new(logarithmand: ratio)]
     elsif log
-      if log.kind_of?(Tonal::Log2)
+      if log.kind_of?(Tonal::Log)
         [log.logarithmand, log]
       else
         lg = Tonal::Log2.new(logarithm: log)

data/lib/tonal/tools.rb

@@ -17,4 +17,10 @@ module Tonal
   require "tonal/interval"
   require "tonal/step"
   require "tonal/extensions"
+  require "tonal/irb_helpers"
+end
+
+if ENV["MTONAL_IRB_HELPERS"]
+  Tonal.include_irb_helpers
+  puts 'mTonal IRB helpers have been enabled.'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tonal-tools
 version: !ruby/object:Gem::Version
-  version: 5.3.0
+  version: 6.1.1
 platform: ruby
 authors:
 - Jose Hales-Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-09 00:00:00.000000000 Z
+date: 2025-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yaml
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.9'
 - !ruby/object:Gem::Dependency
   name: prime
   requirement: !ruby/object:Gem::Requirement
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +165,7 @@ files:
 - lib/tonal/extensions.rb
 - lib/tonal/hertz.rb
 - lib/tonal/interval.rb
+- lib/tonal/irb_helpers.rb
 - lib/tonal/log.rb
 - lib/tonal/log2.rb
 - lib/tonal/ratio.rb