Create SwiftFloatingPointTypes for float-related helpers

Author: ultramiraculous

stdlib/public/core/FixedPoint.swift.gyb

@@ -13,6 +13,7 @@
 %{
 
 from SwiftIntTypes import all_integer_types, int_max_bits, should_define_truncating_bit_pattern_init
+from SwiftFloatingPointTypes import all_floating_point_types, getFtoIBounds
 
 #
 # Utility code for later in this template
@@ -33,21 +34,6 @@ word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
 # Number of bits in integer literals.
 builtinIntLiteralBits = 2048
 
-# Mapping from float bits to significand bits
-allFloatBits = [32, 64, 80]
-floatName = { 32:'Float', 64:'Double', 80:'Float80' }
-explicitFloatSignificandBits = { 32:24, 64:53, 80:64 }
-
-
-def getFtoIBounds(floatBits, intBits, signed):
-  if not signed:
-    return (-1, 1 << intBits)
-  upper = 1 << intBits - 1
-  if intBits <= explicitFloatSignificandBits[floatBits]:
-    return (-upper - 1, upper)
-  ulp = 1 << intBits - explicitFloatSignificandBits[floatBits]
-  return (-upper - ulp, upper)
-
 def maskBits(n):
     """Return an n-bit mask in hex"""
     return hexify((1 << n) - 1)
@@ -540,8 +526,9 @@ extension ${Self} {
 
 extension ${Self} {
 // Construction of integers from floating point numbers.
-%   for srcBits in allFloatBits:
-%     Src = floatName[srcBits]
+%   for src_type in all_floating_point_types():
+%     Src = src_type.stdlib_name
+%     srcBits = src_type.bits
 %     (lower, upper) = getFtoIBounds(floatBits=srcBits, intBits=int(bits), signed=signed)
 
 %     if srcBits == 80:

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -13,15 +13,12 @@
 import SwiftShims
 
 %{
+from SwiftFloatingPointTypes import all_floating_point_types
+
 #
 # Utility code for later in this template
 #
 
-# // Bit counts for all floating point types. 
-# // 80-bit floating point types are only permitted on x86 architectures. This
-# // restriction is handled via #if's in the generated code.
-allFloatBits = [32, 64, 80]
-
 # Bit counts for all int types
 allIntBits = [8, 16, 32, 64, 'Int']
 
@@ -31,12 +28,6 @@ word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
 # Number of bits in integer literals.
 builtinIntLiteralBits = 2048
 
-# Mapping from float bits to significand bits
-explicitSignificandBits = { 32:24, 64:53, 80:64 }
-SignificandSizes = { 32:32, 64:64, 80:64 }
-SignificandBitCounts = { 32:23, 64:52, 80:63 }
-ExponentBitCounts = { 32:8, 64:11, 80:15 }
-
 def allInts():
     for bits in allIntBits:
         for signed in False, True:
@@ -50,21 +41,6 @@ def builtinIntName(name):
 
 def intName(name, signed):
     return ('' if signed else 'U') + baseIntName(name)
-
-floatName = { 32:'Float', 64:'Double', 80:'Float80' }
-
-def cFuncSuffix(bits):
-    if bits == 32:
-        return 'f'
-    if bits == 64:
-        return ''
-    if bits == 80:
-        return 'l'
-        
-def intFormatFix(bits):
-    if bits == 'Int':
-        return int(CMAKE_SIZEOF_VOID_P) * 8
-    return bits
 }%
 
 //  TODO: remove once integer proposal is available ----------------------------
@@ -79,12 +55,13 @@ extension UInt${bits} {
 }
 %end
 
-% for bits in allFloatBits:
+% for self_type in all_floating_point_types():
 %{
-Self = floatName[bits]
-SignificandSize = SignificandSizes[bits]
-SignificandBitCount = SignificandBitCounts[bits]
-ExponentBitCount = ExponentBitCounts[bits]
+Self = self_type.stdlib_name
+bits = self_type.bits
+SignificandSize = self_type.significand_size
+SignificandBitCount = self_type.significand_bits
+ExponentBitCount = self_type.exponent_bits
 RawSignificand = 'UInt' + str(SignificandSize)
 
 if Self == 'Float':
@@ -867,8 +844,9 @@ extension ${Self} {
 // Construction from other floating point numbers.
 @_transparent
 extension ${Self} {
-% for srcBits in allFloatBits:
-%   That = floatName[srcBits]
+% for src_type in all_floating_point_types():
+%   srcBits = src_type.bits
+%   That = src_type.stdlib_name
 
 %   if srcBits == 80:
 #if !os(Windows) && (arch(i386) || arch(x86_64))
@@ -1080,4 +1058,4 @@ public postfix func -- (lhs: inout ${Self}) -> ${Self} {
 % if bits == 80:
 #endif
 % end
-% end # for bits in allFloatBits
+% end # for bits in all_floating_point_types

utils/SwiftFloatingPointTypes.py

@@ -0,0 +1,48 @@
+# ===--- SwiftFloatingPointTypes.py ----------------------------*- coding: utf-8 -*-===//
+#
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+# Licensed under Apache License v2.0 with Runtime Library Exception
+#
+# See http://swift.org/LICENSE.txt for license information
+# See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+
+# returns (lower, upper) exclusive bounds for the integer values
+# that can be stored into a float
+def getFtoIBounds(floatBits, intBits, signed):
+  sigBits = floating_point_bits_to_type()[floatBits].explicit_significand_bits
+  if not signed:
+    return (-1, 1 << intBits)
+  upper = 1 << (intBits - 1)
+  if intBits <= sigBits:
+    return (-upper - 1, upper)
+  ulp = 1 << (intBits - sigBits)
+  return (-upper - ulp, upper)
+
+class SwiftFloatType(object):
+    
+    def __init__(self, name, significandBits, exponentBits, significandSize, totalBits):
+        self.stdlib_name = name
+        self.significand_bits = significandBits
+        self.significand_size = significandSize
+        self.exponent_bits = exponentBits
+        self.explicit_significand_bits = significandBits + 1
+        self.bits = totalBits
+        
+        
+def floating_point_bits_to_type():
+    return {
+        32: SwiftFloatType(name="Float",   significandBits=23, exponentBits=8,  significandSize=32, totalBits=32),
+        64: SwiftFloatType(name="Double",  significandBits=52, exponentBits=11, significandSize=64, totalBits=64),
+        80: SwiftFloatType(name="Float80", significandBits=63, exponentBits=15, significandSize=64, totalBits=80),
+    }
+
+def all_floating_point_types():
+    return floating_point_bits_to_type().values()
+
+# // Bit counts for all floating point types. 
+# // 80-bit floating point types are only permitted on x86 architectures. This
+# // restriction is handled via #if's in the generated code.
+def all_floating_point_bits():
+    return floating_point_bits_to_type().keys()

validation-test/stdlib/FixedPointConversion.swift.gyb

@@ -48,8 +48,7 @@ int_to_int_conversion_template = gyb.parse_template("int_to_int_conversion",
 """
 %{
 from SwiftIntTypes import all_integer_types, int_max, int_min
-
-floatNameToSignificandBits = { 'Float32':24, 'Float64':53, 'Float80':64 }
+from SwiftFloatingPointTypes import all_floating_point_types
 
 }%
 % for self_ty in all_integer_types(word_bits):
@@ -110,9 +109,10 @@ FixedPointConversionFailure.test("${Other}To${Self}Conversion/dest=${testValue}"
 %     end # for testValue in ...
 %   end # for in all_integer_types (Other)
 
-%   for Other, otherSignificandBits in floatNameToSignificandBits.iteritems():
-%    otherMin = int_min(bits=otherSignificandBits, signed=False)
-%    otherMax = int_max(bits=otherSignificandBits, signed=False)
+%   for other_type in all_floating_point_types():
+%    Other = "Float" + str(other_type.bits)
+%    otherMin = -int_max(bits=other_type.explicit_significand_bits, signed=False)
+%    otherMax = int_max(bits=other_type.explicit_significand_bits, signed=False)
 
 %    if Other == 'Float80':
 #if !os(Windows) && (arch(i386) || arch(x86_64))
@@ -123,7 +123,7 @@ FixedPointConversionFailure.test("${Other}To${Self}Conversion/dest=${testValue}"
 %     if testValue < otherMin or testValue > otherMax: 
 %       # Can't construct `other` value to test from, do nothing and continue.
 
-%     elif testValue >= selfMin and testValue <= selfMax and testValue % 1 == 0:
+%     elif testValue >= selfMin and testValue <= selfMax and testValue % 1 == 0 and testValue != -0.0:
 
 FloatingPointConversionTruncations.test("${Other}To${Self}Conversion/dest=${testValue}") {
   let input = get${Other}(${testValue})
@@ -213,7 +213,7 @@ FloatingPointConversionFailures.test("${Self}/${Other}/NaN") {
 #endif
 %   end
 
-%  end # for in floatNameToSignificandBits (Other)
+%  end # for in all_floating_point_types (Other)
 % end # for in all_integer_types (Self)
 
 """)