musicality 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f460185c537892ef1e12ffce5b1c829095666c7
-  data.tar.gz: fc1512fe588da6ee7599aea61ba713d268c50cc3
+  metadata.gz: 0f671084b7ea13c0ac038a4b52cfcdfa51aeb76e
+  data.tar.gz: 19e843c3f803fc34fcd3520dbbdea8bf100102f0
 SHA512:
-  metadata.gz: ab8468ae5d3f4daf66a6f054480969c0d81e5b409b9a52efc513b3fc8ec6ccf5cdace8be25df378d63a9002ec6c6db61afb9fe6d92506b01a3c53412f8abe587
-  data.tar.gz: 784d01d623fd8436e635853340905ab381915138d9ccf2773e3728084c0ad04b6083e16ee692546a7fd9556930eced67bd70e3703fad91abb3b427443a72695d
+  metadata.gz: 592b30da2943856712ddda8b78b0710d7311ef3ae9f2a9f8afad5b37a586ff4dc0227de98431b01da740b1b20d82956eaed0fe3cbfa2ddf47e7eaeba52bf968f
+  data.tar.gz: 38a0389ee700b706a3b384e4a8702b9e1743ccf36a98090c7046c3c4e9dfc731b3ff9de946e2adcb856318d15686e95e5b75d9f9814b07fcfb06c52364683540

data/ChangeLog.md

@@ -1,4 +1,11 @@
-### 0.3.0 / 2014-11-24
+### 0.4.0 / 2014-12-02
+* Make Program inherit from Array.
+* Make Program#initialize take either a single array or variable number of args.
+
+### 0.3.1 / 2014-12-01
+* Add (optional) argument to Score::Measured#measures_long, to convert a specific note duration to measure duration. If not specified, the note duration of the longest part is used (as before).
+
+### 0.3.0 / 2014-12-01
 * Conversion of both tempo-based scores (measured and unmeasured) directly to time-based score
 * Trimming of gradual changes, useful in collating scores
 * Refactoring of ValueComputer using Function and Transition utility classes

data/bin/midify

@@ -7,13 +7,11 @@ Loads a musicality score from YAML file, and converts it to a MIDI file.
 
 Usage:
   #{exe_name} <input> [PART PROGRAM] ... [options]
-  #{exe_name} <input> <output> [PART PROGRAM] ... [options]
   #{exe_name} -h | --help
   #{exe_name} --version
 
 Arguments:
   input A musicality score file (may be packed as a hash) in YAML format
-  output Midi filename
   PART name of a part in the score
   PROGRAM MIDI program (instrument) number for the given part
   
@@ -22,6 +20,7 @@ Options:
                 score, and for sampling dynamic change values [default: 200]
   -h --help     Show this screen.
   --version     Show version.
+  --outfile=OUTF Name of output MIDI file
 
 DOCOPT
 
@@ -50,7 +49,7 @@ File.open(fin_name) do |fin|
   
   unless score.is_a? Score::Timed
     print "Converting to timed score..."
-    score = score.to_timed(args["--srate"])
+    score = score.to_timed(args["--srate"].to_i)
     puts "done"
   end
   
@@ -64,7 +63,7 @@ File.open(fin_name) do |fin|
     seq = sequencer.make_midi_seq(instr_map)
     puts "done"  
   
-    fout_name = args["<output>"]
+    fout_name = args["--outfile"]
     if fout_name.nil?
       fout_name = "#{File.dirname(fin_name)}/#{File.basename(fin_name,File.extname(fin_name))}.mid"
     end

data/examples/composition/auto_counterpoint.rb

