coltrane 0.0.2

data/lib/coltrane/interval_sequence.rb

@@ -0,0 +1,70 @@
+module Coltrane
+  # It describes a sequence of intervals
+  class IntervalSequence
+    attr_reader :intervals
+
+    def initialize(arg)
+      arg = [arg] if arg.class != Array
+      @intervals = arg.reduce([]) do |memo, arg_item|
+        case arg_item
+        when Numeric  then memo << Interval.new(arg_item)
+        when Interval then memo << arg_item
+        when NoteSet  then memo + intervals_from_note_set(arg_item)
+        end
+      end
+    end
+
+    def intervals_from_note_set(note_set)
+      note_numbers = note_set.notes.collect(&:number)
+      root         = note_numbers.shift
+      note_numbers.reduce([Interval.new(0)]) do |memo, number|
+        number += 12 if number < root
+        memo << Interval.new(number - root)
+      end
+    end
+
+    def reordered
+      IntervalSequence.new @intervals.sort_by!(&:number)
+    end
+
+    def all
+      intervals
+    end
+
+    def [](x)
+      intervals[x]
+    end
+
+    def shift(ammount)
+      IntervalSequence.new(intervals.map do |i|
+        (i.number + ammount) % 12
+      end)
+    end
+
+    def zero_it
+      self.shift(-intervals.first.number)
+    end
+
+    def next_inversion
+      IntervalSequence.new(intervals.rotate(+1))
+    end
+
+    def previous_inversion
+      IntervalSequence.new(intervals.rotate(-1))
+    end
+
+    def inversions
+      Array.new(intervals.length) do |index|
+        IntervalSequence.new(interval.rotate(index))
+      end
+    end
+
+    def numbers
+      intervals.collect(&:number)
+    end
+
+    def names
+      intervals.collect(&:name)
+    end
+  end
+end

data/lib/coltrane/interval_set.rb

@@ -0,0 +1,23 @@
+
+# class IntervalSet
+#   def initialize(*intervals)
+#     @intervals = intervals
+#     @number_of_frets = 24
+#     sum = @intervals.reduce(:+)
+#     sum < 12 && @intervals << 12 - sum
+#   end
+
+#   def to_s
+#     @intervals.to_s
+#   end
+
+#   def to_frets(offset = 0)
+#     frets = [-offset]
+#     i = 0
+#     while frets.last < @number_of_frets
+#       frets << frets.last + @intervals[i % @intervals.length]
+#       i += 1
+#     end
+#     frets
+#   end
+# end

data/lib/coltrane/note.rb

@@ -0,0 +1,98 @@
+module Coltrane
+  # It describes a musical note, independent of octave
+  class Note
+    attr_reader :name
+
+    NOTES = {
+      'C'  => 0,
+      'C#' => 1,
+      'Db' => 1,
+      'D'  => 2,
+      'D#' => 3,
+      'Eb' => 3,
+      'E'  => 4,
+      'F'  => 5,
+      'F#' => 6,
+      'Gb' => 6,
+      'G'  => 7,
+      'G#' => 8,
+      'Ab' => 8,
+      'A'  => 9,
+      'A#' => 10,
+      'Bb' => 10,
+      'B'  => 11
+    }.freeze
+
+    def self.all
+      NOTES.keys.map {|n| Note.new(n)}
+    end
+
+    def accident?
+      [1,3,6,8,10].include?(number)
+    end
+
+    def initialize(arg)
+      case arg
+      when String
+        raise "invalid note: #{arg}" unless valid_note?(arg)
+        @name = arg
+      when Numeric then @name = name_from_number(arg)
+      end
+    end
+
+    def +(n)
+      case n
+        when Numeric then Note.new(number + n)
+        when Note then Chord.new(number + n.number)
+      end
+    end
+
+    def -(n)
+      case n
+        when Numeric then Note.new(number + n)
+        when Note then Interval.new((number - n.number) % 12)
+      end
+    end
+
+    def valid_note?(note_name)
+      NOTES.key?(note_name)
+    end
+
+    def number
+      NOTES[name]
+    end
+
+    def interval_to(note_name)
+      Interval.new(Note.new(note_name).number - number)
+    end
+
+    def transpose_by(interval_number)
+      @name = name_from_number(number + interval_number)
+      self
+    end
+
+    def guitar_notes
+      Guitar.strings.reduce([]) do |memo, guitar_string|
+        memo + in_guitar_string(guitar_string)
+      end
+    end
+
+    def on_guitar
+      GuitarNoteSet.new(guitar_notes).render
+    end
+
+    def in_guitar_string(guitar_string)
+      guitar_string.guitar_notes_for_note(self)
+    end
+
+    def in_guitar_string_region(guitar_string, region)
+      guitar_string.guitar_notes_for_note_in_region(self, region)
+    end
+
+    protected
+
+    def name_from_number(number)
+      NOTES.key(number % 12)
+    end
+  end
+end

