[WIP] Try conforming to ElementaryFunctions.

Author: rxwei

Sources/TensorFlow/Operators/Math.swift

@@ -23,9 +23,150 @@ func pow<T: BinaryFloatingPoint>(_ x: T, _ y: T) -> T {
     return T(pow(Double(x), Double(y)))
 }
 
-// TODO:
-// - Consider explicit broadcasting for elementwise binary ops when
-//   scalarization and rank getter are implemented.
+//===------------------------------------------------------------------------------------------===//
+// Generic elementary functions
+//===------------------------------------------------------------------------------------------===//
+
+extension Tensor: ElementaryFunctions where Scalar: FloatingPoint {
+    /// The square root of `x`.
+    ///
+    /// For real types, if the argument is negative, either the result is NaN
+    /// or a precondition failure occurs. For complex types, this function has
+    /// a branch cut along the negative real axis.
+    @differentiable
+    public static func sqrt(_ x: Self) -> Self {
+        return TensorFlow.sqrt(x)
+    }
+  
+    /// The cosine of `x`.
+    ///
+    /// For real types, `x` is interpreted as an angle measured in radians.
+    @differentiable
+    public static func cos(_ x: Self) -> Self {
+        return TensorFlow.cos(x)
+    }
+  
+    /// The sine of `x`.
+    ///
+    /// For real types, `x` is interpreted as an angle measured in radians.
+    @differentiable
+    public static func sin(_ x: Self) -> Self {
+        return TensorFlow.sin(x)
+    }
+  
+    /// The tangent of `x`.
+    @differentiable
+    public static func tan(_ x: Self) -> Self {
+        return TensorFlow.tan(x)
+    }
+  
+    /// The acos function.
+    public static func acos(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The asin function.
+    public static func asin(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The atan function.
+    public static func atan(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The cosh function.
+    public static func cosh(_ x: Self) -> Self {
+        TensorFlow.cosh(x)
+    }
+  
+    /// The sinh function.
+    public static func sinh(_ x: Self) -> Self {
+        TensorFlow.sinh(x)
+    }
+  
+    /// The tanh function.
+    public static func tanh(_ x: Self) -> Self {
+        TensorFlow.tanh(x)
+    }
+  
+    /// The acosh function.
+    public static func acosh(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The asinh function.
+    public static func asinh(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The atanh function.
+    public static func atanh(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The exp function.
+    public static func exp(_ x: Self) -> Self {
+        TensorFlow.exp(x)
+    }
+  
+    /// The exp2 function.
+    public static func exp2(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The exp10 function.
+    public static func exp10(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The expm1 function.
+    public static func expm1(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The log function.
+    public static func log(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The log2 function.
+    public static func log2(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The log10 function.
+    public static func log10(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The log1p function.
+    public static func log1p(_ x: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// `exp(y log(x))` computed without loss of intermediate precision.
+    ///
+    /// For real types, if `x` is negative the result is NaN, even if `y` has
+    /// an integral value. For complex types, there is a branch cut on the
+    /// negative real axis.
+    public static func pow(_ x: Self, _ y: Self) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// `x` raised to the `n`th power.
+    public static func pow(_ x: Self, _ n: Int) -> Self {
+        fatalError("Unimplemented")
+    }
+  
+    /// The `n`th root of `x`.
+    ///
+    /// For real types, if `x` is negative and `n` is even, the result is NaN.
+    /// For complex types, there is a branch cut along the negative real axis.
+    public static func root(_ x: Self, _ n: Int) -> Self {
+        fatalError("Unimplemented")
+    }
+}
 
 //===------------------------------------------------------------------------------------------===//
 // Vector Space