In order to better support writing numerical algorithms, we should provide bindings for <math.h>-style elementary functions that are generic over scalar types (including allowance for future complex types) and SIMD vectors.
Motivation
BinaryFloatingPoint (and the protocols it refines) provides a powerful set of abstractions for writing numerical code, but it does not include the transcendental operations defined by the C math library, which are instead imported by the platform overlay as a set of overloaded concrete free functions. This makes it impossible to write generic code that uses, say exp or sin without defining your own trampolines or converting everything to and from Double, neither of which is very satisfying.
For example, suppose that we want to write a sigmoid function that works for any floating-point type. We "should" be able to write something like the following:
func sigmoid<T>(_ x: T) -> T where T: FloatingPoint {
return 1/(1 + exp(-x))
}
but that isn't valid, because the FloatingPoint protocol only binds IEEE 754 operations, which exp is not. Instead we can currently do something like:
return 1/(1 + T(exp(-Double(x))))
but that's messy, inefficient if T is less precise than Double, and inaccurate if T is more precise than Double. We can and should do better in Swift.
This issue has come up a few times in past discussion, and was recently mentioned in a fast.ai article about using Swift for numerical computing. I finally have a little bit of breathing room to tackle it, so I would like to push on getting this functionality into Swift 5.1. A link to the draft proposal can be found below, and I'll publish a full draft implementation in the next couple of days.
