musa-dsl 0.14.32 → 0.21.5

data/lib/musa-dsl/music/equally-tempered-12-tone-scale-system.rb

@@ -1,204 +1,208 @@
+require_relative 'scales'
+
 module Musa
-  class TwelveSemitonesScaleSystem < ScaleSystem
-    class << self
-      @@intervals = { P0: 0, m2: 1, M2: 2, m3: 3, M3: 4, P4: 5, TT: 6, P5: 7, m6: 8, M6: 9, m7: 10, M7: 11, P8: 12 }
+  module Scales
+    class TwelveSemitonesScaleSystem < ScaleSystem
+      class << self
+        @@intervals = { P0: 0, m2: 1, M2: 2, m3: 3, M3: 4, P4: 5, TT: 6, P5: 7, m6: 8, M6: 9, m7: 10, M7: 11, P8: 12 }
 
-      def id
-        :et12
-      end
+        def id
+          :et12
+        end
 
-      def notes_in_octave
-        12
-      end
+        def notes_in_octave
+          12
+        end
 
-      def part_of_tone_size
-        1
-      end
+        def part_of_tone_size
+          1
+        end
 
-      def intervals
-        @@intervals
+        def intervals
+          @@intervals
+        end
       end
     end
-  end
-
-  class EquallyTempered12ToneScaleSystem < TwelveSemitonesScaleSystem
-    class << self
-      def frequency_of_pitch(pitch, _root_pitch, a_frequency)
-        (a_frequency * Rational(2)**Rational(pitch - 69, 12)).to_f
-      end
-    end
-
-    Scales.register EquallyTempered12ToneScaleSystem, default: true
-  end
-
 
-  class ChromaticScaleKind < ScaleKind
-    class << self
-      @@pitches =
-        [{ functions: [:_1], pitch: 0 },
-         { functions: [:_2], pitch: 1 },
-         { functions: [:_3], pitch: 2 },
-         { functions: [:_4], pitch: 3 },
-         { functions: [:_5], pitch: 4 },
-         { functions: [:_6], pitch: 5 },
-         { functions: [:_7], pitch: 6 },
-         { functions: [:_8], pitch: 7 },
-         { functions: [:_9], pitch: 8 },
-         { functions: [:_10], pitch: 9 },
-         { functions: [:_11], pitch: 10 },
-         { functions: [:_12], pitch: 11 }].freeze
-
-      def pitches
-        @@pitches
+    class EquallyTempered12ToneScaleSystem < TwelveSemitonesScaleSystem
+      class << self
+        def frequency_of_pitch(pitch, _root_pitch, a_frequency)
+          (a_frequency * Rational(2)**Rational(pitch - 69, 12)).to_f
+        end
       end
 
-      def id
-        :chromatic
-      end
-
-      def chromatic?
-        true
-      end
+      Scales.register EquallyTempered12ToneScaleSystem, default: true
     end
 
-    EquallyTempered12ToneScaleSystem.register ChromaticScaleKind
-  end
-
-  class MajorScaleKind < ScaleKind
-    class << self
-      @@pitches =
-        [{ functions: %i[I _1 tonic],
-           pitch: 0 },
-         { functions: %i[II _2 supertonic],
-           pitch: 2 },
-         { functions: %i[III _3 mediant],
-           pitch: 4 },
-         { functions: %i[IV _4 subdominant],
-           pitch: 5 },
-         { functions: %i[V _5 dominant],
-           pitch: 7 },
-         { functions: %i[VI _6 submediant relative relative_minor],
-           pitch: 9 },
-         { functions: %i[VII _7 leading],
-           pitch: 11 },
-         { functions: %i[VIII _8],
-           pitch: 12 },
-         { functions: %i[IX _9],
-           pitch: 12 + 2 },
-         { functions: %i[X _10],
-           pitch: 12 + 4 },
-         { functions: %i[XI _11],
-           pitch: 12 + 5 },
-         { functions: %i[XII _12],
-           pitch: 12 + 7 },
-         { functions: %i[XIII _13],
-           pitch: 12 + 9 }].freeze
-
-      def pitches
-        @@pitches
-      end
 
-      def grades
-        7
-      end
-
-      def id
-        :major
-      end
+    class ChromaticScaleKind < ScaleKind
+      class << self
+        @@pitches =
+            [{ functions: [:_1], pitch: 0 },
+             { functions: [:_2], pitch: 1 },
+             { functions: [:_3], pitch: 2 },
+             { functions: [:_4], pitch: 3 },
+             { functions: [:_5], pitch: 4 },
+             { functions: [:_6], pitch: 5 },
+             { functions: [:_7], pitch: 6 },
+             { functions: [:_8], pitch: 7 },
+             { functions: [:_9], pitch: 8 },
+             { functions: [:_10], pitch: 9 },
+             { functions: [:_11], pitch: 10 },
+             { functions: [:_12], pitch: 11 }].freeze
+
+        def pitches
+          @@pitches
+        end
+
+        def id
+          :chromatic
+        end
+
+        def chromatic?
+          true
+        end
+      end
+
+      EquallyTempered12ToneScaleSystem.register ChromaticScaleKind
     end
 
