jmtk 0.0.3.3-java

data/lib/mtk/patterns/chain.rb

@@ -0,0 +1,49 @@
+module MTK
+  module Patterns
+
+    # A pattern that takes a list of patterns and combines their values into a list of event properties.
+    class Chain < Pattern
+
+      def initialize(elements, options={})
+        super
+        @stop_after_first = true # assume everything's an element until we inspect them in the loop below
+        @stop_after_first = true if @elements.all?{|element| not element.is_a? ::MTK::Patterns::Pattern }
+      end
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @is_element_done = Array.new(elements.size)
+        super
+      end
+
+      # (see Pattern#advance)
+      def advance
+        @current = @elements.map.with_index do |element,index|
+          if element.is_a? ::MTK::Patterns::Pattern
+            begin
+              element.next
+            rescue StopIteration
+              raise StopIteration if element.max_elements_exceeded?
+              @is_element_done[index] = true
+              element.rewind
+              element.next
+            end
+          else
+            element
+          end
+        end.flatten
+
+        raise StopIteration if @is_element_done.all?{|done| done }
+
+        @elements.each.with_index do |element,index|
+          @is_element_done[index] = true unless element.is_a? ::MTK::Patterns::Pattern
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/choice.rb

@@ -0,0 +1,43 @@
+module MTK
+  module Patterns
+
+    # Randomly choose from a list of elements.
+    #
+    # Supports giving different weights to different choices.
+    # Default is to weight all choices equally.
+    #
+    class Choice < Pattern
+
+      # @param (see Pattern#initialize)
+      # @option (see Pattern#initialize)
+      # @option options [Array] :weights a list of chances that each corresponding element will be selected (normalized against the total weight)
+      # @example choose the second element twice as often as the first or third:
+      #     MTK::Pattern::Choice.new [:first,:second,:third], :weights => [1,2,1]
+      def initialize(elements, options={})
+        super
+        @weights = options.fetch :weights, Array.new(@elements.length, 1)
+        @total_weight = @weights.inject(:+).to_f
+      end
+
+      #####################
+      protected
+
+      def advance
+        @index += 1
+        raise StopIteration if @index > 0
+
+        target = rand * @total_weight
+        @weights.each_with_index do |weight,index|
+          if target < weight
+            @current = @elements[index]
+            break
+          else
+            target -= weight
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/cycle.rb

@@ -0,0 +1,18 @@
+module MTK
+  module Patterns
+
+    # 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.
+    # This is the same as a Sequence but by default has unlimited @max_cycles
+    class Cycle < Sequence
+
+      def initialize(elements, options={})
+        super
+        # Base Pattern & Sequence default to 1 max_cycle, this defaults to nil which is unlimited cycles
+        @max_cycles = options[:max_cycles]
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/for_each.rb

@@ -0,0 +1,71 @@
+module MTK
+  module Patterns
+
+    # For each value in the first sub-pattern, iterate over the second sub-pattern and chain the resulting values.
+    #
+    class ForEach < Pattern
+
+      # (see Pattern#next)
+      def next
+        @index = 0 if @index < 0
+
+        last_index = @elements.length-1
+        while @index <= last_index
+          # assume all elements are Patterns, otherwise this construct doesn't really have a point...
+          pattern = @elements[@index]
+          begin
+            element = pattern.next
+            value = evaluate_variables(element)
+
+            if @index == last_index # then emit values
+              @current = value
+              return emit(value)
+
+            else # not last element, so store variables
+              @vars.push value
+              @index += 1
+            end
+
+          rescue StopIteration
+            if @index==0
+              raise # We're done when the first pattern is done
+            else
+              pattern.rewind
+              @vars.pop
+              @index -= 1
+            end
+          end
+        end
+      end
+
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @vars = []
+        @elements.each{|elem| elem.rewind }
+        super
+      end
+
+
+      ####################
+      private
+
+      def evaluate_variables(element)
+        case element
+          when ::MTK::Lang::Variable
+            if element.implicit?
+              return @vars[-element.name.length] # '$' is most recently pushed value, $$' goes back 2 levels, '$$$' goes back 3, etc
+            end
+          when Array
+            return element.map{|e| evaluate_variables(e) }
+        end
+        return element
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/function.rb

