31 · 숫자와 부동소수점

Int.max + 1        → exit 133      # SIGTRAP — 오버플로
Int(1e30)          → exit 133      # SIGTRAP — 표현 범위 초과
Int.min / -1       → exit 133      # SIGTRAP — 결과가 Int.max+1
10 / 0             → exit 133      # SIGTRAP — 0으로 나누기
Int.max &+ 1       → exit 0        # 정상 — 감싸서 Int.min

print("Int.max         =", Int.max)
print("Int.max &+ 1    =", Int.max &+ 1)
let (v, o) = Int.max.addingReportingOverflow(1)
print("addingReportingOverflow(1) = (\(v), overflow: \(o))")

Int.max         = 9223372036854775807
Int.max &+ 1    = -9223372036854775808
addingReportingOverflow(1) = (-9223372036854775808, overflow: true)

print("Int8(exactly: 200) =", Int8(exactly: 200) as Any)
print("Int8(truncatingIfNeeded: 200) =", Int8(truncatingIfNeeded: 200))
print("UInt8(clamping: 300) =", UInt8(clamping: 300),
      "| UInt8(clamping: -5) =", UInt8(clamping: -5))

Int8(exactly: 200) = nil
Int8(truncatingIfNeeded: 200) = -56
UInt8(clamping: 300) = 255 | UInt8(clamping: -5) = 0

func totalBytes(count: Int, itemSize: Int) -> Int? {
    // ❌ count * itemSize  — 손상된 입력이면 트랩
    let (product, overflow) = count.multipliedReportingOverflow(by: itemSize)
    guard !overflow, product >= 0 else { return nil }   // 거부한다
    return product
}

// 서버가 count: Int.max 를 보내도 크래시가 아니라 nil 이 된다
print(totalBytes(count: Int.max, itemSize: 4) as Any)   // nil

// 링 버퍼 인덱스 — 감싸는 것이 정상 동작이다
struct RingIndex {
    private var raw: UInt32 = 0
    let capacity: UInt32
    // private 저장 프로퍼티가 있으면 멤버와이즈 init 이 비공개가 되므로 직접 선언한다
    init(capacity: UInt32) { self.capacity = capacity }
    mutating func advance() {
        raw = raw &+ 1                 // 의도적 wrap — 2^32 주기
    }
    var slot: Int { Int(raw % capacity) }
}

print("Int is BinaryInteger    :", Int.self is any BinaryInteger.Type)
print("Int is FixedWidthInteger:", Int.self is any FixedWidthInteger.Type)
print("Int is SignedInteger    :", Int.self is any SignedInteger.Type)
print("UInt is SignedInteger   :", UInt.self is any SignedInteger.Type)
print("Double is BinaryFloatingPoint:", Double.self is any BinaryFloatingPoint.Type)

Int is BinaryInteger    : true
Int is FixedWidthInteger: true
Int is SignedInteger    : true
UInt is SignedInteger   : false
Double is BinaryFloatingPoint: true

print("-7 / 2 = \(-7 / 2)  -7 % 2 = \(-7 % 2)  7 / -2 = \(7 / -2)  7 % -2 = \(7 % -2)")
print("(-7).quotientAndRemainder(dividingBy: 2) =", (-7).quotientAndRemainder(dividingBy: 2))

-7 / 2 = -3  -7 % 2 = -1  7 / -2 = -3  7 % -2 = 1
(-7).quotientAndRemainder(dividingBy: 2) = (quotient: -3, remainder: -1)

let items = ["a", "b", "c"]

func at(_ i: Int) -> String {
    items[i % items.count]        // ❌ i 가 음수면 인덱스가 음수
}
// at(-1) → -1 % 3 == -1 → items[-1] → 트랩 (exit 133)

func atSafe(_ i: Int) -> String {
    let n = items.count
    let m = ((i % n) + n) % n     // ✅ 항상 0..<n
    return items[m]
}
print(atSafe(-1), atSafe(-4), atSafe(4))   // c c b

c c b

