mtk 0.0.3.2 → 0.0.3.3

data/lib/mtk/intensity.rb

@@ -1,156 +0,0 @@
-module MTK
-
-  # A measure of intensity, using an underlying value in the range 0.0-1.0
-  class Intensity
-
-    include Comparable
-
-    # The names of the base intensities. See {}MTK::Constants::Intensities} for more info.
-    NAMES = %w[ppp pp p mp mf o ff fff].freeze
-
-    VALUES_BY_NAME = {
-      'ppp' => 0.125,
-      'pp' => 0.25,
-      'p' => 0.375,
-      'mp' => 0.5,
-      'mf' => 0.625,
-      'o' => 0.75,
-      'ff' => 0.875,
-      'fff' => 1.0
-    }
-
-    @flyweight = {}
-
-    # The number of beats, typically representation as a Rational
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    # Return an Intensity, only constructing a new instance when not already in the flyweight cache
-    def self.[](value)
-      value = value.to_f
-      @flyweight[value] ||= new(value)
-    end
-
-    class << self
-      alias :from_f :[]
-      alias :from_i :[]
-    end
-
-    # Lookup an intensity by name.
-    # This method supports appending '-' or '+' for more fine-grained values.
-    def self.from_s(s)
-      return self[1.0] if s == 'fff+' # special case because "fff" is already the maximum
-
-      name = nil
-      modifier = nil
-      if s =~ /^(\w+)([+-])?$/
-        name = $1
-        modifier = $2
-      end
-
-      value = VALUES_BY_NAME[name]
-      raise ArgumentError.new("Invalid Intensity string '#{s}'") unless value
-
-      value += 1.0/24 if modifier == '+'
-      value -= 1.0/24 if modifier == '-'
-
-      self[value]
-    end
-
-    class << self
-      alias :from_name :from_s
-    end
-
-    # The number of beats as a floating point number
-    def to_f
-      @value.to_f
-    end
-
-    # The numerical value for the nearest whole number of beats
-    def to_i
-      @value.round
-    end
-
-    def to_midi
-      (to_f * 127).round
-    end
-
-    def to_percent
-      (@value * 100).round
-    end
-
-    def to_s
-      "#{to_percent}% intensity"
-    end
-
-    def inspect
-      "#<#{self.class}:#{object_id} @value=#{@value}>"
-    end
-
-    def ==( other )
-      other.is_a? MTK::Intensity and other.value == @value
-    end
-
-    def <=> other
-      if other.respond_to? :value
-        @value <=> other.value
-      else
-        @value <=> other
-      end
-
-    end
-
-    def + intensity
-      if intensity.is_a? MTK::Intensity
-        MTK::Intensity[@value + intensity.value]
-      else
-        MTK::Intensity[@value + intensity]
-      end
-    end
-
-    def -intensity
-      if intensity.is_a? MTK::Intensity
-        MTK::Intensity[@value - intensity.value]
-      else
-        MTK::Intensity[@value - intensity]
-      end
-    end
-
-    def * intensity
-      if intensity.is_a? MTK::Intensity
-        MTK::Intensity[@value * intensity.value]
-      else
-        MTK::Intensity[@value * intensity]
-      end
-    end
-
-    def / intensity
-      if intensity.is_a? MTK::Intensity
-        MTK::Intensity[to_f / intensity.value]
-      else
-        MTK::Intensity[to_f / intensity]
-      end
-    end
-
-    def coerce(other)
-      return MTK::Intensity[other], self
-    end
-
-  end
-
-  # Construct a {Duration} from any supported type
-  def Intensity(*anything)
-    anything = anything.first if anything.length == 1
-    case anything
-      when Numeric then MTK::Intensity[anything]
-      when String, Symbol then MTK::Intensity.from_s(anything)
-      when Intensity then anything
-      else raise "Intensity doesn't understand #{anything.class}"
-    end
-  end
-  module_function :Intensity
-
-end

data/lib/mtk/interval.rb

