xi-lang 0.1.4 → 0.1.5

data/lib/xi/pattern/generators.rb

@@ -1,189 +1,184 @@
 module Xi
   class Pattern
     module Generators
-      module ClassMethods
-        # Create an arithmetic series pattern of +length+ values, being +start+
-        # the starting value and +step+ the addition factor.
-        #
-        # @example
-        #   peek P.series                 #=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-        #   peek P.series(3)              #=> [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
-        #   peek P.series(0, 2)           #=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
-        #   peek P.series(0, 0.25, 8)     #=> [0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
-        #
-        # @param start [Numeric] (default: 0)
-        # @param step [Numeric] (default: 1)
-        # @param length [Numeric, Symbol] number or inf (default: inf)
-        # @return [Pattern]
-        #
-        def series(start=0, step=1, length=inf)
-          Pattern.new(size: length) do |y|
-            i = start
-            loop_n(length) do
-              y << i
-              i += step
-            end
+      # Create an arithmetic series pattern of +length+ values, being +start+
+      # the starting value and +step+ the addition factor.
+      #
+      # @example
+      #   peek P.series                 #=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+      #   peek P.series(3)              #=> [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+      #   peek P.series(0, 2)           #=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
+      #   peek P.series(0, 0.25, 8)     #=> [0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+      #
+      # @param start [Numeric] (default: 0)
+      # @param step [Numeric] (default: 1)
+      # @param length [Numeric, Symbol] number or inf (default: inf)
+      # @return [Pattern]
+      #
+      def series(start=0, step=1, length=inf)
+        Pattern.new(size: length) do |y|
+          i = start
+          loop_n(length) do
+            y << i
+            i += step
           end
         end
+      end
 
-        # Create a geometric series pattern of +length+ values, being +start+ the
-        # starting value and +step+ the multiplication factor.
-        #
-        # @example
-        #   peek P.geom                 #=> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-        #   peek P.geom(3)              #=> [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
-        #   peek P.geom(1, 2)           #=> [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
-        #   peek P.geom(1, 1/2, 6)      #=> [1, (1/2), (1/4), (1/8), (1/16), (1/32)]
-        #   peek P.geom(1, -1, 8)       #=> [1, -1, 1, -1, 1, -1, 1, -1]
-        #
-        # @param start [Numeric] (default: 0)
-        # @param grow [Numeric] (default: 1)
-        # @param length [Numeric, Symbol] number or inf (default: inf)
-        # @return [Pattern]
-        #
-        def geom(start=0, grow=1, length=inf)
-          Pattern.new(size: length) do |y|
-            i = start
-            loop_n(length) do
-              y << i
-              i *= grow
-            end
+      # Create a geometric series pattern of +length+ values, being +start+ the
+      # starting value and +step+ the multiplication factor.
+      #
+      # @example
+      #   peek P.geom                 #=> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      #   peek P.geom(3)              #=> [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
+      #   peek P.geom(1, 2)           #=> [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+      #   peek P.geom(1, 1/2, 6)      #=> [1, (1/2), (1/4), (1/8), (1/16), (1/32)]
+      #   peek P.geom(1, -1, 8)       #=> [1, -1, 1, -1, 1, -1, 1, -1]
+      #
+      # @param start [Numeric] (default: 0)
+      # @param grow [Numeric] (default: 1)
+      # @param length [Numeric, Symbol] number or inf (default: inf)
+      # @return [Pattern]
+      #
+      def geom(start=0, grow=1, length=inf)
+        Pattern.new(size: length) do |y|
+          i = start
+          loop_n(length) do
+            y << i
+            i *= grow
           end
         end
+      end
 
-        # Choose items from the +list+ randomly, +repeats+ number of times
-        #
-        # +list+ can be a *finite* enumerable or Pattern.
-        #
-        # @see Pattern::Transforms#rand
-        #
-        # @example
-        #   peek P.rand([1, 2, 3])          #=> [2]
-        #   peek P.rand([1, 2, 3, 4], 6)    #=> [1, 3, 2, 2, 4, 3]
-        #
-        # @param list [#each] list of values
-        # @param repeats [Fixnum, Symbol] number or inf (default: 1)
-        # @return [Pattern]
-        #
-        def rand(list, repeats=1)
-          Pattern.new(size: repeats) do |y|
-            ls = list.to_a
-            loop_n(repeats) { y << ls.sample }
-          end
+      # Choose items from the +list+ randomly, +repeats+ number of times
+      #
+      # +list+ can be a *finite* enumerable or Pattern.
+      #
+      # @see Pattern::Transforms#rand
+      #
+      # @example
+      #   peek P.rand([1, 2, 3])          #=> [2]
+      #   peek P.rand([1, 2, 3, 4], 6)    #=> [1, 3, 2, 2, 4, 3]
+      #
+      # @param list [#each] list of values
+      # @param repeats [Fixnum, Symbol] number or inf (default: 1)
+      # @return [Pattern]
+      #
+      def rand(list, repeats=1)
+        Pattern.new(size: repeats) do |y|
+          ls = list.to_a
+          loop_n(repeats) { y << ls.sample }
         end
