musicality 0.3.0 → 0.5.0

data/lib/musicality/composition/util/compound_sequence.rb

@@ -0,0 +1,44 @@
+module Musicality
+
+class CompoundSequence
+  def initialize combine_method, sequences
+    @seqs = sequences
+    @comb_meth = combine_method
+  end
+  
+  def at offset
+    if offset.is_a? Enumerable
+      return enum_for(:at,offset) unless block_given?
+      enums = @seqs.map {|s| s.at(offset) }
+      offset.size.times { yield combine(enums.map {|e| e.next }) }
+    else
+      vals = @seqs.map {|s| s.at(offset) }
+      return combine(vals)
+    end
+  end
+  
+  def take n
+    return enum_for(:take,n) unless block_given?
+    enums = @seqs.map {|s| s.take(n) }
+    n.times { yield combine(enums.map {|e| e.next }) }
+  end
+  
+  def over range
+    return enum_for(:over,range) unless block_given?
+    enums = @seqs.map {|s| s.over(range) }
+    range.size.times { yield combine(enums.map {|e| e.next }) }
+  end
+  
+  def take_back n
+    return enum_for(:take_back,n) unless block_given?
+    enums = @seqs.map {|s| s.take_back(n) }
+    n.times { yield combine(enums.map {|e| e.next }) }
+  end
+  
+  private
+  def combine vals
+    vals[1..-1].inject(vals.first,@comb_meth)
+  end
+end
+
+end

data/lib/musicality/composition/util/probabilities.rb

@@ -0,0 +1,20 @@
+module Musicality
+
+class Probabilities
+  def self.uniform n
+    probs = [1/n.to_f]*n
+    sum = probs.inject(0,:+)
+    if sum != 1
+      probs[0] += (1 - sum)
+    end
+    return probs
+  end
+  
+  def self.random n
+    cumulative_probs = Array.new(n-1){ rand }.sort + [1]
+    x0 = 0
+    cumulative_probs.map {|x| y = x - x0; x0 = x; y }
+  end
+end
+
+end

data/lib/musicality/composition/util/random_sampler.rb

@@ -0,0 +1,26 @@
+module Musicality
+
+class RandomSampler
+  attr_reader :values, :probabilities
+  def initialize vals, probs
+    @values, @probabilities = vals, probs
+    total_prob = probs.inject(0,:+)
+    raise ArgumentError, "Total probability is not 1" if total_prob != 1
+    
+    offsets = AddingSequence.new(probs).over(1...probs.size).to_a
+    changes = vals[1..-1].map{|val| Change::Immediate.new(val) }
+    
+    value_changes = Hash[ [offsets, changes].transpose ]
+    @val_comp = ValueComputer.new(vals.first, value_changes)
+  end
+  
+  def sample n=nil
+    if n.nil?
+      return @val_comp.at(rand)
+    else
+      return Array.new(n){ @val_comp.at(rand) }
+    end
+  end
+end
+
+end

data/lib/musicality/composition/util/repeating_sequence.rb

@@ -0,0 +1,24 @@
+module Musicality
+
+class RepeatingSequence
+  include BiInfiniteSequence
+
+  attr_reader :start_value
+  def initialize pattern
+    raise EmptyError if pattern.empty?
+    @pattern = pattern
+    @n = pattern.size
+    @start_value = pattern.first
+  end
+  
+  def pattern_size; @pattern.size; end
+    
+  def next_value cur_val, cur_idx
+    @pattern[(cur_idx + 1) % @n]      
+  end
+  def prev_value cur_val, cur_idx
+    @pattern[(cur_idx - 1) % @n]        
+  end
+end
+
+end

data/lib/musicality/errors.rb

@@ -5,6 +5,8 @@ module Musicality
   class NonIntegerError < StandardError; end
   class NonRationalError < StandardError; end
   class NonIncreasingError < StandardError; end
+  class DecreasingError < StandardError; end
   class NotValidError < StandardError; end
   class DomainError < StandardError; end
+  class EmptyError < StandardError; end
 end

data/lib/musicality/notation/conversion/score_conversion.rb

@@ -27,7 +27,7 @@ class Score
       @parts.values.each do |part|
         part.dynamic_changes.each {|moff,change| moffs += change.offsets(moff) }
       end
