mtk 0.0.1

data/spec/mtk/pitch_class_set_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe MTK::PitchClassSet do
+
+  let(:pitch_classes) { [C,E,G] }
+  let(:pitch_class_set) { PitchClassSet.new(pitch_classes) }
+
+  it "is Enumerable" do
+    pitch_class_set.should be_a Enumerable
+  end
+
+  describe "#pitch_classes" do
+    it "is the list of pitch_classes contained in this set" do
+      pitch_class_set.pitch_classes.should == pitch_classes
+    end
+
+    it "is immutable" do
+      lambda { pitch_class_set.pitch_classes << D }.should raise_error
+    end
+
+    it "does not affect the immutabilty of the pitch class list used to construct it" do
+      pitch_classes << D
+      pitch_classes.length.should == 4
+    end
+
+    it "is not affected by changes to the pitch class list used to construct it" do
+      pitch_class_set # force construction before we modify the pitch_classes array
+      pitch_classes << D
+      pitch_class_set.pitch_classes.length.should == 3
+    end
+
+    it "does not include duplicates" do
+      PitchClassSet.new([C, E, G, C]).pitch_classes.should == [C, E, G]
+    end
+
+    it "sorts the pitch_classes (C to B)" do
+      PitchClassSet.new([B, E, C]).pitch_classes.should == [C, E, B]
+    end
+  end
+
+  describe "#to_a" do
+    it "is equal to #pitch_classes" do
+      pitch_class_set.to_a.should == pitch_class_set.pitch_classes
+    end
+
+    it "is mutable" do
+      (pitch_class_set.to_a << Bb).should == [C, E, G, Bb]
+    end
+  end
+
+  describe "#each" do
+    it "yields each pitch_class" do
+      pcs = []
+      pitch_class_set.each{|pc| pcs << pc }
+      pcs.should == pitch_classes
+    end
+  end
+
+  describe "#map" do
+    it "returns a PitchClassSet with each PitchClass replaced with the results of the block" do
+      pitch_class_set.map{|pc| pc + 2}.should == [D, Gb, A]
+    end
+  end
+
+  describe "#normal_order" do
+    it "permutes the set so that the first and last pitch classes are as close together as possible" do
+      PitchClassSet.new([E,A,C]).normal_order.should == [A,C,E]
+    end
+
+    it "breaks ties by minimizing the distance between the first and second-to-last pitch class" do
+      # 0,4,8,9,11
+      PitchClassSet.new([C,E,Ab,A,B]).normal_order.should == [Ab,A,B,C,E]
+    end
+
+  end
+
+  describe "#normal_form" do
+    it "is transposes the #normal_order so that the first pitch class set is 0 (C)" do
+      PitchClassSet.new([E,A,C]).normal_form.should == [0,3,7]
+    end
+
+    it "is invariant across reorderings of the pitch classes" do
+      PitchClassSet.new([C,E,G]).normal_form.should == [0,4,7]
+      PitchClassSet.new([E,C,G]).normal_form.should == [0,4,7]
+      PitchClassSet.new([G,E,C]).normal_form.should == [0,4,7]
+    end
+
+    it "is invariant across transpositions" do
+      PitchClassSet.new([C,Eb,G]).normal_form.should == [0,3,7]
+      PitchClassSet.new([Db,E,Ab]).normal_form.should == [0,3,7]
+      PitchClassSet.new([Bb,F,Db]).normal_form.should == [0,3,7]
+    end
+  end
+
+  describe ".span_for" do
+    pending
+  end
+
+  describe ".span_between" do
+    pending
+  end
+
+end

