coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/representation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'coltrane'
+
+module Coltrane
+  module Representation
+    autoload :Guitar,  'coltrane/representation/guitar'
+    autoload :Ukulele, 'coltrane/representation/guitar_like_instruments'
+    autoload :Bass,    'coltrane/representation/guitar_like_instruments'
+    autoload :Piano,   'coltrane/representation/piano'
+  end
+end

data/lib/coltrane/representation/guitar.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'coltrane/representation/guitar/chord'
+require 'coltrane/representation/guitar/note'
+require 'coltrane/representation/guitar/note_set'
+require 'coltrane/representation/guitar/string'
+
+module Coltrane
+  module Representation
+    class Guitar
+      # A base class for operations involving Guitars
+      attr_reader :strings, :tuning, :frets, :special_frets
+
+      def self.find_chords(target_chord)
+        unless target_chord.is_a?(Theory::Chord)
+          target_chord = Theory::Chord.new(name: target_chord)
+        end
+
+        Guitar::Chord.find(target_chord, guitar: new)
+      end
+
+      def self.find_notes(notes)
+        Guitar::NoteSet.new(notes, guitar: new)
+      end
+
+      def initialize(tuning: nil, frets: nil, special_frets: nil)
+        @tuning        = tuning        || %w[E2 A2 D3 G3 B3 E4]
+        @special_frets = special_frets || [3, 5, 7, 9, 12, 15, 17, 19]
+        @frets         = frets         || 23
+
+        @strings = @tuning.map { |p| String.new(Theory::Pitch[p], guitar: self) }
+      end
+    end
+  end
+end