-      moffs += @program.segments.map {|seg| [seg.first, seg.last] }.flatten
+      moffs += @program.map {|seg| [seg.first, seg.last] }.flatten
       return moffs.sort
     end
   

data/lib/musicality/notation/conversion/score_converter.rb

@@ -25,9 +25,9 @@ class ScoreConverter
   end
   
   def self.convert_program program, offset_map
-    Program.new(program.segments.map do |segment|
+    program.map do |segment|
       offset_map[segment.first]...offset_map[segment.last]
-    end)
+    end
   end
   
   class TempoBased
@@ -44,7 +44,7 @@ class ScoreConverter
         part.notes.each {|note| noffs.add(noff += note.duration) }
         part.dynamic_changes.each {|noff2,change| noffs += change.offsets(noff2) }
       end
-      noffs += @program.segments.map {|seg| [seg.first, seg.last] }.flatten
+      noffs += @program.map {|seg| [seg.first, seg.last] }.flatten
       return noffs.sort
     end
 

data/lib/musicality/notation/model/link.rb

@@ -10,24 +10,26 @@ class Link
     Marshal.load(Marshal.dump(self))
   end
 
-  class Tie < Link
-    def initialize; end
-    
-    def ==(other)
-      self.class == other.class
-    end
-    
-    def transpose diff
-      self.clone.transpose! diff
-    end
-    
-    def transpose! diff
-      return self
-    end
-    
-    def to_s; "="; end
+  def transpose diff
+    self.clone.transpose! diff
   end
   
+  def transpose! diff
+    return self
+  end
+
+  def ==(other)
+    self.class == other.class
+  end
+
+  def to_s
+    self.class::LINK_CHAR
+  end
+
+  class Tie < Link
+    LINK_CHAR = LINK_SYMBOLS[Links::TIE]
+  end
+
   class TargetedLink < Link
     attr_accessor :target_pitch
     
@@ -36,7 +38,7 @@ class Link
     end
     
     def ==(other)
-      self.class == other.class && @target_pitch == other.target_pitch
+      super && @target_pitch == other.target_pitch
     end
     
     def transpose diff
@@ -49,24 +51,24 @@ class Link
     end
     
     def to_s
-      link_char + @target_pitch.to_s
+      super + @target_pitch.to_s
     end
   end
   
   class Glissando < TargetedLink
-    def link_char; "~"; end
+    LINK_CHAR = LINK_SYMBOLS[Links::GLISSANDO]
   end
   
   class Portamento < TargetedLink
-    def link_char; "/"; end
+    LINK_CHAR = LINK_SYMBOLS[Links::PORTAMENTO]
   end
-  
+
   class Slur < TargetedLink
-    def link_char; "="; end
+    LINK_CHAR = LINK_SYMBOLS[Links::SLUR]
   end
-  
+
   class Legato < TargetedLink
-    def link_char; "|"; end
+    LINK_CHAR = LINK_SYMBOLS[Links::LEGATO]
   end
 end
 

data/lib/musicality/notation/model/links.rb

@@ -0,0 +1,11 @@
+module Musicality
+
+module Links
+  TIE = :tie
+  GLISSANDO = :glissando
+  PORTAMENTO = :portamento
+  SLUR = :slur
+  LEGATO = :legato
+end
+
+end

data/lib/musicality/notation/model/note.rb

@@ -22,7 +22,7 @@ class Note
   end
   
   def check_methods
-    [ :ensure_positive_duration ]
+    [ :ensure_positive_duration, :check_pitches ]
   end
   
   def ensure_positive_duration
@@ -31,6 +31,13 @@ class Note
     end
   end
   
+  def check_pitches
+    non_pitches = @pitches.select {|p| !p.is_a?(Pitch) }
+    if non_pitches.any?
+      raise TypeError, "Found non-pitches: #{non_pitches}"
+    end
+  end
+  
   def == other
     return (@duration == other.duration) &&
     (self.pitches == other.pitches) &&
@@ -73,17 +80,7 @@ class Note
     else
       dur_str = d.to_s
     end
-    
-    art_str = case @articulation
-    when Articulations::SLUR then "="
-    when Articulations::LEGATO then "|"
-    when Articulations::TENUTO then "_"
-    when Articulations::PORTATO then "%"
-    when Articulations::STACCATO then "."
-    when Articulations::STACCATISSIMO then "'"
-    else ""
-    end
-    
+
     pitch_links_str = @pitches.map do |p|
       if @links.has_key?(p)
         p.to_s + @links[p].to_s