data/spec/mtk/pitch_class_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe MTK::PitchClass do
+
+  let(:names) {
+    [
+        ['B#', 'C', 'Dbb'],
+        ['B##', 'C#', 'Db'],
+        ['C##', 'D', 'Ebb'],
+        ['D#', 'Eb', 'Fbb'],
+        ['D##', 'E', 'Fb'],
+        ['E#', 'F', 'Gbb'],
+        ['E##', 'F#', 'Gb'],
+        ['F##', 'G', 'Abb'],
+        ['G#', 'Ab'],
+        ['G##', 'A', 'Bbb'],
+        ['A#', 'Bb', 'Cbb'],
+        ['A##', 'B', 'Cb']
+    ].flatten
+  }
+
+  describe 'NAMES' do
+    it "is the 12 note names in western chromatic scale" do
+      PitchClass::NAMES =~ ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']
+    end
+  end
+
+  describe '.from_s' do
+    context "the argument is a valid name" do
+      it "returns a PitchClass" do
+        names.each { |name| PitchClass.from_s(name).should be_a PitchClass }
+      end
+      it "returns an object with that name" do
+        names.each { |name| PitchClass.from_s(name).name.should == name }
+      end
+      it "ignores case" do
+        for name in names
+          PitchClass.from_s(name.upcase).name.should == name
+          PitchClass.from_s(name.downcase).name.should == name
+        end
+      end
+    end
+    context "the argument is not a valid name" do
+      it "returns nil, if the name doesn't exist" do
+        PitchClass.from_s('z').should be_nil
+      end
+    end
+  end
+
+  describe '.from_name' do
+    it "acts like from_s" do
+      for name in ['C', 'bbb', 'z']
+        PitchClass.from_name(name).should == PitchClass.from_s(name)
+      end
+    end
+  end
+
+  describe '.from_i' do
+    it "returns the PitchClass with that value" do
+      PitchClass.from_i(2).should == D
+    end
+    it "returns the PitchClass with that value mod 12" do
+      PitchClass.from_i(14).should == D
+      PitchClass.from_i(-8).should == E
+    end
+  end
+
+  describe '.[]' do
+    it "acts like from_name if the argument is a string" do
+      PitchClass['D'].should == PitchClass.from_name('D')
+    end
+    it "acts like from_i if the argument is a number" do
+      PitchClass[3].should == PitchClass.from_i(3)
+    end
+  end
+
+  describe '#name' do
+    it "is the name of the pitch class" do
+      C.name.should == 'C'
+    end
+  end
+
+  describe '#to_i' do
+    it "is the integer value of the pitch class" do
+      C.to_i.should == 0
+      D.to_i.should == 2
+      E.to_i.should == 4
+    end
+  end
+
+  describe '#to_s' do
+    it "returns the name" do
+      C.to_s.should == C.name
+      for name in names
+        PitchClass.from_s(name).to_s.should == name
+      end
+    end
+  end
+
+  describe '#==' do
+    it "checks for equality" do
+      C.should == C
+      C.should_not == D
+    end
+    it "treats enharmonic names as equal" do
+      C.should == PitchClass['B#']
+      C.should == PitchClass['Dbb']
+    end
+  end
+
+  describe "#<=>" do
+    it "compares the underlying int value" do
+      (C <=> D).should < 0
+      (B <=> C).should > 0
+    end
+  end
+
+  describe '#+' do
+    it "adds the integer value of the argument and #to_i" do
+      (C + 4).should == E
+    end
+
+    it "'wraps around' the range 0-11" do
+      (D + 10).should == C
+    end
+  end
+
+  describe '#-' do
+    it "subtracts the integer value of the argument from #to_i" do
+      (E - 2).should == D
+    end
+
+    it "'wraps around' the range 0-11" do
+      (C - 8).should == E
+    end
+  end
+
+  describe "#distance_to" do
+    it "is the distance in semitones between 2 PitchClass objects" do
+      C.distance_to(D).should == 2
+    end
+
+    it "is the shortest distance (accounts from octave 'wrap around')" do
+      B.distance_to(C).should == 1
+    end
+
+    it "is a negative distance in semitones when the cloest given PitchClass is at a higher Pitch" do
+      D.distance_to(C).should == -2
+      C.distance_to(B).should == -1
+    end
+
+    it "is (positive) 6 for tritone distances, when this PitchClass is C-F" do
+      for pc in [C,Db,D,Eb,E,F]
+        pc.distance_to(pc+TT).should == 6
+      end
+    end
+
+    it "is -6 for tritone distances, when this PitchClass is Gb-B" do
+      for pc in [Gb,G,Ab,A,Bb,B]
+        pc.distance_to(pc+TT).should == -6
+      end
+    end
+  end
+
+end  

