head_music 8.3.0 → 11.0.0

data/lib/head_music/time/smpte_timecode.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module HeadMusic
+  module Time
+    # Represents a SMPTE (Society of Motion Picture and Television Engineers) timecode
+    #
+    # SMPTE timecode is used for synchronizing audio and video in professional
+    # production. It represents time as HH:MM:SS:FF (hours:minutes:seconds:frames).
+    #
+    # The framerate determines how many frames occur per second. Common framerates:
+    # - 24 fps: Film standard
+    # - 25 fps: PAL video standard (Europe)
+    # - 30 fps: NTSC video standard (North America)
+    # - 29.97 fps: NTSC drop-frame
+    #
+    # @example Creating a timecode at 1 hour
+    #   timecode = HeadMusic::Time::SmpteTimecode.new(1, 0, 0, 0)
+    #   timecode.to_s # => "01:00:00:00"
+    #
+    # @example Parsing from a string
+    #   timecode = HeadMusic::Time::SmpteTimecode.parse("02:30:45:15")
+    #   timecode.hour # => 2
+    #   timecode.minute # => 30
+    #
+    # @example Normalizing with overflow
+    #   timecode = HeadMusic::Time::SmpteTimecode.new(0, 0, 0, 60, framerate: 30)
+    #   timecode.normalize!
+    #   timecode.to_s # => "00:00:02:00" (frames carried into seconds)
+    #
+    # @example Comparing timecodes
+    #   tc1 = HeadMusic::Time::SmpteTimecode.new(1, 0, 0, 0)
+    #   tc2 = HeadMusic::Time::SmpteTimecode.new(1, 30, 0, 0)
+    #   tc1 < tc2 # => true
+    class SmpteTimecode
+      include Comparable
+
+      # @return [Integer] the hour component
+      attr_reader :hour
+
+      # @return [Integer] the minute component
+      attr_reader :minute
+
+      # @return [Integer] the second component
+      attr_reader :second
+
+      # @return [Integer] the frame component
+      attr_reader :frame
+
+      # @return [Integer] frames per second (default: 30 for NTSC)
+      attr_reader :framerate
+
+      # Default framerate (30 fps NTSC)
+      DEFAULT_FRAMERATE = 30
+
+      # Seconds per minute
+      SECONDS_PER_MINUTE = 60
+
+      # Minutes per hour
+      MINUTES_PER_HOUR = 60
+
+      # Parse a timecode from a string representation
+      #
+      # @param identifier [String] timecode in "HH:MM:SS:FF" format
+      # @return [SmpteTimecode] the parsed timecode
+      # @example
+      #   SmpteTimecode.parse("02:30:45:15")
+      def self.parse(identifier)
+        new(*identifier.scan(/\d+/)[0..3])
+      end
+
+      # Create a new SMPTE timecode
+      #
+      # @param hour [Integer, String] the hour component (default: 0)
+      # @param minute [Integer, String] the minute component (default: 0)
+      # @param second [Integer, String] the second component (default: 0)
+      # @param frame [Integer, String] the frame component (default: 0)
+      # @param framerate [Integer] frames per second (default: 30)
+      def initialize(hour = 0, minute = 0, second = 0, frame = 0, framerate: DEFAULT_FRAMERATE)
+        @hour = hour.to_i
+        @minute = minute.to_i
+        @second = second.to_i
+        @frame = frame.to_i
+        @framerate = framerate
+        @total_frames = nil
+      end
+
+      # Convert timecode to array format
+      #
+      # @return [Array<Integer>] [hour, minute, second, frame]
+      def to_a
+        [hour, minute, second, frame]
+      end
+
+      # Convert timecode to string format with zero padding
+      #
+      # @return [String] timecode in "HH:MM:SS:FF" format
+      def to_s
+        format("%02d:%02d:%02d:%02d", hour, minute, second, frame)
+      end
+
+      # Normalize the timecode, handling overflow and underflow
+      #
+      # This method modifies the timecode in place, carrying excess values
+      # from lower levels to higher levels (frames → seconds → minutes → hours).
+      # Also handles negative values by borrowing from higher levels.
+      #
+      # @return [self] returns self for method chaining
+      # @example
+      #   timecode = SmpteTimecode.new(0, 0, 0, 60, framerate: 30)
+      #   timecode.normalize! # => "00:00:02:00"
+      def normalize!
+        @total_frames = nil # Invalidate cached value
+
+        # Carry frames into seconds
+        if frame >= framerate || frame.negative?
+          second_delta, @frame = frame.divmod(framerate)
+          @second += second_delta
+        end
+
+        # Carry seconds into minutes
+        if second >= SECONDS_PER_MINUTE || second.negative?
+          minute_delta, @second = second.divmod(SECONDS_PER_MINUTE)
+          @minute += minute_delta
+        end
+
+        # Carry minutes into hours
+        if minute >= MINUTES_PER_HOUR || minute.negative?
+          hour_delta, @minute = minute.divmod(MINUTES_PER_HOUR)
+          @hour += hour_delta
+        end
+
+        self
+      end
+
+      # Compare this timecode to another
+      #
+      # @param other [SmpteTimecode] another timecode to compare
+      # @return [Integer] -1 if less than, 0 if equal, 1 if greater than
+      def <=>(other)
+        to_total_frames <=> other.to_total_frames
+      end
+
+      # Convert timecode to total frames from the beginning
+      #
+      # @return [Integer] total frames
+      def to_total_frames
+        return @total_frames if @total_frames
+
+        total = 0
+        total += hour * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * framerate
+        total += minute * SECONDS_PER_MINUTE * framerate
+        total += second * framerate
+        total += frame
+
+        @total_frames = total
+      end
+
+      protected
+
+      # Allow other SmpteTimecode instances to access this method for comparison
+      alias_method :to_i, :to_total_frames
+    end
+  end
+end

