music_set_theory 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3d6c653105c33d0aad4903ab2f5fc4e3df1092174fea8f44277f422f0dbb6c6
-  data.tar.gz: 572212c3e54b19770e15483658cb4e1a5c4193f26ba9716048e80959e2969ea5
+  metadata.gz: 2b66a2a0c031f2d15f603607c3ce78762a0f3e738f63d968c917fd7872618721
+  data.tar.gz: 505349cc9f85f8ecaaa890090522153a35e34c452707fb54f3d4112de5317a06
 SHA512:
-  metadata.gz: f618cb4c86604a1432d7a4cb1b330cad6551a3b2da38d036b46b31215000d97cd33e0ac245fbe3328eec32b7708154ed1393126c95797cc1f99fb5d3b36629c0
-  data.tar.gz: b04ee383b072f6ecca89f5cbc05cc2e6e44f0c4b886777f76a7ee824c3faeae83062cd7bd2f015d0ebb190771ab7eb631ced7b1a3634ec788e0c379deb4568e2
+  metadata.gz: 456d90f4f7e2b1c263381554d4587a2052285822d357af26417362dc8b0fc7d4386a18dc15f60b0ed03f883209f0ca20cfbd65adf079007b83a9439b2539cedb
+  data.tar.gz: 192520afd4ac5954fc1b933b4560061f7958d8a809036b08443fb44ed73a2f4eabf5a655377af2bb9d24c0e25fc33b56255c854e78e15b5af4976cd7fb4a5b9d

data/examples/mst_temperament.rb