+      end
 
-        # Choose randomly, but only allow repeating the same item after yielding
-        # all items from the list.
-        #
-        # +list+ can be a *finite* enumerable or Pattern.
-        #
-        # @see Pattern::Transforms#xrand
-        #
-        # @example
-        #   peek P.xrand([1, 2, 3, 4, 5])    #=> [4]
-        #   peek P.xrand([1, 2, 3], 8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
-        #
-        # @param list [#each] list of values
-        # @param repeats [Fixnum, Symbol] number or inf (default: 1)
-        # @return [Pattern]
-        #
-        def xrand(list, repeats=1)
-          Pattern.new(size: repeats) do |y|
-            ls = list.to_a
-            xs = nil
-            loop_n(repeats) do |i|
-              xs = ls.shuffle if i % ls.size == 0
-              y << xs[i % ls.size]
-            end
+      # Choose randomly, but only allow repeating the same item after yielding
+      # all items from the list.
+      #
+      # +list+ can be a *finite* enumerable or Pattern.
+      #
+      # @see Pattern::Transforms#xrand
+      #
+      # @example
+      #   peek P.xrand([1, 2, 3, 4, 5])    #=> [4]
+      #   peek P.xrand([1, 2, 3], 8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
+      #
+      # @param list [#each] list of values
+      # @param repeats [Fixnum, Symbol] number or inf (default: 1)
+      # @return [Pattern]
+      #
+      def xrand(list, repeats=1)
+        Pattern.new(size: repeats) do |y|
+          ls = list.to_a
+          xs = nil
+          loop_n(repeats) do |i|
+            xs = ls.shuffle if i % ls.size == 0
+            y << xs[i % ls.size]
           end
         end
+      end
 
-        # Shuffle the list in random order, and use the same random order
-        # +repeats+ times
-        #
-        # +list+ can be a *finite* enumerable or Pattern.
-        #
-        # @see Pattern::Transforms#shuf
-        #
-        # @example
-        #   peek P.shuf([1, 2, 3, 4, 5])    #=> [5, 3, 4, 1, 2]
-        #   peek P.shuf([1, 2, 3], 3)       #=> [2, 3, 1, 2, 3, 1, 2, 3, 1]
-        #
-        # @param list [#each] list of values
-        # @param repeats [Fixnum, Symbol] number or inf (default: 1)
-        # @return [Pattern]
-        #
-        def shuf(list, repeats=1)
-          Pattern.new(size: list.size * repeats) do |y|
-            xs = list.to_a.shuffle
-            loop_n(repeats) do |i|
-              xs.each { |x| y << x }
-            end
+      # Shuffle the list in random order, and use the same random order
+      # +repeats+ times
+      #
+      # +list+ can be a *finite* enumerable or Pattern.
+      #
+      # @see Pattern::Transforms#shuf
+      #
+      # @example
+      #   peek P.shuf([1, 2, 3, 4, 5])    #=> [5, 3, 4, 1, 2]
+      #   peek P.shuf([1, 2, 3], 3)       #=> [2, 3, 1, 2, 3, 1, 2, 3, 1]
+      #
+      # @param list [#each] list of values
+      # @param repeats [Fixnum, Symbol] number or inf (default: 1)
+      # @return [Pattern]
+      #
+      def shuf(list, repeats=1)
+        Pattern.new(size: list.size * repeats) do |y|
+          xs = list.to_a.shuffle
+          loop_n(repeats) do |i|
+            xs.each { |x| y << x }
           end
         end
+      end
 
