coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/pitch_class.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  #
-  # 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 <=>(other)
-      integer <=> other.integer
-    end
-
-    def fundamental_frequency
-      @fundamental_frequency ||=
-        Frequency[
-          Coltrane.base_tuning *
-          (2**((integer - Coltrane::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
-        (Coltrane::BASE_PITCH_INTEGER +
-          size * Math.log(f.to_f / Coltrane.base_tuning.to_f, 2)) % size
-      end.round
-    end
-  end
-end

data/lib/coltrane/progression.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # 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.map! { |c| Chord.new(name: c) } if chords[0].is_a?(String)
-
-      root_notes = NoteSet[*chords.map(&:root_note)]
-
-      scales = Scale.having_notes(*root_notes)[:scales]
-      progressions = scales.reduce([]) do |memo, scale|
-        memo + [Progression.new(chords: chords, scale: scale)]
-      end
-
-      progressions.sort_by(&:notes_out_size)
-    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

data/lib/coltrane/roman_chord.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # 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

data/lib/coltrane/scale.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-# frozen_string_literal: true
-
-module Coltrane
-  # 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 name
-      @name = begin
-        is = interval_sequence.relative_intervals
-        (0...is.size).each do |i|
-          if (scale_name = Coltrane::ClassicScales::SCALES.key(is.rotate(i)))
-            return scale_name
-          end
-        end
-        nil
-      end
-    end
-
-    def to_s
-      "#{tone} #{name}"
-    end
-
-    def pretty_name
-      "#{tone.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