-    EquallyTempered12ToneScaleSystem.register MajorScaleKind
-  end
-
-  class MinorScaleKind < ScaleKind
-    class << self
-      @@pitches =
-        [{ functions: %i[i _1 tonic],
-           pitch: 0 },
-         { functions: %i[ii _2 supertonic],
-           pitch: 2 },
-         { functions: %i[iii _3 mediant relative relative_major],
-           pitch: 3 },
-         { functions: %i[iv _4 subdominant],
-           pitch: 5 },
-         { functions: %i[v _5 dominant],
-           pitch: 7 },
-         { functions: %i[vi _6 submediant],
-           pitch: 8 },
-         { functions: %i[vii _7],
-           pitch: 10 },
-         { functions: %i[viii _8],
-           pitch: 12 },
-         { functions: %i[ix _9],
-           pitch: 12 + 2 },
-         { functions: %i[x _10],
-           pitch: 12 + 3 },
-         { functions: %i[xi _11],
-           pitch: 12 + 5 },
-         { functions: %i[xii _12],
-           pitch: 12 + 7 },
-         { functions: %i[xiii _13],
-           pitch: 12 + 8 }].freeze
-
-      def pitches
-        @@pitches
-      end
-
-      def grades
-        7
-      end
-
-      def id
-        :minor
-      end
+    class MajorScaleKind < ScaleKind
+      class << self
+        @@pitches =
+            [{ functions: %i[I _1 tonic],
+               pitch: 0 },
+             { functions: %i[II _2 supertonic],
+               pitch: 2 },
+             { functions: %i[III _3 mediant],
+               pitch: 4 },
+             { functions: %i[IV _4 subdominant],
+               pitch: 5 },
+             { functions: %i[V _5 dominant],
+               pitch: 7 },
+             { functions: %i[VI _6 submediant relative relative_minor],
+               pitch: 9 },
+             { functions: %i[VII _7 leading],
+               pitch: 11 },
+             { functions: %i[VIII _8],
+               pitch: 12 },
+             { functions: %i[IX _9],
+               pitch: 12 + 2 },
+             { functions: %i[X _10],
+               pitch: 12 + 4 },
+             { functions: %i[XI _11],
+               pitch: 12 + 5 },
+             { functions: %i[XII _12],
+               pitch: 12 + 7 },
+             { functions: %i[XIII _13],
+               pitch: 12 + 9 }].freeze
+
+        def pitches
+          @@pitches
+        end
+
+        def grades
+          7
+        end
+
+        def id
+          :major
+        end
+      end
+
+      EquallyTempered12ToneScaleSystem.register MajorScaleKind
     end
 
-    EquallyTempered12ToneScaleSystem.register MinorScaleKind
-  end
-
-  class MinorHarmonicScaleKind < ScaleKind
-    class << self
-      @@pitches =
-        [{ functions: %i[i _1 tonic],
-           pitch: 0 },
-         { functions: %i[ii _2 supertonic],
-           pitch: 2 },
-         { functions: %i[iii _3 mediant relative relative_major],
-           pitch: 3 },
-         { functions: %i[iv _4 subdominant],
-           pitch: 5 },
-         { functions: %i[v _5 dominant],
-           pitch: 7 },
-         { functions: %i[vi _6 submediant],
-           pitch: 8 },
-         { functions: %i[vii _7 leading],
-           pitch: 11 },
-         { functions: %i[viii _8],
-           pitch: 12 },
-         { functions: %i[ix _9],
-           pitch: 12 + 2 },
-         { functions: %i[x _10],
-           pitch: 12 + 3 },
-         { functions: %i[xi _11],
-           pitch: 12 + 5 },
-         { functions: %i[xii _12],
-           pitch: 12 + 7 },
-         { functions: %i[xiii _13],
-           pitch: 12 + 8 }].freeze
-
-      def pitches
-        @@pitches
-      end
-
-      def grades
-        7
-      end
-
-      def id
-        :minor_harmonic
-      end
+    class MinorScaleKind < ScaleKind
+      class << self
+        @@pitches =
+            [{ functions: %i[i _1 tonic],
+               pitch: 0 },
+             { functions: %i[ii _2 supertonic],
+               pitch: 2 },
+             { functions: %i[iii _3 mediant relative relative_major],
+               pitch: 3 },
+             { functions: %i[iv _4 subdominant],
+               pitch: 5 },
+             { functions: %i[v _5 dominant],
+               pitch: 7 },
+             { functions: %i[vi _6 submediant],
+               pitch: 8 },
+             { functions: %i[vii _7],
+               pitch: 10 },
+             { functions: %i[viii _8],
+               pitch: 12 },
+             { functions: %i[ix _9],
+               pitch: 12 + 2 },
+             { functions: %i[x _10],
+               pitch: 12 + 3 },
+             { functions: %i[xi _11],
+               pitch: 12 + 5 },
+             { functions: %i[xii _12],
+               pitch: 12 + 7 },
+             { functions: %i[xiii _13],
+               pitch: 12 + 8 }].freeze
+
+        def pitches
+          @@pitches
+        end
+
+        def grades
+          7
+        end
+
+        def id
+          :minor
+        end
+      end
+
+      EquallyTempered12ToneScaleSystem.register MinorScaleKind
     end
 
