rb-music 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fc617a723dd833ba0f1000693c41eb7b268b6ea
-  data.tar.gz: 19a307ef2a1fd82f13eb930c205744adbd547f9f
+  metadata.gz: 64717c99b5fbd105422fc99c79fd9d137abd80b0
+  data.tar.gz: b61cfe61e4b3c562480d2f5b201d4d0636af8e69
 SHA512:
-  metadata.gz: d99d234ff1650ec22574dedacf1afb3624e9e71144405931ff283d64b3abd70cf0944347955f65b053434113ca48bb25fb12db0afb6450a026b66a761faf0dc7
-  data.tar.gz: 9f01db156a66dc104f237397dd9e93f421aa51d655a4ac0473f1914852458c1f49a9e925a935e98bdfc93d7f15f1a45fffd79f6f2cc524dd65430d4005655a6d
+  metadata.gz: cdc92e5119be32c2a4ac88869d8a48903e50992458035265096ef4efaef1a0a6f4a8f79c89237dc2ef6458998a9d689bb4d6c7feb30768d3394c5871709b6cbf
+  data.tar.gz: ba46377b0db3961a66a2ae7a5c0f82da8e8c3e8fa11e389204de82d87e165888a2370ee6920ffd8d0bafea289471dff5fcdb7f314fc80271d38dc0c83e36b716

data/lib/rb-music/constants.rb

@@ -0,0 +1,105 @@
+module RBMusic
+  Error = Class.new(StandardError)
+  ArgumentError = Class.new(ArgumentError)
+
+  NOTE_NAMES = ["F", "C", "G", "D", "A", "E", "B"]
+  ACCIDENTALS = ["bb", "b", "", "#", "x"]
+
+  # notes - two dimensional [octave, fifth] - relative to the 'main' note
+  NOTES = {
+    "Fbb" => [10, -17],
+    "Cbb" => [10, -16],
+    "Gbb" => [9, -15],
+    "Dbb" => [8, -14],
+    "Abb" => [8, -13],
+    "Ebb" => [7, -12],
+    "Bbb" => [7, -11],
+
+    "Fb" => [6, -10],
+    "Cb" => [5, -9],
+    "Gb" => [5, -8],
+    "Db" => [4, -7],
+    "Ab" => [4, -6],
+    "Eb" => [3, -5],
+    "Bb" => [3, -4],
+
+    "F" => [2, -3],
+    "C" => [1, -2],
+    "G" => [1, -1],
+    "D" => [0, 0],
+    "A" => [0, 1],
+    "E" => [-1, 2],
+    "B" => [-1, 3],
+
+    "F#" => [-2, 4],
+    "C#" => [-3, 5],
+    "G#" => [-3, 6],
+    "D#" => [-4, 7],
+    "A#" => [-4, 8],
+    "E#" => [-5, 9],
+    "B#" => [-5, 10],
+
+    "Fx" => [-6, 11],
+    "Cx" => [-7, 12],
+    "Gx" => [-7, 13],
+    "Dx" => [-8, 14],
+    "Ax" => [-8, 15],
+    "Ex" => [-9, 16],
+    "Bx" => [-10, 17]
+  }
+
+  BASE_FREQ = 440  # A4 'main' note
+  BASE_OFFSET = [4, 1]  # offset of base note from D0
+
+  # intervals - two dimensional [octave, fifth] - relative to the 'main' note
+  INTERVALS = {
+    unison:           [0, 0],
+    minor_second:     [3, -5],
+    major_second:     [-1, 2],
+    minor_third:      [2, -3],
+    major_third:      [-2, 4],
+    fourth:           [1, -1],
+    augmented_fourth: [-3, 6],
+    tritone:          [-3, 6],
+    diminished_fifth: [4, -6],
+    fifth:            [0, 1],
+    minor_sixth:      [3, -4],
+    major_sixth:      [-1, 3],
+    minor_seventh:    [2, -2],
+    major_seventh:    [-2, 5],
+    octave:           [1, 0]
+  }
+
+  INTERVALS_SEMITONES = {
+    0 =>  [0, 0],
+    1 =>  [3, -5],
+    2 =>  [-1, 2],
+    3 =>  [2, -3],
+    4 =>  [-2, 4],
+    5 =>  [1, -1],
+    6 =>  [-3, 6],
+    7 =>  [0, 1],
+    8 =>  [3, -4],
+    9 =>  [-1, 3],
+    10 => [2, -2],
+    11 => [-2, 5],
+    12 => [1, 0]
+  }
+
+  SCALES = {
+    major: [:major_second, :major_third, :fourth, :fifth, :major_sixth, :major_seventh],
+    natural_minor: [:major_second, :minor_third, :fourth, :fifth, :minor_sixth, :minor_seventh],
+    harmonic_minor: [:major_second, :minor_third, :fourth, :fifth, :minor_sixth, :major_seventh],
+    major_pentatonic: [:major_second, :major_third, :fifth, :major_sixth],
+    minor_pentatonic: [:minor_third, :fourth, :fifth, :minor_seventh],
+    blues: [:minor_third, :fourth, :augmented_fourth, :fifth, :minor_seventh],
+    dorian: [:major_second, :minor_third, :fourth, :fifth, :major_sixth, :minor_seventh],
+    phrygian: [:minor_second, :minor_third, :fourth, :fifth, :major_sixth, :minor_seventh],
+    lydian: [:major_second, :major_third, :augmented_fourth, :fifth, :major_sixth, :major_seventh],
+    mixolydian: [:major_second, :major_third, :fourth, :fifth, :major_sixth, :minor_seventh],
+    locrian: [:minor_second, :minor_third, :fourth, :diminished_fifth, :minor_sixth, :minor_seventh],
+  }
+  SCALES[:ionian] = SCALES[:major]
+  SCALES[:aeolian] = SCALES[:natural_minor]
+
+end

