coltrane 2.0.0 → 2.1.0

data/lib/coltrane/voicing.rb

@@ -0,0 +1,38 @@
+module Coltrane
+
+  # This class describes an actual implementation of a Chord, being aware
+  # of exact octaves of each pitch and even repeating pitches across octaves.
+  class Voicing
+    attr_reader :pitches
+
+    def initialize(*pitch_strings, pitches: nil)
+      @pitches = if pitch_strings.any?
+                   pitch_strings.map { |s| Pitch[s] }
+                 elsif pitches
+                   pitches
+                 else
+                   raise WrongArgumentsError
+                 end
+    end
+
+    def self.[](*args)
+      new(*args)
+    end
+
+    def pitch_classes
+      NoteSet[*pitches.map(&:pitch_class).uniq]
+    end
+
+    alias notes pitch_classes
+
+    def chord
+      @chord ||= Chord.new(notes: notes)
+    rescue ChordNotFoundError
+      return false
+    end
+
+    def frequencies
+      pitches.map(&:frequency)
+    end
+  end
+end

data/lib/coltrane_game/question.rb

@@ -0,0 +1,6 @@
+module ColtraneGame
+  class Question
+    def generate
+    end
+  end
+end

data/lib/coltrane_instruments.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
+require 'coltrane'
+
 module ColtraneInstruments
+  autoload :Guitar, 'coltrane_instruments/guitar'
 end

data/lib/coltrane_instruments/guitar.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 module ColtraneInstruments
-  # This module  represents a guitar
   module Guitar
+    autoload :Base,   'coltrane_instruments/guitar/base'
+    autoload :Chord,  'coltrane_instruments/guitar/chord'
+    autoload :Note,   'coltrane_instruments/guitar/note'
+    autoload :String, 'coltrane_instruments/guitar/string'
   end
-end
+end

data/lib/coltrane_instruments/guitar/base.rb

@@ -2,12 +2,27 @@
 
 module ColtraneInstruments
   module Guitar
+    DEFAULT_TUNING = %w[E2 A2 D3 G3 B3 E4]
+    DEFAULT_FRETS = 23
     # A base class for operations involving Guitars
     class Base
-      def initialize; end
+      attr_reader :strings, :frets
 
-      def find_chord(target_chord)
-        Chord.new(target_chord, guitar: self).fetch_descendant_chords
+      def self.find_chords(target_chord)
+        unless target_chord.is_a?(Coltrane::Chord)
+          target_chord = Coltrane::Chord.new(name: target_chord)
+        end
+
+        ColtraneInstruments::Guitar::Chord.new(target_chord, guitar: new)
+                                          .fetch_descendant_chords
+      end
+
+      def initialize(tuning = DEFAULT_TUNING, frets = DEFAULT_FRETS)
+        @strings = tuning.map do |p|
+          String.new(Coltrane::Pitch[p], guitar: self)
+        end
+
+        @frets = frets
       end
     end
   end

data/lib/coltrane_instruments/guitar/chord.rb

@@ -4,14 +4,62 @@ module ColtraneInstruments
   module Guitar
     # This class represents a group of guitar notes, strummed at the same time
     class Chord
