music_theory 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c15cd87fabd67ca0ede6f68605d580bc3cc7ba2d
+  data.tar.gz: 0e93f91ed13aca5f3fc89e35b5084571bf3b7333
+SHA512:
+  metadata.gz: 6b92d549db767e82445777e9224badc158750ec740a2eaf292fc5071f2ffc944b6355907423b1e0e8c4269a6c6f52614f1d3db8c6c4f21a9ef53be316d7cf19d
+  data.tar.gz: 7b52db9f8d81ed3bce32b9ce275b81087e8d388a92a196f0691c78a4651ce883497eabc73638002fe91d26383d40113a26c7c7c7f7f38b1789c6ba6c1385c59d

data/.gitignore

@@ -0,0 +1,20 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version
+.ruby-gemset
+
+*.wav
+presentation*
+samples

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in music_theory.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Ben Eggett
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# MusicTheory
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'music_theory'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install music_theory
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/music_theory/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/music_theory.rb

@@ -0,0 +1,18 @@
+require 'wavefile'
+require 'active_support/all'
+
+require "music_theory/version"
+require "music_theory/note"
+require "music_theory/octave"
+require "music_theory/scale"
+require "music_theory/modes"
+require "music_theory/third"
+require "music_theory/chord"
+require "music_theory/harmonize"
+require "music_theory/output"
+require "music_theory/play"
+
+
+module MusicTheory
+
+end

data/lib/music_theory/chord.rb

@@ -0,0 +1,37 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Chord
+    include MusicTheory::Output
+
+    attr_accessor :third, :duration, :all_notes, :output_file_name
+
+    def initialize(third, options = {})
+      @duration = options[:duration] || 2.0
+      @third = third
+      @output_file_name = options[:output_file_name] || 'chord' # File name to write (without extension)
+    end
+
+    def flatten_third
+       third.all_notes.each {|note| note.duration = duration}
+       new_samples = []
+       sample_count = third.all_notes.first.samples.count
+       third.samples.in_groups_of(sample_count).each do |group|
+         group.each_with_index do |value, i|
+           new_samples[i] ||= 0
+           new_samples[i] +=  value
+         end
+       end
+
+       max = new_samples.map {|s| s.abs }.max
+       multiplier = 1.0 / max
+       new_samples.map!{ |s| multiplier * s }
+    end
+
+
+    def samples
+      flatten_third
+    end
+
+  end
+end

data/lib/music_theory/harmonize.rb

@@ -0,0 +1,26 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Harmonize
+    include MusicTheory::Output
+
+    attr_accessor :samples
+
+    def initialize(*things_to_flatten)
+      @samples = []
+      [*things_to_flatten].each do |group|
+        group.each_with_index do |value, i|
+         @samples[i] ||= 0
+         @samples[i] +=  value
+        end
+      end
+       max = @samples.map {|s| s.abs }.max
+       multiplier = 1.0 / max
+       @samples.map!{ |s| multiplier * s }
+    end
+
+
+
+
+  end
+end

data/lib/music_theory/modes.rb

@@ -0,0 +1,33 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Modes
+    include MusicTheory::Output
+    S = 1
+    T = 2
+    I = [T, T, S, T, T, T, S]
+    II = I.rotate
+    III = I.rotate(2)
+    IV = I.rotate(3)
+    V = I.rotate(4)
+    VI = I.rotate(5)
+    VII = I.rotate(6)
+    CHROMATIC = [S,S,S,S,S,S,S,S,S,S,S,S]
+
+    # Map the music theory names as class methods
+
+    def self.ionian; I; end
+    self.singleton_class.send(:alias_method, :major, :ionian)
+    def self.dorian; II; end
+    def self.phrygian; III; end
+    def self.lydian; IV; end
+    def self.mixolydian; V; end
+    def self.aeolian; VI; end
+    self.singleton_class.send(:alias_method, :minor, :aeolian)
+    def self.locrian; VII; end
+    def self.chromatic; CHROMATIC; end
+
+
+  end
+
+end

data/lib/music_theory/note.rb

