Added add4 chords and fixed bug with chords having multiple roots

Author: aure

Sources/Tonic/Chord.swift

@@ -221,6 +221,20 @@ extension Chord {
                 var usedNoteArrays: [[Note]] = [enharmonicNoteArray]
                 var foundNotes: [Note] = []
                 foundNotes.append(rootNote)
+
+                // The root's pitch class can appear at several octaves (guitar
+                // voicings routinely double the root). The interval search below
+                // never looks for a unison/octave, so consume those duplicates
+                // up front. Otherwise they're never matched and `foundNotes`
+                // can't reach `pitchSet.count`, which silently defeats detection
+                // whenever every pitch class in the voicing is doubled.
+                for noteArray in enharmonicNoteArrays where !usedNoteArrays.contains(noteArray) {
+                    if let duplicateRoot = noteArray.first(where: { $0.noteClass == rootNote.noteClass }) {
+                        foundNotes.append(duplicateRoot)
+                        usedNoteArrays.append(noteArray)
+                    }
+                }
+
                 for nextIntervals in chordSearchIntervalArray {
                     var foundNote = false
                     for nextInterval in nextIntervals {

Sources/Tonic/ChordType.swift

@@ -96,6 +96,9 @@ public enum ChordType: String, Sendable, CaseIterable, Codable {
     /// Major Add Nine: Major Third, Perfect Fifth, Major Ninth, e.g. `C(add9)`
     case maj_add9
 
+    /// Major Add Four: Major Third, Perfect Fifth, Perfect Eleventh, e.g. `C(add4)`
+    case maj_add4
+
     /// Minor Add Nine: Minor Third, Perfect Fifth, Major Ninth, e.g. `Cm(add9)`
     case min_add9
 
@@ -629,6 +632,8 @@ public enum ChordType: String, Sendable, CaseIterable, Codable {
                 return [.m3, .P5, .m7, .m9]
             case .maj_add9:
                 return [.M3, .P5, .M9]
+            case .maj_add4:
+                return [.M3, .P5, .P11]
             case .min_add9:
                 return [.m3, .P5, .M9]
             case .dim_add9:
@@ -946,6 +951,7 @@ extension ChordType: CustomStringConvertible {
             case .min9:                        return "m9"
             case .min_maj9:                    return "mMaj9"
             case .maj_add9:                    return "(add9)"
+            case .maj_add4:                    return "(add4)"
             case .min_add9:                    return "m(add9)"
             case .maj_6_9:                     return "6/9"
             case .maj9_flat5:                  return "maj9(♭5)"
@@ -1131,6 +1137,7 @@ extension ChordType: CustomStringConvertible {
             case .min9:                        return "m9"
             case .min_maj9:                    return "m^9"
             case .maj_add9:                    return "@9"
+            case .maj_add4:                    return "@4"
             case .min_add9:                    return "m@9"
             case .maj_6_9:                     return "%"
             case .maj9_flat5:                  return "^9b5"

Tests/TonicTests/ChordTests.swift

@@ -653,5 +653,45 @@ class ChordTests: XCTestCase {
         assertRankedChord([65, 69, 72, 74, 79], expectedDescriptions: ["F6/9", "G9sus4/F", "G11sus2/F", "Dm7(add11)/F"])
         assertRankedChord([65, 69, 72, 76, 79], expectedDescriptions: ["Fmaj9", "Am7(add♭13)/F"])
     }
-    
+
+    // MARK: - Octave-Doubled Voicings
+    //
+    // A chord must be detected the same regardless of how many times its notes
+    // are doubled at other octaves — guitar voicings routinely repeat the root,
+    // third, and fifth across six strings. Detection currently breaks when
+    // *every* pitch class is doubled (e.g. a full six-string D/F♯): the chord
+    // search never matches a unison/octave of the root, so `foundNotes` falls
+    // one short of `pitchSet.count`. The "every note doubled" cases below
+    // document that bug and should pass once it is fixed.
+
+    func testDMajorDetectedInRootPosition() {
+        // D F♯ A
+        assertRankedChord([50, 54, 57], expectedDescriptions: ["D"])
+    }
+
+    func testDMajorOverFSharpDetectedWithDistinctNotes() {
+        // F♯ A D
+        assertRankedChord([42, 45, 50], expectedDescriptions: ["D/F♯"])
+    }
+
+    func testDMajorOverFSharpDetectedWhenFifthAndOctaveDoubled() {
+        // F♯ A D A D — A and D doubled; F♯ is still single so it can root the search
+        assertRankedChord([42, 45, 50, 57, 62], expectedDescriptions: ["D/F♯"])
+    }
+
+    func testDMajorOverFSharpDetectedWhenEveryNoteDoubled() {
+        // F♯ A D A D F♯ — full six-string voicing, every pitch class doubled
+        assertRankedChord([42, 45, 50, 57, 62, 66], expectedDescriptions: ["D/F♯"])
+    }
+
+    func testCMajorDetectedWhenRootAndThirdDoubled() {
+        // C E G C E — G is single so the search can root on G
+        assertRankedChord([60, 64, 67, 72, 76], expectedDescriptions: ["C"])
+    }
+
+    func testCMajorDetectedWhenEveryNoteDoubled() {
+        // C E G C E G — every pitch class doubled
+        assertRankedChord([60, 64, 67, 72, 76, 79], expectedDescriptions: ["C"])
+    }
+
 }