data/lib/head_music/time/tempo_event.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module HeadMusic
+  module Time
+    # Represents a tempo change at a specific musical position
+    #
+    # TempoEvent marks a point in a musical timeline where the tempo changes.
+    # This is essential for converting between clock time and musical position,
+    # as different tempos affect how long each beat takes in real time.
+    #
+    # @example Creating a tempo change to quarter = 120 at bar 1
+    #   position = HeadMusic::Time::MusicalPosition.new(1, 1, 0, 0)
+    #   event = HeadMusic::Time::TempoEvent.new(position, "quarter", 120)
+    #
+    # @example With a dotted quarter note tempo
+    #   position = HeadMusic::Time::MusicalPosition.new(5, 1, 0, 0)
+    #   event = HeadMusic::Time::TempoEvent.new(position, "dotted quarter", 92)
+    #
+    # @example With an eighth note tempo
+    #   position = HeadMusic::Time::MusicalPosition.new(10, 1, 0, 0)
+    #   event = HeadMusic::Time::TempoEvent.new(position, "eighth", 140)
+    class TempoEvent
+      # @return [MusicalPosition] the position where this tempo change occurs
+      attr_accessor :position
+
+      # @return [HeadMusic::Rudiment::Tempo] the tempo
+      attr_accessor :tempo
+
+      # Create a new tempo change event
+      #
+      # @param position [MusicalPosition] where the tempo change occurs
+      # @param beat_value [String] the rhythmic value that gets the beat (e.g., "quarter", "eighth")
+      # @param beats_per_minute [Numeric] the tempo in beats per minute
+      def initialize(position, beat_value, beats_per_minute)
+        @position = position
+        @tempo = HeadMusic::Rudiment::Tempo.new(beat_value, beats_per_minute)
+      end
+    end
+  end
+end