@@ -0,0 +1,59 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Note
+    include MusicTheory::Output
+    attr_accessor :frequency,  :duration, :output_file_name, :distort
+
+    def initialize(options = {})
+      @frequency        = options[:frequency].to_f || 220.0          # Note frequency in Hz
+      @duration         = options[:duration] ||  1.0            # Number of seconds per note
+      @distort          = options[:distort] || false
+      @output_file_name = options[:output_file_name] || 'note'  # File name to write (without extension)
+    end
+
+    def total_frames
+      # We want 1 second of the note, so we need 1 second's worth of frames
+      (duration * sample_rate).to_i
+    end
+
+    def cycles_per_frame
+      # each frame, we want this fraction of a cycle:
+      frequency / sample_rate
+    end
+
+    def sine_wave_cycle
+      # A cycle is a full sine wave, which is 2π radians:
+      2 * Math::PI * cycles_per_frame
+    end
+
+    def samples
+      # So to create a note that's one second long, we need to write out all the samples in the sine waves
+      phase = 0
+      samples = total_frames.times.map do
+        sample = (Math.sin phase).to_f
+        phase += sine_wave_cycle
+        sample
+      end
+      samples = distort!(samples) if distort
+      samples
+    end
+
+    def distort!(samples)
+      samples.map do |sample|
+        negative = (sample) < 0
+        sample *= 8.to_f
+        if sample.abs > 5
+          sample = 5
+          sample *= -1 if negative
+        end
+        sample /= 8.to_f
+      end
+    end
+
+    def scale
+
+    end
+  end
+
+end

data/lib/music_theory/octave.rb

@@ -0,0 +1,35 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Octave
+    include MusicTheory::Output
+    attr_accessor :starting_note, :number_of_octaves, :direction, :output_file_name, :all_notes
+
+    def initialize(options = {})
+      @starting_note    = options[:starting_note] || MusicTheory::Note.new      # Note to start on
+      @number_of_octaves= options[:number_of_octaves] || 2                      # Number of octaves to repeat
+      @direction        = options[:direction] ||  'asc'                         # Number of seconds per note
+      @output_file_name = options[:output_file_name] || 'octave' # File name to write (without extension)
+      @all_notes = []
+      all_notes << starting_note
+      number_of_octaves.to_i.times do
+        new_note = all_notes.last.clone
+        if direction == 'asc'
+          new_note.frequency = all_notes.last.frequency * 2
+        elsif direction == 'desc'
+          new_note.frequency = all_notes.last.frequency / 2
+        end
+        all_notes << new_note unless new_note.frequency > 20000
+      end
+    end
+
+    def samples
+      all_notes.map(&:samples).flatten
+    end
+
+    def sample_rate
+      starting_note.sample_rate
+    end
+  end
+
+end

data/lib/music_theory/output.rb

@@ -0,0 +1,30 @@
+module MusicTheory
+  module Output
+
+    def sample_rate
+      22050
+    end
+
+    def format
+      WaveFile::Format.new :mono, :pcm_16, sample_rate
+    end
+
+    def buffer_format
+      WaveFile::Format.new :mono, :float, sample_rate
+    end
+
+    def output_track
+      WaveFile::Writer.new "#{output_file_name || 'music'}.wav", format do |writer|
+        buffer = WaveFile::Buffer.new samples, buffer_format
+        writer.write buffer
+      end
+    end
+
+    def play
+      output_track # unless File.file?("#{output_file_name}.wav")
+      `afplay #{output_file_name}.wav`
+      nil
+    end
+
+  end
+end

data/lib/music_theory/play.rb

@@ -0,0 +1,20 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Play
+    include MusicTheory::Output
+
+    attr_accessor :samples, :output_file_name, :playable_music
+    def initialize(playable_music = [], options = {} )
+      @playable_music = playable_music
+      @output_file_name = options[:output_file_name] || 'music'
+      extract_samples
+      play
+    end
+
+    def extract_samples
+      @samples = playable_music.map  { |music| music.samples }.flatten
+    end
+  end
+
+end

data/lib/music_theory/scale.rb

