mtk 0.0.2 → 0.0.3

data/lib/mtk/_constants/durations.rb

@@ -1,80 +0,0 @@
-require 'rational'
-
-module MTK
-
-  # Defines duration constants using abbreviations for standard rhythm values ('w' for whole note, 'h' for half note, etc).
-  #
-  # These can be thought of like constants, but in order to distinguish 'e' (eighth note) from the {PitchClass} 'E'
-  # it was necessary to use lower-case names and therefore define them as "pseudo constant" methods.
-  # The methods are available either through the module (MTK::Durations::e) or via mixin (include MTK::Durations; e)
-  #
-  # These values assume the quarter note is one beat (1.0), so they work best with 4/4 and other */4 time signatures.
-  #
-  # @note Including this module defines a bunch of single-character variables, which may shadow existing variable names.
-  #       Just be mindful of what is defined in this module when including it.
-  #
-  # @see Note
-  module Durations
-    extend Helper::PseudoConstants
-
-    # NOTE: the yard doc macros here only fill in [$2] with the actual value when generating docs under Ruby 1.9+
-
-    # whole note
-    # @macro [attach] durations.define_constant
-    #   @attribute [r]
-    #   @return [$2] number of beats for $1
-    define_constant 'w', 4
-
-    # half note
-    define_constant 'h', 2
-
-    # quarter note
-    define_constant 'q', 1
-
-    # eight note
-    define_constant 'e', Rational(1,2)
-
-    # sixteenth note
-    define_constant 's', Rational(1,4)
-
-    # thirty-second note
-    define_constant 'r', Rational(1,8)
-
-    # sixty-fourth note
-    define_constant 'x', Rational(1,16)
-
-    # The values of all "psuedo constants" defined in this module
-    DURATIONS = [w, h, q, e, s, r, x].freeze
-
-    # The names of all "psuedo constants" defined in this module
-    DURATION_NAMES = %w[w h q e s r x].freeze
-
-    # Lookup the value of an duration constant by name.
-    # This method supports appending any combination of '.' and 't' for more fine-grained values.
-    # each '.' multiplies by 3/2, and each 't' multiplies by 2/3.
-    # @example lookup value of 'e.' (eight note), which is 0.75 (0.5 * 1.5)
-    #         MTK::Durations['e.']
-    def self.[](name)
-      begin
-        modifier = nil
-        if name =~ /(\w)((.|t)*)/
-          name = $1
-          modifier = $2
-        end
-
-        value = send name
-        modifier.each_char do |mod|
-          case mod
-            when '.' then value *= Rational(3,2)
-            when 't' then value *= Rational(2,3)
-          end
-        end
-        value
-
-      rescue
-        nil
-      end
-    end
-
-  end
-end

data/lib/mtk/_constants/intensities.rb

@@ -1,81 +0,0 @@
-module MTK
-
-  # Defines intensity constants using standard dynamic symbols.
-  #
-  # These can be thought of like constants, but in order to distinguish 'f' (forte) from the {PitchClass} 'F'
-  # it was necessary to use lower-case names and therefore define them as "pseudo constant" methods.
-  # The methods are available either through the module (MTK::Intensities::f) or via mixin (include MTK::Intensities;  f)
-  #
-  # These values are intensities in the range 0.125 - 1.0 (in increments of 1/8), so they can be easily scaled (unlike MIDI velocities).
-  #
-  # It is also possible to retrieve values in increments of 1/24 by using the '+' and '-' suffix when looking
-  # up values via the {.[]} method.
-  #
-  # @note Including this module shadows Ruby's built-in p() method. 
-  #   If you include this module, you can access the built-in p() method via Kernel.p()
-  #
-  # @see Note
-  module Intensities
-    extend Helper::PseudoConstants
-    
-    # NOTE: the yard doc macros here only fill in [$2] with the actual value when generating docs under Ruby 1.9+
-    
-    # pianississimo 
-    # @macro [attach] intensities.define_constant
-    #   @attribute [r]
-    #   @return [$2] intensity value for $1   
-    define_constant 'ppp', 0.125
-
-    # pianissimo      
-    define_constant 'pp', 0.25
-
-    # piano
-    # @note Including this module shadows Ruby's built-in p() method. 
-    #   If you include this module, you can access the built-in p() method via Kernel.p()
-    define_constant 'p', 0.375
-
-    # mezzo-piano
-    define_constant 'mp', 0.5
-
-    # mezzo-forte
-    define_constant 'mf', 0.625
-
-    # forte
-    define_constant 'f', 0.75
-    
-    # fortissimo
-    define_constant 'ff', 0.875
-
-    # fortississimo
-    define_constant 'fff', 1.0
-
-    # The values of all "psuedo constants" defined in this module
-    INTENSITIES = [ppp, pp, p, mp, mf, f, ff, fff].freeze
-
-    # The names of all "psuedo constants" defined in this module
-    INTENSITY_NAMES = %w[ppp pp p mp mf f ff fff].freeze
-
-    # Lookup the value of an intensity constant by name.
-    # This method supports appending '+' or '-' for more fine-grained values.
-    # '+' and '-' add and subtract 1/24, respectively (enforcing the upper bound of 1.0 for 'fff+').
-    # @example lookup value of 'mp+', which is 0.5416666666666666  (0.5 + 1/24.0)
-    #         MTK::Intensities['mp+']
-    def self.[](name)
-      return 1.0 if name == "fff+" # special case because "fff" is already the maximum
-
-      modifier = nil
-      if name =~ /(\w+)([+-])/
-        name = $1
-        modifier = $2
-      end
-
-      value = send name
-      value += 1.0/24 if modifier == '+'
-      value -= 1.0/24 if modifier == '-'
-      value
-    rescue
-      nil
-    end
-
-  end
-end

