r"""Generates evenly-spaced values in an interval along a given axis.

with ops.name_scope(name, "linspace", [start, stop]):

start = ops.convert_to_tensor(start, name="start")

# stop must be convertible to the same dtype as start

stop = ops.convert_to_tensor(stop, name="stop", dtype=start.dtype)

num_int = array_ops.convert_to_int_tensor(num, name="num")

num = cast(num_int, dtype=start.dtype)

broadcast_shape = array_ops.broadcast_dynamic_shape(

array_ops.shape(start), array_ops.shape(stop))

start = array_ops.broadcast_to(start, broadcast_shape)

stop = array_ops.broadcast_to(stop, broadcast_shape)

expanded_start = array_ops.expand_dims(start, axis=axis)

expanded_stop = array_ops.expand_dims(stop, axis=axis)

shape = array_ops.shape(expanded_start)

ndims = array_ops.shape(shape)[0]

axis = array_ops.where_v2(axis >= 0, axis, ndims + axis)

# The purpose is to avoid having negative values when repeating.

num_fill = gen_math_ops.maximum(num_int - 2, 0)

# To avoid having negative values in the range or zero division

# the result is sliced in the end so a correct result is returned for

# num == 1, and num == 0.

n_steps = gen_math_ops.maximum(num_int - 1, 1)

delta = (expanded_stop - expanded_start) / cast(n_steps,

expanded_stop.dtype)

# Re-cast tensors as delta.

expanded_start = cast(expanded_start, delta.dtype)

expanded_stop = cast(expanded_stop, delta.dtype)

# If num < 0, we will throw exception in the range

# otherwise use the same div for delta

range_end = array_ops.where_v2(num_int >= 0, n_steps, -1)

# Even though range supports an output dtype, its limited

# (e.g. doesn't support half at the moment).

desired_range = cast(range(1, range_end, dtype=dtypes.int64), delta.dtype)

mask = gen_math_ops.equal(axis, range(ndims))

# desired_range_shape is [1. 1. 1. ... 1. num_fill 1. 1. ... 1.], where the

# index of num_fill is equal to axis.

desired_range_shape = array_ops.where_v2(mask, num_fill, 1)

desired_range = array_ops.reshape(desired_range, desired_range_shape)

res = expanded_start + delta * desired_range

# Add the start and endpoints to the result, and slice out the desired

# portion.

all_tensors = (expanded_start, res, expanded_stop)

concatenated = array_ops.concat(all_tensors, axis=axis)

begin = array_ops.zeros_like(shape)

# Preserve shape information for final slice.

size = array_ops.concat(

(shape[0:axis], array_ops.reshape(num_int, [1]), shape[axis + 1 :]),

axis=0,

)

def _decorator(func):

func.__doc__ = doc

return func

axis=None,

name=None,

dimension=None,

output_type=dtypes.int64):

axis = deprecation.deprecated_argument_lookup("axis", axis, "dimension",

dimension)

"""Returns the index with the largest value across axes of a tensor.

if axis is None:

axis = 0

if hasattr(axis, "dtype"):

allowed_dtypes = {

dtypes.int8,

dtypes.uint8,

dtypes.int16,

dtypes.uint16,

dtypes.int32,

dtypes.int64,

}

if axis.dtype not in allowed_dtypes:

raise TypeError(f"axis tensor dtypes {axis.dtype} is not supported")

castable_types = {dtypes.int8, dtypes.int16, dtypes.uint8, dtypes.uint16}

if axis.dtype in castable_types:

axis = cast(axis, dtypes.int32)

elif not isinstance(axis, int):

raise TypeError("axis must be int or Tensor with integer datatype")

axis=None,

name=None,

dimension=None,

output_type=dtypes.int64):

axis = deprecation.deprecated_argument_lookup("axis", axis, "dimension",

dimension)

"""Returns the index with the smallest value across axes of a tensor.

if axis is None:

axis = 0

r"""Computes the absolute value of a tensor.

with ops.name_scope(name, "Abs", [x]) as name:

x = ops.convert_to_tensor(x, name="x")

if x.dtype.is_complex:

return gen_math_ops.complex_abs(x, Tout=x.dtype.real_dtype, name=name)

