post_tonal 0.1.0.pre

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.DS_Store

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+#CHANGELOG
+
+####October 21, 2012 [0.1.0.pre]
+-Implement transposition in PitchClassSet
+-Change normal_form, inversion, and transpose so that they each return a PitchClassSet
+
+####October 20, 2012 [0.0.3.pre]
+-Implement inversion in PitchClassSet
+
+####October 16, 2012 [0.0.2.pre]
+-Implement normal form in PitchClassSet
+
+####October 15, 2012 [0.0.1.pre]
+- Create PitchClass, PitchClassSet, PitchClassInterval, PitchInterval, and NoteParser

data/README.md

@@ -0,0 +1,8 @@
+PostTonal
+==========
+
+PostTonal is a Ruby library for analyzing sets of musical pitches. It's based on [pitch class set theory](http://en.wikipedia.org/wiki/Set_theory_\(music\) "Pitch class set theory") pioneered by Allen Forte.
+
+Work In Progress: Detailed usage documentation to come soon.
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs      << 'lib' << 'test'
+  test.pattern   = 'test/{functional,unit}/**/*_test.rb'
+  test.verbose   = true
+end
+
+task :default => :test

data/lib/post_tonal/note_parser.rb

@@ -0,0 +1,30 @@
+module PostTonal
+	class NoteParser
+
+		NAME_TO_INT = {	:'b#' => 0, :'c' => 0, 
+										:'c#' => 1, :'db' => 1, 
+										:'d' => 2, 
+										:'d#' => 3, :'eb' => 3, 
+										:'e' => 4, :'fb' => 4, 
+										:'e#' => 5, :'f' => 5, 
+										:'f#' => 6, :'gb' => 6, 
+										:'g' => 7, 
+										:'g#' => 8, :'ab' => 8,
+										:'a' => 9,
+										:'a#' => 10, :'bb' => 10,
+										:'b' => 11, :'cb' => 11}
+
+		INT_TO_NAME = ['c', 'c#', 'd', 'd#', 'e', 'f', 'f#', 'g', 'g#', 'a', 'a#', 'b']
+		INT_TO_NAME_FLAT = ['c', 'db', 'd', 'eb', 'e', 'f', 'gb', 'g', 'ab', 'a', 'bb', 'b']
+
+		def self.integer_value(name_or_integer)
+			return name_or_integer.abs % 12 if name_or_integer.class == Fixnum
+			return NAME_TO_INT[name_or_integer.downcase.to_sym]
+		end
+
+		def self.note_name(name_or_integer)
+			return INT_TO_NAME[(name_or_integer.abs % 12)] if name_or_integer.class == Fixnum
+			return name_or_integer.downcase if NAME_TO_INT.has_key?(name_or_integer.downcase.to_sym)
+		end
+	end
+end

data/lib/post_tonal/pitch_class.rb

@@ -0,0 +1,37 @@
+module PostTonal
+	class PitchClass
+
+		require 'post_tonal/note_parser'
+
+		# value - The integer value of a pitch class, with C as 0.
+		# octave - A relative marker denoting the octave of the pitch class. Defaults to 0.
+		attr_reader :value, :octave
+
+		def initialize(note_name_or_integer, octave = 0)
+			@value = NoteParser.integer_value(note_name_or_integer)
+			@octave = octave
+		end
+
+		def value=(val)
+			v = val
+			v -= 12 while v > 11
+			v += 12 while v < 0
+
+			@value = v
+
+			@value
+		end
+
+		def to_s
+			"[#{@value}, oct.#{@octave}]"
+		end
+
+		def eql?(pitch_class)
+			return pitch_class.value == @value && pitch_class.octave == @octave
+		end
+
+		def ==(pitch_class)
+			eql? pitch_class
+		end
+	end
+end

data/lib/post_tonal/pitch_class_interval.rb