-        # Generates values from a sinewave discretized to +quant+ events
-        # for the duration of +dur+ cycles.
-        #
-        # Values range from -1 to 1
-        #
-        # @see #sin1 for the same function but constrained on 0 to 1 values
-        #
-        # @example
-        #   P.sin(8).map { |i| i.round(2) }
-        #     #=> [0.0, 0.71, 1.0, 0.71, 0.0, -0.71, -1.0, -0.71]
-        #
-        # @example +quant+ determines the size, +dur+ the total duration
-        #   P.sin(8).size                 #=> 8
-        #   P.sin(22).total_duration      #=> (1/1)
-        #   P.sin(19, 2).total_duration   #=> (2/1)
-        #
-        # @param quant [Fixnum]
-        # @param dur [Fixnum] (default: 1)
-        # @return [Pattern]
-        #
-        def sin(quant, dur=1)
-          Pattern.new(size: quant, dur: dur / quant) do |y|
-            quant.times do |i|
-              y << Math.sin(i / quant * 2 * Math::PI)
-            end
+      # Generates values from a sinewave discretized to +quant+ events
+      # for the duration of +delta+ cycles.
+      #
+      # Values range from -1 to 1
+      #
+      # @see #sin1 for the same function but constrained on 0 to 1 values
+      #
+      # @example
+      #   P.sin(8).map { |i| i.round(2) }
+      #     #=> [0.0, 0.71, 1.0, 0.71, 0.0, -0.71, -1.0, -0.71]
+      #
+      # @example +quant+ determines the size, +delta+ the total duration
+      #   P.sin(8).size           #=> 8
+      #   P.sin(22).duration      #=> (1/1)
+      #   P.sin(19, 2).duration   #=> (2/1)
+      #
+      # @param quant [Fixnum]
+      # @param delta [Fixnum] (default: 1)
+      # @return [Pattern]
+      #
+      def sin(quant, delta=1)
+        Pattern.new(size: quant, delta: delta / quant) do |y|
+          quant.times do |i|
+            y << Math.sin(i / quant * 2 * Math::PI)
           end
         end
+      end
 
-        # Generates values from a sinewave discretized to +quant+ events
-        # for the duration of +dur+ cycles.
-        #
-        # Values range from 0 to 1
-        #
-        # @see #sin
-        #
-        # @example
-        #   P.sin1(8).map { |i| i.round(2) }
-        #     #=> [0.5, 0.85, 1.0, 0.85, 0.5, 0.15, 0.0, 0.15]
-        #
-        # @param quant [Fixnum]
-        # @param dur [Fixnum] (default: 1)
-        # @return [Pattern]
-        #
-        def sin1(quant, dur=1)
-          sin(quant, dur).scale(-1, 1, 0, 1)
-        end
+      # Generates values from a sinewave discretized to +quant+ events
+      # for the duration of +delta+ cycles.
+      #
+      # Values range from 0 to 1
+      #
+      # @see #sin
+      #
+      # @example
+      #   P.sin1(8).map { |i| i.round(2) }
+      #     #=> [0.5, 0.85, 1.0, 0.85, 0.5, 0.15, 0.0, 0.15]
+      #
+      # @param quant [Fixnum]
+      # @param delta [Fixnum] (default: 1)
+      # @return [Pattern]
+      #
+      def sin1(quant, delta=1)
+        sin(quant, delta).scale(-1, 1, 0, 1)
+      end
 
-        private
+      private
 
-        def loop_n(length)
-          i = 0
-          loop do
-            break if length != inf && i == length
-            yield i
-            i += 1
-          end
+      # @private
+      def loop_n(length)
+        i = 0
+        loop do
+          break if length != inf && i == length
+          yield i
+          i += 1
         end
       end
-
-      def self.included(receiver)
-        receiver.extend(ClassMethods)
-      end
     end
   end
 end

data/lib/xi/pattern/transforms.rb

@@ -12,12 +12,7 @@ module Xi
       # @return [Pattern]
       #
       def -@
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:-@) ? -v : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:-@) ? -v : v }
       end
 
       # Concatenate +object+ pattern or perform a scalar sum with +object+
@@ -39,17 +34,12 @@ module Xi
       #
       def +(object)
         if object.is_a?(Pattern)
