zgomot 0.0.1

data/lib/zgomot/comp/chord.rb

@@ -0,0 +1,171 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Chord
+
+    #####-------------------------------------------------------------------------------------------------------
+    # progession interface
+    #####-------------------------------------------------------------------------------------------------------
+    class Progression
+    
+      #.........................................................................................................
+      attr_reader :chord
+
+      #.........................................................................................................
+      def initialize(chord)
+        @chord = chord || :scale
+      end
+      
+      #.........................................................................................................
+      def notes(prog)
+        chords = prog.mode.chords(chord); count = -1
+        prog.items.select do |d| 
+          d.eql?(:R) || chords[d-1]
+        end.map do |d|
+          count += 1; idx_length, idx_velocity = count % prog.length.length, count % prog.velocity.length
+          unless d.eql?(:R)
+            Chord.new(:tonic => prog.pitches[d-1], :chord => chords[d-1], :length => prog.length[idx_length], :velocity => prog.velocity[idx_velocity])
+          else
+            Zgomot::Midi::Note.new(:pitch => :R, :length => prog.length[idx_length], :velocity => prog.velocity[idx_velocity])            
+          end
+        end
+      end
+    
+    #### Progression  
+    end
+
+    #.........................................................................................................
+    @chord_intervals = {
+      :maj  => [4,7],
+      :min  => [3,7],
+      :dim  => [3,6],
+      :aug  => [4,8],
+      :sus2 => [2,7],
+      :sus4 => [5,7]
+      }
+        
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+      
+      #.........................................................................................................
+      attr_reader :chord_intervals
+
+    #### self
+    end
+        
+    #.........................................................................................................
+    attr_reader :tonic, :chord, :clock, :intervals, :arp, :time_scale, :items, :inversion, :reverse
+    attr_accessor :length, :velocity
+  
+    #.........................................................................................................
+    def initialize(args)
+      @length, @velocity, @chord = args[:length], args[:velocity], args[:chord]
+      (@intervals =  Chord.chord_intervals[chord]) || raise(Zgomot::Error, "#{chord.inspect} is invalid")                      
+      @time_scale, @inversion, @reverse = 1.0, 0, false
+      @tonic = case args[:tonic]
+                when Array then args[:tonic]
+                when Symbol then [args[:tonic], 4]
+                when nil then [:C,4]
+                else raise(Zgomot::Error, "#{args[:tonic].inspect} is invalid tonic")
+              end
+    end
+
+    #.........................................................................................................
+    def pitches
+      last_pitch, octave = tonic; pitches = [tonic]
+      intervals.each_index{|i| pitches << PitchClass.next(tonic.first, intervals[i])}
+      nts = pitches[1..-1].map do |p|
+              octave += 1 if p < last_pitch; last_pitch = p.value; [last_pitch, octave]
+            end.unshift(tonic)
+      @reverse ? invert(nts).reverse : invert(nts)     
+    end
+
+    #.........................................................................................................
+    def notes
+      @notes ||= pitches.map do |p| 
+                   Zgomot::Midi::Note.new(:pitch => p, :length => length, :velocity => velocity)
+                 end                          
+    end
+
+    #.........................................................................................................
+    # transforms
+    #.........................................................................................................
+    def arp!(v)
+      @notes = nil; @arp = v; self
+    end
+
+    #.........................................................................................................
+    def inv!(v)
+      @notes = nil; @inversion = v; self
+    end
+
+    #.........................................................................................................
+    def rev!
+      @reverse = true; self
+    end
+
+    #.........................................................................................................
+    def bpm!(v)
+      @time_scale = 1.0/v.to_f; self
+    end
+
+    #.........................................................................................................
+    def octave!(v)
+      @notes = nil; @octave = v; self
+    end
+      
+    #.........................................................................................................
+    # channel and dispatch interface
+    #.........................................................................................................
+    def length_to_sec
+      time_scale*Zgomot::Midi::Clock.whole_note_sec*(1.0/length + (arp.to_f.eql?(0.0) ? 0.0 : intervals.length.to_f/arp.to_f))
+    end
+
+    #.........................................................................................................
+    def to_midi
+      notes.map{|n| n.to_midi}
+    end
+
+    #.........................................................................................................
+    def channel=(chan)
+      notes.each{|n| n.channel = chan}
+    end
+
+    #.........................................................................................................
+    def offset_time=(time)
+      notes.each{|n| n.offset_time = time}
+    end
+    
+    #.........................................................................................................
+    def time=(time)
+      @clock = Zgomot::Midi::Clock.new
+      clock.update(time)
+      notes.each do |n|
+        n.time = clock.current_time
+        clock.update(Zgomot::Midi::Clock.whole_note_sec/arp.to_f) if arp.to_f > 0.0        
+      end
+    end
+
+    #.........................................................................................................
+    # private
+    #.........................................................................................................
+    def sum(a)
+      a.inject(0) {|s,n| s+n}
+    end
+
+    #.........................................................................................................
+    def invert(p)
+      inversion.times do |i|
+        n = p.shift; p.push([n.first, (n.last.eql?(9) ? n.last : n.last+1)]) 
+      end; p
+    end
+
+    #.........................................................................................................
+    private :sum, :invert
+      
+  #### Chord
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/markov.rb

