LostTech.TensorFlow : API Documentation

Type tf.bitwise

Namespace tensorflow

Public static methods

Tensor bitwise_and(IGraphNodeBase x, IGraphNodeBase y, string name)

Elementwise computes the bitwise AND of `x` and `y`.

The result will have those bits set, that are set in both `x` and `y`. The computation is performed on the underlying representations of `x` and `y`.
Parameters
IGraphNodeBase x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
IGraphNodeBase y
A `Tensor`. Must have the same type as `x`.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                          tf.uint8, tf.uint16, tf.uint32, tf.uint64] 

for dtype in dtype_list: lhs = tf.constant([0, 5, 3, 14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype) exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)

res = bitwise_ops.bitwise_and(lhs, rhs) tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

object bitwise_and_dyn(object x, object y, object name)

Elementwise computes the bitwise AND of `x` and `y`.

The result will have those bits set, that are set in both `x` and `y`. The computation is performed on the underlying representations of `x` and `y`.
Parameters
object x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
object y
A `Tensor`. Must have the same type as `x`.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                          tf.uint8, tf.uint16, tf.uint32, tf.uint64] 

for dtype in dtype_list: lhs = tf.constant([0, 5, 3, 14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype) exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)

res = bitwise_ops.bitwise_and(lhs, rhs) tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

Tensor bitwise_or(IGraphNodeBase x, IGraphNodeBase y, string name)

Elementwise computes the bitwise OR of `x` and `y`.

The result will have those bits set, that are set in `x`, `y` or both. The computation is performed on the underlying representations of `x` and `y`.
Parameters
IGraphNodeBase x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
IGraphNodeBase y
A `Tensor`. Must have the same type as `x`.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                          tf.uint8, tf.uint16, tf.uint32, tf.uint64] 

for dtype in dtype_list: lhs = tf.constant([0, 5, 3, 14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype) exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)

res = bitwise_ops.bitwise_or(lhs, rhs) tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

object bitwise_or_dyn(object x, object y, object name)

Elementwise computes the bitwise OR of `x` and `y`.

The result will have those bits set, that are set in `x`, `y` or both. The computation is performed on the underlying representations of `x` and `y`.
Parameters
object x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
object y
A `Tensor`. Must have the same type as `x`.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                          tf.uint8, tf.uint16, tf.uint32, tf.uint64] 

for dtype in dtype_list: lhs = tf.constant([0, 5, 3, 14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype) exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)

res = bitwise_ops.bitwise_or(lhs, rhs) tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

Tensor bitwise_xor(IGraphNodeBase x, IGraphNodeBase y, string name)

Elementwise computes the bitwise XOR of `x` and `y`.

The result will have those bits set, that are different in `x` and `y`. The computation is performed on the underlying representations of `x` and `y`.
Parameters
IGraphNodeBase x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
IGraphNodeBase y
A `Tensor`. Must have the same type as `x`.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                          tf.uint8, tf.uint16, tf.uint32, tf.uint64] 

for dtype in dtype_list: lhs = tf.constant([0, 5, 3, 14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype) exp = tf.constant([5, 5, 4, 5], dtype=tf.float32)

res = bitwise_ops.bitwise_xor(lhs, rhs) tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

object bitwise_xor_dyn(object x, object y, object name)

Elementwise computes the bitwise XOR of `x` and `y`.

The result will have those bits set, that are different in `x` and `y`. The computation is performed on the underlying representations of `x` and `y`.
Parameters
object x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
object y
A `Tensor`. Must have the same type as `x`.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
                          tf.uint8, tf.uint16, tf.uint32, tf.uint64] 

for dtype in dtype_list: lhs = tf.constant([0, 5, 3, 14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype) exp = tf.constant([5, 5, 4, 5], dtype=tf.float32)

res = bitwise_ops.bitwise_xor(lhs, rhs) tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE

Tensor invert(IGraphNodeBase x, string name)

Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.

Flip each bit of supported types. For example, type `int8` (decimal 2) binary 00000010 becomes (decimal -3) binary 11111101. This operation is performed on each element of the tensor argument `x`.

Example:
Parameters
IGraphNodeBase x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops 

# flip 2 (00000010) to -3 (11111101) tf.assert_equal(-3, bitwise_ops.invert(2))

dtype_list = [dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64, dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64]

inputs = [0, 5, 3, 14] for dtype in dtype_list: # Because of issues with negative numbers, let's test this indirectly. # 1. invert(a) and a = 0 # 2. invert(a) or a = invert(0) input_tensor = tf.constant([0, 5, 3, 14], dtype=dtype) not_a_and_a, not_a_or_a, not_0 = [bitwise_ops.bitwise_and( input_tensor, bitwise_ops.invert(input_tensor)), bitwise_ops.bitwise_or( input_tensor, bitwise_ops.invert(input_tensor)), bitwise_ops.invert( tf.constant(0, dtype=dtype))]

expected = tf.constant([0, 0, 0, 0], dtype=tf.float32) tf.assert_equal(tf.cast(not_a_and_a, tf.float32), expected)

expected = tf.cast([not_0] * 4, tf.float32) tf.assert_equal(tf.cast(not_a_or_a, tf.float32), expected)

# For unsigned dtypes let's also check the result directly. if dtype.is_unsigned: inverted = bitwise_ops.invert(input_tensor) expected = tf.constant([dtype.max - x for x in inputs], dtype=tf.float32) tf.assert_equal(tf.cast(inverted, tf.float32), tf.cast(expected, tf.float32))

object invert_dyn(object x, object name)

Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes 10101010.

Flip each bit of supported types. For example, type `int8` (decimal 2) binary 00000010 becomes (decimal -3) binary 11111101. This operation is performed on each element of the tensor argument `x`.

Example:
Parameters
object x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops 

# flip 2 (00000010) to -3 (11111101) tf.assert_equal(-3, bitwise_ops.invert(2))

dtype_list = [dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64, dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64]

inputs = [0, 5, 3, 14] for dtype in dtype_list: # Because of issues with negative numbers, let's test this indirectly. # 1. invert(a) and a = 0 # 2. invert(a) or a = invert(0) input_tensor = tf.constant([0, 5, 3, 14], dtype=dtype) not_a_and_a, not_a_or_a, not_0 = [bitwise_ops.bitwise_and( input_tensor, bitwise_ops.invert(input_tensor)), bitwise_ops.bitwise_or( input_tensor, bitwise_ops.invert(input_tensor)), bitwise_ops.invert( tf.constant(0, dtype=dtype))]

expected = tf.constant([0, 0, 0, 0], dtype=tf.float32) tf.assert_equal(tf.cast(not_a_and_a, tf.float32), expected)

expected = tf.cast([not_0] * 4, tf.float32) tf.assert_equal(tf.cast(not_a_or_a, tf.float32), expected)

# For unsigned dtypes let's also check the result directly. if dtype.is_unsigned: inverted = bitwise_ops.invert(input_tensor) expected = tf.constant([dtype.max - x for x in inputs], dtype=tf.float32) tf.assert_equal(tf.cast(inverted, tf.float32), tf.cast(expected, tf.float32))

Tensor left_shift(IGraphNodeBase x, IGraphNodeBase y, string name)

Elementwise computes the bitwise left-shift of `x` and `y`.

If `y` is negative, or greater than or equal to the width of `x` in bits the result is implementation defined.

Example:
Parameters
IGraphNodeBase x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
IGraphNodeBase y
A `Tensor`. Must have the same type as `x`.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            import numpy as np
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64] 

