coltrane 2.1.5 → 2.2.1

data/lib/coltrane/frequency.rb

@@ -38,7 +38,7 @@ module Coltrane
 
     def /(other)
       case other
-      when Frequency then Interval[1200 * Math.log2(frequency / other.frequency)]
+      when Frequency then FrequencyInterval[1200 * Math.log2(other.frequency / frequency)]
       when Numeric then Frequency[frequency / other]
       end
     end

data/lib/coltrane/frequency_interval.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Coltrane
+  # Interval describe the logarithmic distance between 2 frequencies.
+  # It's measured in cents.
+  class FrequencyInterval
+    include Comparable
+
+    attr_reader :cents
+
+    class << self
+      alias [] new
+    end
+
+    def initialize(cents)
+      @cents = cents.round
+    end
+
+    def semitones
+      (cents.to_f / 100).round
+    end
+
+    def ascending
+      self.class[cents.abs]
+    end
+
+    def descending
+      self.class[-cents.abs]
+    end
+
+    def ascending?
+      cents > 0
+    end
+
+    def descending?
+      cents < 0
+    end
+
+    def inversion
+      self.class[(-cents.abs % 1200) * (ascending? ? +1 : -1)]
+    end
+
+    def opposite
+      self.class.new(-cents)
+    end
+
+    def interval_class
+      IntervalClass.new(semitones)
+    end
+
+    def ==(other)
+      return false unless other.is_a? FrequencyInterval
+      cents == other.cents
+    end
+
+    alias eql? ==
+    alias hash cents
+
+    def +(other)
+      case other
+      when Numeric then FrequencyInterval[cents + other]
+      when Interval then FrequencyInterval[cents + other.cents]
+      end
+    end
+
+    def -(other)
+      case other
+      when Numeric then FrequencyInterval[cents - other]
+      when Interval then FrequencyInterval[cents - other.cents]
+      end
+    end
+
+    def -@
+      FrequencyInterval[-cents]
+    end
+
+    def <=>(other)
+      cents <=> other.cents
+    end
+  end
+end

data/lib/coltrane/interval.rb

@@ -1,64 +1,208 @@
 # frozen_string_literal: true
 
 module Coltrane
-  # Interval describe the logarithmic distance between 2 frequencies.
-  # It's measured in cents.
-  class Interval
-    include Comparable
-
-    attr_reader :cents
+  class Interval < IntervalClass
+    attr_reader :letter_distance, :cents
+    alias compound? compound
 
     class << self
-      alias [] new
+      def all
+        @all ||= super.map(&:interval)
+      end
+
+      def all_compound
+        @all_compound ||= all.map(&:compound)
+      end
+
+      def all_including_compound
+        @all_including_compound ||= all + all_compound
+      end
 
-      def method_missing(method, *args)
-        IntervalClass.send(method, *args)
+      def all_augmented
+        @all_augmented ||= all_including_compound.select(&:has_augmented?)
+                                                 .map(&:augmented)
+      end
+
+      def all_diminished
+        @all_diminished ||= all_including_compound.select(&:has_diminished?)
+                                                  .map(&:diminished)
+      end
+
+      def all_including_compound_and_altered
+        @all_including_compound_and_altered ||=
+          all_including_compound +
+          all_diminished +
+          all_augmented
       end
     end
 
-    def initialize(cents)
-      @cents = cents.round
+    def initialize(arg_1 = nil, arg_2 = nil, ascending: true,
+                   letter_distance: nil,
+                   semitones: nil,
+                   compound: false)
+      if arg_1 && !arg_2 # assumes arg_1 is a letter
+        @compound = compound
+        IntervalClass[arg_1].interval.yield_self do |interval|
+          @letter_distance = interval.letter_distance
+          @cents = interval.cents
+        end
+      elsif arg_1 && arg_2 # assumes those are notes
+        if ascending
+          @compound = compound
+          @cents =
+            (arg_1.frequency / arg_2.frequency)
+            .interval_class
+            .cents
+
+          @letter_distance = calculate_letter_distance arg_1.letter,
+                                                       arg_2.letter,
+                                                       ascending
+        else
+          self.class.new(arg_1, arg_2).descending.yield_self do |base_interval|
+            @compound        = base_interval.compound?
+            @cents           = base_interval.cents
+            @letter_distance = base_interval.letter_distance
+          end
+        end
+      elsif letter_distance && semitones
+        @compound        = compound || letter_distance > 8
+        @cents           = semitones * 100
+        @letter_distance = letter_distance
+      else
+        raise WrongKeywordsError,
+              '[interval_class_name]' \
+              'Provide: [first_note, second_note] || ' \
+              '[letter_distance:, semitones:]'
+      end
     end
 
-    def semitones
-      (cents.to_f / 100).round
+    def self.[](arg)
+      new(arg)
     end
 
-    def ascending?
-      cents < 0
+    def interval_class
+      FrequencyInterval[cents].interval_class
     end
 
-    def descending?
-      cents > 0
+    def compound?
+      @compound
     end
 
