mtk 0.0.1

data/lib/mtk/pattern/note_sequence.rb

@@ -0,0 +1,60 @@
+module MTK
+  module Pattern
+
+    # A {Sequence} of {Note}s
+    class NoteSequence
+
+      attr_reader :pitch_sequence, :intensity_sequence, :duration_sequence
+
+      attr_accessor :pitch, :intensity, :duration
+
+      def initialize(pitches, intensities=nil, durations=nil, defaults={})
+        @pitch_sequence     = PitchSequence.new(pitches)
+        @intensity_sequence = Sequence.new(intensities)
+        @duration_sequence  = Sequence.new(durations)
+        @default = {:pitch => Pitches::C4, :intensity => Dynamics::mf, :duration => 1}.merge defaults
+        reset
+      end
+
+      def pitches
+        @pitch_sequence.elements
+      end
+
+      def intensities
+        @intensity_sequence.elements
+      end
+
+      def durations
+        @duration_sequence.elements
+      end
+
+      # reset the Sequence to the beginning
+      def reset
+        @pitch_sequence.reset
+        @intensity_sequence.reset
+        @duration_sequence.reset
+
+        @pitch = @default[:pitch]
+        @intensity = @default[:intensity]
+        @duration = @default[:duration]
+      end
+
+      # return next {Note} in sequence
+      def next
+        @pitch = @pitch_sequence.next || @pitch
+        @intensity = @intensity_sequence.next || @intensity
+        @duration = @duration_sequence.next || @duration
+
+
+        case @pitch
+          when PitchSet,Array then Chord.new(@pitch, @intensity, @duration)
+          else Note.new(@pitch, @intensity, @duration)
+        end
+      end
+
+    end
+
+  end
+end
+
+

data/lib/mtk/pattern/pitch_sequence.rb

@@ -0,0 +1,22 @@
+module MTK
+  module Pattern
+
+    # A {Sequence} of pitch-related elements, which may be {Pitch}es, {PitchClass}es, {PitchSet}s, or {Intervals} (Numeric)
+    class PitchSequence < Sequence
+
+      protected
+
+      # extend value_of to handle intervals and PitchClasses
+      def value_of element
+        element = super # eval Procs
+        case element
+          when Numeric then @value + element if @value # add interval
+          when PitchClass then @value.nearest(element) if @value
+          else element
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/pattern/sequence.rb

@@ -0,0 +1,65 @@
+module MTK
+  module Pattern
+
+    # An endless enumerator that outputs an element one at a time from a list of elements,
+    # looping back to the beginning when elements run out.
+    class Sequence
+
+      # The list of elements enumerated by this Sequence
+      attr_reader :elements
+
+      # @param elements [Array] the list of {#elements}
+      # @param default [Object] the default value returned by {#next} in place of nil
+      def initialize(elements)
+        if elements.respond_to? :elements
+          @elements = elements.elements
+        else
+          @elements = elements.to_a
+        end
+        reset
+      end
+
+      # reset the Sequence to its initial state
+      def reset
+        @index = -1
+        @element = nil
+        @value = nil
+      end
+
+      # The value of the next element in the Sequence.
+      # The sequence goes back to the first element if there are no more elements.
+      #
+      # @return if an element is a Proc, it is called (depending on the arity of the Proc: with either no arguments,
+      #   the last value of #next, or the last value and last element) and its return value is returned.
+      # @return if an element is nil, previous value of #next is returned. If there is no previous value the @default is returned.
+      # @return otherwise the element itself is returned
+      #
+      def next
+        if @elements and not @elements.empty?
+          @index = (@index + 1) % @elements.length
+          element = @elements[@index]
+          value = value_of(element)
+          @element, @value = element, value
+        end
+        @value
+      end
+
+      ####################
+      protected
+
+      def value_of element
+        case element
+          when Proc
+            case element.arity
+              when 0 then element.call
+              when 1 then element.call(@value)
+              else element.call(@value, @element)
+            end
+          else element
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns.rb