-    EquallyTempered12ToneScaleSystem.register MinorHarmonicScaleKind
+    class MinorHarmonicScaleKind < ScaleKind
+      class << self
+        @@pitches =
+            [{ functions: %i[i _1 tonic],
+               pitch: 0 },
+             { functions: %i[ii _2 supertonic],
+               pitch: 2 },
+             { functions: %i[iii _3 mediant relative relative_major],
+               pitch: 3 },
+             { functions: %i[iv _4 subdominant],
+               pitch: 5 },
+             { functions: %i[v _5 dominant],
+               pitch: 7 },
+             { functions: %i[vi _6 submediant],
+               pitch: 8 },
+             { functions: %i[vii _7 leading],
+               pitch: 11 },
+             { functions: %i[viii _8],
+               pitch: 12 },
+             { functions: %i[ix _9],
+               pitch: 12 + 2 },
+             { functions: %i[x _10],
+               pitch: 12 + 3 },
+             { functions: %i[xi _11],
+               pitch: 12 + 5 },
+             { functions: %i[xii _12],
+               pitch: 12 + 7 },
+             { functions: %i[xiii _13],
+               pitch: 12 + 8 }].freeze
+
+        def pitches
+          @@pitches
+        end
+
+        def grades
+          7
+        end
+
+        def id
+          :minor_harmonic
+        end
+      end
+
+      EquallyTempered12ToneScaleSystem.register MinorHarmonicScaleKind
+    end
   end
 end

data/lib/musa-dsl/music/scales.rb

@@ -1,47 +1,36 @@
 module Musa
   module Scales
-    class << self
-      def register(scale_system, default: nil)
+    module Scales
+      def self.register(scale_system, default: nil)
         @scale_systems ||= {}
         @scale_systems[scale_system.id] = scale_system
 
         @default_scale_system = scale_system if default
+
+        self.class.define_method scale_system.id do
+          scale_system
+        end
+
         self
       end
 
-      def [](id)
+      def self.[](id)
         raise KeyError, "Scale system :#{id} not found" unless @scale_systems.key?(id)
 
         @scale_systems[id]
       end
 
-      def default_system
+      def self.default_system
         @default_scale_system
       end
-
-      private
-
-      def method_missing(method_name, *args, **key_args, &block)
-        if @scale_systems.key?(method_name) && args.empty? && key_args.empty? && !block
-          self[method_name]
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_name, include_private)
-        @scale_systems.key?(method_name) || super
-      end
     end
-  end
 
-  class ScaleSystem
-    class << self
+    class ScaleSystem
       # @abstract Subclass is expected to implement names
       # @!method id
       # @return [Symbol] the id of the ScaleSystem as a symbol
       #
-      def id
+      def self.id
         raise 'Method not implemented. Should be implemented in subclass.'
       end
 
@@ -49,7 +38,7 @@ module Musa
       # @!method notes_in_octave
       # @return [Integer] the number of notes in one octave in the ScaleSystem
       #
-      def notes_in_octave
+      def self.notes_in_octave
         raise 'Method not implemented. Should be implemented in subclass.'
       end
 
@@ -57,7 +46,7 @@ module Musa
       # @!method part_of_tone_size
       # @return [Integer] the size inside the ScaleSystem of the smaller part of a tone; used for calculate sharp and flat notes
       #
-      def part_of_tone_size
+      def self.part_of_tone_size
         raise 'Method not implemented. Should be implemented in subclass.'
       end
 
@@ -65,7 +54,7 @@ module Musa
       # @!method intervals
       # @return [Hash] the intervals of the ScaleSystem as { name: semitones#, ... }
       #
-      def intervals
+      def self.intervals
         # TODO: implementar intérvalos sinónimos (p.ej, m3 = A2)
         # TODO: implementar identificación de intérvalos, teniendo en cuenta no sólo los semitonos sino los grados de separación
         # TODO: implementar inversión de intérvalos
@@ -79,7 +68,7 @@ module Musa
       # @param a_frequency [Number] The reference frequency of the mid A note
       # @return [Number] the frequency of the fundamental tone of the pitch
       #
-      def frequency_of_pitch(pitch, root_pitch, a_frequency)
+      def self.frequency_of_pitch(pitch, root_pitch, a_frequency)
         raise 'Method not implemented. Should be implemented in subclass.'
       end
 
@@ -87,11 +76,11 @@ module Musa
       # @!method default_a_frequency
       # @return [Number] the frequency A by default
       #
-      def default_a_frequency
+      def self.default_a_frequency
         440.0
       end
 
-      def [](a_frequency)
+      def self.[](a_frequency)
         a_frequency = a_frequency.to_f
 
         @a_tunings ||= {}
@@ -100,15 +89,15 @@ module Musa
         @a_tunings[a_frequency]
       end
 
-      def offset_of_interval(name)
+      def self.offset_of_interval(name)
         intervals[name]
       end
 
-      def default_tuning
+      def self.default_tuning
         self[default_a_frequency]
       end
 
-      def register(scale_kind_class)
+      def self.register(scale_kind_class)
         @scale_kind_classes ||= {}
         @scale_kind_classes[scale_kind_class.id] = scale_kind_class
         if scale_kind_class.chromatic?
@@ -117,468 +106,478 @@ module Musa
         self
       end
 