data/lib/coltrane/note_set.rb

@@ -0,0 +1,50 @@
+module Coltrane
+  # It describes a set of notes
+  class NoteSet
+    attr_reader :notes
+
+    def initialize(arg)
+      @notes = case arg
+               when String then notes_from_note_string(arg)
+               when Array  then notes_from_note_array(arg)
+               end
+    end
+
+    def root_note
+      notes.sort_by(&:number).first
+    end
+
+    def transpose_to(note_name)
+      transpose_by(root_note.interval_to(note_name).number)
+    end
+
+    def transpose_by(interval)
+      notes.map do |note|
+        note.transpose_by(interval)
+      end
+    end
+
+    def guitar_notes
+      GuitarNoteSet.new(notes.map(&:guitar_notes).flatten)
+    end
+
+    def interval_sequence
+      IntervalSequence.new(self)
+    end
+
+    protected
+
+    def notes_from_note_string(note_string)
+      notes_from_note_array(note_string.split(' '))
+    end
+
+    def notes_from_note_array(note_array)
+      note_array.collect do |note|
+        case note
+        when String then Note.new(note)
+        when Note   then note
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/piano_representation.rb

@@ -0,0 +1,58 @@
+module Coltrane
+  class PianoRepresentation
+    PIANO_TEMPLATE = <<~ASCII
+      ┌─┬─┬┬─┬─╥─┬─┬┬─┬┬─┬─╥─┬─┬┬─┬─╥─┬─┬┬─┬┬─┬─┐
+      │ │ ││ │ ║ │ ││ ││ │ ║ │ ││ │ ║ │ ││ ││ │ │
+      │ │X││X│ ║ │X││X││X│ ║ │X││X│ ║ │X││X││X│ │
+      │ │X││X│ ║ │X││X││X│ ║ │X││X│ ║ │X││X││X│ │
+      │ ┕╥┙┕╥┙ ║ ┕╥┙┕╥┙┕╥┙ ║ ┕╥┙┕╥┙ ║ ┕╥┙┕╥┙┕╥┙ │
+      │XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX│
+      └──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──┘
+    ASCII
+
+    class << self
+      def render_intervals(notes, ref_note)
+        output = place_black_notes(Paint[PIANO_TEMPLATE, 'gray'], notes, ref_note)
+        place_white_notes(output, notes, ref_note)
+      end
+
+      def place_white_notes(input, notes, ref_note)
+        white_notes = Scale.major.notes
+        i = 0
+        output_array = input.split("\n")
+        output_array[5].gsub!('XX') do |match|
+          note = white_notes[i%7]
+          interval_name = (note - ref_note).name
+          i += 1
+          notes.map(&:name).include?(note.name) ? Paint[interval_name, 'red'] : '  '
+        end
+
+        output_array.join("\n")
+      end
+
+      def place_black_notes(input, notes, ref_note)
+        black_notes  = Scale.pentatonic_major('C#',4).notes
+        output_array = input.split("\n")
+
+        i = 0
+        output_array[2].gsub!('X') do |match|
+          note = black_notes[i%5]
+          interval_name = (note - ref_note).name
+          i += 1
+          notes.map(&:name).include?(note.name) ? Paint[interval_name[0], 'red'] : ' '
+        end
+
+        i = 0
+        output_array[3].gsub!('X') do |match|
+          note = black_notes[i%5]
+          interval_name = (black_notes[i%5] - ref_note).name
+          i += 1
+          notes.map(&:name).include?(note.name) ? Paint[interval_name[1], 'red'] : ' '
+        end
+
+        output_array.join("\n")
+      end
+    end
+
+  end
+end