@@ -0,0 +1,39 @@
+module MTK
+  module Patterns
+
+    # An arbitrary function that dynamically generates elements.
+    #
+    class Function < Pattern
+
+      attr_reader :function
+      
+      def initialize(elements, options={})
+        # unpack from the varargs Array that may be passed in from the "convenience constructor methods" defined in MTK::Pattern                        \
+        @function = if elements.is_a? Enumerable then elements.first else elements end
+        super [@function], options
+      end
+
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @function_call_count = -1
+        super
+      end
+
+      def advance
+        @function_call_count += 1
+        @current = case @function.arity
+          when 0 then @function.call
+          when 1 then @function.call(@current)
+          when 2 then @function.call(@current, @function_call_count)
+          else @function.call(@current, @function_call_count, @element_count)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/lines.rb

@@ -0,0 +1,54 @@
+module MTK
+  module Patterns
+
+    # A piecewise linear function (see {http://en.wikipedia.org/wiki/File:PiecewiseLinear.png}) defined in terms
+    # of [value, steps_to_reach_value] pairs.
+    #
+    # The "steps_to_reach_value" for the first element is ignored and may be omitted, since it takes 0 steps to start.
+    class Lines < Pattern
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @steps = -1
+        @step_count = -1
+        @prev = nil
+        @next = nil
+        super
+      end
+
+      # (see Pattern#advance)
+      def advance
+        while @step_count >= @steps
+          @step_count = 0
+
+          @index += 1
+          raise StopIteration if @index >= @elements.length
+
+          @prev = @next
+          next_elem = @elements[@index]
+          if next_elem.is_a? Array
+            @next = next_elem.first
+            @steps = next_elem.last.to_f
+          else
+            @next = next_elem
+            @steps = 1.0
+          end
+        end
+
+        @step_count += 1
+
+        if @prev and @next
+          # linear interpolation
+          @current = @prev + (@next - @prev)*@step_count/@steps
+        else
+          @current = @next
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/palindrome.rb

@@ -0,0 +1,45 @@
+module MTK
+  module Patterns
+
+    # 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 Palindrome < Cycle
+
+      # true if the first/last element are repeated when the ends are reached, else false
+      def repeat_ends?
+        @repeat_ends ||= @options.fetch :repeat_ends, false
+      end
+
+      ##############
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @direction = 1
+        super
+      end
+
+      # (see Pattern#advance)
+      def advance
+        raise StopIteration if @elements.nil? or @elements.empty? # prevent infinite loops
+
+        @index += @direction
+
+        if @index >= @elements.length
+          @direction = -1
+          @index = @elements.length - 1
+          @index -= 1 unless repeat_ends? or @elements.length == 1
+
+        elsif @index < 0
+          @direction = 1
+          @index = 0
+          @index += 1 unless repeat_ends? or @elements.length == 1
+        end
+
+        @current = @elements[@index]
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/pattern.rb