-      def scale_kind_class(id)
+      def self.scale_kind_class(id)
         raise KeyError, "Scale kind class [#{id}] not found in scale system [#{self.id}]" unless @scale_kind_classes.key? id
 
         @scale_kind_classes[id]
       end
 
-      def scale_kind_class?(id)
+      def self.scale_kind_class?(id)
         @scale_kind_classes.key? id
       end
 
-      def chromatic_class
+      def self.scale_kind_classes
+        @scale_kind_classes
+      end
+
+      def self.chromatic_class
         raise "Chromatic scale kind class for [#{self.id}] scale system undefined" if @chromatic_scale_kind_class.nil?
 
         @chromatic_scale_kind_class
       end
-    end
 
-    def ==(other)
-      self.class == other.class
+      def ==(other)
+        self.class == other.class
+      end
     end
-  end
 
-  class ScaleSystemTuning
-    extend Forwardable
+    class ScaleSystemTuning
+      extend Forwardable
 
-    def initialize(scale_system, a_frequency)
-      @scale_system = scale_system
-      @a_frequency = a_frequency
-      @scale_kinds = {}
+      def initialize(scale_system, a_frequency)
+        @scale_system = scale_system
+        @a_frequency = a_frequency
+        @scale_kinds = {}
 
-      @chromatic_scale_kind = self[@scale_system.chromatic_class.id]
-    end
-
-    # TODO: allow scales not based in octaves but in other intervals (like fifths or other ratios). Possibly based on intervals definition of ScaleSystem plus a "generator interval" attribute
-
-    def_delegators :@scale_system, :notes_in_octave, :offset_of_interval
+        @chromatic_scale_kind = self[@scale_system.chromatic_class.id]
 
-    attr_reader :a_frequency, :scale_system
+        @scale_system.scale_kind_classes.each_key do |name|
+          define_singleton_method name do
+            self[name]
+          end
+        end
+      end
 
-    def [](scale_kind_class_id)
-      @scale_kinds[scale_kind_class_id] ||= @scale_system.scale_kind_class(scale_kind_class_id).new self
-    end
+      # TODO: allow scales not based in octaves but in other intervals (like fifths or other ratios). Possibly based on intervals definition of ScaleSystem plus a "generator interval" attribute
 
-    def chromatic
-      @chromatic_scale_kind
-    end
+      def_delegators :@scale_system, :notes_in_octave, :offset_of_interval
 
-    def frequency_of_pitch(pitch, root)
-      @scale_system.frequency_of_pitch(pitch, root, @a_frequency)
-    end
+      attr_reader :a_frequency, :scale_system
 
-    def ==(other)
-      self.class == other.class &&
-        @scale_system == other.scale_system &&
-        @a_frequency == other.a_frequency
-    end
+      def [](scale_kind_class_id)
+        @scale_kinds[scale_kind_class_id] ||= @scale_system.scale_kind_class(scale_kind_class_id).new self
+      end
 
-    def inspect
-      "<ScaleSystemTuning: scale_system = #{@scale_system} a_frequency = #{@a_frequency}>"
-    end
+      def chromatic
+        @chromatic_scale_kind
+      end
 
-    alias to_s inspect
+      def frequency_of_pitch(pitch, root)
+        @scale_system.frequency_of_pitch(pitch, root, @a_frequency)
+      end
 
-    private
+      def ==(other)
+        self.class == other.class &&
+            @scale_system == other.scale_system &&
+            @a_frequency == other.a_frequency
+      end
 
-    def method_missing(method_name, *args, **key_args, &block)
-      if @scale_system.scale_kind_class?(method_name) && args.empty? && key_args.empty? && !block
-        self[method_name]
-      else
-        super
+      def inspect
+        "<ScaleSystemTuning: scale_system = #{@scale_system} a_frequency = #{@a_frequency}>"
       end
-    end
 
-    def respond_to_missing?(method_name, include_private)
-      @scale_system.scale_kind_class?(method_name) || super
+      alias to_s inspect
     end
-  end
 
-  class ScaleKind
-    extend Forwardable
+    class ScaleKind
+      extend Forwardable
 
-    def initialize(tuning)
-      @tuning = tuning
-      @scales = {}
-    end
+      def initialize(tuning)
+        @tuning = tuning
+        @scales = {}
+      end
 
-    attr_reader :tuning
+      attr_reader :tuning
 
-    def [](root_pitch)
-      @scales[root_pitch] = Scale.new(self, root_pitch: root_pitch) unless @scales.key?(root_pitch)
-      @scales[root_pitch]
-    end
+      def [](root_pitch)
+        @scales[root_pitch] = Scale.new(self, root_pitch: root_pitch) unless @scales.key?(root_pitch)
+        @scales[root_pitch]
+      end
 
-    def absolut
-      self[0]
-    end
+      def absolut
+        self[0]
+      end
 
-    def ==(other)
-      self.class == other.class && @tuning == other.tuning
-    end
+      def ==(other)
+        self.class == other.class && @tuning == other.tuning
+      end
 
-    def inspect
-      "<#{self.class.name}: tuning = #{@tuning}>"
-    end
+      def inspect
+        "<#{self.class.name}: tuning = #{@tuning}>"
+      end
 
-    alias to_s inspect
+      alias to_s inspect
 