@@ -0,0 +1,32 @@
+module PostTonal
+	class PitchClassInterval
+
+		attr_reader :pitch1, :pitch2, :ordered, :unordered
+
+		def initialize(pitch1, pitch2)
+			@pitch1 = pitch1
+			@pitch2 = pitch2
+
+			@ordered = calculate_ordered(pitch1, pitch2)
+			@unordered =  calculate_unordered(pitch1, pitch2)
+		end
+
+		private
+
+		def calculate_ordered(p1, p2)
+			pitches = [p1, p2]
+
+			if pitches[0].octave != pitches[1].octave
+				pitches = pitches.sort { |x, y| y.octave <=> x.octave }
+			else
+				pitches = pitches.sort { |x, y| y.value <=> x.value }
+			end
+
+			(pitches[0].value + (12 * pitches[0].octave)) - (pitches[1].value + (12 * pitches[1].octave))
+		end
+
+		def calculate_unordered(p1, p2)
+			(p1.value - p2.value).abs > 6 ? 12 - (p1.value - p2.value).abs : (p1.value - p2.value).abs
+		end
+	end
+end

data/lib/post_tonal/pitch_class_set.rb

@@ -0,0 +1,145 @@
+module PostTonal
+	class PitchClassSet
+
+		require 'post_tonal/pitch_class'
+
+		attr_reader :pitch_classes
+
+		def initialize(pitch_classes = nil)
+			@pitch_classes = pitch_classes || []
+			@normalized_pitch_classes = pitch_classes ? self.class.to_normal_form(@pitch_classes) : []
+			@inverted_pitch_classes = pitch_classes ? invert(@pitch_classes) : []
+		end
+
+		# Add a pitch to the pitch class set
+		# 
+		# The reason you are adding pitches as opposed to pitch classes
+		# is that you may want to get the ordered intervals of the set.
+		# Therefore, you may pass an optional octave value, which is an
+		# arbitrary marker starting at 0 representing the default octave.
+		# Non-zero values are calculated relative to octave 0.
+		# 
+		# note_name_or_integer may be the name of the note (e.g. A-G, with # 
+		#	and lowercase b representing sharps and flats, respectively), or the
+		# integer value of the pitch class (e.g. 0-11, or T and E for eleven 
+		# and twelve, respectively)
+		def add_pitch(note_name_or_integer, octave = 0)
+
+			pc = PitchClass.new(note_name_or_integer, octave)
+
+			if !@pitch_classes.any? { |p| p.value == pc.value && p.octave == pc.octave }
+				@pitch_classes << pc
+				@normalized_pitch_classes = self.class.to_normal_form(@pitch_classes)
+				@inverted_pitch_classes = invert(@pitch_classes)
+			end
+
+			pc
+		end
+
+		def eql?(pitch_class_set)
+			return false if @pitch_classes.size != pitch_class_set.pitch_classes.size
+
+			@normalized_pitch_classes.each_with_index do |pitch_class, i|
+				return false if !pitch_class_set.normal_form.pitch_classes[i].eql?(pitch_class)
+			end
+
+			true
+		end
+
+		def ==(pitch_class_set)
+			eql? pitch_class_set
+		end
+
+		def to_s
+			"PitchClassSet: #{@pitch_classes}"
+		end
+
+		# Returns the normal form of an array of pitch classes
+		def self.to_normal_form(pitch_classes)
+			normal = pitch_classes.sort { |x, y| x.value <=> y.value }
+
+			newLen = normal.last.value - normal.first.value
+			newLen += 12 if newLen < 0
+			newLen += 12 if newLen == 1 && normal.size > 2
+
+			shortest = {:array => normal.dup, :length => newLen}
+
+			0.upto(normal.size - 1) do |q|
+				# Rotate
+				normal.push normal.shift
+
+				newLen = normal.last.value - normal.first.value
+				newLen += 12 if newLen < 0
+				newLen += 12 if newLen == 1 && normal.size > 2
+
+				if newLen < shortest[:length]
+					shortest = {:array => normal.dup, :length => newLen}
+				elsif newLen == shortest[:length]
+					(normal.size - 1).downto(q) do |r|
+
+						newLen = normal[r].value - normal.first.value
+						newLen += 12 if newLen < 0
+						newLen += 12 if newLen == 1 && normal.size > 2
+
+						sNewLen = shortest[:array][r].value - shortest[:array].first.value
+						sNewLen += 12 if sNewLen < 0
+						sNewLen += 12 if sNewLen == 1 && normal.size > 2
+
+						if newLen < sNewLen
+							shortest = {:array => normal.dup, :length => newLen}
+							break
+						end
+					end
+				end
+			end
+
+			shortest[:array]
+		end
+
+		# Returns a PitchClassSet of the inversino of the current PitchClassSet
+		def inversion
+			self.class.new(@inverted_pitch_classes)
+		end
+
+		# Returns a PitchClassSet of the current PitchClassSet in normal form
+		def normal_form
+			self.class.new(@normalized_pitch_classes)
+		end
+
+		# Transposes the set by a degree (integer)
+		# Returns PitchClassSet of the transposed set
+		def transpose(degree)
+			transposed = self.class.new
+
+			@pitch_classes.each do |pitch_class|
+				oct = pitch_class.octave
+				val = pitch_class.value
+
+				val += degree
+
+				oct += val / 12
+				oct -= 1 if val < 0 && val % 12 == 0
+
+				transposed.add_pitch(val, oct)
+			end
+
+			transposed
+		end
+
+		private
+
+		# Inverts an array of pitch classes. The PitchClass attribute octave may become invalid after inversion.
+		# Returns a PitchClassSet of the inverted pitch classes
+		def invert(pitch_classes)
+			inverted = []
+
+			pitch_classes.each do |pitch_class|
+				pc = PitchClass.new(12 - pitch_class.value, pitch_class.octave)
+				inverted << pc
+			end
+
+			inverted
+		end
+
+	end
+end