-          Pattern.new(self, size: size + object.size) { |y|
+          Pattern.new(self, size: size + object.size) { |y, d|
             each { |v| y << v }
             object.each { |v| y << v }
           }
         else
-          Pattern.new(self) { |y|
-            each_event { |e|
-              v = e.value
-              y << E[(v.respond_to?(:+) ? v + object : v), e.start, e.duration]
-            }
-          }
+          map { |v| v.respond_to?(:+) ? v + object : v }
         end
       end
 
@@ -66,12 +56,7 @@ module Xi
       # @return [Pattern]
       #
       def -(numeric)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:-) ? v - numeric : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:-) ? v - numeric : v }
       end
 
       # Performs a scalar multiplication with +numeric+
@@ -87,12 +72,7 @@ module Xi
       # @return [Pattern]
       #
       def *(numeric)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:*) ? v * numeric : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:*) ? v * numeric : v }
       end
 
       # Performs a scalar division by +numeric+
@@ -108,12 +88,7 @@ module Xi
       # @return [Pattern]
       #
       def /(numeric)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:/) ? v / numeric : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:/) ? v / numeric : v }
       end
 
       # Performs a scalar modulo against +numeric+
@@ -129,12 +104,7 @@ module Xi
       # @return [Pattern]
       #
       def %(numeric)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:%) ? v % numeric : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:%) ? v % numeric : v }
       end
 
       # Raises each value to the power of +numeric+, which may be negative or
@@ -150,12 +120,7 @@ module Xi
       # @return [Pattern]
       #
       def **(numeric)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:**) ? v ** numeric : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:**) ? v ** numeric : v }
       end
       alias_method :^, :**
 
@@ -166,16 +131,16 @@ module Xi
       #   peek [1, 2, 3].p.seq(2)           #=> [1, 2, 3, 1, 2, 3]
       #   peek [1, 2, 3].p.seq(1, 1)        #=> [2, 3, 1]
       #   peek [1, 2, 3].p.seq(2, 2)        #=> [3, 2, 1, 3, 2, 1]
-      #   peek [1, 2].p.seq(inf, 1)         #=> [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
       #
-      # @param repeats [Fixnum, Symbol] number or inf (defaut: 1)
+      # @param repeats [Fixnum] number (defaut: 1)
       # @param offset [Fixnum] (default: 0)
       # @return [Pattern]
       #
       def seq(repeats=1, offset=0)
-        unless (repeats.is_a?(Fixnum) && repeats >= 0) || repeats == inf
-          fail ArgumentError, "repeats must be a non-negative Fixnum or inf"
+        unless repeats.is_a?(Fixnum) && repeats >= 0
+          fail ArgumentError, "repeats must be a non-negative Fixnum"
         end
+
         unless offset.is_a?(Fixnum) && offset >= 0
           fail ArgumentError, "offset must be a non-negative Fixnum"
         end
@@ -227,14 +192,12 @@ module Xi
       def bounce(skip_extremes=true)
         return self if size == 0 || size == 1
 
-        Pattern.new(self, size: size * 2 - 1) { |y|
-          last_id = 0
-          each.with_index { |v, i|
-            y << v
-            last_id = i
-          }
+        new_size = skip_extremes ? size * 2 - 2 : size * 2
+        Pattern.new(self, size: new_size) { |y|
+          each { |v| y << v }
+          last_i = size - 1
           reverse_each.with_index { |v, i|
-            y << v unless skip_extremes && (i == 0 || i == last_id)
+            y << v unless skip_extremes && (i == 0 || i == last_i)
           }
         }
       end
@@ -254,12 +217,7 @@ module Xi
       # @return [Pattern]
       #
       def normalize(min, max)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:-) ? (v - min) / (max - min) : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:-) ? (v - min) / (max - min) : v }
       end
 
       # Scales a pattern of normalized values (0..1) to a custom range
@@ -279,12 +237,7 @@ module Xi
       # @return [Pattern]
       #
       def denormalize(min, max)
-        Pattern.new(self) { |y|
-          each_event { |e|
-            v = e.value
-            y << E[(v.respond_to?(:*) ? (max - min) * v + min : v), e.start, e.duration]
-          }
-        }
+        map { |v| v.respond_to?(:*) ? (max - min) * v + min : v }
       end
 
       # Scale from one range of values to another range of values
@@ -308,18 +261,17 @@ module Xi
       #
       # It is the inverse operation of #accelerate
       #
+      # @see #accelerate
+      #
       # @example
       #   peek_events %w(a b c d).p([1/4, 1/8, 1/6]).decelerate(2)
       #     #=> [E["a",0,1/2], E["b",1/2,1/4], E["c",3/4,1/3], E["d",13/12,1/2]]
       #
       # @param num [Numeric]
       # @return [Pattern]