@@ -91,9 +88,11 @@ class Note
         p.to_s
       end
     end.join(",")
-    
-    acc_str = @accented ? "!" : ""
-    return dur_str + art_str + pitch_links_str + acc_str
+
+    art_str = ARTICULATION_SYMBOLS[@articulation] || ""
+    acc_str = @accented ? ACCENT_SYMBOL : ""
+
+    return dur_str + pitch_links_str + art_str + acc_str
   end
 
   def self.add_note_method(name, dur)

data/lib/musicality/notation/model/part.rb

@@ -16,7 +16,7 @@ class Part
   end
   
   def check_methods
-    [:ensure_start_dynamic, :ensure_dynamic_change_values_range ]
+    [:check_start_dynamic, :check_dynamic_changes]
   end
   
   def validatables
@@ -37,13 +37,13 @@ class Part
     return @notes.inject(0) { |sum, note| sum + note.duration }
   end
   
-  def ensure_start_dynamic
+  def check_start_dynamic
     unless @start_dynamic.between?(0,1)
       raise RangeError, "start dynamic #{@start_dynamic} is not between 0 and 1"
     end
   end
   
-  def ensure_dynamic_change_values_range
+  def check_dynamic_changes
     outofrange = @dynamic_changes.values.select {|v| !v.end_value.between?(0,1) }
     if outofrange.any?
       raise RangeError, "dynamic change values #{outofrange} are not between 0 and 1"

data/lib/musicality/notation/model/pitch.rb

@@ -96,6 +96,14 @@ class Pitch
     Pitch.new(cent: (@total_cents + semitones * CENTS_PER_SEMITONE).round)
   end
   
+  def + semitones
+    transpose(semitones)
+  end
+
+  def - semitones
+    transpose(-semitones)
+  end
+  
   def total_semitones
     Rational(@total_cents, CENTS_PER_SEMITONE)
   end

data/lib/musicality/notation/model/score.rb

@@ -4,15 +4,14 @@ class Score
   include Validatable
   attr_accessor :parts, :program
   
-  def initialize parts: {}, program: Program.new
+  def initialize parts: {}, program: []
     @parts = parts
     @program = program
     yield(self) if block_given?
   end
 
-  def validatables
-    [ @program ] + @parts.values
-  end
+  def validatables; @parts.values; end
+  def check_methods; [:check_program, :check_parts ]; end
   
   def clone
     Marshal.load(Marshal.dump(self))
@@ -27,7 +26,7 @@ class Score
   end
   
   def collated?
-    @program.segments.size == 1 && @program.segments[0].first == 0
+    @program.size == 1 && @program[0].first == 0
   end
   
   class Timed < Score
@@ -39,16 +38,14 @@ class Score
   class TempoBased < Score
     attr_accessor :start_tempo, :tempo_changes
 
-    def initialize start_tempo, tempo_changes: {}, parts: {}, program: Program.new
+    def initialize start_tempo, tempo_changes: {}, parts: {}, program: []
       @start_tempo = start_tempo
       @tempo_changes = tempo_changes
       super(parts: parts, program: program)
-      
-      yield(self) if block_given?
     end
     
     def check_methods
-      [:check_start_tempo, :check_tempo_changes]
+      super() + [:check_start_tempo, :check_tempo_changes]
     end
   
     def ==(other)
@@ -60,16 +57,23 @@ class Score
       self.duration
     end
     
+    private
+    
     def check_start_tempo
       if @start_tempo <= 0
-        raise NonPositiveError, "start tempo (#{@start_tempo}) is not positive"
+        raise NonPositiveError, "Start tempo (#{@start_tempo}) is not positive"
       end
     end
     
     def check_tempo_changes
+      badtypes = @tempo_changes.select {|k,v| !v.end_value.is_a?(Numeric) }
+      if badtypes.any?
+        raise TypeError, "Found non-numeric tempo change values: #{badtypes}"
+      end
+      
       badvalues = @tempo_changes.select {|k,v| v.end_value <= 0 }
       if badvalues.any?
-        raise NonPositiveError, "tempo changes (#{badvalues}) are not positive"
+        raise NonPositiveError, "Found non-positive tempo changes values: #{badvalues}"
       end    
     end
   end
