musa-dsl 0.14.32 → 0.21.5

data/lib/musa-dsl/datasets/score/to-mxml/process-ps.rb

@@ -0,0 +1,51 @@
+module Musa::Datasets::Score::ToMXML
+  private
+
+  DynamicsContext = Struct.new(:last_dynamics)
+  private_constant :DynamicsContext
+
+  def process_ps(measure, element, context, logger, do_log)
+    context ||= DynamicsContext.new
+
+    logger.debug "\nprocess_ps #{element}" if do_log
+
+    case element[:dataset][:type]
+    when :crescendo, :diminuendo
+      if element[:change] == :start
+        dynamics = dynamics_to_string(element[:dataset][:from])
+
+        if dynamics != context.last_dynamics
+          measure.add_dynamics dynamics, placement: 'below' if dynamics && element[:dataset][:from] > 0
+          context.last_dynamics = dynamics
+        end
+
+        measure.add_wedge element[:dataset][:type],
+                          niente: element[:dataset][:type] == :crescendo && element[:dataset][:from] == 0,
+                          placement: 'below'
+      else
+        measure.add_wedge 'stop',
+                          niente: element[:dataset][:type] == :diminuendo && element[:dataset][:to] == 0,
+                          placement: 'below'
+
+        dynamics = dynamics_to_string(element[:dataset][:to])
+
+        measure.add_dynamics dynamics, placement: 'below' if dynamics && element[:dataset][:to] > 0
+        context.last_dynamics = dynamics
+      end
+
+    when :dynamics
+      dynamics = dynamics_to_string(element[:dataset][:from])
+
+      if dynamics != context.last_dynamics
+        measure.add_dynamics dynamics, placement: 'below'
+        context.last_dynamics = dynamics
+      end
+
+    else
+      # ignored
+    end
+
+    context
+  end
+
+end

data/lib/musa-dsl/datasets/score/to-mxml/process-time.rb

