ёik&SSKJr SSKJrJr SSKJr SSKrSSKJr SSK J r J r J r J r JrJr SSKJr SSKJr SS KJrJrJr SS KJr S S KJrJr S S KJr S SKJ r J!r!J"r"J#r# \(aSSKJ$r$ /r%S;SSjj5r'\S=S>Sjj5r(\S=S>Sjj5r)\S=S?Sjj5r*S=S?Sjjr+S=S>Sjjr,S@SASjjr-\"SS/SS/5S=SS.SBSjjj5r.\S=S>Sjj5r/\"SS/SS/5S=SS.SBSjjj5r0\"SS/SS/5S=SS.SBS jjj5r1\S=S>S!jj5r2\S=S>S"jj5r3\"SS/SS/5S=SS.SBS#jjj5r4\S=S>S$jj5r5\"SS/SS/5S=SS.SBS%jjj5r6\S=S>S&jj5r7\S=S>S'jj5r8\"SS/SS/5S=SS.SBS(jjj5r9\S=S>S)jj5r:\"SS*/5SCS+j5r;S;S\S=S>S/jj5r?\"SS/SS/5SDSES0jj5r@SDSGS1jjrA\\"S/S/S2.5S=S>S3jj55rBSDSES4jjrCSDSGS5jjrD\S=S>S6jj5rESDSHS7jjrF\S=S?S8jj5rGSDSHS9jjrH\S=S?S:jj5rIg)I) 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)Tensorxyc[5(a'[[U5nU(aU"X5$U"U5$[US/SQU5 Ub[US/SQU5 Ub[ US[ U5 [ U40[5D6nUcURURS9nU(aURXUS.SU0S9 U$URUS U0SU0S9 U$) Nr) boolint8int16int32int64float16float32float64uint16 complex64 complex128routdtypeXYOuttypeinputsoutputsr/) rgetattrrrrrrlocals"create_variable_for_type_inferencer- append_opop_namerrr+name binary_opophelpers S/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/tensor/logic.py _logical_oprA7s VW % a8Oa5L   ! $ = $ ! $ ? sE8W 5W11 ;;;!'';JC    1%5s|     c1Xs|   c[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)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_rrr< out_shapes r@rIrIs  1IGG,YK7abcbibiajkE F  ""1((rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``logical_or`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_or`. rDrErFN)rrGrHrr logical_or_rJs r@rNrNs  1IGG,YK7abcbibiajkE F  !!!''rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``logical_xor`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_logical_xor`. rDrErFN)rrGrHrr logical_xor_rJs r@rQrQrLrBcN[5(a[R"U5$g)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 r@rSrS# ""1%%rBct[5(a[R"U5$[US/SQS5 [ US[ [ S54S5 [5(a[R"U5$[S 0[5D6nURSS9nSUl URSS U/0S U/0S 9 U$) ao 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 r,Tr/r1r2)rW) rrrWrrstrr3rrr7r8 stop_gradientr9)rr<r?conds r@rWrWs0q!! 38*tVc4:. ;}}q!!468488v8F!S1#J   rBc[5(a[R"X5$[S0[ 5D6nUR SS9nUR SU/U/S.SU/0S9 U$)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 r,r.r1r2)r\)rrr\rr7r8r9)rrr<r?r+s r@r\r\ssB%%5FH577f7EA3'SEN   rBcp[5(a[R"XX#U5$[5(a[ US/SQS5 [ US/SQS5 [ U[ [RR45(d[S[U535e[ U[ [RR45(d[S[U535e[US[S5 [R"XX#U5$[ US/SQS5 [ US/SQS5 [US[ S5 [US[ S5 [US[S5 [S0[5D6nUR!S S 9nXS .nS U0n [#U5[#U5US .n UR%SXU S9 U$)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 equal_nanrtolatolr r,)InputOtherr1)rarbr`)r3r4r5attrs)r_)rrr_rr isinstancefloatpaddlepirValue TypeErrorr3rr rr7r8rXr9) rrrarbr`r<r?r+r4r5res r@r_r_spqT;;   G   !  G   $ (8(8 9::FtDzlS $ (8(8 9::FtDzlS  9k4<qT;;  G   !  G   4 34 39k4<468477f7E)#,TCIINF5   rBr^otherr+c [U[[[[[ [ RR45(d[S[U535e[U[[ RR[ 45(d[/URUS9n[U[ 5(a[ R"U5n[5(a[R "XUS9$[#US/SQS5 [#US/SQS5 [%S0['5D6nUR)SS 9nS UlUR-SU/U/S .S U/0S 9 U$)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 )rGr- fill_valuermr r r%r&r'uint8r!r"r#r$r(r)r*equalrr r,Tr.r1r2)rr)rfintr rgrcomplexrhrirjrkr3rr- to_tensorrrrrrrr7r8rYr9rrr<r+r?s r@rrrr~sHH  Cuh1A1A B  `aefgah`i j   a(FJJ$4$4g> ? ? rQ 7!W   Q ||Ac**   # & !   # &1177f7E A3'SEN   rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_equal`. rDrErFN)rrGrHrrequal_rJs r@rxrxsq  1IGG,YK7abcbibiajkE F  }}Q"" rBc`[5(a[R"XUS9$[S5e)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 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 ]) rmz.paddle.gt does not support legacy static mode.)rrrNotImplementedError)rrr<r+s r@gtr{s1D""1S11! <  rBc[5(a[R"XUS9$[US/SQS5 [US/SQS5 [ S 0[ 5D6nUR SS9nSUlURSU/U/S .S U/0S 9 U$) a2 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 ]) rmrrp greater_equalrr r,Tr.r1r2)r}) rrr}rrr7r8rYr9rvs r@r}r}sB##Ac22   # & !   # &9977f7E  A3'SEN   rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``greater_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_greater_equal`. rDrErFN)rrGrHrrgreater_equal_rJs r@rrtss  1IGG,YK7abcbibiajkE F  $$Q**rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``greater_than`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_greater_than`. rDrErFN)rrGrHrr greater_than_rJs r@rrss  1IGG,YK7abcbibiajkE F  ##A))rBc[5(a[R"XUS9$[US/SQS5 [US/SQS5 [ S 0[ 5D6nUR SS9nSUlURSU/U/S .S U/0S 9 U$) a0 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]) rmrrp less_equalrr r,Tr.r1r2)r) rrrrrr7r8rYr9rvs r@rrsD  3//   # & !   # &6VX677f7E A3'SEN   rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``less_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less_equal`. rDrErFN)rrGrHrr less_equal_rJs r@rrrOrBc[5(a[R"XUS9$[US/SQS5 [US/SQS5 [ S 0[ 5D6nUR SS9nSUlURSU/U/S .S U/0S 9 U$) 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]) rmrrp less_thanrr r,Tr.r1r2)r) rrrrrr7r8rYr9rvs r@rrD#..   # & !   # &5FH577f7E A3'SEN   rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``less_than`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less_than`. rDrErFN)rrGrHrr less_than_rJs r@rrNs  1IGG,YK7abcbibiajkE F    &&rBc[XU5$)z Inplace version of ``less_`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_less`. )r)rrr<s r@less_r]s aD !!rBc[5(a[R"XUS9$[US/SQS5 [US/SQS5 [ S 0[ 5D6nUR SS9nSUlURSU/U/S .S U/0S 9 U$) 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 ]) rmrrp not_equalrr r,Tr.r1r2)r) rrrrrr7r8rYr9rvs r@rrhrrBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``not_equal`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_not_equal`. rDrErFN)rrGrHrr not_equal_rJs r@rrrrBobjc[5(a4[U[R[RR 45$[U[ 5$)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 )rrfrhrrirjr)rs r@ is_tensorrs;@!fmmVZZ-=-=>??!X&&rBc[5(a'[[U5nU(aU"X5$U"U5$[US/SQU5 Ub[US/SQU5 Ub[ US[ U5 [ U40[5D6nU(aURUR:XdeUcURURS9nU(aURXUS.SU0S9 U$URUS U0SU0S9 U$) Nr)r rqr!r"r#r$rr+r,r.r1r2r/) rr6rrrrrr7r-r8r9r:s r@ _bitwise_oprs VW % a8Oa5L  @   = $D   ? sE8W 5W11 77agg% %% ;;;!'';JC    1%5s|     c1Xs|   rBc j[5(aUc[R"X5$[SXX2SS9$)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]) bitwise_andTr;rrr<r+r=)rrrrrrr+r<s r@rr&9HCK!!!'' dt rBc[U[[45(a+[R"XR S9n[ X SS5$[S[U5RS35e)Nr,$unsupported operand type(s) for |: '' and 'Tensor') rfrsr rhrur-rrkr3__name__)rry_tensors r@__rand__rQsZ!c4[!!##AWW58d332473C3C2DN S  rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``bitwise_and`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_and`. rDrErFN)rrGrHrr bitwise_and_rJs r@rr[ss  1IGG,YK7abcbibiajkE F  ""1(( rBc j[5(aUc[R"X5$[SXX2SS9$)aj 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]) bitwise_orTr)rrrrrs r@rrjs9VCK  && Td rBc[U[[45(a([R"XR S9n[ XX#S9$[S[U5RS35eNr,r+r<rr) rfrsr rhrur-rrkr3rrs r@__ror__rsZ !c4[!!   Qgg .!C332473C3C2DN S  rB)rrc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``bitwise_or`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_or`. rDrErFN)rrGrHrr bitwise_or_rJs r@rrss 1IGG,YK7abcbibiajkE F  !!!''rBc j[5(aUc[R"X5$[SXX2SS9$)a3 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]) bitwise_xorTr)rrrrrs r@rrrrBc[U[[45(a([R"XR S9n[ XX#S9$[S[U5RS35er) rfrsr rhrur-rrkr3rrs r@__rxor__rsZ !c4[!!   Qgg .1S442473C3C2DN S  rBc[URUR5nX0R:wa[SUSURS35e[5(a[R "X5$g)z Inplace version of ``bitwise_xor`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_bitwise_xor`. rDrErFN)rrGrHrr bitwise_xor_rJs r@rrrLrBc l[5(aUc[R"U5$[SUSX!SS9$)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 r@rrs;DCK!!!$$ d% rBcN[5(a[R"U5$g)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_rTs r@rr/rUrBc[XUS9$)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 r@bitwise_invertr9sF q --rBc[XS9$)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<)rrTs r@bitwise_invert_r_s  %%rB)NNT)r;rXrrr Tensor | Noner+rr< str | Noner=r returnr)N)rrrrr<rrr)rrr<rrr)gh㈵>g:0yE>FN)rrrrrargrbrgr`r r<rrr) rrrrr<rr+rrr)rrrzTypeGuard[Tensor])NN) rrrrr+rr<rrr)rrr int | bool) rrrrr+rr<rrr)rrr+rr<rrr)J __future__rtypingrrtyping_extensionsrrhr paddle._C_opsrr r r r r paddle.tensor.creationrpaddle.tensor.mathrpaddle.utils.decorator_utilsrrrpaddle.utils.inplace_utilsrbase.data_feederrrcommon_ops_importr frameworkrrrrr__all__rArIrNrQrSrWr\r_rrrxr{r}rrrrrrrrrrrrrrrrrrrrrrrrrBr@rs#%' (. DC(  E E EE  E  E  E EP ) ) ( ( ) )&&(V+b l l l l  l  l  l l^#w#w0-1aKOa aa *a;Ha a1aH # #"#w#w0-1& KO&  & & *& ;H&  & 1& R#w#w0-1QKOQ QQ *Q;HQ Q1Qh + + * *#w#w0-1RKOR RR *R;HR R1Rj ( (#w#w0-1SKOS SS *S;HS S1Sl ' '""#w#w0-1SKOS SS *S;HS S1Sl ' '#u"'"'R / / //  /  /  / /fIM( ((,(;E( (V  ) )#w#w0HL/ //,/;E/ /1/j               G9G956 (7 (IM( ((,(;E( (\                ) )>B' '!'0:' 'T&&>B#. #.!#.0:#. #.L&&rB