@@ -84,58 +88,29 @@ class Score
   class Measured < Score::TempoBased
     attr_accessor :start_meter, :meter_changes
     
-    def initialize start_meter, start_tempo, meter_changes: {}, tempo_changes: {}, parts: {}, program: Program.new
+    def initialize start_meter, start_tempo, meter_changes: {}, tempo_changes: {}, parts: {}, program: []
       @start_meter = start_meter
       @meter_changes = meter_changes
       
       super(start_tempo, tempo_changes: tempo_changes,
             program: program, parts: parts)
-      yield(self) if block_given?
     end
     
     def check_methods
-      super() + [:check_startmeter_type, :check_meterchange_types,
-                 :check_meterchange_durs, :check_meterchange_offsets]
+      super() + [:check_start_meter, :check_meter_changes]
     end
     
     def validatables
       super() + [ @start_meter ] + @meter_changes.values.map {|v| v.end_value}
     end
     
-    def check_startmeter_type
-      unless @start_meter.is_a? Meter
-        raise TypeError, "start meter #{@start_meter} is not a Meter object"
-      end
-    end
-    
-    def check_meterchange_types
-      badtypes = @meter_changes.select {|k,v| !v.end_value.is_a?(Meter) }
-      if badtypes.any?
-        raise TypeError, "meter change values #{nonmeter_values} are not Meter objects"
-      end
-    end
-    
-    def check_meterchange_offsets
-      badoffsets = @meter_changes.select {|k,v| k != k.to_i }
-      if badoffsets.any?
-        raise NonIntegerError, "meter changes #{badoffsets} have non-integer offsets"
-      end
-    end
-    
-    def check_meterchange_durs
-      nonzero_duration = @meter_changes.select {|k,v| !v.is_a?(Change::Immediate) }
-      if nonzero_duration.any?
-        raise NonZeroError, "meter changes #{nonzero_duration} are not immediate"
-      end
-    end
-    
     def ==(other)
       return super(other) && @start_meter == other.start_meter &&
         @meter_changes == other.meter_changes
     end
     
-    def measures_long
-      noff_end = self.notes_long
+    def measures_long note_dur = self.notes_long
+      noff_end = note_dur
       noff_prev = 0.to_r
       moff_prev, mdur_prev = 0.to_r, @start_meter.measure_duration
       
@@ -154,6 +129,57 @@ class Score
       end
       return moff_prev + Rational(noff_end - noff_prev, mdur_prev)
     end
+    
+    private
+    
+    def check_start_meter
+      unless @start_meter.is_a? Meter
+        raise TypeError, "Start meter #{@start_meter} is not a Meter object"
+      end
+    end
+    
+    def check_meter_changes
+      badtypes = @meter_changes.select {|k,v| !v.end_value.is_a?(Meter) }
+      if badtypes.any?
+        raise TypeError, "Found meter change values that are not Meter objects: #{nonmeter_values}"
+      end
+      
+      badoffsets = @meter_changes.select {|k,v| k != k.to_i }
+      if badoffsets.any?
+        raise NonIntegerError, "Found meter changes at non-integer offsets: #{badoffsets}"
+      end
+      
+      nonzero_duration = @meter_changes.select {|k,v| !v.is_a?(Change::Immediate) }
+      if nonzero_duration.any?
+        raise NonZeroError, "Found meter changes that are not immediate: #{nonzero_duration}"
+      end
+    end
+  end
+  
+  private
+    
+  def check_program
+    non_ranges = @program.select {|x| !x.is_a?(Range) }
+    if non_ranges.any?
+      raise TypeError, "Non-Range program element(s) found: #{non_ranges}"
+    end
+    
+    non_increasing = @program.select {|seg| seg.first >= seg.last }
+    if non_increasing.any?
+      raise NonIncreasingError, "Non-increasing program range(s) found: #{non_increasing}"
+    end
+    
+    negative = @program.select {|seg| seg.first < 0 || seg.last < 0 }
+    if negative.any?
+      raise NegativeError, "Program range(s) with negative value(s) found: #{negative}"
+    end
+  end
+  
+  def check_parts
+    non_parts = @parts.values.select {|x| !x.is_a?(Part) }
+    if non_parts.any?
+      raise TypeError, "Non-Part part value(s) found: #{non_parts}"
+    end
   end
 end