@@ -0,0 +1,153 @@
+require 'prime'
+
+module Musa::Datasets::Score::ToMXML
+  private
+
+  class ElementDurationDecomposition
+    def initialize(element, bar, bar_size = 1r) # TODO remove (unused because of bad strategy to time groups)
+      @continue_from_previous_bar = element[:start] < bar
+      @continue_to_next_bar = element[:finish] >= bar + bar_size
+
+      @start = continue_from_previous_bar ? 0r : element[:start] - bar
+
+      @duration = continue_to_next_bar ?
+                      (1r - @start) :
+                      (element[:start] + element[:dataset][:duration] - (bar + start))
+
+      @duration_decomposition = integrate_as_dotteable_durations(decompose_as_sum_of_simple_durations(@duration))
+    end
+
+    attr_reader :continue_from_previous_bar, :continue_to_next_bar, :start, :duration, :duration_decomposition
+
+    def to_s
+      "ElementDurationDecomposition(#{@duration}) = [#{@duration_decomposition}]"
+    end
+
+    alias inspect to_s
+  end
+
+  private_constant :ElementDurationDecomposition
+
+  def time_and_tuplet_optimize(elements, bar, bar_size = 1r) # TODO remove (unused because of bad strategy to time groups)
+    decompositions = elements.collect { |pdv| ElementDurationDecomposition.new(pdv, bar, bar_size) }
+
+    denominators = decompositions.collect { |g| g.duration_decomposition.collect { |d| d.to_r.denominator } }.flatten.uniq
+
+    lcm_denominators = denominators.reduce(:lcm)
+
+    primes = Prime.prime_division(lcm_denominators)
+
+    factors = primes.collect { |base, exp| [base] * exp }.flatten
+
+    refactors = all_combinations(factors).collect { |a| a.reduce(&:*) }
+
+    # Y no se puede seguir con la descomposición
+
+    nil
+  end
+
+  def decompose_as_sum_of_simple_durations(duration)
+    return [] if duration.zero?
+
+    # TODO mejorar esta descomposición para que tenga menos factores redundantes
+    pd = Prime.prime_division(duration.to_r.denominator).collect { |base, exp| (1..exp).collect { |i| base ** i } }.flatten
+
+    divisors = ([[1]] + all_combinations(pd)).collect { |combination| combination.inject(:*) }
+
+    summands = []
+
+    while divisor = divisors.shift
+      c = Rational(1, divisor)
+      f = (duration / c).floor
+      n = f * c
+      summands << n unless n.zero?
+      duration -= n
+    end
+
+    raise ArgumentError, "#{duration} cannot be further decomposed" unless duration.zero?
+
+    summands
+  end
+
+  def all_combinations(numbers)
+    all_combinations = []
+    i = 1
+    until (combinations = numbers.combination(i).to_a).empty?
+      all_combinations += combinations
+      i += 1
+    end
+
+    all_combinations.uniq
+  end
+
+  def integrate_as_dotteable_durations(simple_durations)
+    integrated_durations = []
+    last = nil
+    simple_durations.each do |duration|
+      if last && duration == last / 2
+        integrated_durations[integrated_durations.size-1] += duration
+      else
+        integrated_durations << duration
+      end
+      last = duration
+    end
+    integrated_durations
+  end
+
+  def type_and_dots_and_tuplet_ratio(noteable_duration)
+    r = decompose_as_sum_of_simple_durations(noteable_duration)
+    n = r.shift
+
+    tuplet_ratio = Rational(n.denominator, nearest_lower_power_of_2(n.denominator))
+
+    type = type_of(nearest_upper_power_of_2(n))
+    dots = 0
+
+    while nn = r.shift
+      if nn == n / 2
+        dots += 1
+        n = nn
+      else
+        break
+      end
+    end
+
+    raise ArgumentError, "#{noteable_duration} cannot be decomposed as a duration with dots" unless r.empty?
+
+    return type, dots, tuplet_ratio
+  end
+
+  def nearest_upper_power_of_2(number)
+    return 0 if number.zero?
+
+    exp = Math.log2(number)
+    exp_floor = exp.floor
+    plus = exp > exp_floor ? 1 : 0
+
+    2 ** (exp_floor + plus)
+  end
+
+  def nearest_lower_power_of_2(number)
+    return 0 if number.zero?
+
+    exp_floor = Math.log2(number).floor
+
+    2 ** exp_floor
+  end
+
+  def type_of(base_type_duration)
+    duration_log2i = Math.log2(base_type_duration)
+
+    raise ArgumentError, "#{base_type_duration} is not a inverse power of 2 (i.e. 2, 1, 1/2, 1/4, 1/8, 1/64, etc)" \
+      unless base_type_duration == 2 ** duration_log2i
+
+    raise ArgumentError, "#{base_type_duration} is not between 1024th and maxima accepted durations" \
+      unless duration_log2i >= -10 && duration_log2i <= 3
+
+    ['1024th', '512th', '256th', '128th',
+     '64th', '32nd', '16th', 'eighth',
+     'quarter', 'half', 'whole', 'breve',
+     'long', 'maxima'][duration_log2i + 10]
+  end
+end
+

data/lib/musa-dsl/datasets/score/to-mxml/to-mxml.rb

