jmtk 0.0.3.3-java

data/lib/mtk/patterns/sequence.rb

@@ -0,0 +1,20 @@
+module MTK
+  module Patterns
+
+    # A finite list of elements, which can be enumerated one at a time.
+    class Sequence < Pattern
+
+      ###################
+      protected
+
+      # (see Pattern#advance)
+      def advance
+        @index += 1
+        raise StopIteration if @index >= @elements.length
+        @current = @elements[@index]
+      end
+
+    end
+
+  end
+end

data/lib/mtk/sequencers/event_builder.rb

@@ -0,0 +1,132 @@
+module MTK
+  module Sequencers
+
+    # A special pattern that takes a list of event properties and/or patterns and emits lists of {Events::Event}s
+    class EventBuilder
+
+      DEFAULT_PITCH     = MTK.Pitch(60)
+      DEFAULT_DURATION  = MTK.Duration(1)
+      DEFAULT_INTENSITY = MTK.Intensity(0.75)
+
+      def initialize(patterns, options={})
+        @patterns = patterns
+        @options = options
+        @default_pitch     = if options.has_key? :default_pitch     then MTK.Pitch(    options[:default_pitch])     else DEFAULT_PITCH     end
+        @default_duration  = if options.has_key? :default_duration  then MTK.Duration( options[:default_duration])  else DEFAULT_DURATION  end
+        @default_intensity = if options.has_key? :default_intensity then MTK.Intensity(options[:default_intensity]) else DEFAULT_INTENSITY end
+        @channel = options[:channel]
+        @max_interval = options.fetch(:max_interval, 127)
+        rewind
+      end
+
+      # Build a list of events from the next element in each {Patterns::Pattern}
+      # @return [Array] an array of events
+      def next
+        pitches = []
+        intensities = []
+        duration = nil
+
+        @patterns.each do |pattern|
+          pattern_value = pattern.next
+
+          elements = pattern_value.is_a?(Enumerable) ? pattern_value : [pattern_value]
+          elements.each do |element|
+            return nil if element.nil? or element == :skip
+
+            case element
+              when ::MTK::Core::Pitch         then pitches << element
+              when ::MTK::Core::PitchClass    then pitches += pitches_for_pitch_classes([element], @previous_pitch)
+              when ::MTK::Groups::PitchClassSet then pitches += pitches_for_pitch_classes(element, @previous_pitch)
+              when ::MTK::Groups::PitchCollection then pitches += element.pitches # this must be after the PitchClassSet case, because that is also a PitchCollection
+
+              when ::MTK::Core::Duration
+                duration ||= 0
+                duration += element
+
+              when ::MTK::Core::Intensity
+                intensities << element
+
+              when ::MTK::Core::Interval
+                if @previous_pitches
+                  pitches += @previous_pitches.map{|pitch| pitch + element }
+                else
+                  pitches << (@previous_pitch + element)
+                end
+
+              # TODO? String/Symbols for special behaviors like :skip, or :break (something like StopIteration for the current Pattern?)
+
+              else STDERR.puts "#{self.class}#next: Unexpected type '#{element.class}'"
+            end
+
+          end
+        end
+
+        pitches     << @previous_pitch if pitches.empty?
+        duration   ||= @previous_duration
+
+        if intensities.empty?
+          intensity = @previous_intensity
+        else
+          intensity = MTK::Core::Intensity[intensities.map{|i| i.to_f }.inject(:+)/intensities.length] # average the intensities
+        end
+
+        # Not using this yet, maybe later...
+        # return nil if duration==:skip or intensities.include? :skip or pitches.include? :skip
+
+        constrain_pitch(pitches)
+
+        @previous_pitch = pitches.last   # Consider doing something different, maybe averaging?
+        @previous_pitches = pitches.length > 1 ? pitches : nil
+        @previous_intensity = intensity
+        @previous_duration = duration
+
+        pitches.map{|pitch| MTK::Events::Note.new(pitch,duration,intensity,@channel) }
+      end
+
+      # Reset the EventBuilder to its initial state
+      def rewind
+        @previous_pitch     = @default_pitch
+        @previous_pitches   = [@default_pitch]
+        @previous_intensity = @default_intensity
+        @previous_duration  = @default_duration
+        @max_pitch = nil
+        @min_pitch = nil
+        @patterns.each{|pattern| pattern.rewind if pattern.is_a? MTK::Patterns::Pattern }
+      end
+
+      ########################
+      private
+
+      def pitches_for_pitch_classes(pitch_classes, previous_pitch)
+        pitch_classes.map{|pitch_class| previous_pitch.nearest(pitch_class) }
+      end
+
+      def constrain_pitch(pitches)
+        if @max_pitch.nil? or @min_pitch.nil?
+          first_pitch = pitches.first
+
+          @max_pitch = first_pitch + @max_interval
+          @max_pitch = 127 if @max_pitch > 127
+
+          @min_pitch = first_pitch - @max_interval
+          @min_pitch = 0 if @min_pitch < 0
+
+          @small_max_span = (@max_pitch - @min_pitch < 12)
+        end
+
+        pitches.map! do |pitch|
+          if @small_max_span
+            pitch = @max_pitch if pitch > @max_pitch
+            pitch = @min_pitch if pitch < @max_pitch
+          else
+            pitch -= 12 while pitch > @max_pitch
+            pitch += 12 while pitch < @min_pitch
+          end
+          pitch
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/sequencers/legato_sequencer.rb

