[numpy] add op bitwise_not

python/mxnet/ndarray/numpy/_op.py

@@ -28,8 +28,8 @@
 from . import _internal as _npi
 from ..ndarray import NDArray
 
-__all__ = ['shape', 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like',
- 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power',
+__all__ = ['shape', 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like', 'invert',
+ 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'bitwise_not',
  'arctan2', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'sqrt', 'cbrt', 'abs',
  'absolute', 'exp', 'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log', 'degrees', 'log2',
  'log1p', 'rint', 'radians', 'reciprocal', 'square', 'negative', 'fix', 'ceil', 'floor', 'histogram',
@@ -2690,6 +2690,112 @@ def floor(x, out=None, **kwargs):
  return _unary_func_helper(x, _npi.floor, _np.floor, out=out, **kwargs)
 
 
+@set_module('mxnet.ndarray.numpy')
+@wrap_np_unary_func
+def bitwise_not(x, out=None, **kwargs):
+ r"""
+ Compute bit-wise inversion, or bit-wise NOT, element-wise.
+ Computes the bit-wise NOT of the underlying binary representation of
+ the integers in the input arrays. This ufunc implements the C/Python
+ operator ``~``.
+
+ Parameters
+ ----------
+ x : array_like
+ Only integer and boolean types are handled.
+ out : ndarray, None, or tuple of ndarray and None, optional
+ A location into which the result is stored. If provided, it must have
+ a shape that the inputs broadcast to. If not provided or `None`,
+ a freshly-allocated array is returned. A tuple (possible only as a
+ keyword argument) must have length equal to the number of outputs.
+
+ Returns
+ -------
+ out : ndarray or scalar
+ Result.
+ This is a scalar if `x` is a scalar.
+
+ See Also
+ --------
+ bitwise_and, bitwise_or, bitwise_xor
+ logical_not
+ binary_repr :
+ Return the binary representation of the input number as a string.
+
+ Examples
+ --------
+ We've seen that 13 is represented by ``00001101``.
+ The invert or bit-wise NOT of 13 is then:
+
+ >>> x = np.invert(np.array(13, dtype=np.uint8))
+ >>> x
+ 242
+ >>> np.binary_repr(x, width=8)
+ '11110010'
+
+ Notes
+ -----
+ `bitwise_not` is an alias for `invert`:
+
+ >>> np.bitwise_not is np.invert
+ True
+ """
+ return _unary_func_helper(x, _npi.bitwise_not, _np.bitwise_not, out=out, **kwargs)
+
+
+@set_module('mxnet.ndarray.numpy')
+@wrap_np_unary_func
+def invert(x, out=None, **kwargs):
+ r"""
+ Compute bit-wise inversion, or bit-wise NOT, element-wise.
+ Computes the bit-wise NOT of the underlying binary representation of
+ the integers in the input arrays. This ufunc implements the C/Python
+ operator ``~``.
+
+ Parameters
+ ----------
+ x : array_like
+ Only integer and boolean types are handled.
+ out : ndarray, None, or tuple of ndarray and None, optional
+ A location into which the result is stored. If provided, it must have
+ a shape that the inputs broadcast to. If not provided or `None`,
+ a freshly-allocated array is returned. A tuple (possible only as a
+ keyword argument) must have length equal to the number of outputs.
+
+ Returns
+ -------
+ out : ndarray or scalar
+ Result.
+ This is a scalar if `x` is a scalar.
+
+ See Also
+ --------
+ bitwise_and, bitwise_or, bitwise_xor
+ logical_not
+ binary_repr :
+ Return the binary representation of the input number as a string.
+
+ Examples
+ --------
+ We've seen that 13 is represented by ``00001101``.
+ The invert or bit-wise NOT of 13 is then:
+
+ >>> x = np.invert(np.array(13, dtype=np.uint8))
+ >>> x
+ 242
+ >>> np.binary_repr(x, width=8)
+ '11110010'
+
+ Notes
+ -----
+ `bitwise_not` is an alias for `invert`:
+
+ >>> np.bitwise_not is np.invert
+ True
+ """
+ return _unary_func_helper(x, _npi.bitwise_not, _np.bitwise_not, out=out, **kwargs)
+
+
 @set_module('mxnet.ndarray.numpy')
 @wrap_np_unary_func
 def trunc(x, out=None, **kwargs):

python/mxnet/numpy/multiarray.py

@@ -47,8 +47,8 @@
 from ..ndarray.ndarray import _storage_type
 
 __all__ = ['ndarray', 'empty', 'array', 'shape', 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like',
- 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power',
- 'arctan2', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10',
+ 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'bitwise_not',
+ 'arctan2', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'invert',
  'sqrt', 'cbrt', 'abs', 'absolute', 'exp', 'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log',
  'degrees', 'log2', 'log1p', 'rint', 'radians', 'reciprocal', 'square', 'negative', 'histogram',
  'fix', 'ceil', 'floor', 'trunc', 'logical_not', 'arcsinh', 'arccosh', 'arctanh', 'append', 'argsort',
@@ -3981,6 +3981,110 @@ def floor(x, out=None, **kwargs):
  """
  return _mx_nd_np.floor(x, out=out, **kwargs)
 
+@set_module('mxnet.numpy')
+@wrap_np_unary_func
+def invert(x, out=None, **kwargs):
+ r"""
+ Compute bit-wise inversion, or bit-wise NOT, element-wise.
+ Computes the bit-wise NOT of the underlying binary representation of
+ the integers in the input arrays. This ufunc implements the C/Python
+ operator ``~``.
+
+ Parameters
+ ----------
+ x : array_like
+ Only integer and boolean types are handled.
+ out : ndarray, None, or tuple of ndarray and None, optional
+ A location into which the result is stored. If provided, it must have
+ a shape that the inputs broadcast to. If not provided or `None`,
+ a freshly-allocated array is returned. A tuple (possible only as a
+ keyword argument) must have length equal to the number of outputs.
+
+ Returns
+ -------
+ out : ndarray or scalar
+ Result.
+ This is a scalar if `x` is a scalar.
+
+ See Also
+ --------
+ bitwise_and, bitwise_or, bitwise_xor
+ logical_not
+ binary_repr :
+ Return the binary representation of the input number as a string.
+
+ Examples
+ --------
+ We've seen that 13 is represented by ``00001101``.
+ The invert or bit-wise NOT of 13 is then:
+
+ >>> x = np.invert(np.array(13, dtype=np.uint8))
+ >>> x
+ 242
+ >>> np.binary_repr(x, width=8)
+ '11110010'
+
+ Notes
+ -----
+ `bitwise_not` is an alias for `invert`:
+
+ >>> np.bitwise_not is np.invert
+ True
+ """
+ return _mx_nd_np.bitwise_not(x, out=out, **kwargs)
+
+@set_module('mxnet.numpy')
+@wrap_np_unary_func
+def bitwise_not(x, out=None, **kwargs):
+ r"""
+ Compute bit-wise inversion, or bit-wise NOT, element-wise.
+ Computes the bit-wise NOT of the underlying binary representation of
+ the integers in the input arrays. This ufunc implements the C/Python
+ operator ``~``.
+
+ Parameters
+ ----------
+ x : array_like
+ Only integer and boolean types are handled.
+ out : ndarray, None, or tuple of ndarray and None, optional
+ A location into which the result is stored. If provided, it must have
+ a shape that the inputs broadcast to. If not provided or `None`,
+ a freshly-allocated array is returned. A tuple (possible only as a
+ keyword argument) must have length equal to the number of outputs.
+
+ Returns
+ -------
+ out : ndarray or scalar
+ Result.
+ This is a scalar if `x` is a scalar.
+
+ See Also
+ --------
+ bitwise_and, bitwise_or, bitwise_xor
+ logical_not
+ binary_repr :
+ Return the binary representation of the input number as a string.
+
+ Examples
+ --------
+ We've seen that 13 is represented by ``00001101``.
+ The invert or bit-wise NOT of 13 is then:
+
+ >>> x = np.invert(np.array(13, dtype=np.uint8))
+ >>> x
+ 242
+ >>> np.binary_repr(x, width=8)
+ '11110010'
+
+ Notes
+ -----
+ `bitwise_not` is an alias for `invert`:
+
+ >>> np.bitwise_not is np.invert
+ True
+ """
+ return _mx_nd_np.bitwise_not(x, out=out, **kwargs)
+
 
 @set_module('mxnet.numpy')
 @wrap_np_unary_func

python/mxnet/numpy_dispatch_protocol.py

@@ -218,6 +218,8 @@ def _register_array_function():
  'square',
  'cbrt',
  'reciprocal',
+ 'invert',
+ 'bitwise_not',
  'remainder',
  'sin',
  'cos',

python/mxnet/symbol/numpy/_symbol.py

@@ -36,7 +36,7 @@
 except ImportError:
  from builtins import slice as py_slice
 
-__all__ = ['zeros', 'zeros_like', 'ones', 'ones_like', 'full_like',
+__all__ = ['zeros', 'zeros_like', 'ones', 'ones_like', 'full_like', 'bitwise_not', 'invert',
  'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'arctan2',
  'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'sqrt', 'cbrt', 'abs', 'absolute', 'exp',
  'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log', 'degrees', 'log2', 'log1p',
@@ -1040,6 +1040,98 @@ def ones(shape, dtype=_np.float32, order='C', ctx=None):
  return _npi.ones(shape=shape, ctx=ctx, dtype=dtype)
 
 
+@set_module('mxnet.symbol.numpy')
+@wrap_np_unary_func
+def invert(x, out=None, **kwargs):
+ r"""
+ Compute bit-wise inversion, or bit-wise NOT, element-wise.
+ Computes the bit-wise NOT of the underlying binary representation of
+ the integers in the input arrays. This ufunc implements the C/Python
+ operator ``~``.
+ Parameters
+ ----------
+ x : array_like
+ Only integer and boolean types are handled.
+ out : ndarray, None, or tuple of ndarray and None, optional
+ A location into which the result is stored. If provided, it must have
+ a shape that the inputs broadcast to. If not provided or `None`,
+ a freshly-allocated array is returned. A tuple (possible only as a
+ keyword argument) must have length equal to the number of outputs.
+ Returns
+ -------
+ out : ndarray or scalar
+ Result.
+ This is a scalar if `x` is a scalar.
+ See Also
+ --------
+ bitwise_and, bitwise_or, bitwise_xor
+ logical_not
+ binary_repr :
+ Return the binary representation of the input number as a string.
+ Examples
+ --------
+ We've seen that 13 is represented by ``00001101``.
+ The invert or bit-wise NOT of 13 is then:
+ >>> x = np.invert(np.array(13, dtype=np.uint8))
+ >>> x
+ 242
+ >>> np.binary_repr(x, width=8)
+ '11110010'
+ Notes
+ -----
+ `bitwise_not` is an alias for `invert`:
+ >>> np.bitwise_not is np.invert
+ True
+ """
+ return _unary_func_helper(x, _npi.bitwise_not, _np.bitwise_not, out=out, **kwargs)
+
+
+@set_module('mxnet.symbol.numpy')
+@wrap_np_unary_func
+def bitwise_not(x, out=None, **kwargs):
+ r"""
+ Compute bit-wise inversion, or bit-wise NOT, element-wise.
+ Computes the bit-wise NOT of the underlying binary representation of
+ the integers in the input arrays. This ufunc implements the C/Python
+ operator ``~``.
+ Parameters
+ ----------
+ x : array_like
+ Only integer and boolean types are handled.
+ out : ndarray, None, or tuple of ndarray and None, optional
+ A location into which the result is stored. If provided, it must have
+ a shape that the inputs broadcast to. If not provided or `None`,
+ a freshly-allocated array is returned. A tuple (possible only as a
+ keyword argument) must have length equal to the number of outputs.
+ Returns
+ -------
+ out : ndarray or scalar
+ Result.
+ This is a scalar if `x` is a scalar.
+ See Also
+ --------
+ bitwise_and, bitwise_or, bitwise_xor
+ logical_not
+ binary_repr :
+ Return the binary representation of the input number as a string.
+ Examples
+ --------
+ We've seen that 13 is represented by ``00001101``.
+ The invert or bit-wise NOT of 13 is then:
+ >>> x = np.invert(np.array(13, dtype=np.uint8))
+ >>> x
+ 242
+ >>> np.binary_repr(x, width=8)
+ '11110010'
+ Notes
+ -----
+ `bitwise_not` is an alias for `invert`:
+ >>> np.bitwise_not is np.invert
+ True
+ """
+ return _unary_func_helper(x, _npi.bitwise_not, _np.bitwise_not, out=out, **kwargs)
+
+
 @set_module('mxnet.symbol.numpy')
 def full(shape, fill_value, dtype=None, order='C', ctx=None, out=None): # pylint: disable=too-many-arguments
  """

src/operator/mshadow_op.h

@@ -359,6 +359,18 @@ MXNET_UNARY_MATH_OP(negation, -a);
 
 MXNET_UNARY_MATH_OP(reciprocal, 1.0f / math::id(a));
 
+struct bitwise_not : public mxnet_op::tunable {
+ template<typename DType,
+ typename std::enable_if<!std::is_same<DType, bool>::value, int>::type = 0>
+ MSHADOW_XINLINE static DType Map(DType a) {
+ return ~static_cast<int64_t>(a);
+ }
+
+ MSHADOW_XINLINE static bool Map(bool a) {
+ return !a;
+ }
+};
+
 MXNET_UNARY_MATH_OP(reciprocal_grad, -1.0f / math::sqr(a));
 
 MXNET_UNARY_MATH_OP(sigmoid, 1.0f / (1.0f + math::exp(-a)));