data/lib/head_music/time/tempo_map.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module HeadMusic
+  module Time
+    # Manages tempo changes along a musical timeline
+    #
+    # A TempoMap maintains a sorted list of tempo changes at specific musical
+    # positions, allowing you to determine which tempo is active at any point
+    # and iterate through tempo segments for time calculations.
+    #
+    # This is essential for converting between clock time and musical position
+    # when the tempo changes during a composition.
+    #
+    # @example Basic usage
+    #   tempo_map = HeadMusic::Time::TempoMap.new
+    #   tempo_map.add_change(MusicalPosition.new(5, 1, 0, 0), "quarter", 96)
+    #   tempo_map.add_change(MusicalPosition.new(9, 1, 0, 0), "quarter", 140)
+    #
+    #   tempo = tempo_map.tempo_at(MusicalPosition.new(7, 1, 0, 0))
+    #   tempo.beats_per_minute # => 96.0
+    #
+    # @example Iterating through segments
+    #   from = MusicalPosition.new(1, 1, 0, 0)
+    #   to = MusicalPosition.new(10, 1, 0, 0)
+    #   tempo_map.each_segment(from, to) do |start_pos, end_pos, tempo|
+    #     # Calculate clock time for this segment
+    #   end
+    class TempoMap
+      # @return [Array<TempoEvent>] all tempo events in chronological order
+      attr_reader :events
+
+      # Create a new tempo map
+      #
+      # @param starting_tempo [HeadMusic::Rudiment::Tempo] initial tempo (default: quarter = 120)
+      # @param starting_position [MusicalPosition] where the initial tempo begins (default: 1:1:0:0)
+      def initialize(starting_tempo: nil, starting_position: nil)
+        starting_tempo ||= HeadMusic::Rudiment::Tempo.new("quarter", 120)
+        starting_position ||= MusicalPosition.new
+        @events = [TempoEvent.new(starting_position, starting_tempo.beat_value.to_s, starting_tempo.beats_per_minute)]
+        @meter = nil # Will be set when used with a MeterMap
+      end
+
+      # Add a tempo change at the specified position
+      #
+      # If a tempo change already exists at this position, it will be replaced.
+      # Events are automatically maintained in sorted order.
+      #
+      # @param position [MusicalPosition] where the tempo change occurs
+      # @param beat_value_or_tempo [String, HeadMusic::Rudiment::Tempo] either a beat value like "quarter" or a Tempo object
+      # @param beats_per_minute [Numeric, nil] BPM (required if beat_value_or_tempo is a string)
+      # @return [TempoEvent] the created event
+      def add_change(position, beat_value_or_tempo, beats_per_minute = nil)
+        # Remove any existing event at this position (except the first)
+        remove_change(position)
+
+        # Create the new event
+        event = if beat_value_or_tempo.is_a?(HeadMusic::Rudiment::Tempo)
+          TempoEvent.new(position, beat_value_or_tempo.beat_value.to_s, beat_value_or_tempo.beats_per_minute).tap do |e|
+            e.tempo = beat_value_or_tempo
+          end
+        else
+          TempoEvent.new(position, beat_value_or_tempo, beats_per_minute)
+        end
+
+        @events << event
+        sort_events!
+        event
+      end
+
+      # Remove a tempo change at the specified position
+      #
+      # The starting tempo (first event) cannot be removed.
+      #
+      # @param position [MusicalPosition] the position of the event to remove
+      # @return [void]
+      def remove_change(position)
+        @events.reject! do |event|
+          event != @events.first && positions_equal?(event.position, position)
+        end
+      end
+
+      # Remove all tempo changes except the starting tempo
+      #
+      # @return [void]
+      def clear_changes
+        @events = [@events.first]
+      end
+
+      # Find the tempo active at a given position
+      #
+      # Returns the tempo from the most recent tempo event at or before
+      # the specified position.
+      #
+      # @param position [MusicalPosition] the position to query
+      # @return [HeadMusic::Rudiment::Tempo] the active tempo
+      def tempo_at(position)
+        # Normalize positions for comparison if we have a meter
+        normalized_pos = @meter ? position.dup.tap { |p| p.normalize!(@meter) } : position
+
+        # Find the last event at or before this position
+        active_event = @events.reverse.find do |event|
+          normalized_event_pos = @meter ? event.position.dup.tap { |p| p.normalize!(@meter) } : event.position
+          normalized_event_pos <= normalized_pos
+        end
+
+        active_event&.tempo || @events.first.tempo
+      end
+
+      # Iterate through tempo segments between two positions
+      #
+      # Yields each segment with its start position, end position, and tempo.
+      # Segments are created wherever a tempo change occurs within the range.
+      #
+      # @param from_position [MusicalPosition] start of the range
+      # @param to_position [MusicalPosition] end of the range
+      # @yield [start_position, end_position, tempo] for each segment
+      # @yieldparam start_position [MusicalPosition] segment start
+      # @yieldparam end_position [MusicalPosition] segment end
+      # @yieldparam tempo [HeadMusic::Rudiment::Tempo] active tempo
+      # @return [void]
+      def each_segment(from_position, to_position)
+        # Normalize positions if we have a meter
+        from_pos = @meter ? from_position.dup.tap { |p| p.normalize!(@meter) } : from_position
+        to_pos = @meter ? to_position.dup.tap { |p| p.normalize!(@meter) } : to_position
+
+        # Find events that affect this range
+        relevant_events = @events.select do |event|
+          normalized_event_pos = @meter ? event.position.dup.tap { |p| p.normalize!(@meter) } : event.position
+          normalized_event_pos < to_pos
+        end
+
+        # Start with the tempo active at from_position
+        current_pos = from_pos
+        current_tempo = tempo_at(from_pos)
+
+        # Iterate through relevant events
+        relevant_events.each do |event|
+          normalized_event_pos = @meter ? event.position.dup.tap { |p| p.normalize!(@meter) } : event.position
+
+          # Skip events before our starting position
+          next if normalized_event_pos <= from_pos
+
+          # Yield the segment up to this event
+          yield current_pos, normalized_event_pos, current_tempo
+
+          # Move to next segment
+          current_pos = normalized_event_pos
+          current_tempo = event.tempo
+        end
+
+        # Yield the final segment to the end position
+        yield current_pos, to_pos, current_tempo
+      end
+
+      # Set the meter for position normalization
+      #
+      # @param meter [HeadMusic::Rudiment::Meter] the meter to use
+      # @return [void]
+      # @api private
+      attr_writer :meter
+
+      private
+
+      # Sort events by position
+      #
+      # @return [void]
+      def sort_events!
+        @events.sort_by! do |event|
+          pos = event.position
+          [pos.bar, pos.beat, pos.tick, pos.subtick]
+        end
+      end
+
+      # Check if two positions are equal
+      #
+      # @param pos1 [MusicalPosition] first position
+      # @param pos2 [MusicalPosition] second position
+      # @return [Boolean] true if positions are equal
+      def positions_equal?(pos1, pos2)
+        pos1.bar == pos2.bar &&
+          pos1.beat == pos2.beat &&
+          pos1.tick == pos2.tick &&
+          pos1.subtick == pos2.subtick
+      end
+    end
+  end
+end

