mtk 0.0.3.2 → 0.0.3.3

data/lib/mtk/pitch_class.rb

@@ -1,192 +0,0 @@
-module MTK
-
-  # A set of all pitches that are an integer number of octaves apart.
-  # A {Pitch} has the same PitchClass as the pitches one or more octaves away.
-  # @see https://en.wikipedia.org/wiki/Pitch_class
-  #
-  class PitchClass
-
-    # The normalized names of the 12 pitch classes in the chromatic scale.
-    # The index of each {#name} is the pitch class's numeric {#value}.
-    NAMES = %w( C Db D Eb E F Gb G Ab A Bb B ).freeze
-
-    # All enharmonic names of the 12 pitch classes, including sharps, flats, double-sharps, and double-flats,
-    # organized such that each index contains the allowed names of the pitch class with a {#value} equal to that index.
-    # @see VALID_NAMES
-    VALID_NAMES_BY_VALUE =
-    [ # (valid names ), # value # normalized name
-      %w( B#  C  Dbb ), #   0   #   C
-      %w( B## C# Db  ), #   1   #   Db
-      %w( C## D  Ebb ), #   2   #   D
-      %w( D#  Eb Fbb ), #   3   #   Eb
-      %w( D## E  Fb  ), #   4   #   E
-      %w( E#  F  Gbb ), #   5   #   F
-      %w( E## F# Gb  ), #   6   #   Gb
-      %w( F## G  Abb ), #   7   #   G
-      %w( G#     Ab  ), #   8   #   Ab
-      %w( G## A  Bbb ), #   9   #   A
-      %w( A#  Bb Cbb ), #  10   #   Bb
-      %w( A## B  Cb  )  #  11   #   B
-    ].freeze
-
-    # All valid enharmonic pitch class names in a flat list.
-    # @see VALID_NAMES_BY_VALUE
-    VALID_NAMES = VALID_NAMES_BY_VALUE.flatten.freeze
-
-    # A mapping from valid names to the value of the pitch class with that name
-    VALUES_BY_NAME = Hash[ # a map from a list of name,value pairs
-      VALID_NAMES_BY_VALUE.map.with_index do |valid_names,value|
-        valid_names.map{|name| [name,value] }
-      end.flatten(1)
-    ].freeze
-
-
-    # The name of this pitch class.
-    # One of the {NAMES} defined by this class.
-    attr_reader :name
-
-    # The value of this pitch class.
-    # An integer from 0..11 that indexes this pitch class in {PITCH_CLASSES} and the {#name} in {NAMES}.
-    attr_reader :value
-
-
-    private  ######
-    # Even though new is a private_class_method, YARD gets confused so we temporarily go private
-
-    def initialize(name, value)
-      @name, @value = name, value
-    end
-    private_class_method :new
-
-    @flyweight = {}
-
-    public   ######
-
-
-    # Lookup a PitchClass by name or value.
-    # @param name_or_value [String,Symbol,Numeric] one of {VALID_NAMES} or 0..12
-    # @return the PitchClass representing the argument
-    # @raise ArgumentError for arguments that cannot be converted to a PitchClass
-    def self.[] name_or_value
-      @flyweight[name_or_value] ||= case name_or_value
-        when String,Symbol then from_name(name_or_value)
-        when Numeric       then from_value(name_or_value.round)
-        else raise ArgumentError.new("PitchClass.[] doesn't understand #{name_or_value.class}")
-      end
-    end
-
-    # Lookup a PitchClass by name.
-    # @param name [String,#to_s] one of {VALID_NAMES} (case-insensitive)
-    def self.from_name(name)
-      @flyweight[name] ||= (
-        valid_name = name.to_s.capitalize
-        value = VALUES_BY_NAME[valid_name] or raise ArgumentError.new("Invalid PitchClass name: #{name}")
-        new(valid_name,value)
-      )
-    end
-
-    class << self
-      alias from_s from_name
-    end
-
-    # All 12 pitch classes in the chromatic scale.
-    # The index of each pitch class is the pitch class's numeric {#value}.
-    PITCH_CLASSES = NAMES.map{|name| from_name name }.freeze
-
-    # return the pitch class with the given integer value mod 12
-    # @param value [Integer,#to_i]
-    def self.from_value(value)
-      PITCH_CLASSES[value.to_i % 12]
-    end
-
-    class << self
-      alias from_i from_value
-    end
-
-    # return the pitch class with the given float rounded to the nearest integer, mod 12
-    # @param value [Float,#to_f]
-    def self.from_f(value)
-      from_i value.to_f.round
-    end
-
-    # Compare 2 pitch classes for equal values.
-    # @param other [PitchClass]
-    # @return true if this pitch class's value is equal to the other pitch class's value
-    def == other
-      other.is_a? PitchClass and other.value == @value
-    end
-
-    # Compare a pitch class with another pitch class or integer value
-    # @param other [PitchClass,#to_i]
-    # @return -1, 0, or +1 depending on whether this pitch class's value is less than, equal to, or greater than the other object's integer value
-    # @see http://ruby-doc.org/core-1.9.3/Comparable.html
-    def <=> other
-      @value <=> other.to_i
-    end
-
-    # This pitch class's normalized {#name}.
-    # @see NAMES
-    def to_s
-      @name.to_s
-    end
-
-    # This pitch class's integer {#value}
-    def to_i
-      @value.to_i
-    end
-
-    # This pitch class's {#value} as a floating point number
-    def to_f
-      @value.to_f
-    end
-
-    # Transpose this pitch class by adding it's value to the value given (mod 12)
-    # @param interval [PitchClass,Float,#to_f]
-    def + interval
-      new_value = (value + interval.to_f).round
-      self.class.from_value new_value
-    end
-    alias transpose +
-
-    # Transpose this pitch class by subtracing the given value from this value (mod 12)
-    # @param interval [PitchClass,Float,#to_f]
-    def - interval
-      new_value = (value - interval.to_f).round
-      self.class.from_value new_value
-    end
-
-    # Inverts (mirrors) the pitch class around the given center
-    # @param center [PitchClass,Pitch,Float,#to_f] the value to "mirror" this pitch class around
-    def invert(center)
-      delta = (2*(center.to_f - value)).round
-      self + delta
-    end
-
-    # the smallest interval in semitones that needs to be added to this PitchClass to reach the given PitchClass
-    # @param pitch_class [PitchClass,#value]
-    def distance_to(pitch_class)
-      delta = (pitch_class.value - value) % 12
-      if delta > 6
-        delta -= 12
-      elsif delta == 6 and to_i >= 6
-        # this is a special edge case to prevent endlessly ascending pitch sequences when alternating between two pitch classes a tritone apart
-        delta = -6
-      end
-      delta
-    end
-
-  end
-
-  # Construct a {PitchClass} from any supported type
-  # @param anything [PitchClass,String,Symbol,Numeric]
-  def PitchClass(anything)
-    case anything
-      when Numeric then PitchClass.from_f(anything)
-      when String, Symbol then PitchClass.from_s(anything)
-      when PitchClass then anything
-      else raise ArgumentError.new("PitchClass doesn't understand #{anything.class}")
-    end
-  end
-  module_function :PitchClass
-
-end

data/lib/mtk/pitch_class_set.rb

@@ -1,161 +0,0 @@
-module MTK
-
-  # An ordered collection of {PitchClass}es.
-  #
-  # Unlike a mathematical Set, a PitchClassSet is ordered and may contain duplicates.
-  #
-  # @see Melody
-  # @see Chord
-  #
-  class PitchClassSet
-    include Helpers::PitchCollection
-
-    attr_reader :pitch_classes
-
-    def self.random_row
-      new(Constants::PitchClasses::PITCH_CLASSES.shuffle)
-    end
-
-    def self.all
-      @all ||= new(Constants::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
-
-
-  # Construct a {PitchClassSet}
-  # @see PitchClassSet#initialize
-  def PitchClassSet(*anything)
-    PitchClassSet.new Helpers::Convert.to_pitch_classes(*anything)
-  end
-  module_function :PitchClassSet
-
-end

data/lib/mtk/timeline.rb

@@ -1,230 +0,0 @@
-module MTK
-
-  # A collection of timed events. The core data structure used to interface with input and output.
-  #
-  # Maps sorted floating point times to lists of events.
-  #
-  # Enumerable as [time,event_list] pairs.
-  #
-  class Timeline
-    include Enumerable
-
-    def initialize()
-      @timeline = {}
-    end
-
-    class << self
-      def from_a(enumerable)
-        new.merge enumerable
-      end
-      alias from_hash from_a
-    end
-
-    def merge enumerable
-      enumerable.each do |time,events|
-        add(time,events)
-      end
-      self
-    end
-
-    def clear
-      @timeline.clear
-      self
-    end
-
-    def to_hash
-      @timeline
-    end
-
-    def == other
-      other = other.to_hash unless other.is_a? Hash
-      @timeline == other
-    end
-
-    def [](time)
-      @timeline[time.to_f]
-    end
-
-    def []=(time, events)
-      time = time.to_f unless time.is_a? Numeric
-      case events
-        when nil?
-          @timeline.delete time.to_f
-        when Array
-          @timeline[time.to_f] = events
-        else
-          @timeline[time.to_f] = [events]
-      end
-    end
-
-    def add(time, event)
-      events = @timeline[time.to_f]
-      if events
-        if event.is_a? Array
-          events.concat event
-        else
-          events << event
-        end
-      else
-         self[time] = event
-      end
-    end
-
-    def delete(time)
-      @timeline.delete(time.to_f)
-    end
-
-    def has_time? time
-      @timeline.has_key? time.to_f
-    end
-
-    def times
-      @timeline.keys.sort
-    end
-
-    def length
-      last_time = times.last
-      events = @timeline[last_time]
-      last_time + events.map{|event| event.duration }.max
-    end
-
-    def empty?
-      @timeline.empty?
-    end
-
-    def events
-      times.map{|t| @timeline[t] }.flatten
-    end
-
-    def each
-      # this is similar to @timeline.each, but by iterating over #times, we yield the events in chronological order
-      times.each do |time|
-        yield time, @timeline[time]
-      end
-    end
-
-    # the original Enumerable#map implementation, which returns an Array
-    alias enumerable_map map
-
-    # Constructs a new Timeline by mapping each [time,event_list] pair
-    # @see #map!
-    def map &block
-      self.class.from_a enumerable_map(&block)
-    end
-
-    # Perform #map in place
-    # @see #map
-    def map! &block
-      mapped = enumerable_map(&block)
-      clear
-      merge mapped
-    end
-
-    # Map every individual event, without regard for the time at which is occurs
-    def map_events
-      mapped_timeline = Timeline.new
-      self.each do |time,events|
-        mapped_timeline[time] = events.map{|event| yield event }
-      end
-      mapped_timeline
-    end
-
-    # Map every individual event in place, without regard for the time at which is occurs
-    def map_events!
-      each do |time,events|
-        self[time] = events.map{|event| yield event }
-      end
-    end
-
-    def clone
-      self.class.from_hash(to_hash)
-    end
-
-    def compact!
-      @timeline.delete_if {|t,events| events.empty? }
-    end
-    
-    def flatten
-      flattened = Timeline.new
-      self.each do |time,events|
-        events.each do |event|
-          if event.is_a? Timeline
-            event.flatten.each do |subtime,subevent|
-              flattened.add(time+subtime, subevent)
-            end
-          else
-            flattened.add(time,event)
-          end
-        end
-      end
-      flattened
-    end
-
-    # @return a new Timeline where all times have been quantized to multiples of the given interval
-    # @example timeline.quantize(0.5)  # quantize to eight notes (assuming the beat is a quarter note)
-    # @see quantize!
-    def quantize interval
-      map{|time,events| [self.class.quantize_time(time,interval), events] }
-    end
-
-    def quantize! interval
-      map!{|time,events| [self.class.quantize_time(time,interval), events] }
-    end
-
-    # shifts all times by the given amount
-    # @see #shift!
-    # @see #shift_to
-    def shift time_delta
-      map{|time,events| [time+time_delta, events] }
-    end
-
-    # shifts all times in place by the given amount
-    # @see #shift
-    # @see #shift_to!
-    def shift! time_delta
-      map!{|time,events| [time+time_delta, events] }
-    end
-
-    # shifts the times so that the start of the timeline is at the given time
-    # @see #shift_to!
-    # @see #shift
-    def shift_to absolute_time
-      start = times.first
-      if start
-        shift absolute_time - start
-      else
-        clone
-      end
-    end
-
-    # shifts the times in place so that the start of the timeline is at the given time
-    # @see #shift_to
-    # @see #shift!
-    def shift_to! absolute_time
-      start = times.first
-      if start
-        shift! absolute_time - start
-      end
-      self
-    end
-
-    def to_s
-      times = self.times
-      last = times.last
-      width = sprintf("%d",last).length + 3 # nicely align the '=>' against the longest number
-      times.map{|t| sprintf("%#{width}.2f",t)+" => #{@timeline[t].join ', '}" }.join "\n"
-    end
-
-    def inspect
-      @timeline.inspect
-    end
-
-    def self.quantize_time time, interval
-      upper = interval * (time.to_f/interval).ceil
-      lower = upper - interval
-      (time - lower) < (upper - time) ? lower : upper
-    end
-
-  end
-
-end

data/spec/mtk/midi/jsound_input_spec.rb

@@ -1,11 +0,0 @@
-begin
-require 'spec_helper'
-require 'mtk/midi/input'
-require 'mtk/midi/jsound_input'
-
-describe MTK::MIDI::JSoundInput do
-
-end
-
-
-rescue LoadError; end # only run the test when the required gems are available

data/spec/mtk/midi/jsound_output_spec.rb

@@ -1,11 +0,0 @@
-begin
-require 'spec_helper'
-require 'mtk/midi/output'
-require 'mtk/midi/jsound_output'
-
-describe MTK::MIDI::JSoundOutput do
-
-end
-
-
-rescue LoadError; end # only run the test when the required gems are available

data/spec/mtk/midi/unimidi_input_spec.rb

@@ -1,11 +0,0 @@
-begin
-require 'spec_helper'
-require 'mtk/midi/input'
-require 'mtk/midi/unimidi_input'
-
-describe MTK::MIDI::UniMIDIInput do
-
-end
-
-
-rescue LoadError; end # only run the test when the required gems are available

data/spec/mtk/midi/unimidi_output_spec.rb

@@ -1,11 +0,0 @@
-begin
-require 'spec_helper'
-require 'mtk/midi/output'
-require 'mtk/midi/unimidi_output'
-
-describe MTK::MIDI::UniMIDIOutput do
-
-end
-
-
-rescue LoadError; end # only run the test when the required gems are available