data/lib/mtk/_constants/intervals.rb

@@ -1,85 +0,0 @@
-module MTK
-
-  # Defines a constant for intervals up to an octave using diatonic naming conventions (see http://en.wikipedia.org/wiki/Interval_(music)#Main_intervals)
-  #
-  # Naming conventions
-  #   P#: perfect interval
-  #   M#: major interval
-  #   m#: minor interval
-  #   TT: tritone (AKA augmented 4th or diminshed 5th)
-  #
-  # These can be thought of like constants, but in order to succintly distinguish 'm2' (minor) from 'M2' (major),
-  # it was necessary to use lower-case names for some of the values and therefore define them as "pseudo constant" methods.
-  # The methods are available either through the module (MTK::Intervals::m2) or via mixin (include MTK::Intervals; m2) 
-  module Intervals
-    extend Helper::PseudoConstants
-
-    # NOTE: the yard doc macros here only fill in [$2] with the actual value when generating docs under Ruby 1.9+
-
-    # perfect unison
-    # @macro [attach] interval.define_constant
-    #   @attribute [r]
-    #   @return [$2] number of semitones in the interval $1    
-    define_constant 'P1', 0
-
-    # minor second
-    # @macro [attach] interval.define_constant
-    #   @attribute [r]
-    #   @return [$2] number of semitones in the interval $1
-    define_constant 'm2', 1
-
-    # major second
-    define_constant 'M2', 2
-
-    # minor third
-    define_constant 'm3', 3
-
-    # major third
-    define_constant 'M3', 4
-
-    # pefect fourth
-    define_constant 'P4', 5
-
-    # tritone (AKA augmented fourth or diminished fifth)
-    define_constant 'TT', 6
-
-    # perfect fifth
-    define_constant 'P5', 7
-
-    # minor sixth
-    define_constant 'm6', 8
-
-    # major sixth
-    define_constant 'M6', 9
-
-    # minor seventh
-    define_constant 'm7', 10
-
-    # major seventh
-    define_constant 'M7', 11
-
-    # pefect octave
-    define_constant 'P8', 12
-
-    # The values of all "psuedo constants" defined in this module
-    INTERVALS = [P1, m2, M2, m3, M3, P4, TT, P5, m6, M6, m7, M7, P8].freeze
-
-    # The names of all "psuedo constants" defined in this module
-    INTERVAL_NAMES = %w[P1 m2 M2 m3 M3 P4 TT P5 m6 M6 m7 M7 P8].freeze
-
-    # Lookup the value of an interval constant by name.
-    # @example lookup value of 'M3', which is 4
-    #         MTK::Intervals['M3']
-    def self.[](name)
-      send name
-    rescue
-      begin
-        const_get name
-      rescue
-        nil
-      end
-    end
-
-  end
-  
-end

data/lib/mtk/_constants/pitch_classes.rb

@@ -1,35 +0,0 @@
-module MTK
-
-  # Defines a constant for each {PitchClass} in the Western chromatic scale.
-
-  module PitchClasses
-
-    # The values of all "psuedo constants" defined in this module
-    PITCH_CLASSES = []
-
-    # The names of all "psuedo constants" defined in this module
-    PITCH_CLASS_NAMES = PitchClass::NAMES
-
-    for name in PITCH_CLASS_NAMES
-      pc = PitchClass[name]
-      PITCH_CLASSES << pc
-      const_set name, pc
-    end
-
-    PITCH_CLASSES.freeze
-
-    # Lookup the value of an pitch class constant by name.
-    # @example lookup value of 'C'
-    #         MTK::PitchClasses['C']
-    # @see PitchClass.[]
-    def self.[](name)
-      begin
-        const_get name
-      rescue
-        nil
-      end
-    end
-
-  end
-
-end