for dtype in dtype_list: lhs = tf.constant([-1, -5, -3, -14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype)

left_shift_result = bitwise_ops.left_shift(lhs, rhs)

print(left_shift_result)

# This will print: # tf.Tensor([ -32 -5 -128 0], shape=(4,), dtype=int8) # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int16) # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int32) # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int64)

lhs = np.array([-2, 64, 101, 32], dtype=np.int8) rhs = np.array([-1, -5, -3, -14], dtype=np.int8) bitwise_ops.left_shift(lhs, rhs) #

object left_shift_dyn(object x, object y, object name)

Elementwise computes the bitwise left-shift of `x` and `y`.

If `y` is negative, or greater than or equal to the width of `x` in bits the result is implementation defined.

Example:
Parameters
object x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
object y
A `Tensor`. Must have the same type as `x`.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            import numpy as np
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64] 

for dtype in dtype_list: lhs = tf.constant([-1, -5, -3, -14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype)

left_shift_result = bitwise_ops.left_shift(lhs, rhs)

print(left_shift_result)

# This will print: # tf.Tensor([ -32 -5 -128 0], shape=(4,), dtype=int8) # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int16) # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int32) # tf.Tensor([ -32 -5 -384 -28672], shape=(4,), dtype=int64)

lhs = np.array([-2, 64, 101, 32], dtype=np.int8) rhs = np.array([-1, -5, -3, -14], dtype=np.int8) bitwise_ops.left_shift(lhs, rhs) #

Tensor right_shift(IGraphNodeBase x, IGraphNodeBase y, string name)

Elementwise computes the bitwise right-shift of `x` and `y`.

Performs a logical shift for unsigned integer types, and an arithmetic shift for signed integer types.

If `y` is negative, or greater than or equal to than the width of `x` in bits the result is implementation defined.

Example:
Parameters
IGraphNodeBase x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
IGraphNodeBase y
A `Tensor`. Must have the same type as `x`.
string name
A name for the operation (optional).
Returns
Tensor
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            import numpy as np
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64] 

for dtype in dtype_list: lhs = tf.constant([-1, -5, -3, -14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype)

right_shift_result = bitwise_ops.right_shift(lhs, rhs)

print(right_shift_result)

# This will print: # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int8) # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int16) # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int32) # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int64)

lhs = np.array([-2, 64, 101, 32], dtype=np.int8) rhs = np.array([-1, -5, -3, -14], dtype=np.int8) bitwise_ops.right_shift(lhs, rhs) #

object right_shift_dyn(object x, object y, object name)

Elementwise computes the bitwise right-shift of `x` and `y`.

Performs a logical shift for unsigned integer types, and an arithmetic shift for signed integer types.

If `y` is negative, or greater than or equal to than the width of `x` in bits the result is implementation defined.

Example:
Parameters
object x
A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`.
object y
A `Tensor`. Must have the same type as `x`.
object name
A name for the operation (optional).
Returns
object
A `Tensor`. Has the same type as `x`.
Show Example
import tensorflow as tf
            from tensorflow.python.ops import bitwise_ops
            import numpy as np
            dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64] 

for dtype in dtype_list: lhs = tf.constant([-1, -5, -3, -14], dtype=dtype) rhs = tf.constant([5, 0, 7, 11], dtype=dtype)

right_shift_result = bitwise_ops.right_shift(lhs, rhs)

print(right_shift_result)

# This will print: # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int8) # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int16) # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int32) # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int64)

lhs = np.array([-2, 64, 101, 32], dtype=np.int8) rhs = np.array([-1, -5, -3, -14], dtype=np.int8) bitwise_ops.right_shift(lhs, rhs) #

Public properties

PythonFunctionContainer bitwise_and_fn get;

PythonFunctionContainer bitwise_or_fn get;

PythonFunctionContainer bitwise_xor_fn get;

PythonFunctionContainer invert_fn get;

PythonFunctionContainer left_shift_fn get;

PythonFunctionContainer right_shift_fn get;