musical-chords 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7abf3d598f5b033312d3a9c86fef9306bd4577ad
+  data.tar.gz: 43b915af57b05ddc45f39a6201b236aebcd2dd6c
+SHA512:
+  metadata.gz: f25d035e439b9818a86f0ac26b3f5c6d0b181b1b3ae3070c8da1d01e452d7e4491cf9137e552a28adfe3271fa97a6b95ee7dfaedbbeef5003c0fdaaec6e70ebe
+  data.tar.gz: c18f0206111b45f7efc55ae34ddfb2948cbc678fdd5db851672695c5aa72e1692fc1d252d803bd355d292148689165419886818229c81aae814bba23b2385e74

data/lib/music.rb

@@ -0,0 +1,462 @@
+# This class is designed for music manipulation
+# It is useful for finding notes and chords, and transpositions.
+#
+# Author::    Patrick Sereno  (mailto:patrick@6orbits.com)
+# Copyright:: Copyright (c) 2017 Patrick Sereno
+#
+# ToDos::
+# 1. Include minor scales
+
+# This class contains the variables and methods based upon contemporary western music turning.
+class Music
+
+  # This array is the chromatic scale.
+  @@notes = %w( A A#/Bb B C C#/Db D D#/Eb E F F#/Gb G G#/Ab )
+  
+  # The modules is used for "wrapping" notes back to the beginning of the scale.  For instance, the 12th note above A in the current scale with a modules of 12 would be A ( A + 12 mod 12 = A ).
+  @@scale_modulus = @@notes.count
+  
+  # This array is the chromatic scale written using sharps.
+  @@sharp_notes = %w( A A# B C C# D D# E F F# G G# )
+  
+  # This array is the chromatic scale written using flats.
+  @@flat_notes = %w( A Bb B C Db D Eb E F Gb G Ab )
+
+  # This array is of keys that are contain sharps.  This array is useful for determining if a note should be labeled as a sharp.  For instance A#/Bb in one of these keys would be written as A#.  (While the key of C has no sharps, it's common for accidentals to contain sharps when used in the key of C.)
+  @@sharps = %w( C G D A E B )
+  
+  # This array is of keys that are contain flats.  This array is useful for determining if a note should be labeled as a flat.  For instance A#/Bb in one of these keys would be written as Bb.
+  @@flats = %w( F Bb Eb Ab Db Gb )
+
+  # These notes are the white keys on a piano
+  @@white_keys = %w( C D E F G A B )
+  
+  # These notes are the black keys on a piano
+  @@black_keys = ( %w( C# D# ) << nil << %w(  F# G# A# ) ).flatten
+
+  # This hash is used to convert the different ways of writing notes into a consistent form.
+  # For example, @@note_transforms["B#"] => "C", @@note_transforms["B-SHARP"] => "C"
+  # Note: all keys are in uppercase
+  @@note_transforms = {
+    "G#/Ab" => "G#/Ab",
+    "AB" => "G#/Ab",
+    "A-FLAT" => "G#/Ab",
+    "A" => "A",
+    "A#/Bb" => "A#/Bb",
+    "A-SHARP" => "A#/Bb",
+    "A#" => "A#/Bb",
+    "BB" => "A#/Bb",
+    "B-FLAT" => "A#/Bb",
+    "B" => "B",
+    "B-SHARP" => "C",
+    "B#" => "C",
+    "CB" => "B",
+    "C-FLAT" => "B",
+    "C" => "C",
+    "C#/Db" => "C#/Db",
+    "C-SHARP" => "C#/Db",
+    "C#" => "C#/Db",
+    "DB" => "C#/Db",
+    "D-FLAT" => "C#/Db",
+    "D" => "D",
+    "D#/Eb" => "D#/Eb",
+    "D-SHARP" => "D#/Eb",
+    "D#" => "D#/Eb",
+    "EB" => "D#/Eb",
+    "E-FLAT" => "D#/Eb",
+    "E" => "E",
+    "E-SHARP" => "F",
+    "E#" => "F",
+    "FB" => "E",
+    "F-FLAT" => "E",
+    "F" => "F",
+    "F#/Gb" => "F#/Gb",
+    "F-SHARP" => "F#/Gb",
+    "F#" => "F#/Gb",
+    "GB" => "F#/Gb",
+    "G-FLAT" => "F#/Gb",
+    "G" => "G",
+    "G-SHARP" => "G#/Ab",
+    "G#" => "G#/Ab"
+  }
+  
+  # This hash is used to convert the different notes into a consistent form
+  # primarily for use with other class varibles or methods.
+  # Usage: #note_normalized_names["G##"] => "a"
+  # Note: all keys are in uppercase; all values are in lowercase.
+  @@note_normalized_names = {
+    "G##"   => "a",
+    "A"     => "a",
+    "BBB"   => "a",
+    "A-SHARP" => "a-sharp",
+    "A#/BB" => "a-sharp",
+    "A#"    => "a-sharp",
+    "BB"    => "a-sharp",
+    "A##"   => "b",
+    "B"     => "b",
+    "CB"    => "b",
+    "B#"    => "c",
+    "C"     => "c",
+    "DBB"   => "c",
+    "C-SHARP" => "c-sharp",
+    "B##"   => "c-sharp",
+    "C#"    => "c-sharp",
+    "C#/DB" => "c-sharp",
+    "DB"    => "c-sharp",
+    "C##"   => "d",
+    "D"     => "d",
+    "EBB"   => "d",
+    "D-SHARP" => "d-sharp",
+    "D#"    => "d-sharp",
+    "D#/EB" => "d-sharp",
+    "EB"    => "d-sharp",
+    "FBB"   => "d-sharp",
+    "D##"   => "e",
+    "E"     => "e",
+    "FB"    => "e",
+    "E#"    => "f",
+    "F"     => "f",
+    "GBB"   => "f",
+    "F-SHARP" => "F-SHARP",
+    "E##"   => "f-sharp",
+    "F#"    => "f-sharp",
+    "F#/GB" => "f-sharp",
+    "GB"    => "f-sharp",
+    "F##"   => "g",
+    "G"     => "g",
+    "ABB"   => "g",
+    "G-SHARP" => "G-SHARP",
+    "G#"    => "g-sharp",
+    "G#/AB" => "g-sharp",
+    "AB"    => "g-sharp",
+  }
+  
+  # An array of common scales.
+  #
+  # The key,value pairs are the symbolized name of the scale and the offset in semitones from the base note.
+  @@scales = {
+    major: [0,2,4,5,7,9,11],
+    minor: [0,2,3,5,7,9,11],
+    chromatic: [ 0,1,2,3,4,5,6,7,8,9,10,11 ],
+  }
+  
+  # Chords are constructed as an array of half-steps beginning with the root of the chord as 0.
+  #
+  # A major chord, usually written as 1-3-5 would be constructed here as [ 0, 4, 7 ].
+  # The root note is always 0.  The second arry member is 4, because the thrid note in a scale is *four* half-steps (semitones) higher than the root.
+  @@chords = {
+    "maj" => [0,4,7],
+    "maj6" => [0, 4, 7, 9],
+    "maj7" => [0, 4, 7, 11],
+    "maj9" => [0, 4, 7, 11, 14],
+    "maj11" => [0, 4, 7, 11, 14, 17],
+    "maj13" => [0, 4, 7, 11, 14, 17, 21],
+    "maj+9" => [0, 4, 7, 14],
+    "maj-9" => [0, 4, 7, 13],
+    "maj+69" => [0, 4, 7, 9, 14],
+    "maj7#5" => [0, 4, 8, 11],
+    "maj7b5" => [0, 4, 6, 11],
+    
+    
+    "min" => [0, 3, 7],
+    "min6" => [0, 3, 7, 9],
+    "min7" => [0, 3, 7, 10],
+    "min9" => [0, 3, 7, 10, 14],
+    "min11" => [0, 3, 7, 10, 14, 17],
+    "min13" => [0, 3, 7, 10, 14, 17, 21],
+    "min-maj7" => [0, 3, 7, 11],
+    "min-maj9" => [0, 3, 7, 11, 14],
+    "min+9" => [0, 3, 7, 14],
+    "min-9" => [0, 3, 7, 13],
+    "min+69" => [0, 3, 7, 9, 14],
+    
+    "dom7" => [0, 4, 7, 10],
+    "dom7#5" => [0, 4, 8, 10],
+    "dom7b5" => [0, 4, 6, 10],
+    "dom9" => [0, 4, 7, 10, 14],
+    "dom11" => [0, 4, 7, 10, 14, 17],
+    "dom13" => [0, 4, 7, 10, 14, 17, 21],
+    
+    "dim" => [0, 3, 6],
+    "dim7" => [0, 3, 6, 9],
+    "half-dim7" => [0, 3, 6, 10],
+    
+    "aug" => [0, 4, 8],
+    "aug7" => [0, 4, 8, 10],
+    
+    "sus" => [0, 5, 7],
+    "sus2" => [0, 2, 7],
+    "7sus4" => [0, 5, 7, 10],
+    
+    "major-scale" => [0,2,4,5,7,9,11],
+    "minor-scale" => [0,2,3,5,7,9,11],
+    "chromatic-scale" => [ 0,1,2,3,4,5,6,7,8,9,10,11 ],
+    
+    "alt9" => [4,7,10,14],
+  }
+  
+  # An array that represents every note in the scale.
+  @@chromatic_scale = (0...@@notes.count).to_a
+
+  # Chords that are arranged by their common types
+  @@chord_groups = {
+    scales: %w( major-scale minor-scale chromatic-scale ),
+    major: %w( maj maj6 maj7 maj9 maj11 maj13 maj+9 maj-9 maj+69 maj7#5 maj7b5 ),
+    minor: %w( min min6 min7 min9 min11 min13 min-maj7 min-maj9 min+9 min-9 min+69 ),
+    dominant: %w( dom7 dom7#5 dom7b5 dom9 dom11 dom13 ),
+    diminished: %w( dim dim7 half-dim7 ),
+    augmented: %w( aug aug7 ),
+    suspended: %w( sus 7sus4 sus2 ),
+    alternate: %w( alt9 ),
+  }
+  
+  # Returns the notes allowed as input to class methods
+  def self.allowed_notes
+    @@note_transforms.keys
+  end
+  
+  # Returns the keys allowed an input to class methods
+  def self.allowed_keys
+    (@@sharp_notes + @@flat_notes).uniq.sort
+  end
+  
+  # Returns the allowed chords
+  def self.allowed_chords
+    @@chords.keys
+  end
+  
+  # Returns the note as a sharp note.
+  #
+  # Params:
+  #
+  # * note: (see Music::allowed_notes)
+  def self.note_as_sharp( note )
+    @@sharp_notes[ @@notes.index( @@note_transforms[note] ) ]
+  end
+  
+  # Returns the note as a flat note.
+  #
+  # Params:
+  #
+  # * note: (see Music::allowed_notes)
+  def self.note_as_flat( note )
+    @@flat_notes[ @@notes.index( @@note_transforms[note] ) ]
+  end
+  
+  # Returns the note as a flat or sharp based upon the given key
+  #
+  # Params:
+  #
+  # * key: (see Music::allowed_keys)
+  # * note: (see Music::allowed_notes)
+  def self.name_note( key, note )
+    if @@sharps.include?( key )
+      note_as_sharp( note )
+    else
+      note_as_flat( note )
+    end
+  end
+
+  # Converts an array of notes to flats or sharps based upon the given key
+  #
+  # Params:
+  #
+  # * key: (see Music::allowed_keys)
+  # * note: (see Music::allowed_notes)
+  def self.name_notes( key, notes = [] )
+    notes.map { |n|
+      name_note( key, n )
+    }
+  end
+
+  # Returns the position (index in the chromatic scale) of the note in the given key.
+  # For instance, C# is note 1 in the chromatic scale of C.  (Note 0 in the key of C is C.)
+  #
+  # Params:
+  #
+  # * key: (see Music::allowed_keys)
+  # * note: (see Music::allowed_notes)
+  def self.note_position( key, note )
+    chromatic_scale( key ).index( @@note_transforms[note] )
+  end
+  
+  # Returns the position (index in the chromatic scale) of each note in the array in the given key.
+  # For instance, C# is note 1 in the chromatic scale of C.  (Note 0 in the key of C is C.)
+  #
+  # Params:
+  #
+  # * key: (see Music::allowed_keys)
+  # * note: (see Music::allowed_notes)
+  def self.note_positions( key, notes )
+    notes.map do |note|
+      note_position(key, note)
+    end
+  end
+
+  # Returns a hash indexing arrays of chords grouped according to their type
+  #
+  # Optional Params:
+  #
+  # * max_length : (integer) specifies the maximum length of any given chord.  Useful for instruments that are limited in the number of simultaneous notes they can play.  The default is 0, or no maximum length
+  # * exclude_scales : (boolean) specifies that the scales should not be included.  Ignored if max_length = 0
+  def self.chord_groups( params = { } )
+    options = { max_length: 0, exclude_scales: false }.merge params
+    case options[:max_length]
+    when 0
+      @@chord_groups
+    else
+      Hash[
+        @@chord_groups.map { |name,group|
+          if name == :scales and !options[:exclude_scales]
+            [ name, group ]
+          else
+            [ name, group.select { |chord| @@chords[chord].length <= options[:max_length] } ]
+          end
+        }
+      ]
+    end
+  end
+  
+  
+  # Returns an array of notes comprising the chromatic scale (all semi-tones) beginning at the root note of the key provided.
+  #
+  # Params:
+  #
+  # * key: (see Music::allowed_keys)
+  def self.chromatic_scale( key )
+    self.chord( key, @@chords["chromatic-scale"] )
+  end
+
+  # Returns a hash of the included scales and their semi-tone members as an array
+  def self.scales
+    @@scales
+  end
+  
+  # Returns the names/notes of the white keys on a piano
+  def self.white_keys
+    @@white_keys
+  end
+
+  # Returns the names/notes of the black keys on a piano
+  def self.black_keys
+    @@black_keys
+  end
+  
+  # Returns the notes in the specifed key and chord type
+  #
+  # Params:
+  #
+  # * key: (see Music::allowed_keys)
+  # * chord_name : (see Music::allowed_chords)
+  def self.chord_from_name( key, chord_name )
+    self.chord( key, @@chords[chord_name.downcase] )
+  end
+  
+  # Returns notes in a normalized fashon.
+  # This method is not used and may be deprecated in the future
+  #
+  # Params:
+  #
+  # * base_note : of the form "Cb" or "C#" or "c-sharp"
+  def self.normalize_name( base_note )
+    @@note_normalized_names[ base_note.upcase ]
+  end
+  
+  # Returns a numeric pointer to the note provided within the @@notes class array
+  #
+  # Params:
+  #
+  # * note: (see Music::allowed_notes)
+  def self.index_note( note )
+    return @@notes.index( @@note_transforms[ note.upcase ] )
+  end
+  
+  # Converts the given note into a normalized form.
+  # THis method is used primarly for chord manipulation.
+  #
+  # Params:
+  #
+  # * note: (see Music::allowed_notes)
+  #
+  # Returns:
+  # * nil  : if the note is not valid
+  def self.normalize_note( note )
+    return @@notes.include?(note.upcase) ? note.upcase : @@note_transforms[ note.upcase ]
+  end #Music#normalize_note
+  
+  # Returns a major chord : 1-3-5 with the given base_note (key)
+  # This method will likelhy be deprecated in the future.  Use Music::chord(base_note,"maj") instead.
+  #
+  # Params:
+  #
+  # * base_note: (see Music::allowed_notes)
+  def self.major( base_note )
+    self.chord( base_note, @@chords["maj"] )
+  end # Music#major_triad
+  
+  # Returns a major scale : 1-2-3-4-5-6-7 with the given base_note (key)
+  #
+  # Params:
+  #
+  # * base_note: (see Music::allowed_notes)
+  def self.major_scale( base_note )
+    self.chord( base_note, @@scales[:major] )
+  end
+
+  # Returns a major chord : 1-3b-5 with the given base_note (key)
+  # This method will likelhy be deprecated in the future.  Use Music::chord(base_note,"min") instead.
+  #
+  # Params:
+  #
+  # * base_note: (see Music::allowed_notes)
+  def self.minor( base_note )
+    self.chord( base_note, @@chords["min"]  )
+  end
+
+  # Returns a manor scale : 1-2-3-4-5-6-7 with the given base_note (key)
+  #
+  # Params:
+  #
+  # * base_note: (see Music::allowed_notes)
+  def self.minor_scale( base_note )
+    self.chord( base_note, @@scales[:minor] )
+  end
+
+  # Returns the note with a postivie number of semitones away from the base note
+  #
+  # Params:
+  #
+  # * base_note: (see Music::allowed_notes)
+  # * offset: a positive integer representing half-steps (semitones) above the base note
+  def self.note_from_offset( base_note, offset, params = { } )
+    options = { key: nil }.merge params
+    base = @@notes.index( Music.normalize_note(base_note))
+    raise "Invalid note: #{base_note}" if base.nil?
+    options[:key].nil? ? @@notes[ (base + offset) % @@scale_modulus ] : name_note( options[:key], @@notes[ (base + offset) % @@scale_modulus ] )
+  end
+  
+  # Returns an array of notes in a chord given a chord pattern
+  #
+  # Params:
+  # * base_note: (see Music::allowed_notes)
+  # * chord_pattern: am array positive integers representing half-steps (semitones) above the base note
+  def self.chord( base_note, chord_pattern )
+    base = @@notes.index( Music.normalize_note(base_note) )
+    raise "Invalid note: #{base_note}" if base.nil?
+    raise "Invalid chord: #{chord_pattern}" if chord_pattern.nil?
+    chord_pattern.map do |step|
+      @@notes[ ( base + step ) % @@scale_modulus ]
+    end
+  end
+  
+  # Converts the specified note to html formatting.
+  # Useful for sharps and flats
+  #
+  # Params:
+  #
+  # * note: 
+  def self.note_to_html( note )
+    note.gsub("#","&#9839;").gsub(/(\w)[bB]/) { $1 + "&#9837;" }
+  end
+  
+end # Class Music

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: musical-chords
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick Sereno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-09 00:00:00.000000000 Z
+dependencies: []
+description: This library is designed primarity for rendering chords.
+email: patrick@6orbits.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/music.rb
+homepage: http://6orbits.com/gems/music
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: A library for music theory and practice.
+test_files: []