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)