musicality 0.1.0

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

@@ -0,0 +1,25 @@
+module Musicality
+
+class Tempo
+  class QNPM
+    def self.to_bpm qnpm, beat_dur
+      Rational(qnpm,4*beat_dur)
+    end
+    
+    def self.to_nps qnpm
+      Rational(qnpm,240)
+    end
+  end
+  
+  class BPM
+    def self.to_qnpm bpm, beat_dur
+      4*beat_dur*bpm
+    end
+    
+    def self.to_nps bpm, beat_dur
+      Rational(bpm*beat_dur,60)
+    end
+  end
+end
+  
+end

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

@@ -0,0 +1,47 @@
+module Musicality
+
+class Score
+  class Unmeasured < TempoBased
+    # Convert to unmeasured score by converting measure-based offsets to
+    # note-based offsets, and eliminating the use of meters. Also, tempo is
+    # coverted from beats-per-minute to quarter-notes per minute.
+    def to_timed tempo_sample_rate
+      UnmeasuredScoreConverter.new(self,tempo_sample_rate).convert_score
+    end
+    
+    def note_time_map tempo_sample_rate
+      tempo_computer = ValueComputer.new(@start_tempo, @tempo_changes)
+      ntc = NoteTimeConverter.new(tempo_computer, tempo_sample_rate)
+      ntc.note_time_map(note_offsets)
+    end
+        
+    def note_offsets
+      noffs = Set.new([0.to_r])
+      
+      @tempo_changes.each do |noff,change|
+        noffs += change.offsets(noff)
+      end
+      
+      @parts.values.each do |part|
+        noff = 0.to_r
+        part.notes.each do |note|
+          noff += note.duration
+          noffs.add(noff)
+        end
+        
+        part.dynamic_changes.each do |noff,change|
+          noffs += change.offsets(noff)
+        end
+      end
+      
+      @program.segments.each do |seg|
+        noffs.add(seg.first)
+        noffs.add(seg.last)
+      end
+      
+      return noffs.sort
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,64 @@
+require 'set'
+
+module Musicality
+
+# Converts unmeasured score to timed score, by converting note-based offsets
+# and durations to time-based, and eliminating the use of tempo.
+class UnmeasuredScoreConverter
+
+  def initialize score, tempo_sample_rate
+    unless score.valid?
+      raise NotValidError, "The given score can not be converted because \
+                            it is invalid, with these errors: #{score.errors}"
+    end
+    
+    @score = score
+    @note_time_map = score.note_time_map(tempo_sample_rate)
+  end
+  
+  def convert_score
+    Score::Timed.new(parts: convert_parts, program: convert_program)
+  end
+  
+  # Convert note-based offsets & durations to time-based.
+  def convert_parts
+    Hash[ @score.parts.map do |name,part|
+      offset = 0.to_r
+      
+      new_notes = part.notes.map do |note|
+        starttime = @note_time_map[offset]
+        endtime = @note_time_map[offset + note.duration]
+        offset += note.duration
+        newnote = note.clone
+        newnote.duration = endtime - starttime
+        newnote
+      end
+      
+      new_dcs = Hash[ part.dynamic_changes.map do |noff,change|
+        case change
+        when Change::Immediate
+          [@note_time_map[noff],change.clone]
+        when Change::Gradual
+          toff1, toff2, toff3, toff4 = change.offsets(noff).map {|x| @note_time_map[x] }
+          [toff2, Change::Gradual.new(change.value,
+            toff3-toff2, toff2-toff1, toff4-toff3)]
+        end
+      end ]
+      
+      [name, Part.new(part.start_dynamic,
+        notes: new_notes, dynamic_changes: new_dcs)]
+    end]
+  end
+  
+  # Convert note-based offsets & durations to time-based.
+  def convert_program
+    newsegments = @score.program.segments.map do |segment|
+      first = @note_time_map[segment.first]
+      last = @note_time_map[segment.last]
+      first...last
+    end
+    Program.new(newsegments)
+  end
+end
+
+end

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

@@ -0,0 +1,13 @@
+module Musicality
+
+module Articulations
+  NORMAL = :normal
+  SLUR = :slur
+  LEGATO = :legato
+  TENUTO = :tenuto
+  PORTATO = :portato
+  STACCATO = :staccato
+  STACCATISSIMO = :staccatissimo
+end
+
+end

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