@@ -0,0 +1,60 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Markov
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+      
+      #.........................................................................................................
+      def mark
+        new 
+      end
+
+    #### self
+    end
+              
+    #.........................................................................................................
+    attr_reader :current_state, :states
+    
+    #.........................................................................................................
+    def initialize
+      @current_state, @states = 0, []
+    end
+
+    #.........................................................................................................
+    def add(trans, &blk)
+      @states << {:trans=>sum_trans(trans), :blk => blk}
+    end
+
+    #.........................................................................................................
+    def init(state, args={})
+      @current_state = state
+      states[@current_state][:blk].call(args)
+    end
+    
+    #.........................................................................................................
+    def next(args={})
+      r, state = rand, states[@current_state]
+      @current_state = state[:trans].select{|t| r >= t}.count
+      Zgomot.logger.info "CURRENT MARKOV STATE: #{current_state}"
+      blk = states[@current_state][:blk]
+      blk.arity > 0 ? blk.call(args) : blk.call
+    end
+
+    #.........................................................................................................
+    # private
+    #.........................................................................................................
+    def sum_trans(trans)      
+      sums = []; trans.each_index{|i| sums[i] = trans[0..i].inject(0){|s,v| s+v}}; sums      
+    end
+       
+    #.........................................................................................................
+    private :sum_trans
+          
+  #### Markov
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/mode.rb

@@ -0,0 +1,66 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Mode
+    
+    #.........................................................................................................
+    @modes = [:ionian, :dorian, :phrygian, :lydian, :mixolydian, :aeolian, :locrian]
+    @intervals = [2,2,1,2,2,2,1]
+    @chords = {:scale => [:maj, :min, :min, :maj, :maj, :min, :dim],
+               :maj   => [:maj, nil, nil, :maj, :maj, nil, nil],
+               :min   => [nil, :min, :min, nil, nil, :min, nil],  
+               :dim   => [nil, nil, nil, nil, nil, nil, :dim],                                                                                            
+               :sus2  => [:sus2, :sus2, nil, :sus2, :sus2, :sus2, nil],
+               :sus4  => [:sus4, :sus4, :sus4, nil, :sus4, :sus4, nil],
+               :aug   => [nil, nil, nil, nil, nil, nil, nil]}
+    
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+    
+      #.........................................................................................................
+      attr_reader :modes, :intervals, :chords
+    
+    #### self  
+    end
+    
+    #####-------------------------------------------------------------------------------------------------------
+    attr_reader :scale, :mode
+  
+    #.........................................................................................................
+    def initialize(mode = 1)
+      @mode = case mode
+                 when Symbol then self.class.modes.index(mode)+1
+                 when Fixnum then mode
+                 when nil then 1
+                 else raise(Zgomot::Error, "#{mode.inspect} is invalid mode")
+               end
+      raise(Zgomot::Error, "'#{mode}' is invalid mode") if @mode.nil?
+      @scale = Scale.new(self.class.intervals, @mode)        
+    end
+      
+    #.........................................................................................................
+    def chords(chord = :scale)
+      cycle_chords(Mode.chords[chord].clone)
+    end
+    
+    #.........................................................................................................
+    def method_missing(meth, *args, &blk )
+      scale.send(meth, *args, &blk)
+    end
+
+    #.........................................................................................................
+    # private
+    #.........................................................................................................
+    def cycle_chords(cs)
+      (mode-1).times{cs.push(cs.shift)}; cs 
+    end
+
+    #.........................................................................................................
+    private :cycle_chords
+      
+  #### Mode
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/note.rb

