stdlib/Floating point: switch infinity, NaN, quietNaN to properties

Swift SVN r18348

Author: gribozavr

stdlib/core/FloatingPoint.swift.gyb

@@ -181,19 +181,19 @@ extension ${Self} : FloatingPointNumber {
     return _toBitPattern() & mask
   }
 
-  static func infinity() -> ${Self} {
+  static var infinity: ${Self} {
     return _fromBitPattern(${getInfBitPattern(bits)})
   }
 
-  static func NaN() -> ${Self} {
-    return quietNaN()
+  static var NaN: ${Self} {
+    return quietNaN
   }
 
-  static func quietNaN() -> ${Self} {
+  static var quietNaN: ${Self} {
     return _fromBitPattern(${getQuietNaNBitPattern(bits)})
   }
 
-  var isSignMinus:  Bool {
+  var isSignMinus: Bool {
     return __getSignBit() == 1
   }
 

stdlib/core/FloatingPointOperations.swift

@@ -44,21 +44,19 @@ func ==(lhs: FloatingPointClassification, rhs: FloatingPointClassification) -> B
   }
 }
 
-
 protocol FloatingPointNumber {
   typealias _BitsType
   class func _fromBitPattern(bits: _BitsType) -> Self
   func _toBitPattern() -> _BitsType
 
-  // FIXME: make these readonly static properties.
-
-  /// Returns positive infinity.
-  class func infinity() -> Self
+  /// The positive infinity.
+  class var infinity: Self { get }
 
-  /// Returns a quiet NaN.
-  class func NaN() -> Self
+  /// A quiet NaN.
+  class var NaN: Self { get }
 
-  class func quietNaN() -> Self
+  /// A quiet NaN.
+  class var quietNaN: Self { get }
 
   /// @{
   /// IEEE 754-2008 Non-computational operations.

test/stdlib/Float.swift

@@ -168,12 +168,12 @@ func checkInf(inf: TestFloat) {
 }
 
 func testInf() {
-  var stdlibPlusInf = TestFloat.infinity()
+  var stdlibPlusInf = TestFloat.infinity
   checkInf(stdlibPlusInf)
   _precondition(!stdlibPlusInf.isSignMinus)
   _precondition(stdlibPlusInf.floatingPointClass == .PositiveInfinity)
 
-  var stdlibMinusInf = -TestFloat.infinity()
+  var stdlibMinusInf = -TestFloat.infinity
   checkInf(stdlibMinusInf)
   _precondition(stdlibMinusInf.isSignMinus)
   _precondition(stdlibMinusInf.floatingPointClass == .NegativeInfinity)
@@ -220,11 +220,11 @@ func checkQNaN(qnan: TestFloat) {
 }
 
 func testNaN() {
-  var stdlibDefaultNaN = TestFloat.NaN()
+  var stdlibDefaultNaN = TestFloat.NaN
   checkQNaN(stdlibDefaultNaN)
   _precondition(stdlibDefaultNaN != stdlibDefaultNaN)
 
-  var stdlibQNaN = TestFloat.quietNaN()
+  var stdlibQNaN = TestFloat.quietNaN
   checkQNaN(stdlibQNaN)
   _precondition(stdlibQNaN != stdlibQNaN)
 

test/stdlib/FloatingPointConversionOverflow.swift

@@ -41,10 +41,10 @@ import Darwin
 // Interpret the command line arguments.
 let arg = Process.arguments[1]
 
-let pd = +Double.infinity()
-let nd = -Double.infinity()
-let pf = +Float.infinity()
-let nf = -Float.infinity()
+let pd = +Double.infinity
+let nd = -Double.infinity
+let pf = +Float.infinity
+let nf = -Float.infinity
 
 println("GOOD") // CHECK: GOOD
 

test/stdlib/Print.swift

@@ -213,18 +213,18 @@ test_IntegerPrinting()
 // CHECK: test_IntegerPrinting done
 
 func test_FloatingPointPrinting() {
-  printedIs(Float.infinity(), "inf")
-  printedIs(-Float.infinity(), "-inf")
-  printedIs(Float.NaN(), "nan")
+  printedIs(Float.infinity, "inf")
+  printedIs(-Float.infinity, "-inf")
+  printedIs(Float.NaN, "nan")
   printedIs(Float(0.0), "0.0")
   printedIs(Float(1.0), "1.0")
   printedIs(Float(-1.0), "-1.0")
   printedIs(Float(100.125), "100.125")
   printedIs(Float(-100.125), "-100.125")
 
-  printedIs(Double.infinity(), "inf")
-  printedIs(-Double.infinity(), "-inf")
-  printedIs(Double.NaN(), "nan")
+  printedIs(Double.infinity, "inf")
+  printedIs(-Double.infinity, "-inf")
+  printedIs(Double.NaN, "nan")
   printedIs(Double(0.0), "0.0")
   printedIs(Double(1.0), "1.0")
   printedIs(Double(-1.0), "-1.0")