jmtk 0.0.3.3-java

data/lib/mtk/groups/chord.rb

@@ -0,0 +1,56 @@
+module MTK
+  module Groups
+
+    # A sorted collection of distinct {Pitch}es.
+    #
+    # The "vertical" (simultaneous) pitch collection.
+    #
+    # @see Melody
+    # @see Groups::PitchClassSet
+    #
+    class Chord < Melody
+
+      # @param pitches [#to_a] the collection of pitches
+      # @note duplicate pitches will be removed. See #{Melody} if you want to maintain duplicates.
+      #
+      def initialize(pitches)
+        pitches = pitches.to_a.clone
+        pitches.uniq!
+        pitches.sort!
+        @pitches = pitches.freeze
+      end
+
+      # Generate a chord inversion (positive numbers move the lowest notes up an octave, negative moves the highest notes down)
+      def inversion(number)
+        number = number.to_i
+        pitch_set = Array.new(@pitches.uniq.sort)
+        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.sort
+      end
+
+      # Transpose the chord so that it's lowest pitch is the given pitch class.
+      def nearest(pitch_class)
+        self.transpose @pitches.first.pitch_class.distance_to(pitch_class)
+      end
+    end
+  end
+
+  # Construct an ordered {MTK::Groups::Chord} with no duplicates.
+  # @see #MTK::Groups::Chord
+  # @see #MTK::Groups::Melody
+  def Chord(*anything)
+    MTK::Groups::Chord.new MTK::Groups.to_pitches(*anything)
+  end
+  module_function :Chord
+
+end

data/lib/mtk/groups/collection.rb

@@ -0,0 +1,196 @@
+module MTK
+  module Groups
+
+     # Given a method #elements, which returns an Array of elements in the collection,
+     # including this module will make the class Enumerable and provide various methods you'd expect from an Array.
+     module Collection
+       include Enumerable
+
+       # A mutable array of elements in this collection
+       def to_a
+         Array.new(elements) # we construct a new array since some including classes make elements be immutable
+       end
+
+       # The number of elements in this collection
+       def size
+         elements.size
+       end
+       alias length size
+
+       def empty?
+         elements.nil? or elements.size == 0
+       end
+
+       # The each iterator for providing Enumerable functionality
+       def each &block
+         elements.each(&block)
+       end
+
+       # the original Enumerable#map implementation, which returns an Array
+       alias enumerable_map map
+
+       # the overriden #map implementation, which returns an object of the same type
+       def map &block
+         clone_with enumerable_map(&block)
+       end
+
+       # The first element
+       def first(n=nil)
+         n ? elements.first(n) : elements.first
+       end
+
+       # The last element
+       def last(n=nil)
+         n ? elements.last(n) : elements.last
+       end
+
+       # The element with the given index
+       def [](index)
+         elements[index]
+       end
+
+       def repeat(times=2)
+         full_repetitions, fractional_repetitions = times.floor, times%1  # split into int and fractional part
+         repeated = elements * full_repetitions
+         repeated += elements[0...elements.size*fractional_repetitions]
+         clone_with repeated
+       end
+
+       def permute
+         clone_with elements.shuffle
+       end
+       alias shuffle permute
+
+       def rotate(offset=1)
+         clone_with elements.rotate(offset)
+       end
+
+       def concat(other)
+         other_elements = (other.respond_to? :elements) ? other.elements : other
+         clone_with(elements + other_elements)
+       end
+
+       def reverse
+         clone_with elements.reverse
+       end
+       alias retrograde reverse
+
+
+       # Partition the collection into an Array of sub-collections.
+       #
+       # With a Numeric argument: partition the elements into collections of the given size (plus whatever's left over).
+       #
+       # With an Array argument: partition the elements into collections of the given sizes.
+       #
+       # Otherwise if a block is given: partition the elements into collections with the same block return value.
+       #
+       def partition(arg=nil, &block)
+         partitions = nil
+         case arg
+           when Numeric
+             partitions = self.each_slice(arg)
+
+           when Enumerable
+             partitions = []
+             items, sizes = self.to_enum, arg.to_enum
+             group = []
+             size = sizes.next
+             loop do
+               item = items.next
+               if group.size < size
+                 group << item
+               else
+                 partitions << group
+                 group = []
+                 size = sizes.next
+                 group << item
+               end
+             end
+             partitions << group unless group.empty?
+
+           else
+             if block
+               group = Hash.new{|h,k| h[k] = [] }
+               if block.arity == 2
+                 self.each_with_index{|item,index| group[block[item,index]] << item }
+               else
+                 self.each{|item| group[block[item]] << item }
+               end
+               partitions = group.values
+             end
+         end
+
+         if partitions
+           partitions.map{|p| self.class.from_a(p) }
+         else
+           self
+         end
+       end
+
+       def ==(other)
+         if other.respond_to? :elements
+           if other.respond_to? :options
+             elements == other.elements and @options == other.options
+           else
+             elements == other.elements
+           end
+         else
+           elements == other
+         end
+       end
+
+       # Create a copy of the collection.
+       # In order to use this method, the including class must implement .from_a()
+       def clone
+         clone_with to_a
+       end
+
+       #################################
+       private
+
+       # "clones" the object with the given elements, attempting to maintain any @options
+       # This is designed to work with 2 argument constructors: def initialize(elements, options=default)
+       def clone_with elements
+         from_a = self.class.method(:from_a)
+         if @options and from_a.arity == -2
+           from_a[elements, @options]
+         else
+           from_a[elements]
+         end
+       end
+
+     end
+
+
+     ######################################################################
+     # MTK::Groups
+
+     def to_pitch_classes(*anything)
+       anything = anything.first if anything.length == 1
+       if anything.respond_to? :to_pitch_classes
+         anything.to_pitch_classes
+       else
+         case anything
+           when ::Enumerable then anything.map{|item| MTK.PitchClass(item) }
+           else [MTK.PitchClass(anything)]
+         end
+       end
+     end
+     module_function :to_pitch_classes
+
+
+     def to_pitches(*anything)
+       anything = anything.first if anything.length == 1
+       if anything.respond_to? :to_pitches
+         anything.to_pitches
+       else
+         case anything
+           when ::Enumerable then anything.map{|item| MTK.Pitch(item) }
+           else [MTK.Pitch(anything)]
+         end
+       end
+     end
+     module_function :to_pitches
+
+  end
+end