-    class << self
       # @abstract Subclass is expected to implement id
       # @!method id
       # @return [Symbol] the id of the ScaleKind as a symbol
-      def id
+      def self.id
         raise 'Method not implemented. Should be implemented in subclass.'
       end
 
       # @abstract Subclass is expected to implement pitches
       # @!method pitches
       # @return [Array] the pitches array of the ScaleKind as [ { functions: [ <symbol>, ...], pitch: <Number> }, ... ]
-      def pitches
+      def self.pitches
         raise 'Method not implemented. Should be implemented in subclass.'
       end
 
       # @abstract Subclass is expected to implement chromatic?. Only one of the subclasses should return true.
       # @!method chromatic?
       # @return [Boolean] wether the scales is a full scale (with all the notes in the ScaleSystem), sorted and to be considered canonical. I.e. a chromatic 12 semitones uprising serie in a 12 tone tempered ScaleSystem.
-      def chromatic?
+      def self.chromatic?
         false
       end
 
       # @abstract Subclass is expected to implement grades when the ScaleKind is defining more pitches than notes by octave has the scale. This can happen when there are pitches defined on upper octaves (i.e., to define XII grade, as a octave + fifth)
       # @!method grades
       # @return [Integer] Number of grades inside of a octave of the scale
-      def grades
+      def self.grades
         pitches.length
       end
 
-      def find_index(symbol)
-        init unless @index
-        @index[symbol]
+      def self.grade_of_function(symbol)
+        create_grade_functions_index unless @grade_names_index
+        @grade_names_index[symbol]
       end
 
+      def self.grades_functions
+        create_grade_functions_index unless @grade_names_index
+        @grade_names_index.keys
+      end
 
       private
 
-      def init
-        @index = {}
+      def self.create_grade_functions_index
+        @grade_names_index = {}
         pitches.each_index do |i|
           pitches[i][:functions].each do |function|
-            @index[function] = i
+            @grade_names_index[function] = i
           end
         end
+
         self
       end
     end
-  end
 
-  class Scale
-    extend Forwardable
+    class Scale
+      extend Forwardable
 
-    def initialize(kind, root_pitch:)
-      @notes_by_grade = {}
-      @notes_by_pitch = {}
+      def initialize(kind, root_pitch:)
+        @notes_by_grade = {}
+        @notes_by_pitch = {}
 
-      @kind = kind
+        @kind = kind
 
-      @root_pitch = root_pitch
-    end
+        @root_pitch = root_pitch
 
-    def_delegators :@kind, :a_tuning
+        @kind.class.grades_functions.each do |name|
+          define_singleton_method name do
+            self[name]
+          end
+        end
 
-    attr_reader :kind, :root_pitch
+      end
 
-    def root
-      self[0]
-    end
+      def_delegators :@kind, :a_tuning
 
-    def chromatic
-      @kind.tuning.chromatic[@root_pitch]
-    end
+      attr_reader :kind, :root_pitch
 
-    def absolut
-      @kind[0]
-    end
+      def root
+        self[0]
+      end
 
-    def octave(octave)
-      raise ArgumentError, "#{octave} is not integer" unless octave == octave.to_i
+      def chromatic
+        @kind.tuning.chromatic[@root_pitch]
+      end
 
-      @kind[@root_pitch + octave * @kind.class.grades]
-    end
+      def absolut
+        @kind[0]
+      end
 
-    def [](grade_or_symbol)
+      def octave(octave)
+        raise ArgumentError, "#{octave} is not integer" unless octave == octave.to_i
 
-      raise ArgumentError, "grade_or_symbol '#{grade_or_symbol}' should be a Numeric, String or Symbol" unless grade_or_symbol.is_a?(Symbol) || grade_or_symbol.is_a?(String) || grade_or_symbol.is_a?(Integer)
+        @kind[@root_pitch + octave * @kind.class.grades]
+      end
 
-      wide_grade, sharps = grade_of(grade_or_symbol)
+      def [](grade_or_symbol)
 
-      unless @notes_by_grade.key?(wide_grade)
+        raise ArgumentError, "grade_or_symbol '#{grade_or_symbol}' should be a Numeric, String or Symbol" unless grade_or_symbol.is_a?(Symbol) || grade_or_symbol.is_a?(String) || grade_or_symbol.is_a?(Integer)
 
-        octave = wide_grade / @kind.class.grades
-        grade = wide_grade % @kind.class.grades
+        wide_grade, sharps = grade_of(grade_or_symbol)
 
-        pitch = @root_pitch +
-                octave * @kind.tuning.notes_in_octave +
-                @kind.class.pitches[grade][:pitch]
+        unless @notes_by_grade.key?(wide_grade)
 
-        note = NoteInScale.new self, grade, octave, pitch
+          octave = wide_grade / @kind.class.grades
+          grade = wide_grade % @kind.class.grades
 
-        @notes_by_grade[wide_grade] = @notes_by_pitch[pitch] = note
-      end
+          pitch = @root_pitch +
+              octave * @kind.tuning.notes_in_octave +
+              @kind.class.pitches[grade][:pitch]
 
+          note = NoteInScale.new self, grade, octave, pitch
 
-      @notes_by_grade[wide_grade].sharp(sharps)
-    end
+          @notes_by_grade[wide_grade] = @notes_by_pitch[pitch] = note
+        end
 