data/lib/post_tonal/pitch_interval.rb

@@ -0,0 +1,19 @@
+module PostTonal
+	class PitchInterval
+
+		attr_reader :pitch1, :pitch2
+
+		def initialize(pitch1, pitch2)
+			@pitch1 = pitch1
+			@pitch2 = pitch2
+		end
+
+		def ordered
+			pitch1.int_value - pitch2.int_value
+		end
+
+		def unordered
+			(pitch1.int_value - pitch2.int_value).abs
+		end
+	end
+end

data/lib/post_tonal/version.rb

@@ -0,0 +1,3 @@
+module PostTonal
+	VERSION = '0.1.0.pre'
+end

data/lib/post_tonal.rb

@@ -0,0 +1,4 @@
+require 'post_tonal/note_parser'
+require 'post_tonal/pitch_class'
+require 'post_tonal/pitch_class_interval'
+require 'post_tonal/pitch_class_set'

data/post_tonal.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "post_tonal/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'post_tonal'
+  s.version     = PostTonal::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author     = 'Eric Rubio'
+  s.email       = 'penmanglewood@fastmail.fm'
+  s.summary     = %q{Pitch-class set analysis library}
+  s.description = %q{Ruby library for analyzing pitch-class sets according to post-tonal theory}
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/{functional,unit}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "shoulda", ">= 2.1.1"
+  s.add_development_dependency "mocha", ">= 0.9.5"
+  s.add_development_dependency "rake"
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'post_tonal'

