Some bug fixes and added cyclic operator to list operations and some tests

Some bug fixes in pitch multiplication and added cyclic operator to lists: (1 2 3)<+ - *>(3 2 1) and some tests.

Author: amiika

lib/parser/generative.treetop

@@ -50,7 +50,7 @@ grammar GenerativeSyntax
   end
 
   rule set
-    set_scale:(prefix_scale)? '(' ':'? content:(set_items) repeat_two:(':')? repeat_times:(integer)? ')' p:(('~' / '?') [1-9]*)? t:(transform)? a:(array_method)? o:(operation)* eval_f:(ternary)? select_range:(set_range)?
+    set_scale:(prefix_scale)? '(' ':'? content:(set_items) repeat_two:(':')? repeat_times:(integer)? ')' p:(('~' / '?') [1-9]*)? a:(array_method)? o:(operation)* t:(transform)? eval_f:(ternary)? select_range:(set_range)?
     {
     def value
       reps = repeat_times.value if repeat_times.methods.include?(:value)
@@ -127,7 +127,8 @@ grammar GenerativeSyntax
           o.elements.each do |op|
             if op.methods.include?(:value) then
               op_values = ZiffArray.new(op.value.flatten.compact) if op.value.is_a?(Array)
-              case op.operator
+              op_operator = op.operator(set_id)
+              case op_operator
               when '**', '*', '/', '+', '-', '^', '%', '|', '&', '<<', '>>'
                 if op.value.kind_of?(Array)
                     set = op_values.map do |z|
@@ -138,14 +139,14 @@ grammar GenerativeSyntax
                             if z and c
                               if z.is_a?(Hash) and c.is_a?(Hash)
                                 if z[:pc] and c[:pc]
-                                  c_dup[:pc] = z[:pc].method(op.operator).(c[:pc])
+                                  c_dup[:pc] = c[:pc].method(op_operator).(z[:pc])
                                 elsif z[:hpcs] and c[:pc]
-                                  c_dup[:hpcs] = z_dup[:hpcs].map {|h| h = Marshal.load(Marshal.dump(h)) ; h[:pc] = h[:pc].method(op.operator).(c[:pc]); h}
+                                  c_dup[:hpcs] = z_dup[:hpcs].map {|h| h = Marshal.load(Marshal.dump(h)) ; h[:pc] = c[:pc].method(op_operator).(h[:pc]); h}
                                   c_dup.delete(:pc)
                                 elsif c[:hpcs] and z[:pc]
-                                  c_dup[:hpcs] = c[:hpcs].map {|h| h = Marshal.load(Marshal.dump(h)) ; h[:pc] = h[:pc].method(op.operator).(z[:pc]); h}
+                                  c_dup[:hpcs] = c[:hpcs].map {|h| h = Marshal.load(Marshal.dump(h)) ; h[:pc] = h[:pc].method(op_operator).(z[:pc]); h}
                                 elsif c[:hpcs] and z[:hpcs]
-                                  c_dup[:hpcs] = c_dup[:hpcs].map {|ch| z[:hpcs].map{|zh| zh = Marshal.load(Marshal.dump(zh)) ; zh[:pc] = zh[:pc].method(op.operator).(ch[:pc]) ; zh }}.flatten
+                                  c_dup[:hpcs] = c_dup[:hpcs].map {|ch| z[:hpcs].map{|zh| zh = Marshal.load(Marshal.dump(zh)) ; zh[:pc] = ch[:pc].method(op_operator).(zh[:pc]) ; zh }}.flatten
                                 end
                               end
                             end
@@ -161,9 +162,9 @@ grammar GenerativeSyntax
                       v = Marshal.load(Marshal.dump(v))
                       if v.is_a?(Hash)
                         if v[:pc]
-                          v[:pc] = v[:pc].to_i.method(op.operator).(operation_value)
+                          v[:pc] = v[:pc].to_i.method(op_operator).(operation_value)
                         elsif v[:hpcs]
-                          v[:hpcs] = v[:hpcs].map {|h| h = Marshal.load(Marshal.dump(h)) ; h[:pc] = h[:pc].method(op.operator).(operation_value); h }
+                          v[:hpcs] = v[:hpcs].map {|h| h = Marshal.load(Marshal.dump(h)) ; h[:pc] = h[:pc].method(op_operator).(operation_value); h }
                         end
                       end
                       v
@@ -177,19 +178,21 @@ grammar GenerativeSyntax
                 set = set-op_values if op_values
               when '<*>'
                 if op_values
-                set = set.ois.map do |v|
-                  op_values.map do |z|
-                    z = Marshal.load(Marshal.dump(z))
-                    if z[:hpcs] and v.is_a?(Array)
-                      z[:hpcs] = v.map {|ival| z[:hpcs].map {|h|  ZiffHash[{pc: h[:pc]+ival}] }}.flatten
-                    elsif z[:pc] and v.is_a?(Array)
-                        z[:hpcs] = v.map {|ival| ZiffHash[{pc: z[:pc]+ival}] }
-                        z.delete(:pc)
-                    elsif z[:hpcs] and v.is_a?(Integer)
-                      z[:hpcs] = z[:hpcs].map {|h|  h[:pc] = h[:pc]+v ; h }
-                    else
-                       z[:pc] =  z[:pc]+v
-                     end
+                  set = op_values.ois.map do |v|
+                    set.map do |z|
+                      if z.is_a?(Hash)
+                        z = Marshal.load(Marshal.dump(z))
+                        if z[:hpcs] and v.is_a?(Array)
+                          z[:hpcs] = v.map {|ival| z[:hpcs].map {|h|  ZiffHash[{pc: h[:pc]+ival}] }}.flatten
+                        elsif z[:pc] and v.is_a?(Array)
+                          z[:hpcs] = v.map {|ival| ZiffHash[{pc: z[:pc]+ival}] }
+                          z.delete(:pc)
+                        elsif z[:hpcs] and v.is_a?(Integer)
+                          z[:hpcs] = z[:hpcs].map {|h|  h[:pc] = h[:pc]+v ; h }
+                        else
+                         z[:pc] =  z[:pc]+v
+                         end
+                      end
                      z
                     end
                   end
@@ -423,10 +426,18 @@ grammar GenerativeSyntax
   end
 
   rule operation
-    op:('**' / '*' / '+' / '-' / '/' / '^' / '%' / '|' / '&' / '<<' / '>>' / '#' / '@' / '<@>' / '<&>' / '<->' / '<+>' / '<*>' / '<|>') val:(min_max / set / array)
-    {
-    def operator
-      op.text_value
+    op:(cyclic_operators / '**' / '*' / '+' / '-' / '/' / '^' / '%' / '|' / '&' / '<<' / '>>' / '#' / '@' / '<@>' / '<&>' / '<->' / '<+>' / '<*>' / '<|>') val:(min_max / set / array)
+    {
+    def operator(set_id)
+      if op.methods.include?(:value)
+        reps = (Thread.current[:tshared][:set_repeat_index] || 0)
+        operation_cycle_index = (Thread.current[:tshared][:operation_cycle_index] || 0) + 1
+        Thread.current[:tshared][:operation_cycle_index] = operation_cycle_index
+        val = op.value
+        val = resolve_cycle(val,"OP"+(reps>0?("R"+set_id.to_s):operation_cycle_index.to_s),reps) if val.is_a?(Hash) and val[:cycle]
+      else
+        op.text_value
+      end
     end
     def value
      if val.methods.include?(:value)
@@ -439,6 +450,18 @@ grammar GenerativeSyntax
     }
   end
 
+  rule cyclic_operators
+  '<' ' '* first:(operator) following:(' ' i:operator)+ ' '* '>'
+    {
+    def value
+        r = following.elements.map {|v| v.i.value }
+        r.prepend(first.value)
+        r = r.compact
+        {:cycle=>r}
+    end
+    }
+  end
+
   rule parens
     '[' parens_subset ']'
     {

lib/ziffarray.rb

@@ -450,14 +450,14 @@ def chord_intervals
     def ois(r=nil)
       #arr = self.pitch_classes #.select {|v| v.is_a?(Integer)}.compact
       if self.length>0
-        pc_list = self.select {|v| v[:pc] }.compact
+        pc_list = self.filter{|z| z.is_a?(Hash) and z[:pc] }.select {|v| v[:pc] }.compact
         if !r
           r = pc_list[0][:pc] if pc_list[0]
         end
         if pc_list.length==0
           return self.map {|v| v.ois }
         else
-          return self.map {|v| (v[:pc] and v[:pc].is_a?(Integer)) ? pc_int(r, v[:pc]) : v.ois }
+          return self.filter{|z| z.is_a?(Hash) and z[:pc] }.map {|v| (v[:pc] and v[:pc].is_a?(Integer)) ? pc_int(r, v[:pc]) : v.ois }
         end
       else
         return nil

lib/ziffhash.rb

@@ -26,6 +26,10 @@ def pcs
         self[:hpcs].map {|h| h[:pc] }
       end
 
+      def dgrs
+        self[:hpcs].map {|h| h.dgr }
+      end
+
       def opcs
         self[:hpcs].map {|h| h[:pc]+(h[:octave] ? h[:octave]*h[:scale_length] : 0) }
       end

test/run_wiki_test_generative.rb

@@ -68,7 +68,7 @@ def test_generative
     a = zparse "(1 2 3)<+>(3 6 3)" # Product of two sets
     assert_equal(a.pcs,[1, 3, 1, 6, 1, 3, 2, 3, 2, 6, 2, 3, 3, 3, 3, 6, 3, 3])
     a = zparse "(1 2 3)<*>(3 6 3)" # Two sets interval multiplication
-    assert_equal(a.pcs,[3, 6, 3, 4, 0, 4, 5, 1, 5])
+    assert_equal(a.pcs,[1, 2, 3, 4, 5, 6, 1, 2, 3])
     a = zparse "(1 2 3)<&>(3 6 3)" # Intersection of two sets
     assert_equal(a.pcs,[3])
     a = zparse "(1 2 3)<|>(3 6 3)" # Union of two sets

test/run_wiki_tests_2.rb

@@ -97,7 +97,28 @@ def test_functions
   assert_equal(a.pcs,[2,4,6])
 end
 
+def test_list_operations
+  a = zparse "(1 2 3)+(3 4 5)"
+  assert_equal(a.pcs,[4, 5, 6, 5, 6, 0, 6, 0, 1])
+  a = zparse "(1 2 3)-(3 4 5)"
+  assert_equal(a.pcs,[5, 6, 0, 4, 5, 6, 3, 4, 5])
+  a = zparse "(:(1 2 3)<+ ->(3 4 5):)"
+  assert_equal(a.pcs,[4, 5, 6, 5, 6, 0, 6, 0, 1, 5, 6, 0, 4, 5, 6, 3, 4, 5])
+  a = zparse "(1 2 3)*(3 4 5)"
+  assert_equal(a.pcs,[3, 6, 2, 4, 1, 5, 5, 3, 1])
+  a = zparse "(3 4 5)/(1 2 3)"
+  assert_equal(a.pcs,[3, 4, 5, 1, 2, 2, 1, 1, 1])
+  a = zparse "(1 2 3)%(3 4 5)"
+  assert_equal(a.pcs,[1, 2, 0, 1, 2, 3, 1, 2, 3])
+  a = zparse "(1 2 3)**(3 4 5)"
+  assert_equal(a.pcs,[1, 1, 6, 1, 2, 4, 1, 4, 5])
+  a = zparse "(q 2 e 4 8)<*>(0 2 4 3)"
+  assert_equal(a.pcs,[2, 4, 1, 4, 6, 3, 6, 1, 5, 5, 0, 4])
+end
+
+
 test_chords
 test_cycles
+test_list_operations
 
 print "All tests OK"