o #j@sNddlZddlmZmZddlmZddlmZejj j j j Z ddlm Z ddlmZdd lmZdd lmZdd l mZmZmZgZdVd dZdWddZedXddZdWddZedXddZdWddZedXddZdWddZedXddZ dXdd Z!dXd!d"Z"edYd&d'Z#edXd(d)Z$edXd*d+Z%edXd,d-Z&edXd.d/Z'edXd0d1Z(edXd2d3Z)edXd4d5Z*edXd6d7Z+edXd8d9Z,edXd:d;Z-edXdd?Z/d@dAZ0dVdBdCZ1dWdDdEZ2edXdFdGZ3dWdHdIZ4edXdJdKZ5dWdLdMZ6edXdNdOZ7dWdPdQZ8edXdRdSZ9edYdTdUZ:dS)ZN) check_typecheck_variable_and_dtype)Variable) templatedoc)_C_ops)full)broadcast_shape)inplace_apis_in_dygraph_only) LayerHelperin_dynamic_modein_dynamic_or_pir_modeTcCstrtt|}|r|||S||St|dgd||dur)t|dgd||dur4t|dt|t|fit}|rU|j|jkrUt d|d|jd|jd|dur`|j |jd }|rq|j |||d d |id |S|j |d |id |id |S)Nx) boolint8int16int32int64float16float32float64uint16 complex64 complex128youtz"(InvalidArgument) The DataType of z0 Op's Variable must be consistent, but received z and .dtypeXYOuttypeinputsoutputsr!) r getattrrrrrr localsr ValueError"create_variable_for_type_inference append_opop_namerrrname binary_opophelperr3T/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/tensor/logic.py _logical_op#sH    r5cC&tr t||Std||||ddS)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_andTr.rrr/rr0)rrr7r5rrrr/r3r3r4r7i %  r7cC@t|j|j}||jkrtd||jtrt||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`. fThe shape of broadcast output {} is different from that of inplace tensor {} in the Inplace operation.N)r shaper*formatr r logical_and_rrr/Z out_shaper3r3r4r?  r?cCr6)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_orTr8)rrrBr5r9r3r3r4rBs %  rBcCr;)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>r r logical_or_r@r3r3r4rCrArCcCr6)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_xorTr8)rrrDr5r9r3r3r4rDr:rDcCr;)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>r r logical_xor_r@r3r3r4rErArEcCs$trt|Std|d||ddS)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_notNFr8)rrrFr5rrr/r3r3r4rF"s #  rFcCtrt|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)r r logical_not_rr/r3r3r4rIL rIcCsztrt|St|dgddt|dttdfdtd it}|j dd}d|_ |j dd |gid |gid |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_emptyr/NrrTr!r#r$)rL) rrrLrrstrr%r r)r+ stop_gradientr,)rr/r2Zcondr3r3r4rLVs   rLcCsRtr t||Stdit}|jdd}|jd|g|gdd|gid|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, 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_allrrr r#r$N)rO)rrrOr r)r+r,rrr/r2rr3r3r4rOs!   rOh㈵>:0yE>Fc Ctr t|||||St|dgddt|dgddt|dtdt|dtdt|dtdtdit}|j dd}||d }d |i} t |t ||d } |j 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 (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_nanrrZInputOtherr#rVrWrXr%r&r'attrsN)rU) rrrUrrfloatrr r)r+rMr, rrrVrWrXr/r2rr&r'r]r3r3r4rUs(2    rUcCst|tttttjjfstdt |t|ttjjfs&t g|j |d}t r/t ||St|dgddt|dgddtdit}|jdd}d |_|jd|g|gd d |gid |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=rZ fill_valuer rrrruint8rrrrrequalrrrTr r#r$N)rb) isinstanceintrr^rpaddlepirZOpResult TypeErrorr%r rrrrbrr r)r+rNr,rPr3r3r4rbs:      rbcCr;)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>rrequal_r@r3r3r4rhPrArhcC|tr t||St|dgddt|dgddtd it}|jdd}d|_|jd|g|gdd |gid |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 ]) rr` greater_equalrrrTr r#r$N)rj) rrrjrr r)r+rNr,rPr3r3r4rja.     rjcCr;)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>r rgreater_equal_r@r3r3r4rlrArlcCri) 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 ]) rr` greater_thanrrrTr r#r$N)rm) rrrmrr r)r+rNr,rPr3r3r4rmrkrmcCr;)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>r r greater_than_r@r3r3r4rn rArncCri) 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]) rr` less_equalrrrTr r#r$N)ro) rrrorr r)r+rNr,rPr3r3r4ro.     rocCr;)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>r r less_equal_r@r3r3r4rqkrArqcCri) 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]) rr` less_thanrrrTr r#r$N)rr) rrrrrr r)r+rNr,rPr3r3r4rr|rprrcCr;)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>r r less_than_r@r3r3r4rsrArscCri) 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 ]) rr` not_equalrrrTr r#r$N)rt) rrrtrr r)r+rNr,rPr3r3r4rtrprtcCr;)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>r r not_equal_r@r3r3r4ru)rArucCs,trt|ttjjjjtjjfSt|t S)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 ) rrcTensorrebasecoreeagerrfValuer)rr3r3r4 is_tensor:s  r{cCstrtt|}|r|||S||St|dgd||dur)t|dgd||dur4t|dt|t|fit}|rG|j|jksGJ|durR|j |jd}|rc|j |||dd|id|S|j |d |id|id|S) Nr)rrarrrrrrrr r#r$r!) r r(rrrrr r)rr+r,r-r3r3r4 _bitwise_op]sD  r|cC.tr |dur t||Std||||ddS)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]) N bitwise_andTr8)rrr~r|r9r3r3r4r~ "  r~cCr;)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_r@r3r3r4rrArcCr})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]) N bitwise_orTr8)rrrr|r9r3r3r4rs "  rcCr;)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>r r bitwise_or_r@r3r3r4rrArcCr})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]) N bitwise_xorTr8)rrrr|r9r3r3r4rrrcCr;)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>r r bitwise_xor_r@r3r3r4r&rArcCs,tr |dur t|Std|d||ddS)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_notFr8)rrrr|rGr3r3r4r7s   rcCrH)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)r r bitwise_not_rJr3r3r4r_rKrc CrS)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]) rT)rrrrriscloserVrWrXrrrYr#r[r\N)r) rrrrrr^rr r)r+rMr,r_r3r3r4ris48  r)NNT)NN)N)rQrRFN);reZbase.data_feederrrZcommon_ops_importrZlayer_function_generatorrrwZ frameworkrxryrvrZpaddle.tensor.creationr Zpaddle.tensor.mathr Zpaddle.utils.inplace_utilsr r r r__all__r5r7r?rBrCrDrErFrIrLrOrUrbrhrjrlrmrnrorqrrrsrtrur{r|r~rrrrrrrrr3r3r3r4s        F-  ,  -  *  ). K V  L  L  M  M  M  # +)  *  )  (