data/test/unit/note_parser_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+class NoteParserTest < Test::Unit::TestCase
+
+	def test_valid_int_values
+		(0..11).each do |i|
+			@p = PostTonal::NoteParser.integer_value(i)
+			assert_equal(i, @p, "0-11 should be valid")
+		end
+	end
+
+	def test_mod12_int_values
+		(12..23).each do |i|
+			@p = PostTonal::NoteParser.integer_value(i)
+			assert_equal(i-12, @p, "12-23 should be valid")
+		end
+	end
+
+	def test_negative_int_values
+		(-11..0).each do |i|
+			@p = PostTonal::NoteParser.integer_value(i)
+			assert_equal(i.abs, @p, "(-11)-0 should count as 11-0")
+		end
+	end
+
+	def test_valid_str_values
+		PostTonal::NoteParser::NAME_TO_INT.each do |k, v|
+			@p = PostTonal::NoteParser.integer_value(k)
+			@q = PostTonal::NoteParser.integer_value(k.upcase)
+			assert_equal(v, @p, "Note names should be valid 1")
+			assert_equal(v, @q, "Note names should be valid 2")
+		end
+	end
+
+	def test_invalid_str_values
+		('h'..'z').each do |z|
+			@p = PostTonal::NoteParser.integer_value(z)
+			assert_equal(nil, @p, "h-z should be invalid")
+		end
+	end
+
+	def test_note_names
+		assert_equal('c', PostTonal::NoteParser.note_name(0), '0 should be c')
+		assert_equal('c#', PostTonal::NoteParser.note_name(1), '1 should be c#')
+		assert_equal('d', PostTonal::NoteParser.note_name(2), '2 should be d')
+		assert_equal('d#', PostTonal::NoteParser.note_name(3), '3 should be d#')
+		assert_equal('e', PostTonal::NoteParser.note_name(4), '4 should be e')
+		assert_equal('f', PostTonal::NoteParser.note_name(5), '5 should be f')
+		assert_equal('f#', PostTonal::NoteParser.note_name(6), '6 should be f#')
+		assert_equal('g', PostTonal::NoteParser.note_name(7), '7 should be g')
+		assert_equal('g#', PostTonal::NoteParser.note_name(8), '8 should be g#')
+		assert_equal('a', PostTonal::NoteParser.note_name(9), '9 should be a')
+		assert_equal('a#', PostTonal::NoteParser.note_name(10), '10 should be a#')
+		assert_equal('b', PostTonal::NoteParser.note_name(11), '11 should be b')
+	end
+end

data/test/unit/pitch_class_interval_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+class PitchClassIntervalTest < Test::Unit::TestCase
+
+	def test_unordered_intervals
+		(0..11).each do |i|
+			@p1 = PostTonal::PitchClass.new(i)
+			(0..11).each do |j|
+				@p2 = PostTonal::PitchClass.new(j)
+				@interval = PostTonal::PitchClassInterval.new(@p1, @p2)
+				expected = (@p1.value - @p2.value).abs > 6 ? 12 - (@p1.value - @p2.value).abs : (@p1.value - @p2.value).abs
+				assert_equal(expected, @interval.unordered, "p1: #{i}, p2: #{j}") if i != j
+			end
+		end
+	end
+
+	def test_ordered_intervals
+
+		#Same octave ordered intervals
+		(0..11).each do |i|
+			@p1 = PostTonal::PitchClass.new(i)
+			(0..11).each do |j|
+				@p2 = PostTonal::PitchClass.new(j)
+				@interval = PostTonal::PitchClassInterval.new(@p1, @p2)
+				expected = j > i  ? @p2.value - @p1.value : @p1.value - @p2.value
+				assert_equal(expected, @interval.ordered, "p1: #{i}, p2: #{j}") if i != j
+			end
+		end
+
+		#Cross-octave ordered intervals
+		@p3 = PostTonal::PitchClass.new(11)
+		(0...11).each do |j|
+			@p4 = PostTonal::PitchClass.new(j, 1)
+			@interval = PostTonal::PitchClassInterval.new(@p3, @p4)
+			assert_equal(j+1, @interval.ordered, "Cross-Octave p1: 11, p2: #{j}")
+		end
+	end
+end

data/test/unit/pitch_class_set_test.rb