@@ -0,0 +1,29 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Note
+
+    #####-------------------------------------------------------------------------------------------------------
+    # progession interface
+    #####-------------------------------------------------------------------------------------------------------
+    class Progression
+
+      #.........................................................................................................
+      def notes(prog)
+        count = -1
+        prog.items.map do |d| 
+          count += 1; idx_length, idx_velocity = count % prog.length.length, count % prog.velocity.length
+          pitch = d.eql?(:R) ? :R : prog.pitches[d-1]
+          Zgomot::Midi::Note.new(:pitch => pitch, :length => prog.length[idx_length], :velocity => prog.velocity[idx_velocity])
+        end
+      end
+    
+    #### Progression  
+    end
+      
+  #### Note
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/pattern.rb

@@ -0,0 +1,63 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Pattern
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+    
+      #.......................................................................................................
+      def n(p=[:C,4], opts = {})
+        l = opts[:l] || 4; v = opts[:v] || 0.6
+        Zgomot::Midi::Note.new(:pitch => p, :length => l, :velocity => v)
+      end
+
+      #.........................................................................................................
+      def c(tonic, chord = :maj, opts = {})
+        l = opts[:l] || 4; v = opts[:v] || 0.6
+        Chord.new(:tonic => tonic, :chord => chord, :length => l, :velocity => v)
+      end
+
+      #.........................................................................................................
+      def np(tonic=[:C,4], mode=0, opts = {})
+        l = opts[:l] || 4; v = opts[:v] || 0.6
+        Progression.new(:item => Note::Progression.new, :tonic => tonic, :mode => mode, :length => l, :velocity => v)
+      end
+
+      #.........................................................................................................
+      def cp(tonic=[:C,4], mode=0, opts = {})
+        l = opts[:l] || 4; v = opts[:v] || 0.6
+        Progression.new(:item => Chord::Progression.new(:scale), :tonic => tonic, :mode => mode, :length => l, :velocity => v)
+      end
+
+      #.........................................................................................................
+      def pr(percs = acoustic_bass_drum, opts = {})
+        l = opts[:l] || 4; v = opts[:v] || 0.6
+        Perc.new(:percs => percs, :length => l, :velocity => v)
+      end
+
+    #### self
+    end
+
+    #...........................................................................................................
+    attr_reader :seq
+    
+    #...........................................................................................................
+    def initialize(seq)
+      @seq = [seq].flatten
+    end
+
+    #.........................................................................................................
+    def method_missing(meth, *args, &blk )
+      @seq = seq.map do |p|
+               p.respond_to?(meth) ? p.send(meth, *args, &blk) : p
+             end
+      self
+    end
+
+  #### Pattern
+  end
+
+#### Zgomot ::Comp
+end

data/lib/zgomot/comp/perc.rb

