coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/theory/interval_sequence.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # It describes a sequence of intervals
+    class IntervalSequence
+      extend Forwardable
+      attr_reader :intervals
+
+      def_delegators :@intervals, :map, :each, :[], :size,
+                     :reduce, :delete, :reject!, :delete_if, :detect, :to_a
+
+      def initialize(*intervals, notes: nil, relative_intervals: nil)
+        if intervals.any?
+          @intervals = if intervals.first.is_a?(Interval)
+                         intervals
+                       else
+                         intervals.map { |i| Interval[i] }
+          end
+
+        elsif notes
+          notes = NoteSet[*notes] if notes.is_a?(Array)
+          @intervals = intervals_from_notes(notes)
+        elsif relative_intervals
+          @relative_intervals = relative_intervals
+          @intervals = intervals_from_relative_intervals(relative_intervals)
+        else
+          raise WrongKeywordsError,
+                'Provide: [notes:] || [intervals:] || [relative_intervals:]'
+        end
+      end
+
+      Interval.all_including_compound_and_altered.each do |interval|
+        # Creates methods such as major_third, returning it if it finds
+        define_method(interval.full_name.underscore.to_s) { find(interval) }
+        # Creates methods such as has_major_third?, returning a boolean
+        define_method("has_#{interval.full_name.underscore}?") { has?(interval) }
+      end
+
+      Interval.distances_names.map(&:underscore).each_with_index do |distance, i|
+        # Creates methods such as has_third?, returning a boolean
+        define_method("has_#{distance}?") { !!find_by_distance(i + 1) }
+        # Creates methods such third, returning any third it finds
+        define_method(distance.to_s) { find_by_distance(i + 1) }
+        # Creates methods such third!, returning thirds that arent aug or dim
+        define_method("#{distance}!") { find_by_distance(i + 1, false) }
+      end
+
+      instance_eval { alias [] new }
+
+      def relative_intervals
+        intervals_semitones[1..-1].each_with_index.map do |n, i|
+          if i.zero?
+            n
+          elsif i < intervals_semitones.size
+            n - intervals_semitones[i]
+          end
+        end + [12 - intervals_semitones.last]
+      end
+
+      def names
+        intervals.map(&:name)
+      end
+
+      def find(interval)
+        interval.clone if detect { |i| interval == i }
+      end
+
+      def has?(interval)
+        !!find(interval)
+      end
+
+      def find_by_distance(n, accept_altered = true)
+        strategy = (accept_altered ? :as : :as!)
+        map { |interval| interval.send(strategy, n) }
+          .compact
+          .sort_by { |i| i.alteration.abs }
+          .first
+      end
+
+      alias interval_names names
+
+      def all
+        intervals
+      end
+
+      def [](x)
+        intervals[x]
+      end
+
+      def shift(ammount)
+        self.class.new(*intervals.map do |i|
+          (i.semitones + ammount) % 12
+        end)
+      end
+
+      def zero_it
+        shift(-intervals.first.semitones)
+      end
+
+      def inversion(index)
+        self.class.new(*intervals.rotate(index)).zero_it
+      end
+
+      def next_inversion
+        inversion(index + 1)
+      end
+
+      def previous_inversion
+        inversion(index - 1)
+      end
+
+      def inversions
+        Array.new(intervals.length) { |i| inversion(i) }
+      end
+
+      def intervals_semitones
+        map(&:semitones)
+      end
+
+      def names
+        map(&:name)
+      end
+
+      def full_names
+        map(&:full_name)
+      end
+
+      def notes_for(root_note)
+        NoteSet[
+          *intervals.reduce([]) do |memo, interval|
+            memo + [root_note + interval]
+          end
+        ]
+      end
+
+      def &(other)
+        case other
+        when Array then intervals & other
+        when IntervalSequence then intervals & other.semitones
+        end
+      end
+
+      private
+
+      def intervals_from_relative_intervals(relative_intervals)
+        relative_intervals[0..-2].reduce([Interval[0]]) do |memo, d|
+          memo + [memo.last + d]
+        end
+      end
+
+      def intervals_from_notes(notes)
+        notes.map { |n| notes.root - n }.sort_by(&:semitones)
+      end
+    end
+  end
+end

