tonal-tools 7.7.0 → 8.3.1

data/lib/tonal/ratio.rb

@@ -12,7 +12,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio]
   # @example
-  #   Tonal::Ratio.new(3,2) => (3/2)
+  #   Tonal::Ratio.new(3,2) => 3/2
   # @param antecedent [Numeric, Tonal::Ratio]
   # @param consequent [Numeric, Tonal::Ratio]
   #
@@ -28,7 +28,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] ratio who's numerator and denominator are seperated by a difference of 1
   # @example
-  #   Tonal::Ratio.superparticular(100) = (101/100)
+  #   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
@@ -39,7 +39,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] ratio who's numerator and denominator are separated by a summand difference
   # @example
-  #   Tonal::Ratio.superpartient(23, summand: 3) => (26/23)
+  #   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
@@ -56,11 +56,12 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] a randomly generated ratio
   # @example
-  #   Tonal::Ratio.random_ratio => (169/1)
-  # @param number_of_factors
-  # @param within
+  #   Tonal::Ratio.random_ratio => 169/1
+  # @param number_of_factors  the number of prime factors to include in the ratio
+  # @param within the upper limit for prime factors
+  # @param reduced boolean determining whether to use Tonal::ReducedRatio or Tonal::Ratio
   #
-  def self.random_ratio(number_of_factors = 2, within: 100, reduced: false)
+  def self.random_ratio(number_of_factors = 2, within: 100, reduced: (self == Tonal::ReducedRatio) ? true : false)
     primes = Prime.each(within).to_a
     nums = []
     dens = []
@@ -73,13 +74,12 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] the ratio of step in the modulo
   # @example
-  #   Tonal::Ratio.ed(12, 7)
-  #     => (4771397596969315/4503599627370496)
-  # @param modulo
-  # @param step
-  # @param equave
+  #   Tonal::Ratio.ed(12, 7) => 1.5
+  # @param modulo the number of steps in the equal division
+  # @param step the step number in the equal division of the equave
+  # @param equave the interval of equivalence, default 2/1
   #
-  def self.ed(modulo, step, equave: 2/1r)
+  def self.ed(step, modulo, equave: 2/1r)
     self.new(2**(step.to_f/modulo), equave: equave)
   end
 
@@ -108,7 +108,7 @@ class Tonal::Ratio
   end
 
   # ==================================
-  # Conversions
+  # Conversions, mappings and measurements
   # ==================================
 
   # @return [Array] antecedent and consequent as elements of Array
@@ -143,6 +143,7 @@ class Tonal::Ratio
   def to_f
     antecedent.to_f / consequent.to_f
   end
+  alias :number :to_f
 
   # @return [Tonal::Log] Math.log of self in given base
   # @example
@@ -177,7 +178,7 @@ class Tonal::Ratio
   #   Tonal::ReducedRatio.new(3,2).step(12) => 7\12
   #
   def step(modulo=12)
-    Tonal::Step.new(ratio: to_r, modulo: modulo)
+    Tonal::Scale::Step.new(ratio: to_r, modulo: modulo)
   end
 
   # @return [Float] degrees
@@ -200,7 +201,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] copy of self rationally reduced
   # @example
-  #   Tonal::Ratio.new(16,14).fraction_reduce => (8/7)
+  #   Tonal::Ratio.new(16,14).fraction_reduce => 8/7
   # @see to_r
   #
   def fraction_reduce
@@ -209,7 +210,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] copy of self reduced to the given equave
   # @example
-  #   Tonal::Ratio.new(48,14).equave_reduce(3) => (8/7)
+  #   Tonal::Ratio.new(48,14).equave_reduce(3) => 8/7
   # @param equave Numeric
   #
   def equave_reduce(equave=2/1r)
@@ -220,7 +221,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] self reduced to the given equave
   # @example
-  #   Tonal::Ratio.new(48,14).equave_reduce!(3) => (8/7)
+  #   Tonal::Ratio.new(48,14).equave_reduce!(3) => 8/7
   # @param equave Numeric
   #
   def equave_reduce!(equave=2/1r)