@@ -0,0 +1,53 @@
+require 'musicality'
+include Musicality
+include Pitches
+
+bass_pitch_palette = [ C2, D2, E2, F2, G2, A2, B2, C3 ]
+guitar_pitch_palette = [ C3, D3, E3, F3, G3, A3, B3, C4 ]
+
+bass = Part.new(Dynamics::MF)
+guitar = Part.new(Dynamics::MF)
+
+def random_melody rhythm, pitch_palette
+  pitches = pitch_palette.sample(rand(2..pitch_palette.size))
+  pitch_sampler = RandomSampler.new(pitches,Probabilities.random(pitches.size))
+  make_notes(rhythm, pitch_sampler.sample(rhythm.size))
+end
+  
+def random_counterpoint rhythm, rhythm_palette, sample_rate, pitch_palette
+  cpg = CounterpointGenerator.new(rhythm,rhythm_palette)
+  counterpoint = cpg.best_solutions(25,0.5,sample_rate).sample
+  pitches = pitch_palette.sample(rand(2..pitch_palette.size))
+  pitch_sampler = RandomSampler.new(pitches,Probabilities.random(pitches.size))
+  make_notes(counterpoint, pitch_sampler.sample(counterpoint.size))  
+end
+
+2.times do
+  [ {
+      :rhythm_probs => { 1/8.to_r => 0.25, 1/4.to_r => 0.25, 1/6.to_r => 0.25, 1/2.to_r => 0.25 },
+      :sample_rate => 48,
+    },
+    {
+      :rhythm_probs => { 1/8.to_r => 0.325, 1/4.to_r => 0.325, 3/16.to_r => 0.10, 1/2.to_r => 0.25 },
+      :sample_rate => 16,
+    },
+  ].each do |params|
+    rrg =RandomRhythmGenerator.new(params[:rhythm_probs])
+    rhythm_palette = params[:rhythm_probs].keys
+    5.times do
+      rhythm = rrg.random_rhythm(3/4.to_r)
+      guitar.notes += random_melody(rhythm, guitar_pitch_palette)
+      bass.notes += random_counterpoint(rhythm, rhythm_palette,
+                                        params[:sample_rate], bass_pitch_palette)
+    end
+  end
+end
+
+score = Score::Unmeasured.new(120,
+  parts: { "bass" => bass, "guitar" => guitar },
+  program: [ 0...([bass.duration,guitar.duration].min) ]
+)
+
+instr_map = { "bass" => 32, "guitar" => 25 }
+seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq(instr_map)
+File.open("./auto_counterpoint.mid", 'wb'){ |fout| seq.write(fout) }

data/examples/composition/part_generator.rb

@@ -0,0 +1,51 @@
+require 'musicality'
+include Musicality
+include Pitches
+include PitchClasses
+include Meters
+include ScaleClasses
+
+minor = Heptatonic::Prima::MINOR
+major = Heptatonic::Prima::MAJOR
+
+pitch_seqs = {
+  D4 => minor, C4 => major, E4 => minor, F4 => minor
+}.map do |pitch,scale_class|
+  scale_class.to_pitch_seq(pitch)        
+end
+
+rhythm_seq2 = RepeatingSequence.new([3/8.to_r]*4)
+
+score = Score::Measured.new(SIX_EIGHT,90) do |s|
+  s.parts["main"] = Part.new(Dynamics::MF) do |p|
+    rhythm_seq = RepeatingSequence.new(([1/8.to_r]*3)*3 + [1/4.to_r,1/8.to_r])
+    selector = RepeatingSequence.new([4,2,0])
+    rhythm = rhythm_seq.take(pitch_seqs.size * rhythm_seq.pattern_size).to_a
+    poffsets = selector.take(rhythm_seq.pattern_size).to_a
+    pitches = pitch_seqs.map { |pseq| pseq.at(poffsets).to_a }.flatten
+    p.notes += make_notes(rhythm,pitches)
+  end
+  
+  s.parts["bass"] = Part.new(Dynamics::MP) do |p|
+    rhythm_seq = RepeatingSequence.new([3/8.to_r]*4)
+    selector = RepeatingSequence.new([-7])
+    rhythm = rhythm_seq.take(pitch_seqs.size * rhythm_seq.pattern_size).to_a
+    poffsets = selector.take(rhythm_seq.pattern_size).to_a
+    pitches = pitch_seqs.map { |pseq| pseq.at(poffsets).to_a }.flatten
+    p.notes += make_notes(rhythm,pitches)
+  end
+  
+  s.parts["pluck"] = Part.new(Dynamics::MP) do |p|
+    rhythm_seq = RepeatingSequence.new(([1/8.to_r]*3)*4)
+    selector = RepeatingSequence.new([0,2,4])
+    rhythm = rhythm_seq.take(pitch_seqs.size * rhythm_seq.pattern_size).to_a
+    poffsets = selector.take(rhythm_seq.pattern_size).to_a
+    pitches = pitch_seqs.map { |pseq| pseq.at(poffsets).to_a }.flatten
+    p.notes += make_notes(rhythm,pitches)
+  end
+  
+  s.program = [0...s.measures_long]*2
+end
+
+seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq("main" => 81, "bass" => 80, "pluck" => 46)
+File.open("./part_generator.mid", 'wb'){ |fout| seq.write(fout) }

