interval 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 YOUR NAME
+
+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.mkd

@@ -0,0 +1,17 @@
+# Interval
+
+Interval is a tiny library that provides simple musicial note pitch and interval arithmetic. 
+
+Observe:
+
+    >> p = Interval::Pitch.from_string("c")
+    >> i = Interval::Interval.from_string("M3")
+    >> p2 = p + i
+    >> p2.to_short_name
+    => "e"
+
+# Authors
+
+Nate Murray 2009
+
+based on code from GNU Solfege

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = "interval"
+GEM_VERSION = "0.0.1"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.author = "Nate Murray"
+  s.email = "nate@natemurray.com"
+  s.homepage = "http://www.xcombinator.com"
+  s.description = s.summary = "interval is a tiny library that provides simple musicial note pitch and interval arithmetic."
+  
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.mkd", "LICENSE"]
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README.mkd Rakefile) + Dir.glob("{lib,spec}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/lib/interval.rb

@@ -0,0 +1,318 @@
+class Array
+  def rand
+    self[super(self.length)]
+  end
+end
+
+module Interval
+  class Pitch
+    NOTE_NAMES = %w{c d e f g a b}
+    NOTE_NAMES_TO_I = {'c' => 0, 'd' => 1, 'e' => 2, 'f' => 3, 'g' => 4, 'a' => 5, 'b' => 6}
+
+    attr_accessor :octave
+    attr_accessor :notename_i
+    attr_accessor :accidental
+
+    class << self
+      def from_string(str)
+        p = new
+        ary = str.split(//) 
+        possible_notename = ary.shift.downcase
+        raise "invalid notename: #{possible_notename}" unless Pitch::NOTE_NAMES_TO_I.has_key?(possible_notename)
+        p.notename_i = note_s_to_i(possible_notename)
+
+        octave = 0
+        accidental = 0
+        while(char = ary.shift)
+          octave = octave + 1 if char == "'"
+          octave = octave - 1 if char == ","
+          accidental = accidental + 1 if char == "#"
+          accidental = accidental - 1 if char == "b"
+        end
+        p.octave = octave
+        p.accidental = accidental
+        p
+      end
+
+      def from_int(midiint)
+        p = new
+        p.octave = (midiint - 48) / 12
+        p.notename_i = {0 => 0, 1 => 0, 
+                      2 => 1, 3 => 1, 
+                      4 => 2, 
+                      5 => 3, 6 => 3, 
+                      7 => 4, 8 => 4,
+                      9 => 5, 10 => 5, 
+                      11 => 6}[midiint % 12]
+        p.accidental = midiint - (p.octave + 4) * 12 - ([0, 2, 4, 5, 7, 9, 11][p.notename_i])
+        p
+      end
+
+      def notename_s(s)
+        NOTE_NAMES[s]
+      end
+
+      # if normal=true then only return notes you would "normally" see. 
+      # what is the word for that, natural?
+      def random(normal=false)
+        p = new
+        p.notename_i = NOTE_NAMES_TO_I.values.rand
+        p.octave = 0
+
+        accidentals = []
+        if normal
+          accidentals = case p.notename
+                        when 'c', 'f' 
+                          [0, 1]
+                        when 'e', 'b'
+                          [-1, 0]
+                        else [-1, 0, 1]
+                        end
+        else
+          accidentals = [-1, 0, 1]
+        end
+        p.accidental = accidentals.rand
+        p
+      end
+
+      # def notename_s(s)
+      #   {0 => 'c', 1 => 'c', 
+      #    2 => 'd', 3 => 'd', 
+      #    4 => 'e', 
+      #    5 => 'f', 6 => 'f', 
+      #    7 => 'g', 8 => 'g', 
+      #    9 => 'a', 10 => 'a', 
+      #    11 => 'c'}[s]
+      # end
+
+      # i dont think this is right. also, just start storing notename as an integer. make it a lot easier
+      # this isn't notename_i!!! this is some strange mididint accidental array. todo, redo this
+      # def pitchy(i)
+      #   notes = 
+      #   {'c' => 0,
+      #    'd' => 2,
+      #    'e' => 4,
+      #    'f' => 5,
+      #    'g' => 6,
+      #    'a' => 9,
+      #    'b' => 11}
+      #   notes[i]
+      # end
+
+      # def note_i_to_s(i)
+        # NOTENAMES[i]
+      # end
+
+      def note_s_to_i(s)
+        NOTE_NAMES_TO_I[s]
+      end
+
+      def accidental_name(i)
+        names =
+        { -2 => " double flat",
+          -1 => " flat",
+          0 => "",
+          1 => " sharp",
+          2 => " double sharp" }
+        names[i]
+      end
+    end
+
+    def semitone_pitch
+      [0, 2, 4, 5, 7, 9, 11][notename_i] + accidental + (octave * 12) + 48
+    end
+
+    # def notename_i
+      # self.class.notename_i(self.notename)
+    # end
+
+    # def notename_i=(i)
+    # end
+
+    def notename
+      self.class.notename_s(notename_i)
+    end
+
+    def to_long_name
+      "%s%s" % [notename.upcase, self.class.accidental_name(accidental)]
+    end
+
+    def to_short_name
+      "%s%s" % [notename, accidental > 0 ? ('#' * accidental.abs) : ('b' * accidental.abs)]
+    end
+
+    def to_s
+      to_short_name
+    end
+
+    def +(other)
+      if other.kind_of?(Interval)
+        plus_interval(other)
+      else
+        raise "todo"
+      end
+    end
+
+    def -(other)
+      if other.kind_of?(Interval)
+        minus_interval(other)
+      else
+        raise "todo"
+      end
+    end
+
+    private
+    def plus_interval(other)
+      r = self.dup
+      _p = r.semitone_pitch
+      r.notename_i = r.notename_i + (other.interval - 1) * other.direction
+      r.octave = r.octave + r.notename_i / 7 + other.octave * other.direction
+      r.notename_i = r.notename_i % 7
+      _diff = r.semitone_pitch - _p
+      r.accidental = r.accidental + (other.to_i - _diff)
+      r
+    end
+    def minus_interval(other)
+      other2 = other.dup
+      other2.direction = other2.direction * -1
+      plus_interval(other2)
+    end
+  end
+
+  class Interval
+    attr_accessor :direction # value to be 1 or -1
+    attr_accessor :octave # 0, 1, 2, 3 etc
+    attr_accessor :interval # 1:unison, 2:second, ... 7: seventh
+        # unison:              dim   perfect   aug
+        # second:  -2:dim -1:minor 0:major   1:aug
+        # third:      dim    minor   major     aug
+        # fourth:              dim   perfect   aug
+        # fifth:               dim   perfect   aug
+        # sixth:      dim    minor   major     aug
+        # seventh:    dim    minor   major     aug
+    attr_accessor :mod # -2:dim -1:minor 0:major   1:aug
+
+    QUALITY_LONG_NAMES = {
+      'p' => 'Perfect',
+      'dd' => 'Doubly-diminished',
+      'd' => 'Diminished',
+      'm' => 'Minor',
+      'M' => 'Major',
+      'a' => 'Augmented',
+      'aa' => 'Doubly-augmented',
+    }
+
+    SIZE_LONG_NAMES = %w{x 
+      Unison
+      Second
+      Third
+      Fourth
+      Fifth
+      Sixth
+      Seventh
+      Octave
+    }
+
+    class << self
+      # Number of
+      # semitones	name	enharmonic notes
+      # 0	Perfect Unison (P1)	Diminished second (dim2)
+      # 1	Minor second (m2)	Augmented unison (aug1)
+      # 2	Major second (M2)	Diminished third (dim3)
+      # 3	Minor third (m3)	Augmented second (aug2)
+      # 4	Major third (M3)	Diminished fourth (dim4)
+      # 5	Perfect fourth (P4)	Augmented third (aug3)
+      # 6	Tritone	Augmented fourth (aug4) Diminished fifth (dim5)
+      # 7	Perfect fifth (P5)	Diminished sixth (dim6)
+      # 8	Minor sixth (m6)	Augmented fifth (aug5)
+      # 9	Major sixth (M6)	Diminished seventh (dim7)
+      # 10	Minor seventh (m7)	Augmented sixth (aug6)
+      # 11	Major seventh (M7)	Diminished octave (dim8)
+      # 12	Perfect octave (P8)	Augmented seventh (aug7)
+
+      # unison  p1
+      # second  m2 M2
+      # third   m3 M3
+      # fourth  p4
+      # fifth   p5
+      # sixth   m6 M6
+      # seventh m7 M7
+      # octave  p8
+      def from_string(str)
+        i = new
+        i.direction = str[0,1] == "-" ? -1 : 1
+        str =~ /([mMdap])(\d+)/
+        modifier, size = $1,$2
+        raise "#{str} is not a valid interval" unless modifier && size
+        size = size.to_i
+        if size <= 7 
+          i.octave = 0
+        else
+          i.octave = size / 8 # ?
+        end
+        i.interval = size - (i.octave * 7)
+
+        i.mod = case i.interval 
+        when 2, 3, 6, 7  
+          {"d" => -2, "m" => -1, "M" => 0, "a" => 1}[modifier]
+        when 1, 4, 5, 8  
+          {"d" => -1, "p" => 0, "a" => 1}[modifier]
+        else
+          raise "unknown interval"
+        end
+
+        i
+      end
+
+      def from_int(number)
+        interval = new
+        interval.direction = number >= 0 ? 1 : -1
+        interval.octave = number.abs / 12
+        mod, intervali = *([
+               [0, 1],          # unison
+               [-1, 2], [0, 2], # second
+               [-1, 3], [0, 3], # third
+               [0, 4],          # fourth
+               [-1, 5],         # dim 5, tritone
+               [0, 5],          # fifth
+               [-1, 6], [0, 6], # sixth
+               [-1, 7], [0, 7]])[number.abs % 12] # seventh
+        interval.mod = mod 
+        interval.interval = intervali
+        interval
+      end
+
+
+    end
+
+    def to_long_name
+      short_modifier = case self.interval 
+      when 2, 3, 6, 7  
+        {-2 => "d", -1 => "m", 0 => "M", 1 => "a"}[self.mod]
+      when 1, 4, 5, 8  
+        {-1 => "d",  0 => "p", 1 => "a"}[self.mod]
+      else
+        raise "unknown interval"
+      end
+
+      long_modifier = QUALITY_LONG_NAMES[short_modifier]
+      size = SIZE_LONG_NAMES[self.interval]
+      size = "Octave" if interval == 1 && octave > 0 
+
+      # tritone (diminished fifth) has the following: todo
+      #<Interval::Interval:0x2efa90 @mod=0, @interval=5, @octave=0, @direction=1>
+
+      return "%s %s" % [long_modifier, size]
+
+    end
+
+    def to_s
+      to_long_name
+    end
+
+    def to_i
+      return ([0, 0, 2, 4, 5, 7, 9, 11][interval] + octave * 12 + mod) * direction
+    end
+ 
+  end
+end

data/spec/interval_spec.rb

@@ -0,0 +1,402 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+require File.dirname(__FILE__) + '/spec_helper'
+require "interval"
+require "pp"
+
+include Interval
+
+describe "interval" do
+  it "should create from int" do
+    test_set = {
+      0 => "Perfect Unison",
+      1 => "Minor second",
+      2 => "Major second",
+      3 => "Minor third",
+      4 => "Major third",
+      5 => "Perfect fourth",
+      6 => "Diminished fifth",
+      7 => "Perfect fifth",
+      8 => "Minor sixth",
+      9 => "Major sixth",
+      10 => "Minor seventh",
+      11 => "Major seventh",
+      12 => "Perfect octave"}
+
+    test_set.keys.sort.each do |k|
+      value = test_set[k]
+      v = Interval::Interval.from_int(k)
+      v.to_long_name.downcase.should == value.downcase
+      v.to_i.should == k
+    end
+  end
+
+  it "should create from string" do
+    test_set = [
+      ["p1", "Perfect Unison"],
+      ["m2", "Minor second"],
+      ["M2", "Major second"],
+      ["m3", "Minor third"],
+      ["M3", "Major third"],
+      ["p4", "Perfect fourth"],
+      ["d5", "Diminished fifth"],
+      ["p5", "Perfect fifth"],
+      ["m6", "Minor sixth"],
+      ["M6", "Major sixth"],
+      ["m7", "Minor seventh"],
+      ["M7", "Major seventh"],
+      ["p8", "Perfect octave"]]
+    test_set.each do |key,value|
+      v = Interval::Interval.from_string(key)
+      v.to_long_name.downcase.should == value.downcase
+    end
+  end
+end
+
+describe "pitch" do
+  it "should create from string and integer" do
+
+    p = Interval::Pitch.from_string("c")
+    p.notename_i.should == 0
+    p.notename.should == "c"
+    p.accidental.should == 0
+    p.octave.should == 0
+
+    p2 = Interval::Pitch.from_int(p.semitone_pitch)
+    p2.notename.should == "c"
+    p2.accidental.should == 0
+    p2.octave.should == 0
+
+    p2.to_long_name.should == "C"
+    p2.to_short_name.should == "c"
+
+    p.semitone_pitch.should == p2.semitone_pitch
+
+    p = Interval::Pitch.from_string("c#'")
+    p.notename.should == "c"
+    p.accidental.should == 1
+    p.octave.should == 1
+
+    p2 = Interval::Pitch.from_int(p.semitone_pitch)
+    p2.notename.should == "c"
+    p2.accidental.should == 1
+    p2.octave.should == 1
+
+    p2.to_long_name.should == "C sharp"
+    p2.to_short_name.should == "c#"
+
+    p.semitone_pitch.should == p2.semitone_pitch
+ 
+    p = Interval::Pitch.from_string("eb,,")
+    p.notename.should == "e"
+    p.accidental.should == -1 
+    p.octave.should == -2 
+
+    p2 = Interval::Pitch.from_int(p.semitone_pitch)
+    
+    p2.notename.should == "d"
+    p2.accidental.should == 1 
+    p2.octave.should == -2 
+
+    p2.to_long_name.should == "D sharp"
+    p2.to_short_name.should == "d#"
+
+    p.semitone_pitch.should == p2.semitone_pitch
+  end
+
+  describe "adding intervals" do
+
+  it "should be able to be added to an interval" do
+    p = Pitch.from_string("c")
+    i = Interval::Interval.from_string("M3")
+    p2 = p + i
+    p2.to_short_name.should == "e"
+  end
+
+  it "should add minor seconds" do
+    i = Interval::Interval.from_string("m2")
+    [["c", "db"],
+     ["f", "gb"],
+     ["Bb", "cb"],
+     ["eb", "fb"],
+     ["ab", "bbb"],
+     ["db", "ebb"],
+     ["gb", "abb"],
+     ["f#", "g"],
+     ["b", "c"],
+     ["e", "f"],
+     ["a", "bb"],
+     ["d", "eb"],
+     ["g", "ab"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add major seconds" do
+    i = Interval::Interval.from_string("M2")
+    [["c", "d"],
+     ["f", "g"],
+     ["Bb", "c"],
+     ["eb", "f"],
+     ["ab", "bb"],
+     ["db", "eb"],
+     ["gb", "ab"],
+     ["f#", "g#"],
+     ["b", "c#"],
+     ["e", "f#"],
+     ["a", "b"],
+     ["d", "e"],
+     ["g", "a"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add minor thirds" do
+    i = Interval::Interval.from_string("m3")
+    [["c", "eb"],
+     ["f", "ab"],
+     ["Bb", "db"],
+     ["eb", "gb"],
+     ["ab", "cb"],
+     ["db", "fb"],
+     ["gb", "bbb"],
+     ["f#", "a"],
+     ["b", "d"],
+     ["e", "g"],
+     ["a", "c"],
+     ["d", "f"],
+     ["g", "bb"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add major thirds" do
+    i = Interval::Interval.from_string("M3")
+    [["c", "e"],
+     ["f", "a"],
+     ["Bb", "d"],
+     ["eb", "g"],
+     ["ab", "c"],
+     ["db", "f"],
+     ["gb", "bb"],
+     ["f#", "a#"],
+     ["b", "d#"],
+     ["e", "g#"],
+     ["a", "c#"],
+     ["d", "f#"],
+     ["g", "b"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add perfect fourths" do
+    i = Interval::Interval.from_string("p4")
+    [["c", "f"],
+     ["f", "bb"],
+     ["Bb", "eb"],
+     ["eb", "ab"],
+     ["ab", "db"],
+     ["db", "gb"],
+     ["gb", "cb"],
+     ["f#", "b"],
+     ["b", "e"],
+     ["e", "a"],
+     ["a", "d"],
+     ["d", "g"],
+     ["g", "c"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add diminished fifths (tritone)" do
+    i = Interval::Interval.from_string("d5")
+    [["c", "gb"],
+     ["f", "cb"],
+     ["Bb", "fb"],
+     ["eb", "bbb"],
+     ["ab", "ebb"],
+     ["db", "abb"],
+     ["gb", "dbb"],
+     ["f#", "c"],
+     ["b", "f"],
+     ["e", "bb"],
+     ["a", "eb"],
+     ["d", "ab"],
+     ["g", "db"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add perfect fifths" do
+    i = Interval::Interval.from_string("p5")
+    [["c", "g"],
+     ["f", "c"],
+     ["Bb", "f"],
+     ["eb", "bb"],
+     ["ab", "eb"],
+     ["db", "ab"],
+     ["gb", "db"],
+     ["f#", "c#"],
+     ["b", "f#"],
+     ["e", "b"],
+     ["a", "e"],
+     ["d", "a"],
+     ["g", "d"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add minor sixths" do
+    i = Interval::Interval.from_string("m6")
+    [["c", "ab"],
+     ["f", "db"],
+     ["Bb", "gb"],
+     ["eb", "cb"],
+     ["ab", "fb"],
+     ["db", "bbb"],
+     ["gb", "ebb"],
+     ["f#", "d"],
+     ["b", "g"],
+     ["e", "c"],
+     ["a", "f"],
+     ["d", "bb"],
+     ["g", "eb"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add major sixths" do
+    i = Interval::Interval.from_string("M6")
+    [["c", "a"],
+     ["f", "d"],
+     ["Bb", "g"],
+     ["eb", "c"],
+     ["ab", "f"],
+     ["db", "bb"],
+     ["gb", "eb"],
+     ["f#", "d#"],
+     ["b", "g#"],
+     ["e", "c#"],
+     ["a", "f#"],
+     ["d", "b"],
+     ["g", "e"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add minor sevenths" do
+    i = Interval::Interval.from_string("m7")
+    [["c", "bb"],
+     ["f", "eb"],
+     ["Bb", "ab"],
+     ["eb", "db"],
+     ["ab", "gb"],
+     ["db", "cb"],
+     ["gb", "fb"],
+     ["f#", "e"],
+     ["b", "a"],
+     ["e", "d"],
+     ["a", "g"],
+     ["d", "c"],
+     ["g", "f"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add major sevenths" do
+    i = Interval::Interval.from_string("M7")
+    [["c", "b"],
+     ["f", "e"],
+     ["Bb", "a"],
+     ["eb", "d"],
+     ["ab", "g"],
+     ["db", "c"],
+     ["gb", "f"],
+     ["f#", "e#"],
+     ["b", "a#"],
+     ["e", "d#"],
+     ["a", "g#"],
+     ["d", "c#"],
+     ["g", "f#"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  it "should add perfect octaves" do
+    i = Interval::Interval.from_string("p8")
+    [["c", "c"],
+     ["f", "f"],
+     ["Bb", "bb"],
+     ["eb", "eb"],
+     ["ab", "ab"],
+     ["db", "db"],
+     ["gb", "gb"],
+     ["f#", "f#"],
+     ["b", "b"],
+     ["e", "e"],
+     ["a", "a"],
+     ["d", "d"],
+     ["g", "g"]
+    ].each do |pitch, new_pitch|
+       (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+     end
+  end
+
+  describe "adding enharmonic intervals" do
+    it "should add diminished seconds" do
+      i = Interval::Interval.from_string("d2")
+      [["c", "dbb"],
+       ["f", "gbb"],
+       ["Bb", "cbb"],
+       ["eb", "fbb"],
+       ["ab", "bbbb"],
+       ["db", "ebbb"],
+       ["gb", "abbb"],
+       ["f#", "gb"],
+       ["b", "cb"],
+       ["e", "fb"],
+       ["a", "bbb"],
+       ["d", "ebb"],
+       ["g", "abb"]
+      ].each do |pitch, new_pitch|
+         (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+       end
+    end
+  end
+
+  describe "finding intervals below" do
+    it "should subtract major thirds" do
+      i = Interval::Interval.from_string("-M3")
+      [["c", "ab"],
+       ["f", "db"],
+       ["Bb", "gb"],
+       ["eb", "cb"],
+       ["ab", "fb"],
+       ["db", "bbb"],
+       ["gb", "ebb"],
+       ["f#", "d"],
+       ["b", "g"],
+       ["e", "c"],
+       ["a", "f"],
+       ["d", "bb"],
+       ["g", "eb"]
+      ].each do |pitch, new_pitch|
+         (Pitch.from_string(pitch) + i).to_short_name.should == new_pitch
+       end
+    end
+  end
+
+
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: interval
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nate Murray
+autorequire: interval
+bindir: bin
+cert_chain: []
+
+date: 2009-11-17 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: interval is a tiny library that provides simple musicial note pitch and interval arithmetic.
+email: nate@natemurray.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.mkd
+- LICENSE
+files: 
+- LICENSE
+- README.mkd
+- Rakefile
+- lib/interval.rb
+- spec/interval_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://www.xcombinator.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: interval is a tiny library that provides simple musicial note pitch and interval arithmetic.
+test_files: []
+