@@ -0,0 +1,171 @@
+module MTK
+  module Patterns
+
+    # A pattern of elements that can be emitted one element at a time via calls to {#next}.
+    #
+    # Patterns can be reset to the beginning via {#rewind}.
+    #
+    # @abstract Subclass and override {#advance} to implement a Pattern.
+    #
+    class Pattern
+      include MTK::Groups::Collection
+
+      # The elements in the pattern
+      attr_reader :elements
+
+      attr_reader :options
+
+      # The number of elements emitted since the last {#rewind}
+      attr_reader :element_count
+
+      # The minimum number of elements this Pattern will emit before a StopIteration exception
+      # This overrides any conflicting max_cycles setting.
+      attr_reader :min_elements
+
+      # The maximum number of elements this Pattern will emit before a StopIteration exception
+      # A nil value means infinite elements.
+      # @note {#max_cycles} may cause this Pattern to end before max_elements are emitted.
+      #       If this is undesirable then use min_elements to override max_cycles.
+      attr_reader :max_elements
+
+      # The number of cycles emitted (1 cycle == all elements emitted) since the last {#rewind}
+      attr_reader :cycle_count
+
+      # The maximum number of cycles this Pattern will emit before a StopIteration exception.
+      # A nil value means inifinite cycles.
+      attr_reader :max_cycles
+
+      # @param elements [Enumerable] the list of elements in the pattern
+      # @param options [Hash] the pattern options
+      # @option options [Fixnum] :max_elements the {#max_elements} (default is nil, which means unlimited)
+      # @option options [Fixnum] :max_cycles the {#max_cycles} (default is 1)
+      def initialize(elements, options={})
+        elements = elements.to_a if elements.is_a? Enumerable
+        @elements = elements
+        @options = options
+        @min_elements = options[:min_elements]
+        @max_elements = options[:max_elements]
+        @max_cycles = options.fetch(:max_cycles, 1)
+        rewind
+      end
+
+      # Construct a pattern from an Array.
+      # @param (see #initialize)
+      # @option (see #initialize)
+      # @see #initialize
+      def self.from_a(elements, options={})
+        new(elements, options)
+      end
+
+      # Reset the pattern to the beginning
+      def rewind
+        rewind_or_cycle
+        self
+      end
+
+      # Emit the next element in the pattern
+      # @raise StopIteration when the pattern has emitted all values, or has hit the {#max_elements} limit.
+      def next
+        raise StopIteration if empty?
+
+        if @current.is_a? Pattern
+          begin
+            return emit(@current.next)
+          rescue StopIteration
+            raise if max_elements_exceeded?
+            # else fall through and continue with normal behavior
+          end
+        end
+
+        begin
+          advance
+        rescue StopIteration
+          rewind_or_cycle(true)
+          return self.next
+        end
+
+        if @current.kind_of? Pattern
+          @current.rewind # ensure nested patterns start from the beginning each time they are encountered
+          return self.next
+        end
+
+        emit(@current)
+      end
+
+
+      def min_elements_unmet?
+        @min_elements and @element_count < @min_elements
+      end
+
+      def max_elements_exceeded?
+        @max_elements and @element_count >= @max_elements
+      end
+
+      def max_cycles_exceeded?
+        @max_cycles and @cycle_count >= @max_cycles
+      end
+
+      def empty?
+        @elements.nil? or @elements.empty?
+      end
+
+      ##################
+      protected
+
+      # Reset the pattern to the beginning
+      # @param is_cycling [Boolean] true when #next is performing a cycle back to the beginning of the Pattern. false for a normal #rewind
+      def rewind_or_cycle(is_cycling=false)
+        @current = nil
+        @index = -1
+
+        # and rewind child patterns
+        @elements.each{|element| element.rewind if element.is_a? Pattern }
+
+        if is_cycling
+          @cycle_count += 1
+          raise StopIteration if max_cycles_exceeded? and not min_elements_unmet?
+        else
+          @element_count = 0
+          @cycle_count = 0
+        end
+      end
+
+      # Update internal state (index, etc) and set @current to the next element.
+      def advance
+        @current = elements[0]
+      end
+
+
+      ##################
+      private
+
+      def emit element
+        raise StopIteration if (max_elements_exceeded? or max_cycles_exceeded?) and not min_elements_unmet?
+        @element_count += 1
+        element
+      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::Patterns.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
+
+        %w(Pitch PitchClass Intensity Duration Interval Rhythm).each do |type|
+          MTK::Patterns.define_singleton_method "#{type}#{classname}" do |*args|
+            options  = (args[-1].is_a? Hash) ? args.pop : {}
+            args = args[0] if args.length == 1 and args[0].is_a? Array
+            constructor_for_type = (type == 'Rhythm') ? 'Duration' : type
+            args = args.map{|arg| (arg.nil? or arg.is_a? Proc) ? arg : MTK.send(constructor_for_type, arg) } # coerce to the given type (or Duration for rhythm type)
+            subclass.new(args,options)
+          end
+        end
+      end
+    end
+
+  end
+end