data/lib/coltrane/representation/guitar/chord.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Representation
+    class Guitar
+      # This class represents a group of guitar notes, strummed at the same time
+      class Chord
+        include Comparable
+        attr_reader :guitar_notes, :guitar, :free_fingers, :target_chord, :barre
+
+        MAX_FRET_SPAN = 3
+
+        def self.find(chord, guitar:)
+          new(chord, guitar: guitar)
+          .fetch_descendant_chords
+          .sort
+          .reverse
+        end
+
+        def initialize(target_chord,
+                       guitar_notes: [],
+                       free_fingers: 4,
+                       barre: nil,
+                       guitar:)
+
+          @target_chord = target_chord
+          @guitar_notes = guitar_notes
+          @free_fingers = free_fingers
+          @guitar       = guitar
+          @barre        = barre
+        end
+
+        def max_fret_span
+          MAX_FRET_SPAN
+        end
+
+        def <=>(other)
+          rank <=> other.rank
+        end
+
+        def rank
+          +completeness * 10_000 +
+          +fullness     * 1000 +
+          -spreadness   * 100 +
+          +easyness     * 1
+        end
+
+        def analysis
+          {
+            completeness: completeness,
+            fullness:     fullness,
+            easyness:     easyness,
+            spreadness:   spreadness
+          }
+        end
+
+        def spreadness
+          fret_range.size.to_f / MAX_FRET_SPAN
+        end
+
+        def completeness
+          (target_chord.notes.size.to_f - notes_left.size) / target_chord.notes.size
+        end
+
+        def easyness
+          frets.count(0).to_f / guitar_notes.size
+        end
+
+        def fullness
+          (guitar.strings.size.to_f - frets.count(nil)) / guitar.strings.size
+        end
+
+        def barre?
+          !@barre.nil?
+        end
+
+        def fetch_descendant_chords
+          return [self] if guitar_notes.size >= guitar.strings.size
+          possible_new_notes(notes_available.positive?).reduce([]) do |memo, n|
+            barre = n.fret if guitar_notes.last == n.fret
+            fingers_change = n.fret == barre || n.fret.zero? ? 0 : 1
+            next memo if (free_fingers - fingers_change).negative?
+            self.class.new(target_chord,
+              guitar_notes: guitar_notes + [n],
+              free_fingers: free_fingers - fingers_change,
+              guitar: guitar,
+              barre: barre
+            ).fetch_descendant_chords + memo
+          end
+        end
+
+        def notes_available
+          strings_available - notes_left.size
+        end
+
+        def strings_available
+          guitar.strings.size - guitar_notes.size
+        end
+
+        def notes_left
+          @notes_left ||= begin
+                            target_chord.notes - Theory::NoteSet[
+                            *guitar_notes.map do |n|
+                              next if n.pitch.nil?
+                              n.pitch.pitch_class
+                            end
+                          ]
+                          end
+        end
+
+        def target_notes
+          notes_left.any? ? notes_left : target_chord.notes
+        end
+
+        def notes
+          guitar_notes.map(&:pitch)
+        end
+
+        def frets
+          @frets ||= guitar_notes.map(&:fret)
+        end
+
+        def non_zero_frets
+          frets.reject { |f| f.nil? || f.zero? }
+        end
+
+        def lowest_fret
+          non_zero_frets.any? ? non_zero_frets.min : 0
+        end
+
+        def highest_fret
+          non_zero_frets.max || 0
+        end
+
+        def fret_range
+          (lowest_fret..highest_fret)
+        end
+
+        def lowest_possible_fret
+          lowest_fret.zero? ? 0 : [(lowest_fret - possible_span), 0].max
+        end
+
+        def highest_possible_fret
+          [(possible_span + (highest_fret == 0 ? guitar.frets : highest_fret)), guitar.frets].min
+        end
+
+        def possible_span
+          MAX_FRET_SPAN - fret_range.size
+        end
+
+        def fret_expansion_range
+          (lowest_possible_fret..highest_possible_fret).to_a +
+            [(0 unless barre?)].compact
+        end
+
+        def to_s
+          guitar_notes.map { |n| n.fret.nil? ? 'x' : n.fret }.join('-')
+        end
+
+        def voicing
+          Coltrane::Voicing.new(pitches: guitar_notes.map(&:pitch).compact)
+        end
+
+        private
+
+        attr_writer :barre
+
+        def next_string
+          guitar.strings[guitar_notes.size]
+        end
+
+        def possible_new_notes(include_mute_note = false)
+          target_notes.notes.map do |note|
+            next_string.find(note, possible_frets: fret_expansion_range)
+          end.flatten + [(Guitar::Note.new(next_string, nil) if include_mute_note)].compact
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/representation/guitar/note.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Representation
+    class Guitar
+      class Note
+        attr_reader :string, :fret
+
+        def initialize(string, fret = nil)
+          @string = string
+          @fret   = fret
+        end
+
+        def pitch
+          string + fret unless fret.nil?
+        end
+
+        def pitch_class
+          pitch.pitch_class unless fret.nil?
+        end
+
+        alias note pitch_class
+      end
+    end
+  end
+end

data/lib/coltrane/representation/guitar/note_set.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Representation
+    class Guitar
+      class NoteSet
+        extend Forwardable
+        include Enumerable
+
+        attr_reader :notes, :guitar
+        def_delegators :notes, :each, :root
+
+        def initialize(note_set, guitar:)
+          @notes  = note_set
+          @guitar = guitar
+        end
+
+        instance_eval { alias [] new }
+
+        def results
+          @strings ||= begin
+            guitar.strings.map do |string|
+              {
+                pitch: string.pitch,
+                notes: notes.map { |note| string.find(note) }
+              }
+            end
+          end
+        end
+
+        alias strings results
+      end
+    end
+  end
+end

data/lib/coltrane/representation/guitar/string.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Representation
+    class Guitar
+      class String
+        attr_reader :pitch, :guitar
+
+        def initialize(pitch, guitar:)
+          @guitar = guitar
+          @pitch = pitch
+        end
+
+        def find(pitch_class, possible_frets: (0..guitar.frets).to_a)
+          output = []
+          n = 0
+          loop do
+            f = (pitch_class.integer - pitch.integer) % 12 + 12 * n
+            possible_frets.include?(f) ? output << Note.new(self, f) : break
+            n += 1
+          end
+          output
+        end
+
+        def +(fret)
+          pitch + fret
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/representation/guitar_like_instruments.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'coltrane/representation/guitar'
+
+module Coltrane
+  module Representation
+    class Ukulele < Guitar
+      def initialize(tuning: %w[G3 C4 E4 A4],
+                     frets: 12,
+                     special_frets: [5, 7, 9, 12])
+      super
+      end
+    end
+
+    class Bass < Guitar
+      def initialize(tuning: %w[E1 A1 D2 G2])
+      super
+      end
+    end
+  end
+end