@@ -0,0 +1,62 @@
+module Musicality
+
+class Change
+  attr_reader :value, :duration
+  
+  def initialize value, duration
+    @value = value
+    @duration = duration
+  end
+  
+  def ==(other)
+    self.class == other.class &&
+    self.value == other.value &&
+    self.duration == other.duration
+  end
+
+  class Immediate < Change
+    def initialize value
+      super(value,0)
+    end
+    
+    def clone
+      Immediate.new(@value)
+    end
+  end
+  
+  class Gradual < Change
+    attr_reader :elapsed, :impending, :remaining, :total_duration
+    
+    def initialize value, impending, elapsed=0, remaining=0
+      if elapsed < 0
+        raise NegativeError, "elapsed (#{elapsed}) is < 0"
+      end
+      
+      if impending <= 0
+        raise NonPositiveError, "impending (#{impending}) is <= 0"
+      end
+      
+      if remaining < 0
+        raise NegativeError, "remaining #{remaining} is < 0"
+      end
+      
+      @total_duration = elapsed + impending + remaining
+      @elapsed = elapsed
+      @impending = impending
+      @remaining = remaining
+      super(value,impending)
+    end
+    
+    def ==(other)
+      super(other) &&
+      @elapsed == other.elapsed &&
+      @remaining == other.remaining
+    end
+    
+    def clone
+      Gradual.new(@value, @impending, @elapsed, @remaining)
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,12 @@
+module Musicality
+module Dynamics
+  PPP = 0.125
+  PP = 0.25
+  P = 0.375
+  MP = 0.5
+  MF = 0.625
+  F = 0.75
+  FF = 0.875
+  FFF = 1.0
+end
+end

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

@@ -0,0 +1,73 @@
+module Musicality
+
+# Connect one note pitch to the target pitch of the next note, via slur, legato, etc.
+#
+# @!attribute [rw] target_pitch
+#   @return [Pitch] The pitch of the note which is being connected to.
+#
+class Link
+  def clone
+    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
+  end
+  
+  class TargetedLink < Link
+    attr_accessor :target_pitch
+    
+    def initialize target_pitch
+      @target_pitch = target_pitch
+    end
+    
+    def ==(other)
+      self.class == other.class && @target_pitch == other.target_pitch
+    end
+    
+    def transpose diff
+      self.clone.transpose! diff
+    end
+    
+    def transpose! diff
+      @target_pitch = @target_pitch.transpose(diff)
+      return self
+    end
+    
+    def to_s
+      link_char + @target_pitch.to_s
+    end
+  end
+  
+  class Glissando < TargetedLink
+    def link_char; "~"; end
+  end
+  
+  class Portamento < TargetedLink
+    def link_char; "/"; end
+  end
+  
+  class Slur < TargetedLink
+    def link_char; "="; end
+  end
+  
+  class Legato < TargetedLink
+    def link_char; "|"; end
+  end
+end
+
+end

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

@@ -0,0 +1,54 @@
+module Musicality
+
+class Meter
+  include Validatable
+
+  attr_reader :measure_duration, :beat_duration, :beats_per_measure
+  
+  def initialize beats_per_measure, beat_duration
+    @beats_per_measure = beats_per_measure
+    @beat_duration = beat_duration
+    @measure_duration = beats_per_measure * beat_duration    
+  end
+  
+  def check_methods
+    [ :check_beats_per_measure, :check_beat_duration ]
+  end
+  
+  def check_beats_per_measure
+    unless @beats_per_measure > 0
+      raise NonPositiveError, "beats per measure #{@beats_per_measure} is not positive"
+    end
+    
+    unless @beats_per_measure.is_a?(Integer)
+      raise NonIntegerError, "beats per measure #{@beats_per_measure} is not an integer"
+    end
+  end
+    
+  def check_beat_duration
+    unless @beat_duration > 0
+      raise NonPositiveError, "beat duration #{@beat_duration} is not positive"
+    end
+    
+    unless @beat_duration > 0
+      raise NonRationalError, "beat duration #{@beat_duration} is a rational"
+    end
+  end
+  
+  def ==(other)
+    return (@beats_per_measure == other.beats_per_measure &&
+      @beat_duration == other.beat_duration)
+  end
+  
+  def to_s
+    if beat_duration.numerator == 1
+      num = beats_per_measure * beat_duration.numerator
+      den = beat_duration.denominator
+      "#{num}/#{den}"
+    else
+      "#{beats_per_measure}*#{beat_duration}"
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,9 @@
+module Musicality
+module Meters
+  TWO_TWO = Meter.new(2,"1/2".to_r)
+  TWO_FOUR = Meter.new(2,"1/4".to_r)
+  THREE_FOUR = Meter.new(3,"1/4".to_r)
+  FOUR_FOUR = Meter.new(4,"1/4".to_r)
+  SIX_EIGHT = Meter.new(2,"3/8".to_r)
+end
+end

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