@@ -0,0 +1,94 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Perc
+    
+    #.........................................................................................................
+    PERC_MAP = {
+        :acoustic_bass_drum => [:B,1], 
+        :bass_drum_1        => [:C,2],  :side_stick     => [:Cs,2], :acoustic_snare => [:D,2],
+        :hand_clap          => [:Ds,2], :electric_snare => [:E,2],  :low_floor_tom  => [:F,2],
+        :closed_hi_hat      => [:Fs,2], :high_floor_tom => [:G,2],  :pedal_hi_hat   => [:Gs,2],
+        :low_tom            => [:A,2],  :open_hi_hat    => [:As,2], :low_mid_tom    => [:B,2],
+        :high_mid_tom       => [:C,3],  :crash_cymbal_1 => [:Cs,3], :high_tom       => [:D,3], 
+        :ride_cymbal_1      => [:Ds,3], :chinese_cymbal => [:E,3],  :ride_bell      => [:F,3], 
+        :tambourine         => [:Fs,3], :splash_cymbal  => [:G,3],  :cowbell        => [:Gs,3], 
+        :crash_cymbal_2     => [:A,3],  :vibraslap      => [:As,3], :ride_cymbal_2  => [:B,3],
+        :high_bongo         => [:C,4],  :low_bongo      => [:Cs,4], :mute_hi_conga  => [:D,4], 
+        :open_hi_conga      => [:Ds,4], :low_conga      => [:E,4],  :high_timbale   => [:F,4], 
+        :low_timbale        => [:Fs,4], :high_agogo     => [:G,4],  :low_agogo      => [:Gs,4], 
+        :cabasa             => [:A,4],  :maracas        => [:As,4], :short_whistle  => [:B,4],
+        :long_whistle       => [:C,5],  :short_guiro    => [:Cs,5], :long_guiro     => [:D,5],  
+        :claves             => [:Ds,5], :hi_woodblock   => [:E,5],  :low_woodblock  => [:F,5], 
+        :mute_cuica         => [:Fs,5], :open_cuica     => [:G,5],  :mute_triangle  => [:Gs,5], 
+        :open_triangle      => [:A,5],
+        :R                  => :R,      
+        }
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+    #### self
+    end
+    
+    #.........................................................................................................
+    attr_reader :percs, :length, :velocity, :time_scale
+  
+    #.........................................................................................................
+    def initialize(args)
+      @length, @velocity, @percs = args[:length], args[:velocity], [args[:percs]].flatten
+      @time_scale = 1.0
+    end
+
+    #.........................................................................................................
+    def pitches
+      percs.inject([]){|p,r| (m = Perc::PERC_MAP[r]).nil? ? p : p << m}
+    end
+    
+    #.........................................................................................................
+    def notes
+      @notes ||= pitches.map do |p| 
+                   Zgomot::Midi::Note.new(:pitch => p, :length => length, :velocity => velocity)
+                 end                          
+    end
+
+    #.........................................................................................................
+    # transforms
+    #.........................................................................................................
+    def bpm_scale!(v)
+      @time_scale = 1.0/v.to_f; self
+    end
+    
+    #.........................................................................................................
+    # channel and dispatch interface
+    #.........................................................................................................
+    def channel=(chan)
+      notes.each{|n| n.channel = chan}
+    end
+
+    #.........................................................................................................
+    def offset_time=(time)
+      notes.each{|n| n.offset_time = time}
+    end
+    
+    #.........................................................................................................
+    def time=(time)
+      notes.each{|n| n.time = time}
+    end
+
+    #.........................................................................................................
+    def length_to_sec
+      time_scale*Zgomot::Midi::Clock.whole_note_sec/length
+    end
+
+    #.........................................................................................................
+    def to_midi
+      notes.map{|n| n.to_midi}
+    end
+      
+  #### Scale
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/permutation.rb

@@ -0,0 +1,17 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Permutation
+      
+    #.........................................................................................................
+
+    #.........................................................................................................
+    def initialize
+    end
+      
+  #### Markov
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/pitch_class.rb

@@ -0,0 +1,63 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class PitchClass
+    
+    #.........................................................................................................
+    PITCH_CLASS = {
+      :C  => 0, 
+      :Cs => 1,
+      :D  => 2,
+      :Ds => 3,
+      :E  => 4,
+      :F  => 5,
+      :Fs => 6,
+      :G  => 7, 
+      :Gs => 8,
+      :A  => 9,
+      :As => 10,
+      :B  => 11 
+    }
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+      #.........................................................................................................
+      def next(pc, interval)
+        start_pos = PITCH_CLASS[to_value(pc)]
+        new(PITCH_CLASS.inject([]){|r,(c,p)|  p.eql?((start_pos+interval) % 12) ? r << c : r}.first) if start_pos
+      end
+    
+      #.........................................................................................................
+      def to_value(p)
+        p.kind_of?(PitchClass) ? p.value : p
+      end
+    
+    #### self  
+    end
+    
+    #.........................................................................................................
+    attr_reader :value
+  
+    #.........................................................................................................
+    def initialize(p)
+      raise(Zgomot::Error, "#{p} is invalid pitch class") unless PITCH_CLASS.include?(p)
+      @value = p
+    end
+
+    #.........................................................................................................
+    def <(p)
+      PITCH_CLASS[value] < PITCH_CLASS[self.class.to_value(p)]
+    end
+
+    #.........................................................................................................
+    def >(p)
+      PITCH_CLASS[value] > PITCH_CLASS[self.class.to_value(p)]
+    end
+            
+  #### PitchClass
+  end
+
+#### Zgomot::Comp 
+end