Update links and add more examples with dpnp.binary_repr

Author: antonwolfy

dpnp/dpnp_iface_bitwise.py

@@ -165,14 +165,16 @@ def binary_repr(num, width=None):
 :obj:`dpnp.logical_and` : Compute the truth value of ``x1`` AND ``x2`` element-wise.
 :obj:`dpnp.bitwise_or`: Compute the bit-wise OR of two arrays element-wise.
 :obj:`dpnp.bitwise_xor` : Compute the bit-wise XOR of two arrays element-wise.
+:obj:`dpnp.binary_repr` : Return the binary representation of the input number
+                          as a string.
 
 Examples
 --------
 >>> import dpnp as np
 >>> x1 = np.array([2, 5, 255])
->>> x2 = np.array([3,14,16])
+>>> x2 = np.array([3, 14, 16])
 >>> np.bitwise_and(x1, x2)
-[2, 4, 16]
+array([ 2,  4, 16])
 
 >>> a = np.array([True, True])
 >>> b = np.array([False, True])
@@ -184,6 +186,16 @@ def binary_repr(num, width=None):
 
 >>> x1 & x2
 array([ 2,  4, 16])
+
+The number 13 is represented by ``00001101``.  Likewise, 17 is represented by
+``00010001``. The bit-wise AND of 13 and 17 is therefore ``000000001``, or 1:
+
+>>> np.bitwise_and(np.array(14), 13)
+array(12)
+>>> np.binary_repr(12)
+'1100'
+>>> np.bitwise_and(np.array([14, 3]), 13)
+array([12,  1])
 """
 
 bitwise_and = DPNPBinaryFunc(
@@ -234,6 +246,8 @@ def binary_repr(num, width=None):
 :obj:`dpnp.logical_or` : Compute the truth value of ``x1`` OR ``x2`` element-wise.
 :obj:`dpnp.bitwise_and`: Compute the bit-wise AND of two arrays element-wise.
 :obj:`dpnp.bitwise_xor` : Compute the bit-wise XOR of two arrays element-wise.
+:obj:`dpnp.binary_repr` : Return the binary representation of the input number
+                          as a string.
 
 Examples
 --------
@@ -248,6 +262,15 @@ def binary_repr(num, width=None):
 
 >>> x1 | x2
 array([  6,   5, 255])
+
+The number 13 has the binary representation ``00001101``. Likewise, 16 is
+represented by ``00010000``. The bit-wise OR of 13 and 16 is then ``00011101``,
+or 29:
+
+>>> np.bitwise_or(np.array(13), 16)
+array(29)
+>>> np.binary_repr(29)
+'11101'
 """
 
 bitwise_or = DPNPBinaryFunc(
@@ -298,6 +321,8 @@ def binary_repr(num, width=None):
 :obj:`dpnp.logical_xor` : Compute the truth value of ``x1`` XOR `x2`, element-wise.
 :obj:`dpnp.bitwise_and`: Compute the bit-wise AND of two arrays element-wise.
 :obj:`dpnp.bitwise_or` : Compute the bit-wise OR of two arrays element-wise.
+:obj:`dpnp.binary_repr` : Return the binary representation of the input number
+                          as a string.
 
 Examples
 --------
@@ -317,6 +342,14 @@ def binary_repr(num, width=None):
 
 >>> a ^ b
 array([ True, False])
+
+The number 13 is represented by ``00001101``. Likewise, 17 is represented by
+``00010001``. The bit-wise XOR of 13 and 17 is therefore ``00011100``, or 28:
+
+>>> np.bitwise_xor(np.array(13), 17)
+array(28)
+>>> np.binary_repr(28)
+'11100'
 """
 
 bitwise_xor = DPNPBinaryFunc(
@@ -365,13 +398,21 @@ def binary_repr(num, width=None):
 :obj:`dpnp.bitwise_or` : Compute the bit-wise OR of two arrays element-wise.
 :obj:`dpnp.bitwise_xor` : Compute the bit-wise XOR of two arrays element-wise.
 :obj:`dpnp.logical_not` : Compute the truth value of NOT x element-wise.
+:obj:`dpnp.binary_repr` : Return the binary representation of the input number
+                          as a string.
 
 Examples
 --------
 >>> import dpnp as np
+
+The number 13 is represented by ``00001101``. The invert or bit-wise NOT of 13
+is then:
+
 >>> x = np.array([13])
 >>> np.invert(x)
--14
+array([-14])
+>>> np.binary_repr(-14, width=8)
+'11110010'
 
 >>> a = np.array([True, False])
 >>> np.invert(a)
@@ -382,6 +423,7 @@ def binary_repr(num, width=None):
 
 >>> ~a
 array([False,  True])
+
 """
 
 invert = DPNPUnaryFunc(
@@ -435,6 +477,8 @@ def binary_repr(num, width=None):
 See Also
 --------
 :obj:`dpnp.right_shift` : Shift the bits of an integer to the right.
+:obj:`dpnp.binary_repr` : Return the binary representation of the input number
+                          as a string.
 
 Examples
 --------
@@ -449,6 +493,13 @@ def binary_repr(num, width=None):
 
 >>> x1 << x2
 array([10, 20, 40])
+
+>>> np.binary_repr(5)
+'101'
+>>> np.left_shift(np.array(5), 2)
+array(20)
+>>> np.binary_repr(20)
+'10100'
 """
 
 left_shift = DPNPBinaryFunc(
@@ -501,6 +552,8 @@ def binary_repr(num, width=None):
 See Also
 --------
 :obj:`dpnp.left_shift` : Shift the bits of an integer to the left.
+:obj:`dpnp.binary_repr` : Return the binary representation of the input number
+                          as a string.
 
 Examples
 --------
@@ -515,6 +568,13 @@ def binary_repr(num, width=None):
 
 >>> x1 >> x2
 array([5, 2, 1])
+
+>>> np.binary_repr(10)
+'1010'
+>>> np.right_shift(np.array(10), 1)
+array(5)
+>>> np.binary_repr(5)
+'101'
 """
 
 right_shift = DPNPBinaryFunc(