coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/theory/pitch_class.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    #
+    # Pitch classes, and by classes here we don't mean in the sense of a ruby class
+    # are all the classes of pitches (frequencies) that are in a whole number of
+    # octaves apart.
+    #
+    # For example, C1, C2, C3 are all pitches from the C pitch class. Take a look into
+    # Notes description if you somehow feel this is confuse and that it could just be
+    # called as notes instead.
+    #
+    class PitchClass
+      attr_reader :integer
+      include Comparable
+
+      NOTATION = %w[C C# D D# E F F# G G# A A# B].freeze
+
+      def self.all_letters
+        %w[C D E F G A B]
+      end
+
+      def self.all
+        NOTATION.map { |n| new(n) }
+      end
+
+      def initialize(arg = nil, frequency: nil)
+        @integer = case arg
+                   when String then NOTATION.index(arg)
+                   when Frequency then frequency_to_integer(Frequency.new(arg))
+                   when Numeric then (arg % 12)
+                   when nil then frequency_to_integer(Frequency.new(frequency))
+                   when PitchClass then arg.integer
+                   else raise(WrongArgumentsError)
+                   end
+      end
+
+      def self.[](arg, frequency: nil)
+        new(arg, frequency: nil)
+      end
+
+      def ==(other)
+        integer == other.integer
+      end
+
+      alias eql? ==
+      alias hash integer
+
+      def true_notation
+        NOTATION[integer]
+      end
+
+      def letter
+        name[0]
+      end
+
+      def ascending_interval_to(other)
+        Interval.new(self, (other.is_a?(PitchClass) ? other : Note.new(other)))
+      end
+
+      alias interval_to ascending_interval_to
+
+      def descending_interval_to(other)
+        Interval.new(
+          self,
+          (other.is_a?(PitchClass) ? other : Note.new(other)),
+          ascending: false
+        )
+      end
+
+      alias name true_notation
+
+      def pretty_name
+        name.tr('b', "\u266D").tr('#', "\u266F")
+      end
+
+      def accidental?
+        notation.match? /#|b/
+      end
+
+      def sharp?
+        notation.match? /#/
+      end
+
+      def flat?
+        notation.match? /b/
+      end
+
+      alias notation true_notation
+      alias to_s true_notation
+
+      def +(other)
+        case other
+        when Interval   then self.class[integer + other.semitones]
+        when Integer    then self.class[integer + other]
+        when PitchClass then self.class[integer + other.integer]
+        when Frequency  then self.class.new(frequency: frequency + other)
+        end
+      end
+
+      def -(other)
+        case other
+        when Interval   then self.class[integer - other.semitones]
+        when Integer    then self.class[integer - other]
+        when PitchClass then Interval.new(self, other)
+        when Frequency  then self.class.new(frequency: frequency - other)
+        end
+      end
+
+      def pitch_class
+        self
+      end
+
+      def <=>(other)
+        integer <=> other.integer
+      end
+
+      def fundamental_frequency
+        @fundamental_frequency ||=
+          Frequency[
+            Theory.base_tuning *
+            (2**((integer - Theory::BASE_PITCH_INTEGER.to_f) / 12))
+          ]
+      end
+
+      alias frequency fundamental_frequency
+
+      def self.size
+        NOTATION.size
+      end
+
+      def size
+        self.class.size
+      end
+
+      def enharmonic?(other)
+        case other
+        when String then integer == Note[other].integer
+        when Note then integer == other.integer
+        end
+      end
+
+      private
+
+      def frequency_to_integer(f)
+        begin
+          (::BASE_PITCH_INTEGER +
+            size * Math.log(f.to_f / Theory.base_tuning.to_f, 2)) % size
+        end.round
+      end
+    end
+  end
+end

data/lib/coltrane/theory/progression.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # Allows the creation of chord progressions using standard notations.
+    # Ex: Progression.new('I-IV-V', key: 'Am')
+    class Progression
+      extend NotableProgressions
+      include Changes
+      attr_reader :scale, :chords, :notation
+
+      def self.find(*chords)
+        chords
+          .yield_self { |chords|
+            next chords if chords[0].is_a?(Chord)
+            chords.map {|c| Chord.new(name: c) }
+          }
+          .yield_self { |chords|
+            NoteSet[*chords.map(&:root_note)]
+            .yield_self { |root_notes|
+              Scale.having_notes(*root_notes).strict_scales
+            }
+            .reduce([]) { |memo, scale|
+              memo + [Progression.new(chords: chords, scale: scale)]
+            }
+          }
+          .yield_self { |progressions| ProgressionSet.new(*progressions) }
+      end
+
+      def initialize(notation = nil, chords: nil, roman_chords: nil, key: nil, scale: nil)
+        if notation.nil? && chords.nil? && roman_chords.nil? || key.nil? && scale.nil?
+          raise WrongKeywordsError,
+            '[chords:, [scale: || key:]] '\
+            '[roman_chords:, [scale: || key:]] '\
+            '[notation:, [scale: || key:]] '\
+        end
+
+        @scale  = scale || Key[key]
+        @chords =
+          if !chords.nil?
+            chords
+          elsif !roman_chords.nil?
+            roman_chords.map(&:chord)
+          elsif !notation.nil?
+            @notation = notation
+            notation.split('-').map { |c| RomanChord.new(c, scale: @scale).chord }
+          end
+      end
+
+      def interval_sequence
+        @interval_sequence ||= IntervalSequence(notes: @root_notes)
+      end
+
+      def root_notes
+        @root_notes ||= @chords.map(&:root_note)
+      end
+
+      def roman_chords
+        @roman_chords ||= chords.map do |c|
+          RomanChord.new(chord: c, scale: scale)
+        end
+      end
+
+      def notation
+        roman_chords.map(&:notation).join('-')
+      end
+
+      def notes
+        NoteSet[*chords.map(&:notes).map(&:notes).flatten]
+      end
+
+      def notes_out
+        notes - scale.notes
+      end
+
+      def notes_out_size
+        notes_out.size
+      end
+    end
+  end
+end

data/lib/coltrane/theory/progression_set.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    class ProgressionSet
+      extend Forwardable
+      include Enumerable
+
+      def_delegators :progressions, :each
+
+      attr_accessor :progressions
+
+      def initialize(*progressions)
+        @progressions = progressions.sort_by(&:notes_out_size)
+      end
+    end
+  end
+end

data/lib/coltrane/theory/roman_chord.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # This class deals with chords in roman notation. Ex: IVº.
+    class RomanChord
+      DIGITS = %w[I II III IV V VI VII].freeze
+      NOTATION_REGEX = /(b?[ivIV]*)(.*)/
+
+      NOTATION_SUBSTITUTIONS = [
+        %w[º dim],
+        %w[o dim],
+        %w[ø m7b5]
+      ].freeze
+
+      def initialize(notation = nil, chord: nil, key: nil, scale: nil)
+        if notation.nil? && chord.nil? || key.nil? && scale.nil?
+          raise WrongKeywordsError,
+                '[notation, [scale: || key:]] '\
+                '[chord:, [scale: || key:]] '\
+        end
+        @scale = scale || Key[key]
+        if notation
+          @notation = notation
+        elsif chord
+          @chord = chord.is_a?(String) ? Chord.new(name: chord) : chord
+        end
+      end
+
+      def degree
+        return @scale.degree_of_note(root_note) unless @chord.nil?
+        d      = regexed_notation[:degree]
+        @flats = d.count('b')
+        d      = d.delete('b')
+        @degree ||= DIGITS.index(d.upcase) + 1
+      end
+
+      def roman_numeral
+        r = DIGITS[degree]
+        minor? ? r.downcase : r
+      end
+
+      def upcase?
+        !!(regexed_notation[:degree][0].match /[[:upper:]]/)
+      end
+
+      def chord
+        @chord ||= Chord.new root_note: root_note,
+                             quality: quality
+      end
+
+      def minor?
+        quality.has_minor_third?
+      end
+
+      def major?
+        quality.has_major_third?
+      end
+
+      def quality_name
+        return @chord.quality.name unless @chord.nil?
+        q     = normalize_quality_name(regexed_notation[:quality])
+        minor = 'm' if (!q.match? /dim|m7b5/) && !upcase?
+        q     = [minor, q].join
+        q.empty? ? 'M' : q
+      end
+
+      def quality
+        return @chord.quality unless @chord.nil?
+        ChordQuality.new(name: quality_name) if quality_name
+      end
+
+      def root_note
+        return @chord.root_note unless @chord.nil?
+        @scale[degree] - @flats
+      end
+
+      def notation
+        q = case quality_name
+            when 'm', 'M' then ''
+            when 'm7', 'M' then '7'
+            else quality_name
+        end
+
+        @notation ||= [
+          roman_numeral,
+          q
+        ].join
+      end
+
+      def function
+        return if @scale.name != 'Major'
+        %w[Tonic Supertonic Mediant Subdominant
+           Dominant Submediant Leading][degree - 1]
+      end
+
+      private
+
+      def regexed_notation
+        @regexed_notation ||= begin
+          matchdata = @notation.match(NOTATION_REGEX)
+          { degree: matchdata[1], quality: matchdata[2] }
+        end
+      end
+
+      def normalize_quality_name(quality_name)
+        NOTATION_SUBSTITUTIONS.reduce(quality_name) do |memo, subs|
+          break memo if memo.empty?
+          memo.gsub(*subs)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/theory/scale.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # Musical scale creation and manipulation
+    class Scale
+      extend ClassicScales
+      extend Forwardable
+
+      def_delegators :notes, :accidentals, :sharps, :flats
+
+      attr_reader :interval_sequence, :tone
+
+      def initialize(*relative_intervals, tone: 'C',
+                     mode: 1,
+                     name: nil,
+                     notes: nil)
+        @name = name
+        if relative_intervals.any? && tone
+          @tone              = Note[tone]
+          relative_intervals = relative_intervals.rotate(mode - 1)
+          @interval_sequence = IntervalSequence.new(
+            relative_intervals: relative_intervals
+          )
+        elsif notes
+          @notes             = NoteSet[*notes]
+          @tone              = @notes.first
+          ds                 = @notes.interval_sequence.relative_intervals
+          @interval_sequence = IntervalSequence.new(relative_intervals: ds)
+        else
+          raise WrongKeywordsError,
+                '[*relative_intervals, tone: "C", mode: 1] || [notes:]'
+        end
+      end
+
+      def id
+        [(name || @interval_sequence), tone.number]
+      end
+
+      def ==(other)
+        id == other.id
+      end
+
+      def name
+        @name ||= begin
+          is = interval_sequence.relative_intervals
+          (0...is.size).each do |i|
+            if (scale_name = ::ClassicScales::SCALES.key(is.rotate(i)))
+              return scale_name
+            end
+          end
+          nil
+        end
+      end
+
+      def full_name
+        "#{tone} #{name}"
+      end
+
+      alias to_s full_name
+
+      def pretty_name
+        "#{tone.pretty_name} #{name}"
+      end
+
+      alias full_name pretty_name
+
+      def degree(d)
+        raise WrongDegreeError, d if d < 1 || d > size
+        tone + interval_sequence[d - 1].semitones
+      end
+
+      alias [] degree
+
+      def degrees
+        (1..size)
+      end
+
+      def degree_of_chord(chord)
+        return if chords(chord.size).map(&:name).include?(chord.name)
+        degree_of_note(chord.root_note)
+      end
+
+      def degree_of_note(note)
+        notes.index(note)
+      end
+
+      def &(other)
+        raise HasNoNotesError unless other.respond_to?(:notes)
+        notes & other
+      end
+
+      def include_notes?(arg)
+        noteset = arg.is_a?(Note) ? NoteSet[arg] : arg
+        (self & noteset).size == noteset.size
+      end
+
+      alias include? include_notes?
+
+      def notes
+        @notes ||= NoteSet[*degrees.map { |d| degree(d) }]
+      end
+
+      def interval(i)
+        interval_sequence[(i - 1) % size]
+      end
+
+      def size
+        interval_sequence.size
+      end
+
+      def tertians(n = 3)
+        degrees.size.times.reduce([]) do |memo, d|
+          ns = NoteSet[ *Array.new(n) { |i| notes[(d + (i * 2)) % size] } ]
+          begin
+            chord = Chord.new(notes: ns)
+          rescue ChordNotFoundError
+            memo
+          else
+            memo + [chord]
+          end
+        end
+      end
+
+      def triads
+        tertians(3)
+      end
+
+      def sevenths
+        tertians(4)
+      end
+
+      def pentads
+        tertians(5)
+      end
+
+      def progression(*degrees)
+        Progression.new(self, degrees)
+      end
+
+      def chords(size = 3..12)
+        size = (size..size) if size.is_a?(Integer)
+        scale_rotations = interval_sequence.inversions
+        ChordQuality.intervals_per_name.reduce([]) do |memo1, (qname, qintervals)|
+          next memo1 unless size.include?(qintervals.size)
+          memo1 + scale_rotations.each_with_index
+                                 .reduce([]) do |memo2, (rot, index)|
+                    if (rot & qintervals).size == qintervals.size
+                      memo2 + [Chord.new(root_note: degree(index + 1),
+                                         quality: ChordQuality.new(name: qname))]
+                    else
+                      memo2
+                    end
+                  end
+        end
+      end
+
+      alias all_chords chords
+    end
+  end
+end