-    def grade_of(grade_or_string_or_symbol)
-      sign, name, wide_grade, accidentals = Musa::Datasets::GDVd::Parser.parse_grade(grade_or_string_or_symbol)
 
-      raise ArgumentError, "Cannot parse sign on #{grade_or_string_or_symbol}" if sign
+        @notes_by_grade[wide_grade].sharp(sharps)
+      end
 
-      grade = @kind.class.find_index name if name
+      def grade_of(grade_or_string_or_symbol)
+        name, wide_grade, accidentals = parse_grade(grade_or_string_or_symbol)
 
-      octave = wide_grade / @kind.class.grades if wide_grade
-      grade = wide_grade % @kind.class.grades if wide_grade
+        grade = @kind.class.grade_of_function name if name
 
-      octave ||= 0
+        octave = wide_grade / @kind.class.grades if wide_grade
+        grade = wide_grade % @kind.class.grades if wide_grade
 
-      return octave * @kind.class.grades + grade, accidentals
-    end
+        octave ||= 0
 
-    def note_of_pitch(pitch, allow_chromatic: nil, allow_nearest: nil)
-      allow_chromatic ||= false
-      allow_nearest ||= false
+        return octave * @kind.class.grades + grade, accidentals
+      end
 
-      note = @notes_by_pitch[pitch]
+      def parse_grade(neuma_grade)
+        name = wide_grade = nil
+        accidentals = 0
 