// 산술만 필요하다 — BinaryInteger 로 넓게 받는다
func sumAll<T: BinaryInteger>(_ xs: [T]) -> T {
    xs.reduce(0, +)
}

// 경계값이 필요하다 — FixedWidthInteger 를 요구해야 한다
func saturatingSum<T: FixedWidthInteger>(_ xs: [T]) -> T {
    var acc: T = 0
    for x in xs {
        let (v, o) = acc.addingReportingOverflow(x)
        acc = o ? (x > 0 ? T.max : T.min) : v      // max/min 은 여기서만 쓸 수 있다
    }
    return acc
}
print(saturatingSum([Int.max, 1, 1]))   // 9223372036854775807 — 포화

9223372036854775807

let count: Int32 = 1000
let size: Int = 8

// ❌ count * size — 컴파일 에러: 타입 불일치
// ✅ 어떤 변환인지 결정한다
let total1 = Int(count) * size                        // 넓히기 — 항상 안전
guard let narrowed = Int32(exactly: size) else { ... } // 좁히기 — 실패 가능

print("Double.significandBitCount =", Double.significandBitCount)
print("Float.significandBitCount  =", Float.significandBitCount)

Double.significandBitCount = 52
Float.significandBitCount  = 23

import Foundation
print("0.1 + 0.2       =", 0.1 + 0.2)
print("0.1+0.2 == 0.3  :", (0.1 + 0.2) == 0.3)
print("0.1 실제값(20자리) =", String(format: "%.20f", 0.1))
var acc = 0.0
for _ in 0..<10 { acc += 0.1 }
print("0.1 x10 누적 =", acc, "| == 1.0 :", acc == 1.0)
print("Double.ulpOfOne =", Double.ulpOfOne, "| (0.1).nextUp =", (0.1).nextUp)

0.1 + 0.2       = 0.30000000000000004
0.1+0.2 == 0.3  : false
0.1 실제값(20자리) = 0.10000000000000000555
0.1 x10 누적     = 0.9999999999999999 | == 1.0 : false
Double.ulpOfOne = 2.220446049250313e-16 | (0.1).nextUp = 0.10000000000000002

let a = 0.1 + 0.2
let b = 0.3

// ① == — 실패한다
print("① ==            :", a == b)

// ② 고정 허용 오차 — 값의 크기에 따라 부적절해질 수 있다
print("② abs 차 < 1e-9 :", abs(a - b) < 1e-9)

// ③ ulp 기반 — 값의 크기에 비례한 오차를 쓴다
func isClose(_ x: Double, _ y: Double, ulps: Int = 4) -> Bool {
    if x == y { return true }
    let scale = max(abs(x), abs(y))
    return abs(x - y) <= Double(ulps) * scale.ulp
}
print("③ isClose       :", isClose(a, b))

① ==            : false
② abs 차 < 1e-9 : true
③ isClose       : true

let big1 = 1e9, big2 = 1e9 + 1e-7
print("1e9 근처 — 두 값이 다른가:", big1 != big2)
print("  고정 오차 판정(1e-9):", abs(big1 - big2) < 1e-9)
print("  ulp 판정            :", isClose(big1, big2))
print("  (1e9).ulp =", (1e9).ulp)

let tiny1 = 1e-15, tiny2 = 5e-16
print("1e-15 근처 — 두 값은 두 배 차이:", tiny1, tiny2)
print("  고정 오차 판정(1e-9):", abs(tiny1 - tiny2) < 1e-9, "← 같다고 판정한다")
print("  ulp 판정            :", isClose(tiny1, tiny2))

1e9 근처 — 두 값이 다른가: true
  고정 오차 판정(1e-9): false
  ulp 판정            : true
  (1e9).ulp = 1.1920928955078125e-07
1e-15 근처 — 두 값은 두 배 차이: 1e-15 5e-16
  고정 오차 판정(1e-9): true ← 같다고 판정한다
  ulp 판정            : false

