dodecaphony 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2cdb493c58e0f214ef7cc89dac4bafd38d7826b9
+  data.tar.gz: 807fe2e936382444b1c9612969105a7215bf9307
+SHA512:
+  metadata.gz: 9662162bdee955579875ba1e37a41b591176ea4cd9e24c92c9c829ef3f211e49fd3c38ce629ca8d570cdaecdc4234746c95ba7cc0b0dbacd088ef2ca17ca6273
+  data.tar.gz: 06baece067f2ad549ce6808a10c5dba842fef4e924698f56c01f7c1bc69a1d6099b7c31cd5a79cec703847714bfd92ed64b7c85565e285c950b948006187e992

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Kevin McGladdery
+
+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,49 @@
+Dodecaphony
+-----------
+
+Dodecaphony calculates twelve tone rows for
+you. To learn more about what this means, [read
+this](http://www.tufts.edu/~mdevoto/12TonePrimer.pdf).
+
+Examples
+---
+
+Dodecaphony takes an array of twelve strings, one for each pitch in your
+twelve tone row.
+
+```ruby
+Dodecaphony::Row.new %w[a a# b c c# d d# e f f# g g#]
+```
+
+Each pitch must begin with a valid letter name (a through g) and can be
+followed by one or more accidentals. `#`, `+`, `b` and `-` are the four valid
+accidentals.
+
+Once you have your row, you can ask it for any prime, inversion, retrograde, or
+retrograde inversion like so:
+
+```ruby
+tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+#  "p" followed by 0 through 11 returns the corresponding prime row
+tone_row.p0    # ["a", "f#", "g", "ab", "e", "f", "b", "bb", "d", "c#", "c", "eb"]
+
+#  "r" followed by 0 through 11 returns the corresponding retrograde
+tone_row.r11   # ["d", "b", "c", "c#", "a", "bb", "e", "eb", "g", "f#", "f", "ab"]
+
+#  "i" followed by 0 through 11 returns the corresponding inversion
+tone_row.i2    # ["b", "d", "c#", "c", "e", "eb", "a", "bb", "f#", "g", "ab", "f"]
+
+# "ri" followed by 0 through 11 returns the corresponding retrograde inversion
+tone_row.ri6   # ["a", "c", "b", "bb", "d", "c#", "g", "ab", "e", "f", "f#", "eb"]
+```
+
+You can also ask a row to respell itself, favoring flats or sharps:
+```ruby
+tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+tone_row.spell_with_sharps # ["A", "F#", "G", "G#", "E", "F", "B", "A#", "D", "C#", "C", "D#"]
+
+tone_row.spell_with_flats # ["A", "Gb", "G", "Ab", "E", "F", "B", "Bb", "D", "Db", "C", "Eb"]
+```
+

data/lib/dodecaphony.rb

@@ -0,0 +1,120 @@
+require_relative 'pitch'
+require 'set'
+
+module Dodecaphony
+  class Row
+
+    attr_reader :original_row
+
+    def initialize tone_row
+      self.original_row = create_row_with_pitches(tone_row)
+      validate_size_of original_row
+      self.row_with_intervals = create_list_with_intervals(original_row,
+                                                           starting_pitch)
+    end
+
+    def to_s
+      p0.join(" ")
+    end
+
+    def spell_with_sharps
+      normalize_row(:spell_as_sharp)
+    end
+
+    def spell_with_flats
+      normalize_row(:spell_as_flat)
+    end
+
+    def i0
+      original_row.each_with_object([]) do |pitch, row|
+        row << row_with_intervals[((row_with_intervals.key(pitch) - 12).abs)].name
+      end
+    end
+
+    (0..11).each do |i|
+      define_method "p#{i}".to_sym do
+        original_row.each_with_object([]) do |pitch, row|
+          row << row_with_intervals[(transpose i, pitch)].name
+        end
+      end
+    end
+
+    (1..11).each do |i|
+      define_method "i#{i}".to_sym do
+        corresponding_p = self.send("p#{i}")
+        new_row = self.class.new corresponding_p
+        new_row.i0
+      end
+    end
+
+    (0..11).each do |i|
+      define_method "r#{i}".to_sym do
+        self.send("p#{i}".to_sym).reverse.each_with_object([]) do |pitch, row|
+          row << pitch
+        end
+      end
+    end
+
+    (0..11).each do |i|
+      define_method "ri#{i}".to_sym do
+        self.send("i#{i}").reverse.each_with_object([]) do |pitch, row|
+          row << pitch
+        end
+      end
+    end
+
+    private
+
+    attr_writer :original_row
+
+    attr_accessor :row_with_intervals
+
+    def create_list_with_intervals(row, first_pitch)
+      row_list = row.each_with_object({}) do |pitch, hash|
+        distance = first_pitch.distance_from pitch
+        validate_uniqueness_of distance, hash
+        hash[distance] = pitch
+      end
+      finalize_pitches(row_list)
+    end
+
+    def finalize_pitches(row_list)
+      row_list[12] = starting_pitch
+      row_list
+    end
+
+    def starting_pitch
+      original_row[0]
+    end
+
+    def create_row_with_pitches tone_row
+      tone_row.each_with_object([]) do |pitch, row|
+        row << Pitch.new(pitch)
+      end
+    end
+
+    def validate_size_of row
+      row_size = row.to_set.length
+      unless row_size == 12
+        raise ArgumentError, "incorrect number of pitches (#{row_size}) in row"
+      end
+    end
+
+    def validate_uniqueness_of distance, hash
+      if hash.has_key? distance
+        raise ArgumentError, "duplicate pitch (#{hash[distance].name})"
+      end
+    end
+
+    def normalize_row message
+      original_row.each_with_object([]) do |pitch, row|
+        row << pitch.send(message)
+      end
+    end
+
+    def transpose interval, pitch
+      (starting_pitch.distance_from(pitch) + interval) % 12
+    end
+
+  end
+end

data/lib/pitch.rb

@@ -0,0 +1,73 @@
+module Dodecaphony
+  class Pitch
+
+    attr_reader :name
+
+    VALID_PITCHES = {'A' => 0, 'B' => 2, 'C' => 3, 'D' => 5,
+                     'E' => 7, 'F' => 8, 'G' => 10}
+
+    private_constant :VALID_PITCHES
+
+    def initialize pitch_name
+      self.name = pitch_name
+      validate_name
+      self.pitch_number = adjust_for_accidentals(starting_number)
+    end
+
+    def distance_from second_pitch
+      ensure_number_scale(second_pitch.pitch_number - pitch_number)
+    end
+
+    def spell_as_sharp
+      respell :-, "#"
+    end
+
+    def spell_as_flat
+      respell :+, "b"
+    end
+
+    protected
+
+    attr_reader :pitch_number
+
+    private
+
+    attr_writer :name, :pitch_number
+
+    def validate_name
+      unless VALID_PITCHES.has_key?(starting_letter)
+        raise ArgumentError, 'invalid pitch name'
+      end
+    end
+
+    def respell method, accidental
+      num = self.pitch_number
+      VALID_PITCHES.key(num) || 
+        VALID_PITCHES.key(ensure_number_scale(num.send(method, 1))) + accidental
+    end
+
+    def accidentals
+      name.downcase.split(//)[1..-1]
+    end
+
+    def adjust_for_accidentals number
+      accidentals.each do |a|
+        number += 1 if a == '+' or a == '#'
+        number -= 1 if a == '-' or a == 'b' 
+      end
+      ensure_number_scale number
+    end
+
+    def ensure_number_scale number
+      number % 12
+    end
+
+    def starting_number
+      VALID_PITCHES[starting_letter]
+    end
+
+    def starting_letter
+      name.upcase.split(//)[0]
+    end
+  end
+end

data/spec/dodecaphony_spec.rb

@@ -0,0 +1,96 @@
+require 'dodecaphony'
+
+describe Dodecaphony::Row do
+
+  it "initializes with an array of strings and returns the original row" do
+    tone_row = %w[ a a# b c db d eb e f f# g g# ]
+    new_dod = Dodecaphony::Row.new tone_row
+
+    expect(new_dod.p0).to eq tone_row
+  end
+
+  it "raises an error for a row with more than 12 pitches" do
+    expect{ Dodecaphony::Row.new %w[ a a# b c c# d eb e f f# g ab a] }.
+      to raise_error(ArgumentError, 'incorrect number of pitches (13) in row')
+  end
+
+  it "raises an error for a row with less than 12 pitches" do
+    expect{ Dodecaphony::Row.new %w[ a a# b eb e f f# g ab a] }.
+      to raise_error(ArgumentError, 'incorrect number of pitches (10) in row')
+  end
+  
+  it "raises an error for duplicate pitches" do
+    expect{ Dodecaphony::Row.new %w[a a# b c c# d eb e f f g ab]}.
+      to raise_error(ArgumentError, 'duplicate pitch (f)')
+  end
+
+  it "can respell the row, favoring sharps" do
+    tone_row = %w[ c c+ d d# fb f gb g a- b-- bb b ]
+    new_dod = Dodecaphony::Row.new tone_row 
+
+    expect(new_dod.spell_with_sharps).to eq %w[ C C# D D# E F F# G G# A A# B ]
+  end
+
+  it "can respell the row, favoring flats" do
+    tone_row = %w[ c c+ d d# fb f gb g a- b-- bb b ]
+    new_dod = Dodecaphony::Row.new tone_row
+    
+    expect(new_dod.spell_with_flats).to eq %w[ C Db D Eb E F Gb G Ab A Bb B ]
+  end
+
+  it "can give p1" do
+    tone_row = %w[ bb b c c# d f e eb g gb a ab ]
+    new_dod = Dodecaphony::Row.new tone_row
+
+    expect(new_dod.p1).to eq %w[ b c c# d eb gb f e ab g bb a ]
+  end
+
+  it "can give p7" do
+    tone_row = Dodecaphony::Row.new %w[ d c# a b- f eb e c ab g f# b ]
+      
+    expect(tone_row.p7).to eq %w[ a ab e f c b- b g eb d c# f# ]
+  end
+
+  it "can give i0" do
+    tone_row = Dodecaphony::Row.new %w[ A ab a# b c c# d eb e f gb g ]
+
+    expect(tone_row.i0).to eq %w[ A a# ab g gb f e eb d c# c b ]
+  end
+
+  it "can give i8" do
+    tone_row = Dodecaphony::Row.new %w[ A ab a# b c c# d eb e f gb g ]
+
+    expect(tone_row.i8).to eq %w[ f gb e eb d c# c b a# A ab g ]
+  end
+  
+  it "can give r0" do
+    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+    expect(tone_row.r0).to eq %w[ eb c c# d bb b f e ab g f# a ]
+  end
+  
+  it "can give r9" do
+    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+    expect(tone_row.r9).to eq %w[ c a bb b g ab d c# f e eb f# ]
+  end
+
+  it "can give ri0" do
+    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+    expect(tone_row.ri0).to eq %w[eb f# f e ab g c# d bb b c a ]
+  end
+
+  it "can give ri11" do
+    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+    expect(tone_row.ri10).to eq %w[ c# e eb d f# f b c ab a bb g ]
+  end
+
+  it "converts to a reasonable string" do
+    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+
+    expect(tone_row.to_s).to eq "a f# g ab e f b bb d c# c eb"
+  end
+
+end

data/spec/pitch_spec.rb

@@ -0,0 +1,54 @@
+require 'pitch'
+
+describe Dodecaphony::Pitch do
+
+  it "can tell you its pitch name" do
+    pitch = Dodecaphony::Pitch.new "A"
+
+    expect(pitch.name).to eq "A"
+  end
+
+  it "can tell you its distance from another pitch" do
+    first_pitch = Dodecaphony::Pitch.new "d"
+    second_pitch = Dodecaphony::Pitch.new "f"
+
+    expect(first_pitch.distance_from second_pitch).to eq 3
+  end
+
+  it "responds with the ascending distance, not an inversion for length" do
+    first_pitch = Dodecaphony::Pitch.new "f"
+    second_pitch = Dodecaphony::Pitch.new "e"
+
+    expect(first_pitch.distance_from second_pitch).to eq 11
+  end
+
+  it "understands unusual pitch names" do
+    first_pitch = Dodecaphony::Pitch.new "fb"
+    second_pitch = Dodecaphony::Pitch.new "A+++"
+
+    expect(first_pitch.distance_from second_pitch).to eq 8
+  end
+
+  it "understands more unusual pitch names" do
+    first_pitch = Dodecaphony::Pitch.new "g#####"
+    second_pitch = Dodecaphony::Pitch.new "C"
+
+    expect(first_pitch.distance_from second_pitch).to eq 0
+  end
+
+  it "can respell pitch as a normalized sharp" do
+    pitch = Dodecaphony::Pitch.new "G++++++"
+
+    expect(pitch.spell_as_sharp).to eq "C#"
+  end
+
+  it "can respell pitch as a normalized flat" do
+    pitch = Dodecaphony::Pitch.new "c###"
+
+    expect(pitch.spell_as_flat).to eq "Eb"
+  end
+
+  it "raises an error with an invalid pitch name" do
+    expect {Dodecaphony::Pitch.new "H"}.to raise_error(ArgumentError, 'invalid pitch name')
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: dodecaphony
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin McGladdery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+description: A gem for calculating twelve-tone rows
+email:
+- kevin.mcgladdery@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Readme.md
+- lib/dodecaphony.rb
+- lib/pitch.rb
+- spec/dodecaphony_spec.rb
+- spec/pitch_spec.rb
+homepage: http://github.com/runkmc/dodecaphony
+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.3.0
+signing_key: 
+specification_version: 4
+summary: Tone Row Calculator
+test_files:
+- spec/dodecaphony_spec.rb
+- spec/pitch_spec.rb