jmtk 0.0.3.3-java

data/examples/test_output.rb

@@ -0,0 +1,7 @@
+require 'mtk'
+require_relative 'helpers/output_selector'
+include MTK::Lang::Pitches
+
+output = OutputSelector.ensure_output ARGV[0]
+
+output.play MTK.Note(C4,2,1)

data/examples/tone_row_melody.rb

@@ -0,0 +1,23 @@
+# Generate a MIDI file using a tone row, repeated 3 times using random rhythms
+#
+# NOTE: this blindly overwrites any existing MTK-tone_row_melody.mid file, unless an argument is provided
+
+require 'mtk'
+require 'mtk/io/midi_file'
+include MTK
+include MTK::Lang::PitchClasses
+include MTK::Lang::Durations
+
+file = ARGV[0] || 'MTK-tone_row_melody.mid'
+
+row = PitchClassSet Db, G, Ab, F, Eb, E, D, C, B, Gb, A, Bb
+pitch_pattern = Patterns.Cycle *row
+rhythm_pattern = Patterns.Choice s, i, i+s, q # choose between sixteenth, eighth, dotted eighth, and quarter
+
+chain = Patterns.Chain pitch_pattern, rhythm_pattern, min_elements: 36, max_elements: 36
+
+sequencer = Sequencers.LegatoSequencer chain
+timeline = sequencer.to_timeline
+
+MIDIFile(file).write timeline
+

data/lib/mtk.rb

@@ -0,0 +1,76 @@
+# Description of modules for documentation:
+
+# The top level module for this library
+module MTK
+
+  # Core data types
+  module Core
+  end
+
+  # Musical events, such as {MTK::Events::Note}s and {MTK::Events::Parameter} changes, that are arranged in time via a {MTK::Events::Timeline}.
+  module Events
+  end
+
+  # Collections of {MTK::Core} objects
+  module Groups
+  end
+
+  # Optional classes for MIDI {MTK::IO::File} and realtime MIDI {MTK::IO::Input} and {MTK::IO::Output}.
+  module IO
+  end
+
+  # Optional classes for the "MTK language", which let's you compose music via MTK without writing any Ruby code
+  module Lang
+  end
+
+  # Classes that emit elements one at a time. Used by {MTK::Sequencers::Sequencer}s to construct {MTK::Events::Timeline}s.
+  module Patterns
+  end
+
+  # Classes that assemble {MTK::Patterns::Pattern}s into {MTK::Events::Timeline}s.
+  module Sequencers
+  end
+
+end
+
+require 'mtk/core/pitch_class'
+require 'mtk/core/pitch'
+require 'mtk/core/duration'
+require 'mtk/core/intensity'
+require 'mtk/core/interval'
+
+require 'mtk/lang/pseudo_constants'
+require 'mtk/lang/pitch_classes'
+require 'mtk/lang/pitches'
+require 'mtk/lang/intervals'
+require 'mtk/lang/intensities'
+require 'mtk/lang/durations'
+require 'mtk/lang/variable'
+require 'mtk/lang/parser'
+
+require 'mtk/groups/collection'
+require 'mtk/groups/pitch_collection'
+require 'mtk/groups/pitch_class_set'
+require 'mtk/groups/melody'
+require 'mtk/groups/chord'
+
+require 'mtk/events/event'
+require 'mtk/events/note'
+require 'mtk/events/parameter'
+require 'mtk/events/timeline'
+
+require 'mtk/patterns/pattern'
+require 'mtk/patterns/sequence'
+require 'mtk/patterns/cycle'
+require 'mtk/patterns/choice'
+require 'mtk/patterns/function'
+require 'mtk/patterns/lines'
+require 'mtk/patterns/palindrome'
+require 'mtk/patterns/chain'
+require 'mtk/patterns/for_each'
+
+require 'mtk/sequencers/event_builder'
+require 'mtk/sequencers/sequencer'
+require 'mtk/sequencers/step_sequencer'
+require 'mtk/sequencers/rhythmic_sequencer'
+require 'mtk/sequencers/legato_sequencer'

data/lib/mtk/core/duration.rb