data/lib/mtk/groups/melody.rb

@@ -0,0 +1,96 @@
+module MTK
+  module Groups
+
+    # An ordered collection of {Pitch}es.
+    #
+    # The "horizontal" (sequential) pitch collection.
+    #
+    # Unlike the strict definition of melody, this class is fairly abstract and only models a succession of pitches.
+    # To create a true, playable melody one must combine an MTK::Melody and rhythms into a {Events::Timeline}.
+    #
+    # @see Chord
+    #
+    class Melody
+      include PitchCollection
+
+      attr_reader :pitches
+
+      # @param pitches [#to_a] the collection of pitches
+      # @see MTK#Melody
+      #
+      def initialize(pitches)
+        @pitches = pitches.to_a.clone.freeze
+      end
+
+      def self.from_pitch_classes(pitch_classes, start=MTK::Lang::Pitches::C4, max_distance=12)
+        pitch = start
+        pitches = []
+        pitch_classes.each do |pitch_class|
+          pitch = pitch.nearest(pitch_class)
+          pitch -= 12 if pitch > start+max_distance # keep within max_distance of start (default is one octave)
+          pitch += 12 if pitch < start-max_distance
+          pitches << pitch
+        end
+        new pitches
+      end
+
+      # @see Helper::Collection
+      def elements
+        @pitches
+      end
+
+      # Convert to an Array of pitches.
+      # @note this returns a mutable copy the underlying @pitches attribute, which is otherwise unmutable
+      alias :to_pitches :to_a
+
+      def self.from_a enumerable
+        new enumerable
+      end
+
+      def to_pitch_class_set(remove_duplicates=true)
+        PitchClassSet.new(remove_duplicates ? pitch_classes.uniq : pitch_classes)
+      end
+
+      def pitch_classes
+        @pitch_classes ||= @pitches.map{|p| p.pitch_class }
+      end
+
+      # @param other [#pitches, Enumerable]
+      def == other
+        if other.respond_to? :pitches
+          @pitches == other.pitches
+        elsif other.is_a? Enumerable
+          @pitches == other.to_a
+        else
+          @pitches == other
+        end
+      end
+
+      # Compare for equality, ignoring order and duplicates
+      # @param other [#pitches, Array, #to_a]
+      def =~ other
+        @normalized_pitches ||= @pitches.uniq.sort
+        @normalized_pitches == case
+          when other.respond_to?(:pitches) then other.pitches.uniq.sort
+          when (other.is_a? Array and other.frozen?) then other
+          when other.respond_to?(:to_a) then other.to_a.uniq.sort
+          else other
+        end
+      end
+
+      def to_s
+        '[' + @pitches.map{|pitch| pitch.to_s}.join(', ') + ']'
+      end
+
+    end
+  end
+
+  # Construct an ordered {MTK::Groups::Melody} that allows duplicates
+  # @see #MTK::Groups::Melody
+  # @see #MTK::Groups::Chord
+  def Melody(*anything)
+    MTK::Groups::Melody.new MTK::Groups.to_pitches(*anything)
+  end
+  module_function :Melody
+
+end