data/lib/head_music/time.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module HeadMusic
+  # The Time module provides classes and methods to handle representations
+  # of musical time and its relationship to clock time and SMPTE Time Code.
+  #
+  # This module enables synchronization between three time representations:
+  # - Clock time: elapsed nanoseconds (source of truth)
+  # - Musical position: bars:beats:ticks:subticks notation
+  # - SMPTE timecode: hours:minutes:seconds:frames for video/audio sync
+  #
+  # @example Converting between time representations
+  #   conductor = HeadMusic::Time::Conductor.new
+  #   clock_pos = HeadMusic::Time::ClockPosition.new(1_000_000_000) # 1 second
+  #   musical_pos = conductor.clock_to_musical(clock_pos)
+  module Time
+    # Ticks per quarter note value (MIDI standard)
+    PPQN = PULSES_PER_QUARTER_NOTE = 960
+
+    # Subticks provide finer resolution than ticks for precise timing
+    SUBTICKS_PER_TICK = 240
+  end
+end
+
+require_relative "time/clock_position"
+require_relative "time/musical_position"
+require_relative "time/smpte_timecode"
+require_relative "time/meter_event"
+require_relative "time/tempo_event"
+require_relative "time/tempo_map"
+require_relative "time/meter_map"
+require_relative "time/conductor"

data/lib/head_music/utilities/case.rb

@@ -0,0 +1,27 @@
+# A namespace for utilities classes and modules
+module HeadMusic::Utilities; end
+
+# Util for converting an object to a particular case
+class HeadMusic::Utilities::Case
+  def self.to_snake_case(text)
+    text.to_s
+      .gsub("::", "/")
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr("-", "_")
+      .tr(" ", "_")
+      .gsub(/[^\w\/]+/, "_")
+      .squeeze("_")
+      .gsub(/^_|_$/, "")
+      .downcase
+  end
+
+  def self.to_kebab_case(text)
+    to_snake_case(text).tr("_", "-")
+  end
+
+  def self.to_camel_case(text)
+    str = to_snake_case(text)
+    str.split("_").map.with_index { |word, index| index.zero? ? word : word.capitalize }.join
+  end
+end