@@ -0,0 +1,213 @@
+module MTK
+  module Core
+
+    # A measure of time in musical beats.
+    # May be negative to indicate a rest, which uses the absolute value for the effective duration.
+    class Duration
+
+      include Comparable
+
+      # The names of the base durations. See {MTK::Lang::Durations} for more info.
+      NAMES = %w[w h q i s r x].freeze
+
+      VALUES_BY_NAME = {
+        'w' => 4,
+        'h' => 2,
+        'q' => 1,
+        'i' => Rational(1,2),
+        's' => Rational(1,4),
+        'r' => Rational(1,8),
+        'x' => Rational(1,16)
+      }
+
+      @flyweight = {}
+
+      # The number of beats, typically represented as a Rational
+      attr_reader :value
+
+      def initialize( length_in_beats )
+        @value = length_in_beats
+      end
+
+      # Return a duration, only constructing a new instance when not already in the flyweight cache
+      def self.[](length_in_beats)
+        if length_in_beats.is_a? Fixnum
+          value = length_in_beats
+        else
+          value = Rational(length_in_beats)
+        end
+        @flyweight[value] ||= new(value)
+      end
+
+      class << self
+        alias :from_f :[]
+        alias :from_i :[]
+      end
+
+      # Lookup a duration 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.
+      # You may use the prefix '-' to negate the duration (which turns it into a rest of the same length).
+      # You may also prefix (after the '-' if present) the base duration name with an integer, float, or rational number
+      # to multiply the base duration value. Rationals are in the form "#!{numerator_integer}/#!{denominator_integer}".
+      # @example lookup value of 'q.', which is 1.5 times a quarter note (1.5 beats):
+      #          MTK::Core::Duration.from_s('q.')
+      # @example lookup the value of 3/4w, which three-quarters of a whole note (3 beats):
+      #          MTK::Core::Duration.from_s('3/4w')
+      def self.from_s(s)
+        if s =~ /^(-)?(\d+([\.\/]\d+)?)?([whqisrx])((\.|t)*)$/i
+          name = $4.downcase
+          modifier = $5.downcase
+          modifier << $1 if $1 # negation
+          multiplier = $2
+        else
+          raise ArgumentError.new("Invalid Duration string '#{s}'")
+        end
+
+        value = VALUES_BY_NAME[name]
+        modifier.each_char do |mod|
+          case mod
+            when '-' then value *= -1
+            when '.' then value *= Rational(3,2)
+            when 't' then value *= Rational(2,3)
+          end
+        end
+
+        if multiplier
+          case multiplier
+            when /\./
+              value *= multiplier.to_f
+            when /\//
+              numerator, denominator = multiplier.split('/')
+              value *= Rational(numerator.to_i, denominator.to_i)
+            else
+              value *= multiplier.to_i
+          end
+        end
+
+        self[value]
+      end
+
+      class << self
+        alias :from_name :from_s
+      end
+
+      # The magnitude (absolute value) of the duration.
+      # This is the actual duration for rests.
+      # @see #rest?
+      def length
+        @value < 0 ? -@value : @value
+      end
+
+      # Durations with negative values are rests.
+      # @see #length
+      # @see #-@
+      def rest?
+        @value < 0
+      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_s
+        value = @value.to_s
+        value = sprintf '%.2f', @value if value.length > 6 # threshold is 6 for no particular reason...
+        "#{value} #{@value.abs > 1 || @value==0 ? 'beats' : 'beat'}"
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} @value=#{@value}>"
+      end
+
+      def ==( other )
+        if other.is_a? MTK::Core::Duration
+          other.value == @value
+        else
+          other == @value
+        end
+      end
+
+      def <=> other
+        if other.respond_to? :value
+          @value <=> other.value
+        else
+          @value <=> other
+        end
+      end
+
+      # Add this duration to another.
+      # @return a new Duration that has a value of the sum of the arguments.
+      def + duration
+        if duration.is_a? MTK::Core::Duration
+          MTK::Core::Duration[@value + duration.value]
+        else
+          MTK::Core::Duration[@value + duration]
+        end
+      end
+
+      # Subtract another duration from this one.
+      # @return a new Duration that has a value of the difference of the arguments.
+      def - duration
+        if duration.is_a? MTK::Core::Duration
+          MTK::Core::Duration[@value - duration.value]
+        else
+          MTK::Core::Duration[@value - duration]
+        end
+      end
+
+      # Multiply this duration with another.
+      # @return a new Duration that has a value of the product of the arguments.
+      def * duration
+        if duration.is_a? MTK::Core::Duration
+          MTK::Core::Duration[@value * duration.value]
+        else
+          MTK::Core::Duration[@value * duration]
+        end
+      end
+
+      # Divide this duration with another.
+      # @return a new Duration that has a value of the division of the arguments.
+      def / duration
+        if duration.is_a? MTK::Core::Duration
+          MTK::Core::Duration[to_f / duration.value]
+        else
+          MTK::Core::Duration[to_f / duration]
+        end
+      end
+
+      # Negate the duration value.
+      # Turns normal durations into rests and vice versa.
+      # @return a new Duration that has a negated value.
+      # @see #rest?
+      def -@
+        MTK::Core::Duration[@value * -1]
+      end
+
+      # Allow basic math operations with Numeric objects.
+      def coerce(other)
+        return MTK::Core::Duration[other], self
+      end
+
+    end
+  end
+
+  # Construct a {Duration} from any supported type
+  def Duration(*anything)
+    anything = anything.first if anything.length == 1
+    case anything
+      when Numeric then MTK::Core::Duration[anything]
+      when String, Symbol then MTK::Core::Duration.from_s(anything)
+      when Duration then anything
+      else raise "Duration doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Duration
+
+end

data/lib/mtk/core/intensity.rb

@@ -0,0 +1,158 @@
+module MTK
+  module Core
+
+    # 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::Lang::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::Core::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::Core::Intensity
+          MTK::Core::Intensity[@value + intensity.value]
+        else
+          MTK::Core::Intensity[@value + intensity]
+        end
+      end
+
+      def -intensity
+        if intensity.is_a? MTK::Core::Intensity
+          MTK::Core::Intensity[@value - intensity.value]
+        else
+          MTK::Core::Intensity[@value - intensity]
+        end
+      end
+
+      def * intensity
+        if intensity.is_a? MTK::Core::Intensity
+          MTK::Core::Intensity[@value * intensity.value]
+        else
+          MTK::Core::Intensity[@value * intensity]
+        end
+      end
+
+      def / intensity
+        if intensity.is_a? MTK::Core::Intensity
+          MTK::Core::Intensity[to_f / intensity.value]
+        else
+          MTK::Core::Intensity[to_f / intensity]
+        end
+      end
+
+      def coerce(other)
+        return MTK::Core::Intensity[other], self
+      end
+
+    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::Core::Intensity[anything]
+      when String, Symbol then MTK::Core::Intensity.from_s(anything)
+      when Intensity then anything
+      else raise "Intensity doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Intensity
+
+end