data/spec/mtk/pitch_set_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe MTK::PitchSet do
+
+  let(:pitches) { [C4, D4, E4, F4, G4, A4, B4] }
+  let(:pitch_set) { PitchSet.new(pitches) }
+  let(:c_major) { PitchSet.new([C4,E4,G4]) }
+
+  it "is Enumerable" do
+    pitch_set.should be_a Enumerable
+  end
+
+  describe '#pitches' do
+    it 'is the list of pitches used to construct the scale' do
+      pitch_set.pitches.should == pitches
+    end
+
+    it "is immutable" do
+      lambda { pitch_set.pitches << Db4 }.should raise_error
+    end
+
+    it "does not affect the immutabilty of the pitch list used to construct it" do
+      pitches << Db4
+      pitches.length.should == 8
+    end
+
+    it "is not affected by changes to the pitch list used to construct it" do
+      pitch_set # force construction before we modify the pitches array
+      pitches << Db4
+      pitch_set.pitches.length.should == 7
+    end
+
+    it "does not include duplicates" do
+      PitchSet.new([C4, E4, G4, C4]).pitches.should == [C4, E4, G4]
+    end
+
+    it "sorts the pitches" do
+      PitchSet.new([G4, E4, C4]).pitches.should == [C4, E4, G4]
+    end
+  end
+
+  describe "#to_a" do
+    it "is equal to #pitches" do
+      pitch_set.to_a.should == pitch_set.pitches
+    end
+
+    it "is mutable" do
+      (c_major.to_a << Bb4).should == [C4, E4, G4, Bb4]
+    end
+  end
+
+  describe "#each" do
+    it "yields each pitch" do
+      ps = []
+      pitch_set.each{|p| ps << p }
+      ps.should == pitches
+    end
+  end
+
+  describe "#map" do
+    it "returns a PitchSet with each Pitch replaced with the results of the block" do
+      c_major.map{|p| p + 2}.should == [D4, Gb4, A4]
+    end
+  end
+
+  describe "#to_pitch_class_set" do
+    it "is a PitchClassSet" do
+      pitch_set.to_pitch_class_set.should be_a PitchClassSet
+    end
+
+    it "contains all the pitch_classes in this PitchSet" do
+      pitch_set.to_pitch_class_set.pitch_classes.should == pitch_set.pitch_classes
+    end
+  end
+
+  describe '#pitch_classes' do
+    it 'is the list of pitch classes' do
+      pitch_set.pitch_classes.should == pitches.map { |p| p.pitch_class }
+    end
+
+    it "doesn't include duplicates" do
+      PitchSet.new([C4, C5, D5, C6, D4]).pitch_classes.should == [C, D]
+    end
+  end
+
+  describe '#+' do
+    it 'transposes upward by the given semitones' do
+      (pitch_set + 12).should == PitchSet.new([C5, D5, E5, F5, G5, A5, B5])
+    end
+  end
+
+  describe '#-' do
+    it 'transposes downward by the given semitones' do
+      (pitch_set - 12).should == PitchSet.new([C3, D3, E3, F3, G3, A3, B3])
+    end
+  end
+
+  describe '#invert' do
+    it 'inverts all pitches around the given center pitch' do
+      (pitch_set.invert Gb4).should == PitchSet.new([C5, Bb4, Ab4, G4, F4, Eb4, Db4])
+    end
+
+    it 'inverts all pitches around the first pitch, when no center pitch is given' do
+      pitch_set.invert.should == PitchSet.new([C4, Bb3, Ab3, G3, F3, Eb3, Db3])
+    end
+  end
+
+  describe '#include?' do
+    it 'returns true if the Pitch is in the PitchList' do
+      (pitch_set.include? C4).should be_true
+    end
+
+    it 'returns false if the Pitch is not in the PitchList' do
+      (pitch_set.include? Db4).should be_false
+    end
+  end
+
+  describe '#==' do
+    it "is true when all the pitches are equal" do
+      PitchSet.new([C4, E4, G4]).should == PitchSet.new([Pitch.from_i(60), Pitch.from_i(64), Pitch.from_i(67)])
+    end
+
+    it "doesn't consider duplicates in the comparison" do
+      PitchSet.new([C4, C4]).should == PitchSet.new([C4])
+    end
+
+    it "doesn't consider the order of pitches" do
+      PitchSet.new([G4, E4, C4]).should == PitchSet.new([C4, E4, G4])
+    end
+  end
+
+  describe '#inversion' do
+    it "adds an octave to the chord's pitches starting from the lowest, for each whole number in a postive argument" do
+      c_major.inversion(2).should == PitchSet.new([G4,C5,E5])
+    end
+
+    it "subtracts an octave to the chord's pitches starting fromt he highest, for each whole number in a negative argument" do
+      c_major.inversion(-2).should == PitchSet.new([E3,G3,C4])
+    end
+
+    it "wraps around to the lowest pitch when the argument is bigger than the number of pitches in the chord (positive argument)" do
+      c_major.inversion(4).should == PitchSet.new([E5,G5,C6])
+    end
+
+    it "wraps around to the highest pitch when the magnitude of the argument is bigger than the number of pitches in the chord (negative argument)" do
+      c_major.inversion(-4).should == PitchSet.new([G2,C3,E3])
+    end
+  end
+
+  describe "#nearest" do
+    it "returns the nearest PitchSet where the first Pitch has the given PitchClass" do
+      c_major.nearest(F).should == c_major + 5
+      c_major.nearest(G).should == c_major - 5
+    end
+  end
+
+  describe "#to_s" do
+    it "looks like an array of pitches" do
+      c_major.to_s.should == "[C4, E4, G4]"
+    end
+  end
+
+end

