musicality 0.3.0 → 0.5.0

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

@@ -0,0 +1,39 @@
+module Musicality
+
+class RandomRhythmGenerator
+  attr_reader :durations, :probabilities
+  
+  def initialize palette_with_probs
+    @durations, @probabilities = palette_with_probs.entries.transpose
+    @dur_sampler = RandomSampler.new(@durations,@probabilities)
+  end
+  
+  def random_dur
+    @dur_sampler.sample
+  end
+  
+  def random_rhythm target_dur, end_retries = 5
+    rhythm = []
+    total_dur = 0
+    retries = 0
+    
+    while(total_dur < target_dur && retries < end_retries)
+      dur = random_dur
+      
+      if (dur + total_dur) <= target_dur
+        total_dur += dur
+        rhythm.push(dur)
+      else
+        retries += 1
+      end
+    end
+    
+    if total_dur < target_dur
+      rhythm.push(target_dur - total_dur)
+    end
+    
+    return rhythm
+  end
+end
+
+end

data/lib/musicality/composition/model/pitch_class.rb

@@ -0,0 +1,33 @@
+module Musicality
+
+class PitchClass
+  MOD = Pitch::SEMITONES_PER_OCTAVE
+  
+  def self.from_i i
+    i % MOD
+  end
+  
+  def self.invert val
+    (MOD - val.to_pc).to_pc
+  end
+end
+  
+class Pitch
+  def to_pc
+    PitchClass.from_i semitone
+  end
+end
+
+end
+
+class Fixnum
+  def to_pc
+    PitchClass.from_i self
+  end
+end
+
+module Enumerable
+  def to_pcs
+    map {|value| value.to_pc }
+  end
+end

data/lib/musicality/composition/model/pitch_classes.rb

@@ -0,0 +1,22 @@
+module Musicality
+
+module PitchClasses  
+  C = 0
+  Db = 1
+  D = 2
+  Eb = 3
+  E = 4
+  F = 5
+  Gb = 6
+  G = 7
+  Ab = 8
+  A = 9
+  Bb = 10
+  B = 11
+end
+
+PITCH_CLASSES = PitchClasses.constants.map do |sym|
+  PitchClasses.const_get(sym)
+end.sort
+
+end

data/lib/musicality/composition/model/scale.rb

@@ -0,0 +1,34 @@
+module Musicality
+  
+class Scale
+  attr_reader :pitch_class
+  def initialize pitch_class, intervals
+    @pitch_class = pitch_class
+    @intervals = intervals
+  end
+  
+  def intervals; @intervals.entries; end
+
+  def size
+    @intervals.size
+  end
+  
+  def transpose diff
+    new_pc = (@pitch_class + diff).to_pc
+    Scale.new(new_pc,@intervals)
+  end
+  
+  def rotate n
+    diff = AddingSequence.new(@intervals).at(n)
+    new_pc = (@pitch_class + diff).to_pc
+    new_intervals = @intervals.rotate(n)
+    Scale.new(new_pc,new_intervals)
+  end
+  
+  def at_octave octave
+    start_pitch = Pitch.new(octave: octave, semitone: @pitch_class)
+    AddingSequence.new(@intervals, start_pitch)
+  end
+end
+
+end

data/lib/musicality/composition/model/scale_class.rb

@@ -0,0 +1,37 @@
+module Musicality
+
+class ScaleClass
+  include Enumerable
+  
+  def initialize intervals
+    if intervals.detect {|x| x <= 0 }
+      raise NonPositiveError, "One or more scale intervals (#{intervals}) is non-positive"
+    end
+    @intervals = intervals
+  end
+  
+  def intervals; self.entries; end
+  
+  def ==(other)
+    self.entries == other.entries
+  end
+  
+  def each
+    return @intervals.each unless block_given?
+    @intervals.each {|x| yield x }
+  end
+  
+  def to_pitch_seq start_pitch
+    AddingSequence.new(@intervals, start_pitch)
+  end
+  
+  def to_scale pitch_class
+    Scale.new(pitch_class, @intervals)
+  end
+  
+  def rotate n = 1
+    ScaleClass.new(@intervals.rotate(n))
+  end
+end
+
+end

data/lib/musicality/composition/model/scale_classes.rb