data/examples/composition/scale_exercise.rb

@@ -0,0 +1,41 @@
+require 'musicality'
+include Musicality
+include Pitches
+include Meters
+include ScaleClasses
+
+def scale_exercise scale_class, base_pitch, rhythm
+  scale = scale_class.to_pitch_seq(base_pitch)
+  n = scale_class.count
+  m = rhythm.size
+  
+  rseq = RepeatingSequence.new((0...m).to_a)
+  aseq = AddingSequence.new([0]*(m-1) + [1])
+  cseq = CompoundSequence.new(:+,[aseq,rseq])
+  pgs = cseq.take(m*n).map {|i| scale.at(i) }
+  notes = make_notes(rhythm, pgs) +
+          make_notes([3/4.to_r,-1/4.to_r], [scale.at(n)])
+  
+  rseq = RepeatingSequence.new(n.downto(n+1-m).to_a)
+  aseq = AddingSequence.new([0]*(m-1) + [-1])
+  cseq = CompoundSequence.new(:+,[aseq,rseq])
+  pgs = cseq.take(m*n).map {|i| scale.at(i) }
+  notes += make_notes(rhythm, pgs) +
+          make_notes([3/4.to_r,-1/4.to_r], [scale.at(0)])
+  
+  return notes
+end
+
+score = Score::Measured.new(FOUR_FOUR,120) do |s|
+  s.parts["scale"] = Part.new(Dynamics::MP) do |p|
+    Heptatonic::Prima::MODES.each do |mode_n,scale_class|
+      [[1/4.to_r,1/4.to_r,1/2.to_r]].each  do |rhythm|
+        p.notes += scale_exercise(scale_class, C3, rhythm)
+      end
+    end
+  end
+  s.program.push 0...s.measures_long
+end
+
+seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq("scale" => 1)
+File.open("./scale_exercise.mid", 'wb'){ |fout| seq.write(fout) }

data/examples/{hip.rb → notation/hip.rb}

@@ -7,7 +7,7 @@ include Articulations
 include Meters
 
 score = Score::Measured.new(FOUR_FOUR,120) do |s|
-  s.program = Program.new([0...2, 0...2,2...4,0...2])
+  s.program += [0...2, 0...2, 2...4, 0...2]
   s.parts["lead"] = Part.new(Dynamics::MF) do |p|
     riff = "/6Bb3 /4 /12Db4= /6Db4= /36Db4 /36Eb4 /36Db4 /6Ab3 /12Db4 \
             /6Bb3 /4 /12Db4= /4Db4=                      /8=Db4 /8C4".to_notes

data/examples/{missed_connection.rb → notation/missed_connection.rb}

@@ -7,7 +7,7 @@ include Articulations
 include Meters
 
 score = Score::Measured.new(FOUR_FOUR, 120) do |s|
-  s.program = Program.new([0...2,0...6])
+  s.program += [0...2, 0...6]
   s.parts["bass"] = Part.new(Dynamics::MF) do |p|
     p.notes =  "/4Eb2 /4 /4Bb2 /4 /4Eb2 /8 /8B2 /4Bb2 /4Ab2".to_notes
     p.notes += "/4Bb2 /8 /8F3= /2F3 /4Bb2 /8 /8F3= /2F3".to_notes

data/examples/{song1.rb → notation/song1.rb}

@@ -7,7 +7,7 @@ include Articulations
 include Meters
 
 score = Score::Measured.new(FOUR_FOUR, 120) do |s|
-  s.program = Program.new([ 0...4.0, 0...4.0 ])
+  s.program += [0...4]*2
   
   s.parts[1] = Part.new(Dynamics::MF) do |p|
     p.notes = "3/8C2 /4Eb2 5/16F2 /16Eb2 \

data/examples/{song2.rb → notation/song2.rb}

@@ -6,7 +6,7 @@ include Pitches
 include Meters
 
 score = Score::Measured.new(FOUR_FOUR, 120) do |s|
-  s.program = Program.new([0...4.0, 0...4.0 ])
+  s.program += [0...4]*2
   
   s.parts[1] = Part.new(Dynamics::MF) do |p|
     p.notes = "1C4 1Bb3 1Ab3 /2G3 /2Bb3".to_notes

data/lib/musicality.rb

