Skip to content
This repository was archived by the owner on Nov 10, 2025. It is now read-only.

Alias bitwise_not with invert #399

Open
bveeramani wants to merge 5 commits into
base: master
Choose a base branch
from
Open

Alias bitwise_not with invert #399

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
cfe7690
Alias `bitwise_not` with `invert`
bveeramani Apr 6, 2022
704aa92
Remove `bitwise_not` from documentation
bveeramani Apr 6, 2022
75f7bd5
Update generated.py
bveeramani Apr 6, 2022
c33fa03
Update generated.py
bveeramani Apr 6, 2022
5239972
Merge branch 'master' into rename-bitwise-not
bveeramani Apr 12, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 1 addition & 2 deletions docs/source/numpy.rst
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -79,7 +79,6 @@ NumS Supported API
arcsinh
arctan
arctanh
bitwise_not
cbrt
ceil
conj
Expand Down Expand Up @@ -159,4 +158,4 @@ NumS Supported API
ones
empty_like
trace
top_k
top_k
Copy link
Member Author

@bveeramani bveeramani Apr 6, 2022

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

EOL was missing here.

102 changes: 3 additions & 99 deletions nums/numpy/api/generated.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -600,105 +600,6 @@ def arctanh(x: BlockArray, out: BlockArray = None, where=True, **kwargs) -> Bloc
)


def bitwise_not(
x: BlockArray, out: BlockArray = None, where=True, **kwargs
) -> BlockArray:
"""Compute bit-wise inversion, or bit-wise NOT, element-wise.

This docstring was copied from numpy.bitwise_not.

Some inconsistencies with the NumS version may exist.

Computes the bit-wise NOT of the underlying binary representation of
the integers in the input arrays. This ufunc implements the C/Python
operator ``~``.

For signed integer inputs, the two's complement is returned. In a
two's-complement system negative numbers are represented by the two's
complement of the absolute value. This is the most common method of
representing signed integers on computers [1]_. A N-bit
two's-complement system can represent every integer in the range
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters
----------
x : BlockArray
Only integer and boolean types are handled.
out : BlockArray, None, or 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.
where : BlockArray, optional
This condition is broadcast over the input. At locations where the
condition is True, the `out` array will be set to the ufunc result.
Elsewhere, the `out` array will retain its original value.
Note that if an uninitialized `out` array is created via the default
``out=None``, locations within it where the condition is False will
remain uninitialized.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.

Returns
-------
out : BlockArray or scalar
Result.

See Also
--------
bitwise_and, bitwise_or, bitwise_xor
logical_not
binary_repr :
Return the binary representation of the input number as a string.

References
----------
.. [1] Wikipedia, "Two's complement",
https://en.wikipedia.org/wiki/Two's_complement

Examples
--------
The doctests shown below are copied from NumPy.
They won’t show the correct result until you operate ``get()``.

We've seen that 13 is represented by ``00001101``.
The invert or bit-wise NOT of 13 is then:

>>> x = nps.invert(nps.array(13, dtype=nps.uint8)) # doctest: +SKIP
>>> x.get() # doctest: +SKIP
array(242, dtype=uint8)

The result depends on the bit-width:

>>> x = nps.invert(nps.array(13, dtype=nps.uint16)).get() # doctest: +SKIP
>>> x # doctest: +SKIP
65522
>>> nps.binary_repr(x, width=16).get() # doctest: +SKIP
'1111111111110010'

When using signed integer types the result is the two's complement of
the result for the unsigned type:

>>> nps.invert(nps.array([13], dtype=nps.int8)).get() # doctest: +SKIP
array([-14], dtype=int8)
>>> nps.binary_repr(-14, width=8).get() # doctest: +SKIP
'11110010'

Booleans are accepted as well:

>>> nps.invert(nps.array([True, False])).get() # doctest: +SKIP
array([False, True])
"""
return _instance().map_uop(
op_name="bitwise_not",
arr=x,
out=out,
where=where,
kwargs=numpy_utils.ufunc_kwargs(kwargs),
)


def cbrt(x: BlockArray, out: BlockArray = None, where=True, **kwargs) -> BlockArray:
"""Return the cube-root of an array, element-wise.

Expand Down Expand Up @@ -1539,6 +1440,9 @@ def invert(x: BlockArray, out: BlockArray = None, where=True, **kwargs) -> Block
)


bitwise_not = invert


def isfinite(x: BlockArray, out: BlockArray = None, where=True, **kwargs) -> BlockArray:
"""Test element-wise for finiteness (not infinity or not Not a Number).

Expand Down