@@ -0,0 +1,159 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+class PitchClassSetTest < Test::Unit::TestCase
+
+	def setup
+		@pitch_class_set = PostTonal::PitchClassSet.new
+	end
+
+	def teardown
+		@pitch_class_set = nil
+	end
+
+	def test_duplicate_assignment
+		@pitch_class_set.add_pitch(0)
+		@pitch_class_set.add_pitch(0)
+		@pitch_class_set.add_pitch(0)
+
+		assert_equal(1, @pitch_class_set.pitch_classes.size)
+	end
+
+	def test_nonduplicate_assignment
+		@pitch_class_set.add_pitch(0)
+		@pitch_class_set.add_pitch(1)
+		@pitch_class_set.add_pitch(0, 1)
+
+		assert_equal(3, @pitch_class_set.pitch_classes.size)
+	end
+
+	def test_equality
+		@pitch_class_set.add_pitch(0)
+		@pitch_class_set.add_pitch(1)
+		@pitch_class_set.add_pitch(2)
+
+		@p1 = PostTonal::PitchClassSet.new
+		@p1.add_pitch(0)
+		@p1.add_pitch(1)
+		@p1.add_pitch(2)
+
+		assert(@pitch_class_set.eql?(@p1), "eql? should be true")
+		assert(@pitch_class_set == @p1, "== should be true")
+	end
+
+	def test_normal_form
+
+		@p1 = PostTonal::PitchClassSet.new
+		@p1.add_pitch(0)
+		@p1.add_pitch(1)
+		@p1.add_pitch(2)
+
+		[0,1,2].each do |n|
+			assert_equal(@p1.pitch_classes[n], @p1.normal_form.pitch_classes[n])
+		end
+
+		@p2 = PostTonal::PitchClassSet.new
+		@p2.add_pitch(0)
+		@p2.add_pitch(10)
+		@p2.add_pitch(11)
+
+		[10,11,0].each_with_index do |n, i|
+			assert_equal(n, @p2.normal_form.pitch_classes[i].value)
+		end
+
+		@p3 = PostTonal::PitchClassSet.new
+		@p3.add_pitch(0)
+		@p3.add_pitch(3)
+		@p3.add_pitch(4)
+		@p3.add_pitch(9)
+
+		[9,0,3,4].each_with_index do |n, i|
+			assert_equal(n, @p3.normal_form.pitch_classes[i].value)
+		end
+
+		@p4 = PostTonal::PitchClassSet.new
+		@p4.add_pitch(0)
+		@p4.add_pitch(3)
+		@p4.add_pitch(4)
+		@p4.add_pitch(8)
+
+		[0,3,4,8].each_with_index do |n, i|
+			assert_equal(n, @p4.normal_form.pitch_classes[i].value)
+		end
+
+		@p5 = PostTonal::PitchClassSet.new
+		@p5.add_pitch(0)
+		@p5.add_pitch(1)
+		@p5.add_pitch(10)
+		@p5.add_pitch(11)
+
+		[10,11,0,1].each_with_index do |n, i|
+			assert_equal(n, @p5.normal_form.pitch_classes[i].value)
+		end
+
+		@p6 = PostTonal::PitchClassSet.new
+		@p6.add_pitch(0)
+		@p6.add_pitch(1)
+		@p6.add_pitch(8)
+		@p6.add_pitch(4)
+
+		[0,1,4,8].each_with_index do |n, i|
+			assert_equal(n, @p6.normal_form.pitch_classes[i].value)
+		end
+
+		@p7 = PostTonal::PitchClassSet.new
+		@p7.add_pitch(0)
+		@p7.add_pitch(3)
+		@p7.add_pitch(6)
+		@p7.add_pitch(9)
+
+		[0,3,6,9].each_with_index do |n, i|
+			assert_equal(n, @p7.normal_form.pitch_classes[i].value)
+		end
+
+		@p7 = PostTonal::PitchClassSet.new
+		@p7.add_pitch(0)
+		@p7.add_pitch(6)
+		@p7.add_pitch(7)
+
+		[6,7,0].each_with_index do |n, i|
+			assert_equal(n, @p7.normal_form.pitch_classes[i].value)
+		end
+	end
+
+	def test_inversion
+		@p1 = PostTonal::PitchClassSet.new
+		0.upto(11) do |i|
+			@p1.add_pitch(i)
+		end
+
+		@p1i = PostTonal::PitchClassSet.new
+		@p1i.add_pitch(0)
+		11.downto(1) do |i|
+			@p1i.add_pitch(i)
+		end
+
+		assert_equal(@p1i, @p1.inversion, "Should be inverted")
+	end
+
+	def test_transposition
+		@p1 = PostTonal::PitchClassSet.new
+		0.upto(11) do |i|
+			@p1.add_pitch(i)
+		end
+
+		#transposition degree
+		0.upto(200) do |t|
+			@p1t = PostTonal::PitchClassSet.new
+			t.upto(t+11) do |i|
+				oct = 0
+				oct = i / 12
+				oct -= 1 if i < 0 && i % 12 == 0
+
+				@p1t.add_pitch(i, oct)
+			end
+
+			assert_equal(@p1t, @p1.transpose(t), "Should transpose #{t} degrees")
+		end
+	end
+
+end