data/lib/mtk/groups/pitch_class_set.rb

@@ -0,0 +1,163 @@
+module MTK
+
+  module Groups
+
+    # An ordered collection of {PitchClass}es.
+    #
+    # Unlike a mathematical Set, a PitchClassSet is ordered and may contain duplicates.
+    #
+    # @see MTK::Groups::Melody
+    # @see MTK::Groups::Chord
+    #
+    class PitchClassSet
+      include PitchCollection
+
+      attr_reader :pitch_classes
+
+      def self.random_row
+        new(MTK::Lang::PitchClasses::PITCH_CLASSES.shuffle)
+      end
+
+      def self.all
+        @all ||= new(MTK::Lang::PitchClasses::PITCH_CLASSES)
+      end
+
+      # @param pitch_classes [#to_a] the collection of pitch classes
+      #
+      # @see MTK#PitchClassSet
+      #
+      def initialize(pitch_classes)
+        @pitch_classes = pitch_classes.to_a.clone.freeze
+      end
+
+      # @see Helper::Collection
+      def elements
+        @pitch_classes
+      end
+
+      # Convert to an Array of pitch_classes.
+      # @note this returns a mutable copy the underlying @pitch_classes attribute, which is otherwise unmutable
+      alias :to_pitch_classes :to_a
+
+      def self.from_a enumerable
+        new enumerable
+      end
+
+      def normal_order
+        ordering = Array.new(@pitch_classes.uniq.sort)
+        min_span, start_index_for_normal_order = nil, nil
+
+        # check every rotation for the minimal span:
+        size.times do |index|
+          span = self.class.span_between ordering.first, ordering.last
+
+          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
+
+      # the collection of elements present in both sets
+      def intersection(other)
+        self.class.from_a(to_a & other.to_a)
+      end
+
+      # the collection of all elements present in either set
+      def union(other)
+        self.class.from_a(to_a | other.to_a)
+      end
+
+      # the collection of elements from this set with any elements from the other set removed
+      def difference(other)
+        self.class.from_a(to_a - other.to_a)
+      end
+
+      # the collection of elements that are members of exactly one of the sets
+      def symmetric_difference(other)
+        union(other).difference( intersection(other) )
+      end
+
+      # the collection of elements that are not members of this set
+      def complement
+        self.class.all.difference(self)
+      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
+
+      # Compare for equality, ignoring order and duplicates
+      # @param other [#pitch_classes, Array, #to_a]
+      def =~ other
+        @normalized_pitch_classes ||= @pitch_classes.uniq.sort
+        @normalized_pitch_classes == case
+          when other.respond_to?(:pitch_classes) then other.pitch_classes.uniq.sort
+          when (other.is_a? Array and other.frozen?) then other
+          when other.respond_to?(:to_a) then other.to_a.uniq.sort
+          else other
+        end
+      end
+
+      def to_s
+        @pitch_classes.join(' ')
+      end
+
+      def inspect
+        @pitch_classes.inspect
+      end
+
+      def self.span_between(pc1, pc2)
+        (pc2.to_i - pc1.to_i) % 12
+      end
+
+    end
+  end
+
+  # Construct a {Groups::PitchClassSet}
+  # @see Groups::PitchClassSet#initialize
+  def PitchClassSet(*anything)
+    MTK::Groups::PitchClassSet.new MTK::Groups.to_pitch_classes(*anything)
+  end
+  module_function :PitchClassSet
+
+end