-      unless note
-        pitch_offset = pitch - @root_pitch
+        case neuma_grade
+        when Symbol, String
+          match = /\A(?<name>[^[#|_]]*)(?<accidental_sharps>#*)(?<accidental_flats>_*)\Z/.match neuma_grade.to_s
 
-        pitch_offset_in_octave = pitch_offset % @kind.tuning.scale_system.notes_in_octave
-        pitch_offset_octave = pitch_offset / @kind.tuning.scale_system.notes_in_octave
+          if match
+            if match[:name] == match[:name].to_i.to_s
+              wide_grade = match[:name].to_i
+            else
+              name = match[:name].to_sym unless match[:name].empty?
+            end
+            accidentals = match[:accidental_sharps].length - match[:accidental_flats].length
+          else
+            name = neuma_grade.to_sym unless (neuma_grade.nil? || neuma_grade.empty?)
+          end
+        when Numeric
+          wide_grade = neuma_grade.to_i
 
-        grade = @kind.class.pitches.find_index { |pitch_definition| pitch_definition[:pitch] == pitch_offset_in_octave }
+        else
+          raise ArgumentError, "Cannot eval #{neuma_grade} as name or grade position."
+        end
 
-        if grade
-          wide_grade = pitch_offset_octave * @kind.class.grades + grade
-          note = self[wide_grade]
+        return name, wide_grade, accidentals
+      end
 
-        elsif allow_nearest
-          sharps = 0
+      def note_of_pitch(pitch, allow_chromatic: nil, allow_nearest: nil)
+        allow_chromatic ||= false
+        allow_nearest ||= false
 
-          until note
-            note = note_of_pitch(pitch - (sharps += 1) * @kind.tuning.scale_system.part_of_tone_size)
-            note ||= note_of_pitch(pitch + sharps * @kind.tuning.scale_system.part_of_tone_size)
-          end
+        note = @notes_by_pitch[pitch]
 
-        elsif allow_chromatic
-          nearest = note_of_pitch(pitch, allow_nearest: true)
+        unless note
+          pitch_offset = pitch - @root_pitch
 
-          note = chromatic.note_of_pitch(pitch).with_background(scale: self, grade: nearest.grade, octave: nearest.octave, sharps: (pitch - nearest.pitch) / @kind.tuning.scale_system.part_of_tone_size)
-        end
-      end
+          pitch_offset_in_octave = pitch_offset % @kind.tuning.scale_system.notes_in_octave
+          pitch_offset_octave = pitch_offset / @kind.tuning.scale_system.notes_in_octave
 
-      note
-    end
+          grade = @kind.class.pitches.find_index { |pitch_definition| pitch_definition[:pitch] == pitch_offset_in_octave }
 
-    def offset_of_interval(interval_name)
-      @kind.tuning.offset_of_interval(interval_name)
-    end
+          if grade
+            wide_grade = pitch_offset_octave * @kind.class.grades + grade
+            note = self[wide_grade]
 
-    def chord_of(*grades_or_symbols)
-      Chord.new(notes: grades_or_symbols.collect { |g| self[g] })
-    end
+          elsif allow_nearest
+            sharps = 0
 
-    def ==(other)
-      self.class == other.class &&
-        @kind == other.kind &&
-        @root_pitch == other.root_pitch
-    end
+            until note
+              note = note_of_pitch(pitch - (sharps += 1) * @kind.tuning.scale_system.part_of_tone_size)
+              note ||= note_of_pitch(pitch + sharps * @kind.tuning.scale_system.part_of_tone_size)
+            end
 
-    def inspect
-      "<Scale: kind = #{@kind} root_pitch = #{@root_pitch}>"
-    end
+          elsif allow_chromatic
+            nearest = note_of_pitch(pitch, allow_nearest: true)
 
-    alias to_s inspect
+            note = chromatic.note_of_pitch(pitch).with_background(scale: self, grade: nearest.grade, octave: nearest.octave, sharps: (pitch - nearest.pitch) / @kind.tuning.scale_system.part_of_tone_size)
+          end
+        end
 
-    private
+        note
+      end
 
-    def method_missing(method_name, *args, **key_args, &block)
-      if @kind.class.find_index(method_name) && args.empty? && key_args.empty? && !block
-        self[method_name]
-      else
-        super
+      def offset_of_interval(interval_name)
+        @kind.tuning.offset_of_interval(interval_name)
       end
-    end
 
-    def respond_to_missing?(method_name, include_private)
-      @kind.class.find_index(method_name) || super
-    end
-  end
+      def chord_of(*grades_or_symbols)
+        Chord.new(notes: grades_or_symbols.collect { |g| self[g] })
+      end
 
-  class NoteInScale
-
-    # @param scale [Scale]
-    # @param grade []
-    # @param octave [Integer]
-    # @param pitch [Number] pitch of the note, based on MIDI note numbers. Can be Integer, Rational or Float to express fractions of a semitone
-    #
-    def initialize(scale, grade, octave, pitch, background_scale: nil, background_grade: nil, background_octave: nil, background_sharps: nil)
-      @scale = scale
-      @grade = grade
-      @octave = octave
-      @pitch = pitch
-
-      @background_scale = background_scale
-      @background_grade = background_grade
-      @background_octave = background_octave
-      @background_sharps = background_sharps
-    end
+      def ==(other)
+        self.class == other.class &&
+            @kind == other.kind &&
+            @root_pitch == other.root_pitch
+      end
 
-    attr_reader :grade, :pitch
+      def inspect
+        "<Scale: kind = #{@kind} root_pitch = #{@root_pitch}>"
+      end
 
-    def functions
-      @scale.kind.class.pitches[grade][:functions]
+      alias to_s inspect
     end
 
-    def octave(octave = nil)
-      if octave.nil?
-        @octave
-      else
-        raise ArgumentError, "#{octave} is not integer" unless octave == octave.to_i
+    class NoteInScale
 
-        @scale[@grade + (@octave + octave) * @scale.kind.class.grades]
+      # @param scale [Scale]
+      # @param grade []
+      # @param octave [Integer]
+      # @param pitch [Number] pitch of the note, based on MIDI note numbers. Can be Integer, Rational or Float to express fractions of a semitone
+      #
+      def initialize(scale, grade, octave, pitch, background_scale: nil, background_grade: nil, background_octave: nil, background_sharps: nil)
+        @scale = scale
+        @grade = grade
+        @octave = octave
+        @pitch = pitch
+
+        @background_scale = background_scale
+        @background_grade = background_grade
+        @background_octave = background_octave
+        @background_sharps = background_sharps
+
+        @scale.kind.tuning.scale_system.scale_kind_classes.each_key do |name|
+          define_singleton_method name do
+            scale(name)
+          end
+        end
       end
-    end
 
-    def with_background(scale:, grade: nil, octave: nil, sharps: nil)
-      NoteInScale.new(@scale, @grade, @octave, @pitch,
-                      background_scale: scale,
-                      background_grade: grade,
-                      background_octave: octave,
-                      background_sharps: sharps)
-    end
+      attr_reader :grade, :pitch
 
-    attr_reader :background_scale
+      def functions
+        @scale.kind.class.pitches[grade][:functions]
+      end
 
-    def background_note
-      @background_scale[@background_grade + (@background_octave || 0) * @background_scale.kind.class.grades] if @background_grade
-    end
+      def octave(octave = nil)
+        if octave.nil?
+          @octave
+        else
+          raise ArgumentError, "#{octave} is not integer" unless octave == octave.to_i
 
-    attr_reader :background_sharps
+          @scale[@grade + (@octave + octave) * @scale.kind.class.grades]
+        end
+      end
 
-    def wide_grade
-      @grade + @octave * @scale.kind.class.grades
-    end
+      def with_background(scale:, grade: nil, octave: nil, sharps: nil)
+        NoteInScale.new(@scale, @grade, @octave, @pitch,
+                        background_scale: scale,
+                        background_grade: grade,
+                        background_octave: octave,
+                        background_sharps: sharps)
+      end
 
-    def up(interval_name_or_interval, natural_or_chromatic = nil, sign: nil)
+      attr_reader :background_scale
 
-      sign ||= 1
+      def background_note
+        @background_scale[@background_grade + (@background_octave || 0) * @background_scale.kind.class.grades] if @background_grade
+      end
 
-      if interval_name_or_interval.is_a?(Numeric)
-        natural_or_chromatic ||= :natural
-      else
-        natural_or_chromatic = :chromatic
+      attr_reader :background_sharps
+
+      def wide_grade
+        @grade + @octave * @scale.kind.class.grades
       end
 
-      if natural_or_chromatic == :chromatic
-        interval = if interval_name_or_interval.is_a?(Symbol)
-                     @scale.kind.tuning.offset_of_interval(interval_name_or_interval)
-                   else
-                     interval_name_or_interval
-                   end
+      def up(interval_name_or_interval, natural_or_chromatic = nil, sign: nil)
+
+        sign ||= 1
+
+        if interval_name_or_interval.is_a?(Numeric)
+          natural_or_chromatic ||= :natural
+        else
+          natural_or_chromatic = :chromatic
+        end
 
-        calculate_note_of_pitch(@pitch, sign * interval)
-      else
-        @scale[@grade + sign * interval_name_or_interval]
+        if natural_or_chromatic == :chromatic
+          interval = if interval_name_or_interval.is_a?(Symbol)
+                       @scale.kind.tuning.offset_of_interval(interval_name_or_interval)
+                     else
+                       interval_name_or_interval
+                     end
+
+          calculate_note_of_pitch(@pitch, sign * interval)
+        else
+          @scale[@grade + sign * interval_name_or_interval]
+        end
       end
-    end
 
-    def calculate_note_of_pitch(in_scale_pitch, sharps)
-      pitch = in_scale_pitch + sharps * @scale.kind.tuning.scale_system.part_of_tone_size
+      def calculate_note_of_pitch(in_scale_pitch, sharps)
+        pitch = in_scale_pitch + sharps * @scale.kind.tuning.scale_system.part_of_tone_size
 
-      if pitch == @pitch
-        self
-      else
-        note = @scale.note_of_pitch(pitch, allow_chromatic: true)
-        if @background_scale
-          note.on(@background_scale) || note
+        if pitch == @pitch
+          self
         else
-          note
+          note = @scale.note_of_pitch(pitch, allow_chromatic: true)
+          if @background_scale
+            note.on(@background_scale) || note
+          else
+            note
+          end
         end
       end
-    end
 
-    private :calculate_note_of_pitch
+      private :calculate_note_of_pitch
 
-    def down(interval_name_or_interval, natural_or_chromatic = nil)
-      up(interval_name_or_interval, natural_or_chromatic, sign: -1)
-    end
+      def down(interval_name_or_interval, natural_or_chromatic = nil)
+        up(interval_name_or_interval, natural_or_chromatic, sign: -1)
+      end
 
-    def sharp(count = nil)
-      count ||= 1
-      calculate_note_of_pitch(@pitch, count)
-    end
+      def sharp(count = nil)
+        count ||= 1
+        calculate_note_of_pitch(@pitch, count)
+      end
 
-    def flat(count = nil)
-      count ||= 1
-      sharp(-count)
-    end
+      def flat(count = nil)
+        count ||= 1
+        sharp(-count)
+      end
 
-    def frequency
-      @scale.kind.tuning.frequency_of_pitch(@pitch, @scale.root)
-    end
+      def frequency
+        @scale.kind.tuning.frequency_of_pitch(@pitch, @scale.root)
+      end
 
-    def scale(kind_id_or_kind = nil)
-      if kind_id_or_kind.nil?
-        @scale
-      else
-        if kind_id_or_kind.is_a? ScaleKind
-          kind_id_or_kind[@pitch]
+      def scale(kind_id_or_kind = nil)
+        if kind_id_or_kind.nil?
+          @scale
         else
-          @scale.kind.tuning[kind_id_or_kind][@pitch]
+          if kind_id_or_kind.is_a? ScaleKind
+            kind_id_or_kind[@pitch]
+          else
+            @scale.kind.tuning[kind_id_or_kind][@pitch]
+          end
         end
       end
-    end
-
-    def on(scale)
-      scale.note_of_pitch @pitch
-    end
-
-    def chord(*feature_values, allow_chromatic: nil, **features_hash)
-      features = { size: :triad } if feature_values.empty? && features_hash.empty?
-      features ||= ChordDefinition.features_from(feature_values, features_hash)
 
-      Musa::Chord.new(root: self, allow_chromatic: allow_chromatic, features: features)
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        @scale == other.scale &&
-        @grade == other.grade &&
-        @octave == other.octave &&
-        @pitch == other.pitch
-    end
+      def on(scale)
+        scale.note_of_pitch @pitch
+      end
 
-    def inspect
-      "<NoteInScale: grade = #{@grade} octave = #{@octave} pitch = #{@pitch} scale = (#{@scale.kind.class.name} on #{scale.root_pitch})>"
-    end
+      def chord(*feature_values, allow_chromatic: nil, **features_hash)
+        features = { size: :triad } if feature_values.empty? && features_hash.empty?
+        features ||= ChordDefinition.features_from(feature_values, features_hash)
 
-    alias to_s inspect
+        Musa::Chords::Chord.new(root: self, allow_chromatic: allow_chromatic, features: features)
+      end
 
-    private
+      def ==(other)
+        self.class == other.class &&
+            @scale == other.scale &&
+            @grade == other.grade &&
+            @octave == other.octave &&
+            @pitch == other.pitch
+      end
 
-    def method_missing(method_name, *args, **key_args, &block)
-      if @scale.kind.tuning[method_name] && args.empty? && key_args.empty? && !block
-        scale(method_name)
-      else
-        super
+      def inspect
+        "<NoteInScale: grade = #{@grade} octave = #{@octave} pitch = #{@pitch} scale = (#{@scale.kind.class.name} on #{scale.root_pitch})>"
       end
-    end
 
-    def respond_to_missing?(method_name, include_private)
-      @scale.kind.tuning[method_name] || super
+      alias to_s inspect
     end
   end
 end