@@ -0,0 +1,158 @@
+require_relative '../../../logger'
+require_relative '../../../musicxml'
+
+require_relative 'process-time'
+require_relative 'process-pdv'
+require_relative 'process-ps'
+
+module Musa::Datasets; class Score
+  module ToMXML
+    include Musa::MusicXML::Builder
+    include Musa::Datasets
+
+    def to_mxml(beats_per_bar, ticks_per_beat,
+                bpm: nil,
+                title: nil,
+                creators: nil,
+                encoding_date: nil,
+                parts:,
+                logger: nil,
+                do_log: nil)
+
+      bpm ||= 90
+      title ||= 'Untitled'
+      creators ||= { composer: 'Unknown' }
+      logger ||= Musa::Logger::Logger.new
+      do_log ||= nil
+
+      mxml = ScorePartwise.new do |_|
+        _.work_title title
+        _.creators **creators
+        _.encoding_date encoding_date if encoding_date
+
+        parts.each_pair do |id, part_info|
+          _.part id,
+                 name: part_info&.[](:name),
+                 abbreviation: part_info&.[](:abbreviation) do |_|
+
+            _.measure do |_|
+              _.attributes do |_|
+                _.divisions ticks_per_beat
+
+                i = 0
+                (part_info&.[](:clefs) || { g: 2 }).each_pair do |clef, line|
+                  i += 1
+                  _.clef i, sign: clef.upcase, line: line
+                  _.time i, beats: beats_per_bar, beat_type: 4
+                end
+              end
+
+              _.metronome placement: 'above', beat_unit: 'quarter', per_minute: bpm
+            end
+          end
+        end
+      end
+
+      if do_log
+        logger.debug"\nscore.to_mxl log:"
+        logger.debug  "-----------------"
+      end
+
+      parts.each_key do |part_id|
+        fill_part mxml.parts[part_id], beats_per_bar * ticks_per_beat, (parts.size > 1 ? part_id : nil), logger, do_log
+      end
+
+      mxml
+    end
+
+    private
+
+    def fill_part(part, divisions_per_bar, instrument, logger, do_log)
+      measure = nil
+      dynamics_context = nil
+
+      (1..finish || 0).each do |bar|
+        if do_log
+          logger.debug ""
+          logger.debug msg = "filling part #{part.name} (#{instrument}): processing bar #{bar}"
+          logger.debug "-" * msg.size
+        end
+
+        measure = part.add_measure if measure
+        measure ||= part.measures.last
+
+        pointer = 0r
+
+        instrument_score = subset { |dataset| dataset[:instrument] == instrument }
+
+        bar_elements = \
+        (instrument_score.changes_between(bar, bar + 1).select { |p| p[:dataset].is_a?(PS) } +
+            (pdvs = instrument_score.between(bar, bar + 1).select { |p| p[:dataset].is_a?(PDV) }))
+                                   .sort_by { |e| [ e[:time_in_interval] || e[:start_in_interval],
+                                                    e[:dataset].is_a?(PS) ? 0 : 1 ] }
+
+        if pdvs.empty?
+          logger.debug "\nadded full bar silence" if do_log
+
+          process_pdv(measure, bar, divisions_per_bar,
+                      { start: bar,
+                        finish: bar + 1,
+                        dataset: { pitch: :silence, duration: 1 }.extend(PDV) },
+                      pointer,
+                      logger,
+                      do_log)
+        else
+          first = bar_elements.first
+
+          logger.debug "\nfirst element #{first}" if do_log
+
+          # TODO habrá que arreglar el cálculo de pointer cuando haya avances y retrocesos para que
+          # TODO no añada silencios incorrectos al principio o al final
+
+          if (first[:time_in_interval] || first[:start_in_interval]) > bar
+
+            silence_duration = first[:start_in_interval] - bar
+
+            logger.debug "\nadded initial silence for duration #{silence_duration}" if do_log
+
+            pointer = process_pdv(measure, bar, divisions_per_bar,
+                                  { start: bar,
+                                    finish: first[:start_in_interval],
+                                    dataset: { pitch: :silence, duration: silence_duration }.extend(PDV) },
+                                  pointer,
+                                  logger,
+                                  do_log)
+          end
+
+          bar_elements.each do |element|
+            case element[:dataset]
+            when PDV
+              pointer = process_pdv(measure, bar, divisions_per_bar, element, pointer, logger, do_log)
+
+            when PS
+              dynamics_context = process_ps(measure, element, dynamics_context, logger, do_log)
+
+            else
+              # ignored
+            end
+          end
+
+          if pointer < 1r
+            silence_duration = 1r - pointer
+
+            logger.debug "\nadded ending silence for duration #{silence_duration}" if do_log
+
+            process_pdv(measure, bar, divisions_per_bar,
+                        { start: bar + pointer,
+                          finish: bar + 1 - Rational(1, divisions_per_bar),
+                          dataset: { pitch: :silence, duration: silence_duration }.extend(PDV) },
+                        pointer,
+                        logger,
+                        do_log)
+
+          end
+        end
+      end
+    end
+  end
+end; end

