Improved getRankedChords algorithm

Sources/Tonic/Accidental.swift

@@ -43,3 +43,12 @@ extension Accidental: Comparable {
         lhs.rawValue < rhs.rawValue
     }
 }
+
+extension Accidental {
+    var isDouble: Bool {
+        switch self {
+            case .doubleFlat, .doubleSharp: return true
+            default: return false
+        }
+    }
+}

Sources/Tonic/Chord.swift

@@ -182,22 +182,73 @@ extension Chord {
         }
         return count
     }
-
-    /// Get chords that match a set of pitches, ranking by least number of accidentals
-    public static func getRankedChords(from pitchSet: PitchSet) -> [Chord] {
-        var noteArrays: Set<[Note]> = []
+
+    /// Get chords from a PitchSet, ranked by simplicity of notation
+    /// - Parameters:
+    ///   - pitchSet: Pitches to be analyzed
+    ///   - allowTheoreticalChords: This algorithim will provide chords with double flats, double sharps, and inergonomic root notes like E# and Cb
+    public static func getRankedChords(from pitchSet: PitchSet, allowTheoreticalChords: Bool = false) -> [Chord] {
+        var enharmonicNoteArrays: [[Note]] = []
         var returnArray: [Chord] = []
-
-        for key in Key.circleOfFifths {
-            noteArrays.insert(pitchSet.array.map { Note(pitch: $0, key: key) })
+        for pitch in pitchSet.array {
+            let octave = pitch.note(in: .C).octave
+            var noteArray: [Note] = []
+            for letter in Letter.allCases {
+                for accidental in Accidental.allCases {
+                    var intValue = Int(letter.baseNote) + Int(accidental.rawValue)
+                    if intValue > 11 {
+                        intValue -= 12
+                    }
+                    if intValue < 0 {
+                        intValue += 12
+                    }
+                    if pitch.midiNoteNumber % 12 == intValue {
+                        noteArray.append(Note(letter, accidental: accidental, octave: octave))
+                    }
+                }
+            }
+            noteArray.sort { n1, n2 in
+                abs(n1.accidental.rawValue) < abs(n2.accidental.rawValue)
+            }
+            enharmonicNoteArrays.append(noteArray)
         }
+        let chordSearchIntervalArray: [[Interval]] =
+        [[.M3, .m3], [.P5, .d5], [.M7, .m7], [.M9, .m9, .A9], [.P11, .A11], [.M13, .m13, .A13]]
 
-        for key in Key.circleOfFourths {
-            noteArrays.insert(pitchSet.array.map { Note(pitch: $0, key: key) })
+        var foundNoteArrays: [[Note]] = []
+        for enharmonicNoteArray in enharmonicNoteArrays {
+            for rootNote in enharmonicNoteArray {
+                var usedNoteArrays: [[Note]] = [enharmonicNoteArray]
+                var foundNotes: [Note] = []
+                foundNotes.append(rootNote)
+                for nextIntervals in chordSearchIntervalArray {
+                    var foundNote = false
+                    for nextInterval in nextIntervals {
+                        if foundNote { continue }
+                        guard let searchNoteClass = rootNote.shiftUp(nextInterval)?.noteClass else { continue }
+                        for noteArray in enharmonicNoteArrays where !usedNoteArrays.contains(noteArray) {
+                            if noteArray.map({$0.noteClass}).contains(searchNoteClass) {
+                                guard let matchedNote = noteArray.first(where: {$0.noteClass == searchNoteClass}) else { continue }
+                                foundNotes.append(matchedNote)
+                                usedNoteArrays.append(noteArray)
+                                foundNote = true
+                            }
+                        }
+                    }
+                    if foundNotes.count == pitchSet.count {
+                        foundNoteArrays.append(foundNotes)
+                    }
+                }
+            }
         }
 
-        for noteArray in noteArrays {
-            returnArray.append(contentsOf: Chord.getRankedChords(from: noteArray))
+        for foundNoteArray in foundNoteArrays {
+            let chords = Chord.getRankedChords(from: foundNoteArray)
+            for chord in chords {
+                if !returnArray.contains(chord) {
+                    returnArray.append(chord)
+                }
+            }
         }
 
         // Sorts anti-alphabetical, but the net effect is to pefer flats to sharps
@@ -211,16 +262,32 @@ extension Chord {
 
         // prefer root notes not being uncommon enharmonics
         returnArray.sort { ($0.root.canonicalNote.isUncommonEnharmonic ? 1 : 0) < ($1.root.canonicalNote.isUncommonEnharmonic ? 1 : 0) }
-
-
+
+        if !allowTheoreticalChords {
+            returnArray = returnArray.filter { chord in
+                !chord.root.accidental.isDouble
+            }
+            returnArray = returnArray.filter { chord in
+                !chord.root.canonicalNote.isUncommonEnharmonic
+            }
+            returnArray = returnArray.filter { chord in
+                !chord.bassNote.canonicalNote.isUncommonEnharmonic
+            }
+            returnArray = returnArray.filter { chord in
+                !chord.bassNote.accidental.isDouble
+            }
+        }
+
         return returnArray
     }
+
     /// Get chords from actual notes (spelling matters, C# F G# will not return a C# major)
     /// Use pitch set version of this function for all enharmonic chords
     /// The ranking is based on how low the root note of the chord appears, for example we
     /// want to list the notes C, E, G, A as C6 if the C is in the bass
     public static func getRankedChords(from notes: [Note]) -> [Chord] {
         let potentialChords = ChordTable.shared.getAllChordsForNoteSet(NoteSet(notes: notes))
+        if potentialChords.isEmpty { return [] }
         let orderedNotes = notes.sorted(by: { f, s in  f.noteNumber < s.noteNumber })
         var ranks: [(Int, Chord)] = []
         for chord in potentialChords {