@@ -0,0 +1,91 @@
+module Musicality
+
+module ScaleClasses
+  CHROMATIC = ScaleClass.new([1,1,1,1,1,1,1,1,1,1,1,1])
+  
+  module Pentatonic
+    MINOR = ScaleClass.new([3,2,2,3,2])
+    MAJOR = MINOR.rotate(1)
+    EGYPTIAN = MINOR.rotate(2)
+    MINOR_BLUES = MINOR.rotate(3)
+    MAJOR_BLUES = MINOR.rotate(4)
+
+    MODES = {
+      1 => MINOR,
+      2 => MAJOR,
+      3 => EGYPTIAN,
+      4 => MINOR_BLUES,
+      5 => MAJOR_BLUES
+    }
+  end
+  
+  module Hexatonic
+    WHOLE_TONE = ScaleClass.new([2,2,2,2,2,2])
+    AUGMENTED = ScaleClass.new([3,1,3,1,3,1])
+    MYSTIC = PROMETHEAN = ScaleClass.new([2,2,2,3,1,2])
+    BLUES = ScaleClass.new([3,2,1,1,3,2])
+    TRITONE = PETRUSHKA = ScaleClass.new([1,3,2,1,3,2])
+  end
+
+  module Heptatonic
+    # This is where the standard Major scale and its modes are found, among others.
+    module Prima
+      IONIAN = MAJOR = ScaleClass.new([2,2,1,2,2,2,1])
+      DORIAN = IONIAN.rotate(1)
+      PHRYGIAN = IONIAN.rotate(2)
+      LYDIAN = IONIAN.rotate(3)
+      MIXOLYDIAN = IONIAN.rotate(4)
+      AEOLIAN = MINOR = IONIAN.rotate(5)
+      LOCRIAN = IONIAN.rotate(6)
+      
+      MODES = {
+        1 => IONIAN,
+        2 => DORIAN,
+        3 => PHRYGIAN,
+        4 => LYDIAN,
+        5 => MIXOLYDIAN,
+        6 => AEOLIAN,
+        7 => LOCRIAN
+      }
+    end
+
+    module Secunda
+      JAZZ_MINOR = MELODIC_MINOR = ScaleClass.new([2,1,2,2,2,2,1])
+      PHRYGIAN_RAISED_SIXTH = MELODIC_MINOR.rotate(1)
+      LYDIAN_RAISED_FIFTH = MELODIC_MINOR.rotate(2)
+      ACOUSTIC = LYDIAN_DOMINANT = MELODIC_MINOR.rotate(3)
+      MAJOR_MINOR = MELODIC_MINOR.rotate(4)
+      HALF_DIMINISHED = MELODIC_MINOR.rotate(5)
+      ALTERED = MELODIC_MINOR.rotate(6)
+
+      MODES = {
+        1 => MELODIC_MINOR,
+        2 => PHRYGIAN_RAISED_SIXTH,
+        3 => LYDIAN_RAISED_FIFTH,
+        4 => ACOUSTIC,
+        5 => MAJOR_MINOR,
+        6 => HALF_DIMINISHED,
+        7 => ALTERED
+      }
+    end
+
+    module Other
+      GYPSY = ScaleClass.new([1,3,1,2,1,3,1])
+      HUNGARIAN = ScaleClass.new([2,1,3,1,1,3,1])
+      PHRYGIAN_MAJOR = ScaleClass.new([1,3,1,2,1,2,2])
+      SCALA_ENIGMATICA = ScaleClass.new([1,3,2,2,2,1,1])
+    end
+  end
+
+  module Octatonic
+    WHOLE_HALF = ScaleClass.new([2,1,2,1,2,1,2,1])
+    HALF_WHOLE = WHOLE_HALF.rotate(1)
+
+    MODES = {
+      1 => WHOLE_HALF,
+      2 => HALF_WHOLE
+    }
+  end
+end
+
+end

data/lib/musicality/composition/note_generation.rb