@@ -0,0 +1,24 @@
+module MTK
+  module Sequencers
+
+    # A Sequencer which uses the longest duration of the events at each step to determine
+    # the delta times between entries in the {Events::Timeline}.
+    class LegatoSequencer < Sequencer
+
+      # (see Sequencer#next)
+      def next
+        @previous_events = super
+      end
+
+     ########################
+      protected
+
+      # (see Sequencer#advance)
+      def advance
+        @time += @previous_events.map{|event| event.length }.max
+      end
+
+    end
+
+  end
+end

data/lib/mtk/sequencers/rhythmic_sequencer.rb

@@ -0,0 +1,28 @@
+module MTK
+  module Sequencers
+
+    # A Sequencer which uses a :rhythm type {Patterns::Pattern} to determine the delta times between entries in the {Events::Timeline}.
+    class RhythmicSequencer < Sequencer
+
+      def initialize(patterns, options={})
+        super
+        @rhythm = options[:rhythm] or raise ArgumentError.new(":rhythm option is required")
+      end
+
+      def rewind
+        super
+        @rhythm.rewind if @rhythm
+      end
+
+     ########################
+      protected
+
+      # (see Sequencer#advance)
+      def advance
+        @time += @rhythm.next.length
+      end
+
+    end
+
+  end
+end

data/lib/mtk/sequencers/sequencer.rb

@@ -0,0 +1,111 @@
+module MTK
+  module Sequencers
+
+    # A Sequencer produces {Events::Timeline}s from a collection of {Patterns::Pattern}s.
+    #
+    # @abstract Subclass and override {#advance} to implement a Sequencer.
+    #
+    class Sequencer
+
+      # The maximum number of [time,event_list] entries that will be generated for the {Events::Timeline}.
+      # nil means no maximum (be careful of infinite loops!)
+      attr_accessor :max_steps
+
+      # The maximum time (key) that will be generated for the {Events::Timeline}.
+      # nil means no maximum (be careful of infinite loops!)
+      attr_accessor :max_time
+
+      # Used by {#to_timeline} to builds event lists from the results of {Patterns::Pattern#next} for the {Patterns::Pattern}s in this Sequencer.
+      attr_reader :event_builder
+
+      # The current time offset for the sequencer. Used for the {Events::Timeline} times.
+      attr_reader :time
+
+      # The current sequencer step index (the number of times-1 that {#next} has been called), or -1 if the sequencer has not yet started.
+      attr_reader :step
+
+      attr_reader :patterns
+
+      # @param patterns [Array] the list of patterns to be sequenced into a {Events::Timeline}
+      # @param  options [Hash] the options to create a message with.
+      # @option options [String] :max_steps set {#max_steps}
+      # @option options [String] :max_time set {#max_time}
+      # @option options [Proc] :filter a Proc that will replace the events generated by {#next} with the results of the Proc[events]
+      # @option options [Class] :event_builder replace the {Sequencers::EventBuilder} with a custom Event pattern
+      def initialize(patterns, options={})
+        @patterns = patterns
+        @max_steps = options[:max_steps]
+        @max_time = options[:max_time]
+        @filter = options[:filter]
+
+        event_builder_class = options.fetch :event_builder, ::MTK::Sequencers::EventBuilder
+        @event_builder = event_builder_class.new(patterns, options)
+
+        rewind
+      end
+
+
+      # Produce a {Events::Timeline} from the {Patterns::Pattern}s in this Sequencer.
+      def to_timeline
+        rewind
+        timeline =  MTK::Events::Timeline.new
+        loop do
+          events = self.next
+          if events
+            events = events.reject{|e| e.rest? }
+            timeline[@time] = events unless events.empty?
+          end
+        end
+        timeline
+      end
+
+
+      # Advanced the step index and time, and return the next list of events built from the sequencer patterns.
+      # @note this is called automatically by {#to_timeline},
+      #    so you can ignore this method unless you want to hack on sequencers at a lower level.
+      def next
+        if @step >= 0
+          advance
+          raise StopIteration if @max_time and @time > @max_time
+        end
+        @step += 1
+        raise StopIteration if @max_steps and @step >= @max_steps
+        events = @event_builder.next
+        events = @filter[events] if @filter
+        events
+      end
+
+
+      # Reset the sequencer and all its patterns.
+      # @note this is called automatically at the beginning of {#to_timeline},
+      #    so you can ignore this method unless you want to hack on sequencers at a lower level.
+      def rewind
+        @time = 0
+        @step = -1
+        @event_builder.rewind
+      end
+
+
+      ########################
+      protected
+
+      # Advance @time to the next time for the {Events::Timeline} being produced by {#to_timeline}
+      def advance
+        @time += 1 # default behavior simply advances one beat at a time
+      end
+
+      def self.inherited(subclass)
+        # Define a convenience method like MTK::Patterns.Sequence()
+        # that can handle varargs or a single array argument, plus any Hash options
+        classname = subclass.name.sub /.*::/, '' # Strip off module prefixes
+        MTK::Sequencers.define_singleton_method classname do |*args|
+          options  = (args[-1].is_a? Hash) ? args.pop : {}
+          args = args[0] if args.length == 1 and args[0].is_a? Array
+          subclass.new(args,options)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/sequencers/step_sequencer.rb