@@ -232,7 +233,7 @@ class Tonal::Ratio
 
   # @return [Tonal::ReducedRatio] of self
   # @example
-  #   Tonal::Ratio.new(1,9).to_reduced_ratio => (16/9)
+  #   Tonal::Ratio.new(1,9).to_reduced_ratio => 16/9
   #
   def to_reduced_ratio
     Tonal::ReducedRatio.new(reduced_antecedent, reduced_consequent, equave: equave)
@@ -241,7 +242,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] copy of self with the antecedent and precedent switched
   # @example
-  #   Tonal::Ratio.new(3,2).invert => (2/3)
+  #   Tonal::Ratio.new(3,2).invert => 2/3
   #
   def invert
     self.class.new(consequent, antecedent)
@@ -251,7 +252,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] with antecedent and precedent switched
   # @example
-  #   Tonal::Ratio.new(3,2).invert! => (2/3)
+  #   Tonal::Ratio.new(3,2).invert! => 2/3
   #
   def invert!
     _initialize(consequent, antecedent, label: label, equave: equave)
@@ -260,7 +261,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] the mirror of self along the axis (default 1/1)
   # @example
-  #   Tonal::ReducedRatio.new(4,3).mirror => (3/2)
+  #   Tonal::ReducedRatio.new(4,3).mirror => 3/2
   # @param axis
   #
   def mirror(axis=1/1r)
@@ -269,7 +270,7 @@ class Tonal::Ratio
 
   # @return [Tonal::ReducedRatio] the Ernst Levy negative of self
   # @example
-  #   Tonal::ReducedRatio.new(7/4r).negative => (12/7)
+  #   Tonal::ReducedRatio.new(7/4r).negative => 12/7
   #
   def negative
     self.class.new(3/2r) / self
@@ -281,10 +282,9 @@ class Tonal::Ratio
   # denominator mapped on y-axis
   # ==================================
   #
-
   # @return [Tonal::Ratio] with the antecedent and consequent translated by x and y
   # @example
-  #   Tonal::Ratio.new(3,2).translate(3,3) => (6/5)
+  #   Tonal::Ratio.new(3,2).translate(3,3) => 6/5
   # @param x [Numeric]
   # @param y [Numeric]
   #
@@ -295,7 +295,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] self scaled by given arguments
   # @example
-  #   Tonal::Ratio.new(3,2).scale(2**5) => (96/64)
+  #   Tonal::Ratio.new(3,2).scale(2**5) => 96/64
   # @param a [Numeric]
   # @param b [Numeric]
   #
@@ -306,7 +306,7 @@ class Tonal::Ratio
 
   # @return [Tonal::Ratio] self sheared by given arguments
   # @example
-  #   Tonal::Ratio.new(3,2).shear(1, 3) => (14/11)
+  #   Tonal::Ratio.new(3,2).shear(1, 3) => 14/11
   # @param a [Numeric]
   # @param b [Numeric]
   #
@@ -377,15 +377,10 @@ class Tonal::Ratio
     prime_divisions.flatten(1).map(&:first).min
   end
 
-  # @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
+  # =================================
+  # Measures of complexity
+  # ==================================
   #
-  def max_prime_within?(number)
-    max_prime.nil? ? false : max_prime <= number
-  end
-
   # @return [Integer] the product complexity of self
   # @example
   #   Tonal::ReducedRatio.new(3/2r).benedetti_height => 6
@@ -471,6 +466,86 @@ class Tonal::Ratio
     cents - other_ratio.ratio.cents
   end
 