data/lib/mtk/_constants/pitches.rb

@@ -1,49 +0,0 @@
-module MTK
-
-  # Defines a constants for each {Pitch} in the standard MIDI range using scientific pitch notation.
-  #
-  # See http://en.wikipedia.org/wiki/Scientific_pitch_notation
-  #
-  # @note Because the character '#' cannot be used in the name of a constant,
-  #     the "black key" pitches are all named as flats with 'b' (for example, Gb3 or Cb4)
-  # @note Because the character '-' (minus) cannot be used in the name of a constant,
-  #     the low pitches use '_' (underscore) in place of '-' (minus) (for example C_1).
-  module Pitches
-
-    # The values of all "psuedo constants" defined in this module
-    PITCHES = []
-
-    # The names of all "psuedo constants" defined in this module
-    PITCH_NAMES = []
-
-    128.times do |note_number|
-      pitch = Pitch.from_i( note_number )
-      PITCHES << pitch
-
-      octave_str = pitch.octave.to_s.sub(/-/,'_') # '_1' for -1
-      name = "#{pitch.pitch_class}#{octave_str}"
-      PITCH_NAMES << name
-
-      const_set name, pitch
-    end
-
-    PITCHES.freeze
-    PITCH_NAMES.freeze
-
-    # Lookup the value of an pitch constant by name.
-    # @example lookup value of 'C3'
-    #         MTK::Pitches['C3']
-    # @see Pitch.from_s
-    # @note Unlike {Pitch.from_s} this method will accept either '_' (underscore) or '-' (minus) and treat it like '-' (minus)
-    # @note Unlike {Pitch.from_s} this method only accepts the accidental 'b'
-    def self.[](name)
-      begin
-        const_get name.sub('-','_')
-      rescue
-        nil
-      end
-    end
-
-  end
-
-end

data/lib/mtk/event.rb

@@ -1,70 +0,0 @@
-module MTK
-
-  # An abstract musical event that has an intensity and a duration
-  # @abstract
-  class Event
-
-    # intensity of the note as a value in the range 0.0 - 1.0
-    attr_reader :intensity
-
-    def initialize(intensity, duration)
-      @intensity, @duration = intensity, duration
-    end
-
-    def self.from_hash(hash)
-      new hash[:intensity], hash[:duration]
-    end
-
-    def to_hash
-      { :intensity => @intensity, :duration => @duration }
-    end
-
-    def clone_with(hash)
-      self.class.from_hash(to_hash.merge hash)
-    end
-
-    def scale_intensity(scaling_factor)
-      clone_with :intensity => @intensity * scaling_factor.to_f
-    end
-
-    def scale_duration(scaling_factor)
-      clone_with :duration => @duration * scaling_factor.to_f
-    end
-
-    # intensity scaled to the MIDI range 0-127
-    def velocity
-      @velocity ||= (127 * @intensity).round
-    end
-
-    # Duration of the Event in beats (e.g. 1.0 is a quarter note in 4/4 time signatures)
-    # This is the absolute value of the duration attribute used to construct the object.
-    # @see rest?
-    def duration
-      @abs_duration ||= @duration.abs
-    end
-
-    # By convention, any events with negative durations are considered a rest
-    def rest?
-      @duration < 0
-    end
-
-    def duration_in_pulses(pulses_per_beat)
-      @duration_in_pulses ||= (duration * pulses_per_beat).round
-    end
-
-    def == other
-      other.respond_to? :intensity and @intensity == other.intensity and
-      other.respond_to? :duration and @duration == other.duration
-    end
-
-    def to_s
-      "#{sprintf '%.2f',@intensity}, #{sprintf '%.2f',@duration}"
-    end
-
-    def inspect
-      "#@intensity, #@duration"
-    end
-
-  end
-
-end

data/lib/mtk/helper/collection.rb

@@ -1,114 +0,0 @@
-module MTK::Helper
-
-  # 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 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
-
-    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={})
-    def clone_with elements
-      from_a = self.class.method(:from_a)
-      if from_a.arity == -2
-        from_a[elements, (@options || {})]
-      else
-        from_a[elements]
-      end
-    end
-
-  end
-
-end
-
-if not Array.instance_methods.include? :rotate
-  # Array#rotate is only available in Ruby 1.9, so we may have to implement it
-  class Array
-    def rotate(offset=1)
-      return self if empty?
-      offset %= length
-      self[offset..-1]+self[0...offset]
-    end
-  end
-end