data/lib/musa-dsl/datasets/v.rb

@@ -0,0 +1,23 @@
+require_relative 'dataset'
+require_relative 'packed-v'
+
+module Musa::Datasets
+  module V
+    include AbsI
+
+    def to_packed_V(mapper)
+      case mapper
+      when Hash
+        pv = {}.extend(PackedV)
+        each_index { |i| pv[mapper.keys[i]] = self[i] unless self[i] == mapper.values[i] }
+        pv
+      when Array
+        pv = {}.extend(PackedV)
+        each_index { |i| pv[mapper[i]] = self[i] if mapper[i] && self[i] }
+        pv
+      else
+        raise ArgumentError, "Expected Hash or Array as mapper but got a #{mapper.class.name}"
+      end
+    end
+  end
+end

data/lib/musa-dsl/generative.rb

@@ -1,5 +1,5 @@
-require 'musa-dsl/generative/variatio'
-require 'musa-dsl/generative/darwin'
-require 'musa-dsl/generative/rules'
-require 'musa-dsl/generative/markov'
-require 'musa-dsl/generative/generative-grammar'
+require_relative 'generative/variatio'
+require_relative 'generative/darwin'
+require_relative 'generative/backboner'
+require_relative 'generative/markov'
+require_relative 'generative/generative-grammar'

data/lib/musa-dsl/generative/backboner.rb