data/lib/rb-music/interval.rb

@@ -0,0 +1,50 @@
+module RBMusic
+
+  class Interval
+    attr_accessor :coord
+
+    def initialize(coord)
+      self.coord = coord
+    end
+
+    def self.from_name(name)
+      Interval.new(INTERVALS[name.to_sym])
+    end
+
+    def self.from_semitones(num)
+      Interval.new(INTERVALS_SEMITONES[num])
+    end
+
+    def self.from_tones_semitones(tone_semitone)
+      # multiply [tones, semitones] vector with [-1 2;3 -5] to get coordinate from tones and semitones
+      Interval.new([tone_semitone[0] * -1 + tone_semitone[1] * 3, tone_semitone[0] * 2 + tone_semitone[1] * -5])
+    end
+
+    def tone_semitone
+      # multiply coord vector with [5 2;3 1] to get coordinate in tones and semitones
+      # [5 2;3 1] is the inverse of [-1 2;3 -5], which is the coordinates of [tone; semitone]
+      @tone_semitone ||= [coord[0] * 5 + coord[1] * 3, coord[0] * 2 + coord[1] * 1]
+    end
+
+    def semitone
+      # number of semitones of interval = tones * 2 + semitones
+      tone_semitone[0] * 2 + tone_semitone[1]
+    end
+
+    def add(interval)
+      if interval.is_a?(String)
+        interval = Interval.from_name(interval)
+      end
+      Interval.new([coord[0] + interval.coord[0], coord[1] + interval.coord[1]])
+    end
+
+    def subtract(interval)
+      if interval.is_a?(String)
+        interval = Interval.from_name(interval)
+      end
+      Interval.new([coord[0] - interval.coord[0], coord[1] - interval.coord[1]])
+    end
+
+  end
+
+end

data/lib/rb-music/note.rb