-      # @see #accelerate
       #
       def decelerate(num)
-        Pattern.new(self) { |y|
-          each_event { |e| y << E[e.value, e.start * num, e.duration * num] }
-        }
+        Pattern.new(self, delta: delta.p * num)
       end
 
       # Advance a pattern by shrinking start and duration of events
@@ -327,18 +279,17 @@ module Xi
       #
       # It is the inverse operation of #decelerate
       #
+      # @see #decelerate
+      #
       # @example
       #   peek_events %w(a b c d).p([1/2, 1/4]).accelerate(2)
       #     #=> [E["a",0,1/4], E["b",1/4,1/8], E["c",3/8,1/4], E["d",5/8,1/8]]
       #
       # @param num [Numeric]
       # @return [Pattern]
-      # @see #decelerate
       #
       def accelerate(num)
-        Pattern.new(self) { |y|
-          each_event { |e| y << E[e.value, e.start / num, e.duration / num] }
-        }
+        Pattern.new(self, delta: delta.p / num)
       end
 
       # Based on +probability+, it yields original value or nil
@@ -362,12 +313,12 @@ module Xi
         prob_pat = probability.p
 
         if prob_pat.infinite?
-          fail ArgumentError, 'times must be a finite pattern'
+          fail ArgumentError, 'times must be finite'
         end
 
-        Pattern.new(self, size: size * prob_pat.reduce(:+)) do |y|
+        Pattern.new(self, size: size * prob_pat.size) do |y|
           prob_pat.each do |prob|
-            each { |v| y << (rand < prob ? v : nil) }
+            each { |v| y << (Kernel.rand < prob ? v : nil) }
           end
         end
       end
@@ -393,10 +344,10 @@ module Xi
         times_pat = times.p
 
         if times_pat.infinite?
-          fail ArgumentError, 'times must be a finite pattern'
+          fail ArgumentError, 'times must be finite'
         end
 
-        Pattern.new(self, size: size * times_pat.reduce(:+)) do |y|
+        Pattern.new(self, size: size * times_pat.size) do |y|
           times_pat.each do |t|
             each { |v| t.times { y << v } }
           end
@@ -449,6 +400,72 @@ module Xi
       def shuf(repeats=1)
         P.shuf(self, repeats)
       end
+
+      # Returns a new Pattern where values for which +test_proc+ are true are
+      # yielded as a pattern to another +block+
+      #
+      # If no block is given, an Enumerator is returned.
+      #
+      # These values are grouped together as a "subpattern", then yielded to
+      # +block+ for further transformation and finally spliced into the original
+      # pattern.  +test_proc+ will be called with +value+, +start+ and +duration+
+      # as parameters.
+      #
+      # @param test_proc [#call]
+      # @yield [Pattern] subpattern
+      # @yieldreturn [Pattern] transformed subpattern
+      # @return [Pattern, Enumerator]
+      #
+      def when(test_proc, &block)
+        return enum_for(__method__, test_proc) if block.nil?
+
+        Pattern.new(self) do |y|
+          each_event do |v, s, d, i|
+            if test_proc.call(v, s, d, i)
+              new_pat = block.call(self)
+              new_pat.each_event(s)
+                .take_while { |_, s_, d_| s_ + d_ <= s + d }
+                .each { |v_, _| y << v_ }
+            else
+              y << v
+            end
+          end
+        end
+      end
+
+      # Splices a new pattern returned from +block+ every +n+ cycles
+      #
+      # @see #every_iter
+      #
+      # @param n [Numeric]
+      # @yield [Pattern] subpattern
+      # @yieldreturn [Pattern] transformed subpattern
+      # @return [Pattern]
+      #
+      def every(n, &block)
+        fn = proc { |_, s, _|
+          m = (s + 1) % n
+          m >= 0 && m < 1
+        }
+        self.when(fn, &block)
+      end
+
+      # Splices a new pattern returned from +block+ every +n+ iterations
+      #
+      # @see #every
+      #
+      # @param n [Numeric]
+      # @yield [Pattern] subpattern
+      # @yieldreturn [Pattern] transformed subpattern
+      # @return [Pattern]
+      #
+      def every_iter(n, &block)
+        fn = proc { |_, _, _, i|
+          m = (i + 1) % n
+          m >= 0 && m < 1
+        }
+        self.when(fn, &block)
+      end
     end
   end
 end