@@ -24,19 +24,19 @@ nseqtype_dict.each {|k, v|
   dict = v
   puts pad2+"name_dict (#{dict.name_dict.keys.size}):"
   dict.name_dict.each_with_index {|(k, v), i|
-    puts pad2+pad+"(#{i+1}) #{k}: #{v}"
+    puts pad2+pad+"(#{i+1}) #{k}:#{v}"
   }
   puts
 
   puts pad2+"abbr_dict (#{dict.abbr_dict.keys.size}):"
   dict.abbr_dict.each_with_index {|(k, v), i|
-    puts pad2+pad+"(#{i+1}) #{k}: #{v}"
+    puts pad2+pad+"(#{i+1}) #{k}:#{v}"
   }
   puts
 
   puts pad2+"seqpos_dict (#{dict.seqpos_dict.keys.size}):"
   dict.seqpos_dict.each_with_index {|(k, v), i|
-    puts pad2+pad+"(#{i+1}) #{k}: #{v}"
+    puts pad2+pad+"(#{i+1}) #{k}:#{v}"
   }
 
   puts '-'*40

data/lib/music_set_theory/chord_generator.rb

@@ -47,7 +47,7 @@ require_relative "./temperament"
 require_relative "./scales"
 require_relative "./chords"
 
-require 'romannumerals'
+require 'romanumerals'
 
 
 # import copy, codecs
@@ -57,6 +57,10 @@ require 'romannumerals'
 # from .scales import MajorScale, MelMinorScale, HarmMinorScale,\
 #     HarmMajorScale;
 # from .chords import CHORDTYPE_DICT;
+require_relative "musutility"
+require_relative "temperament"
+require_relative "scales"
+require_relative "chords"
 
 
 #
@@ -142,8 +146,9 @@ module MusicSetTheory
 #    >>> print int_to_roman(1999)
 #    MCMXCIX
 #    """
-  def int_to_roman(input)
-    raise "#{input} must be greater than zero." if input <= 0
+  def int_to_roman( input )
+    raise ArgumentError, "#{input} must be greater than zero." if input <= 0
+    raise TypeError, "Input must be an integer." unless input.is_a? Integer
 
     input.to_roman
   end
@@ -166,12 +171,28 @@ module MusicSetTheory
 
     attr_accessor :full_name, :key, :full_notes, :table_title, :rows
     def initialize( full_name, key, full_notes, table_title )
-      self.full_name    = full_name;
-      self.key          = key;
-      self.full_notes   = full_notes;
-      self.table_title  = table_title;
-      self.rows         = [];
+      self.full_name    = full_name
+      self.key          = key
+      self.full_notes   = full_notes
+      self.table_title  = table_title
+      self.rows         = []
     end
+
+    def to_a
+      tmp = []
+      tmp << [ self.full_name, self.key, self.full_notes, self.table_title, ]
+
+      #
+      self.rows.map{|r|
+        # tmp << r.to_a
+        # tmp += r.to_a
+        tmp << r.to_a
+      }
+
+      ret = tmp
+      ret
+    end
+
   end
 
   # Represents different rows (triads, 7ths, 9ths) in tabular
@@ -180,8 +201,18 @@ module MusicSetTheory
   class ScaleChordRow
     attr_accessor :chord_type, :notes
     def initialize( chord_type )
-      self.chord_type = chord_type;
-      self.notes = [];
+      self.chord_type = chord_type
+      self.notes = []
+    end
+
+    def to_a
+      # ret = "#{self.chord_type}:#{self.notes}"
+      tmp = []
+      self.notes.each do |nt|
+        tmp << [self.chord_type,] + nt.to_a
+      end
+      ret = tmp
+      ret
     end
   end
 
@@ -189,9 +220,13 @@ module MusicSetTheory
   class ScaleChordCell
     attr_accessor :chordname_1, :chordname_2, :notes
     def initialize( chordname_1, chordname_2, notes )
-      self.chordname_1 = chordname_1;
-      self.chordname_2 = chordname_2;
-      self.notes = notes;
+      self.chordname_1 = chordname_1
+      self.chordname_2 = chordname_2
+      self.notes = notes
+    end
+
+    def to_a
+      [self.chordname_1, self.chordname_2, self.notes]
     end
   end
 
@@ -201,6 +236,8 @@ end
 module MusicSetTheory
 
   # Used for converting "C" -> 1, "Db"-> 2b, etc.
+  #
+  #
   def makebaserep( notex, base = 0 )
     notexparsed = WestTemp.note_parse(notex)
     #pos_rep = str(WestTemp.nat_key_lookup_order[notexparsed[0]] + base)
@@ -211,7 +248,7 @@ module MusicSetTheory
     elsif notexparsed[1] < 0
       ret = pos_rep + (M_FLAT * (-1 * notexparsed[1]))
     else
-      ret = pos_rep;
+      ret = pos_rep
     end
 
     ret
@@ -219,25 +256,33 @@ module MusicSetTheory
 
 
   # Returns an instance of scale_chords using the following inputs:
-  # 
-  # scale_name: a name of a scale like "Dorian".
-  # key: generally a standard music key like "C".
-  # possiblechords: a sequence of chord types like "Seventh" and "Ninth".
+  # ==== Args
+  # scale_name:: a name of a scale like "Dorian".
+  # key:: generally a standard music key like "C".
+  # possiblechords:: a sequence of chord types like "Seventh" and "Ninth".
+  # west_temp:: Temperament object.
   #
-  def populate_scale_chords( scale_name, key, possiblechords )
-    our_scale = WestTemp.get_nseqby_name(scale_name, NSEQ_SCALE);
-    num_elem = len(our_scale.nseq_posn);
+  # ==== Returns
+  # ScaleChords object.
+  #
+  #def populate_scale_chords( scale_name, key, possiblechords )
+  def populate_scale_chords( scale_name, key, possiblechords,
+                             west_temp = WestTemp )
+    our_scale = west_temp.get_nseqby_name(scale_name, NSEQ_SCALE)
+    # num_elem = len(our_scale.nseq_posn)
+    num_elem = our_scale.nseq_posn.size
+
     begin
       int_of_key    = key.to_i
-      is_key_an_int = true;
+      is_key_an_int = true
     rescue ValueError
-      is_key_an_int = false;
-      int_of_key    = nil;
+      is_key_an_int = false
+      int_of_key    = nil
     end
 
     if is_key_an_int
       #our_scale_notes = [makebaserep(x, int_of_key) for x in 
-      #our_scale.get_notes_for_key("C")];
+      #our_scale.get_notes_for_key("C")]
       our_scale_notes = our_scale.get_notes_for_key("C").map{|x|
                           makebaserep(x, int_of_key) }
     else
@@ -251,19 +296,22 @@ module MusicSetTheory
       ourchordrow = ScaleChordRow.new(i)
       our_chord_data.rows.append(ourchordrow)
 
-      for j in range(num_elem):
-        our_slice = CHORDTYPE_DICT[i];
+      # for j in range(num_elem):
+      for j in 0...num_elem
+        our_slice = CHORDTYPE_DICT[i]
+
         if is_key_an_int
           #our_chord_notes = [makebaserep(x, int_of_key) for x in
-          #  our_scale.get_notes_for_key("C", j, our_slice)];
+          #  our_scale.get_notes_for_key("C", j, our_slice)]
           our_chord_notes = our_scale.get_notes_for_key("C", j, our_slice).
                               map{|x| makebaserep(x, int_of_key) }
         else
           our_chord_notes = our_scale.get_notes_for_key(key, j, our_slice)
         end
 
-        our_posn  = our_scale.get_posn_for_offset(j, our_slice, true)
-        our_chord = WestTemp.get_nseqby_seqpos(our_posn, NSEQ_CHORD)
+        #our_posn  = our_scale.get_posn_for_offset(j, our_slice, true)
+        our_posn  = our_scale.get_posn_for_offset(j, our_slice, raz: true)
+        our_chord = west_temp.get_nseqby_seqpos(our_posn, NSEQ_CHORD)
         if our_chord
           ourchordrow.notes.append(ScaleChordCell.new(our_chord.nseq_name,
             our_chord.nseq_abbrev, our_chord_notes))
@@ -295,16 +343,17 @@ module MusicSetTheory
       thestring += "<caption>%s</caption>\n" %
         (scale.key + " " + scale.full_name +
           ": " + seqtostr(scale.full_notes))
-      thestring += "<thead>\n" + startrow + "<th>Chord Types</th>\n";
-      for q in range(7):
-#             thestring += "<th>%s</th>\n" % str(int_to_roman(q+1));
+      thestring += "<thead>\n" + startrow + "<th>Chord Types</th>\n"
+      # for q in range(7)
+      for q in 0...7
+        thestring += "<th>%s</th>\n" % str(int_to_roman(q+1))
       end
-      thestring += endrow + "</thead>\n<tbody>\n";
+      thestring += endrow + "</thead>\n<tbody>\n"
 
-      for i in scale.rows:
-        thestring += startrow;    
-        thestring += "<td>%s</td>\n" % i.chord_type;
-        for j in i.notes:
+      for i in scale.rows
+        thestring += startrow
+        thestring += "<td>%s</td>\n" % i.chord_type
+        for j in i.notes
           if not j.chordname_1
             thestring += ("<td><p>%s<br />" % (str(j.chordname_1)))
             thestring += ("<i>%s</i><br />" % (str(j.chordname_2)))

data/lib/music_set_theory/musutility.rb

@@ -264,17 +264,35 @@ end
 
 require 'active_support'
 require 'active_support/core_ext/object/deep_dup'
+require 'ice_nine'
 module MusicSetTheory
   module MusUtility
 
     def deep_freeze( obj )
+      IceNine.deep_freeze(obj)
+    end
+
+    def deep_melt( obj )
       case obj
       when Hash
-        obj.each { |k, v| deep_freeze(k); deep_freeze(v) }
+        obj.each_with_object({}) do |(key, value), new_hash|
+          new_hash[deep_melt(key)] = deep_melt(value)
+        end
       when Array
-        obj.each { |e| deep_freeze(e) }
+        obj.map { |element| deep_melt(element) }
+      when Object
+        # インスタンス変数の解除
+        obj.instance_variables.each do |var|
+          deep_melt(var)
+          value = obj.instance_variable_get(var)
+          obj.remove_instance_variable(var)
+          obj.instance_variable_set(var, deep_melt(value))
+        end
+        obj.dup rescue obj # 凍結状態を解除
+      else
+        obj.dup rescue obj
       end
-      obj.freeze
+      obj.dup rescue obj
     end
 
   end

data/lib/music_set_theory/scales.rb

@@ -121,6 +121,9 @@ module MusicSetTheory
     # Note: it is easier to define scales using the noteseq_scale class (this
     # file) and chord using the noteseq_chord class (in chords.py)
     #
+    # ==== Warning
+    # - ! This method updates `nseq_temp`.
+    #
     attr_accessor :nseq_name, :nseq_type, :nseq_temp, :nseq_posn
     attr_accessor :nseq_nat_posns, :nseq_abbrev, :nseq_synonyms,
                   :nseq_other_abbrevs
@@ -132,7 +135,10 @@ module MusicSetTheory
                     nseq_other_abbrevs: [] )
       self.nseq_name = nseq_name
       self.nseq_type = nseq_type
