   return StringTensor(handle: ret)
 }
 
-/// Computes asin of x element-wise.
+/// Computes the trignometric inverse sine of x element-wise.
+///
+/// The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that
+/// if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.
+///
+/// **Note**: The output of `tf.math.asin` will lie within the invertible range 
+/// of sine, i.e [-pi/2, pi/2].
+///
+/// For example:
+///
+/// ```python
+/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
+/// x = tf.constant([1.047, 0.785])
+/// y = tf.math.sin(x) # [0.8659266, 0.7068252]
+///
+/// tf.math.asin(y) # [1.047, 0.785] = x
+/// ```
+///
 @inlinable @inline(__always)
 public static func asin<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>

/// Returns the index with the smallest value across dimensions of a tensor.
///
/// Note that in case of ties the identity of the return value is not guaranteed.
///
/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
///   Describes which dimension of the input Tensor to reduce across. For vectors,

  return Tensor(handle: ret)
}

/// Computes the matrix square root of one or more square matrices:
///
/// matmul(sqrtm(A), sqrtm(A)) = A
///
/// The input matrix should be invertible. If the input matrix is real, it should
/// have no eigenvalues which are real and negative (pairs of complex conjugate
/// eigenvalues are allowed).
///
/// The matrix square root is computed by first reducing the matrix to 
/// quasi-triangular form with the real Schur decomposition. The square root 
/// of the quasi-triangular matrix is then computed directly. Details of 
/// the algorithm can be found in: Nicholas J. Higham, "Computing real 
/// square roots of a real matrix", Linear Algebra Appl., 1987.
///
/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
/// form square matrices. The output is a tensor of the same shape as the input
/// containing the matrix square root for all input submatrices `[..., :, :]`.
///
/// - Parameter input: Shape is `[..., M, M]`.
///
/// - Output output: Shape is `[..., M, M]`.
///
///   @compatibility(scipy)
///   Equivalent to scipy.linalg.sqrtm
///   @end_compatibility
@inlinable @inline(__always)
public static func matrixSquareRoot<T: FloatingPoint & TensorFlowScalar>(
  _ input: Tensor<T>
) -> Tensor<T> {
  let ret: TensorHandle<T> = #tfop("MatrixSquareRoot",
    input,
    T$dtype: T.tensorFlowDataType)
  return Tensor(handle: ret)
}

/// Solves systems of linear equations with upper or lower triangular matrices by
///
/// backsubstitution.