@@ -0,0 +1,274 @@
+require_relative '../core-ext/smart-proc-binder'
+require_relative '../core-ext/with'
+
+using Musa::Extension::Arrayfy
+
+# incluir With -> hecho
+# eliminar method_missing
+# crear rama tb debe recibir la serie de la history -> ya lo hace
+# crear rama puede repetirse (hasta terminar según ended_when) -> no
+#
+# hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
+# esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
+
+module Musa
+  module Backboner
+    class Backboner
+      include Musa::Extension::With
+
+      def initialize(&block)
+        @context = RulesEvalContext.new(&block)
+      end
+
+      def generate_possibilities(object, confirmed_node = nil, node = nil, grow_rules = nil)
+        node ||= Node.new
+        grow_rules ||= @context._grow_rules
+
+        history = confirmed_node.history if confirmed_node
+        history ||= []
+
+        grow_rules = grow_rules.clone
+        grow_rule = grow_rules.shift
+
+        if grow_rule
+          grow_rule.generate_possibilities(object, history).each do |new_object|
+            new_node = Node.new new_object, node
+            new_node.mark_as_ended! if @context._ended? new_object
+
+            rejection = @context._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history) }
+            # TODO: include rejection secondary reasons in rejection message
+
+            new_node.reject! rejection if rejection
+
+            node.children << new_node
+          end
+        end
+
+        unless grow_rules.empty?
+          node.children.each do |node|
+            generate_possibilities node.object, confirmed_node, node, grow_rules unless node.rejected || node.ended?
+          end
+        end
+
+        node
+      end
+
+      def apply(object_or_list, node = nil)
+        list = object_or_list.arrayfy.clone
+
+        node ||= Node.new
+
+        seed = list.shift
+
+        if seed
+          result = generate_possibilities seed, node
+
+          fished = result.fish
+
+          node.reject! 'All children are rejected' if fished.empty?
+
+          fished.each do |object|
+            subnode = node.add(object).mark_as_ended!
+            apply list, subnode
+          end
+        end
+
+        node
+      end
+
+      class RulesEvalContext
+        include Musa::Extension::With
+
+        attr_reader :_grow_rules, :_ended_when, :_cut_rules
+
+        def initialize(&block)
+          with &block
+        end
+
+        def grow(name, &block)
+          @_grow_rules ||= []
+          @_grow_rules << GrowRule.new(name, &block)
+          self
+        end
+
+        def ended_when(&block)
+          @_ended_when = block
+          self
+        end
+
+        def cut(reason, &block)
+          @_cut_rules ||= []
+          @_cut_rules << CutRule.new(reason, &block)
+          self
+        end
+
+        def _ended?(object)
+          instance_exec object, &@_ended_when
+        end
+
+        class GrowRule
+          attr_reader :name
+
+          def initialize(name, &block)
+            @name = name
+            @block = block
+          end
+
+          def generate_possibilities(object, history)
+            # TODO: optimize context using only one instance for all genereate_possibilities calls
+            context = GrowRuleEvalContext.new
+            context.with object, history, &@block
+
+            context._branches
+          end
+
+          class GrowRuleEvalContext
+            include Musa::Extension::With
+
+            attr_reader :_branches
+
+            def initialize
+              @_branches = []
+            end
+
+            def branch(object)
+              @_branches << object
+              self
+            end
+          end
+
+          private_constant :GrowRuleEvalContext
+        end
+
+        private_constant :GrowRule
+
+        class CutRule
+          attr_reader :reason
+
+          def initialize(reason, &block)
+            @reason = reason
+            @block = block
+          end
+
+          def rejects?(object, history)
+            # TODO: optimize context using only one instance for all rejects? checks
+            context = CutRuleEvalContext.new
+            context.with object, history, &@block
+
+            reasons = context._secondary_reasons.collect { |_| ("#{@reason} (#{_})" if _) || @reason }
+
+            reasons.empty? ? nil : reasons
+          end
+
+          class CutRuleEvalContext
+            include Musa::Extension::With
+
+            attr_reader :_secondary_reasons
+
+            def initialize
+              @_secondary_reasons = []
+            end
+
+            def prune(secondary_reason = nil)
+              @_secondary_reasons << secondary_reason
+              self
+            end
+          end
+
+          private_constant :CutRuleEvalContext
+        end
+
+        private_constant :CutRule
+      end
+
+      private_constant :RulesEvalContext
+
+      class Node
+        attr_reader :parent, :children, :object, :rejected
+
+        def initialize(object = nil, parent = nil)
+          @parent = parent
+          @children = []
+          @object = object
+
+          @ended = false
+          @rejected = nil
+        end
+
+        def add(object)
+          Node.new(object, self).tap { |n| @children << n }
+        end
+
+        def reject!(rejection)
+          @rejected = rejection
+          self
+        end
+
+        def mark_as_ended!
+          @children.each(&:update_rejection_by_children!)
+
+          if !@children.empty? && !@children.find { |n| !n.rejected }
+            reject! "Node rejected because all children are rejected"
+          end
+
+          @ended = true
+
+          self
+        end
+
+        def ended?
+          @ended
+        end
+
+        def history
+          objects = []
+          n = self
+          while n && n.object
+            objects << n.object
+            n = n.parent
+          end
+
+          objects.reverse
+        end
+
+        def fish
+          fished = []
+
+          @children.each do |node|
+            unless node.rejected
+              if node.ended?
+                fished << node.object
+              else
+                fished += node.fish
+              end
+            end
+          end
+
+          fished
+        end
+
+        def combinations(parent_combination = nil)
+          parent_combination ||= []
+
+          combinations = []
+
+          unless rejected
+            if @children.empty?
+              combinations << parent_combination
+            else
+              @children.each do |node|
+                node.combinations(parent_combination + [node.object]).each do |object|
+                  combinations << object
+                end
+              end
+            end
+          end
+
+          combinations
+        end
+      end
+
+      private_constant :Node
+    end
+  end
+end