musicality 0.3.0 → 0.5.0

data/lib/musicality/notation/parsing/note_parsing.treetop

@@ -9,9 +9,12 @@ grammar Note
 
   rule note
     duration
-    art:articulation?
-    pitch_links:(first:pitch_link more:("," pl:pitch_link)*)?
-    acc:accent?
+    more:(
+      first_pl:pitch_link
+      more_pl:("," pl:pitch_link)*
+      art:articulation?
+      acc:accent?
+    )?
     <NoteNode>
   end
 

data/lib/musicality/notation/parsing/pitch_node.rb

@@ -3,13 +3,15 @@ module Parsing
   class PitchNode < Treetop::Runtime::SyntaxNode
     def to_pitch
       
-      sem = pitch_letter.to_semitone
+      modval = 0
       unless mod.empty?
-        sem += case mod.text_value
+        modval = case mod.text_value
         when "#" then 1
         when "b" then -1
         end
       end
+      sem = (pitch_letter.to_semitone + modval) % Musicality::Pitch::SEMITONES_PER_OCTAVE
+
       oct = octave.to_i
       ncents = 0
       unless cents.empty?

data/lib/musicality/performance/conversion/score_collator.rb

@@ -13,7 +13,7 @@ class ScoreCollator
   end
   
   def collate_parts
-    segments = @score.program.segments
+    segments = @score.program
     
     Hash[
       @score.parts.map do |name, part|
@@ -29,12 +29,12 @@ class ScoreCollator
   
   def collate_tempo_changes
     collate_changes(@score.start_tempo,
-      @score.tempo_changes, @score.program.segments)
+      @score.tempo_changes, @score.program)
   end
   
   def collate_meter_changes
     collate_changes(@score.start_meter,
-      @score.meter_changes, @score.program.segments)
+      @score.meter_changes, @score.program)
   end
   
   private

data/lib/musicality/performance/midi/midi_util.rb

@@ -9,14 +9,21 @@ class MidiUtil
   end
   
   p0 = Pitch.new(octave:-1,semitone:0)
-  MIDI_NOTENUMS = Hash[
-    (0..127).map do |note_num|
-      [ p0.transpose(note_num), note_num ]
-    end
-  ]
+  PITCH_TO_NOTENUM = {}
+  NOTENUM_TO_PITCH = {}
+  
+  (0..127).each do |note_num|
+    pitch = p0.transpose(note_num)
+    PITCH_TO_NOTENUM[pitch] = note_num
+    NOTENUM_TO_PITCH[note_num] = pitch
+  end
   
   def self.pitch_to_notenum pitch
-    MIDI_NOTENUMS.fetch(pitch.round)
+    PITCH_TO_NOTENUM.fetch(pitch.round)
+  end
+  
+  def self.notenum_to_pitch notenum
+    NOTENUM_TO_PITCH.fetch(notenum)
   end
   
   def self.dynamic_to_volume dynamic

data/lib/musicality/performance/midi/score_sequencing.rb

@@ -0,0 +1,17 @@
+module Musicality
+
+class Score
+  class Timed < Score
+    def to_midi_seq instr_map = {}
+      ScoreSequencer.new(self).make_midi_seq(instr_map)
+    end
+  end
+
+  class TempoBased < Score
+    def to_midi_seq tempo_sample_rate, instr_map = {}
+      to_timed(tempo_sample_rate).to_midi(instr_map)
+    end
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/errors.rb

@@ -0,0 +1,5 @@
+module Musicality
+
+UnsupportedDurationError = Class.new(RuntimeError)
+
+end

data/lib/musicality/printing/lilypond/meter_engraving.rb

@@ -0,0 +1,11 @@
+module Musicality
+
+class Meter
+  def to_lilypond
+    num = beats_per_measure * beat_duration.numerator
+    den = beat_duration.denominator
+    "#{num}/#{den}"
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/note_engraving.rb