@@ -0,0 +1,70 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Scale
+    include MusicTheory::Output
+    attr_accessor :starting_note, :number_of_octaves, :direction, :output_file_name, :all_notes, :scale_type, :scale_notes, :distort, :duration, :frequency, :sample_rate
+
+    def initialize(scale_type  = :major, options = {})
+      @scale_type = scale_type
+      @distort          = options[:distort] || false
+      @duration         = options[:duration] || 0.5
+      @frequency        = options[:frequency] || 220.0
+      @starting_note    = create_new_note     # Note to start on
+
+      @number_of_octaves= options[:number_of_octaves] || 2                      # Number of octaves to repeat
+      @direction        = options[:direction] ||  'asc'                         # Number of seconds per note
+      @output_file_name = options[:output_file_name] || 'scale' # File name to write (without extension)
+      set_all_notes
+      set_scale_notes
+    end
+
+    def third
+      third ||= MusicTheory::Third.new self
+    end
+
+    def chord
+      third.chord
+    end
+
+    def twelth_root_of_two
+      (2 ** (1.0/12))
+    end
+
+    def mode
+       MusicTheory::Modes.send(scale_type)
+    end
+
+    def set_scale_notes
+      @scale_notes = [all_notes.first]
+      note_index = 0
+      mode.each do |interval|
+        note_index +=  interval
+        scale_notes << all_notes[note_index]
+      end
+    end
+
+    def create_new_note
+      MusicTheory::Note.new( frequency: frequency, duration: duration, distort: distort)
+    end
+
+    def set_all_notes
+      @all_notes = [@starting_note]
+      12.times do
+        new_note = create_new_note
+        new_note.frequency  = (all_notes.last.frequency * twelth_root_of_two)
+        all_notes << new_note
+      end
+    end
+
+    def samples
+      scale_notes.map(&:samples).flatten
+    end
+
+    def sample_rate
+      starting_note.sample_rate
+    end
+
+  end
+
+end

data/lib/music_theory/third.rb

@@ -0,0 +1,37 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Third
+    include MusicTheory::Output
+
+    attr_accessor :scale, :all_notes
+
+    def initialize(scale)
+      @scale = scale
+      @all_notes  = [@scale.scale_notes.first]
+      current = 0
+      double_scale_notes = @scale.scale_notes * 2
+      @scale.mode.in_groups_of(2, false) do |group|
+        current += group.sum
+        all_notes << double_scale_notes[current]
+      end
+      all_notes.uniq! {|note| note.frequency}
+      all_notes.sort_by! {|note| note.frequency}
+    end
+
+
+    def output_file_name
+      scale.output_file_name || 'thirds'
+    end
+
+    def samples
+      all_notes.map(&:samples).flatten
+      # chord_samples
+    end
+
+    def chord
+      chord ||= MusicTheory::Chord.new self
+    end
+
+  end
+end

data/lib/music_theory/transpose.rb

@@ -0,0 +1,26 @@
+require 'music_theory/output'
+
+module MusicTheory
+  class Transpose
+    include MusicTheory::Output
+
+    attr_accessor :samples
+
+    def initialize(*things_to_flatten)
+      @samples = []
+      [*things_to_flatten].each do |group|
+        group.each_with_index do |value, i|
+         @samples[i] ||= 0
+         @samples[i] +=  value
+        end
+      end
+       max = @samples.map {|s| s.abs }.max
+       multiplier = 1.0 / max
+       @samples.map!{ |s| multiplier * s }
+    end
+
+
+
+
+  end
+end

data/lib/music_theory/version.rb

@@ -0,0 +1,3 @@
+module MusicTheory
+  VERSION = "0.0.1"
+end

data/music_theory.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'music_theory/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "music_theory"
+  spec.version       = MusicTheory::VERSION
+  spec.authors       = ["Ben Eggett"]
+  spec.email         = ["beneggett@gmail.com"]
+  spec.summary       = %q{Music theory with ruby}
+  spec.description   = %q{Create music with pure ruby goodness}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "wavefile"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: music_theory
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Eggett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: wavefile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Create music with pure ruby goodness
+email:
+- beneggett@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/music_theory.rb
+- lib/music_theory/chord.rb
+- lib/music_theory/harmonize.rb
+- lib/music_theory/modes.rb
+- lib/music_theory/note.rb
+- lib/music_theory/octave.rb
+- lib/music_theory/output.rb
+- lib/music_theory/play.rb
+- lib/music_theory/scale.rb
+- lib/music_theory/third.rb
+- lib/music_theory/transpose.rb
+- lib/music_theory/version.rb
+- music_theory.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Music theory with ruby
+test_files: []