-    def ==(other)
-      cents == other.cents
+    def has_augmented?
+      name.match?(%r{M|P|A})
     end
 
-    alias eql? ==
-    alias hash cents
+    def has_diminished?
+      name.match?(%r{m|P|d})
+    end
+
+    def accidentals
+      case
+      when distance_to_starting.positive? then 'A'
+      when distance_to_starting.negative? then 'd'
+      else return ''
+      end * distance_to_starting.abs
+    end
 
-    def +(other)
-      case other
-      when Numeric then Interval[cents + other]
-      when Interval then Interval[cents + other.cents]
+    def name
+      @name ||= begin
+        if distance_to_starting.zero? || distance_to_starting.abs > 2
+          compound? ? interval_class.compound_name : interval_class.name
+        else
+          "#{accidentals}#{starting_interval.distance + (compound? ? 7 : 0)}"
+        end
       end
     end
 
-    def -(other)
-      case other
-      when Numeric then Interval[cents - other]
-      when Interval then Interval[cents - other.cents]
+    def as(n)
+      i = clone(letter_distance: n)
+      i if i.name.match?(n.to_s)
+    end
+
+    def as!(n)
+      i = as(n)
+      i unless i&.name&.match?(/d|A/)
+    end
+
+    def as_diminished(n = 1)
+      as(letter_distance + n)
+    end
+
+    def as_augmented(n = 1)
+      as(letter_distance - n)
+    end
+
+    def clone(override_args = {})
+      self.class.new({
+        semitones: semitones,
+        letter_distance: letter_distance,
+        compound: compound?
+      }.merge(override_args))
+    end
+
+    def diminish(n = 1)
+      clone(semitones: semitones - n)
+    end
+
+    alias diminished diminish
+
+    def augment(n = 1)
+      clone(semitones: semitones + n)
+    end
+
+    alias augmented augment
+
+    def opposite
+      clone(semitones: -semitones, letter_distance: (-letter_distance % 8) + 1)
+    end
+
+    def ascending
+      ascending? ? self : opposite
+    end
+
+    def descending
+      descending? ? self : opposite
+    end
+
+    private
+
+    def starting_interval # select the closest interval possible to start from
+      @starting_interval ||= begin
+        IntervalClass.all
+                     .select { |i| i.distance == normalized_letter_distance }
+                     .sort_by do |i|
+          (cents - i.cents)
+            .yield_self { |d| [(d % 1200), (d % -1200)].min_by(&:abs) }
+            .abs
+        end
+                     .first
       end
     end
 
-    def -@
-      Interval[-cents]
+    def normalized_letter_distance
+      return letter_distance if letter_distance < 8
+      (letter_distance % 8) + 1
+    end
+
+    def distance_to_starting # calculate the closts distance to it
+      d = semitones - starting_interval.semitones
+      [(d % 12), (d % -12)].min_by(&:abs)
     end
 
-    def <=>(other)
-      cents <=> other.cents
+    def all_letters
+      PitchClass.all_letters
+    end
+
+    def calculate_letter_distance(a, b, asc)
+      all_letters
+        .rotate(all_letters.index(asc ? a : b))
+        .index(b) + 1
+    end
+
+    public
+
+    all_including_compound_and_altered.each do |interval|
+      self.class.define_method(interval.full_name.underscore) { interval.clone }
     end
   end
 end

data/lib/coltrane/interval_class.rb

@@ -7,85 +7,183 @@ module Coltrane
   #
   # This class in specific still takes into account the order of intervals.
   # C to D is a major second, but D to C is a minor seventh.
-  class IntervalClass < Interval
-    INTERVALS = %w[P1 m2 M2 m3 M3 P4 A4 P5 m6 M6 m7 M7].freeze
+  class IntervalClass < FrequencyInterval
+    QUALITY_SEQUENCE = [
+      %w[P],
+      %w[m M],
+      %w[m M],
+      %w[P A],
+      %w[P],
+      %w[m M],
+      %w[m M]
+    ].freeze
+
+    ALTERATIONS = {
+      'A' => +1,
+      'd' => -1
+    }.freeze
+
+    SINGLE_DISTANCES_NAMES = %w[
+      Unison
+      Second
+      Third
+      Fourth
+      Fifth
+      Sixth
+      Seventh
+    ].freeze
+
+    COMPOUND_DISTANCES_NAMES = [
+      'Octave',
+      'Ninth',
+      'Tenth',
+      'Eleventh',
+      'Twelfth',
+      'Thirteenth',
+      'Fourteenth',
+      'Double Octave'
+    ].freeze
+
+    DISTANCES_NAMES = (SINGLE_DISTANCES_NAMES + COMPOUND_DISTANCES_NAMES).freeze
+
+    QUALITY_NAMES = {
+      'P' => 'Perfect',
+      'm' => 'Minor',
+      'M' => 'Major',
+      'A' => 'Augmented',
+      'd' => 'Diminished'
+    }.freeze
+
+    class << self
+      def distances_names
+        DISTANCES_NAMES
+      end
 