@@ -9,13 +9,14 @@ require 'musicality/errors'
 
 require 'musicality/notation/model/pitch'
 require 'musicality/notation/model/pitches'
-require 'musicality/notation/model/link'
+require 'musicality/notation/model/links'
 require 'musicality/notation/model/articulations'
+require 'musicality/notation/model/symbols'
+require 'musicality/notation/model/link'
 require 'musicality/notation/model/note'
 require 'musicality/notation/model/dynamics'
 require 'musicality/notation/model/change'
 require 'musicality/notation/model/part'
-require 'musicality/notation/model/program'
 require 'musicality/notation/model/meter'
 require 'musicality/notation/model/meters'
 require 'musicality/notation/model/score'
@@ -43,7 +44,6 @@ require 'musicality/notation/parsing/convenience_methods'
 
 require 'musicality/notation/packing/change_packing'
 require 'musicality/notation/packing/part_packing'
-require 'musicality/notation/packing/program_packing'
 require 'musicality/notation/packing/score_packing'
 
 require 'musicality/notation/util/interpolation'
@@ -59,6 +59,29 @@ require 'musicality/notation/conversion/measure_note_map'
 require 'musicality/notation/conversion/score_converter'
 require 'musicality/notation/conversion/score_conversion'
 
+#
+# Composition
+#
+
+require 'musicality/composition/util/biinfinite_sequence'
+require 'musicality/composition/util/repeating_sequence'
+require 'musicality/composition/util/adding_sequence'
+require 'musicality/composition/util/compound_sequence'
+require 'musicality/composition/util/random_sampler'
+require 'musicality/composition/util/probabilities'
+
+require 'musicality/composition/model/pitch_class'
+require 'musicality/composition/model/pitch_classes'
+require 'musicality/composition/model/scale'
+require 'musicality/composition/model/scale_class'
+require 'musicality/composition/model/scale_classes'
+
+require 'musicality/composition/note_generation'
+require 'musicality/composition/transposition'
+
+require 'musicality/composition/generation/counterpoint_generator'
+require 'musicality/composition/generation/random_rhythm_generator'
+
 #
 # Performance
 #
@@ -78,4 +101,11 @@ require 'midilib'
 require 'musicality/performance/midi/midi_util'
 require 'musicality/performance/midi/midi_events'
 require 'musicality/performance/midi/part_sequencer'
-require 'musicality/performance/midi/score_sequencer'
+require 'musicality/performance/midi/score_sequencer'
+require 'musicality/performance/midi/score_sequencing'
+
+require 'musicality/printing/lilypond/errors'
+require 'musicality/printing/lilypond/pitch_engraving'
+require 'musicality/printing/lilypond/note_engraving'
+require 'musicality/printing/lilypond/meter_engraving'
+require 'musicality/printing/lilypond/score_engraver'

data/lib/musicality/composition/generation/counterpoint_generator.rb