data/lib/coltrane/theory/key.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    class Key < DiatonicScale
+      KEY_REGEX = /([A-G][#b]?)([mM]?)/
+
+      def initialize(notation)
+        _, note, s = *notation.match(KEY_REGEX)
+        super(note, major: s != 'm')
+      end
+
+      def self.[](notation)
+        new(notation)
+      end
+    end
+  end
+end

data/lib/coltrane/theory/notable_progressions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # This module takes care of adding to progressions knowledge that is more
+    # based on common standards and practices.
+    module NotableProgressions
+      PROGRESSIONS = {
+        'Pop' => ['I-V-vi-IV', :major],
+        'Jazzy Pop' =>  ['IM7-V7-vi7-IVM7',      :major],
+        'Jazz' =>       ['ii7-V7-I7',            :major],
+        'Jazz Minor' => ['ii7-V7-i7',            :major],
+        'Blues' =>      ['IM7-IV7-I7-V7-IV7-I7', :major],
+        'Jazz Blues' => ['I7-IV7-I7-V7-IV7-I7',  :major],
+        'Fifties' =>    ['I-vi-IV-V',            :major],
+        'Circle' =>     ['vi-ii-V-I',            :major],
+        'Tune Up' =>    ['ii7-V7-IM7-i7-IV7-IVM7-VIIM7', :minor]
+      }.freeze
+
+      PROGRESSIONS.each do |name, values|
+        notation, scale_name = values
+        define_method name.underscore do |note|
+          note  = note.is_a?(Note) ? note : Note[note]
+          scale = Scale.public_send(scale_name, note)
+          new(notation, scale: scale)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/theory/note.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # Notes are different ways of calling pitch classes. In the context of equal
+    # tempered scales, they're more like a conceptual subject for
+    # matters of convention than an actual thing.
+    #
+    # Take for example A# and Bb. Those are different notes. Nevertheless, in the
+    # context of equal tempered scales they represent pretty much the same
+    # frequency.
+    #
+    # The theory of notes have changed too much in the course of time, which
+    # lead us with a lot of conventions and strategies when dealing with music.
+    # That's what this class is for.
+    class Note < PitchClass
+      attr_reader :alteration
+
+      ALTERATIONS = {
+        'b' => -1,
+        '#' => 1
+      }.freeze
+
+      def initialize(arg)
+        note_name = case arg
+                    when String then arg
+                    when PitchClass then arg.true_notation
+                    when Numeric, Frequency then PitchClass.new(arg).true_notation
+                    else raise(WrongArgumentsError, arg)
+                    end
+
+        chars  = note_name.chars
+        letter = chars.shift
+        raise InvalidNoteLetterError, arg unless ('A'..'G').cover?(letter)
+        @alteration = chars.reduce(0) do |alt, symbol|
+          raise InvalidNoteLetterError, arg unless ALTERATIONS.include?(symbol)
+          alt + ALTERATIONS[symbol]
+        end
+        super((PitchClass[letter].integer + @alteration) % PitchClass.size)
+      end
+
+      def self.[](arg)
+        new(arg)
+      end
+
+      def name
+        "#{base_pitch_class}#{accidents}".gsub(/#b|b#/, '')
+      end
+
+      def base_pitch_class
+        PitchClass[integer - alteration]
+      end
+
+      def pitch_class
+        PitchClass.new(self)
+      end
+
+      def alteration=(a)
+        @alteration = a unless PitchClass[integer - a].accidental?
+      end
+
+      def alter(x)
+        Note.new(name).tap { |n| n.alteration = x }
+      end
+
+      def sharp?
+        alteration == 1
+      end
+
+      def double_sharp?
+        alteration == 2
+      end
+
+      def flat?
+        alteration == -1
+      end
+
+      def double_flat?
+        alteration == -2
+      end
+
+      def natural?
+        alteration == 0
+      end
+
+      def accidents
+        (@alteration > 0 ? '#' : 'b') * alteration.abs
+      end
+
+      def -(other)
+        super(other).yield_self { |r| r.is_a?(Note) ? r.alter(alteration) : r }
+      end
+
+      def +(other)
+        super(other).yield_self { |r| r.is_a?(Note) ? r.alter(alteration) : r }
+      end
+
+      def as(letter)
+        a = (Note[letter] - self)
+        alter([a.semitones, -(-a).semitones].min_by(&:abs))
+      end
+    end
+  end
+end

data/lib/coltrane/theory/note_set.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # It describes a set of notes
+    class NoteSet
+      extend Forwardable
+
+      def_delegators :@notes, :first, :each, :size, :map, :reduce, :index,
+                     :[], :index, :empty?, :permutation, :include?, :<<, :any?,
+                     :count, :rotate
+
+      attr_reader :notes
+
+      alias root first
+      alias all notes
+
+      def self.[](*notes)
+        new(notes)
+      end
+
+      def initialize(arg)
+        @notes =
+          case arg
+          when NoteSet then arg.notes
+          when Array   then arg.compact.map { |n| n.is_a?(PitchClass) ? n : Note[n] }.uniq
+          else raise InvalidNotesError, arg
+          end
+      end
+
+      def ==(other)
+        (self & other).size == self.size
+      end
+
+      alias eql? ==
+
+      def &(other)
+        NoteSet[*(notes & other.notes)]
+      end
+
+      def degree(note)
+        index(note) + 1
+      end
+
+      def +(other)
+        case other
+        when Note then NoteSet[*(notes + [other])]
+        when NoteSet then NoteSet[*notes, *other.notes]
+        when Interval then NoteSet[*notes.map { |n| n + other }]
+        end
+      end
+
+      def -(other)
+        case other
+        when NoteSet then NoteSet[*(notes - other.notes)]
+        when Interval then NoteSet[*notes.map { |n| n - other }]
+        end
+      end
+
+      def pretty_names
+        map(&:pretty_name)
+      end
+
+      def names
+        map(&:name)
+      end
+
+      def hash
+        integers.join.to_i
+      end
+
+      def integers
+        map(&:integer)
+      end
+
+      def accidentals
+        count(&:accidental?)
+      end
+
+      def sharps
+        count(&:sharp?)
+      end
+
+      def flats
+        count(&:flat?)
+      end
+
+      def alter(alteration)
+        NoteSet[*map { |n| n.alter(alteration) }]
+      end
+
+      def alter_accidentals(alteration)
+        NoteSet[*map { |n| n.alter(alteration) if n.accidental? }]
+      end
+
+      def interval_sequence
+        IntervalSequence.new(notes: self)
+      end
+    end
+  end
+end

data/lib/coltrane/theory/pitch.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Theory
+    # It describes a pitch, like E4 or Bb5. It's like a note, but it has an octave
+    class Pitch
+      attr_reader :integer
+
+      def initialize(notation_arg = nil,
+                     note: nil,
+                     octave: nil,
+                     notation: nil,
+                     frequency: nil)
+
+        @integer = begin
+          if (n = notation_arg || notation)
+            n.is_a?(Integer) ? n : integer_from_notation(n)
+          elsif note && octave
+            integer_from_note_and_octave(Note[note], octave)
+          elsif frequency
+            integer_from_frequency(frequency)
+          else
+            raise(InvalidArgumentsError)
+          end
+        end
+      end
+
+      def self.[](*args)
+        new *args
+      end
+
+      def scientific_notation
+        "#{pitch_class}#{octave}"
+      end
+
+      def pitch_class
+        PitchClass[integer]
+      end
+
+      def octave
+        (integer / 12) - 1
+      end
+
+      alias notation scientific_notation
+      alias name     scientific_notation
+      alias to_s     scientific_notation
+
+      alias hash integer
+      alias midi integer
+
+      def ==(other)
+        integer == other.integer
+      end
+
+      def frequency
+        pitch_class.frequency.octave(octave)
+      end
+
+      alias eql? ==
+      alias eq ==
+
+      def +(other)
+        case other
+        when Integer then Pitch[integer + other]
+        end
+      end
+
+      def -(other)
+        case other
+        when Integer then Pitch[integer - other]
+        end
+      end
+
+      private
+
+      def integer_from_notation(the_notation)
+        _, n, o = *the_notation.match(/(\D+)(\d+)/)
+        integer_from_note_and_octave(Note[n], o)
+      end
+
+      def integer_from_note_and_octave(p, o)
+        12 * (o.to_i + 1) + p.integer
+      end
+
+      def integer_from_frequency(f)
+        octave_from_frequency(f) * 12 + PitchClass.new(frequency: f).integer
+      end
+
+      def octave_from_frequency(f)
+        Math.log(f.to_f / PitchClass['C'].frequency.to_f, 2).ceil
+      end
+    end
+  end
+end