@@ -1,155 +0,0 @@
-module MTK
-
-  # A measure of intensity, using an underlying value in the range 0.0-1.0
-  class Interval
-
-    include Comparable
-
-    # The preferred names of all pre-defined intervals
-    NAMES = %w[P1 m2 M2 m3 M3 P4 TT P5 m6 M6 m7 M7 P8].freeze
-
-    # All valid names of pre-defined intervals, indexed by their value.
-    NAMES_BY_VALUE =
-      [ #   names      # value # description
-        %w( P1 p1 ),   #   0   #  unison
-        %w( m2 min2 ), #   1   #  minor second
-        %w( M2 maj2 ), #   2   #  major second
-        %w( m3 min3 ), #   3   #  minor third
-        %w( M3 maj3 ), #   4   #  major third
-        %w( P4 p4 ),   #   5   #  perfect fourth
-        %w( TT tt ),   #   6   #  tritone (AKA augmented fourth, diminished fifth)
-        %w( P5 p5 ),   #   7   #  perfect fifth
-        %w( m6 min6 ), #   8   #  minor sixth
-        %w( M6 maj6 ), #   9   #  major sixth
-        %w( m7 min7 ), #  10   #  minor seventh
-        %w( M7 maj7 ),  #  11   #  major seventh
-        %w( P8 p8 )    #  12   #  octave
-      ].freeze
-
-    # A mapping from intervals names to their value
-    VALUES_BY_NAME = Hash[ # a map from a list of name,value pairs
-        NAMES_BY_VALUE.map.with_index do |names,value|
-          names.map{|name| [name,value] }
-        end.flatten(1)
-    ].freeze
-
-    # All valid interval names
-    ALL_NAMES = NAMES_BY_VALUE.flatten.freeze
-
-
-    @flyweight = {}
-
-    # The number of semitones represented by this interval
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    # Return an {Interval}, only constructing a new instance when not already in the flyweight cache
-    def self.[](value)
-      value = value.to_f unless value.is_a? Fixnum
-      @flyweight[value] ||= new(value)
-    end
-
-    class << self
-      alias :from_f :[]
-      alias :from_i :[]
-    end
-
-    # Lookup an interval duration by name.
-    def self.from_s(s)
-      value = VALUES_BY_NAME[s.to_s]
-      raise ArgumentError.new("Invalid Interval string '#{s}'") unless value
-      self[value]
-    end
-
-    class << self
-      alias :from_name :from_s
-    end
-
-    # The number of semitones as a floating point number
-    def to_f
-      @value.to_f
-    end
-
-    # The numerical value for the nearest whole number of semitones in this interval
-    def to_i
-      @value.round
-    end
-
-    def to_s
-      @value.to_s
-    end
-
-    def inspect
-      "#{self.class}<#{to_s} semitones>"
-    end
-
-    def ==( other )
-      other.is_a? MTK::Interval and other.value == @value
-    end
-
-    def <=> other
-      if other.respond_to? :value
-        @value <=> other.value
-      else
-        @value <=> other
-      end
-    end
-
-    def + interval
-      if interval.is_a? MTK::Interval
-        MTK::Interval[@value + interval.value]
-      else
-        MTK::Interval[@value + interval]
-      end
-    end
-
-    def -interval
-      if interval.is_a? MTK::Interval
-        MTK::Interval[@value - interval.value]
-      else
-        MTK::Interval[@value - interval]
-      end
-    end
-
-    def * interval
-      if interval.is_a? MTK::Interval
-        MTK::Interval[@value * interval.value]
-      else
-        MTK::Interval[@value * interval]
-      end
-    end
-
-    def / interval
-      if interval.is_a? MTK::Interval
-        MTK::Interval[to_f / interval.value]
-      else
-        MTK::Interval[to_f / interval]
-      end
-    end
-
-    def -@
-      MTK::Interval[@value * -1]
-    end
-
-    def coerce(other)
-      return MTK::Interval[other], self
-    end
-
-  end
-
-  # Construct a {Duration} from any supported type
-  def Interval(*anything)
-    anything = anything.first if anything.length == 1
-    case anything
-      when Numeric then MTK::Interval[anything]
-      when String, Symbol then MTK::Interval.from_s(anything)
-      when Interval then anything
-      else raise "Interval doesn't understand #{anything.class}"
-    end
-  end
-  module_function :Interval
-
-end

data/lib/mtk/melody.rb

@@ -1,94 +0,0 @@
-module MTK
-
-  # 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 {Timeline}.
-  #
-  # @see Chord
-  #
-  class Melody
-    include Helpers::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=Constants::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
-
-  # Construct an ordered {Melody} that allows duplicates
-  # @see #Melody
-  # @see #Chord
-  def Melody(*anything)
-    Melody.new Helpers::Convert.to_pitches(*anything)
-  end
-  module_function :Melody
-
-end

data/lib/mtk/pitch.rb