data/test/unit/pitch_class_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+class PitchClassTest < Test::Unit::TestCase
+
+	def test_valid_int_values
+		(0..11).each do |i|
+			@p = PostTonal::PitchClass.new(i)
+			assert_equal(i, @p.value, "0-11 should be valid")
+		end
+	end
+
+	def test_mod12_int_values
+		(12..23).each do |i|
+			@p = PostTonal::PitchClass.new(i)
+			assert_equal(i-12, @p.value, "12-23 should be valid")
+		end
+	end
+
+	def test_negative_int_values
+		(-11..0).each do |i|
+			@p = PostTonal::PitchClass.new(i)
+			assert_equal(i.abs, @p.value, "(-11)-0 should count as 11-0")
+		end
+	end
+
+	def test_valid_str_values
+		PostTonal::NoteParser::NAME_TO_INT.each do |k, v|
+			@p = PostTonal::PitchClass.new(k)
+			@q = PostTonal::PitchClass.new(k.upcase)
+			assert_equal(v, @p.value, "Note names should be valid 1")
+			assert_equal(v, @q.value, "Note names should be valid 2")
+		end
+	end
+
+	def test_invalid_str_values
+		('h'..'z').each do |z|
+			@p = PostTonal::PitchClass.new(z)
+			assert_equal(nil, @p.value, "h-z should be invalid")
+		end
+	end
+
+	def test_octave
+		(0..11).each do |i|
+			@p = PostTonal::PitchClass.new(i, i)
+			assert_equal(i, @p.octave, "0-11 should be valid octave values")
+		end
+	end
+
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: post_tonal
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Eric Rubio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby library for analyzing pitch-class sets according to post-tonal theory
+email: penmanglewood@fastmail.fm
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- README.md
+- Rakefile
+- lib/post_tonal.rb
+- lib/post_tonal/note_parser.rb
+- lib/post_tonal/pitch_class.rb
+- lib/post_tonal/pitch_class_interval.rb
+- lib/post_tonal/pitch_class_set.rb
+- lib/post_tonal/pitch_interval.rb
+- lib/post_tonal/version.rb
+- post_tonal.gemspec
+- test/test_helper.rb
+- test/unit/note_parser_test.rb
+- test/unit/pitch_class_interval_test.rb
+- test/unit/pitch_class_set_test.rb
+- test/unit/pitch_class_test.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Pitch-class set analysis library
+test_files:
+- test/unit/note_parser_test.rb
+- test/unit/pitch_class_interval_test.rb
+- test/unit/pitch_class_set_test.rb
+- test/unit/pitch_class_test.rb