data/lib/coltrane/pitch.rb

@@ -0,0 +1,27 @@
+module Coltrane
+  # It describes a pitch, like E4 or Bb5. It's like a note, but it has an octave
+  class Pitch
+    attr_reader :number
+
+    def initialize(pitch)
+      case pitch
+      when String  then @number = number_from_name(pitch)
+      when Numeric then @number = pitch
+      when Pitch   then @number = pitch.number
+      end
+    end
+
+    def number_from_name(pitch_string)
+      _, note, octaves = pitch_string.match(/(.*)(\d)/).to_a
+      Note.new(note).number + 12 * octaves.to_i
+    end
+
+    def name
+      "#{note.name}#{number / 12}"
+    end
+
+    def note
+      Note.new(number)
+    end
+  end
+end

data/lib/coltrane/progression.rb

@@ -0,0 +1,4 @@
+module Coltrane
+  class Progression
+  end
+end

data/lib/coltrane/qualities.rb

@@ -0,0 +1,115 @@
+module Qualities
+  CHORD_QUALITIES = {
+   "5"          => [0, 7],
+   "Msus2"      => [0, 2, 7],
+   "dim"        => [0, 3, 6],
+   "m"          => [0, 3, 7],
+   "m#5"        => [0, 3, 8],
+   "Mb5"        => [0, 4, 6],
+   "M"          => [0, 4, 7],
+   ""           => [0, 4, 7],
+   "M#5"        => [0, 4, 8],
+   "Mb6"        => [0, 4, 8],
+   "7ndim5"     => [0, 4, 10],
+   "Msus4"      => [0, 5, 7],
+   "mb6b9"      => [0, 1, 3, 8],
+   "addb9"      => [0, 1, 4, 7],
+   "madd9"      => [0, 2, 3, 7],
+   "Madd9"      => [0, 2, 4, 7],
+   "sus24"      => [0, 2, 5, 7],
+   "M#5add9"    => [0, 2, 4, 8],
+   "9ndim5"     => [0, 2, 4, 10],
+   "+add#9"     => [0, 3, 4, 8],
+   "madd4"      => [0, 3, 5, 7],
+   "4"          => [0, 3, 5, 10],
+   "dim7"       => [0, 3, 6, 9],
+   "m7"         => [0, 3, 7, 10],
+   "mM7"        => [0, 3, 7, 11],
+   "m7#5"       => [0, 3, 8, 10],
+   "7b5"        => [0, 4, 6, 10],
+   "7"          => [0, 4, 7, 10],
+   "7#5"        => [0, 4, 8, 10],
+   "7b13"       => [0, 4, 8, 10],
+   "M7#5"       => [0, 4, 8, 11],
+   "M7b6"       => [0, 4, 8, 11],
+   "M7b5"       => [0, 4, 6, 11],
+   "M7#5sus4"   => [0, 5, 8, 11],
+   "7sus4"      => [0, 5, 7, 10],
+   "7#5sus4"    => [0, 5, 8, 10],
+   "M7sus4"     => [0, 5, 7, 11],
+   "M6"         => [0, 4, 7, 9],
+   "m7b5"       => [0, 3, 6, 10],
+   "M7"         => [0, 4, 7, 11],
+   "maj7"       => [0, 4, 7, 11],
+   "mb6M7"      => [0, 3, 8, 11],
+   "dimM7"      => [0, 3, 6, 11],
+   "m6"         => [0, 3, 5, 7, 9],
+   "m6/9"       => [0, 2, 3, 7, 9],
+   "M6/9"       => [0, 2, 4, 7, 9],
+   "M6#11"      => [0, 4, 6, 7, 9],
+   "m7add11"    => [0, 3, 5, 7, 10],
+   "dim7M7"     => [0, 3, 6, 9, 11],
+   "m9"         => [0, 2, 3, 7, 10],
+   "m9#5"       => [0, 2, 3, 8, 10],
+   "m9b5"       => [0, 2, 3, 6, 10],
+   "mM7b6"      => [0, 3, 7, 8, 11],
+   "mM9"        => [0, 2, 3, 7, 11],
+   "M7b9"       => [0, 1, 4, 7, 11],
+   "M9"         => [0, 2, 4, 7, 11],
+   "M9#5"       => [0, 2, 4, 8, 11],
+   "M9#5sus4"   => [0, 2, 5, 8, 11],
+   "M9b5"       => [0, 2, 4, 6, 11],
+   "M9sus4"     => [0, 2, 5, 7, 11],
+   "M7#11"      => [0, 4, 6, 7, 11],
+   "7#9"        => [0, 3, 4, 7, 10],
+   "7#11"       => [0, 4, 6, 7, 10],
+   "11"         => [0, 2, 5, 7, 10],
+   "11b9"       => [0, 1, 5, 7, 10],
+   "13ndim5"    => [0, 2, 4, 9, 10],
+   "7#5#9"      => [0, 3, 4, 8, 10],
+   "7#5b9"      => [0, 1, 4, 8, 10],
+   "7add6"      => [0, 4, 7, 9, 10],
+   "7b6"        => [0, 4, 7, 8, 10],
+   "7b9"        => [0, 1, 4, 7, 10],
+   "7sus4b9"    => [0, 1, 5, 7, 10],
+   "9"          => [0, 2, 4, 7, 10],
+   "9#5"        => [0, 2, 4, 8, 10],
+   "9b13"       => [0, 2, 4, 8, 10],
+   "9b5"        => [0, 2, 4, 6, 10],
+   "9sus4"      => [0, 2, 5, 7, 10],
+   "M6/9#11"    => [0, 2, 4, 6, 7, 9],
+   "6/9#11"     => [0, 2, 4, 6, 7, 9],
+   "9#5#11"     => [0, 2, 4, 6, 8, 10],
+   "Blues"      => [0, 3, 5, 6, 7, 10],
+   "m11"        => [0, 2, 3, 5, 7, 10],
+   "m11#5"      => [0, 2, 3, 5, 8, 10],
+   "m11b5"      => [0, 2, 3, 5, 6, 10],
+   "13b5"       => [0, 2, 4, 6, 9, 10],
+   "13b9"       => [0, 1, 4, 7, 9, 10],
+   "13sus4"     => [0, 2, 5, 7, 9, 10],
+   "7#11b13"    => [0, 4, 6, 7, 8, 10],
+   "7#5b9#11"   => [0, 1, 4, 6, 8, 10],
+   "7#9#11"     => [0, 3, 4, 6, 7, 10],
+   "7#9b13"     => [0, 3, 4, 7, 8, 10],
+   "13#9"       => [0, 3, 4, 7, 9, 10],
+   "13"         => [0, 2, 4, 7, 9, 10],
+   "7b9#11"     => [0, 1, 4, 6, 7, 10],
+   "7b9#9"      => [0, 1, 3, 4, 7, 10],
+   "7b9b13"     => [0, 1, 4, 7, 8, 10],
+   "7sus4b9b13" => [0, 1, 5, 7, 8, 10],
+   "9#11"       => [0, 2, 4, 6, 7, 10],
+   "M13"        => [0, 2, 4, 7, 9, 11],
+   "M7#9#11"    => [0, 3, 4, 6, 7, 11],
+   "M7add13"    => [0, 2, 4, 7, 9, 11],
+   "M9#11"      => [0, 2, 4, 6, 7, 11],
+   "mM9b6"      => [0, 2, 3, 7, 8, 11],
+   "7b9b13#11"  => [0, 1, 4, 6, 7, 8, 10],
+   "13b9#11"    => [0, 1, 4, 6, 7, 9, 10],
+   "9#11b13"    => [0, 2, 4, 6, 7, 8, 10],
+   "13#11"      => [0, 2, 4, 6, 7, 9, 10],
+   "M13#11"     => [0, 2, 4, 6, 7, 9, 11],
+   "m13"        => [0, 2, 3, 5, 7, 9, 10],
+   "13#9#11"    => [0, 3, 4, 6, 7, 9, 10],
+   "7#9#11b13"  => [0, 3, 4, 6, 7, 8, 10]
+ }
+end