musa-dsl 0.14.16

data/lib/musa-dsl/music/chord-definition.rb

@@ -0,0 +1,99 @@
+module Musa
+  class ChordDefinition
+    class << self
+      def [](name)
+        @definitions[name]
+      end
+
+      def register(name, offsets:, **features)
+        definition = ChordDefinition.new(name, offsets: offsets, **features).freeze
+
+        @definitions ||= {}
+        @definitions[definition.name] = definition
+
+        @features_by_value ||= {}
+        definition.features.each { |k, v| @features_by_value[v] = k }
+
+        self
+      end
+
+      def find_by_pitches(pitches)
+        @definitions.values.find { |d| d.matches(pitches) }
+      end
+
+      def features_from(values = nil, hash = nil)
+        values ||= []
+        hash ||= {}
+
+        features = hash.dup
+        values.each { |v| features[@features_by_value[v]] = v }
+
+        features
+      end
+
+      def find_by_features(*values, **hash)
+        features = features_from(values, hash)
+        @definitions.values.select { |d| features <= d.features }
+      end
+
+      def feature_key_of(feature_value)
+        @features_by_value[feature_value]
+      end
+    end
+
+    def initialize(name, offsets:, **features)
+      @name = name
+      @features = features.clone.freeze
+      @pitch_offsets = offsets.clone.freeze
+      @pitch_names = offsets.collect { |k, v| [v, k] }.to_h
+    end
+
+    attr_reader :name, :features, :pitch_offsets, :pitch_names
+
+    def pitches(root_pitch)
+      @pitch_offsets.values.collect { |offset| root_pitch + offset }
+    end
+
+    def named_pitches(elements_or_pitches, &block)
+      pitches = elements_or_pitches.collect do |element_or_pitch|
+        [if block_given?
+           yield element_or_pitch
+         else
+           element_or_pitch
+         end,
+         element_or_pitch]
+      end.to_h
+
+      root_pitch = pitches.keys.find do |candidate_root_pitch|
+        candidate_pitches = pitches.keys.collect { |p| p - candidate_root_pitch }
+        octave_reduce(candidate_pitches).uniq == octave_reduce(@pitch_offsets.values).uniq
+      end
+
+      # TODO: OJO: problema con las notas duplicadas, con la identificación de inversiones y con las notas a distancias de más de una octava
+
+      pitches.collect do |pitch, element|
+        [@pitch_names[pitch - root_pitch], [element]]
+      end.to_h
+    end
+
+    def matches(pitches)
+      reduced_pitches = octave_reduce(pitches).uniq
+
+      !!reduced_pitches.find do |candidate_root_pitch|
+        reduced_pitches.sort == octave_reduce(pitches(candidate_root_pitch)).uniq.sort
+      end
+    end
+
+    def inspect
+      "<ChordDefinition: name = #{@name} features = #{@features} pitch_offsets = #{@pitch_offsets}>"
+    end
+
+    alias to_s inspect
+
+    protected
+
+    def octave_reduce(pitches)
+      pitches.collect { |p| p % 12 }
+    end
+  end
+end

data/lib/musa-dsl/music/chord-definitions.rb

@@ -0,0 +1,13 @@
+Musa::ChordDefinition.register :maj, quality: :major, size: :triad, offsets: { root: 0, third: 4, fifth: 7 }
+Musa::ChordDefinition.register :min, quality: :minor, size: :triad, offsets: { root: 0, third: 3, fifth: 7 }
+
+Musa::ChordDefinition.register :maj7, quality: :major, size: :seventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11 }
+Musa::ChordDefinition.register :maj7, quality: :major, size: :seventh, dominant: :dominant , offsets: { root: 0, third: 4, fifth: 7, seventh: 10 }
+
+Musa::ChordDefinition.register :min7, quality: :minor, size: :seventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11 }
+
+Musa::ChordDefinition.register :maj9, quality: :major, size: :ninth, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14 }
+Musa::ChordDefinition.register :min9, quality: :minor, size: :ninth, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14 }
+
+Musa::ChordDefinition.register :maj11, quality: :major, size: :eleventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
+Musa::ChordDefinition.register :min11, quality: :minor, size: :eleventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }

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