data/spec/mtk/pitch_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe MTK::Pitch do
+
+  let(:middle_c) { Pitch.new(C, 4) }
+  let(:lowest) { Pitch.new(C, -1) }
+  let(:highest) { Pitch.new(G, 9) }
+  let(:middle_c_and_50_cents) { Pitch.new(C, 4, 0.5) }
+
+  describe '.[]' do
+    it "constructs and caches a pitch with the given pitch_class and octave" do
+      Pitch[C,4].should be_equal Pitch[C,4]
+    end
+    it "retains the new() method's ability to construct uncached objects" do
+      Pitch.new(C,4).should_not be_equal Pitch[C,4]
+    end
+  end
+
+  describe '#pitch_class' do
+    it "is the pitch class of the pitch" do
+      middle_c.pitch_class.should == C
+    end
+  end
+
+  describe '#octave' do
+    it "is the octave of the pitch" do
+      middle_c.octave.should == 4
+    end
+  end
+
+  describe '#offset' do
+    it 'is the third argument of the constructor' do
+      Pitch.new(C, 4, 0.6).offset.should == 0.6
+    end
+    it 'defaults to 0' do
+      Pitch.new(C, 4).offset.should == 0
+    end
+  end
+
+  describe '#offset_in_cents' do
+    it 'is #offset * 100' do
+      middle_c_and_50_cents.offset_in_cents.should == middle_c_and_50_cents.offset * 100
+    end
+  end
+
+  describe '.from_i' do
+    it("converts 60 to middle C") { Pitch.from_i(60).should == middle_c }
+    it("converts 0 to C at octave -1") { Pitch.from_i(0).should == lowest }
+    it("converts 127 to G at octave 9") { Pitch.from_i(127).should == highest }
+  end
+
+  describe '.from_f' do
+    it "converts 60.5 to middle C with a 0.5 offset" do
+      p = Pitch.from_f(60.5)
+      p.pitch_class.should == C
+      p.octave.should == 4
+      p.offset.should == 0.5
+    end
+  end
+
+  describe '.from_s' do
+    it("converts 'C4' to middle c") { Pitch.from_s('C4').should == middle_c }
+    it("converts 'c4' to middle c") { Pitch.from_s('c4').should == middle_c }
+    it("converts 'B#4' to middle c") { Pitch.from_s('B#4').should == middle_c }
+  end
+
+  describe ".from_hash" do
+    it "constructs a Pitch from a hash of pitch attributes" do
+      Pitch.from_hash({:pitch_class => C, :octave => 4, :offset => 0.5}).should == middle_c_and_50_cents
+    end
+  end
+
+  describe '#to_f' do
+    it "is 60.5 for middle C with a 0.5 offset" do
+      middle_c_and_50_cents.to_f.should == 60.5
+    end
+  end
+
+  describe '#to_i' do
+    it("is 60 for middle C") { middle_c.to_i.should == 60 }
+    it("is 0 for the C at octave -1") { lowest.to_i.should == 0 }
+    it("is 127 for the G at octave 9") { highest.to_i.should == 127 }
+    it "rounds to the nearest integer (the nearest semitone value) when there is an offset" do
+      Pitch.new(C, 4, 0.4).to_i.should == 60
+      Pitch.new(C, 4, 0.5).to_i.should == 61
+    end
+  end
+
+  describe "#to_hash" do
+    it "converts to a Hash" do
+      middle_c_and_50_cents.to_hash.should == {:pitch_class => C, :octave => 4, :offset => 0.5}
+    end
+  end
+
+  describe '#==' do
+    it "compares the pitch_class and octave for equality" do
+      middle_c.should == Pitch.from_s('C4')
+      middle_c.should_not == Pitch.from_s('C3')
+      middle_c.should_not == Pitch.from_s('G4')
+      middle_c.should_not == Pitch.from_s('G3')
+      highest.should == Pitch.from_s('G9')
+    end
+  end
+
+  describe "#<=>" do
+    it "orders pitches based on their underlying float value" do
+      ( Pitch.from_f(60) <=> Pitch.from_f(60.5) ).should < 0
+    end
+  end
+
+  describe '#to_s' do
+    it "should be the pitch class name and the octave" do
+      for pitch in [middle_c, lowest, highest]
+        pitch.to_s.should == pitch.pitch_class.name + pitch.octave.to_s
+      end
+    end
+    it "should include the offset_in_cents when the offset is not 0" do
+      middle_c_and_50_cents.to_s.should == "C4+50cents"
+    end
+    it "rounds to the nearest cent" do
+      Pitch.from_f(60.556).to_s.should == "C4+56cents"
+    end
+  end
+
+  describe '#+' do
+    it 'adds the integer value of the argument and #to_i' do
+      (middle_c + 2).should == Pitch.from_i(62)
+    end
+
+    it 'handles offsets' do
+      (middle_c + Pitch.from_f(0.5)).should == Pitch.from_f(60.5)
+    end
+
+    it 'returns a new pitch (Pitch is immutabile)' do
+      original = Pitch.from_i(60)
+      modified = original + 2
+      original.should_not == modified
+      original.should == Pitch.from_i(60)
+    end
+  end
+
+  describe '#-' do
+    it 'subtracts the integer value of the argument from #to_i' do
+      (middle_c - 2).should == Pitch.from_i(58)
+    end
+
+    it 'handles offsets' do
+      (middle_c - Pitch.from_f(0.5)).should == Pitch.from_f(59.5)
+    end
+
+    it 'returns a new pitch (Pitch is immutabile)' do
+      original = Pitch.from_i(60)
+      modified = original - 2
+      original.should_not == modified
+      original.should == Pitch.from_i(60)
+    end
+  end
+
+  describe "#invert" do
+    context 'higher center pitch' do
+      it 'inverts the pitch around the given center pitch' do
+        middle_c.invert(Pitch.from_i 66).should == Pitch.from_i(72)
+      end
+    end
+
+    context 'lower center pitch' do
+      it 'inverts the pitch around the given center pitch' do
+        middle_c.invert(Pitch.from_i 54).should == Pitch.from_i(48)
+      end
+    end
+  end
+
+  describe "#nearest" do
+    it "is the Pitch with the nearest given PitchClass" do
+      middle_c.nearest(F).should == F4
+      middle_c.nearest(G).should == G3
+    end
+  end
+
+  describe '#coerce' do
+    it 'allows a Pitch to be added to a Numeric' do
+      (2 + middle_c).should == Pitch.from_i(62)
+    end
+
+    it 'allows a Pitch to be subtracted from a Numeric' do
+      (62 - middle_c).should == Pitch.from_i(2)
+    end
+  end
+
+  describe "#clone_with" do
+    it "clones the Pitch when given an empty hash" do
+      middle_c.clone_with({}).should == middle_c
+    end
+
+    it "create a Pitch with the given :pitch_class, and the current Pitch's octave and offset if not provided" do
+      pitch2 = middle_c_and_50_cents.clone_with({:pitch_class => middle_c_and_50_cents.pitch_class+1})
+      pitch2.pitch_class.should == middle_c_and_50_cents.pitch_class + 1
+      pitch2.octave.should == middle_c_and_50_cents.octave
+      pitch2.offset.should == middle_c_and_50_cents.offset
+    end
+
+    it "create a Pitch with the given :octave, and the current Pitch's pitch_class and offset if not provided" do
+      pitch2 = middle_c_and_50_cents.clone_with({:octave => middle_c_and_50_cents.octave+1})
+      pitch2.pitch_class.should == middle_c_and_50_cents.pitch_class
+      pitch2.octave.should == middle_c_and_50_cents.octave + 1
+      pitch2.offset.should == middle_c_and_50_cents.offset
+    end
+
+    it "create a Pitch with the given :offset, and the current Pitch's pitch_class and octave if not provided" do
+      pitch2 = middle_c_and_50_cents.clone_with({:offset => middle_c_and_50_cents.offset+1})
+      pitch2.pitch_class.should == middle_c_and_50_cents.pitch_class
+      pitch2.octave.should == middle_c_and_50_cents.octave
+      pitch2.offset.should == middle_c_and_50_cents.offset + 1
+    end
+  end
+
+end