@@ -0,0 +1,26 @@
+module MTK
+  module Sequencers
+
+    # A Sequencer which has a constant {#step_size} time between {Events::Timeline} entries.
+    class StepSequencer < Sequencer
+
+      # The time between entries in the {Events::Timeline}.
+      attr_accessor :step_size
+
+      def initialize(patterns, options={})
+        super
+        @step_size = options.fetch :step_size, 1
+      end
+
+     ########################
+      protected
+
+      # (see Sequencer#advance)
+      def advance
+        @time += @step_size
+      end
+
+    end
+
+  end
+end

data/spec/mtk/core/duration_spec.rb

@@ -0,0 +1,372 @@
+require 'spec_helper'
+
+describe MTK::Core::Duration do
+
+  let(:one_beat)  { Duration[1] }
+  let(:two_beats) { Duration[2] }
+
+
+  describe 'NAMES' do
+    it "is the list of base duration names available" do
+      Duration::NAMES.should =~ %w( w h q i s r x )
+    end
+
+    it "is immutable" do
+      lambda{ Duration::NAMES << 'z' }.should raise_error
+    end
+  end
+
+
+  describe 'VALUES_BY_NAME' do
+    it 'maps names to values' do
+      Duration::VALUES_BY_NAME.each do |name,value|
+        Duration.from_s(name).value.should == value
+      end
+    end
+
+    it 'is immutable' do
+      lambda{ Duration::VALUES_BY_NAME << 'z' }.should raise_error
+    end
+  end
+
+
+  describe '.new' do
+    it "constructs a Duration with whatever value is given" do
+      float = 0.5
+      value = Duration.new(float).value
+      value.should be_equal float
+    end
+  end
+
+
+  describe '.[]' do
+    it "constructs and caches a duration from a Numeric" do
+      Duration[1].should be_equal Duration[1]
+    end
+
+    it "retains the new() method's ability to construct uncached objects" do
+      Duration.new(1).should_not be_equal Duration[1]
+    end
+
+    it "uses the argument as the value, if the argument is a Fixnum" do
+      value = Duration[4].value
+      value.should be_equal 4
+    end
+
+    it "converts other Numerics to Rational values" do
+      value = Duration[0.5].value
+      value.should be_a Rational
+      value.should == Rational(1,2)
+    end
+  end
+
+
+  describe '.from_i' do
+    it "uses the argument as the value" do
+      value = Duration.from_i(4).value
+      value.should be_equal 4
+    end
+  end
+
+  describe '.from_f' do
+    it "converts Floats to Rational" do
+      value = Duration.from_f(0.5).value
+      value.should be_a Rational
+      value.should == Rational(1,2)
+    end
+  end
+
+  describe '.from_s' do
+    it "converts any of the duration NAMES into a Duration with the value from the VALUES_BY_NAME mapping" do
+      for name in Duration::NAMES
+        Duration.from_s(name).value.should == Duration::VALUES_BY_NAME[name]
+      end
+    end
+
+    it "converts any of the duration names prefixed with a '-' to the negative value" do
+      for name in Duration::NAMES
+        Duration.from_s("-#{name}").value.should == -1 * Duration::VALUES_BY_NAME[name]
+      end
+    end
+
+    it "converts any of the duration names suffixed a 't' to 2/3 of the value" do
+      for name in Duration::NAMES
+        Duration.from_s("#{name}t").value.should == Rational(2,3) * Duration::VALUES_BY_NAME[name]
+      end
+    end
+
+    it "converts any of the duration names suffixed a '.' to 3/2 of the value" do
+      for name in Duration::NAMES
+        Duration.from_s("#{name}.").value.should == Rational(3,2) * Duration::VALUES_BY_NAME[name]
+      end
+    end
+
+    it "converts suffix combinations of 't' and '.' (multiplying by 2/3 and 3/2 for each)" do
+      trip = Rational(2,3)
+      dot  = Rational(3,2)
+      for name in Duration::NAMES
+        for suffix,multiplier in {'tt' => trip*trip, 't.' => trip*dot, '..' => dot*dot, 't..t.' => trip*dot*dot*trip*dot}
+          Duration.from_s("#{name}#{suffix}").value.should == multiplier * Duration::VALUES_BY_NAME[name]
+        end
+      end
+    end
+
+    it "parses durations with integer multipliers" do
+      Durations::DURATION_NAMES.each_with_index do |duration, index|
+        multiplier = index+5
+        Duration.from_s("#{multiplier}#{duration}").should == multiplier * Duration(duration)
+      end
+    end
+
+    it "parses durations with float multipliers" do
+      Durations::DURATION_NAMES.each_with_index do |duration, index|
+        multiplier = (index+1)*1.123
+        Duration.from_s("#{multiplier}#{duration}").should == multiplier * Duration(duration)
+      end
+    end
+
+    it "parses durations with float multipliers" do
+      Durations::DURATION_NAMES.each_with_index do |duration, index|
+        multiplier = Rational(index+1, index+2)
+        Duration.from_s("#{multiplier}#{duration}").should == multiplier * Duration(duration)
+      end
+    end
+
+    it "parses combinations of all modifiers" do
+      Duration.from_s("-4/5qt.").value.should == -4.0/5 * 1 * 2/3.0 * 3/2.0
+      Duration.from_s("-11.234h.tt").value.should == 2 * 3/2.0 * 2/3.0 * 2/3.0 * -11.234
+    end
+  end
+
+  describe '.from_name' do
+    it "acts like .from_s" do
+      for name in Duration::NAMES
+        Duration.from_name(name).value.should == Duration::VALUES_BY_NAME[name]
+      end
+    end
+  end
+
+
+  describe '#value' do
+    it "is the value used to construct the Duration" do
+      Duration.new(1.111).value.should == 1.111
+    end
+  end
+
+
+  describe '#length' do
+    it 'is the value for positive values' do
+      Duration.new(4).length.should == 4
+    end
+
+    it 'is the absolute value for negative values' do
+      Duration.new(-4).length.should == 4
+    end
+  end
+
+
+  describe '#rest?' do
+    it 'is false for positive values' do
+      Duration.new(4).rest?.should be_false
+    end
+
+    it 'is true for negative values' do
+      Duration.new(-4).rest?.should be_true
+    end
+  end
+
+
+  describe '#to_f' do
+    it "is the value as a floating point number" do
+      f = Duration.new(Rational(1,2)).to_f
+      f.should be_a Float
+      f.should == 0.5
+    end
+  end
+
+  describe '#to_i' do
+    it "is the value rounded to the nearest integer" do
+      i = Duration.new(0.5).to_i
+      i.should be_a Fixnum
+      i.should == 1
+      Duration.new(0.49).to_i.should == 0
+    end
+  end
+
+  describe '#to_s' do
+    it "is value.to_s suffixed with 'beats' for beat values > 1" do
+      for value in [2, Rational(3,2), 3.25]
+        Duration.new(value).to_s.should == value.to_s + ' beats'
+      end
+    end
+
+    it "is value.to_s suffixed with 'beats' for positive, non-zero beat values < 1" do
+      for value in [Rational(1,2), 0.25]
+        Duration.new(value).to_s.should == value.to_s + ' beat'
+      end
+    end
+
+    it "is value.to_s suffixed with 'beats' for a value of 0" do
+      for value in [0, 0.0, Rational(0,2)]
+        Duration.new(value).to_s.should == value.to_s + ' beats'
+      end
+    end
+
+    it "is value.to_s suffixed with 'beats' for beat values < -1" do
+      for value in [-2, -Rational(3,2), -3.25]
+        Duration.new(value).to_s.should == value.to_s + ' beats'
+      end
+    end
+
+    it "is value.to_s suffixed with 'beat' for negative, non-zero beat values > -1" do
+      for value in [-Rational(1,2), -0.25]
+        Duration.new(value).to_s.should == value.to_s + ' beat'
+      end
+    end
+    
+    it "rounds to 2 decimal places when value.to_s is overly long" do
+      Duration.new(Math.sqrt 2).to_s.should == '1.41 beats'
+    end
+  end
+
+  describe '#inspect' do
+    it 'is "#<MTK::Core::Duration:{object_id} @value={value}>"' do
+      for value in [0, 60, 60.5, 127]
+        duration = Duration.new(value)
+        duration.inspect.should == "#<MTK::Core::Duration:#{duration.object_id} @value=#{value}>"
+      end
+    end
+  end
+
+  describe '#==' do
+    it "compares two duration values for equality" do
+      Duration.new(Rational(1,2)).should == Duration.new(0.5)
+      Duration.new(4).should == Duration.new(4)
+      Duration.new(1.1).should_not == Duration.new(1)
+    end
+  end
+
+  describe "#<=>" do
+    it "orders durations based on their underlying value" do
+      ( Duration.new(1) <=> Duration.new(1.1) ).should < 0
+      ( Duration.new(2) <=> Duration.new(1) ).should > 0
+      ( Duration.new(1.0) <=> Duration.new(1) ).should == 0
+    end
+  end
+
+
+
+  describe '#+' do
+    it 'adds #value to the Numeric argument' do
+      (one_beat + 1.5).should == Duration[2.5]
+    end
+
+    it 'works with a Duration argument' do
+      (one_beat + Duration[1.5]).should == Duration[2.5]
+    end
+
+    it 'returns a new duration (Duration is immutable)' do
+      original = one_beat
+      modified = one_beat + 2
+      original.should_not == modified
+      original.should == Duration[1]
+    end
+  end
+
+  describe '#-' do
+    it 'subtract the Numeric argument from #value' do
+      (one_beat - 0.5).should == Duration[0.5]
+    end
+
+    it 'works with a Duration argument' do
+      (one_beat - Duration[0.5]).should == Duration[0.5]
+    end
+
+    it 'returns a new duration (Duration is immutable)' do
+      original = one_beat
+      modified = one_beat - 0.5
+      original.should_not == modified
+      original.should == Duration[1]
+    end
+  end
+
+
+  describe '#*' do
+    it 'multiplies #value to the Numeric argument' do
+      (two_beats * 3).should == Duration[6]
+    end
+
+    it 'works with a Duration argument' do
+      (two_beats * Duration[3]).should == Duration[6]
+    end
+
+    it 'returns a new duration (Duration is immutable)' do
+      original = one_beat
+      modified = one_beat * 2
+      original.should_not == modified
+      original.should == Duration[1]
+    end
+  end
+
+  describe '#/' do
+    it 'divides #value by the Numeric argument' do
+      (two_beats / 4.0).should == Duration[0.5]
+    end
+
+    it 'works with a Duration argument' do
+      (two_beats / Duration[4]).should == Duration[0.5]
+    end
+
+    it 'returns a new duration (Duration is immutable)' do
+      original = one_beat
+      modified = one_beat / 2
+      original.should_not == modified
+      original.should == Duration[1]
+    end
+  end
+
+  describe '#coerce' do
+    it 'allows a Duration to be added to a Numeric' do
+      (2 + one_beat).should == Duration[3]
+    end
+
+    it 'allows a Duration to be subtracted from a Numeric' do
+      (7 - two_beats).should == Duration[5]
+    end
+
+    it 'allows a Duration to be multiplied to a Numeric' do
+      (3 * two_beats).should == Duration[6]
+    end
+
+    it 'allows a Numeric to be divided by a Duration' do
+      (8.0 / two_beats).should == Duration[4]
+    end
+  end
+
+end
+
+describe MTK do
+
+  describe '#Duration' do
+    it "acts like .from_s if the argument is a String" do
+      Duration('w').should == Duration.from_s('w')
+    end
+
+    it "acts like .from_s if the argument is a Symbol" do
+      Duration(:w).should == Duration.from_s('w')
+    end
+
+    it "acts like .[] if the argument is a Numeric" do
+      Duration(3.5).should be_equal Duration[Rational(7,2)]
+    end
+
+    it "returns the argument if it's already a Duration" do
+      Duration(Duration[1]).should be_equal Duration[1]
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Duration({:not => :compatible}) }.should raise_error
+    end
+  end
+
+end