data/lib/coltrane/representation/piano.rb

@@ -0,0 +1,36 @@
+require 'coltrane/representation/piano/note_set'
+
+module Coltrane
+  module Representation
+    class Piano
+      attr_reader :octaves
+
+      class << self
+
+        def find_notes(notes)
+          Piano::NoteSet.new(notes, piano: new)
+        end
+
+        def chord(chord)
+          find_notes(
+            chord.is_a?(Chord) ? chord.notes : Chord.new(name: chord).notes
+          )
+        end
+
+        def black_notes
+          Theory::Scale.pentatonic_major('C#', 4).notes
+        end
+
+        def white_notes
+          Theory::Scale.major.notes
+        end
+
+      end
+
+      def initialize
+        @octaves
+      end
+    end
+  end
+end
+

data/lib/coltrane/representation/piano/note_set.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Representation
+    class Piano
+      class NoteSet
+        extend Forwardable
+        include Enumerable
+
+        attr_reader :notes, :piano
+        def_delegators :notes, :each, :root
+
+        def initialize(note_set, piano:)
+          @notes = note_set
+          @piano = piano
+        end
+
+        instance_eval { alias [] new }
+      end
+    end
+  end
+end

data/lib/coltrane/theory.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Coltrane
+  # The main module for working with Music Theory
+  module Theory
+    require 'coltrane/theory/errors'
+    autoload :Frequency, 'coltrane/theory/frequency'
+
+    BASE_OCTAVE = 4
+    BASE_PITCH_INTEGER = 9
+
+    def self.tuning=(f)
+      @base_tuning = Frequency[f].octave(-4)
+    end
+
+    def self.base_tuning
+      @base_tuning
+    end
+
+    @base_tuning = Frequency[440].octave(-4)
+
+    autoload :Pitch,                  'coltrane/theory/pitch'
+    autoload :Voicing,                'coltrane/theory/voicing'
+
+    autoload :PitchClass,             'coltrane/theory/pitch_class'
+    autoload :Note,                   'coltrane/theory/note'
+    autoload :NoteSet,                'coltrane/theory/note_set'
+
+    autoload :FrequencyInterval,      'coltrane/theory/frequency_interval'
+    autoload :IntervalClass,          'coltrane/theory/interval_class'
+    autoload :Interval,               'coltrane/theory/interval'
+    autoload :UnorderedIntervalClass, 'coltrane/theory/unordered_interval_class'
+    autoload :IntervalSequence,       'coltrane/theory/interval_sequence'
+    autoload :Qualities,              'coltrane/theory/qualities'
+    autoload :ChordQuality,           'coltrane/theory/chord_quality'
+    autoload :Chord,                  'coltrane/theory/chord'
+    autoload :ChordSubstitutions,     'coltrane/theory/chord_substitutions'
+    autoload :RomanChord,             'coltrane/theory/roman_chord'
+
+    autoload :ClassicScales,          'coltrane/theory/classic_scales'
+    autoload :Scale,                  'coltrane/theory/scale'
+    autoload :ScaleSet,               'coltrane/theory/scale_set'
+    autoload :CircleOfFifths,         'coltrane/theory/circle_of_fifths'
+    autoload :DiatonicScale,          'coltrane/theory/diatonic_scale'
+    autoload :Key,                    'coltrane/theory/key'
+
+    autoload :NotableProgressions,    'coltrane/theory/notable_progressions'
+    autoload :Changes,                'coltrane/theory/changes'
+    autoload :Cadence,                'coltrane/theory/cadence'
+    autoload :ProgressionSet,         'coltrane/theory/progression_set'
+    autoload :Progression,            'coltrane/theory/progression'
+    autoload :Mode,                   'coltrane/theory/mode'
+  end
+end