"""Use Python2/Python3 division delegation to implement divide for tensors."""

def __init__(self, x, name):

"""Construct DivideDelegateWithName.

self.x = x

self.name = name

def __truediv__(self, y):

return _truediv_python3(self.x, y, self.name)

def __floordiv__(self, y):

return floordiv(self.x, y, self.name)

def __div__(self, y):

"""Computes Python style division of `x` by `y`.

if name is not None:

# Cannot use tensors operator overload, because it has no way to track

# override names. Use a dummy class to track the runtime division behavior

return DivideDelegateWithName(x, name) / y

else:

# We do conversion here to make sure at least x is a tensor.

if not tensor_util.is_tf_type(x):

dtype = y.dtype.base_dtype if tensor_util.is_tf_type(y) else None

x = ops.convert_to_tensor(x, dtype=dtype)

"""Returns an element-wise x * y.

"""Computes numerical negative value element-wise.

"""Multiplies a scalar times a `Tensor` or `IndexedSlices` object.

base_dtype = dtypes.as_dtype(x.dtype).base_dtype

scalar = ops.convert_to_tensor(

scalar, dtype=base_dtype, name="scalar")

shape = scalar.get_shape()

if shape.ndims == 0:

if isinstance(x, indexed_slices.IndexedSlices):

return indexed_slices.IndexedSlices(

gen_math_ops.mul(scalar, x.values, name), x.indices, x.dense_shape)

else:

return gen_math_ops.mul(scalar, x, name)

else:

raise ValueError(

"""Computes elementwise softplus: `softplus(x) = log(exp(x) + 1)`.

r"""Computes the power of one value to another.

with ops.name_scope(name, "Pow", [x]) as name:

r"""Converts two real numbers to a complex number.

real = ops.convert_to_tensor(real, name="real")

imag = ops.convert_to_tensor(imag, name="imag")

with ops.name_scope(name, "Complex", [real, imag]) as name:

input_types = (real.dtype, imag.dtype)

if input_types == (dtypes.float64, dtypes.float64):

Tout = dtypes.complex128

elif input_types == (dtypes.float32, dtypes.float32):

Tout = dtypes.complex64

else:

raise TypeError(

f"The `real` and `imag` components have incorrect types: "

f"{real.dtype.name} {imag.dtype.name}. They must be consistent, and "

f"one of {[dtypes.float32, dtypes.float64]}")

r"""Returns an element-wise indication of the sign of a number.

x = ops.convert_to_tensor(x)

if x.dtype.is_complex:

return gen_math_ops.div_no_nan(

x,

cast(

gen_math_ops.complex_abs(

x,

Tout=dtypes.float32

if x.dtype == dtypes.complex64 else dtypes.float64),

dtype=x.dtype),

name=name)

r"""Returns the real part of a complex (or real) tensor.

with ops.name_scope(name, "Real", [input]) as name:

input = ops.convert_to_tensor(input, name="input")

if input.dtype.is_complex:

real_dtype = input.dtype.real_dtype

return gen_math_ops.real(input, Tout=real_dtype, name=name)

elif input.dtype.is_numeric:

return input

else:

raise TypeError(

"input must be a numeric tensor, but got tensor with dtype {}".format(

input.dtype

)

r"""Returns the imaginary part of a complex (or real) tensor.

with ops.name_scope(name, "Imag", [input]) as name:

input = ops.convert_to_tensor(input, name="input")

if input.dtype.is_complex:

return gen_math_ops.imag(input, Tout=input.dtype.real_dtype, name=name)

else:

r"""Returns the element-wise argument of a complex (or real) tensor.

with ops.name_scope(name, "Angle", [input]) as name:

input = ops.convert_to_tensor(input, name="input")

if input.dtype.is_complex:

return gen_math_ops.angle(input, Tout=input.dtype.real_dtype, name=name)

else:

return array_ops.where(input < 0, np.pi * array_ops.ones_like(input),

"""Rounds the values of a tensor to the nearest integer, element-wise.

x = ops.convert_to_tensor(x, name="x")

if x.dtype.is_integer:

return x

else:

"""Casts a tensor to a new type.