coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/theory/frequency.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    class Frequency
+      attr_reader :frequency
+
+      def initialize(frequency)
+        @frequency = frequency.to_f
+      end
+
+      class << self
+        alias [] new
+      end
+
+      def to_s
+        "#{frequency}hz"
+      end
+
+      def to_f
+        frequency
+      end
+
+      def octave(n)
+        Frequency[frequency * 2**n]
+      end
+
+      def ==(other)
+        frequency == (other.is_a?(Frequency) ? other.frequency : other)
+      end
+
+      def octave_up(n = 1)
+        octave(n)
+      end
+
+      def octave_down(n = 1)
+        octave(-n)
+      end
+
+      def /(other)
+        case other
+        when Frequency then FrequencyInterval[1200 * Math.log2(other.frequency / frequency)]
+        when Numeric then Frequency[frequency / other]
+        end
+      end
+
+      def method_missing(method, *args)
+        Frequency[frequency.send(method, args[0].to_f)]
+      end
+    end
+  end
+end

data/lib/coltrane/theory/frequency_interval.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # 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
+end

data/lib/coltrane/theory/interval.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    class Interval < IntervalClass
+      attr_reader :letter_distance, :cents
+      alias compound? compound
+
+      class << self
+        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 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(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 self.[](arg)
+        new(arg)
+      end
+
+      def interval_class
+        FrequencyInterval[cents].interval_class
+      end
+
+      def compound?
+        @compound
+      end
+
+      def has_augmented?
+        name.match? /M|P|A/
+      end
+
+      def has_diminished?
+        name.match? /m|P|d/
+      end
+
+      def accidentals
+        if distance_to_starting.positive? then 'A' * distance_to_starting.abs
+        elsif distance_to_starting.negative? then 'd' * distance_to_starting.abs
+        else ''
+        end
+      end
+
+      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 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 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 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
+end

data/lib/coltrane/theory/interval_class.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # Interval class here is not related to the Object Oriented Programming context
+    # but to the fact that there is a class of intervals that can all be categorized
+    # as having the same quality.
+    #
+    # 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 < 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 distance_name(n)
+          DISTANCES_NAMES[n - 1]
+        end
+
+        def quality_name(q)
+          QUALITY_NAMES[q]
+        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
+
+        def compound_names
+          @compound_names ||= all.map(&:compound_name)
+        end
+
+        def all_names_including_compound
+          @all_names_including_compound ||= names + compound_names
+        end
+
+        def full_names
+          @full_names ||= names.map { |n| expand_name(n) }
+        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 FrequencyInterval then arg.semitones
+              when String
+                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,
+                      'Provide: [interval] || [name] || [number of semitones]'
+              end % 12 * 100
+      end
+
+      instance_eval { alias [] new }
+
+      def interval
+        Interval.new(letter_distance: distance, semitones: semitones)
+      end
+
+      def compound_interval
+        Interval.new(
+          letter_distance: distance,
+          semitones: semitones,
+          compound: true
+        )
+      end
+
+      alias compound compound_interval
+
+      def ==(other)
+        return false unless other.is_a? FrequencyInterval
+        (semitones % 12) == (other.semitones % 12)
+      end
+
+      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.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 quality
+        self.class.split(name)[0]
+      end
+
+      def +(other)
+        IntervalClass[semitones + other]
+      end
+
+      def -(other)
+        IntervalClass[semitones - other]
+      end
+
+      def -@
+        IntervalClass[-semitones]
+      end
+
+      private
+
+      def self.interval_by_full_name(arg)
+        NAMES.invert.each do |full_names, interval_name|
+          return INTERVALS.index(interval_name) if full_names.include?(arg)
+        end
+        raise IntervalNotFoundError, arg
+      end
+    end
+  end
+end