-    def self.split(interval)
-      interval.scan(/(\w)(\d\d?)/)[0]
-    end
+      def distance_name(n)
+        DISTANCES_NAMES[n - 1]
+      end
 
-    def self.full_name(interval)
-      q, n = split(interval)
-      "#{q.interval_quality} #{n.to_i.interval_name}"
-    end
+      def quality_name(q)
+        QUALITY_NAMES[q]
+      end
 
-    def self.method_missing; end
+      def names
+        @names ||= begin
+          SINGLE_DISTANCES_NAMES.each_with_index.reduce([]) do |i_names, (_d, i)|
+            i_names + QUALITY_SEQUENCE[i % 7].reduce([]) do |qs, q|
+              qs + ["#{q}#{i + 1}"]
+            end
+          end
+        end
+      end
 
-    # Create full names and methods such as major_third? minor_seventh?
-    # TODO: It's a mess and it really needs a refactor someday
-    NAMES = INTERVALS.each_with_index.each_with_object({}) do |(interval, index), memo|
-      memo[interval] ||= []
-      2.times do |o|
-        q, i = split(interval)
-        num = o * 7 + i.to_i
-        prev_q = split(INTERVALS[(index - 1) % 12])[0]
-        next_q = split(INTERVALS[(index + 1) % 12])[0]
-        memo[interval] << full_name("#{q}#{num}")
-        memo[interval] << full_name("d#{(num - 1 + 1) % 14 + 1}") if next_q.match? /m|P/
-        next if q == 'A'
-        memo[interval] << full_name("A#{(num - 1 - 1) % 14 + 1}") if prev_q.match? /M|P/
+      def compound_names
+        @compound_names ||= all.map(&:compound_name)
+      end
+
+      def all_names_including_compound
+        @all_names_including_compound ||= names + compound_names
       end
-    end
 
-    ALL_FULL_NAMES = NAMES.values.flatten
+      def full_names
+        @full_names ||= names.map { |n| expand_name(n) }
+      end
 
-    NAMES.each do |interval_name, full_names|
-      full_names.each do |the_full_name|
-        define_method "#{the_full_name.underscore}?" do
-          name == interval_name
-        end
-        IntervalClass.class.define_method the_full_name.underscore.to_s do
-          IntervalClass.new(interval_name)
-        end
+      def all
+        @all ||= names.map { |n| IntervalClass[n] }
+      end
+
+      def full_names_including_compound
+        @full_names_including_compound ||=
+          all_names_including_compound.map { |n| expand_name(n) }
+      end
+
+      def split(interval)
+        interval.scan(/(\w)(\d\d?)/)[0]
+      end
+
+      def expand_name(name)
+        q, n = split(name)
+        (
+          case name
+          when /AA|dd/ then 'Double '
+          when /AAA|ddd/ then 'Triple '
+          else ''
+          end
+        ) + "#{quality_name(q)} #{distance_name(n.to_i)}"
       end
     end
 
     def initialize(arg)
       super case arg
-            when Interval then arg.semitones
+            when FrequencyInterval then arg.semitones
             when String
-              INTERVALS.index(arg) || self.class.interval_by_full_name(arg)
+              self.class.names.index(arg) ||
+                self.class.full_names.index(arg) ||
+                self.class.all_names_including_compound.index(arg) ||
+                self.class.full_names_including_compound.index(arg)
             when Numeric then arg
-            else raise WrongArgumentsError
+            else
+              raise WrongArgumentsError,
+                    'Provide: [interval] || [name] || [number of semitones]'
             end % 12 * 100
     end
 
-    def self.[](semis)
-      new semis
-    end
+    instance_eval { alias [] new }
 
-    def all_full_names
-      self.class.all_full_names
+    def interval
+      Interval.new(letter_distance: distance, semitones: semitones)
     end
 
-    def self.all_full_names
-      ALL_FULL_NAMES
+    def compound_interval
+      Interval.new(
+        letter_distance: distance,
+        semitones: semitones,
+        compound: true
+      )
     end
 
+    alias compound compound_interval
+
     def ==(other)
-      (cents % 12) == (other.cents % 12)
+      return false unless other.is_a? FrequencyInterval
+      (semitones % 12) == (other.semitones % 12)
     end
 
-    def name
-      INTERVALS[semitones % 12]
+    def alteration
+      name.chars.reduce(0) { |a, s| a + (ALTERATIONS[s] || 0) }
+    end
+
+    def ascending
+      self.class[semitones.abs]
+    end
+
+    def descending
+      self.class[-semitones.abs]
+    end
+
+    def inversion
+      self.class[-semitones % 12]
     end
 
     def full_name
-      self.class.full_name(name)
+      self.class.expand_name(name)
+    end
+
+    def name
+      self.class.names[semitones % 12]
+    end
+
+    def compound_name
+      "#{quality}#{distance + 7}"
+    end
+
+    def distance
+      self.class.split(name)[1].to_i
     end
 
-    def full_names
-      NAMES[name]
+    def quality
+      self.class.split(name)[0]
     end
 
     def +(other)