"""Computes the absolute value of a tensor.

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

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

if x.dtype == dtypes.complex64:

return gen_math_ops.complex_abs(x, name=name)

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

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

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

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

"""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.

with ops.op_scope([x], name, "Cast") as name:

if isinstance(x, ops.SparseTensor):

values_cast = cast(x.values, dtype, name=name)

return ops.SparseTensor(x.indices, values_cast, x.shape)

else:

# TODO(touts): Handle what Josh said.

#

# Could return ops.convert_to_tensor(x, dtype=dtype, ...) here, but that

# allows some conversions that cast() can't do, e.g. casting numbers to

# strings.

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

if x.dtype.base_dtype == dtype:

return x

"""Casts a tensor to type `float32`.

"""Casts a tensor to type `float64`.

"""Casts a tensor to type `int32`.

"""Casts a tensor to type `int64`.

"""Casts a tensor to type `bfloat16`.

"""Register operators with different tensor and scalar versions.

def binary_op_wrapper(x, y):

with ops.op_scope([x, y], None, op_name) as name:

assert isinstance(x, ops.Tensor)

y = ops.convert_to_tensor(y, dtype=x.dtype.base_dtype, name="y")

return func(x, y, name=name)

ops.Tensor._override_operator("__%s__" % op_name, binary_op_wrapper)

del binary_op_wrapper

def r_binary_op_wrapper(y, x):

with ops.op_scope([x, y], None, op_name) as name:

assert isinstance(y, ops.Tensor)

x = ops.convert_to_tensor(x, dtype=y.dtype.base_dtype, name="x")

return func(x, y, name=name)

ops.Tensor._override_operator("__r%s__" % op_name, r_binary_op_wrapper)

dtypes.uint8: dtypes.float32,

dtypes.int8: dtypes.float32,

dtypes.int16: dtypes.float32,

dtypes.int32: dtypes.float64,

dtypes.int64: dtypes.float64,

dtypes.float32: None,

dtypes.float64: None,

dtypes.complex64: None,

"""Divides x / y elementwise, always producing floating point results.

with ops.op_scope([x, y], name, "truediv") as name:

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

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

x_dtype = x.dtype.base_dtype

y_dtype = y.dtype.base_dtype

if x_dtype != y_dtype:

raise TypeError("x and y must have the same dtype, got %r != %r" %

(x_dtype, y_dtype))

try:

dtype = _TRUEDIV_TABLE[x_dtype]

except KeyError:

raise TypeError("Invalid dtype %r in __truediv__" % x_dtype)

if dtype is not None:

x = cast(x, dtype)

y = cast(y, dtype)

"""Divides `x / y` elementwise, rounding down for floating point.

with ops.op_scope([x, y], name, "floordiv") as name:

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

dtype = x.dtype

if dtype.is_floating:

return floor(div(x, y), name=name)

else:

if not dtype.is_integer:

raise TypeError("Expected floating point or integer, got %r" % dtype)

"""x ^ y = (x | y) & ~(x & y)."""

# TODO(alemi) Make this a cwise op if people end up relying on it.

return logical_and(logical_or(x, y), logical_not(logical_and(x, y)),

"""Creates a sequence of integers.

if limit is None:

start, limit = 0, start

start_value = tensor_util.ConstantValue(op.inputs[0])

limit_value = tensor_util.ConstantValue(op.inputs[1])

delta_value = tensor_util.ConstantValue(op.inputs[2])

if start_value is None or limit_value is None or delta_value is None:

return [tensor_shape.vector(None)]

else:

return [tensor_shape.vector((limit_value - start_value + delta_value - 1) //

"""Returns range(0, rank(x)) if reduction_indices is None."""

if reduction_indices is not None:

return reduction_indices

else:

name=None):

"""Computes the sum of elements across dimensions of a tensor.

return gen_math_ops._sum(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

name=None):

"""Computes the mean of elements across dimensions of a tensor.

return gen_math_ops._mean(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

name=None):

"""Computes the product of elements across dimensions of a tensor.

return gen_math_ops._prod(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

name=None):

"""Computes the minimum of elements across dimensions of a tensor.

return gen_math_ops._min(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

name=None):

"""Computes the maximum of elements across dimensions of a tensor.

return gen_math_ops._max(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

name=None):

"""Computes the "logical and" of elements across dimensions of a tensor.

return gen_math_ops._all(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

name=None):

"""Computes the "logical or" of elements across dimensions of a tensor.

return gen_math_ops._any(input_tensor, _ReductionDims(input_tensor,

reduction_indices),

transpose_a=False, transpose_b=False,

a_is_sparse=False, b_is_sparse=False,

name=None):

"""Multiplies matrix `a` by matrix `b`, producing `a` * `b`.

with ops.op_scope([a, b], name, "MatMul") as name:

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

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

if a.dtype == dtypes.float32 and (a_is_sparse or b_is_sparse):

return sparse_matmul(a, b,

transpose_a=transpose_a,

transpose_b=transpose_b,

a_is_sparse=a_is_sparse,

b_is_sparse=b_is_sparse,

name=name)

else:

return gen_math_ops._mat_mul(a, b,

transpose_a=transpose_a,

transpose_b=transpose_b,

"""Convert 'x' to IndexedSlices.

# TODO(touts): op_scope

if not isinstance(x, (ops.Tensor, ops.IndexedSlices)):

raise TypeError("Not a Tensor or IndexedSlices: %s" % type(x))

if isinstance(x, ops.IndexedSlices):

return x

x_shape = array_ops.shape(x)

"""Convert all elements of 'inputs' to IndexedSlices.

if not isinstance(inputs, (list, tuple)):

raise TypeError("Expected a list or tuple, not a %s" % type(inputs))

outputs = [_as_indexed_slices(i) for i in inputs]

with_int32_index = [o.indices for o in outputs

if o.indices.dtype == dtypes.int32]

if not with_int32_index or len(with_int32_index) == len(outputs):

return outputs

casted_outputs = []

for o in outputs:

if o.indices.dtype == dtypes.int32:

casted_outputs.append(

ops.IndexedSlices(o.values, cast(o.indices, dtypes.int64),

o.dense_shape))

else:

casted_outputs.append(o)

"""Returns the element-wise sum of a list of tensors.