@@ -0,0 +1,31 @@
+module Musicality
+
+def make_note dur, pitch_group
+  if dur > 0
+    Musicality::Note.new(dur,pitch_group)
+  else
+    Musicality::Note.new(-dur)
+  end
+end
+module_function :make_note
+
+# Whichever is longer, rhythm or pitch_groups, is iterated over once while
+# the smaller will cycle as necessary.
+def make_notes rhythm, pitch_groups
+  m,n = rhythm.size, pitch_groups.size
+  raise EmptyError, "rhythm is empty" if m == 0
+  raise EmptyError, "pitch_groups is empty" if n == 0
+  
+  if m > n
+    Array.new(m) do |i|
+      make_note(rhythm[i],pitch_groups[i % n])
+    end
+  else
+    Array.new(n) do |i|
+      make_note(rhythm[i % m],pitch_groups[i])
+    end
+  end
+end
+module_function :make_notes
+
+end

data/lib/musicality/composition/transposition.rb

@@ -0,0 +1,8 @@
+module Musicality
+
+def transpose notes, diff
+  notes.map {|n| n.transpose(diff) }
+end
+module_function :transpose
+
+end

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

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

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

@@ -0,0 +1,130 @@
+module Enumerable
+  def map_with_index
+    return enum_for(:map_with_index) unless block_given?
+    ary = entries
+    Array.new(ary.size) do |i|
+      yield ary[i], i
+    end
+  end
+end
+
+module Musicality
+
+module BiInfiniteSequence
+  def at offset
+    if offset.is_a? Enumerable
+      return enum_for(:at,offset) unless block_given?
+    else
+      return at_one(offset)
+    end
+    
+    offset_index_pairs = offset.map_with_index {|x,i| [x,i] }.sort
+    results = Array.new(offset.size)
+    
+    past = offset_index_pairs.select {|p| p[0] < 0 }
+    present = offset_index_pairs.select {|p| p[0] == 0 }
+    future = offset_index_pairs.select {|p| p[0] > 0 }
+    
+    start_val = start_value
+    
+    if past.any?
+      value = start_val
+      j = past.size - 1
+      tgt_offset = past[j][0]
+      0.downto(past.first[0]+1) do |i|
+        value = prev_value(value,i)
+        while (i-1) == tgt_offset
+          results[past[j][1]] = value
+          j -= 1
+          tgt_offset = j >= 0 ? past[j][0] : nil
+        end
+      end
+    end
+    
+    if present.any?
+      present.each do |off,index|
+        results[index] = start_val
+      end
+    end
+    
+    if future.any?
+      value = start_val
+      j = 0
+      tgt_offset = future[j][0]
+      0.upto(future.last[0]-1) do |i|
+        value = next_value(value,i)
+        while (i+1) == tgt_offset
+          results[future[j][1]] = value
+          j += 1
+          tgt_offset = j < future.size ? future[j][0] : nil
+        end
+      end
+    end
+    
+    results.each {|x| yield x }
+  end
+  
+  def take n
+    raise NegativeError if n < 0
+    return enum_for(:take,n) unless block_given?
+    return if n == 0
+    
+    value = start_value
+    0.upto(n - 1) do |i|
+      yield value
+      value = next_value(value,i)
+    end
+  end
+
+  def take_back n
+    raise NegativeError if n < 0
+    return enum_for(:take_back,n) unless block_given?
+    return if n == 0
+    
+    value = start_value
+    0.downto(1 - n) do |i|
+      yield value = prev_value(value,i)
+    end
+  end
+
+  def over range
+    min, max = range.minmax
+    raise EmptyError, "given range (#{range}) is empty" if min.nil?
+    return enum_for(:over,range) unless block_given?
+
+    if min >= 0 && max >= 0
+      value = at(min)
+      range.each do |i|
+        yield value
+        value = next_value(value,i)
+      end
+    elsif max < 0
+      value = at(max+1)
+      values = range.entries.reverse.map do |i|
+        value = prev_value(value,i+1)
+      end
+      values.reverse_each {|x| yield x }
+    else
+      take_back(-min).reverse_each {|x| yield x }
+      take(max + 1){ |x| yield x }
+    end
+  end
+  
+  private
+  
+  def at_one offset
+    value = start_value
+    if offset >= 0
+      0.upto(offset-1) do |i|
+        value = next_value(value,i)
+      end
+    else
+      0.downto(offset+1) do |i|
+        value = prev_value(value,i)
+      end
+    end
+    return value
+  end
+end
+
+end