Hi Jens —
BinaryFloatingPoint is very deliberately limited to the arithmetic
operations required by IEEE 754. This is the minimal set of operations that
a binary floating point type should provide, but it's already a really
large implementation burden for someone who wants to implement their own
conforming type.
I agree that there should eventually be either a refinement or orthogonal
protocol[s] with the semantics “type implements [a subset of] the standard
math functions”, but those shouldn’t get bolted onto BinaryFloatingPoint—implementing
these functions for an arbitrary BinaryFloatingPoint type is highly
non-trivial, and would make the implementation burden for a new floating
point type unreasonably high. This is also out-of-scope for the current
phase of Swift evolution.
In the short term for your immediate problem at hand, I’ve been doing
something like:
import Darwin
public protocol Math: BinaryFloatingPoint {
func _exp() -> Self
func _log() -> Self
func _sin() -> Self
func _cos() -> Self
}
extension Double: Math {
public func _exp() -> Double { return exp(self) }
public func _log() -> Double { return log(self) }
public func _sin() -> Double { return sin(self) }
public func _cos() -> Double { return cos(self) }
}
extension Float: Math {
public func _exp() -> Float { return exp(self) }
public func _log() -> Float { return log(self) }
public func _sin() -> Float { return sin(self) }
public func _cos() -> Float { return cos(self) }
}
func exp<T: Math>(_ x: T) -> T { return x._exp() }
func log<T: Math>(_ x: T) -> T { return x._log() }
func sin<T: Math>(_ x: T) -> T { return x._sin() }
func cos<T: Math>(_ x: T) -> T { return x._cos() }
extension Math {
func sigmoid() -> Self {
return 1.0 / (1.0 + exp(-self))
}
}
let x = 1.0
x.sigmoid()
Someone else might have a more clever solution.
– Steve
On Jan 5, 2017, at 8:22 AM, Jens Persson via swift-users < > swift-users@swift.org> wrote:
The code below doesn't compile since there is no exponential function
(exp) that works on all FloatingPoint or BinaryFloatingPoint types, also no
protocol seems to define the power function or the constant e, although
they do define for example: basic arithmetic operators, squareRoot() and pi.
extension BinaryFloatingPoint {
func sigmoid() -> Self {
return 1.0 / (1.0 + exp(-self))
}
}
I could, but don't want to write two free funcs sigmoid(Float) -> Float
and sigmoid(Double) -> Double, because I need to use x.sigmoid() in several
places where x is of a generic type (a BinaryFloatingPoint).
More generally: I would have the same problem if I needed eg sin or cos.
Are there any particular reason why, given a generic BinaryFloatingPoint, I
cannot use sin or cos, while I can use pi and squareRoot()? It does seem a
bit arbitrary.
Any ideas on how to implement a sigmoid() that works for all
BinaryFloatingPoint types?
/Jens
_______________________________________________
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users