neulab/docprompting-conala huggingface dataset:
tf.math.segment_max   Computes the maximum along segments of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.segment_max, tf.compat.v1.segment_max  
tf.math.segment_max(
    data, segment_ids, name=None
)
 Read the section on segmentation for an explanation of segments. Computes a tensor such that \(output_i = \max_j(data_j)\) where max is over j such that segment_ids[j] == i. If the max is empty for a given segment ID i, output[i] = 0.    For example: c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
tf.segment_max(c, tf.constant([0, 0, 1]))
# ==> [[4, 3, 3, 4],
#      [5, 6, 7, 8]]

 


 Args
  data   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.  
  segment_ids   A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose size is equal to the size of data's first dimension. Values should be sorted and can be repeated.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as data.
tf.math.segment_mean   Computes the mean along segments of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.segment_mean, tf.compat.v1.segment_mean  
tf.math.segment_mean(
    data, segment_ids, name=None
)
 Read the section on segmentation for an explanation of segments. Computes a tensor such that \(output_i = \frac{\sum_j data_j}{N}\) where mean is over j such that segment_ids[j] == i and N is the total number of values summed. If the mean is empty for a given segment ID i, output[i] = 0.    For example: c = tf.constant([[1.0,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
tf.segment_mean(c, tf.constant([0, 0, 1]))
# ==> [[2.5, 2.5, 2.5, 2.5],
#      [5, 6, 7, 8]]

 


 Args
  data   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64.  
  segment_ids   A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose size is equal to the size of data's first dimension. Values should be sorted and can be repeated.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as data.
tf.math.segment_min   Computes the minimum along segments of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.segment_min, tf.compat.v1.segment_min  
tf.math.segment_min(
    data, segment_ids, name=None
)
 Read the section on segmentation for an explanation of segments. Computes a tensor such that \(output_i = \min_j(data_j)\) where min is over j such that segment_ids[j] == i. If the min is empty for a given segment ID i, output[i] = 0.    For example: c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
tf.segment_min(c, tf.constant([0, 0, 1]))
# ==> [[1, 2, 2, 1],
#      [5, 6, 7, 8]]

 


 Args
  data   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64.  
  segment_ids   A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose size is equal to the size of data's first dimension. Values should be sorted and can be repeated.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as data.
tf.math.segment_prod   Computes the product along segments of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.segment_prod, tf.compat.v1.segment_prod  
tf.math.segment_prod(
    data, segment_ids, name=None
)
 Read the section on segmentation for an explanation of segments. Computes a tensor such that \(output_i = \prod_j data_j\) where the product is over j such that segment_ids[j] == i. If the product is empty for a given segment ID i, output[i] = 1.    For example: c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
tf.segment_prod(c, tf.constant([0, 0, 1]))
# ==> [[4, 6, 6, 4],
#      [5, 6, 7, 8]]

 


 Args
  data   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64.  
  segment_ids   A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose size is equal to the size of data's first dimension. Values should be sorted and can be repeated.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as data.
tf.math.segment_sum   Computes the sum along segments of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.segment_sum, tf.compat.v1.segment_sum  
tf.math.segment_sum(
    data, segment_ids, name=None
)
 Read the section on segmentation for an explanation of segments. Computes a tensor such that \(output_i = \sum_j data_j\) where sum is over j such that segment_ids[j] == i. If the sum is empty for a given segment ID i, output[i] = 0.    For example: c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
tf.segment_sum(c, tf.constant([0, 0, 1]))
# ==> [[5, 5, 5, 5],
#      [5, 6, 7, 8]]

 


 Args
  data   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64.  
  segment_ids   A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose size is equal to the size of data's first dimension. Values should be sorted and can be repeated.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as data.
tf.math.sigmoid       View source on GitHub    Computes sigmoid of x element-wise.  View aliases  Main aliases 
tf.nn.sigmoid, tf.sigmoid Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.sigmoid, tf.compat.v1.nn.sigmoid, tf.compat.v1.sigmoid  
tf.math.sigmoid(
    x, name=None
)
 Formula for calculating $\mathrm{sigmoid}(x) = y = 1 / (1 + \exp(-x))$. For $x \in (-\infty, \infty)$, $\mathrm{sigmoid}(x) \in (0, 1)$. Example Usage: If a positive number is large, then its sigmoid will approach to 1 since the formula will be y = <large_num> / (1 + <large_num>) 
x = tf.constant([0.0, 1.0, 50.0, 100.0])
tf.math.sigmoid(x)
<tf.Tensor: shape=(4,), dtype=float32,
numpy=array([0.5      , 0.7310586, 1.       , 1.       ], dtype=float32)>
 If a negative number is large, its sigmoid will approach to 0 since the formula will be y = 1 / (1 + <large_num>) 
x = tf.constant([-100.0, -50.0, -1.0, 0.0])
tf.math.sigmoid(x)
<tf.Tensor: shape=(4,), dtype=float32, numpy=
array([0.0000000e+00, 1.9287499e-22, 2.6894143e-01, 0.5],
      dtype=float32)>

 


 Args
  x   A Tensor with type float16, float32, float64, complex64, or complex128.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor with the same type as x.  
 Usage Example: 
x = tf.constant([-128.0, 0.0, 128.0], dtype=tf.float32)
tf.sigmoid(x)
<tf.Tensor: shape=(3,), dtype=float32,
numpy=array([0. , 0.5, 1. ], dtype=float32)>
 Scipy Compatibility Equivalent to scipy.special.expit
tf.math.sign     View source on GitHub    Returns an element-wise indication of the sign of a number.  View aliases  Main aliases 
tf.sign Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.sign, tf.compat.v1.sign  
tf.math.sign(
    x, name=None
)
 y = sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0. For complex numbers, y = sign(x) = x / |x| if x != 0, otherwise y = 0. Example usage: 
# real number
tf.math.sign([0., 2., -3.])
<tf.Tensor: shape=(3,), dtype=float32,
numpy=array([ 0.,  1., -1.], dtype=float32)>
 
# complex number
tf.math.sign([1 + 1j, 0 + 0j])
<tf.Tensor: shape=(2,), dtype=complex128,
numpy=array([0.70710678+0.70710678j, 0.        +0.j        ])>

 


 Args
  x   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, int32, int64, complex64, complex128.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as x. If x is a SparseTensor, returns SparseTensor(x.indices, tf.math.sign(x.values, ...), x.dense_shape). If x is a SparseTensor, returns SparseTensor(x.indices, tf.math.sign(x.values, ...), x.dense_shape)
tf.math.sin Computes sine of x element-wise.  View aliases  Main aliases 
tf.sin Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.sin, tf.compat.v1.sin  
tf.math.sin(
    x, name=None
)
 Given an input tensor, this function computes sine of every element in the tensor. Input range is (-inf, inf) and output range is [-1,1]. x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 200, 10, float("inf")])
tf.math.sin(x) ==> [nan -0.4121185 -0.47942555 0.84147096 0.9320391 -0.87329733 -0.54402107 nan]

 


 Args
  x   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as x.
tf.math.sinh Computes hyperbolic sine of x element-wise.  View aliases  Main aliases 
tf.sinh Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.sinh, tf.compat.v1.sinh  
tf.math.sinh(
    x, name=None
)
 Given an input tensor, this function computes hyperbolic sine of every element in the tensor. Input range is [-inf,inf] and output range is [-inf,inf]. x = tf.constant([-float("inf"), -9, -0.5, 1, 1.2, 2, 10, float("inf")])
tf.math.sinh(x) ==> [-inf -4.0515420e+03 -5.2109528e-01 1.1752012e+00 1.5094614e+00 3.6268604e+00 1.1013232e+04 inf]

 


 Args
  x   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, complex64, complex128.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as x.
tf.math.sobol_sample Generates points from the Sobol sequence.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.sobol_sample  
tf.math.sobol_sample(
    dim, num_results, skip=0, dtype=tf.dtypes.float32, name=None
)
 Creates a Sobol sequence with num_results samples. Each sample has dimension dim. Skips the first skip samples.
 


 Args
  dim   Positive scalar Tensor representing each sample's dimension.  
  num_results   Positive scalar Tensor of dtype int32. The number of Sobol points to return in the output.  
  skip   (Optional) Positive scalar Tensor of dtype int32. The number of initial points of the Sobol sequence to skip. Default value is 0.  
  dtype   (Optional) The tf.Dtype of the sample. One of: tf.float32 or tf.float64. Defaults to tf.float32.  
  name   (Optional) Python str name prefixed to ops created by this function.   
 


 Returns   Tensor of samples from Sobol sequence with shape [num_results, dim].
tf.math.softplus Computes softplus: log(exp(features) + 1).  View aliases  Main aliases 
tf.nn.softplus Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.softplus, tf.compat.v1.nn.softplus  
tf.math.softplus(
    features, name=None
)

 


 Args
  features   A Tensor. Must be one of the following types: half, bfloat16, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as features.
Module: tf.math.special Public API for tf.math.special namespace. Functions bessel_i0(...): Computes the Bessel i0 function of x element-wise. bessel_i0e(...): Computes the Bessel i0e function of x element-wise. bessel_i1(...): Computes the Bessel i1 function of x element-wise. bessel_i1e(...): Computes the Bessel i1e function of x element-wise. bessel_j0(...): Computes the Bessel j0 function of x element-wise. bessel_j1(...): Computes the Bessel j1 function of x element-wise. bessel_k0(...): Computes the Bessel k0 function of x element-wise. bessel_k0e(...): Computes the Bessel k0e function of x element-wise. bessel_k1(...): Computes the Bessel k1 function of x element-wise. bessel_k1e(...): Computes the Bessel k1e function of x element-wise. bessel_y0(...): Computes the Bessel y0 function of x element-wise. bessel_y1(...): Computes the Bessel y1 function of x element-wise. dawsn(...): Computes Dawson's integral of x element-wise. expint(...): Computes the Exponential integral of x element-wise. fresnel_cos(...): Computes Fresnel's cosine integral of x element-wise. fresnel_sin(...): Computes Fresnel's sine integral of x element-wise. spence(...): Computes Spence's integral of x element-wise.
tf.math.special.bessel_j0 Computes the Bessel j0 function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_j0  
tf.math.special.bessel_j0(
    x, name=None
)
 Modified Bessel function of order 0. 
tf.math.special.bessel_j0([0.5, 1., 2., 4.]).numpy()
array([ 0.93846981,  0.76519769,  0.22389078, -0.39714981], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.j0
tf.math.special.bessel_j1 Computes the Bessel j1 function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_j1  
tf.math.special.bessel_j1(
    x, name=None
)
 Modified Bessel function of order 1. 
tf.math.special.bessel_j1([0.5, 1., 2., 4.]).numpy()
array([ 0.24226846,  0.44005059,  0.57672481, -0.06604333], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.j1
tf.math.special.bessel_k0 Computes the Bessel k0 function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_k0  
tf.math.special.bessel_k0(
    x, name=None
)
 Modified Bessel function of order 0. It is preferable to use the numerically stabler function k0e(x) instead. 
tf.math.special.bessel_k0([0.5, 1., 2., 4.]).numpy()
array([0.92441907, 0.42102444, 0.11389387, 0.01115968], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.k0
tf.math.special.bessel_k0e Computes the Bessel k0e function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_k0e  
tf.math.special.bessel_k0e(
    x, name=None
)
 Modified Bessel function of order 0. 
tf.math.special.bessel_k0e([0.5, 1., 2., 4.]).numpy()
array([1.52410939, 1.14446308, 0.84156822, 0.60929767], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.k0e
tf.math.special.bessel_k1 Computes the Bessel k1 function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_k1  
tf.math.special.bessel_k1(
    x, name=None
)
 Modified Bessel function of order 1. It is preferable to use the numerically stabler function k1e(x) instead. 
tf.math.special.bessel_k1([0.5, 1., 2., 4.]).numpy()
array([1.65644112, 0.60190723, 0.13986588, 0.0124835 ], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.k1
tf.math.special.bessel_k1e Computes the Bessel k1e function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_k1e  
tf.math.special.bessel_k1e(
    x, name=None
)
 Modified Bessel function of order 1. 
tf.math.special.bessel_k1e([0.5, 1., 2., 4.]).numpy()
array([2.73100971, 1.63615349, 1.03347685, 0.68157595], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.k1e
tf.math.special.bessel_y0 Computes the Bessel y0 function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_y0  
tf.math.special.bessel_y0(
    x, name=None
)
 Modified Bessel function of order 0. 
tf.math.special.bessel_y0([0.5, 1., 2., 4.]).numpy()
array([-0.44451873,  0.08825696,  0.51037567, -0.01694074], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.y0
tf.math.special.bessel_y1 Computes the Bessel y1 function of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.bessel_y1  
tf.math.special.bessel_y1(
    x, name=None
)
 Modified Bessel function of order 1. 
tf.math.special.bessel_y1([0.5, 1., 2., 4.]).numpy()
array([-1.47147239, -0.78121282, -0.10703243,  0.39792571], dtype=float32)

 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: half, float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.y1
tf.math.special.dawsn Computes Dawson's integral of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.dawsn  
tf.math.special.dawsn(
    x, name=None
)
 Dawson's integral is defined as exp(-x**2) times the integral of exp(t**2) from 0 to x, with the domain of definition all real numbers. Dawson's function is odd. >>> tf.math.special.dawsn([-1., -0.5, 0.5, 1.]).numpy()
array([-0.5380795, -0.4244364, 0.4244364,  0.5380795], dtype=float32)
 This implementation is based off of the Cephes math library.
 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.dawsn
tf.math.special.expint Computes the Exponential integral of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.expint  
tf.math.special.expint(
    x, name=None
)
 The Exponential integral is defined as the integral of exp(t) / t from -inf to x, with the domain of definition all positive real numbers. 
tf.math.special.expint([1., 1.1, 2.1, 4.1]).numpy()
array([ 1.8951179,  2.1673784,  5.3332353, 21.048464], dtype=float32)
 This implementation is based off of the Cephes math library.
 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.expi
tf.math.special.fresnel_cos Computes Fresnel's cosine integral of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.fresnel_cos  
tf.math.special.fresnel_cos(
    x, name=None
)
 The Fresnel cosine integral is defined as the integral of cos(t^2) from 0 to x, with the domain of definition all real numbers. The Fresnel cosine integral is odd. >>> tf.math.special.fresnel_cos([-1., -0.1, 0.1, 1.]).numpy()
array([-0.7798934 , -0.09999753,  0.09999753,  0.7798934 ], dtype=float32)
 This implementation is based off of the Cephes math library.
 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.fresnel second output.
tf.math.special.fresnel_sin Computes Fresnel's sine integral of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.fresnel_sin  
tf.math.special.fresnel_sin(
    x, name=None
)
 The Fresnel sine integral is defined as the integral of sin(t^2) from 0 to x, with the domain of definition all real numbers. 
tf.math.special.fresnel_sin([-1., -0.1, 0.1, 1.]).numpy()
array([-0.43825912, -0.00052359,  0.00052359,  0.43825912], dtype=float32)
 This implementation is based off of the Cephes math library.
 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.fresnel first output.
tf.math.special.spence Computes Spence's integral of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.special.spence  
tf.math.special.spence(
    x, name=None
)
 Spence's integral is defined as the integral of log(t) / (1 - t) from 1 to x, with the domain of definition all non-negative real numbers. 
tf.math.special.spence([0.5, 1., 2., 3.]).numpy()
array([ 0.58224034,  0.        , -0.82246685, -1.4367464], dtype=float32)
 This implementation is based off of the Cephes math library.
 


 Args
  x   A Tensor or SparseTensor. Must be one of the following types: float32, float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor or SparseTensor, respectively. Has the same type as x.  
 Scipy Compatibility Equivalent to scipy.special.spence
tf.math.sqrt     View source on GitHub    Computes element-wise square root of the input tensor.  View aliases  Main aliases 
tf.sqrt Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.sqrt, tf.compat.v1.sqrt  
tf.math.sqrt(
    x, name=None
)
 
Note: This operation does not support integer types.
 
x = tf.constant([[4.0], [16.0]])
tf.sqrt(x)
<tf.Tensor: shape=(2, 1), dtype=float32, numpy=
  array([[2.],
         [4.]], dtype=float32)>
y = tf.constant([[-4.0], [16.0]])
tf.sqrt(y)
<tf.Tensor: shape=(2, 1), dtype=float32, numpy=
  array([[nan],
         [ 4.]], dtype=float32)>
z = tf.constant([[-1.0], [16.0]], dtype=tf.complex128)
tf.sqrt(z)
<tf.Tensor: shape=(2, 1), dtype=complex128, numpy=
  array([[0.0+1.j],
         [4.0+0.j]])>
 
Note: In order to support complex complex, please provide an input tensor of complex64 or complex128.

 


 Args
  x   A tf.Tensor of type bfloat16, half, float32, float64, complex64, complex128  
  name   A name for the operation (optional).   
 


 Returns   A tf.Tensor of same size, type and sparsity as x. If x is a SparseTensor, returns SparseTensor(x.indices, tf.math.sqrt(x.values, ...), x.dense_shape)