BREAKING: Make .c namespace API more Swifty

Make ergonomic stdlib extensions idiomatic Swift while keeping authoritative
ISO_9899.Math implementations literal (unchanged).

## API Changes

### Category 1: Remove C Type Prefixes
- `fabs` → `abs`
- `fmin(_:)` → `min(_:)`
- `fmax(_:)` → `max(_:)`
- `fmod(_:)` → `mod(_:)`
- `fdim(_:)` → `positiveDifference(from:)`

### Category 2: Classification Functions
- `fpclassify` → `classification`
- `isfinite` → `isFinite` (camelCase)
- `isinf` → `isInfinite` (camelCase)
- `isnan` → `isNaN` (camelCase)
- `isnormal` → `isNormal` (camelCase)
- `signbit` → `hasNegativeSign`

### Category 3: Comparison Functions (with Swift-style labels)
- `isgreater(_:)` → `isGreater(than:)`
- `isgreaterequal(_:)` → `isGreaterOrEqual(to:)`
- `isless(_:)` → `isLess(than:)`
- `islessequal(_:)` → `isLessOrEqual(to:)`
- `islessgreater(_:)` → `isNotEqual(to:)`
- `isunordered(_:)` → `isUnordered(with:)`

### Category 4: Integer-Returning Rounding
- `lrint` → `roundedToInt()`
- `llrint` → `roundedToInt64()`
- `lround` → `roundToInt()`
- `llround` → `roundToInt64()`

### Category 5: Sign Manipulation
- `copysign(_:)` → `withSign(of:)`
- `nextafter(_:)` → `nextRepresentable(toward:)`
- `nexttoward(_:)` → `nextRepresentableExtended(toward:)`

## Migration Guide

Before:
```swift
let abs = (-x).c.fabs
let max = x.c.fmax(y)
let finite = x.c.isfinite
let greater = x.c.isgreater(y)
let asInt = x.c.lround
```

After:
```swift
let abs = (-x).c.abs
let max = x.c.max(y)
let finite = x.c.isFinite
let greater = x.c.isGreater(than: y)
let asInt = x.c.roundToInt()
```

Authoritative API unchanged:
```swift
ISO_9899.Math.fabs(-2.0)  // Still works
ISO_9899.Math.fmax(x, y)  // Still works
```

All tests passing (175/175).

Author: coenttb

README.md

@@ -116,9 +116,11 @@ let ln = ISO_9899.Math.log(2.71828)  // 1.0
 let log2 = ISO_9899.Math.log2(1024.0)  // 10.0
 
 // Absolute value and additional power functions
-let abs = ISO_9899.Math.fabs(-3.14)  // 3.14
-let dist = ISO_9899.Math.hypot(3.0, 4.0)  // 5.0
-let cubeRoot = ISO_9899.Math.cbrt(27.0)  // 3.0
+let abs = ISO_9899.Math.fabs(-3.14)   // 3.14
+let dist = ISO_9899.Math.hypot(3.0, 4.0)   // 5.0
+let cubeRoot = ISO_9899.Math.cbrt(27.0)    // 3.0
+let max = ISO_9899.Math.fmax(3.0, 5.0)     // 5.0
+let min = ISO_9899.Math.fmin(3.0, 5.0)     // 3.0
 
 // Rounding functions
 let rounded = ISO_9899.Math.ceil(2.3)   // 3.0
@@ -127,16 +129,20 @@ let nearest = ISO_9899.Math.round(2.5)  // 3.0 (ties away from zero)
 let truncated = ISO_9899.Math.trunc(-2.7)  // -2.0
 
 // Classification functions
-let classification = ISO_9899.Math.fpclassify(1.0)  // .normal
-let isFinite = ISO_9899.Math.isfinite(.infinity)    // false
-let isNaN = ISO_9899.Math.isnan(.nan)                // true
-let signBit = ISO_9899.Math.signbit(-0.0)            // true
+let classification = ISO_9899.Math.fpclassify(1.0)    // .normal
+let isFinite = ISO_9899.Math.isfinite(.infinity)      // false
+let isNaN = ISO_9899.Math.isnan(.nan)                 // true
+let signBit = ISO_9899.Math.signbit(-0.0)             // true
 
 // Comparison functions (quiet - no exception on NaN)
-let greater = ISO_9899.Math.isgreater(5.0, 3.0)     // true
-let lessOrGreater = ISO_9899.Math.islessgreater(.nan, 5.0)  // false
+let greater = ISO_9899.Math.isgreater(5.0, 3.0)      // true
+let lessOrGreater = ISO_9899.Math.islessgreater(5.0, .nan)  // false
 let unordered = ISO_9899.Math.isunordered(.nan, 5.0)  // true
 