@@ -0,0 +1,53 @@
+module Musicality
+
+class Note
+  def to_lilypond sharpit = false
+    dur_strs = []
+    d = duration
+    
+    if d > 1
+      dur_strs += ["1"]*d.to_i
+      d -= d.to_i
+    end
+
+    if d > 0
+      n = Math.log2(d)
+      if n < -7
+        raise UnsupportedDurationError, "Note duration #{d} is too short for Lilypond"
+      end
+
+      if n.to_i == n # duration is exact power of two
+        dur_strs.push (2**(-n)).to_i.to_s
+      else # duration may be dotted
+        undotted_duration = d/1.5
+        n = Math.log2(undotted_duration)
+
+        if n.to_i == n # duration (undotted) is exact power of two
+          if n < -7
+            raise UnsupportedDurationError, "Undotted note duration #{undotted_duration} is too short for Lilypond"
+          end
+
+          dur_strs.push (2**(-n)).to_i.to_s + "."
+        else
+          raise UnsupportedDurationError, "Leftover note duration #{d}is not power-of-two, and is not dotted power-of-two"
+        end
+      end
+    end
+    
+    if pitches.any?
+      if pitches.size == 1
+        p_str = pitches.first.to_lilypond
+      else
+        p_str = "<" + pitches.map {|p| p.to_lilypond}.join(" ") + ">"
+      end
+      join_str = "~ "
+    else
+      p_str = "r"
+      join_str = " "
+    end
+
+    return dur_strs.map {|dur_str| p_str + dur_str }.join(join_str)
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/part_engraver.rb

@@ -0,0 +1,12 @@
+module Musicality
+
+class PartEngraver
+  def initialize part
+    @part = part
+  end
+
+  def to_lilypad
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/pitch_engraving.rb

@@ -0,0 +1,30 @@
+module Musicality
+
+class Pitch
+  def to_lilypond sharpit = false
+    output = case semitone
+    when 0 then "c"
+    when 1 then sharpit  ? "cis" : "des"
+    when 2 then "d"
+    when 3 then sharpit  ? "dis" : "ees"
+    when 4 then "e"
+    when 5 then "f"
+    when 6 then sharpit  ? "fis" : "ges"
+    when 7 then "g"
+    when 8 then sharpit  ? "gis" : "aes"
+    when 9 then "a"
+    when 10 then sharpit  ? "ais" : "bes"
+    when 11 then "b"
+    end
+    
+    if octave > 3
+      output += "'"*(octave - 3)
+    elsif octave < 3
+      output += ","*(3 - octave)
+    end
+
+    return output
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/score_engraver.rb

@@ -0,0 +1,78 @@
+module Musicality
+
+class ScoreEngraver
+  LILYPOND_VERSION = "2.18.2"
+  MAX_LINE_LEN = 76
+
+  def initialize score
+    case score
+    when Score::Measured
+      @start_meter = score.start_meter
+    when Score::Unmeasured
+      @start_meter = Meters::FOUR_FOUR
+    else
+      raise TypeError, "Only tempo-based score support Lilypond conversion"
+    end
+
+    @parts = score.collated? ? score.parts : ScoreCollator.new(score).collate_parts
+  end
+
+  def make_lilypond part_names = nil
+    part_names ||= @parts.keys
+    output = "\\version \"#{LILYPOND_VERSION}\"\n{\n  <<\n"
+    master = true
+    part_names.each do |part_name|
+      part = @parts[part_name]
+      
+      clef = ScoreEngraver.best_clef(part.notes)
+      output += "  \\new Staff {\n"
+      output += "    \\clef #{clef}\n"
+      if(master)
+        output += "    \\time #{@start_meter.to_lilypond}\n"
+      end
+
+      line = ""
+      part.notes.each_index do |i|
+        note = part.notes[i]
+        begin
+          str = note.to_lilypond
+        rescue UnsupportedDurationError => e
+          binding.pry
+        end
+
+        if (line.size + str.size) > MAX_LINE_LEN
+          output += "    " + line
+          line = ""
+        end
+        line += str
+      end
+      output += "    " + line
+
+      output += "  }\n"
+      
+      master = false if master
+    end
+    output += "  >>\n}\n"
+    return output
+  end
+
+  def self.best_clef notes
+    ranges = { "treble" => Pitches::C4..Pitches::A5, 
+                "bass" => Pitches::E2..Pitches::C4,
+                "tenor" => Pitches::B2..Pitches::G4 }
+    range_scores = { "treble" => 0, "bass" => 0, "tenor" => 0 }
+    notes.each do |n|
+      n.pitches.each do |p|
+        ranges.each do |name,range|
+          if p >= range.min && p <= range.max
+            range_scores[name] += n.duration
+          end
+        end
+      end
+    end
+    range_score = range_scores.max_by {|range,score| score}
+    return range_score[0]
+  end
+end
+
+end

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/spec/composition/generation/random_rhythm_generator_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RandomRhythmGenerator do
+  describe '#initialize' do
+    context 'given probabilities that do not add up to 1' do
+      it 'should raise ArgumentError' do
+        [{ 1 => 0.4, 2 => 0.59 },
+         { 1/2.to_r => 0.5, 1/4.to_r => 0.5001 }].each do |durs_w_probs|
+          expect do
+            RandomRhythmGenerator.new(durs_w_probs)
+          end.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+  
+  before :all do
+    @rrgs = [
+      { 1/8.to_r => 0.25, 1/4.to_r => 0.5, 1/2.to_r => 0.25 },
+      { 1/6.to_r => 0.25, 1/4.to_r => 0.25, 1/3.to_r => 0.25, 1/12.to_r => 0.25 }
+    ].map {|durs_w_probs| RandomRhythmGenerator.new(durs_w_probs) }
+  end
+  
+  describe '#random_rhythm' do
+    it 'should return durations that add to given total dur' do
+      @rrgs.each do |rrg|
+        [3,1,1/2.to_r,5/8.to_r,15/16.to_r].each do |total_dur|
+          20.times do
+            rhythm = rrg.random_rhythm(total_dur)
+            rhythm.inject(0,:+).should eq(total_dur)
+          end
+        end
+      end
+    end
+  end
+  
+  describe '#random_dur' do
+    it 'should return a random duration, according to the probabilities given at initialization' do
+      @rrgs.each do |rrg|
+        counts = Hash[ rrg.durations.map {|dur| [dur,0] } ]
+        1000.times { counts[rrg.random_dur] += 1 }
+        rrg.durations.each_with_index do |dur,i|
+          count = counts[dur]
+          tgt_prob = rrg.probabilities[i]
+          (count / 1000.to_f).should be_within(0.05).of(tgt_prob)
+        end
+      end
+    end
+  end
+end