@@ -0,0 +1,120 @@
+module Musicality
+
+require 'set'
+
+class Note
+  include Validatable
+  
+  attr_reader :pitches, :links
+  attr_accessor :articulation, :duration, :accented
+
+  DEFAULT_ARTICULATION = Articulations::NORMAL
+  
+  def initialize duration, pitches = [], articulation: DEFAULT_ARTICULATION, accented: false, links: {}
+    @duration = duration
+    if !pitches.is_a? Enumerable
+      pitches = [ pitches ]
+    end
+    @pitches = Set.new(pitches).sort
+    @articulation = articulation
+    @accented = accented
+    @links = links
+  end
+  
+  def check_methods
+    [ :ensure_positive_duration ]
+  end
+  
+  def ensure_positive_duration
+    unless @duration > 0
+      raise NonPositiveError, "duration #{@duration} is not positive"
+    end
+  end
+  
+  def == other
+    return (@duration == other.duration) &&
+    (self.pitches == other.pitches) &&
+    (@links.to_a.sort == other.links.to_a.sort) &&
+    (@articulation == other.articulation) &&
+    (@accented == other.accented)
+  end
+  
+  def clone
+    Marshal.load(Marshal.dump(self))
+  end
+
+  def transpose diff
+    self.clone.transpose! diff
+  end
+  
+  def transpose! diff
+    @pitches = @pitches.map {|pitch| pitch.transpose(diff) }
+    @links = Hash[ @links.map do |k,v|
+      [ k.transpose(diff), v.transpose(diff) ]
+    end ]
+    return self
+  end
+  
+  def stretch ratio
+    self.clone.stretch! ratio
+  end
+  
+  def stretch! ratio
+    @duration *= ratio
+    return self
+  end
+  
+  def to_s
+    d = @duration.to_r
+    if d.denominator == 1
+      dur_str = "#{d.numerator}"
+    elsif d.numerator == 1
+      dur_str = "/#{d.denominator}"
+    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
+      else
+        p.to_s
+      end
+    end.join(",")
+    
+    acc_str = @accented ? "!" : ""
+    return dur_str + art_str + pitch_links_str + acc_str
+  end
+
+  def self.add_note_method(name, dur)
+    self.class.send(:define_method,name.to_sym) do |pitches = [], articulation: DEFAULT_ARTICULATION, links: {}, accented: false|
+      Note.new(dur, pitches, articulation: articulation, links: links, accented: accented)
+    end
+  end
+  
+  {
+    :sixteenth => Rational(1,16),
+    :dotted_SIXTEENTH => Rational(3,32),
+    :eighth => Rational(1,8),
+    :dotted_eighth => Rational(3,16),
+    :quarter => Rational(1,4),
+    :dotted_quarter => Rational(3,8),
+    :half => Rational(1,2),
+    :dotted_half => Rational(3,4),
+    :whole => Rational(1),
+  }.each do |meth_name, dur|
+    add_note_method meth_name, dur
+  end
+end
+
+end

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