+// Integer-returning rounding
+let asInt = ISO_9899.Math.lround(2.5)                 // 3
+let asInt64 = ISO_9899.Math.llround(2.5)              // 3
+
 // Mathematical constants
 let circumference = 2 * ISO_9899.Math.Constants.pi * radius
 let radians = degrees * ISO_9899.Math.Constants.degreesToRadians
@@ -169,9 +175,11 @@ let log = x.c.log               // 0.693147180...
 let log2 = x.c.log2             // 1.0
 
 // Absolute value and additional power functions
-let abs = (-x).c.fabs           // 2.0
+let abs = (-x).c.abs            // 2.0
 let dist = x.c.hypot(3.0)       // 3.60555127...
 let cube = x.c.cbrt             // 1.25992104...
+let maximum = x.c.max(5.0)      // 5.0
+let minimum = x.c.min(5.0)      // 2.0
 
 // Rounding functions
 let ceil = (2.3).c.ceil         // 3.0
@@ -180,15 +188,19 @@ let round = (2.5).c.round       // 3.0
 let trunc = (-2.7).c.trunc      // -2.0
 
 // Classification functions
-let classification = (1.0).c.fpclassify       // .normal
-let isFinite = Double.infinity.c.isfinite     // false
-let isNaN = Double.nan.c.isnan                // true
-let signBit = (-0.0).c.signbit                // true
+let classification = (1.0).c.classification          // .normal
+let isFinite = Double.infinity.c.isFinite            // false
+let isNaN = Double.nan.c.isNaN                       // true
+let hasNegativeSign = (-0.0).c.hasNegativeSign       // true
 
 // Comparison functions (quiet - no exception on NaN)
-let greater = (5.0).c.isgreater(3.0)          // true
-let lessOrGreater = Double.nan.c.islessgreater(5.0)  // false
-let unordered = Double.nan.c.isunordered(5.0) // true
+let greater = (5.0).c.isGreater(than: 3.0)           // true
+let lessOrGreater = (5.0).c.isNotEqual(to: .nan)     // false
+let unordered = Double.nan.c.isUnordered(with: 5.0)  // true
+
+// Integer-returning rounding
+let asInt = (2.5).c.roundToInt()                     // 3
+let asInt64 = (2.5).c.roundToInt64()                 // 3
 
 // Works with Float too
 let y: Float = 1.5

Sources/ISO 9899/Double+ISO_9899.swift

