tf.complex_abs(x, name=None) Computes the complex absolute value of a tensor. Given a tensor x of complex numbers, this operation returns a tensor of type float32 or float64 that is the absolute value of each element in x. All elements in x must be complex numbers of the form \(a + bj\). The absolute value is computed as \( \sqrt{a^2 + b^2}\). For example: # tensor 'x' is [[-2.25 + 4.75j], [-3.25 + 5.75j]] tf.complex_abs(x) ==> [5.25594902, 6.60492229] Args: x: A Tensor of type complex64

tf.cholesky_solve(chol, rhs, name=None) Solves systems of linear eqns A X = RHS, given Cholesky factorizations. # Solve 10 separate 2x2 linear systems: A = ... # shape 10 x 2 x 2 RHS = ... # shape 10 x 2 x 1 chol = tf.cholesky(A) # shape 10 x 2 x 2 X = tf.cholesky_solve(chol, RHS) # shape 10 x 2 x 1 # tf.matmul(A, X) ~ RHS X[3, :, 0] # Solution to the linear system A[3, :, :] x = RHS[3, :, 0] # Solve five linear systems (K = 5) for every member of the length 10 batch. A = ... # shape 10 x

tf.complex(real, imag, name=None) Converts two real numbers to a complex number. Given a tensor real representing the real part of a complex number, and a tensor imag representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form (a + bj), where a represents the real part and b represents the imag part. The input tensors real and imag must have the same shape. For example: # tensor 'real' is [2.25, 3.25] # tensor `imag` is [4.75, 5.75] tf.co

tf.betainc(a, b, x, name=None) Compute the regularized incomplete beta integral \(I_x(a, b)\). The regularized incomplete beta integral is defined as: I_x(a, b) = \frac{B(x; a, b)}{B(a, b)} where B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt is the incomplete beta function and \(B(a, b)\) is the complete beta function. Args: a: A Tensor. Must be one of the following types: float32, float64. b: A Tensor. Must have the same type as a. x: A Tensor. Must have the same type as a. name: A nam

tf.ceil(x, name=None) Returns element-wise smallest integer in not less than x. Args: x: A Tensor. Must be one of the following types: half, float32, float64. name: A name for the operation (optional). Returns: A Tensor. Has the same type as x.

tf.cholesky(input, name=None) Computes the Cholesky decomposition of one or more square matrices. The input is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices, with the same constraints as the single matrix Cholesky decomposition above. The output is a tensor of the same shape as the input containing the Cholesky decompositions for all input submatrices [..., :, :]. Args: input: A Tensor. Must be one of the following types: float64, float32. Shape is [..., M,

tf.batch_matmul(x, y, adj_x=None, adj_y=None, name=None) Multiplies slices of two tensors in batches. Multiplies all slices of Tensor x and y (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the adj_x or adj_y flag to True, which are by default False. The inp

tf.assert_rank_at_least(x, rank, data=None, summarize=None, message=None, name=None) Assert x has rank equal to rank or higher. Example of adding a dependency to an operation: with tf.control_dependencies([tf.assert_rank_at_least(x, 2)]): output = tf.reduce_sum(x) Example of adding dependency to the tensor being checked: x = tf.with_dependencies([tf.assert_rank_at_least(x, 2)], x) Args: x: Numeric Tensor. rank: Scalar Tensor. data: The tensors to print out if the condition is False. Def

tf.assert_type(tensor, tf_type, message=None, name=None) Statically asserts that the given Tensor is of the specified type. Args: tensor: A tensorflow Tensor. tf_type: A tensorflow type (dtypes.float32, tf.int64, dtypes.bool, etc). message: A string to prefix to the default message. name: A name to give this Op. Defaults to "assert_type" Raises: TypeError: If the tensors data type doesn't match tf_type. Returns: A no_op that does nothing. Type can be determined statically.

tf.as_string(input, precision=None, scientific=None, shortest=None, width=None, fill=None, name=None) Converts each entry in the given tensor to strings. Supports many numeric types and boolean. Args: input: A Tensor. Must be one of the following types: int32, int64, complex64, float32, float64, bool, int8. precision: An optional int. Defaults to -1. The post-decimal precision to use for floating point numbers. Only used if precision > -1. scientific: An optional bool. Defaults to False.