@@ -0,0 +1,4 @@
+require 'mtk/pattern/sequence'
+require 'mtk/pattern/pitch_sequence'
+require 'mtk/pattern/note_sequence'
+require 'mtk/pattern/choice'

data/lib/mtk/pitch.rb

@@ -0,0 +1,112 @@
+module MTK
+
+  # A frequency represented by a {PitchClass}, an integer octave, and an offset in semitones.
+  
+  class Pitch
+
+    include Comparable
+
+    attr_reader :pitch_class, :octave, :offset
+
+    def initialize( pitch_class, octave, offset=0 )
+      @pitch_class, @octave, @offset = pitch_class, octave, offset
+      @value = @pitch_class.to_i + 12*(@octave+1) + @offset
+    end
+
+    @flyweight = {}
+
+    def self.[](pitch_class, octave)
+      @flyweight[[pitch_class,octave]] ||= new(pitch_class, octave)
+    end
+    
+    def self.from_s( s )
+      # TODO: update to handle offset
+      s = s[0..0].upcase + s[1..-1].downcase # normalize name
+      if s =~ /^([A-G](#|##|b|bb)?)(-?\d+)$/
+        pitch_class = PitchClass.from_s($1)
+        if pitch_class
+          octave = $3.to_i
+          new( pitch_class, octave )
+        end
+      end
+    end
+    
+    # Convert a Numeric semitones value into a Pitch
+    def self.from_f( f )
+      i, offset = f.floor, f%1  # split into int and fractional part
+      pitch_class = PitchClass.from_i(i)
+      octave = i/12 - 1
+      new( pitch_class, octave, offset )      
+    end
+
+    def self.from_hash(hash)
+      new hash[:pitch_class], hash[:octave], hash.fetch(:offset,0)
+    end
+    
+    # Convert a Numeric semitones value into a Pitch    
+    def self.from_i( i )
+      from_f( i )
+    end
+
+    # The numerical value of this pitch
+    def to_f
+      @value
+    end 
+
+    # The numerical value for the nearest semitone
+    def to_i
+      @value.round
+    end
+    
+    def offset_in_cents
+      @offset * 100
+    end
+
+    def to_hash
+      {:pitch_class => @pitch_class, :octave => @octave, :offset => @offset}
+    end
+
+    def to_s
+      "#{@pitch_class}#{@octave}" + (@offset.zero? ? '' : "+#{offset_in_cents.round}cents")
+    end
+
+    def inspect
+      "#{@pitch_class}#{@octave}" + (@offset.zero? ? '' : "+#{offset_in_cents}cents")
+    end
+
+    def ==( other )
+      other.respond_to? :pitch_class and other.respond_to? :octave and other.respond_to? :offset and
+      other.pitch_class == @pitch_class and other.octave == @octave and other.offset == @offset
+    end
+
+    def <=> other
+      @value <=> other.to_f
+    end
+
+    def + interval_in_semitones
+     self.class.from_f( @value + interval_in_semitones.to_f )
+    end
+
+    def - interval_in_semitones
+      self.class.from_f( @value - interval_in_semitones.to_f )
+    end
+
+    def invert(center_pitch)
+      self + 2*(center_pitch.to_f - to_f)
+    end
+
+    def nearest(pitch_class)
+      self + self.pitch_class.distance_to(pitch_class)
+    end
+
+    def coerce(other)
+      return self.class.from_f(other.to_f), self
+    end
+
+    def clone_with(hash)
+      self.class.from_hash(to_hash.merge hash)
+    end
+
+  end
+
+end

data/lib/mtk/pitch_class.rb

@@ -0,0 +1,113 @@
+module MTK
+
+  # A class of pitches under octave equivalence.
+  #
+  # A {Pitch} has the same PitchClass as the {Pitches} one or more octaves away.
+
+  class PitchClass
+
+    NAMES = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']
+
+    VALID_NAMES = [
+        ['B#', 'C', 'Dbb'],
+        ['B##', 'C#', 'Db'],
+        ['C##', 'D', 'Ebb'],
+        ['D#', 'Eb', 'Fbb'],
+        ['D##', 'E', 'Fb'],
+        ['E#', 'F', 'Gbb'],
+        ['E##', 'F#', 'Gb'],
+        ['F##', 'G', 'Abb'],
+        ['G#', 'Ab'],
+        ['G##', 'A', 'Bbb'],
+        ['A#', 'Bb', 'Cbb'],
+        ['A##', 'B', 'Cb']
+    ]
+
+    attr_reader :name
+
+    ##########################################        
+    private
+
+    def initialize(name, int_value)
+      @name, @int_value = name, int_value
+    end
+
+    private_class_method :new
+
+    @flyweight = {}
+
+    def self.get(name, int_value)
+      @flyweight[name] ||= new(name, int_value)
+    end
+
+    private_class_method :get
+
+    ##########################################    
+    public
+
+    def self.from_s(s)
+      s = s.to_s
+      s = s[0..0].upcase + s[1..-1].downcase # normalize the name      
+      VALID_NAMES.each_with_index do |names, index|
+        return get(s, index) if names.include? s
+      end
+      nil
+    end
+
+    class << self
+      alias from_name from_s # alias self.from_name to self.from_s
+    end
+
+    def self.from_i(value)
+      value = value.to_i % 12
+      name = NAMES[value]
+      get(name, value)
+    end
+
+    def self.[](name_or_value)
+      if name_or_value.kind_of? Numeric
+        from_i(name_or_value)
+      else
+        from_s(name_or_value)
+      end
+    end
+
+    def == other
+      other.is_a? PitchClass and other.to_i == @int_value
+    end
+
+    def <=> other
+      @int_value <=> other.to_i
+    end
+
+    def to_s
+      @name
+    end
+
+    def to_i
+      @int_value
+    end
+
+    def +(interval)
+      self.class.from_i(to_i + interval.to_i)
+    end
+
+    def -(interval)
+      self.class.from_i(to_i - interval.to_i)
+    end
+
+    # the smallest interval in semitones that needs to be added to this PitchClass to reach the given PitchClass
+    def distance_to(pitch_class)
+      delta = (pitch_class.to_i - to_i) % 12
+      if delta > 6
+        delta -= 12
+      elsif delta == 6 and to_i >= 6
+        # this is a special edge case to prevent endlessly ascending pitch sequences when alternating between two pitch classes a tritone apart
+        delta = -6
+      end
+      delta
+    end
+
+  end
+
+end

data/lib/mtk/pitch_class_set.rb

@@ -0,0 +1,106 @@
+module MTK
+
+  # A Set of PitchClasses, for 12-tone set-theory pitch analysis and manipulations
+  #
+  class PitchClassSet
+
+    include Mappable
+
+    attr_reader :pitch_classes
+    
+    def initialize(pitch_classes)
+      @pitch_classes = pitch_classes.to_a.uniq.sort.freeze
+    end
+
+    def self.from_a enumerable
+      new enumerable
+    end
+
+    def to_a
+      Array.new(@pitch_classes)
+    end
+
+    def each &block
+      @pitch_classes.each &block
+    end
+
+    def size
+      @pitch_classes.size
+    end
+
+    def normal_order
+      ordering = Array.new(@pitch_classes)
+      min_span, start_index_for_normal_order = nil, nil
+
+      # check every rotation for the minimal span:
+      size.times do |index|
+        span = self.class.span_for ordering
+
+        if min_span.nil? or span < min_span
+          # best so far
+          min_span = span
+          start_index_for_normal_order = index
+
+        elsif span == min_span
+          # handle ties, minimize distance between first and second-to-last note, then first and third-to-last, etc
+          span1, span2 = nil, nil
+          tie_breaker = 1
+          while span1 == span2 and tie_breaker < size
+            span1 = self.class.span_between( ordering[0], ordering[-1 - tie_breaker] )
+            span2 = self.class.span_between( ordering[start_index_for_normal_order], ordering[start_index_for_normal_order - tie_breaker] )
+            tie_breaker -= 1
+          end
+          if span1 != span2
+            # tie cannot be broken, pick the one starting with the lowest pitch class
+            if ordering[0].to_i < ordering[start_index_for_normal_order].to_i
+              start_index_for_normal_order = index
+            end
+          elsif span1 < span2
+            start_index_for_normal_order = index
+          end
+
+        end
+        ordering << ordering.shift  # rotate
+      end
+
+      # we've rotated all the way around, so we now need to rotate back to the start index we just found:
+      start_index_for_normal_order.times{ ordering << ordering.shift }
+
+      ordering
+    end
+
+    def normal_form
+      norder = normal_order
+      first_pc_val = norder.first.to_i
+      norder.map{|pitch_class| (pitch_class.to_i - first_pc_val) % 12 }
+    end
+
+    # @param other [#pitch_classes, #to_a, Array]
+    def == other
+      if other.respond_to? :pitch_classes
+        @pitch_classes == other.pitch_classes
+      elsif other.respond_to? :to_a
+        @pitch_classes == other.to_a
+      else
+        @pitch_classes == other
+      end
+    end
+
+    def to_s
+      @pitch_classes.join(' ')
+    end
+
+    def inspect
+      @pitch_classes.inspect
+    end
+
+    def self.span_for(pitch_classes)
+      span_between pitch_classes.first, pitch_classes.last
+    end
+
+    def self.span_between(pc1, pc2)
+      (pc2.to_i - pc1.to_i) % 12
+    end
+
+  end
+end

data/lib/mtk/pitch_set.rb

@@ -0,0 +1,95 @@
+module MTK
+
+  # A set of {Pitch}es
+  #
+  class PitchSet
+
+    include Mappable
+
+    attr_reader :pitches
+
+    def initialize(pitches)
+      @pitches = pitches.to_a.uniq.sort.freeze
+    end
+
+    def self.from_a enumerable
+      new enumerable
+    end
+
+    def to_a
+      Array.new(@pitches)
+    end
+
+    def each &block
+      @pitches.each &block
+    end
+
+    def to_pitch_class_set
+      PitchClassSet.new @pitches.map{|p| p.pitch_class }
+    end
+
+    def pitch_classes
+      @pitch_classes ||= @pitches.map{|p| p.pitch_class }.uniq
+    end
+
+    def + semitones
+      each_pitch_apply :+, semitones
+    end
+
+    def - semitones
+      each_pitch_apply :-, semitones
+    end
+
+    def invert(center_pitch=@pitches.first)
+      each_pitch_apply :invert, center_pitch
+    end
+
+    def inversion(number)
+      number = number.to_i
+      pitch_set = Array.new(@pitches)
+      if number > 0
+        number.times do |count|
+          index = count % pitch_set.length
+          pitch_set[index] += 12
+        end
+      else
+        number.abs.times do |count|
+          index = -(count + 1) % pitch_set.length # count from -1 downward to go backwards through the list starting at the end
+          pitch_set[index] -= 12
+        end
+      end
+      self.class.new pitch_set
+    end
+
+    def include? pitch
+      @pitches.include? pitch
+    end
+
+    def nearest(pitch_class)
+      self + @pitches.first.pitch_class.distance_to(pitch_class)
+    end
+
+    # @param other [#pitches, #to_a, Array]
+    def == other
+      if other.respond_to? :pitches
+        @pitches == other.pitches
+      elsif other.respond_to? :to_a
+        @pitches == other.to_a
+      else
+        @pitches == other
+      end
+    end
+
+    def to_s
+      @pitches.inspect
+    end
+
+    #######################################
+    protected
+
+    def each_pitch_apply(method_name, *args, &block)
+      self.class.new @pitches.map{|pitch| pitch.send(method_name, *args, &block) }
+    end
+
+  end
+end