def floordiv(x, y, name=None):
"""Divides `x / y` elementwise, rounding down for floating point.
The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for
floating point arguments so that the result is always an integer (though
possibly an integer represented as floating point). This op is generated by
`x // y` floor division in Python 3 and in Python 2.7 with
`from __future__ import division`.
Note that for efficiency, `floordiv` uses C semantics for negative numbers
(unlike Python and Numpy).
`x` and `y` must have the same type, and the result will have the same type
as well.
Args:
x: `Tensor` numerator of real numeric type.
y: `Tensor` denominator of real numeric type.
name: A name for the operation (optional).
Returns:
`x / y` rounded down (except possibly towards zero for negative integers).
Raises:
TypeError: If the inputs are complex.
"""
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 gen_math_ops.floor(gen_math_ops.div(x, y), name=name)
else:
if not dtype.is_integer:
raise TypeError("Expected floating point or integer, got %r" % dtype)
return gen_math_ops.div(x, y, name=name)
def test_tf_div(self):
from tensorflow.python.ops.gen_math_ops import div
shape = 1000
# test floating data
x_val = (np.random.sample(shape) + 1e-6).astype(np.float32)
y_val = (np.random.sample(shape) + 1e-6).astype(np.float32)
x = tf.placeholder(tf.float32, x_val.shape, name=_TFINPUT)
y = tf.placeholder(tf.float32, y_val.shape, name=_TFINPUT1)
output = div(x, y, name=_TFOUTPUT)
assert output.op.type == "Div"
self._run_test_case([_OUTPUT], {_INPUT: x_val, _INPUT1: y_val})
tf.reset_default_graph()
# test integer data
x_val = (100 * np.random.sample(shape) + 1).astype(np.int32)
y_val = (100 * np.random.sample(shape) + 1).astype(np.int32)
x = tf.placeholder(tf.int32, x_val.shape, name=_TFINPUT)
y = tf.placeholder(tf.int32, y_val.shape, name=_TFINPUT1)
output = div(x, y, name=_TFOUTPUT)
assert output.op.type == "Div"
self._run_test_case([_OUTPUT], {_INPUT: x_val, _INPUT1: y_val})
def truediv(x, y, name=None):
"""Divides x / y elementwise, always producing floating point results.
The same as `tf.div` for floating point arguments, but casts integer arguments
to floating point before dividing so that the result is always floating point.
This op is generated by normal `x / y` division in Python 3 and in Python 2.7
with `from __future__ import division`. If you want integer division that
rounds down, use `x // y` or `tf.floordiv`.
`x` and `y` must have the same numeric type. If the inputs are floating
point, the output will have the same type. If the inputs are integral, the
inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`
and `int64` (matching the behavior of Numpy).
Args:
x: `Tensor` numerator of numeric type.
y: `Tensor` denominator of numeric type.
name: A name for the operation (optional).
Returns:
`x / y` evaluated in floating point.
Raises:
TypeError: If `x` and `y` have different dtypes.
"""
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)
return gen_math_ops.div(x, y, name=name)
