|jk"ddlmZddlmZmZddlmZddlZddlmZddl m Z m Z m Z m Z mZmZddlmZddlmZdd lmZmZmZdd lmZd d lmZmZd d lmZd dlm Z m!Z!m"Z"m#Z#erddlm$Z$gZ% dPdQdZ&edRdSdZ'edRdSdZ(edRdSd Z)edRdTd!Z*dRdTd"Z+dRdSd#Z, dUdVd+Z-edd,gdd-g dRdd.dWd/Z.edRdSd0Z/edd,gdd-g dRdd.dWd1Z0edd,gdd-g dRdd.dWd2Z1edRdSd3Z2edRdSd4Z3edd,gdd-g dRdd.dWd5Z4edRdSd6Z5edd,gdd-g dRdd.dWd7Z6edRdSd8Z7edRdSd9Z8edd,gdd-g dRdd.dWd:Z9edRdSd;Z:eddedRdSdDZ?edd,gdd-g dYdZdEZ@ dYd\dFZAeed,gd-gdGdRdSdHZB dYdZdIZC dYd\dJZDedRdSdKZE dYd]dLZFedRdTdMZG dYd]dNZHedRdTdOZIdS)^) annotations) TYPE_CHECKINGAny) TypeGuardN)_C_ops) greater_thanisclose logical_and logical_not logical_or logical_xor)full)broadcast_shape)ParamAliasDecoratorparam_one_aliasparam_two_alias)inplace_apis_in_dygraph_only) check_typecheck_variable_and_dtype)Variable) LayerHelperin_dynamic_modein_dynamic_or_pir_mode in_pir_mode)TensorTop_namestrxry Tensor | Noneoutname str | None binary_opboolreturnctr.tt|}|r |||S||St|dgd||t|dgd||t |dt |t |fit}|||j }|r| |||dd|in| |d |id|i|S) Nr) r&int8int16int32int64float16float32float64uint16 complex64 complex128r r"dtypeXYOuttypeinputsoutputsr6) rgetattrrrrrrlocals"create_variable_for_type_inferencer4 append_oprrr r"r#r%ophelpers c/lsinfo/ai/hellotax_ai/data_center/backend/venv/lib/python3.11/site-packages/paddle/tensor/logic.py _logical_oprE7sg= VW % %  2a88O2a55L     !   $ = $   !   $ ? sE8W 5 5 5W1111 ;;;!';JJC     11%5%5s|        c1Xs|     ct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``logical_and`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_and`. The shape of broadcast output * is different from that of inplace tensor  in the Inplace operation.N)rshape ValueErrorrr logical_and_rr r# out_shapes rDrMrM  11IAG FY F Fbcbi F F F   )"1a((())rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``logical_or`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_or`. rHrIrJN)rrKrLrr logical_or_rNs rDrRrR  11IAG FY F Fbcbi F F F   (!!Q'''((rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``logical_xor`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_xor`. rHrIrJN)rrKrLrr logical_xor_rNs rDrUrUrPrFcJtrtj|SdS)z Inplace version of ``logical_not`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_not`. N)rr logical_not_rr#s rDrWrW- &"1%%%&&rFctrtj|St|dgddt |dt t dfdtrtj|Std it}| d}d|_ | dd |gid |gi |S) a Test whether a Tensor is empty. Args: x (Tensor): The Tensor to be tested. name (str|None, optional): The default value is ``None`` . Normally users don't have to set this parameter. For more information, please refer to :ref:`api_guide_Name` . Returns: Tensor: A bool scalar Tensor. True if 'x' is an empty Tensor. Examples: .. code-block:: python >>> import paddle >>> input = paddle.rand(shape=[4, 32, 32], dtype='float32') >>> res = paddle.is_empty(x=input) >>> print(res) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, False) r)r.r/r+r,is_emptyr#Nr&r3Tr6r8r9)r[) rrr[rrrr:rrr>r? stop_gradientr@)rr#rCconds rDr[r[s0"q!!! 3888*tVc4::. ;;;}} q!!!446884488v8FF!S1#J     rFctrtj||Stdit }|d}|d|g|gdd|gi|S) a Returns the truth value of :math:`x == y`. True if two inputs have the same elements, False otherwise. Note: The output has no gradient. Args: x(Tensor): Tensor, data type is bool, float32, float64, int32, int64. y(Tensor): Tensor, data type is bool, float32, float64, int32, int64. name(str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: output Tensor, data type is bool, value is [False] or [True]. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 2, 3]) >>> z = paddle.to_tensor([1, 4, 3]) >>> result1 = paddle.equal_all(x, y) >>> print(result1) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, True) >>> result2 = paddle.equal_all(x, z) >>> print(result2) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, False) equal_allr&r3r5r8r9N)r_)rrr_rr>r?r@)rr r#rCr"s rDr_r_sB 1%%%55FHH5577f7EEA3''SEN     rFh㈵>:0yE>Frtolfloatatol equal_nanctrtj|||||Strt |dgddt |dgddt |t tjj fstdt|t |t tjj fstdt|t|dtdtj|||||St |dgddt |dgddt|dt dt|dt dt|dtdtdit}|d }||d }d |i} t#|t#||d } |d|| | |S)a Check if all :math:`x` and :math:`y` satisfy the condition: .. math:: \left| x - y \right| \leq atol + rtol \times \left| y \right| elementwise, for all elements of :math:`x` and :math:`y`. This is analogous to :math:`numpy.allclose`, namely that it returns :math:`True` if two tensors are elementwise equal within a tolerance. Args: x (Tensor): The input tensor, it's data type should be float16, float32, float64. y (Tensor): The input tensor, it's data type should be float16, float32, float64. rtol (float, optional): The relative tolerance. Default: :math:`1e-5` . atol (float, optional): The absolute tolerance. Default: :math:`1e-8` . equal_nan (bool, optional): ${equal_nan_comment}. Default: False. name (str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: Tensor: The output tensor, it's data type is bool. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([10000., 1e-07]) >>> y = paddle.to_tensor([10000.1, 1e-08]) >>> result1 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name="ignore_nan") >>> print(result1) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, False) >>> result2 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=True, name="equal_nan") >>> print(result2) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, False) >>> x = paddle.to_tensor([1.0, float('nan')]) >>> y = paddle.to_tensor([1.0, float('nan')]) >>> result1 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name="ignore_nan") >>> print(result1) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, False) >>> result2 = paddle.allclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=True, name="equal_nan") >>> print(result2) Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True, True) input)r&r+r,r-r.r/allclosez4Type of input rtol must be float, but received type z4Type of input atol must be float, but received type rerbrdr&r3)InputOtherr8)rbrdre)r:r;r<attrsN)rh)rrrhrr isinstancercpaddlepirValue TypeErrorr:rr&rr>r?rr@) rr rbrdrer#rCr"r;r<rks rDrhrhsDp4q!T4;;; 2  G G G     !  G G G     $ (8 9:: StDzzSS $ (8 9:: StDzzSS  9k4<<<q!T4;;;  G G G     !  G G G     4 3334 3339k4<<<446884477f7EEq))#,TCIIINNFG5     rFrgotherr"c t|ttttt t jjfstdt|t|tt jjt fstg|j |}t|t rt j |}trtj|||St#|dgddt#|dgddt%dit'}|d }d |_|d|g|gd d |gi |S)a This layer returns the truth value of :math:`x == y` elementwise. Note: The output has no gradient. Args: x (Tensor): Tensor, data type is bool, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. alias: ``input`` y (Tensor): Tensor, data type is bool, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. alias: ``other`` name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): Output tensor. If provided, the result will be stored in this tensor. Returns: Tensor: output Tensor, it's shape is the same as the input's Tensor, and the data type is bool. The result of this op is stop_gradient. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.equal(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [True , False, False]) zRType of input args must be float, bool, complex, int or Tensor, but received type )rKr4 fill_valuerrr r&r-r.r/uint8r)r*r+r,r0r1r2equalr r&r3Tr5r8r9N)rw)rlintr&rcrcomplexrmrnrorpr:rr4 to_tensorrrrwrrr>r?r\r@rr r#r"rCs rDrwrw~sH  Cuh1A B    jaefgahah j j    a(FJ$4g> ? ?8 rQ 7 7 7!W  Q  1|Aqc****     #   & !     #   &111177f7EE A3''SEN     rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_equal`. rHrIrJN)rrKrLrrequal_rNs rDr}r}s  11IAG FY F Fbcbi F F F   #}Q"""##rFcjtrtj|||Std)av Returns the truth value of :math:`x > y` elementwise, which is equivalent function to the overloaded operator `>`. Note: The output has no gradient. Args: x (Tensor): First input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``input``. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``other``. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If provided, the result will be stored in this tensor. Returns: Tensor: The output shape is same as input :attr:`x`. The output data type is bool. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.gt(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [False, False, True ]) rrz.paddle.gt does not support legacy static mode.)rrrNotImplementedError)rr r#r"s rDgtrs@D "1aS1111! <   rFcJtrtj|||St|dgddt|dgddt d it }|d}d|_|d|g|gd d |gi |S)a Returns the truth value of :math:`x >= y` elementwise, which is equivalent function to the overloaded operator `>=`. Note: The output has no gradient. Args: x (Tensor): First input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``input``. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``other``. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: Tensor: The output shape is same as input :attr:`x`. The output data type is bool. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.greater_equal(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [True , False, True ]) rrrru greater_equalr r&r3Tr5r8r9N)r) rrrrrr>r?r\r@r{s rDrrsB1#Aqc2222     #   & !     #   &999977f7EE  A3''SEN     rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``greater_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_greater_equal`. rHrIrJN)rrKrLrrgreater_equal_rNs rDrrts  11IAG FY F Fbcbi F F F   +$Q***++rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``greater_than`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_greater_than`. rHrIrJN)rrKrLrr greater_than_rNs rDrrs  11IAG FY F Fbcbi F F F   *#Aq)))**rFcJtrtj|||St|dgddt|dgddt d it }|d}d|_|d|g|gd d |gi |S)a Returns the truth value of :math:`x <= y` elementwise, which is equivalent function to the overloaded operator `<=`. Note: The output has no gradient. Args: x (Tensor): First input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``input``. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``other``. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: Tensor: The output shape is same as input :attr:`x`. The output data type is bool. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.less_equal(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [True , True , False]) rrrru less_equalr r&r3Tr5r8r9N)r) rrrrrr>r?r\r@r{s rDrrsD1 A3////     #   & !     #   &66VXX6677f7EE A3''SEN     rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``less_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less_equal`. rHrIrJN)rrKrLrr less_equal_rNs rDrrrSrFcJtrtj|||St|dgddt|dgddt d it }|d}d|_|d|g|gd d |gi |S)a Returns the truth value of :math:`x < y` elementwise, which is equivalent function to the overloaded operator `<`. Note: The output has no gradient. Args: x (Tensor): First input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``input`` y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``other`` name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: Tensor: The output shape is same as input :attr:`x`. The output data type is bool. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.less_than(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [False, True , False]) rrrru less_thanr r&r3Tr5r8r9N)r) rrrrrr>r?r\r@r{s rDrrD21#....     #   & !     #   &55FHH5577f7EE A3''SEN     rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``less_than`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less_than`. rHrIrJN)rrKrLrr less_than_rNs rDrrN  11IAG FY F Fbcbi F F F   ' A&&&''rFc$t|||S)z Inplace version of ``less_`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less`. )r)rr r#s rDless_r]s aD ! !!rFcJtrtj|||St|dgddt|dgddt d it }|d}d|_|d|g|gd d |gi |S)a Returns the truth value of :math:`x != y` elementwise, which is equivalent function to the overloaded operator `!=`. Note: The output has no gradient. Args: x (Tensor): First input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``input``. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, bfloat16, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Alias: ``other``. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: Tensor: The output shape is same as input :attr:`x`. The output data type is bool. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.not_equal(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [False, True , True ]) rrrru not_equalr r&r3Tr5r8r9N)r) rrrrrr>r?r\r@r{s rDrrhrrFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``not_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_not_equal`. rHrIrJN)rrKrLrr not_equal_rNs rDrrrrFobjrTypeGuard[Tensor]ctr+t|tjtjjfSt|t S)a  Tests whether input object is a paddle.Tensor. .. note:: Alias Support: The parameter name ``obj`` can be used as an alias for ``x``. For example, ``is_tensor(obj=tensor_x)`` is equivalent to ``is_tensor(x=tensor_x)``. Args: x (object): Object to test. alias: ``obj``. Returns: A boolean value. True if ``x`` is a paddle.Tensor, otherwise False. Examples: .. code-block:: python >>> import paddle >>> input1 = paddle.rand(shape=[2, 3, 5], dtype='float32') >>> check = paddle.is_tensor(input1) >>> print(check) True >>> input3 = [1, 4] >>> check = paddle.is_tensor(input3) >>> print(check) False )rrlrmrrnror)rs rD is_tensorrs?@'!fmVZ-=>???!X&&&rFctr.tt|}|r |||S||St|dgd||t|dgd||t |dt |t |fit}|r|j|jksJ|| |j}|r| |||dd|in| |d |id|i|S) Nr)r&rvr)r*r+r,r r"r3r5r8r9r6) rr=rrrrrr>r4r?r@rAs rD _bitwise_oprst' VW % %  2a88O2a55L  @ @ @     = $DDD     ? sE8W 5 5 5W1111  &7ag%%%% ;;;!';JJC     11%5%5s|        c1Xs|     rFcvtr|tj||Std||||dS)a Apply ``bitwise_and`` on Tensor ``X`` and ``Y`` . .. math:: Out = X \& Y Note: ``paddle.bitwise_and`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): Input Tensor of ``bitwise_and`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. y (Tensor): Input Tensor of ``bitwise_and`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. out (Tensor|None, optional): Result of ``bitwise_and`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Result of ``bitwise_and`` . It is a N-D Tensor with the same data type of input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-5, -1, 1]) >>> y = paddle.to_tensor([4, 2, -3]) >>> res = paddle.bitwise_and(x, y) >>> print(res) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 2, 1]) N bitwise_andTrrr r#r"r%)rrrrrr r"r#s rDrr&NH(CK!!Q''' adt   rF int | boolct|ttfr-tj||j}t ||ddStdt|j d)Nr3$unsupported operand type(s) for |: '' and 'Tensor') rlrxr&rmrzr4rrpr:__name__)rr y_tensors rD__rand__rQsl!c4[!! #AQW5558Qd333 S4773C S S S   rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``bitwise_and`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_and`. rHrIrJN)rrKrLrr bitwise_and_rNs rDrr[s  11IAG FY F Fbcbi F F F   )"1a((())rFcvtr|tj||Std||||dS)a Apply ``bitwise_or`` on Tensor ``X`` and ``Y`` . .. math:: Out = X | Y Note: ``paddle.bitwise_or`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``other`` can be used as an alias for ``y``. For example, ``bitwise_or(input=tensor_x, other=tensor_y, ...)`` is equivalent to ``bitwise_or(x=tensor_x, y=tensor_y, ...)``. Args: x (Tensor): Input Tensor of ``bitwise_or`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. alias: ``input``. y (Tensor): Input Tensor of ``bitwise_or`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. alias: ``oth``. out (Tensor|None, optional): Result of ``bitwise_or`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Result of ``bitwise_or`` . It is a N-D Tensor with the same data type of input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-5, -1, 1]) >>> y = paddle.to_tensor([4, 2, -3]) >>> res = paddle.bitwise_or(x, y) >>> print(res) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [-1, -1, -3]) N bitwise_orTr)rrrrrs rDrrjsNV'CK A&&& QTsd   rFct|ttfr.tj||j}t ||||Stdt|j dNr3r"r#rr) rlrxr&rmrzr4rrpr:rrs rD__ror__rsq !c4[!!  Qag . . .!QCd3333 S4773C S S S   rF)rr ct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``bitwise_or`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_or`. rHrIrJN)rrKrLrr bitwise_or_rNs rDrrs 11IAG FY F Fbcbi F F F   (!!Q'''((rFcvtr|tj||Std||||dS)a Apply ``bitwise_xor`` on Tensor ``X`` and ``Y`` . .. math:: Out = X ^\wedge Y Note: ``paddle.bitwise_xor`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. y (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. out (Tensor|None, optional): Result of ``bitwise_xor`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Result of ``bitwise_xor`` . It is a N-D Tensor with the same data type of input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-5, -1, 1]) >>> y = paddle.to_tensor([4, 2, -3]) >>> res = paddle.bitwise_xor(x, y) >>> print(res) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [-1, -3, -4]) N bitwise_xorTr)rrrrrs rDrrrrFct|ttfr.tj||j}t ||||Stdt|j dr) rlrxr&rmrzr4rrpr:rrs rD__rxor__rsq !c4[!!  Qag . . .1aSt4444 S4773C S S S   rFct|j|j}||jkrtd|d|jdtrt j||SdS)z Inplace version of ``bitwise_xor`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_xor`. rHrIrJN)rrKrLrr bitwise_xor_rNs rDrrrPrFcttr|tj|Std|d||dS)a Apply ``bitwise_not`` on Tensor ``X``. .. math:: Out = \sim X Note: ``paddle.bitwise_not`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): Input Tensor of ``bitwise_not`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. out (Tensor|None, optional): Result of ``bitwise_not`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str|None, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Result of ``bitwise_not`` . It is a N-D Tensor with the same data type of input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-5, -1, 1]) >>> res = paddle.bitwise_not(x) >>> print(res) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [ 4, 0, -2]) N bitwise_notFr)rrrrrr"r#s rDrrsLD%CK!!$$$ d3%   rFcJtrtj|SdS)z Inplace version of ``bitwise_not`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_not`. N)rr bitwise_not_rXs rDrr/rYrFc&t|||S)a~ Apply ``bitwise_not`` (bitwise inversion) on Tensor ``x``. This is an alias to the ``paddle.bitwise_not`` function. .. math:: Out = \sim X Note: ``paddle.bitwise_invert`` is functionally equivalent to ``paddle.bitwise_not``. Args: x (Tensor): Input Tensor of ``bitwise_invert``. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. out (Tensor|None, optional): Result of ``bitwise_invert``. It is a N-D Tensor with the same data type as the input Tensor. Default: None. name (str|None, optional): The default value is None. This property is typically not set by the user. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: Result of ``bitwise_invert``. It is a N-D Tensor with the same data type as the input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([-5, -1, 1]) >>> res = x.bitwise_invert() >>> print(res) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [ 4, 0, -2]) r)rrs rDbitwise_invertr9sF qc - - --rFc$t||S)z Inplace version of ``bitwise_invert`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_invert_`. )r#)rrXs rDbitwise_invert_r_s  % % %%rF)NNT)rrrrr r!r"r!r#r$r%r&r'r)N)rrr rr#r$r'r)rrr#r$r'r)r`raFN)rrr rrbrcrdrcrer&r#r$r'r) rrr rr#r$r"r!r'r)rrr'r)NN) rrr rr"r!r#r$r'r)rrr r) rrr rr"r!r#r$r'r)rrr"r!r#r$r'r)J __future__rtypingrrtyping_extensionsrrmr paddle._C_opsrr r r r r paddle.tensor.creationrpaddle.tensor.mathrpaddle.utils.decorator_utilsrrrpaddle.utils.inplace_utilsrbase.data_feederrrcommon_ops_importr frameworkrrrrr__all__rErMrRrUrWr[r_rhrwr}rrrrrrrrrrrrrrrrrrrrrrrrrrrFrDrs #"""""%%%%%%%%'''''' ('''''...... DCCCCCCCCCCCCC((((((  EEEEEP ) ) ) ) ) ( ( ( ( ( ) ) ) ) )&&&&&(((((V+++++b lllll^#w#w00-1aKOaaaaa10aH # # # # #"#w#w00-1& KO& & & & & 10& R#w#w00-1QKOQQQQQ10Qh + + + + + * * * * *#w#w00-1RKORRRRR10Rj ( ( ( ( (#w#w00-1SKOSSSSS10Sl ' ' ' ' '"""""#w#w00-1SKOSSSSS10Sl ' ' ' ' '#u"'"'"'"'R /////fIM(((((V     ) ) ) ) )#w#w00HL////10/j      G9G95566 ( ( ( (76 (IM(((((\       ) ) ) ) )>B'''''T&&&&&>B#.#.#.#.#.L&&&&&&&rF