+
       self.nseq_temp = nseq_temp
+      # self.nseq_temp = deep_melt(nseq_temp.deep_dup)
+
       self.nseq_posn = nseq_posn
 
       self.nseq_nat_posns     = nseq_nat_posns
@@ -140,7 +146,8 @@ module MusicSetTheory
       self.nseq_synonyms      = nseq_synonyms
       self.nseq_other_abbrevs = nseq_other_abbrevs
 
-      self.register_with_temp()
+      #
+      self.register_with_temp(self.nseq_temp)
     end
 
     #
@@ -189,8 +196,10 @@ module MusicSetTheory
 
     # Registers this note sequence with the underlying temperament, so
     # that it can be looked up by name, by abbreviation or by sequence.
+    # ==== Warning
+    # - This methods updates `self.nseq_temp`
     #
-    def register_with_temp
+    def register_with_temp( nseq_temp = self.nseq_temp )
       if self.nseq_synonyms
         #if self.nseq_name not in self.nseq_synonyms
         if !(self.nseq_synonyms.include? self.nseq_name)
@@ -212,7 +221,9 @@ module MusicSetTheory
       else
         our_abbrevs = [self.nseq_abbrev]
       end
-      self.nseq_temp.seq_maps.add_elem(
+
+      #
+      nseq_temp.seq_maps.add_elem(
         self, self.nseq_type, our_names, our_abbrevs, self.nseq_posn)
     end
 
@@ -239,6 +250,9 @@ module MusicSetTheory
     # it (using slice, if not none). If and only if raz is True, the
     # result is rotated-and-zeroed.
     #
+    # ==== See Also
+    # - chord_generator.rb:`populate_scale_chords()`
+    #
     def get_posn_for_offset( rotate_by=0, slice=nil, raz: false )
       if slice
         modulus = self.nseq_temp.no_nat_keys
@@ -344,55 +358,114 @@ module MusicSetTheory
   DISC_MIN_NOTE_POS   = [0, 2, 3, 5, 6, 9, 11]
   HUNGARIAN_NOTE_POS  = [0, 3, 4, 6, 7, 9, 10]
 
+
   # For ease of comprehension, we have the list of modes as arrays which 
   # can be browsed from outside.
-  MAJORMODES = [ "Ionian",
+  MAJOR_MODES = [ "Ionian",
     "Dorian",
     "Phrygian",
     "Lydian",
     "Mixolydian",
     "Aeolian",
     "Locrian", ]
+  MAJORMODES = MAJOR_MODES
 
-  MELMINORMODES = [ "Jazz Minor",
+  MEL_MINOR_MODES = [ "Jazz Minor",
     "Dorian " + M_FLAT + "9",
     "Lydian Augmented",
     "Lydian Dominant",
     "Mixolydian " + M_FLAT + "13",
     "Semilocrian",
     "Superlocrian", ]
+  MELMINORMODES = MEL_MINOR_MODES
 
-  HARMINORMODES = [ "Harmonic Minor",
+  HARM_MINOR_MODES = [ "Harmonic Minor",
     "Locrian " + M_SHARP + "6",
     "Ionian Augmented",
     "Romanian",
     "Phrygian Dominant",
     "Lydian " + M_SHARP + "2",
     "Ultralocrian", ]
+  HARMINORMODES  = HARM_MINOR_MODES  # for compatibility... typo?
 
-  HARMMAJORMODES = [ "Harmonic Major",
+  HARM_MAJOR_MODES = [ "Harmonic Major",
     "Dorian " + M_FLAT + "6",
     "Phrygian " + M_FLAT + "4",
     "Lydian " + M_FLAT + "3",
     "Mixolydian " + M_FLAT + "9",
     "Lydian " + M_SHARP + "2 " + M_SHARP + "5",
     "Locrian " + M_FLAT + M_FLAT + "7", ]
+  HARMMAJORMODES = HARM_MAJOR_MODES
 
-  DISCORDMINMODES = [ "Melodic Minor " + M_FLAT + "5",
+  DISCORD_MIN_MODES = [ "Melodic Minor " + M_FLAT + "5",
     "Dorian " + M_FLAT + "9 " + M_FLAT + "4",
     "Minor Lydian Augmented",
     "Lydian Dominant " + M_FLAT + "9",
     "Lydian Augmented " + M_SHARP + "2 " + M_SHARP + "3",
     "Semilocrian " + M_FLAT + M_FLAT + "7",
     "Superlocrian " + M_FLAT + M_FLAT + "6", ]
+  DISCORDMINMODES = DISCORD_MIN_MODES
 
-  HUNGARIANMODES = [ "Hungarian",
+  HUNGARIAN_MODES = [ "Hungarian",
     "Superlocrian " + M_FLAT + M_FLAT + "6 " + M_FLAT + M_FLAT + "7",
     "Harmonic Minor " + M_FLAT + "5",
     "Superlocrian " + M_SHARP + "6",
     "Melodic Minor " + M_SHARP + "5",
     "Dorian " + M_FLAT + "9 " + M_SHARP + "11",
     "Lydian Augmented " + M_SHARP + "3", ]
+  HUNGARIANMODES = HUNGARIAN_MODES
+
+  MODE_ARRAY = [
+    MAJOR_MODES,
+    MEL_MINOR_MODES,
+    HARM_MINOR_MODES,
+    HARM_MAJOR_MODES,
+    DISCORD_MIN_MODES,
+    HUNGARIAN_MODES,
+  ]
+end
+
+module MusicSetTheory
+
+  #
+  #
+  #
+  Pentatonic_NAT_POSNS = (0...5).to_a     # 5音音階
+  Hexatonic_NAT_POSNS  = (0...6).to_a     # 6音音階
+  Heptatonic_NAT_POSNS = HEPT_NAT_POSNS   # 7音音階
+  Octatonic_NAT_POSNS  = (0...8).to_a     # 8音音階
+
+  # Pentatonic.
+  #
+  #
+  MAJOR_PENTA_NOTE_POS  = [ 0, 2, 4, 7,  9, ]
+  MINOR_PENTA_NOTE_POS  = [ 0, 3, 5, 7, 10, ]
+  RYUKYU_PENTA_NOTE_POS = [ 0, 4, 5, 7, 11, ]
+
+  BLUES_HEXA_NOTE_POS   = [ 0, 3, 5, 6, 7, 10, ]
+
+  def self.def_scale( const_name, name: , tment: ,
+                      note_pos: , modes: [],
+                      scale_array: :ScaleArray )
+    posns = (0...(note_pos.size)).to_a
+
+    tmp = NoteSeqScale.new(name, tment, note_pos, posns, modes)
+    self.const_set(const_name, tmp)
+    ret = self.const_get(const_name)
+
+    self.const_get(scale_array).const_set(const_name,ret)
+
+    ret
+  end
+
+  def self.undef_scale( const_name, scale_array: :ScaleArray )
+    self.const_get(scale_array).send(:remove_const, const_name)
+    self.send(:remove_const, const_name)
+  end
+
+  def self.scales( scale_array: :ScaleArray )
+    self.const_get(scale_array).constants
+  end
 
 end
 
@@ -401,23 +474,51 @@ end
 #
 #
 module MusicSetTheory
-  MajorScale     = NoteSeqScale.new("Major", WestTemp,
-                     CHROM_NAT_NOTE_POS, HEPT_NAT_POSNS, MAJORMODES)
-
-  MelMinorScale  = NoteSeqScale.new("Melodic Minor", WestTemp,
-                     MEL_MIN_NOTE_POS, HEPT_NAT_POSNS, MELMINORMODES)
-
-  HarmMinorScale = NoteSeqScale.new("Harmonic Minor", WestTemp,
-                     HARM_MIN_NOTE_POS, HEPT_NAT_POSNS, HARMINORMODES)
-
-  HarmMajorScale = NoteSeqScale.new("Harmonic Major", WestTemp,
-                     HARM_MAJ_NOTE_POS, HEPT_NAT_POSNS, HARMMAJORMODES)
-
-  DiscMinorScale = NoteSeqScale.new("Discordant Minor", WestTemp,
-                     DISC_MIN_NOTE_POS, HEPT_NAT_POSNS, DISCORDMINMODES)
+  #ScaleArray = []
+  module ScaleArray; end
+
+  #MajorScale     = NoteSeqScale.new("Major", WestTemp,
+  #                   CHROM_NAT_NOTE_POS, HEPT_NAT_POSNS, MAJORMODES)
+  #MelMinorScale  = NoteSeqScale.new("Melodic Minor", WestTemp,
+  #                   MEL_MIN_NOTE_POS, HEPT_NAT_POSNS, MELMINORMODES)
+  #HarmMinorScale = NoteSeqScale.new("Harmonic Minor", WestTemp,
+  #                   HARM_MIN_NOTE_POS, HEPT_NAT_POSNS, HARMINORMODES)
+  #HarmMajorScale = NoteSeqScale.new("Harmonic Major", WestTemp,
+  #                   HARM_MAJ_NOTE_POS, HEPT_NAT_POSNS, HARMMAJORMODES)
+  #DiscMinorScale = NoteSeqScale.new("Discordant Minor", WestTemp,
+  #                   DISC_MIN_NOTE_POS, HEPT_NAT_POSNS, DISCORDMINMODES)
+  #HungarianScale = NoteSeqScale.new("Hungarian", WestTemp,
+  #                   HUNGARIAN_NOTE_POS, HEPT_NAT_POSNS, HUNGARIANMODES)
+  def_scale :MajorScale, name: "Major", tment: WestTemp,
+    note_pos: CHROM_NAT_NOTE_POS, modes: MAJOR_MODES
+
+  def_scale :MelMinorScale, name: "Melodic Minor", tment: WestTemp,
+    note_pos: MEL_MIN_NOTE_POS, modes: MEL_MINOR_MODES
+
+  def_scale :HarmMinorScale, name: "Harmonic Minor", tment: WestTemp,
+    note_pos: HARM_MIN_NOTE_POS, modes: HARM_MINOR_MODES
+
+  def_scale :HarmMajorScale, name: "Harmonic Major", tment: WestTemp,
+    note_pos: HARM_MAJ_NOTE_POS, modes: HARM_MAJOR_MODES
+
+  def_scale :DiscMinorScale, name: "Discordant Minor", tment: WestTemp,
+    note_pos: DISC_MIN_NOTE_POS, modes: DISCORD_MIN_MODES
+
+  def_scale :HungarianScale, name: "Hungarian", tment: WestTemp,
+    note_pos: HUNGARIAN_NOTE_POS, modes: HUNGARIAN_MODES
+
+  # Pentatonic scales.
+  def_scale :MajorPentaScale, name: "Major Pentatonic", tment: WestTemp,
+    note_pos: MAJOR_PENTA_NOTE_POS
+  def_scale :MinorPentaScale, name: "Minor Pentatonic", tment: WestTemp,
+    note_pos: MINOR_PENTA_NOTE_POS
+  def_scale :RyukyuPentaScale, name: "Ryukyu Pentatonic", tment: WestTemp,
+    note_pos: RYUKYU_PENTA_NOTE_POS
+
+  # Hexatonic scales.
+  def_scale :BluesHexaScale, name: "Blues", tment: WestTemp,
+    note_pos: BLUES_HEXA_NOTE_POS
 
-  HungarianScale = NoteSeqScale.new("Hungarian", WestTemp,
-                     HUNGARIAN_NOTE_POS, HEPT_NAT_POSNS, HUNGARIANMODES)
 end
 
 

data/lib/music_set_theory/temperament.rb

@@ -396,13 +396,23 @@ module MusicSetTheory
       # Initialiser.
       # ==== Args
       # no_keys:: the number of keys in the temperament.
+      #   !number of semitones in one octave. ex. 12.
       # nat_keys:: an array consisting of the names of the natural
       #   (unsharped or unflattened) keys in the temperament.
+      #   ex.
+      #     ["C", "D", "E", "F", "G", "A", "B"]
+      #
       # nat_key_posn:: the position of the natural keys in the temperament.
       #   These should correspond to the elements in nat_keys.
       #   Positions are calculated base zero.
+      #   ex.
+      #     [  0,   2,   4,   5,   7,   9,  11]
       #
-      def initialize( no_keys, nat_keys, nat_key_posn )
+      # def initialize( no_keys, nat_keys, nat_key_posn )
+      def initialize( no_keys       = CHROM_SIZE,
+                      nat_keys      = CHROM_NAT_NOTES,
+                      nat_key_posn  = CHROM_NAT_NOTE_POS )
+        #
         self.no_keys      = no_keys
         self.nat_keys     = nat_keys
         self.nat_key_posn = nat_key_posn
@@ -436,13 +446,29 @@ module MusicSetTheory
 
         #  Useful for dictionary lookup later.
         #self.seq_maps = seq_dict([NSEQ_SCALE, NSEQ_CHORD], self);
-        #self.seq_maps = SeqDict.new(NSEQ_SCALE, NSEQ_CHORD);
         self.seq_maps = SeqDict.new([NSEQ_SCALE, NSEQ_CHORD], self)
 
       end
 
+      # Alias methods of getters+setters.
+      # {
+      #   original_base_name: [ name of aliases ],
+      #   original_base_name: [ name of aliases ],
+      #   :
+      #   :
+      # }
+      #
       {
-        seq_maps:            [:seq_dict],
+        no_keys:      [ :num_semitones, :num_keys, ],
+        nat_keys:     [ :natural_key_names, ],
+        nat_key_posn: [ :natural_key_positions, ],
+        no_nat_keys:  [ :num_natural_keys, ],
+        nat_key_pos_lookup: [
+          :natural_key_position_lookup, :natural_key_position_dict, ],
+        pos_lookup_nat_key: [
+          :position_natural_key_lookup, :position_natural_key_dict, ],
+
+        seq_maps: [:seq_dict],
       }.each do |k, vary|
 
         vary.each do |new_name|
@@ -525,6 +551,9 @@ module MusicSetTheory
       # position of the key in the unit of halftone. ex. key: "C"  =>0,
       # key: "D#" =>3, key: "Cb" =>-1
       #
+      # ==== See Also
+      # - `#get_key_of_pos()`
+      #
       def get_pos_of_key( key, debug_f: false )
         key_parsed = self.note_parse(key)
         $stderr.puts "key_parsed: #{key_parsed}"  if debug_f
@@ -534,6 +563,9 @@ module MusicSetTheory
         ret = self.nat_key_pos_lookup[key_parsed[0]] + key_parsed[1]
         ret
       end
+      alias pos_of_key  get_pos_of_key
+      alias position_of get_pos_of_key
+      alias pos_of      get_pos_of_key
 
       # Given a position in the temperament, this function attempts to
       # return the "best" key name corresponding to it. This is not a 
@@ -546,9 +578,9 @@ module MusicSetTheory
       # pos:: the position inside the temperament.
       # desired_nat_note:: the preferred natural key to start the key name.
       #   For example "C" makes the function return "C#" instead of "Db".
-      #   If None, then the preference depends on...
-      # sharp_not_flat:: if True, returns the sharpened accidental form 
-      # (e.g., "C#"); if False, returns the flattened accidental form
+      #   If nil, then the preference depends on...
+      # sharp_not_flat:: if true, returns the sharpened accidental form 
+      # (e.g., "C#"); if false, returns the flattened accidental form
       # (i.e., "Db").
       # ==== Returns
       #
@@ -602,6 +634,8 @@ module MusicSetTheory
 
         return nil
       end
+      alias key_of_pos get_key_of_pos
+      alias key_of     get_key_of_pos
 
 
       # This function takes a key and a sequence of positions relative to
@@ -669,6 +703,8 @@ module MusicSetTheory
       # ["D", "C#", "E"]  =>["D", [0, 11, 2]]
       #
       # this is returned by the function.
+      # ==== See Also
+      # - `#get_note_sequence()`
       #
       def get_keyseq_notes( note_seq )
         base_key = note_seq[0]
@@ -679,52 +715,70 @@ module MusicSetTheory
         [base_key, pos_seq]
       end
 
+    end
+
+  end
+end
+
+
+#
+#
+#
+module MusicSetTheory
+  module Temperament
+
+    class Temperament
+
 
       ### The next few functions are rip-offs of SeqDict functions.
+      #
+      #! actually these are the utility methods for SeqDict instance.
+      #
+
 
-      # This adds an element to the dictionary inside the temperament. The
-      # arguments:
-      # elem: the element to add  to the dictionary .
-      # nseq_type: the type of the elemenet (such as scale or chord).
-      # name_s: a string, or a sequence of strings. This provides names
+      # This adds an element to the dictionary inside the temperament.
+      # ==== Args
+      # elem:: the element to add  to the dictionary .
+      # nseq_type:: the type of the elemenet (such as scale or chord).
+      # name_s:: a string, or a sequence of strings. This provides names
       #   as keys that map onto elem.
-      # abbrv_s: a string, or a sequence of strings. This provides 
+      # abbrv_s:: a string, or a sequence of strings. This provides 
       #   abbreviations as keys that map onto elem.
-      # seqpos: a sequence. A tuple form will be used as a key that
+      # seqpos:: a sequence. A tuple form will be used as a key that
       #   maps onto elem.
       #
       # If nseq_type is not associated with any of the sub-dictionaries in
       # the dictionary in the temperament, then this function exits.
       #
       def add_elem( elem, nseq_type, name_s, abbrv_s, seqpos )
-        self.seq_maps.add_elem(elem, nseq_type, name_s, abbrv_s, seqpos)
+        self.seq_dict.add_elem(elem, nseq_type, name_s, abbrv_s, seqpos)
       end
 
 
       # Checks if there is a subdictionary associated with nseq_type.
       def check_nseqby_subdict( nseq_type )
-        self.seq_maps.check_nseqby_subdict(nseq_type)
+        self.seq_dict.check_nseqby_subdict(nseq_type)
       end
 
       # Checks if there is a noteseq with a given name.
       def check_nseqby_name( nseq_type, name )
-        self.seq_maps.check_nseqby_name(nseq_type, name)
+        self.seq_dict.check_nseqby_name(nseq_type, name)
       end
 
       # Checks if there is a noteseq with a given abbreviation.
       def check_nseqby_abbrv( nseq_type, abbrv )
-        self.seq_maps.check_nseqby_abbrv(nseq_type, abbrv)
+        self.seq_dict.check_nseqby_abbrv(nseq_type, abbrv)
       end
 
       # Checks if there is a noteseq with a given sequence position.
       def check_nseqby_seqpos( nseq_type, seqpos )
-        self.seq_maps.check_nseqby_seqpos(nseq_type, seqpos)
+        self.seq_dict.check_nseqby_seqpos(nseq_type, seqpos)
       end
-  
+
       # Looks up a noteseq (or anything else) by name.
       def get_nseqby_name( name, nseq_type )
-         if self.seq_maps.check_nseqby_name(nseq_type, name)
-           self.seq_maps.get_nseqby_name(name, nseq_type)
+         if self.seq_dict.check_nseqby_name(nseq_type, name)
+           self.seq_dict.get_nseqby_name(name, nseq_type)
          else
            nil
          end
@@ -748,8 +802,8 @@ module MusicSetTheory
         end
       end
 
-
     end
+
   end
 end
 
@@ -760,9 +814,15 @@ end
 module MusicSetTheory
   module Temperament
 
-    CHROM_NAT_NOTES     = ["C", "D", "E", "F", "G", "A", "B"]
-    CHROM_NAT_NOTE_POS  = [0, 2, 4, 5, 7, 9, 11]
+    #
+    # CHROM_SIZE:: number of semitones.
+    # CHROM_NAT_NOTE_POS:: position in number of semitones.
+    #   ex. D = 2 (i.e., C + #*2), E = 4 (C + #*4), etc.
+    # CHROM_NAT_NOTES:: natural notes.
+    #
     CHROM_SIZE          = 12
+    CHROM_NAT_NOTES     = ["C", "D", "E", "F", "G", "A", "B"]
+    CHROM_NAT_NOTE_POS  = [  0,   2,   4,   5,   7,   9,  11]
     def self.WestTempNew
       Temperament.new(CHROM_SIZE, CHROM_NAT_NOTES, CHROM_NAT_NOTE_POS)
     end
@@ -772,9 +832,13 @@ module MusicSetTheory
 
     #WestTemp = deep_freeze(WestTempNew()) # the last failed in chords_test(1).
     #WestTemp = WestTempNew()  # the last failed in chords_test(1).
-    WestTemp = MusicSetTheory.deep_freeze(WestTempNew())
     #ng. WestTemp.deep_freeze
 
+    ### freeze for debug.
+    # WestTemp = MusicSetTheory.deep_freeze(WestTempNew())
+    WestTemp  = WestTempNew()  # ok. (dependancied removed in test cases).
+    WestTment = WestTemp  # alias.
+
   end
 end
 

data/lib/music_set_theory/version.rb

@@ -4,7 +4,7 @@
 #
 
 module MusicSetTheory
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end
 
 

data/lib/music_set_theory.rb

@@ -20,5 +20,8 @@ require_relative "music_set_theory/temperament"
 require_relative "music_set_theory/scales"
 require_relative "music_set_theory/chords"
 
+#
+require_relative "music_set_theory/chord_generator"
+
 
 #### endof filename: music_set_theory.rb.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: music_set_theory
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - YAMAMOTO, Masayuki
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: ice_nine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
 description: A music theory library based on Python's `musictheory` package.
 email:
 - mephistobooks@users.noreply.github.com
@@ -45,12 +59,12 @@ files:
 - lib/music_set_theory/temperament.rb
 - lib/music_set_theory/version.rb
 - sig/music_theory.rbs
-homepage: https://voidptrjp.blogspot.com/2025/07/musictheorygem.html
+homepage: https://voidptrjp.blogspot.com/2025/07/musicsettheorygem.html
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://voidptrjp.blogspot.com/2025/07/musictheorygem.html
+  homepage_uri: https://voidptrjp.blogspot.com/2025/07/musicsettheorygem.html
   source_code_uri: https://github.com/mephistobooks/music_set_theory
   changelog_uri: https://github.com/mephistobooks/music_set_theory/CHANGELOG.md
 rdoc_options: []