Improve handling of greek letters in star names

ncke · ncke · commit 9c69fa8cef2d · 2025-05-28T23:16:02.000+01:00
diff --git a/Sources/SwiftAstro/StarCatalog/BrightStar+Nameable.swift b/Sources/SwiftAstro/StarCatalog/BrightStar+Nameable.swift
@@ -5,29 +5,14 @@ import Foundation
 extension SwiftAstro.BrightStar : SwiftAstro.AstronomicallyNameable {
 
     public var name: String? {
-        namedInNotes ?? commonlyNamed
-    }
-
-    private var namedInNotes: String? {
-        guard 
-            let namingRemark = notes?.filter({ note in
-                note.noteCategory == .starNames
-            }).first?.remark,
-            let name = namingRemark.split(separator: ";").first
-        else {
-            return nil
+        if let greek = bayerGreek, let constellation = constellation {
+            var n = greek.letter
+            if let number = greek.number { n += "\(number)" }
+            n += " \(constellation)"
+            return n
         }
 
-        return name.trimmingCharacters(in: .whitespaces)
-    }
-
-    private var commonlyNamed: String? {
-        guard let commonName = commonName else { return nil }
-        let parts = commonName
-            .components(separatedBy: .whitespaces)
-            .filter { p in !p.isEmpty }
-        
-        return parts.joined(separator: " ")
+        return nil
     }
 
 }
diff --git a/Sources/SwiftAstro/StarCatalog/BrightStar.swift b/Sources/SwiftAstro/StarCatalog/BrightStar.swift
@@ -11,9 +11,15 @@ extension SwiftAstro {
         /// Harvard Revised Star Number (Bright Star Number).
         public let number: Int
         
-        /// Common name of the star.
-        public let commonName: String?
-        
+        /// Flamsteed number of the star.
+        public let flamsteedNumber: Int?
+
+        /// Bayer greek designation of the star.
+        public let bayerGreek: Greek?
+
+        /// Constellation genitive of the star.
+        public let constellation: String?
+
         /// Durchmusterung Identification.
         public let durchmusterungIdentification: String?
         
diff --git a/Sources/SwiftAstro/StarCatalog/BrightStarCatalog.swift b/Sources/SwiftAstro/StarCatalog/BrightStarCatalog.swift
@@ -72,9 +72,25 @@ private extension SwiftAstro.BrightStarCatalog {
                 componentsSeparation = nil
             }
 
+            let flamsteedNumber: Int?
+            if let flamsteed: Int = line.cols(6, 2) {
+                flamsteedNumber = flamsteed
+            } else {
+                flamsteedNumber = nil
+            }
+
+            let bayerGreek: SwiftAstro.Greek?
+            if let greek: String = line.cols(8, 4) {
+                bayerGreek = SwiftAstro.Greek(hrCoding: greek)
+            } else {
+                bayerGreek = nil
+            }
+
             let star = SwiftAstro.BrightStar(
                 number: number,
-                commonName: line.cols(5, 10),
+                flamsteedNumber: flamsteedNumber,
+                bayerGreek: bayerGreek,
+                constellation: line.cols(12, 3),
                 durchmusterungIdentification: line.cols(15, 11),
                 henryDraperCatalogNumber: line.cols(26, 6),
                 saoCatalogNumber: line.cols(32, 6),
diff --git a/Sources/SwiftAstro/Units/Greek.swift b/Sources/SwiftAstro/Units/Greek.swift
@@ -0,0 +1,116 @@
+import Foundation
+
+// MARK: - Greek
+
+extension SwiftAstro {
+
+    public struct Greek {
+        public let simbad: Simbad
+        public let letter: String
+        public let number: Int?
+
+        public init(simbad: Simbad, number: Int? = nil) {
+            self.simbad = simbad
+            self.letter = simbad.asLetter
+            self.number = number
+        }
+
+        init?(simbad: Simbad?, number: Int?) {
+            guard let simbad = simbad else { return nil }
+            self.init(simbad: simbad, number: number)
+        }
+
+        public init?(simbadCoding: String) {
+            guard let (coding, number) = Self.split(simbadCoding) else {
+                return nil
+            }
+
+            self.init(
+                simbad: Simbad.fromSimbadCoding(coding),
+                number: number)
+        }
+
+        public init?(hrCoding: String) {
+            guard let (coding, number) = Self.split(hrCoding) else {
+                return nil
+            }
+
+            self.init(
+                simbad: Simbad.fromHRCoding(coding),
+                number: number)
+        }
+
+        public init?(greekLetter: String) {
+            guard let (coding, number) = Self.split(greekLetter) else {
+                return nil
+            }
+
+            self.init(simbad: Simbad.fromLetter(coding), number: number)
+        }
+
+        private static func split(_ string: String) -> (String, Int?)? {
+            let digitIndex = string.firstIndex { c in c.isNumber }
+            guard let idx = digitIndex else { return (string, nil) }
+            let coding = string[string.startIndex..<idx]
+            let digits = string[idx..<string.endIndex]
+            guard let number = Int(digits) else { return nil }
+            return (String(coding), number)
+        }
+
+    }
+
+}
+
+// MARK: - Simbad
+
+extension SwiftAstro.Greek {
+
+    public enum Simbad: Hashable {
+        case alf, bet, gam, del, eps, zet, eta, tet
+        case iot, kap, lam, mu,  nu,  ksi, omi, pi
+        case rho, sig, tau, ups, phi, khi, psi, ome
+
+        private static let simbadLookup: [String: Simbad] = [
+            "alf": .alf, "bet": .bet, "gam": .gam, "del": .del,
+            "eps": .eps, "zet": .zet, "eta": .eta, "tet": .tet,
+            "iot": .iot, "kap": .kap, "lam": .lam, "mu" : .mu,
+            "nu" : .nu,  "ksi": .ksi, "omi": .omi, "pi" : .pi,
+            "rho": .rho, "sig": .sig, "tau": .tau, "ups": .ups,
+            "phi": .phi, "khi": .khi, "psi": .psi, "ome": .omi
+        ]
+
+        private static let hrLookup: [String: Simbad] = [
+            "alp": .alf, "bet": .bet, "gam": .gam, "del": .del,
+            "eps": .eps, "zet": .zet, "eta": .eta, "the": .tet,
+            "iot": .iot, "kap": .kap, "lam": .lam, "mu" : .mu,
+            "nu" : .nu,  "xi" : .ksi, "omi": .omi, "pi" : .pi,
+            "rho": .rho, "sig": .sig, "tau": .tau, "ups": .ups,
+            "phi": .phi, "chi": .khi, "psi": .psi, "ome": .omi
+        ]
+
+        private static let letterLookup: [Simbad: String] = [
+            .alf: "α", .bet: "β", .gam: "γ", .del: "δ",
+            .eps: "ε", .zet: "ζ", .eta: "η", .tet: "θ",
+            .iot: "ι", .kap: "κ", .lam: "λ", .mu : "µ",
+            .nu : "ν", .ksi: "ξ", .omi: "o", .pi : "π",
+            .rho: "ρ", .sig: "σ", .tau: "τ", .ups: "υ",
+            .phi: "φ", .khi: "χ", .psi: "ψ", .ome: "ω",
+        ]
+
+        static func fromSimbadCoding(_ coding: String) -> Simbad? {
+            simbadLookup[coding.lowercased()]
+        }
+
+        static func fromHRCoding(_ coding: String) -> Simbad? {
+            hrLookup[coding.lowercased()]
+        }
+
+        static func fromLetter(_ letter: String) -> Simbad? {
+            (letterLookup.first { (s, g) in letter == g })?.0
+        }
+
+        var asLetter: String { Self.letterLookup[self]! }
+
+    }
+
+}
diff --git a/Tests/SwiftAstroTests/BrightStarCatalogTests.swift b/Tests/SwiftAstroTests/BrightStarCatalogTests.swift
@@ -0,0 +1,24 @@
+import XCTest
+@testable import SwiftAstro
+
+final class BrightStarCatalogTests: XCTestCase {
+
+    func test919() throws {
+        let bsc = SwiftAstro.brightStarCatalog
+        let hr919 = try XCTUnwrap(bsc[919])
+
+        XCTAssertEqual(hr919.flamsteedNumber, 11)
+        XCTAssertEqual(hr919.bayerGreek?.simbad, .tau)
+        XCTAssertEqual(hr919.bayerGreek?.number, 3)
+        XCTAssertEqual(hr919.constellation, "Eri")
+    }
+
+    func test972() throws {
+        let bsc = SwiftAstro.brightStarCatalog
+        let hr947 = try XCTUnwrap(bsc[972])
+
+        XCTAssertEqual(hr947.name, "ζ Ari")
+        XCTAssertEqual(hr947.constellation, "Ari")
+    }
+
+}
diff --git a/Tests/SwiftAstroTests/GreekTests.swift b/Tests/SwiftAstroTests/GreekTests.swift
@@ -0,0 +1,63 @@
+import XCTest
+@testable import SwiftAstro
+
+final class GreekTests: XCTestCase {
+
+    func testSimbad() throws {
+        let g = SwiftAstro.Greek(simbad: .ome)
+        XCTAssertEqual(g.simbad, .ome)
+        XCTAssertEqual(g.letter, "ω")
+    }
+
+    func testSimbadCoding() throws {
+        let g = try XCTUnwrap(SwiftAstro.Greek(simbadCoding: "tet"))
+        XCTAssertEqual(g.simbad, .tet)
+        XCTAssertEqual(g.letter, "θ")
+
+        let noSuch = SwiftAstro.Greek(simbadCoding: "nonsense")
+        XCTAssertNil(noSuch)
+    }
+
+    func testHRCoding() throws {
+        let g = try XCTUnwrap(SwiftAstro.Greek(hrCoding: "the"))
+        XCTAssertEqual(g.simbad, .tet)
+        XCTAssertEqual(g.letter, "θ")
+
+        let noSuch = SwiftAstro.Greek(hrCoding: "nonsense")
+        XCTAssertNil(noSuch)
+    }
+
+    func testGreekLetter() throws {
+        let g = try XCTUnwrap(SwiftAstro.Greek(greekLetter: "ξ"))
+        XCTAssertEqual(g.simbad, .ksi)
+        XCTAssertEqual(g.letter, "ξ")
+
+        let noSuch = SwiftAstro.Greek(simbadCoding: "a")
+        XCTAssertNil(noSuch)
+    }
+
+    func testSimbadWithNumber() throws {
+        let g = try XCTUnwrap(SwiftAstro.Greek(simbadCoding: "alf02"))
+        XCTAssertEqual(g.simbad, .alf)
+        XCTAssertEqual(g.letter, "α")
+        XCTAssertEqual(g.number, 2)
+
+        let noSuch = SwiftAstro.Greek(simbadCoding: "alf02yyy")
+        XCTAssertNil(noSuch)
+    }
+
+    func testGreekLetterWithNumber() throws {
+        let g = try XCTUnwrap(SwiftAstro.Greek(greekLetter: "σ5"))
+        XCTAssertEqual(g.simbad, .sig)
+        XCTAssertEqual(g.letter, "σ")
+        XCTAssertEqual(g.number, 5)
+    }
+
+    func testHRCodingWithNumber() throws {
+        let g = try XCTUnwrap(SwiftAstro.Greek(hrCoding: "Eta1"))
+        XCTAssertEqual(g.simbad, .eta)
+        XCTAssertEqual(g.letter, "η")
+        XCTAssertEqual(g.number, 1)
+    }
+
+}