@@ -0,0 +1,153 @@
+module Musicality
+
+class CounterpointGenerator
+  attr_reader :rhythm, :palette, :total_dur, :solution_classes, :solutions
+  def initialize rhythm, palette, max_fact = 5
+    raise ArgumentError, "max_fact must be >= palette size" if max_fact < palette.size
+    
+    @rhythm = rhythm
+    @palette = palette
+    @total_dur = rhythm.map {|dur| dur.abs }.inject(0,:+)
+    @solution_classes = self.class.solution_classes(@total_dur, @palette)
+    @solution_classes.keep_if do |sc|
+      sc.map {|k,v| k*v}.inject(0,:+) == @total_dur
+    end
+    @solutions = figure_solutions(max_fact)
+  end
+  
+  def self.rhythm_to_computer rhythm
+    rhythm_accum = AddingSequence.new(rhythm).take(rhythm.size+1).to_a
+    x = rhythm_accum[0,rhythm.size]
+    y = rhythm_accum[1,rhythm.size].map {|y_| Change::Immediate.new(y_) }
+    value_changes = Hash[ [x,y].transpose ]
+    ValueComputer.new(0, value_changes)
+  end
+  
+  def evaluate solution, ideal_overlap, sample_rate
+    if solution.inject(0,:+) != @total_dur
+      raise ArgumentError, "Given solution #{solution} does not have same duration as rhythm"
+    end
+    
+    rhythm_comp = self.class.rhythm_to_computer(@rhythm)
+    solution_comp = self.class.rhythm_to_computer(solution)
+    
+    r = rhythm_comp.sample(0...@total_dur, sample_rate)
+    s = solution_comp.sample(0...@total_dur, sample_rate)
+    n_same = [r,s].transpose.count {|pair| pair[0] == pair[1] }
+    n_samples = (@total_dur*sample_rate).to_i
+    percent_overlap = (n_same/n_samples).to_f
+    return (ideal_overlap - percent_overlap).abs
+  end
+  
+  def best_solution ideal_overlap, sample_rate
+    @solutions.min_by {|sol| evaluate(sol,ideal_overlap,sample_rate) }
+  end
+  
+  def best_solutions n, ideal_overlap, sample_rate
+    @solutions.sort_by {|sol| evaluate(sol,ideal_overlap,sample_rate) }.take(n)
+  end
+  
+  private
+  
+  def figure_solutions max_factorial
+    solutions = []
+    @solution_classes.each do |sc|
+      tot = sc.values.inject(0,:+)
+      if tot <= max_factorial
+        proto = sc.map {|dur,n| [dur]*n }.flatten
+        solutions += proto.permutation(proto.size).to_a.uniq
+      else
+        durs, counts = sc.sort_by {|k,v| v }.transpose
+        self.class.limited_solution_classes(durs,counts,max_factorial).each do |ltd_sc|
+          ltd_proto = ltd_sc.map do |dur,ns|
+            ns.map {|n| [dur]*n }
+          end.flatten(1)
+          solutions += ltd_proto.permutation(max_factorial).map do |perm|
+            perm.flatten
+          end.to_a.uniq
+        end
+      end
+    end
+    
+    return solutions.uniq
+  end
+  
+  def self.limited_solution_classes durs, counts, max_fact
+    n_counts = counts.size
+    if n_counts > max_fact
+      raise ArgumentError, "counts.size (#{n_counts}) is > max_fact (#{max_fact})"
+    end
+    
+    total_count_rem = counts.inject(0,:+)
+    if total_count_rem < max_fact
+      raise ArgumentError, "total_count_rem (#{total_count_rem}) <= max_fact (#{max_fact})"
+    end
+    
+    ltd_solns = []
+    counts.size.times do |i|
+      count, dur = counts.first, durs.first
+      counts_rem = counts.drop(1)
+      
+      adj_count = [ count, max_fact - counts_rem.size ].min
+      
+      positive_integer_combinations_with_sum(count,adj_count).each do |comb|
+        if counts_rem.empty?
+          ltd_solns.push(dur => comb)
+        else
+          max_fact_rem = max_fact - adj_count
+          limited_solution_classes(durs.drop(1), counts_rem, max_fact_rem).each do |ltd_soln2|
+            ltd_solns.push(ltd_soln2.merge(dur => comb))
+          end
+        end
+      end
+      
+      counts.rotate!
+      durs.rotate!
+    end
+    return ltd_solns.uniq  
+  end
+  
+  def self.positive_integer_combinations_with_sum sum, n_pos_ints
+    raise ArgumentError, "sum must be <= number of positive integers" if n_pos_ints > sum
+    
+    if n_pos_ints == 1
+      return [[sum]]
+    elsif sum == n_pos_ints
+      return [[1]*n_pos_ints]
+    else
+      return (1...sum).to_a.combination(n_pos_ints-1).map do |comb|
+        prev_post = 0
+        diffs = comb.map do |post|
+          diff = post - prev_post
+          prev_post = post
+          diff
+        end
+        (diffs + [sum-prev_post]).sort
+      end.uniq
+    end
+  end
+  
+  def self.solution_classes total_dur, palette
+    dur = palette.first
+    n = (total_dur / dur).to_i
+    
+    if palette.size == 1
+      return [ n > 0 ? {dur => n} : {} ]
+    else
+      new_palette = palette.drop(1)
+      return Array.new(n+1) do |i|
+        subs = solution_classes(total_dur - i*dur, new_palette)
+        if i > 0
+          subs.each{|soln_class| soln_class[dur] = i }
+        end
+        subs
+      end.flatten
+    end
+  end
+end
+
+#rhythm = [1/4.to_r,1/4.to_r,1/8.to_r,1/8.to_r,1/8.to_r,1/8.to_r,1/4.to_r,1/2.to_r]
+#palette = [1/8.to_r,1/4.to_r,1/2.to_r]
+#cpg = CounterpointGenerator.new(rhythm,palette)
+
+end