data/lib/head_music/utilities/hash_key.rb

@@ -2,8 +2,40 @@
 module HeadMusic::Utilities; end
 
 # Util for converting an object to a consistent hash key
-module HeadMusic::Utilities::HashKey
+class HeadMusic::Utilities::HashKey
   def self.for(identifier)
-    I18n.transliterate(identifier.to_s).downcase.gsub(/\W+/, "_").to_sym
+    @hash_keys ||= {}
+    @hash_keys[identifier] ||= new(identifier).to_sym
+  end
+
+  attr_reader :original
+
+  def initialize(identifier)
+    @original = identifier
+  end
+
+  def to_sym
+    normalized_string.to_sym
+  end
+
+  private
+
+  def normalized_string
+    @normalized_string ||=
+      HeadMusic::Utilities::Case.to_snake_case(transliterated_string)
+  end
+
+  def transliterated_string
+    I18n.transliterate(desymbolized_string)
+  end
+
+  def desymbolized_string
+    original.to_s
+      .gsub("𝄫", "_double_flat")
+      .gsub("♭", "_flat")
+      .gsub("♮", "_natural")
+      .gsub("♯", "_sharp")
+      .gsub("#", "_sharp")
+      .gsub("𝄪", "_double_sharp")
   end
 end

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "8.3.0"
+  VERSION = "11.0.0"
 end

data/lib/head_music.rb

@@ -13,59 +13,100 @@ require "humanize"
 require "i18n"
 require "i18n/backend/fallbacks"
 
-I18n::Backend::Simple.include I18n::Backend::Fallbacks
-I18n.load_path << Dir[File.join(File.dirname(__dir__), "lib", "head_music", "locales", "*.yml")]
-I18n.config.available_locales = %i[en fr de it ru es en_US en_GB]
-I18n.default_locale = :en
-I18n.fallbacks[:de] = %i[de en_GB en]
-I18n.fallbacks[:en_US] = %i[en_US en en_GB]
-I18n.fallbacks[:en_GB] = %i[en_GB en en_US]
-I18n.fallbacks[:es] = %i[es en]
-I18n.fallbacks[:fr] = %i[fr en_GB en]
-I18n.fallbacks[:it] = %i[it en_GB en]
-I18n.fallbacks[:ru] = %i[ru en_GB en]
+# Configure I18n for HeadMusic locales
+# Include fallbacks backend if not already included
+I18n::Backend::Simple.include(I18n::Backend::Fallbacks) unless I18n::Backend::Simple.included_modules.include?(I18n::Backend::Fallbacks)
+
+# Add HeadMusic locale files to the load path (additive, doesn't overwrite)
+I18n.load_path += Dir[File.join(File.dirname(__dir__), "lib", "head_music", "locales", "*.yml")]
+
+# Add HeadMusic locales to available locales (additive, doesn't overwrite existing)
+HEAD_MUSIC_LOCALES = %i[en fr de it ru es en_US en_GB].freeze
+existing_locales = I18n.config.available_locales || []
+I18n.config.available_locales = (existing_locales + HEAD_MUSIC_LOCALES).uniq
+
+# Configure fallbacks for HeadMusic locales (only if not already configured)
+# These provide sensible defaults for music terminology translations
+HEAD_MUSIC_FALLBACKS = {
+  de: %i[de en_GB en],
+  en_US: %i[en_US en en_GB],
+  en_GB: %i[en_GB en en_US],
+  es: %i[es en],
+  fr: %i[fr en_GB en],
+  it: %i[it en_GB en],
+  ru: %i[ru en_GB en]
+}.freeze
+
+HEAD_MUSIC_FALLBACKS.each do |locale, fallbacks|
+  I18n.fallbacks[locale] = fallbacks if I18n.fallbacks[locale].empty? || I18n.fallbacks[locale] == [locale]
+end
 
 # utilities
+require "head_music/utilities/case"
 require "head_music/utilities/hash_key"
 
 # modules
 require "head_music/named"
 
 # rudiments
+require "head_music/rudiment/base"
+require "head_music/rudiment/letter_name"
 require "head_music/rudiment/alteration"
