tonal-tools 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 104f86d9527406e4ebb2bc443347c1cd6c45c4b8380c8739c435c504a4381842
+  data.tar.gz: a605b1bdd7c4fc7c20f6a66417422c9e55909bc9eaacaa5e4336280ca8e2f2a4
+SHA512:
+  metadata.gz: '068a485c121ef0941c05d4fcc2e67e607aa8572fd2ba572e7481f5f54189cdeff0c4e04648b2809db35e2bc533dffe81c406bd0873093719bf5a8ea388718f44'
+  data.tar.gz: b5d341be94a1ef9bb7c57cf5974b647bcd943151386c8a9fd4615f1a6f3e251ca8567994870d8882263e7963bcdaeb3214490a4bd245fdb423543fc41ef032f9

data/lib/tonal/approximations.rb

@@ -0,0 +1,148 @@
+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_as_rationals.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

data/lib/tonal/cents.rb

@@ -0,0 +1,145 @@
+class Tonal::Cents
+  extend Forwardable
+  include Comparable
+
+  def_delegators :@log, :logarithm, :logarithmand, :base
+
+  HUNDREDTHS_ROUNDOFF = -2
+  FLOAT_PRECISION = 100
+  CENT_SCALE = 1200.0
+  TOLERANCE = 5
+  PRECISION = 2
+  DEFAULT_ROUNDING_PRECISION = 2
+
+  attr_reader :log, :ratio
+
+  # @return [Cents]
+  # @example
+  #   Tonal::Cents.new(ratio: 2**(2.0/12)) => 200.0
+  # @param cents [Numeric, Tonal::Log2]
+  # @param log [Numeric, Tonal::Log2]
+  # @param ratio [Numeric, Tonal::Log2]
+  # @param precision [Numeric]
+  #
+  def initialize(cents: nil, log: nil, ratio: nil, precision: PRECISION)
+    raise ArgumentError, "One of cents:, log: or ratio: must be provided" unless [cents, log, ratio].compact.count == 1
+
+    @precision = precision
+
+    if cents
+      @log = derive_log(cents: cents)
+      @value = derive_cents(cents: cents)
+      @ratio = derive_ratio(log: @log)
+    elsif log
+      @log = derive_log(log: log)
+      @value = derive_cents(log: @log)
+      @ratio = derive_ratio(log: @log)
+    elsif ratio
+      @log = derive_log(ratio: ratio)
+      @value = derive_cents(log: @log)
+      @ratio = derive_ratio(ratio: ratio)
+    end
+  end
+
+  # @return [Cents] the default cents tolerance
+  # @example
+  #   Tonal::Cents.default_tolerance => 5
+  #
+  def self.default_tolerance
+    self.new(cents: TOLERANCE)
+  end
+
+  # @return [Float] value of self
+  # @example
+  #   Tonal::Cents.new(ratio: 2**(1.0/12)).value => 100.00
+  #
+  def value(precision: @precision)
+    @value.round(precision)
+  end
+  alias :cents :value
+
+  # @return
+  #   [Cents] nearest hundredth cent value
+  # @example
+  #   Tonal::Cents.new(cents: 701.9550008653874).nearest_hundredth => 700.0
+  #
+  def nearest_hundredth
+    self.class.new(cents: value.round(Tonal::Cents::HUNDREDTHS_ROUNDOFF).to_f)
+  end
+
+  # @return
+  #   [Cents] nearest hundredth cent difference
+  # @example
+  #   Tonal::Cents.new(701.9550008653874).nearest_hundredth_difference => 1.955000865387433
+  #
+  def nearest_hundredth_difference
+    self.class.new(cents: (value - nearest_hundredth))
+  end
+
+  # TODO: Document or Consider if needed
+  #
+  def plus_minus(limit = 5)
+    [self - limit, self + limit]
+  end
+
+  # @return
+  #   [String] the string representation of Cents
+  # @example
+  #   Tonal::Cents.new(100.0).inspect => "100.0"
+  #
+  def inspect
+    "#{value.round(@precision)}"
+  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/
+  #
+  def <=>(rhs)
+    rhs.kind_of?(self.class) ? value.round(2) <=> rhs.value.round(2) : value.round(2) <=> rhs.round(2)
+  end
+
+  private
+  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)
+  end
+
+  def derive_ratio(log: nil, ratio: nil)
+    return Tonal::ReducedRatio.new(log.logarithmand) if log
+    Tonal::ReducedRatio.new(ratio.numerator, ratio.denominator)
+  end
+
+  def derive_cents(cents: nil, log: nil)
+    return cents if cents
+    log.logarithm * CENT_SCALE if log
+  end
+
+  # All these operators are binary except for |, ~ and typeof , so the left
+  # hand (A) object would be the context object, and the right hand object (B)
+  # would be the argument passed to the operator member in A. For unary
+  # operators, there won't be arguments, and the function would be called upon
+  # its target. operator functions would only be called if the operator is
+  # explicitly used in the source code.
+  #
+  def method_missing(op, *args, &blk)
+    rhs = args.collect do |arg|
+      arg.kind_of?(self.class) ? arg.value : arg
+    end
+    result = value.send(op, *rhs)
+    return result if op == :coerce
+    case result
+    when Numeric
+      self.class.new(cents: result)
+    # TODO: Work this case out or remove
+    #when Array
+    #  result.collect do |e|
+    #    e.kind_of?(Numeric) ? Cents.new(e) : e
+    #  end
+    else
+      result
+    end
+  end
+end