@@ -0,0 +1,54 @@
+require 'yaml'
+
+module Musicality
+
+class Part
+  include Validatable
+  
+  attr_accessor :start_dynamic, :dynamic_changes, :notes
+  
+  def initialize start_dynamic, notes: [], dynamic_changes: {}
+    @notes = notes
+    @start_dynamic = start_dynamic
+    @dynamic_changes = dynamic_changes
+    
+    yield(self) if block_given?
+  end
+  
+  def check_methods
+    [:ensure_start_dynamic, :ensure_dynamic_change_values_range ]
+  end
+  
+  def validatables
+    @notes
+  end
+  
+  def clone
+    Marshal.load(Marshal.dump(self))
+  end
+  
+  def ==(other)
+    return (@notes == other.notes) &&
+    (@start_dynamic == other.start_dynamic) &&
+    (@dynamic_changes == other.dynamic_changes)
+  end
+
+  def duration
+    return @notes.inject(0) { |sum, note| sum + note.duration }
+  end
+  
+  def ensure_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
+    outofrange = @dynamic_changes.values.select {|v| !v.value.between?(0,1) }
+    if outofrange.any?
+      raise RangeError, "dynamic change values #{outofrange} are not between 0 and 1"
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,163 @@
+module Musicality
+
+# Abstraction of a musical pitch. Contains values for octave and semitone.
+#
+# Octaves represent the largest means of differing two pitches. Each
+# octave added will double the ratio. At zero octaves, the ratio is
+# 1.0. At one octave, the ratio will be 2.0. Each semitone is an increment
+# of less-than-power-of-two.
+#
+# Semitones are the primary steps between octaves. The number of
+# semitones per octave is 12.
+
+# @author James Tunnell
+#
+# @!attribute [r] octave
+#   @return [Fixnum] The pitch octave.
+# @!attribute [r] semitone
+#   @return [Fixnum] The pitch semitone.
+#
+class Pitch
+  include Comparable
+  attr_reader :octave, :semitone, :cent, :total_cents
+
+  #The default number of semitones per octave is 12, corresponding to
+  # the twelve-tone equal temperment tuning system.
+  SEMITONES_PER_OCTAVE = 12
+  CENTS_PER_SEMITONE = 100
+  CENTS_PER_OCTAVE = SEMITONES_PER_OCTAVE * CENTS_PER_SEMITONE
+
+  # The base ferquency is C0
+  BASE_FREQ = 16.351597831287414
+
+  def initialize octave:0, semitone:0, cent: 0
+    raise NonIntegerError, "octave #{octave} is not an integer" unless octave.is_a?(Integer)
+    raise NonIntegerError, "semitone #{semitone} is not an integer" unless semitone.is_a?(Integer)
+    raise NonIntegerError, "cent #{cent} is not an integer" unless cent.is_a?(Integer)
+    
+    @octave = octave
+    @semitone = semitone
+    @cent = cent
+    @total_cents = (@octave*SEMITONES_PER_OCTAVE + @semitone)*CENTS_PER_SEMITONE + @cent
+    balance!
+  end
+
+  # Return the pitch's frequency, which is determined by multiplying the base
+  # frequency and the pitch ratio. Base frequency defaults to DEFAULT_BASE_FREQ,
+  # but can be set during initialization to something else by specifying the
+  # :base_freq key.
+  def freq
+    return self.ratio() * BASE_FREQ
+  end
+
+  # Calculate the pitch ratio. Raises 2 to the power of the total cent
+  # count divided by cents-per-octave.
+  # @return [Float] ratio
+  def ratio
+    2.0**(@total_cents.to_f / CENTS_PER_OCTAVE)
+  end
+
+  # Override default hash method.
+  def hash
+    return @total_cents
+  end
+
+  # Compare pitch equality using total semitone
+  def ==(other)
+    return (self.class == other.class &&
+      @total_cents == other.total_cents)
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  # Compare pitches. A higher ratio or total semitone is considered larger.
+  # @param [Pitch] other The pitch object to compare.
+  def <=> (other)
+    @total_cents <=> other.total_cents
+  end
+
+  # rounds to the nearest semitone
+  def round
+    if @cent == 0
+      self.clone
+    else
+      Pitch.new(semitone: (@total_cents / CENTS_PER_SEMITONE.to_f).round)
+    end
+  end
+
+  # diff in (rounded) semitones
+  def diff other
+    Rational(@total_cents - other.total_cents, CENTS_PER_SEMITONE)
+  end
+
+  def transpose semitones
+    Pitch.new(cent: (@total_cents + semitones * CENTS_PER_SEMITONE).round)
+  end
+  
+  def total_semitones
+    Rational(@total_cents, CENTS_PER_SEMITONE)
+  end
+  
+  def self.from_semitones semitones
+    Pitch.new(cent: (semitones * CENTS_PER_SEMITONE).round)
+  end
+  
+  def clone
+    Pitch.new(cent: @total_cents)
+  end
+
+  def to_s(sharpit = false)
+    letter = case semitone
+    when 0 then "C"
+    when 1 then sharpit  ? "C#" : "Db"
+    when 2 then "D"
+    when 3 then sharpit  ? "D#" : "Eb"
+    when 4 then "E"
+    when 5 then "F"
+    when 6 then sharpit  ? "F#" : "Gb"
+    when 7 then "G"
+    when 8 then sharpit  ? "G#" : "Ab"
+    when 9 then "A"
+    when 10 then sharpit  ? "A#" : "Bb"
+    when 11 then "B"
+    end
+    
+    if @cent == 0
+      return letter + octave.to_s
+    elsif @cent > 0
+      return letter + octave.to_s + "+" + @cent.to_s
+    else
+      return letter + octave.to_s + @cent.to_s
+    end
+  end
+
+  def self.from_ratio ratio
+    raise NonPositiveError, "ratio #{ratio} is not > 0" unless ratio > 0
+    x = Math.log2 ratio
+    new(cent: (x * CENTS_PER_OCTAVE).round)
+  end
+
+  def self.from_freq freq
+    from_ratio(freq / BASE_FREQ)
+  end
+
+  private
+
+  # Balance out the octave and semitone count.
+  def balance!
+    centsTotal = @total_cents
+    
+    @octave = centsTotal / CENTS_PER_OCTAVE
+    centsTotal -= @octave * CENTS_PER_OCTAVE
+    
+    @semitone = centsTotal / CENTS_PER_SEMITONE
+    centsTotal -= @semitone * CENTS_PER_SEMITONE
+    
+    @cent = centsTotal
+    return self
+  end
+end
+
+end