Add _stdlib_random for more platforms (#1)

* Remove refs to Countable ranges

* Add `_stdlib_random` for more platforms

* Use `getrandom` (if available) for Android, Cygwin

* Reorder the `_stdlib_random` functions

* Also include <features.h> on Linux

* Add `#error TODO` in `_stdlib_random` for Windows

* Colon after Fatal Error

Performance improvement for Random

gybify ranges

Fix typo in 'basic random numbers'
Add _stdlib_random as a testable method

Switch to generic constraints

Hopefully link against bcrypt

Fix some implementation details

1. Uniform distribution is now uniform
2. Apply Jens' method for uniform floats

Fix a lineable attribute

Author: benrimmington

stdlib/public/core/Bool.swift

@@ -92,12 +92,24 @@ public struct Bool {
   /// - Parameter generator: The random number generator to use when getting a
   ///   random Boolean.
   /// - Returns: A random Boolean.
-  @_inlineable
-  public static func random(
-    using generator: RandomNumberGenerator = Random.default
+  @inlinable
+  public static func random<T: RandomNumberGenerator>(
+    using generator: T
   ) -> Bool {
     return generator.next() % 2 == 0
   }
+  
+  /// Returns a random Boolean
+  ///
+  /// - Parameter generator: The random number generator to use when getting a
+  ///   random Boolean.
+  /// - Returns: A random Boolean.
+  ///
+  /// This uses the standard library's default random number generator.
+  @inlinable
+  public static func random() -> Bool {
+    return Bool.random(using: Random.default)
+  }
 }
 
 extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLiteral {

stdlib/public/core/CMakeLists.txt

@@ -229,6 +229,10 @@ if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
       ${EXECINFO_LIBRARY})
 endif()
 
+if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+  list(APPEND swift_core_link_flags "$ENV{SystemRoot}/system32/bcrypt.dll")
+endif()
+
 option(SWIFT_CHECK_ESSENTIAL_STDLIB
     "Check core standard library layering by linking its essential subset"
     FALSE)

stdlib/public/core/ClosedRange.swift

@@ -480,57 +480,6 @@ extension ClosedRange where Bound: Strideable, Bound.Stride : SignedInteger {
   }
 }
 
-extension ClosedRange
-where Bound : FixedWidthInteger,
-      Bound.Magnitude : UnsignedInteger {
-
-  /// Returns a random element from this collection.
-  ///
-  /// - Parameter generator: The random number generator to use when getting
-  ///   a random element.
-  /// - Returns: A random element from this collection.
-  ///
-  /// A good example of this is getting a random greeting from an array:
-  ///
-  ///     let greetings = ["hi", "hey", "hello", "hola"]
-  ///     let randomGreeting = greetings.random()
-  ///
-  /// If the collection is empty, the value of this function is `nil`.
-  ///
-  ///     let numbers = [10, 20, 30, 40, 50]
-  ///     if let randomNumber = numbers.random() {
-  ///         print(randomNumber)
-  ///     }
-  ///     // Could print "20", perhaps
-  @_inlineable
-  public func random(
-    using generator: RandomNumberGenerator = Random.default
-  ) -> Element? {
-    let isLowerNegative = Bound.isSigned && lowerBound < 0
-    let sameSign = !Bound.isSigned || isLowerNegative == (upperBound < 0)
-    var delta: Bound.Magnitude
-    if isLowerNegative {
-      delta = sameSign
-        ? lowerBound.magnitude - upperBound.magnitude
-        : lowerBound.magnitude + upperBound.magnitude
-    } else {
-      delta = upperBound.magnitude - lowerBound.magnitude
-    }
-    if delta == Bound.Magnitude.max {
-      return Bound(truncatingIfNeeded: generator.next() as Bound.Magnitude)
-    }
-    delta += 1
-    let randomMagnitude = generator.next(upperBound: delta)
-    if sameSign {
-      return lowerBound + Bound(randomMagnitude)
-    } else {
-      return Bound.isSigned && randomMagnitude <= upperBound.magnitude
-        ? Bound(randomMagnitude)
-        : 0 - Bound(randomMagnitude - upperBound.magnitude)
-    }
-  }
-}
-
 extension ClosedRange {
   @inlinable
   public func overlaps(_ other: ClosedRange<Bound>) -> Bool {

stdlib/public/core/Collection.swift

@@ -1034,12 +1034,12 @@ extension Collection {
   ///         print(randomNumber)
   ///     }
   ///     // Could print "20", perhaps
-  @_inlineable
-  public func random(
-    using generator: RandomNumberGenerator = Random.default
+  @inlinable
+  public func random<T: RandomNumberGenerator>(
+    using generator: T
   ) -> Element? {
     guard !isEmpty else { return nil }
-    let random = generator.next(upperBound: UInt(self.count))
+    let random = generator.next(upperBound: UInt(count))
     let index = self.index(
       self.startIndex,
       offsetBy: IndexDistance(random),
@@ -1048,6 +1048,31 @@ extension Collection {
     return self[index]
   }
 
+  /// Returns a random element from this collection.
+  ///
+  /// - Parameter generator: The random number generator to use when getting
+  ///   a random element.
+  /// - Returns: A random element from this collection.
+  ///
+  /// A good example of this is getting a random greeting from an array:
+  ///
+  ///     let greetings = ["hi", "hey", "hello", "hola"]
+  ///     let randomGreeting = greetings.random()
+  ///
+  /// If the collection is empty, the value of this function is `nil`.
+  ///
+  ///     let numbers = [10, 20, 30, 40, 50]
+  ///     if let randomNumber = numbers.random() {
+  ///         print(randomNumber)
+  ///     }
+  ///     // Could print "20", perhaps
+  ///
+  /// This uses the standard library's default random number generator.
+  @inlinable
+  public func random() -> Element? {
+    return random(using: Random.default)
+  }
+
   /// Do not use this method directly; call advanced(by: n) instead.
   @inlinable
   @inline(__always)

stdlib/public/core/CollectionAlgorithms.swift

@@ -368,7 +368,7 @@ extension MutableCollection where Self : BidirectionalCollection {
 }
 
 //===----------------------------------------------------------------------===//
-// shuffled()
+// shuffled()/shuffle()
 //===----------------------------------------------------------------------===//
 
 extension Sequence {
@@ -377,24 +377,36 @@ extension Sequence {
   /// - Parameter generator: The random number generator to use when shuffling
   ///   the sequence.
   /// - Returns: A shuffled array of this sequence's elements.
-  @_inlineable
-  public func shuffled(
-    using generator: RandomNumberGenerator = Random.default
+  @inlinable
+  public func shuffled<T: RandomNumberGenerator>(
+    using generator: T
   ) -> [Element] {
     var result = ContiguousArray(self)
     result.shuffle(using: generator)
     return Array(result)
   }
+  
+  /// Returns the elements of the sequence, shuffled.
+  ///
+  /// - Parameter generator: The random number generator to use when shuffling
+  ///   the sequence.
+  /// - Returns: A shuffled array of this sequence's elements.
+  ///
+  /// This uses the standard library's default random number generator.
+  @inlinable
+  public func shuffled() -> [Element] {
+    return shuffled(using: Random.default)
+  }
 }
 
 extension MutableCollection {
   /// Shuffles the collection in place.
   ///
   /// - Parameter generator: The random number generator to use when shuffling
   ///   the collection.
-  @_inlineable
-  public mutating func shuffle(
-    using generator: RandomNumberGenerator = Random.default
+  @inlinable
+  public mutating func shuffle<T: RandomNumberGenerator>(
+    using generator: T
   ) {
     guard count > 1 else { return }
     var amount = count
@@ -409,6 +421,17 @@ extension MutableCollection {
       formIndex(after: &currentIndex)
     }
   }
+  
+  /// Shuffles the collection in place.
+  ///
+  /// - Parameter generator: The random number generator to use when shuffling
+  ///   the collection.
+  ///
+  /// This uses the standard library's default random number generator.
+  @inlinable
+  public mutating func shuffle() {
+    shuffle(using: Random.default)
+  }
 }
 
 //===----------------------------------------------------------------------===//

stdlib/public/core/FloatingPoint.swift.gyb

@@ -2413,10 +2413,10 @@ where Self.RawSignificand : FixedWidthInteger,
   /// - Parameter generator: The random number generator to use when getting
   ///   the random floating point.
   /// - Returns: A random representation of this floating point.
-  @_inlineable
-  public static func random(
+  @inlinable
+  public static func random<T: RandomNumberGenerator>(
     in range: ${Range}<Self>,
-    using generator: RandomNumberGenerator = Random.default
+    using generator: T
   ) -> Self {
 %   if 'Closed' not in Range:
     _precondition(
@@ -2425,7 +2425,7 @@ where Self.RawSignificand : FixedWidthInteger,
     )
 %   end
     let delta = range.upperBound - range.lowerBound
-    let maxSignificand: Self.RawSignificand = 1 << Self.significandBitCount
+    let maxSignificand = Self.RawSignificand(1 << (Self.significandBitCount + 1))
 %   if 'Closed' not in Range:
     let rand: Self.RawSignificand = generator.next(upperBound: maxSignificand)
 %   else:
@@ -2434,14 +2434,23 @@ where Self.RawSignificand : FixedWidthInteger,
       return range.upperBound
     }
 %   end
-    let unitRandom = Self.init(
-      sign: .plus,
-      exponentBitPattern: (1 as Self).exponentBitPattern,
-      significandBitPattern: rand
-    ) - 1
+    let unitRandom = Self.init(rand) * Self.ulpOfOne / 2
     return delta * unitRandom + range.lowerBound
   }
 
+  /// Returns a random representation of this floating point within the range.
+  ///
+  /// - Parameter range: A ${Range} to determine the bounds to get a random value
+  ///   from.
+  /// - Parameter generator: The random number generator to use when getting
+  ///   the random floating point.
+  /// - Returns: A random representation of this floating point.
+  ///
+  /// This uses the standard library's default random number generator.
+  @inlinable
+  public static func random(in range: ${Range}<Self>) -> Self {
+    return Self.random(in: range, using: Random.default)
+  }
 }
 
 % end