@@ -0,0 +1,326 @@
+require_relative 'scales'
+require_relative 'chord-definition'
+
+module Musa
+  class Chord
+    def initialize(name_or_notes_or_pitches = nil, # name | [notes] | [pitches]
+                   # definitory
+                   name: nil,
+                   root: nil, root_grade: nil,
+                   notes: nil, pitches: nil,
+                   features: nil,
+                   # target scale (or scale reference)
+                   scale: nil,
+                   allow_chromatic: nil,
+                   # operations
+                   inversion: nil, state: nil,
+                   position: nil,
+                   move: nil,
+                   duplicate: nil,
+                   add: nil,
+                   drop: nil,
+                   #
+                   _source: nil)
+
+      # Preparing notes and pitches Arrays: they will we used to collect further notes and pitches
+      #
+      if notes
+        notes = notes.collect do |n|
+          case n
+          when Musa::NoteInScale
+            n
+          when Numeric, Symbol
+            scale[n]
+          else
+            raise ArgumentError, "Can't recognize #{n} in notes list #{notes}"
+          end
+        end
+      end
+
+      pitches = pitches.clone if pitches
+
+      # Preparing root_pitch
+      #
+
+      root_pitch = nil
+
+      raise ArgumentError, "Duplicate parameter: root: #{root} and root_grade: #{root_grade}" if root && root_grade
+
+      allow_chromatic ||= scale.nil?
+
+      if root && root.is_a?(Musa::NoteInScale)
+        root_pitch = root.pitch
+        scale ||= root.scale
+      end
+
+      raise ArgumentError, "Don't know how to recognize root_grade #{root_grade}: scale is not provided" if root_grade && !scale
+
+      root_pitch = scale[root_grade].pitch if root_grade && scale
+
+      # Parse name_or_notes_or_pitches to name, notes, pitches
+      #
+      #
+      case name_or_notes_or_pitches
+      when Symbol
+        raise ArgumentError, "Duplicate parameter #{name_or_notes_or_pitches} and name: #{name}" if name
+
+        name = name_or_notes_or_pitches
+
+      when Array
+        name_or_notes_or_pitches.each do |note_or_pitch|
+          case note_or_pitch
+          when Musa::NoteInScale
+            notes ||= [] << note_or_pitch
+          when Numeric
+            if scale
+              notes ||= [] << scale[note_or_pitch]
+            else
+              pitches ||= [] << note_or_pitch
+            end
+          when Symbol
+            raise ArgumentError, "Don't know how to recognize #{note_or_pitch} in parameter list #{name_or_notes_or_pitches}: it's a symbol but the scale is not provided" unless scale
+
+            notes ||= [] << scale[note_or_pitch]
+          else
+            raise ArgumentError, "Can't recognize #{note_or_pitch} in parameter list #{name_or_notes_or_pitches}"
+          end
+        end
+
+      when nil
+        # nothing happens
+      else
+        raise ArgumentError, "Can't recognize #{name_or_notes_or_pitches}"
+      end
+
+      # Eval definitory atributes
+      #
+
+      if _source.nil?
+        @notes = compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+      else
+        @notes = compute_notes_from_source(_source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+      end
+
+      # Eval adding / droping operations
+      #
+
+      if add
+        add.each do |to_add|
+          case to_add
+          when NoteInScale
+            @notes << to_add
+          when Numeric # pitch increment
+            pitch = root_pitch + to_add
+            @notes << scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)
+          when Symbol # interval name
+            pitch = root_pitch + scale.offset_of_interval(to_add)
+            @notes << scale.note_of_pitch(pitch)
+          else
+            raise ArgumentError, "Can't recognize element to add #{to_add}"
+          end
+        end
+      end
+
+      # TODO: Missing chord operations: drop, inversion, state, position
+      #
+      raise NotImplementedError, 'Missing chord operations: drop, inversion, state, position' if drop || inversion || state || position
+
+      # Eval voice increment operations
+      #
+
+      if move
+        raise ArgumentError, 'move: expected a Hash' unless move.is_a?(Hash)
+
+        move.each do |position, octave|
+          @notes[position][0] = @notes[position][0].octave(octave)
+        end
+      end
+
+      if duplicate
+        raise ArgumentError, 'duplicate: expected a Hash' unless duplicate.is_a?(Hash)
+
+        duplicate.each do |position, octave|
+          octave.arrayfy.each do |octave|
+            @notes[position] << @notes[position][0].octave(octave)
+          end
+        end
+      end
+
+      # Identify chord
+      #
+
+      @notes.freeze
+
+      @chord_definition = ChordDefinition.find_by_pitches(@notes.values.flatten(1).collect(&:pitch))
+    end
+
+    attr_reader :notes, :chord_definition
+
+    def name(name = nil)
+      if name.nil?
+        @chord_definition.name if @chord_definition
+      else
+        Chord.new(_source: self, name: name)
+      end
+    end
+
+    def features
+      @chord_definition.features if @chord_definition
+    end
+
+    def featuring(*values, allow_chromatic: nil, **hash)
+      features = @chord_definition.features.dup if @chord_definition
+      features ||= {}
+
+      ChordDefinition.features_from(values, hash).each { |k, v| features[k] = v }
+
+      Chord.new(_source: self, allow_chromatic: allow_chromatic, features: features)
+    end
+
+    def root(root = nil)
+      if root.nil?
+        @notes[:root]
+      else
+        Chord.new(_source: self, root: root)
+      end
+    end
+
+    def [](position)
+      case position
+      when Numeric
+        @notes.values[position]
+      when Symbol
+        @notes[position]
+      end
+    end
+
+    def move(**octaves)
+      Chord.new(_source: self, move: octaves)
+    end
+
+    def duplicate(**octaves)
+      Chord.new(_source: self, duplicate: octaves)
+    end
+
+    def scale
+      scales = @notes.values.flatten(1).collect(&:scale).uniq
+      scales.first if scales.size == 1
+    end
+
+    # Converts the chord to a specific scale with the notes in the chord
+    def as_scale
+    end
+
+
+    def project_on_all(*scales, allow_chromatic: nil)
+      # TODO add match to other chords... what does it means?
+      allow_chromatic ||= false
+
+      note_sets = {}
+      scales.each do |scale|
+        if allow_chromatic
+          note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) || n.on(scale.chromatic) }
+        else
+          note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) }
+        end
+      end
+
+      note_sets_in_scale = note_sets.values.reject { |notes| notes.include?(nil) }
+      note_sets_in_scale.collect { |notes| Chord.new(notes: notes) }
+    end
+
+    def project_on(*scales, allow_chromatic: nil)
+      allow_chromatic ||= false
+      project_on_all(*scales, allow_chromatic: allow_chromatic).first
+    end
+
+    def ==(other)
+      self.class == other.class && @notes == other.notes
+    end
+
+    def inspect
+      "<Chord: notes = #{@notes}>"
+    end
+
+    alias to_s inspect
+
+    private
+
+    def compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+      if name && root_pitch && scale && !(notes || pitches || features)
+
+        chord_definition = ChordDefinition[name]
+
+        raise ArgumentError, "Unrecognized #{name} chord" unless chord_definition
+
+        chord_definition.pitch_offsets.transform_values do |offset|
+          pitch = root_pitch + offset
+          [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
+        end
+
+      elsif root_pitch && features && scale && !(name || notes || pitches)
+
+        chord_definitions = ChordDefinition.find_by_features(**features)
+
+        unless allow_chromatic
+          chord_definitions.reject! do |chord_definition|
+            chord_definition.pitches(root_pitch).find { |chord_pitch| scale.note_of_pitch(chord_pitch).nil? }
+          end
+        end
+
+        selected = chord_definitions.first
+
+        unless selected
+          raise ArgumentError, "Don't know how to create a chord with root pitch #{root_pitch}"\
+            " and features #{features} based on scale #{scale.kind.class} with root on #{scale.root}: "\
+            " no suitable definition found (allow_chromatic is #{allow_chromatic})"
+        end
+
+        selected.pitch_offsets.transform_values do |offset|
+          pitch = root_pitch + offset
+          [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
+        end
+
+      elsif (notes || pitches && scale) && !(name || root_pitch || features)
+
+        notes ||= []
+
+        notes += pitches.collect { |p| scale.note_of_pitch(p) } if pitches
+
+        chord_definition = ChordDefinition.find_by_pitches(notes.collect(&:pitch))
+
+        raise "Can't find a chord definition for pitches #{pitches} on scale #{scale.kind.id} based on #{scale.root}" unless chord_definition
+
+        chord_definition.named_pitches(notes, &:pitch)
+      else
+        pattern = { name: name, root: root_pitch, scale: scale, notes: notes, pitches: pitches, features: features, allow_chromatic: allow_chromatic }
+        raise ArgumentError, "Can't understand chord definition pattern #{pattern}"
+      end
+    end
+
+    def compute_notes_from_source(source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+      if !(name || root_pitch || scale || notes || pitches || features)
+        source.notes
+
+      elsif features && !(name || root_pitch || scale || notes || pitches)
+        compute_notes(nil, source.root.first.pitch, source.root.first.scale, nil, nil, features, allow_chromatic)
+
+      else
+        pattern = { name: name, root: root_pitch, scale: scale, notes: notes, pitches: pitches, features: features, allow_chromatic: allow_chromatic }
+        raise ArgumentError, "Can't understand chord definition pattern #{pattern}"
+      end
+    end
+
+    def method_missing(method_name, *args, **key_args, &block)
+      if ChordDefinition.feature_key_of(method_name) && args.empty? && key_args.empty? && !block
+        featuring(method_name)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private)
+      ChordDefinition.feature_key_of(method_name) || super
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+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 }
+
+      def id
+        :et12
+      end
+
+      def notes_in_octave
+        12
+      end
+
+      def part_of_tone_size
+        1
+      end
+
+      def intervals
+        @@intervals
+      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
+      end
+
+      def id
+        :chromatic
+      end
+
+      def chromatic?
+        true
+      end
+    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
+    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
+    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
+    end
+
+    EquallyTempered12ToneScaleSystem.register MinorHarmonicScaleKind
+  end
+end