\;j&ddlZddlmZmZddlmZddlmZejjjjjZ ddlm Z ddlmZdd lmZdd lmZdd l mZmZmZgZd/d Zd0d Zed1dZd0dZed1dZd0dZed1dZd0dZed1dZ d1dZ!d1dZ"ed2dZ#ed1dZ$ed1dZ%ed1dZ&ed1dZ'ed1dZ(ed1dZ)ed1dZ*ed1dZ+ed1d Z,ed1d!Z-ed1d"Z.ed1d#Z/d$Z0d/d%Z1d0d&Z2ed1d'Z3d0d(Z4ed1d)Z5d0d*Z6ed1d+Z7d0d,Z8ed1d-Z9ed2d.Z:y)3N) check_typecheck_variable_and_dtype)Variable) templatedoc)_C_ops)full)broadcast_shape)inplace_apis_in_dygraph_only) LayerHelperin_dynamic_modein_dynamic_or_pir_modec "tr#tt|}|r |||S||St|dgd||t|dgd||t |dt |t |fit}|rB|j|jk7r)td|d|jd|jd||j|j }|r|j|||d d |i |S|j|d |id |i |S)Nx) boolint8int16int32int64float16float32float64uint16 complex64 complex128youtz"(InvalidArgument) The DataType of z0 Op's Variable must be consistent, but received z and .dtypeXYOuttypeinputsoutputsr#) rgetattrr rrrr localsr! ValueError"create_variable_for_type_inference append_opop_namerrrname binary_opophelpers \G:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\paddle/tensor/logic.py _logical_opr6#s[ VW % a8Oa5L   ! $ = $ ! $ ? sE8W 5W11 AGG+4WI=mnonunumvv{|}}D}D|EEFG  ;;;!'';JC    11%5s|     c1Xs|   cdtrtj||Std||||dS)au Compute element-wise logical AND on ``x`` and ``y``, and return ``out``. ``out`` is N-dim boolean ``Tensor``. Each element of ``out`` is calculated by .. math:: out = x \&\& y Note: ``paddle.logical_and`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float16, float32, float64, complex64, complex128. y (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float16, float32, float64, complex64, complex128. out(Tensor, optional): The ``Tensor`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor`` will be created to save the output. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([True]) >>> y = paddle.to_tensor([True, False, True, False]) >>> res = paddle.logical_and(x, y) >>> print(res) Tensor(shape=[4], dtype=bool, place=Place(cpu), stop_gradient=True, [True , False, True , False]) logical_andTr0rrr1rr2)rr r9r6rrrr1s r5r9r9i8J!!!Q'' adt r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``logical_and`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_and`. fThe shape of broadcast output {} is different from that of inplace tensor {} in the Inplace operation.N)r shaper,formatrr logical_and_rrr1 out_shapes r5rArAh  1IAGG t { {177   ""1a((r7cdtrtj||Std||||dS)a ``logical_or`` operator computes element-wise logical OR on ``x`` and ``y``, and returns ``out``. ``out`` is N-dim boolean ``Tensor``. Each element of ``out`` is calculated by .. math:: out = x || y Note: ``paddle.logical_or`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float16, float32, float64, complex64, complex128. y (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float16, float32, float64, complex64, complex128. out(Tensor): The ``Variable`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor`` will be created to save the output. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([True, False], dtype="bool").reshape([2, 1]) >>> y = paddle.to_tensor([True, False, True, False], dtype="bool").reshape([2, 2]) >>> res = paddle.logical_or(x, y) >>> print(res) Tensor(shape=[2, 2], dtype=bool, place=Place(cpu), stop_gradient=True, [[True , True ], [True , False]]) logical_orTr:)rr rFr6r;s r5rFrFs8J  A&& QTsd r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``logical_or`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_or`. r>N)r r?r,r@rr logical_or_rBs r5rHrHh  1IAGG t { {177   !!!Q''r7cdtrtj||Std||||dS)a ``logical_xor`` operator computes element-wise logical XOR on ``x`` and ``y``, and returns ``out``. ``out`` is N-dim boolean ``Tensor``. Each element of ``out`` is calculated by .. math:: out = (x || y) \&\& !(x \&\& y) Note: ``paddle.logical_xor`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x (Tensor): the input tensor, it's data type should be one of bool, int8, int16, int32, int64, float16, float32, float64, complex64, complex128. y (Tensor): the input tensor, it's data type should be one of bool, int8, int16, int32, int64, float16, float32, float64, complex64, complex128. out(Tensor): The ``Tensor`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor`` will be created to save the output. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([True, False], dtype="bool").reshape([2, 1]) >>> y = paddle.to_tensor([True, False, True, False], dtype="bool").reshape([2, 2]) >>> res = paddle.logical_xor(x, y) >>> print(res) Tensor(shape=[2, 2], dtype=bool, place=Place(cpu), stop_gradient=True, [[False, True ], [True , False]]) logical_xorTr:)rr rKr6r;s r5rKrKr<r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``logical_xor`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_xor`. r>N)r r?r,r@rr logical_xor_rBs r5rMrMrDr7cbtrtj|Std|d||dS)a ``logical_not`` operator computes element-wise logical NOT on ``x``, and returns ``out``. ``out`` is N-dim boolean ``Variable``. Each element of ``out`` is calculated by .. math:: out = !x Note: ``paddle.logical_not`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Args: x(Tensor): Operand of logical_not operator. Must be a Tensor of type bool, int8, int16, in32, in64, float16, float32, or float64, complex64, complex128. out(Tensor): The ``Tensor`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor` will be created to save the output. name(str|None): The default value is None. Normally there is no need for users to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([True, False, True, False]) >>> res = paddle.logical_not(x) >>> print(res) Tensor(shape=[4], dtype=bool, place=Place(cpu), stop_gradient=True, [False, True , False, True ]) logical_notNFr:)rr rOr6rrr1s r5rOrO"s6F!!!$$ d3% r7cBtrtj|Sy)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_rr1s r5rRrRL ""1%%r7c*trtj|St|dgddt |dt t dfdtd it}|jd}d|_ |jdd |gid |gi |S) a Test whether a Tensor is empty. Args: x (Tensor): The Tensor to be tested. name (str, 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)rrrris_emptyr1Nrr Tr#r%r&)rV) rr rVrrstrr'r r+r- stop_gradientr.)rr1r4conds r5rVrVVs0q!! s>> 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_allrr r"r%r&)r[)rr r[r r+r-r.rrr1r4rs r5r[r[srB1%%5FH577f7EA3'SEN   r7ctrtj|||||St|dgddt|dgddt |dt dt |dt dt |dt dtd it}|jd}||d }d |i} t|t||d } |jd|| | |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 (rtoltype, optional): The relative tolerance. Default: :math:`1e-5` . atol (atoltype, optional): The absolute tolerance. Default: :math:`1e-8` . equal_nan (equalnantype, optional): ${equal_nan_comment}. Default: False. name (str, 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)rrrallclosertolatol equal_nanrr InputOtherr%r`rarbr'r(r)attrs)r_) rr r_rrfloatrr r+r-rWr. rrr`rarbr1r4rr(r)rhs r5r_r_sdq!T4;; w9:  ! w9:  4 34 39k4<468477f7Eq)#,TCIINFG5   r7c:t|ttttt j jfstdt|t|tt j jfstg|j|}trtj||St|dgddt|dgddt!d it#}|j%d}d |_|j)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. y (Tensor): Tensor, data type is bool, float16, float32, float64, uint8, int8, int16, int32, int64. name (str, 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, 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]) zIType of input args must be float, bool, int or Tensor, but received type )r?r! fill_valuer rrrruint8rrrrrequalrrr Tr"r%r&)ro) isinstanceintrrirpaddlepirOpResult TypeErrorr'r r!rr rorr r+r-rXr.r\s r5roros> a#tUHfjj6I6IJ KWX\]^X_W` a   a(FJJ$7$78 9 rQ 7||Aq!!    " !    "1177f7E A3'SEN   r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_equal`. r>N)r r?r,r@rr equal_rBs r5rwrwPsf  1IAGG t { {177   }}Q"" r7ctrtj||St|dgddt|dgddt d it }|j d}d|_|jd|g|gdd |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, float16, float32, float64, uint8, int8, int16, int32, int64. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, uint8, int8, int16, int32, int64. name (str, 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: 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 ]) rrm greater_equalrrr Tr"r%r&)ry) rr ryrr r+r-rXr.r\s r5ryryas8##Aq))    " !    "9977f7E  A3'SEN   r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``greater_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_greater_equal`. r>N)r r?r,r@rr greater_equal_rBs r5r{r{sh  1IAGG t { {177   $$Q**r7ctrtj||St|dgddt|dgddt d it }|j d}d|_|jd|g|gdd |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, float16, float32, float64, uint8, int8, int16, int32, int64. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, uint8, int8, int16, int32, int64. name (str, 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: 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_than(x, y) >>> print(result1) Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True, [False, False, True ]) rrm greater_thanrrr Tr"r%r&)r}) rr r}rr r+r-rXr.r\s r5r}r}s8""1a((    " !    "8vx877f7E A3'SEN   r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``greater_than`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_greater_than`. r>N)r r?r,r@rr greater_than_rBs r5rr sh  1IAGG t { {177   ##Aq))r7ctrtj||St|dgddt|dgddt d it }|j d}d|_|jd|g|gdd |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, float16, float32, float64, uint8, int8, int16, int32, int64. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, uint8, int8, int16, int32, int64. name (str, 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: 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]) rrm less_equalrrr Tr"r%r&)r) rr rrr r+r-rXr.r\s r5rrs:  A&&    " !    "6VX677f7E A3'SEN   r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``less_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less_equal`. r>N)r r?r,r@rr less_equal_rBs r5rrkrIr7ctrtj||St|dgddt|dgddt d it }|j d}d|_|jd|g|gdd |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, float16, float32, float64, uint8, int8, int16, int32, int64. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, float16, float32, float64, uint8, int8, int16, int32, int64. name (str, 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: 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]) rrm less_thanrrr Tr"r%r&)r) rr rrr r+r-rXr.r\s r5rr|:1%%    " !    "5FH577f7E A3'SEN   r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``less_than`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less_than`. r>N)r r?r,r@rr less_than_rBs r5rrh  1IAGG t { {177     A&&r7ctrtj||St|dgddt|dgddt d it }|j d}d|_|jd|g|gdd |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, float32, float64, uint8, int8, int16, int32, int64. y (Tensor): Second input to compare which is N-D tensor. The input data type should be bool, float32, float64, uint8, int8, int16, int32, int64. name (str, 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: 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 ]) rrm not_equalrrr Tr"r%r&)r) rr rrr r+r-rXr.r\s r5rrrr7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``not_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_not_equal`. r>N)r r?r,r@rr not_equal_rBs r5rr)rr7ctrWt|ttjj j jtjjfSt|tS)a8 Tests whether input object is a paddle.Tensor. Args: x (object): Object to test. 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 ) rrpTensorrrbasecoreeagerrsValuer)rs r5 is_tensorr:sR6  ((..55vzz7G7GH  !X&&r7ctr#tt|}|r |||S||St|dgd||t|dgd||t |dt |t |fit}|r|j|jk(sJ||j|j}|r|j|||dd|i|S|j|d |id|i|S) Nr)rrnrrrrrrr r"r%r&r#) rr*r rrrr r+r!r-r.r/s r5 _bitwise_opr]s  VW % a8Oa5L  @   = $D   ? sE8W 5W11 77agg% %% ;;;!'';JC    11%5s|     c1Xs|   r7chtr|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, optional): Result of ``bitwise_and`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str, 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]) bitwise_andTr:)rr rrr;s r5rr<DCK!!!Q'' adt r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``bitwise_and`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_and`. r>N)r r?r,r@rr bitwise_and_rBs r5rrsh  1IAGG t { {177   ""1a(( r7chtr|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 Args: x (Tensor): Input Tensor of ``bitwise_or`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. y (Tensor): Input Tensor of ``bitwise_or`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64. out (Tensor, optional): Result of ``bitwise_or`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str, 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]) bitwise_orTr:)rr rrr;s r5rrs<DCK  A&& QTsd r7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``bitwise_or`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_or`. r>N)r r?r,r@rr bitwise_or_rBs r5rrrIr7chtr|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, optional): Result of ``bitwise_xor`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str, 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]) bitwise_xorTr:)rr rrr;s r5rrrr7ct|j|j}||jk7r%tdj||jt rt j ||Sy)z Inplace version of ``bitwise_xor`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_xor`. r>N)r r?r,r@rr bitwise_xor_rBs r5rr&rDr7cftr|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, optional): Result of ``bitwise_not`` . It is a N-D Tensor with the same data type of input Tensor. Default: None. name (str, 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:)rr rrrPs r5rr7s:@CK!!!$$ d3% r7cBtrtj|Sy)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_rSs r5rr_rTr7ctrtj|||||St|dgddt|dgddt |dt dt |dt dt |dt dtd it}|jd}||d }d |i} t|t||d } |jd|| | |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`. The behaviour of this operator is analogous to :math:`numpy.isclose`, 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, complex64, complex128. y(Tensor): The input tensor, it's data type should be float16, float32, float64, complex64, complex128. rtol(rtoltype, optional): The relative tolerance. Default: :math:`1e-5` . atol(atoltype, optional): The absolute tolerance. Default: :math:`1e-8` . equal_nan(equalnantype, optional): If :math:`True` , then two :math:`NaNs` will be compared as equal. Default: :math:`False` . name (str, 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.isclose(x, y, rtol=1e-05, atol=1e-08, ... equal_nan=False, name="ignore_nan") >>> print(result1) Tensor(shape=[2], dtype=bool, place=Place(cpu), stop_gradient=True, [True , False]) >>> result2 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, ... equal_nan=True, name="equal_nan") >>> print(result2) Tensor(shape=[2], dtype=bool, place=Place(cpu), stop_gradient=True, [True , False]) >>> x = paddle.to_tensor([1.0, float('nan')]) >>> y = paddle.to_tensor([1.0, float('nan')]) >>> result1 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, ... equal_nan=False, name="ignore_nan") >>> print(result1) Tensor(shape=[2], dtype=bool, place=Place(cpu), stop_gradient=True, [True , False]) >>> result2 = paddle.isclose(x, y, rtol=1e-05, atol=1e-08, ... equal_nan=True, name="equal_nan") >>> print(result2) Tensor(shape=[2], dtype=bool, place=Place(cpu), stop_gradient=True, [True, True]) r^)rrrrriscloser`rarbrr rcr%rfrg)r) rr rrrrirr r+r-rWr.rjs r5rrisp~~aD$ ::  H   !  H   4 24 29k4;3&(377f7Eq)#,TCIIN67%   r7)NNT)NN)N)gh㈵>g:0yE>FN);rrbase.data_feederrrcommon_ops_importrlayer_function_generatorrr frameworkrrrr paddle.tensor.creationr paddle.tensor.mathr paddle.utils.inplace_utilsr r rr__all__r6r9rArFrHrKrMrOrRrVr[r_rorwryr{r}rrrrrrrrrrrrrrrrrrr7r5rsy"C(1    # # ) ) 0 0'.CLL CL*Z ) ) )X ( ( *Z ) ) 'T&&&R+\ HHV SSl # #  IIX + +  IIX * *  JJZ ( (  JJZ ' '  JJZ ' ' 'F(V&R ) ) 'T ( ( &R ) ) %P&& SSr7