-      def initialize(target_chord, guitar_notes: [],
+      include Comparable
+      attr_reader :guitar_notes, :guitar, :free_fingers, :target_chord, :barre
+
+      MAX_FRET_SPAN = 3
+
+      def self.find(chord)
+        new(chord).fetch_descendant_chords
+      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
-        @barre = barre
+        @guitar       = guitar
+        @barre        = barre
+      end
+
+      def <=>(other)
+         rank <=> other.rank
+      end
+
+      def rank
+         +completeness * 10000 +
+         +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?
@@ -19,23 +67,102 @@ module ColtraneInstruments
       end
 
       def fetch_descendant_chords
-        return self if guitar_notes.size < guitar.strings
-        possible_new_notes.reduce([]) do |memo, n|
-          fingers_change = n.fret == @barre ? 0 : 1
-          return self unless (@free_fingers - fingers_change).negative?
-          guitar.create_chord target_chord,
-                              guitar_notes: @guitar_notes + n,
-                              free_fingers: @free_fingers - fingers_change,
-                              barre: @barre
-                                .fetch_descendant_chords + memo
+        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?
+          Chord.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 possible_new_notes; 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 ||= (target_chord.notes - Coltrane::NoteSet[
+                          *guitar_notes.map do |n|
+                            next if n.pitch.nil?
+                            n.pitch.pitch_class
+                          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

data/lib/coltrane_instruments/guitar/note.rb

@@ -3,6 +3,22 @@
 module ColtraneInstruments
   module 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

data/lib/coltrane_instruments/guitar/string.rb

@@ -3,6 +3,27 @@
 module ColtraneInstruments
   module 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

data/lib/coltrane_synth.rb

@@ -0,0 +1,7 @@
+require 'coltrane'
+require 'coreaudio'
+
+module ColtraneSynth
+  autoload :Base,  'coltrane_synth/base'
+  autoload :Synth, 'coltrane_synth/synth'
+end

data/lib/coltrane_synth/base.rb

@@ -0,0 +1,47 @@
+module ColtraneSynth
+  class Base
+    attr_reader :device, :buffer
+
+    SAMPLE_RATE = 44000
+
+    def self.play(something, duration=1.0)
+      new.play(*extract_frequencies(something), duration: duration)
+    end
+
+    def initialize
+      @device = CoreAudio.default_output_device
+    end
+
+    def play(*freqs, duration: 1.0)
+      @device = CoreAudio.default_output_device
+      buffer = @device.output_loop(SAMPLE_RATE)
+
+      SAMPLE_RATE.times do |i|
+        sound = freqs.reduce(0) { |sum, freq| Math.sin(phase(freq)*i) + sum }
+        buffer[i] = (sound * (0x6AFF/freqs.size)).round
+      end
+
+      buffer.start
+      sleep duration
+      buffer.stop
+    end
+
+    private
+
+    def self.extract_frequencies(arg)
+      case arg
+      when Coltrane::Chord then arg.notes.map {|n| n.frequency.octave(4).to_f }
+      when Coltrane::PitchClass then arg.frequency.octave(4).to_f
+      when Coltrane::Voicing then arg.frequencies.map(&:to_f)
+      end
+    end
+
+    def sine_wave(freq, i)
+      Math.sin(phase(freq)*i)
+    end
+
+    def phase(freq)
+      (Math::PI * 2.0 * freq) / SAMPLE_RATE.to_f
+    end
+  end
+end

data/lib/coltrane_synth/synth.rb

@@ -0,0 +1,24 @@
+module ColtraneSynth
+  class Synth
+    attr_reader :freq, :nominal_rate
+
+    def initialize(buffer, freq, nominal_rate)
+      @freq = freq.to_f
+      @nominal_rate = nominal_rate
+
+      i = -1
+      wav = NArray.sint(1024)
+
+      while i += 1
+        1024.times do |j|
+          wav[j] = (0.4 * Math.sin(phase(freq) * (i * 1024 + j)) * 0x7FFF).round
+        end
+        buffer << wav
+      end
+    end
+
+    def phase(freq)
+      Math::PI * 2.0 * freq / nominal_rate
+    end
+  end
+end

data/lib/core_ext.rb

@@ -2,15 +2,24 @@
 
 # Stolen from Active Support and changed a bit
 # may in the future be substituted by facets version
+class Regexp
+  def match?(*args)
+    !!match(*args)
+  end
+end
+
 class String
   def underscore
     return self unless /[A-Z-]|::/.match?(self)
-    word = to_s.gsub('::', '/')
-    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-    word.tr!('- ', '_')
-    word.downcase!
-    word
+    to_s.gsub('::', '/')
+        .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr('- ', '_')
+        .downcase
+  end
+
+  def match?(*args)
+    !!match(*args)
   end
 
   def interval_quality
@@ -22,10 +31,14 @@ class String
       'd' => 'Diminished'
     }[self]
   end
+
+  def symbolize
+    self.underscore.to_sym
+  end
 end
 
 # Here we add some syntax sugar to make the code more understandable later
-class Integer
+class Numeric
   def interval_name
     {
       1   => 'Unison',
@@ -49,11 +62,16 @@ end
 
 # Here we add some methods better work with Tries
 class Hash
+  def dig(*args)
+    args.size > 1 ? self[args.shift].dig(*args) : self[args[0]]
+  end
+
   def clone_values(from_keys: nil,
                    to_keys: nil,
                    suffix: nil,
                    branch_a: nil,
                    branch_b: nil)
+
     branch_a ||= dig(*from_keys)
     if branch_b.nil?
       create_branch!(*to_keys)