data/spec/composition/model/pitch_class_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include PitchClasses
+
+describe PitchClass do
+  it 'should define the MOD constant' do
+    PitchClass.constants.should include(:MOD)
+  end
+  
+  describe '.from_i' do
+    it 'should return the given integer % PitchClass::MOD' do
+      PitchClass.from_i(-1).should eq(11)
+      PitchClass.from_i(12).should eq(0)
+      PitchClass.from_i(2).should eq(2)
+      PitchClass.from_i(16).should eq(4)      
+    end
+  end
+
+  it 'should add the #to_pc method to the Fixnum class' do
+    5.methods.should include(:to_pc)
+  end
+
+  it 'should add the #to_pc method to the Pitch class' do
+    Pitch.new.methods.should include(:to_pc)
+  end
+
+  it 'should add the #to_pcs method to Enumerable classes, like Array' do
+    [1,2,3].methods.should include(:to_pcs)
+  end
+  
+  describe 'Pitch#to_pc' do
+    it 'should send semitone through PitchClass.from_i' do
+      [ C4, D3, E5, G5,
+        Pitch.new(semitone: 4),
+        Pitch.new(semitone: 13),
+      ].each do |pitch|
+        pitch.to_pc.should eq(PitchClass.from_i(pitch.semitone))
+      end
+    end
+  end
+
+  describe 'Fixnum#to_pc' do
+    it 'should pass self to PitchClass.from_i' do
+      [-1,12,2,16].each do |i|
+        i.to_pc.should eq(PitchClass.from_i(i))
+      end
+    end
+  end
+
+  describe '.invert' do
+    before :all do
+      @cases = {
+        C => C,
+        Db => B,
+        D => Bb,
+        Eb => A,
+        E => Ab,
+        F => G,
+        Gb => Gb
+      }
+    end
+
+    it 'should produce a pitch class' do
+      @cases.each do |input_pc, output_pc|
+        PitchClass.invert(input_pc).should eq(output_pc)
+      end
+    end
+
+    it 'should produce a pitch class that when inverted again produces the original pitch class' do
+      @cases.each do |input_pc, output_pc|
+        PitchClass.invert(output_pc).should eq(input_pc)
+      end
+    end
+  end
+end

data/spec/composition/model/pitch_classes_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+pc_syms = [:C, :Db, :D, :Eb, :E, :F, :Gb, :G, :Ab, :A, :Bb, :B]
+
+describe PitchClasses do
+  it 'should include pitch-class constants for C, Db, D, ...' do
+    pc_syms.each do |sym|
+      PitchClasses.constants.should include(sym)
+    end
+  end
+end
+
+
+describe 'PITCH_CLASSES' do
+  it 'should be in the Musicality module namespace' do
+    Musicality.constants.should include(:PITCH_CLASSES)
+  end
+  
+  it 'should have each constant value in PitchClasses' do
+    PitchClasses.constants.each do |sym|
+      PITCH_CLASSES.should include(PitchClasses.const_get(sym))
+    end
+  end
+end