extension Double {
    /// 값의 크기에 비례한 허용 오차로 비교한다.
    func isClose(to other: Double, ulps: Int = 4) -> Bool {
        if self == other { return true }           // ±0.0, 동일 값 처리
        if isNaN || other.isNaN { return false }   // NaN 은 무엇과도 같지 않다 (Q4)
        let scale = Swift.max(abs(self), abs(other))
        guard scale.isFinite else { return false }
        return abs(self - other) <= Double(ulps) * scale.ulp
    }
}
print((0.1 + 0.2).isClose(to: 0.3))   // true

// ❌ 오차가 10번 누적된다
var acc = 0.0
for _ in 0..<10 { acc += 0.1 }
print("누적 덧셈:", acc, acc == 1.0)

// ✅ 오차가 한 번만 생긴다
let byMultiply = 0.1 * 10
print("곱셈    :", byMultiply, byMultiply == 1.0)

// ✅ 눈금 생성도 인덱스 기반으로
for i in 0...10 {
    let t = Double(i) / 10.0    // 매번 독립 계산 — 누적 없음
    _ = t
}

누적 덧셈: 0.9999999999999999 false
곱셈    : 1.0 true

let nan = Double.nan
print("nan == nan :", nan == nan)     // warning: '.nan' == '.nan' is always false
print("nan != nan :", nan != nan)
print("nan <  1.0 :", nan < 1.0, "| nan > 1.0 :", nan > 1.0)
print("nan.isNaN  :", nan.isNaN)

nan == nan : false
nan != nan : true
nan <  1.0 : false | nan > 1.0 : false
nan.isNaN  : true

let arr: [Double] = [3.0, nan, 1.0, 2.0]
print("sorted() :", arr.sorted())

let arr2: [Double] = [nan, 3.0, 1.0, 2.0]
print("nan 앞에 :", arr2.sorted())

print("max()    :", arr.max() ?? -1, "| min() :", arr.min() ?? -1)

sorted() : [3.0, nan, 1.0, 2.0]
nan 앞에 : [nan, 1.0, 2.0, 3.0]
max()    : 3.0 | min() : 1.0

var set = Set<Double>()
set.insert(nan)
set.insert(nan)
print("Set 에 nan 두 번 넣은 크기 :", set.count)
print("set.contains(nan) :", set.contains(nan))

Set 에 nan 두 번 넣은 크기 : 2
set.contains(nan) : false

print("-0.0 == 0.0      :", -0.0 == 0.0)
print("(-0.0).sign      :", (-0.0 as Double).sign, "| (0.0).sign :", (0.0 as Double).sign)
print("1/(-0.0)         :", 1 / (-0.0 as Double), "| 1/(0.0) :", 1 / (0.0 as Double))
print("-0.0 bitPattern  :", (-0.0 as Double).bitPattern, "| 0.0 :", (0.0 as Double).bitPattern)
var s2 = Set<Double>(); s2.insert(-0.0); s2.insert(0.0)
print("Set{-0.0, 0.0}.count :", s2.count)

-0.0 == 0.0      : true
(-0.0).sign      : minus | (0.0).sign : plus
1/(-0.0)         : -inf | 1/(0.0) : inf
-0.0 bitPattern  : 9223372036854775808 | 0.0 : 0
Set{-0.0, 0.0}.count : 1

func sanitize(_ xs: [Double]) -> [Double]? {
    guard xs.allSatisfy({ $0.isFinite }) else { return nil }   // NaN·inf 모두 거른다
    return xs
}

// 파싱 경계
func parseScore(_ s: String) -> Double? {
    guard let d = Double(s), d.isFinite else { return nil }
    return d
}
print(parseScore("1.5") as Any, parseScore("nan") as Any, parseScore("inf") as Any)

Optional(1.5) nil nil

let xs: [Double] = [3.0, .nan, 1.0, 2.0]

// ① 제거 — 대개 이것이 맞다
let cleaned = xs.filter { !$0.isNaN }.sorted()
print("① 제거:", cleaned)

// ② 끝으로 몰기 — 순위 표에서 "측정 실패"를 맨 뒤로
let pushed = xs.sorted { a, b in
    if a.isNaN { return false }     // NaN 은 항상 뒤
    if b.isNaN { return true }
    return a < b
}
print("② 뒤로:", pushed)