+  # @return [Integer] the least common multiple with self's denominator and the given number's denominator
+  # @example
+  #   Tonal::Ratio.new(3/2r).lcm(5/4r) => 4
+  # @param lhs [Numeric, Tonal::Ratio] the number with which the lcm with self is computed
+  #
+  def lcm(lhs)
+    [self.denominator, lhs.denominator].lcm
+  end
+
+  # @return [Tonal::Interval] between self and another ratio
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).interval_with(4/3r)
+  #   => 9/8 (3/2 / 4/3)
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).interval_with(4/3r, is_lower: false)
+  #   => 16/9 (4/3 / 3/2)
+  # @param other_ratio [Tonal::ReducedRatio, Numeric] the ratio to form the interval with
+  # @param is_lower [Boolean] whether other_ratio is the lower ratio of the interval
+  #
+  def interval_with(other_ratio, is_lower: true)
+    other_ratio = self.class.new(other_ratio)
+    args = is_lower ? [self, other_ratio] : [other_ratio, self]
+    Tonal::Interval.new(*args)
+  end
+
+  # @return [Tonal::Interval] between 1/1 and self
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).to_interval
+  #   => (3/2) ((3/2) / (1/1))
+  #
+  def to_interval
+    interval_with(1/1r)
+  end
+
+  # @return [Tonal::Cents] difference between ratio (upper) and self (lower)
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).cents_difference_with(4/3r) => 203.91
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).cents_difference_with(4/3r, is_lower: false) => 996.09
+  # @param other_ratio [Tonal::ReducedRatio, Numeric] the ratio to compare cents difference with
+  #
+  def cents_difference_with(other_ratio, is_lower: true)
+    interval_with(other_ratio, is_lower:).to_cents
+  end
+
+  # @return [Integer] the difference between antecedent and consequent
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).difference => 1
+  #
+  def difference
+    antecedent - consequent
+  end
+  alias :diff :difference
+
+  # @return [Integer] the sum of antecedent and consequent
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).combination => 5
+  #
+  def combination
+    antecedent + consequent
+  end
+  alias :comb :combination
+
+  # @return [Tonal::Ratio] self raised to the given power and root
+  # @example
+  #   Tonal::ReducedRatio.new(3,2).power(2) => 9/8
+  # @param power [Numeric]
+  # @param root [Numeric, nil]
+  # @param approximant [Integer] the index of the approximant to use
+  # @param by_method [Symbol] the method used to calculate approximation of the root intervalic ratio
+  # @param from [Symbol] whether to calculate the root interval from the lower or upper ratio of the interval
+  #
+  def power(power, root=nil, approximant: 0, by_method: :continued_fraction, from: :lower_ratio)
+    to_interval.root_interval(power:, root:, approximant:, by_method:, from:).intervalic_ratio
+  end
+
+  # ==================================
+  # Display
+  # ==================================
+
   # @return [String] symbolic representation of Tonal::Ratio
   #
   def label
@@ -480,7 +555,7 @@ class Tonal::Ratio
 
   # @return [String] the string representation of Tonal::Ratio
   # @example
-  #   Tonal::Ratio.new(3, 2).inspect => "(3/2)"
+  #   Tonal::Ratio.new(3, 2).inspect => "3/2"
   #
   def inspect
     # Return the "antecedent/consequent", if antecedent is less than 7 digits long; or
@@ -489,22 +564,51 @@ class Tonal::Ratio
   end
   alias :to_s :inspect
 
+  # ==================================
+  # Arithmetic operations
+  # ==================================
+
+  # @return [Tonal::Ratio] result of adding self and rhs
+  # @example
+  #   Tonal::Ratio.new(3,2) + Tonal::Ratio.new(4,3) => (17/12)
+  # @param rhs [Numeric, Tonal::Ratio]
+  #
   def +(rhs)
     operate(rhs, :+)
   end
 
+  # @return [Tonal::Ratio] result of subtracting rhs from self
+  # @example
+  #   Tonal::Ratio.new(3,2) - Tonal::Ratio.new(4,3) => (1/6)
+  # @param rhs [Numeric, Tonal::Ratio]
+  #
   def -(rhs)
     operate(rhs, :-)
   end
 
+  # @return [Tonal::Ratio] result of multiplying self and rhs
+  # @example
+  #   Tonal::Ratio.new(3,2) * Tonal::Ratio.new(4,3) => (2/1)
+  # @param rhs [Numeric, Tonal::Ratio]
+  #
   def *(rhs)
     operate(rhs, :*)
   end
 