+require "head_music/rudiment/spelling"
+require "head_music/rudiment/rhythmic_unit"
+require "head_music/rudiment/rhythmic_unit/parser"
+require "head_music/rudiment/rhythmic_value"
+require "head_music/rudiment/rhythmic_value/parser"
+require "head_music/rudiment/register"
+require "head_music/rudiment/pitch"
+require "head_music/rudiment/pitch/parser"
+require "head_music/rudiment/rhythmic_element"
+require "head_music/rudiment/note"
+require "head_music/rudiment/unpitched_note"
+require "head_music/rudiment/rest"
+
 require "head_music/rudiment/chromatic_interval"
 require "head_music/rudiment/clef"
 require "head_music/rudiment/consonance"
+require "head_music/rudiment/tonal_context"
+require "head_music/rudiment/diatonic_context"
+require "head_music/rudiment/key"
+require "head_music/rudiment/mode"
 require "head_music/rudiment/key_signature"
 require "head_music/rudiment/key_signature/enharmonic_equivalence"
-require "head_music/rudiment/letter_name"
 require "head_music/rudiment/meter"
-require "head_music/rudiment/musical_symbol"
-require "head_music/rudiment/pitch"
 require "head_music/rudiment/pitch/enharmonic_equivalence"
 require "head_music/rudiment/pitch/octave_equivalence"
 require "head_music/rudiment/pitch_class"
 require "head_music/rudiment/quality"
 require "head_music/rudiment/reference_pitch"
-require "head_music/rudiment/register"
 require "head_music/rudiment/rhythm"
-require "head_music/rudiment/rhythmic_unit"
 require "head_music/rudiment/scale"
 require "head_music/rudiment/scale_degree"
 require "head_music/rudiment/scale_type"
 require "head_music/rudiment/solmization"
-require "head_music/rudiment/spelling"
+require "head_music/rudiment/tempo"
 require "head_music/rudiment/tuning"
 require "head_music/rudiment/tuning/just_intonation"
-require "head_music/rudiment/tuning/pythagorean"
 require "head_music/rudiment/tuning/meantone"
+require "head_music/rudiment/tuning/pythagorean"
+
+# time
+require "head_music/time"
 
 # instruments
 require "head_music/instruments/instrument_family"
-require "head_music/instruments/instrument"
+require "head_music/instruments/variant"
+require "head_music/instruments/playing_technique"
 require "head_music/instruments/staff_scheme"
 require "head_music/instruments/staff"
-require "head_music/instruments/variant"
+require "head_music/instruments/instrument_configuration_option"
+require "head_music/instruments/instrument_configuration"
+require "head_music/instruments/instrument"
+require "head_music/instruments/stringing_course"
+require "head_music/instruments/stringing"
+require "head_music/instruments/alternate_tuning"
+require "head_music/instruments/score_order"
 
 # content
 require "head_music/content/bar"
@@ -73,10 +114,12 @@ require "head_music/content/composition"
 require "head_music/content/note"
 require "head_music/content/placement"
 require "head_music/content/position"
-require "head_music/content/rhythmic_value"
 require "head_music/content/staff"
 require "head_music/content/voice"
 
+# notation
+require "head_music/notation"
+
 # analysis
 require "head_music/analysis/circle"
 require "head_music/analysis/diatonic_interval"
@@ -85,15 +128,21 @@ require "head_music/analysis/diatonic_interval/naming"
 require "head_music/analysis/diatonic_interval/parser"
 require "head_music/analysis/diatonic_interval/semitones"
 require "head_music/analysis/diatonic_interval/size"
+require "head_music/analysis/dyad"
 require "head_music/analysis/harmonic_interval"
+require "head_music/analysis/interval_consonance"
 require "head_music/analysis/interval_cycle"
 require "head_music/analysis/melodic_interval"
 require "head_music/analysis/motion"
 require "head_music/analysis/pitch_class_set"
-require "head_music/analysis/pitch_set"
+require "head_music/analysis/pitch_collection"
 require "head_music/analysis/sonority"
 
 # style analysis
+require "head_music/style/tradition"
+require "head_music/style/modern_tradition"
+require "head_music/style/renaissance_tradition"
+require "head_music/style/medieval_tradition"
 require "head_music/style/analysis"
 require "head_music/style/annotation"
 require "head_music/style/mark"