o ?es @sdZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z edej!ej"ej#ej$ej%ej&ej'ej( Z)ej*ej+eddCdej,e)dej,e)dej,e)fddZ-ede.e-Z/e-j0j1Z2dej,e)dej,e)dej,e)fddZ3edej!ej"ej#ej$ej%ej&ej'ej( Z4ej*ej+eddCdej,e4dej,e4dej,e4fddZ5ede.e5Z6e5j0j1Z7dej,e4dej,e4dej,e4fdd Z8ed!ej!ej"ej#ej$ej%ej&ej'ej( Z9ej*ej+ed"dCdej,e9dej,e9dej,e9fd#d$Z:ed%e.e:Z;e:j0j1Zej*ej+ed)dCdej,e>dej,e>fd*d+Z?ed,e.e?Z@e?j0j1ZAdej,e>dej,e>fd-d.ZBed/ej!ej"ej#ej$ej%ej&ej'ej( ZCej*ej+ed0dCdej,eCdej,eCdej,eCfd1d2ZDed3e.eDZEeDj0j1ZFdej,eCdej,eCdej,eCfd4d5ZGed6ej!ej"ej#ej$ej%ej&ej'ej( ZHdCdej,eHdej,ej(fd7d8ZIed9e.eIZJdej,eHdej,ej(fd:d;ZKedd?ZMed@e.eMZNeMj0j1ZOdej,eLdej,eLdej,eLfdAdBZPdS)DzUPython wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. N) pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch) tf_export)TypeVarListTV_BitwiseAnd_Tzbitwise.bitwise_andxyreturnc Ctjpt}|j}|jr~z t|d|||}|WStjy2}z t ||WYd}~nd}~wtj y;Ynwzt |||fd}|t urL|WSt ||||dWStjy^Yqttfy}ttdt|||d}|tjjur||YSwt |||fd}|t ur|Sztjd|||d\}}}} Wn ttfyttdt|||d}|tjjur|YSw| dd}trd|df} |j} td| | ||\}|S)aElementwise 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`. For example: ```python 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 ``` Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. BitwiseAndNnamectxrrrT)_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException_dispatcher_for_bitwise_andNotImplementedbitwise_and_eager_fallback_SymbolicException TypeError ValueError _dispatchr bitwise_anddict OpDispatcher NOT_SUPPORTED_op_def_library_apply_op_helper_executemust_record_gradient_get_attr_typeinputsrecord_gradient rrr_ctxtld_resulte__op_outputs_attrs _inputs_flatrrf/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/ops/gen_bitwise_ops.pyr,v"      r,zraw_ops.BitwiseAndc Ct||g|tjtjtjtjtjtjtj tj g\}}|\}}||g}d|f}tj dd||||d}t r>t d||||\}|S)Nrs BitwiseAndr5attrsrrrr2Zargs_to_matching_eager_dtypesZint8Zint16Zint32Zint64Zuint8Zuint16Zuint32Zuint64rr3r6 rrrr_attr_TZ _inputs_Tr@r?r:rrrAr't6 r'TV_BitwiseOr_Tzbitwise.bitwise_orc Cr)aElementwise 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`. For example: ```python 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 ``` Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. BitwiseOrNrrrr)rrrrrrr r!r"r#r$_dispatcher_for_bitwise_orr&bitwise_or_eager_fallbackr(r)r*r+r bitwise_orr-r.r/r0r1r2r3r4r5r6r7rrrArPrBrPzraw_ops.BitwiseOrc CrC)Nrs BitwiseOrrDrErMrGrIrrrArOrKrOTV_BitwiseXor_Tzbitwise.bitwise_xorc Cr)aElementwise 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`. For example: ```python 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 ``` Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. BitwiseXorNrrrr)rrrrrrr r!r"r#r$_dispatcher_for_bitwise_xorr&bitwise_xor_eager_fallbackr(r)r*r+r bitwise_xorr-r.r/r0r1r2r3r4r5r6r7rrrArUrBrUzraw_ops.BitwiseXorc CrC)Nrs BitwiseXorrDrErRrGrIrrrArTHrKrT TV_Invert_Tzbitwise.invertc Cstjpt}|j}|jrzz t|d||}|WStjy1}z t ||WYd}~nd}~wtj y:Ynwzt ||fd}|t urJ|WSt |||dWStjy[Yqttfyyttdt||d}|tjjurx|YSwt ||fd}|t ur|Sztjd||d\}}}}Wnttfyttdt||d}|tjjur|YSw|dd}trd|df} |j} td| | ||\}|S)a: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: ```python 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)) ``` Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. InvertNrrrrr)rrrrrrr r!r"r#r$_dispatcher_for_invertr&invert_eager_fallbackr(r)r*r+r invertr-r.r/r0r1r2r3r4r5r6 rrr8r9r:r;r<r=r>r?r@rrrAr[Xsv5   r[zraw_ops.Invertc C|t|g|tjtjtjtjtjtjtj tj g\}\}|g}d|f}tj dd||||d}t r9t d||||\}|S)NrsInvertrDrErWrGrrrrJr@r?r:rrrArZs6 rZTV_LeftShift_Tzbitwise.left_shiftc Cr)akElementwise 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: ```python 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) # ``` Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. LeftShiftNrrrr)rrrrrrr r!r"r#r$_dispatcher_for_left_shiftr&left_shift_eager_fallbackr(r)r*r+r left_shiftr-r.r/r0r1r2r3r4r5r6r7rrrArcsv-      rczraw_ops.LeftShiftc CrC)Nrs LeftShiftrDrEr`rGrIrrrArb9rKrbTV_PopulationCount_Tc Cstjpt}|j}|jrNz t|d||}|WStjy1}z t ||WYd}~nd}~wtj y:Ynwzt |||dWStj yMYnwt jd||d\}}}}|dd}trvd|df} |j} td| | ||\}|S)axComputes element-wise population count (a.k.a. popcount, bitsum, bitcount). For each entry in `x`, calculates the number of `1` (on) bits in the binary representation of that entry. **NOTE**: It is more efficient to first `tf.bitcast` your tensors into `int32` or `int64` and perform the bitcount on the result, than to feed in 8- or 16-bit inputs and then aggregate the resulting counts. Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. name: A name for the operation (optional). Returns: A `Tensor` of type `uint8`. PopulationCountNrrXr)rrrrrrr r!r"r#r$population_count_eager_fallbackr(r0r1r2r3r4r5r6r\rrrApopulation_countIsB rgzraw_ops.PopulationCountc Cr])NrsPopulationCountrDrErerGr^rrrArfys6 rfTV_RightShift_Tzbitwise.right_shiftc Cr)aElementwise 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: ```python 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) # ``` Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. RightShiftNrrrr)rrrrrrr r!r"r#r$_dispatcher_for_right_shiftr&right_shift_eager_fallbackr(r)r*r+r right_shiftr-r.r/r0r1r2r3r4r5r6r7rrrArlsv0      rlzraw_ops.RightShiftc CrC)Nrs RightShiftrDrErirGrIrrrArkrKrk)N)Q__doc__ collectionsZtensorflow.pythonrZtensorflow.python.eagerrrrr rr2Ztensorflow.python.frameworkrrHZtensorflow.security.fuzzing.pyrZ_atypesrZ_op_def_registryr r"r r0Z"tensorflow.python.util.deprecationr Ztensorflow.python.utilr r+Z tensorflow.python.util.tf_exportr typingrrZInt16ZInt32ZInt64ZInt8ZUInt16ZUInt32ZUInt64ZUInt8rZadd_fallback_dispatch_listZadd_type_based_api_dispatcherZTensorFuzzingAnnotationr,Z to_raw_oprZ_tf_type_based_dispatcherZDispatchr%r'rLrPrMrNrOrQrUrRrSrTrVr[rWrYrZr_rcr`rarbrdrgrerfrhrlrirjrkrrrrAs            (0S((0S((0S((&f( 0^(("- ( 0a,