+  # @return [Tonal::Ratio] result of dividing self by rhs
+  # @example
+  #   Tonal::Ratio.new(3,2) / Tonal::Ratio.new(4,3) => (9/8)
+  # @param rhs [Numeric, Tonal::Ratio]
+  #
   def /(rhs)
     operate(rhs, :/)
   end
 
+  # @return [Tonal::Ratio] result of raising self to the rhs power
+  # @example
+  #   Tonal::Ratio.new(3,2) ** 2 => (9/4)
+  # @param rhs [Numeric, Tonal::Ratio]
+  #
   def **(rhs)
     operate(rhs, :**)
   end
@@ -520,64 +624,27 @@ class Tonal::Ratio
   alias :mediant :mediant_sum
   alias :farey_sum :mediant_sum
 
-  # ==================================
-  # Measurements
-  # ==================================
-
-  # @return [Integer] the least common multiple with self's denominator and the given number's denominator
-  # @example
-  #   Tonal::Ratio.new(3/2r).lcm(5/4r) => 4
-  # @param lhs [Numeric, Tonal::Ratio] the number with which the lcm with self is computed
-  #
-  def lcm(lhs)
-    [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 upper ratio
-  # @param lower ratio
-  #
-  def interval_with(upper, lower=nil)
-    r = self.class.new(upper, lower)
-    Tonal::Interval.new(self, r)
-  end
-
-  # @return [Tonal::Cents] difference between ratio (upper) and self (lower)
-  # @example
-  #   Tonal::ReducedRatio.new(133).cents_difference_with(3/2r)
-  #   => 635.62
-  # @param upper ratio
-  # @param lower ratio
-  #
-  def cents_difference_with(upper, lower=nil)
-    interval_with(upper, lower).to_cents
-  end
-
-  # @return [Integer] the difference between antecedent and consequent
+  # @return [Integer] comparison of self to rhs
   # @example
-  #   Tonal::ReducedRatio.new(3,2).difference => 1
+  #   Tonal::Ratio.new(3,2) <=> Tonal::Ratio.new(4,3) => 1
+  # @param rhs [Tonal::Ratio]
   #
-  def difference
-    antecedent - consequent
+  def <=>(rhs)
+    left = consequent == 0 ? Float::INFINITY : Rational(antecedent, consequent)
+    right = rhs.denominator == 0 ? Float::INFINITY : Rational(rhs.numerator, rhs.denominator)
+    left <=> right
   end
-  alias :diff :difference
 
-  # @return [Integer] the sum of antecedent and consequent
-  # @example
-  #   Tonal::ReducedRatio.new(3,2).combination => 5
+  # Set uses Hash as storage and equality of elements is determined according to Object#eql? and Object#hash.
   #
-  def combination
-    antecedent + consequent
+  def eql?(other)
+     other.instance_of?(self.class) && to_r == other.to_r
   end
-  alias :comb :combination
 
-  def <=>(rhs)
-    left = consequent == 0 ? Float::INFINITY : Rational(antecedent, consequent)
-    right = rhs.denominator == 0 ? Float::INFINITY : Rational(rhs.numerator, rhs.denominator)
-    left <=> right
+  def hash
+     p, q = 17, 37
+     p = q * @id.hash
+     p = q * @name.hash
   end
 
   private
@@ -638,9 +705,3 @@ class Tonal::Ratio
     end
   end
 end
-
-module Ratio
-  def self.[](u, l=nil)
-    Tonal::Ratio.new(u, l)
-  end
-end

data/lib/tonal/reduced_ratio.rb

@@ -3,7 +3,7 @@ class Tonal::ReducedRatio < Tonal::Ratio
 
   # @return [Tonal::ReducedRatio]
   # @example
-  #   Tonal::ReducedRatio.new(12,2) => (3/2)
+  #   Tonal::ReducedRatio.new(12,2) => 3/2
   # @param antecedent [Numeric, Tonal::Ratio]
   # @param consequent [Numeric, Tonal::Ratio]
   # @param equave the interval of equivalence, default 2/1
@@ -35,9 +35,3 @@ 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

@@ -1,112 +1,114 @@
-class Tonal::Step
-  extend Forwardable
-  include Comparable
+class Tonal::Scale
+  class Step
+    extend Forwardable
+    include Comparable
 
-  def_delegators :@log, :logarithmand
+    def_delegators :@log, :logarithmand
 
-  attr_reader :modulo, :log, :step, :ratio, :tempered
+    attr_reader :modulo, :log, :step, :ratio, :tempered
 
-  def initialize(modulo: nil, log: nil, step: nil, ratio: nil)
-    raise ArgumentError, "modulo: required" unless modulo
-    raise ArgumentError, "One of log:, step: or ratio: must be provided" unless [log, step, ratio].compact.count == 1
-    @modulo = modulo.round
+    def initialize(modulo: nil, log: nil, step: nil, ratio: nil)
+      raise ArgumentError, "modulo: required" unless modulo
+      raise ArgumentError, "One of log:, step: or ratio: must be provided" unless [log, step, ratio].compact.count == 1
+      @modulo = modulo.round
 
-    if ratio
-      @ratio, @log = derive_ratio_and_log(ratio: ratio)
-    elsif step
-      @ratio, @log = derive_ratio_and_log(step: step)
-    elsif log
-      @ratio, @log = derive_ratio_and_log(log: log)
-    end
+      if ratio
+        @ratio, @log = derive_ratio_and_log(ratio: ratio)
+      elsif step
+        @ratio, @log = derive_ratio_and_log(step: step)
+      elsif log
+        @ratio, @log = derive_ratio_and_log(log: log)
+      end
 
-    @step = (modulo * @log).round
-    @tempered = 2**(@step.to_f/@modulo)
-  end
+      @step = (modulo * @log).round
+      @tempered = 2**(@step.to_f/@modulo)
+    end
 
-  def inspect
-    "#{step}\\#{modulo}"
-  end
-  alias :to_s :inspect
+    def inspect
+      "#{step}\\#{modulo}"
+    end
+    alias :to_s :inspect
 
-  # @return [Tonal::Step] new step with the ratio mapped to the new modulo
-  # @example
-  #   Tonal::Step.new(ratio: 3/2r, modulo: 31).convert(12)
-  #   => 7\12
-  #
-  def convert(new_modulo)
-    self.class.new(log: log, modulo: new_modulo)
-  end
+    # @return [Tonal::Scale::Step] new step with the ratio mapped to the new modulo
+    # @example
+    #   Tonal::Scale::Step.new(ratio: 3/2r, modulo: 31).convert(12)
+    #   => 7\12
+    #
+    def convert(new_modulo)
+      self.class.new(log: log, modulo: new_modulo)
+    end
 
-  # @return [Rational] of the step
-  # @example
-  #   Tonal::Step.new(ratio: 3/2r, modulo: 31).step_to_r
-  #   => (6735213777669305/4503599627370496)
-  #
-  def step_to_r
-    tempered.to_r
-  end
-  alias :to_r :step_to_r
+    # @return [Rational] of the step
+    # @example
+    #   Tonal::Scale::Step.new(ratio: 3/2r, modulo: 31).step_to_r
+    #   => (6735213777669305/4503599627370496)
+    #
+    def step_to_r
+      tempered.to_r
+    end
+    alias :to_r :step_to_r
 
-  # @return [Rational] of the ratio
-  # @example
-  #   Tonal::Step.new(ratio: 3/2r, modulo: 31).ratio_to_r
-  #   => (3/2)
-  #
-  def ratio_to_r
-    ratio.to_r
-  end
+    # @return [Rational] of the ratio
+    # @example
+    #   Tonal::Scale::Step.new(ratio: 3/2r, modulo: 31).ratio_to_r
+    #   => (3/2)
+    #
+    def ratio_to_r
+      ratio.to_r
+    end
 
-  # @return [Tonal::Cents] measure of step in cents
-  # @example
-  #   Tonal::Step.new(ratio: 3/2r, modulo: 31).step_to_cents
-  #   => 696.77
-  #
-  def step_to_cents
-    tempered.to_cents
-  end
-  alias :to_cents :step_to_cents
+    # @return [Tonal::Cents] measure of step in cents
+    # @example
+    #   Tonal::Scale::Step.new(ratio: 3/2r, modulo: 31).step_to_cents
+    #   => 696.77
+    #
+    def step_to_cents
+      tempered.to_cents
+    end
+    alias :to_cents :step_to_cents
 
-  # @return [Tonal::Cents] measure of ratio in cents
-  # @example
-  #   Tonal::Step.new(ratio: 3/2r, modulo: 31).ratio_to_cents
-  #   => 701.96
-  #
-  def ratio_to_cents
-    ratio.to_cents
-  end
+    # @return [Tonal::Cents] measure of ratio in cents
+    # @example
+    #   Tonal::Scale::Step.new(ratio: 3/2r, modulo: 31).ratio_to_cents
+    #   => 701.96
+    #
+    def ratio_to_cents
+      ratio.to_cents
+    end
 
-  # @return [Tonal::Cents] the difference between the step and the ratio
-  # @example
-  #   Tonal::Step.new(ratio: 3/2r, modulo: 31).efficiency
-  #   => 5.19
-  #
-  def efficiency
-    # We want the efficiency from the step (self).
-    ratio_to_cents - step_to_cents
-  end
+    # @return [Tonal::Cents] the difference between the step and the ratio
+    # @example
+    #   Tonal::Scale::Step.new(ratio: 3/2r, modulo: 31).efficiency
+    #   => 5.19
+    #
+    def efficiency
+      # We want the efficiency from the step (self).
+      ratio_to_cents - step_to_cents
+    end
 
-  def +(rhs)
-    self.class.new(step: (rhs % modulo), modulo: modulo)
-  end
-  alias :% :+
+    def +(rhs)
+      self.class.new(step: (rhs % modulo), modulo: modulo)
+    end
+    alias :% :+
 
-  def <=>(rhs)
-    rhs.kind_of?(self.class) && modulo <=> rhs.modulo && log <=> rhs.log && step <=> rhs.step
-  end
+    def <=>(rhs)
+      rhs.kind_of?(self.class) && modulo <=> rhs.modulo && log <=> rhs.log && step <=> rhs.step
+    end
 
-  private
-  def derive_ratio_and_log(ratio: nil, log: nil, step: nil)
-    if ratio
-      [Tonal::ReducedRatio.new(ratio), Tonal::Log2.new(logarithmand: ratio)]
-    elsif log
-      if log.kind_of?(Tonal::Log)
-        [log.logarithmand, log]
-      else
-        lg = Tonal::Log2.new(logarithm: log)
-        [Tonal::ReducedRatio.new(lg.logarithmand), lg]
+    private
+    def derive_ratio_and_log(ratio: nil, log: nil, step: nil)
+      if ratio
+        [Tonal::ReducedRatio.new(ratio), Tonal::Log2.new(logarithmand: ratio)]
+      elsif log
+        if log.kind_of?(Tonal::Log)
+          [log.logarithmand, log]
+        else
+          lg = Tonal::Log2.new(logarithm: log)
+          [Tonal::ReducedRatio.new(lg.logarithmand), lg]
+        end
+      elsif step
+        [Tonal::ReducedRatio.new(2.0**(step.to_f/@modulo)), Tonal::Log2.new(logarithmand: (2.0 ** (step.to_f/@modulo)))]
       end
-    elsif step
-      [Tonal::ReducedRatio.new(2.0**(step.to_f/@modulo)), Tonal::Log2.new(logarithmand: (2.0 ** (step.to_f/@modulo)))]
     end
   end
 end