@@ -19,7 +19,7 @@ extension Double {
     /// let root = x.c.sqrt               // 1.41421356...
     /// let sine = x.c.sin                // 0.90929742...
     /// let log = x.c.log                 // 0.693147180...
-    /// let abs = (-x).c.fabs             // 2.0
+    /// let abs = (-x).c.abs              // 2.0
     /// ```
     ///
     /// ## See Also
@@ -185,7 +185,7 @@ extension Double.C {
     ///
     /// Delegates to ``ISO_9899/Math/fabs(_:)-1w0zq``
     @_transparent
-    public var fabs: Double {
+    public var abs: Double {
         ISO_9899.Math.fabs(self.value)
     }
 
@@ -369,35 +369,43 @@ extension Double.C {
         ISO_9899.Math.nearbyint(self.value)
     }
 
-    /// Round to nearest integer and return as Int
+    /// Round to nearest integer using current rounding mode
+    ///
+    /// Returns the rounded value as an `Int`, using the current FPU rounding direction.
     ///
     /// Delegates to ``ISO_9899/Math/lrint(_:)-7abaz``
     @_transparent
-    public var lrint: Int {
+    public func roundedToInt() -> Int {
         ISO_9899.Math.lrint(self.value)
     }
 
-    /// Round to nearest integer and return as Int64
+    /// Round to nearest integer using current rounding mode
+    ///
+    /// Returns the rounded value as an `Int64`, using the current FPU rounding direction.
     ///
     /// Delegates to ``ISO_9899/Math/llrint(_:)-61a0k``
     @_transparent
-    public var llrint: Int64 {
+    public func roundedToInt64() -> Int64 {
         ISO_9899.Math.llrint(self.value)
     }
 
-    /// Round (ties away from zero) and return as Int
+    /// Round to nearest integer (ties away from zero)
+    ///
+    /// Returns the rounded value as an `Int`, with ties rounded away from zero.
     ///
     /// Delegates to ``ISO_9899/Math/lround(_:)-4gv6i``
     @_transparent
-    public var lround: Int {
+    public func roundToInt() -> Int {
         ISO_9899.Math.lround(self.value)
     }
 
-    /// Round (ties away from zero) and return as Int64
+    /// Round to nearest integer (ties away from zero)
+    ///
+    /// Returns the rounded value as an `Int64`, with ties rounded away from zero.
     ///
     /// Delegates to ``ISO_9899/Math/llround(_:)-4j6vs``
     @_transparent
-    public var llround: Int64 {
+    public func roundToInt64() -> Int64 {
         ISO_9899.Math.llround(self.value)
     }
 }
@@ -409,7 +417,7 @@ extension Double.C {
     ///
     /// Delegates to ``ISO_9899/Math/fmod(_:_:)-47htk``
     @_transparent
-    public func fmod(_ y: Double) -> Double {
+    public func mod(_ y: Double) -> Double {
         ISO_9899.Math.fmod(self.value, y)
     }
 
@@ -433,28 +441,30 @@ extension Double.C {
 // MARK: - Manipulation Functions (Section 7.12.11)
 
 extension Double.C {
-    /// Copy sign from another value
+    /// Returns self with the sign of another value
+    ///
+    /// Returns a value with the magnitude of self and the sign of `other`.
     ///
     /// Delegates to ``ISO_9899/Math/copysign(_:_:)-76te9``
     @_transparent
-    public func copysign(_ y: Double) -> Double {
-        ISO_9899.Math.copysign(self.value, y)
+    public func withSign(of other: Double) -> Double {
+        ISO_9899.Math.copysign(self.value, other)
     }
 
-    /// Get next representable value toward y
+    /// Returns the next representable value in the direction of another value
     ///
     /// Delegates to ``ISO_9899/Math/nextafter(_:_:)-4hj4j``
     @_transparent
-    public func nextafter(_ y: Double) -> Double {
-        ISO_9899.Math.nextafter(self.value, y)
+    public func nextRepresentable(toward other: Double) -> Double {
+        ISO_9899.Math.nextafter(self.value, other)
     }
 
-    /// Get next representable value toward y (long double)
+    /// Returns the next representable value in the direction of another value (extended precision)
     ///
     /// Delegates to ``ISO_9899/Math/nexttoward(_:_:)-71rr4``
     @_transparent
-    public func nexttoward(_ y: Double) -> Double {
-        ISO_9899.Math.nexttoward(self.value, y)
+    public func nextRepresentableExtended(toward other: Double) -> Double {
+        ISO_9899.Math.nexttoward(self.value, other)
     }
 }
 
@@ -463,102 +473,127 @@ extension Double.C {
 extension Double.C {
     /// Classify floating-point value
     ///
+    /// Returns the classification of the value (normal, zero, subnormal, infinite, or NaN).
+    ///
     /// Delegates to ``ISO_9899/Math/fpclassify(_:)-76te9``
     @_transparent
-    public var fpclassify: ISO_9899.Math.FloatingPointClass {
+    public var classification: ISO_9899.Math.FloatingPointClass {
         ISO_9899.Math.fpclassify(self.value)
     }
 
     /// Test for finite value
     ///
+    /// Returns `true` if the value is finite (not infinite or NaN).
+    ///
     /// Delegates to ``ISO_9899/Math/isfinite(_:)-76te9``
     @_transparent
-    public var isfinite: Bool {
+    public var isFinite: Bool {
         ISO_9899.Math.isfinite(self.value)
     }
 
     /// Test for infinity
     ///
+    /// Returns `true` if the value is positive or negative infinity.
+    ///
     /// Delegates to ``ISO_9899/Math/isinf(_:)-76te9``
     @_transparent
-    public var isinf: Bool {
+    public var isInfinite: Bool {
         ISO_9899.Math.isinf(self.value)
     }
 
     /// Test for NaN
     ///
+    /// Returns `true` if the value is Not-a-Number (NaN).
+    ///
     /// Delegates to ``ISO_9899/Math/isnan(_:)-76te9``
     @_transparent
-    public var isnan: Bool {
+    public var isNaN: Bool {
         ISO_9899.Math.isnan(self.value)
     }
 
     /// Test for normal value
     ///
+    /// Returns `true` if the value is normal (not zero, subnormal, infinite, or NaN).
+    ///
     /// Delegates to ``ISO_9899/Math/isnormal(_:)-76te9``
     @_transparent
-    public var isnormal: Bool {
+    public var isNormal: Bool {
         ISO_9899.Math.isnormal(self.value)
     }
 
-    /// Test sign bit
+    /// Test if sign bit is set
+    ///
+    /// Returns `true` if the sign bit is set (negative), including for -0.0 and -NaN.
     ///
     /// Delegates to ``ISO_9899/Math/signbit(_:)-76te9``
     @_transparent
-    public var signbit: Bool {
+    public var hasNegativeSign: Bool {
         ISO_9899.Math.signbit(self.value)
     }
 }
 
 // MARK: - Comparison Macros (Section 7.12.14)
 
 extension Double.C {
-    /// Determine whether value > y (quiet comparison)
+    /// Determine whether self > other (quiet comparison)
+    ///
+    /// Unlike the `>` operator, this does not raise an exception when comparing with NaN.
     ///
     /// Delegates to ``ISO_9899/Math/isgreater(_:_:)-76te9``
     @_transparent
-    public func isgreater(_ y: Double) -> Bool {
-        ISO_9899.Math.isgreater(self.value, y)
+    public func isGreater(than other: Double) -> Bool {
+        ISO_9899.Math.isgreater(self.value, other)
     }
 
-    /// Determine whether value >= y (quiet comparison)
+    /// Determine whether self >= other (quiet comparison)
+    ///
+    /// Unlike the `>=` operator, this does not raise an exception when comparing with NaN.
     ///
     /// Delegates to ``ISO_9899/Math/isgreaterequal(_:_:)-76te9``
     @_transparent
-    public func isgreaterequal(_ y: Double) -> Bool {
-        ISO_9899.Math.isgreaterequal(self.value, y)
+    public func isGreaterOrEqual(to other: Double) -> Bool {
+        ISO_9899.Math.isgreaterequal(self.value, other)
     }
 
-    /// Determine whether value < y (quiet comparison)
+    /// Determine whether self < other (quiet comparison)
+    ///
+    /// Unlike the `<` operator, this does not raise an exception when comparing with NaN.
     ///
     /// Delegates to ``ISO_9899/Math/isless(_:_:)-76te9``
     @_transparent
-    public func isless(_ y: Double) -> Bool {
-        ISO_9899.Math.isless(self.value, y)
+    public func isLess(than other: Double) -> Bool {
+        ISO_9899.Math.isless(self.value, other)
     }
 
-    /// Determine whether value <= y (quiet comparison)
+    /// Determine whether self <= other (quiet comparison)
+    ///
+    /// Unlike the `<=` operator, this does not raise an exception when comparing with NaN.
     ///
     /// Delegates to ``ISO_9899/Math/islessequal(_:_:)-76te9``
     @_transparent
-    public func islessequal(_ y: Double) -> Bool {
-        ISO_9899.Math.islessequal(self.value, y)
+    public func isLessOrEqual(to other: Double) -> Bool {
+        ISO_9899.Math.islessequal(self.value, other)
     }
 
-    /// Determine whether value < y or value > y (quiet comparison)
+    /// Determine whether self != other (quiet comparison)
+    ///
+    /// Returns `true` if self < other or self > other (excludes equal and unordered).
+    /// Unlike `!=`, this does not raise an exception when comparing with NaN.
     ///
     /// Delegates to ``ISO_9899/Math/islessgreater(_:_:)-76te9``
     @_transparent
-    public func islessgreater(_ y: Double) -> Bool {
-        ISO_9899.Math.islessgreater(self.value, y)
+    public func isNotEqual(to other: Double) -> Bool {
+        ISO_9899.Math.islessgreater(self.value, other)
     }
 
     /// Determine whether arguments are unordered
     ///
+    /// Returns `true` if either self or other is NaN.
+    ///
     /// Delegates to ``ISO_9899/Math/isunordered(_:_:)-76te9``
     @_transparent
-    public func isunordered(_ y: Double) -> Bool {
-        ISO_9899.Math.isunordered(self.value, y)
+    public func isUnordered(with other: Double) -> Bool {
+        ISO_9899.Math.isunordered(self.value, other)
     }
 }
 
@@ -567,25 +602,27 @@ extension Double.C {
 extension Double.C {
     /// Compute positive difference
     ///
+    /// Returns `self - y` if `self > y`, otherwise `+0`.
+    ///
     /// Delegates to ``ISO_9899/Math/fdim(_:_:)-2rksv``
     @_transparent
-    public func fdim(_ y: Double) -> Double {
+    public func positiveDifference(from y: Double) -> Double {
         ISO_9899.Math.fdim(self.value, y)
     }
 
     /// Determine maximum value
     ///
     /// Delegates to ``ISO_9899/Math/fmax(_:_:)-8ks7i``
     @_transparent
-    public func fmax(_ y: Double) -> Double {
+    public func max(_ y: Double) -> Double {
         ISO_9899.Math.fmax(self.value, y)
     }
 
     /// Determine minimum value
     ///
     /// Delegates to ``ISO_9899/Math/fmin(_:_:)-9yw9t``
     @_transparent
-    public func fmin(_ y: Double) -> Double {
+    public func min(_ y: Double) -> Double {
         ISO_9899.Math.fmin(self.value, y)
     }