// ③ 거부 — 애초에 있으면 안 되는 데이터라면
guard xs.allSatisfy({ !$0.isNaN }) else { print("③ 거부: 잘못된 입력"); exit(0) }

① 제거: [1.0, 2.0, 3.0]
② 뒤로: [1.0, 2.0, 3.0, nan]
③ 거부: 잘못된 입력

// ❌ 계산으로 만든 Double 키 — 다시 계산하면 못 찾을 수 있다
var cache1: [Double: String] = [:]
cache1[0.1 + 0.2] = "값"
print(cache1[0.3] as Any)          // nil — 0.30000000000000004 != 0.3

// ✅ 정수 눈금으로 정규화한 키
var cache2: [Int: String] = [:]
func key(_ d: Double) -> Int { Int((d * 1000).rounded()) }
cache2[key(0.1 + 0.2)] = "값"
print(cache2[key(0.3)] as Any)     // Optional("값")

nil
Optional("값")

print("Int(3.7)   =", Int(3.7), "| Int(-3.7) =", Int(-3.7))
print("Int(exactly: 3.7) =", Int(exactly: 3.7) as Any)
print("Int(exactly: 3.0) =", Int(exactly: 3.0) as Any)
// Int(1e30) → exit 133 (트랩)

Int(3.7)   = 3 | Int(-3.7) = -3
Int(exactly: 3.7) = nil
Int(exactly: 3.0) = Optional(3)

let big = 9_007_199_254_740_993          // 2^53 + 1
print("원본        :", big)
print("Double 경유 :", Int(Double(big)))
print("같은가      :", Int(Double(big)) == big)
print("Double.significandBitCount =", Double.significandBitCount)

원본        : 9007199254740993
Double 경유 : 9007199254740992
같은가      : false
Double.significandBitCount = 52

print("Float(16777217) =", Float(16_777_217), "| Int =", Int(Float(16_777_217)))
print("Float.significandBitCount =", Float.significandBitCount)

Float(16777217) = 16777216.0 | Int = 16777216
Float.significandBitCount = 23

let a = SIMD4<Float>(1, 2, 3, 4), b = SIMD4<Float>(10, 20, 30, 40)
print("SIMD4<Float> size =", MemoryLayout<SIMD4<Float>>.size,
      "align =", MemoryLayout<SIMD4<Float>>.alignment)
print("a+b =", a + b)
print("a*b =", a * b, "| (a*b).sum() =", (a * b).sum())
print("a .< b =", a .< b, "| a.max() =", a.max())
print("SIMD8<Int16> size =", MemoryLayout<SIMD8<Int16>>.size)

SIMD4<Float> size = 16 align = 16
a+b = SIMD4<Float>(11.0, 22.0, 33.0, 44.0)
a*b = SIMD4<Float>(10.0, 40.0, 90.0, 160.0) | (a*b).sum() = 300.0
a .< b = SIMDMask<SIMD4<Int32>>(true, true, true, true) | a.max() = 4.0
SIMD8<Int16> size = 16

// ❌ JSON 숫자를 Double 로 받으면 큰 ID가 어긋난다
struct BadUser: Decodable { let id: Double }        // 2^53 넘으면 손실

// ✅ 정수로 받는다. 더 안전하게는 문자열로 받는다
struct GoodUser: Decodable { let id: Int }
struct SafestUser: Decodable { let id: String }     // 서버가 문자열로 준다면 최선

// RGBA 픽셀에 감마 보정 — 4채널을 한 번에
func applyGain(_ px: SIMD4<Float>, gain: Float) -> SIMD4<Float> {
    px * gain                       // 4개 곱셈이 한 연산으로
}

// 두 점 사이 거리 — 내적을 sum() 으로
func distance(_ p: SIMD3<Float>, _ q: SIMD3<Float>) -> Float {
    let d = p - q
    return (d * d).sum().squareRoot()
}
print(distance(SIMD3(0, 0, 0), SIMD3(3, 4, 0)))   // 5.0

5.0