@@ -0,0 +1,107 @@
+module RBMusic
+
+  class Note
+    attr_accessor :coord
+
+    def initialize(coord)
+      self.coord = coord
+    end
+
+    def self.from_latin(name)
+      raise ArgumentError unless name.is_a?(String)
+
+      note_parts = name.split(/(\d+)/)
+      note_name = note_parts.first
+      octave = note_parts.last.to_i
+
+      unless NOTES.has_key?(note_name) && note_parts.size < 3
+        raise ArgumentError
+      end
+
+      coordinate = [NOTES[note_name][0] + octave, NOTES[note_name][1]]
+
+      coordinate[0] -= BASE_OFFSET[0]
+      coordinate[1] -= BASE_OFFSET[1]
+
+      Note.new(coordinate)
+    end
+
+    def frequency
+      BASE_FREQ * (2.0 ** ((coord[0] * 1200 + coord[1] * 700.0) / 1200.0))
+    end
+
+    def accidental
+      @accidental ||= ((coord[1] + BASE_OFFSET[1]) / 7.0).round
+    end
+
+    def octave
+      # calculate octave of base note without accidentals
+      @octave ||= coord[0] + BASE_OFFSET[0] + 4 * accidental + ((coord[1] + BASE_OFFSET[1] - 7 * accidental) / 2).floor
+    end
+
+    def latin
+      return @latin if @latin
+      accidentalName = ACCIDENTALS[accidental + 2]
+      @latin ||= base_note_name + accidentalName
+    end
+
+    def ==(other)
+      other.is_a?(Note) && other.latin == latin && other.octave == octave
+    end
+
+    def enharmonic?(other)
+      raise ArgumentError unless other.is_a?(Note)
+
+      other.frequency == frequency
+    end
+    alias_method :enharmonically_equivalent_to?, :enharmonic?
+
+    def midi_note_number
+      # see http://www.phys.unsw.edu.au/jw/notes.html
+      12 * Math.log2(frequency / 440) + 69
+    end
+
+    def scale(name, octaves = 1)
+      NoteSet.from_scale(Scale.new(latin, name), octave, octaves)
+    end
+
+    def add(that)
+      # if input is an array return an array
+      if that.is_a?(Array)
+        notes = that.map { |thing| add(thing) }
+        return NoteSet.new(notes)
+      end
+
+      # if input is string/symbol try to parse it as interval
+      if that.is_a?(String) || that.is_a?(Symbol)
+        that = Interval.from_name(that)
+      end
+
+      Note.new([coord[0] + that.coord[0], coord[1] + that.coord[1]])
+    end
+
+    def subtract(that)
+      if that.is_a?(Array)
+        notes = that.map { |thing| subtract(thing) }
+        return NoteSet.new(notes)
+      end
+
+      # if input is string try to parse it as interval
+      if that.is_a?(String) || that.is_a?(Symbol)
+        that = Interval.from_name(that)
+      end
+
+      coordinate = [coord[0] - that.coord[0], coord[1] - that.coord[1]]
+
+      # if input is another note return the difference as an Interval
+      that.is_a?(Note) ? Interval.new(coordinate) : Note.new(coordinate)
+    end
+
+    private
+
+    def base_note_name
+      @base_note_name ||= NOTE_NAMES[coord[1] + BASE_OFFSET[1] - accidental * 7 + 3]
+    end
+  end
+
+end

data/lib/rb-music/note_set.rb

@@ -0,0 +1,61 @@
+module RBMusic
+
+  class NoteSet
+    include Enumerable
+
+    attr_accessor :notes
+
+    def initialize(notes = [])
+      @notes = notes
+    end
+
+    def self.from_scale(scale, octave=0, octaves=1)
+      raise ArgumentError unless scale.is_a?(Scale) && octaves > 0
+
+      root_note = Note.from_latin("#{scale.key}#{octave}")
+      notes = []
+      octaves.times do |i|
+        notes += scale.degrees.map do |interval_name|
+          note = root_note.add(interval_name)
+          i.times do |octave_offset|
+            note = note.add(:octave)
+          end
+          note
+        end
+      end
+
+      self.new(notes)
+    end
+
+    def each(&block)
+      @notes.each(&block)
+    end
+
+    def [](index)
+      @notes[index]
+    end
+
+    def <<(other)
+      @notes << other
+    end
+
+    def map(&block)
+      @notes.map(&block)
+    end
+
+    def ==(other)
+      @notes == other.notes
+    end
+    alias_method :eql?, :==
+
+    def add(that)
+      NoteSet.new(@notes.map { |note| note.add(that) })
+    end
+
+    def subtract(that)
+      NoteSet.new(@notes.map { |note| note.subtract(that) })
+    end
+
+  end
+
+end

data/lib/rb-music/scale.rb

@@ -0,0 +1,30 @@
+module RBMusic
+
+  class Scale
+    attr_reader :key
+    attr_reader :degrees
+
+    def initialize(key, name)
+      @scale_name = name.to_sym
+      raise ArgumentError unless NOTES.has_key?(key)
+      raise ArgumentError unless SCALES.has_key?(@scale_name)
+      @key = key
+      @degrees = [:unison] + SCALES[@scale_name]
+    end
+
+    def degree_count
+      @degree_count ||= @degrees.size
+    end
+    alias_method :size, :degree_count
+
+    def name
+      @name ||= "#{key} #{human_scale_name}"
+    end
+
+    private
+    def human_scale_name
+      @scale_name.to_s.split("_").map { |word| word.capitalize }.join(" ")
+    end
+  end
+
+end

data/lib/rb-music/version.rb

@@ -0,0 +1,3 @@
+module RBMusic
+  VERSION = "0.0.4" unless defined? RBMusic::VERSION
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb-music
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Mark Wise
@@ -102,6 +102,12 @@ files:
 - LICENSE
 - README.md
 - lib/rb-music.rb
+- lib/rb-music/constants.rb
+- lib/rb-music/interval.rb
+- lib/rb-music/note.rb
+- lib/rb-music/note_set.rb
+- lib/rb-music/scale.rb
+- lib/rb-music/version.rb
 - spec/rb-music/constants_spec.rb
 - spec/rb-music/interval_spec.rb
 - spec/rb-music/note_set_spec.rb