@@ -1,152 +0,0 @@
-module MTK
-
-  # A frequency represented by a {PitchClass}, an integer octave, and an offset in semitones.
-  class Pitch
-
-    include Comparable
-
-    attr_reader :pitch_class, :octave, :offset
-
-    def initialize( pitch_class, octave, offset=0 )
-      @pitch_class, @octave, @offset = pitch_class, octave, offset
-      @value = @pitch_class.to_i + 12*(@octave+1) + @offset
-    end
-
-    @flyweight = {}
-
-    # Return a pitch with no offset, only constructing a new instance when not already in the flyweight cache
-    def self.[](pitch_class, octave)
-      pitch_class = MTK.PitchClass(pitch_class)
-      @flyweight[[pitch_class,octave]] ||= new(pitch_class, octave)
-    end
-
-    # Lookup a pitch by name, which consists of any {PitchClass::VALID_NAMES} and an octave number.
-    # The name may also be optionally suffixed by +/-###cents (where ### is any number).
-    # @example get the Pitch for middle C :
-    #         Pitch.from_s('C4')
-    # @example get the Pitch for middle C + 50 cents:
-    #         Pitch.from_s('C4+50cents')
-    def self.from_s( name )
-      s = name.to_s
-      s = s[0..0].upcase + s[1..-1].downcase # normalize name
-      if s =~ /^([A-G](#|##|b|bb)?)(-?\d+)(\+(\d+(\.\d+)?)cents)?$/
-        pitch_class = PitchClass.from_s($1)
-        if pitch_class
-          octave = $3.to_i
-          offset_in_cents = $5.to_f
-          if offset_in_cents.nil? or offset_in_cents.zero?
-            return self[pitch_class, octave]
-          else
-            return new( pitch_class, octave, offset_in_cents/100.0 )
-          end
-        end
-      end
-      raise ArgumentError.new("Invalid pitch name: #{name.inspect}")
-    end
-
-    class << self
-      alias :from_name :from_s
-    end
-    
-    # Convert a Numeric semitones value into a Pitch
-    def self.from_f( f )
-      i, offset = f.floor, f%1  # split into int and fractional part
-      pitch_class = PitchClass.from_i(i)
-      octave = i/12 - 1
-      if offset == 0
-        self[pitch_class, octave]
-      else
-        new( pitch_class, octave, offset )
-      end
-    end
-
-    def self.from_hash(hash)
-      new hash[:pitch_class], hash[:octave], hash.fetch(:offset,0)
-    end
-    
-    # Convert a Numeric semitones value into a Pitch    
-    def self.from_i( i )
-      from_f( i )
-    end
-
-    # The numerical value of this pitch
-    def to_f
-      @value
-    end 
-
-    # The numerical value for the nearest semitone
-    def to_i
-      @value.round
-    end
-    
-    def offset_in_cents
-      @offset * 100
-    end
-
-    def to_hash
-      {:pitch_class => @pitch_class, :octave => @octave, :offset => @offset}
-    end
-
-    def to_s
-      "#{@pitch_class}#{@octave}" + (@offset.zero? ? '' : "+#{offset_in_cents.round}cents")
-    end
-
-    def inspect
-      "#<#{self.class}:#{object_id} @value=#{@value}>"
-    end
-
-    def ==( other )
-      other.respond_to? :pitch_class and other.respond_to? :octave and other.respond_to? :offset and
-      other.pitch_class == @pitch_class and other.octave == @octave and other.offset == @offset
-    end
-
-    def <=> other
-      @value <=> other.to_f
-    end
-
-    def + interval_in_semitones
-     self.class.from_f( @value + interval_in_semitones.to_f )
-    end
-    alias transpose +
-
-    def - interval_in_semitones
-      self.class.from_f( @value - interval_in_semitones.to_f )
-    end
-
-    def invert(center_pitch)
-      self + 2*(center_pitch.to_f - to_f)
-    end
-
-    def nearest(pitch_class)
-      self + self.pitch_class.distance_to(pitch_class)
-    end
-
-    def coerce(other)
-      return self.class.from_f(other.to_f), self
-    end
-
-    def clone_with(hash)
-      self.class.from_hash(to_hash.merge hash)
-    end
-
-  end
-
-  # Construct a {Pitch} from any supported type
-  def Pitch(*anything)
-    anything = anything.first if anything.length == 1
-    case anything
-      when Numeric then Pitch.from_f(anything)
-      when String, Symbol then Pitch.from_s(anything)
-      when Pitch then anything
-      when Array
-        if anything.length == 2
-          Pitch[*anything]
-        else
-          Pitch.new(*anything)
-        end
-      else raise ArgumentError.new("Pitch doesn't understand #{anything.class}")
-    end
-  end
-  module_function :Pitch
-
-end