mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/auto_generate/gen_ops_def.py

@@ -250,11 +250,11 @@ def add_ext(input, other, alpha=1):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
@@ -312,7 +312,7 @@ def add(input, other):
 
     Note:
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
+          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - Support broadcast, support implicit type conversion and type promotion.
         - When the input is a tensor, the dimension should be greater than or equal to 1.
 
@@ -1985,112 +1985,6 @@ def count_nonzero(input, dim=None):
     return count_nonzero_op(input, dim)
 
 
-def cross_entropy_loss_grad(grad_loss, log_prob, target, weight=None, grad_zloss=None, lse_for_zloss=None, reduction='mean', ignore_index=-100, label_smoothing=0.0, lse_square_scale_for_zloss=0.0):
-    r"""
-    
-    """
-    return cross_entropy_loss_grad_op(grad_loss, log_prob, target, weight, grad_zloss, lse_for_zloss, reduction, ignore_index, label_smoothing, lse_square_scale_for_zloss)
-
-
-def cross_entropy_loss(input, target, weight=None, reduction='mean', ignore_index=-100, label_smoothing=0.0, lse_square_scale_for_zloss=0.0, return_zloss=False):
-    r"""
-    Computes the cross entropy loss between input and target.
-
-    Assume the number of classes :math:`C` in the range :math:`[0, C)`,
-    the loss with reduction=none can be described as:
-
-    .. math::
-
-        \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad
-        l_n = - w_{y_n} \log \frac{\exp(x_{n,y_n})}{\sum_{c=1}^C \exp(x_{n,c})}
-        \cdot \mathbb{1}\{y_n \not= \text{ignore_index}\}
-
-    where :math:`x` is the inputs, :math:`y` is the target, :math:`w` is the weight, :math:`N` is the batch size,
-    :math:`c` belonging to :math:`[0, C-1]` is class index, where :math:`C` is the number of classes.
-
-    If `reduction` is not ``None`` (default ``'mean'`` ), then
-
-    .. math::
-
-        \ell(x, y) = \begin{cases}
-            \sum_{n=1}^N \frac{1}{\sum_{n=1}^N w_{y_n} \cdot \mathbb{1}\{y_n \not= \text{ignore_index}\}} l_n, &
-            \text{if reduction} = \text{'mean',}\\
-            \sum_{n=1}^N l_n,  &
-            \text{if reduction} = \text{'sum'.}
-            \end{cases}
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Inputs:
-        - **input** (Tensor) - Tensor of shape of :math:`(N, C)` where `C = number of classes`, data type must be bfloat16, float16 or float32.
-        - **target** (Tensor) - For class indices, tensor of shape :math:`(N)`, data type must be int64. The value must be in range [0, C).
-        - **weight** (Tensor, optional) - A rescaling weight applied to the loss of each batch element.
-          If not None, the shape is :math:`(C,)`, data type must be float32. Default: ``None`` .
-        - **reduction** (str, optional) - Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-          ``'sum'`` . Default: ``'mean'`` .
-
-          - ``'none'``: no reduction will be applied.
-          - ``'mean'``: compute and return the weighted mean of elements in the output.
-          - ``'sum'``: the output elements will be summed.
-
-        - **ignore_index** (int, optional) - Specifies a target value that is ignored and does not contribute to the input
-          gradient. When set to negative values, no target value is ignored. It should be int64.
-          Default: ``-100`` .
-        - **label_smoothing** (float, optional) - Label smoothing values, a regularization tool used to prevent the model
-          from overfitting when calculating Loss. This value must be 0.0 currently. Default: ``0.0`` .
-        - **lse_square_scale_for_zloss** (float, optional) - The value range is [0.0, 1.0), not enabled for now, can only be 0.0. Default: ``0.0`` .
-        - **return_zloss** (float, optional) - Not enabled for now, can only be ``False``. Default: ``False`` .
-
-    Outputs:
-        A tuple consisting of 4 Tensors.
-
-        - **loss** (Tensor) - loss between `input` and `target`, the dtype is the same as `input`.
-
-          - If `reduction` is ``'none'`` , the shape is :math:`(N,)` .
-          - If `reduction` is ``'sum'` or ``'mean'`, the shape is :math:`(1,)` .
-
-        - **log_prob** (Tensor) - the shape is :math:`(N, C)` with the same dtype as `input`.
-        - **zloss** (Tensor) - the shape is :math:`(N,)` if `return_zloss` is True, or the shape is :math:`(0,)` with the same dtype as `input`. This parameter is disabled for now.
-        - **lse_for_zloss** (Tensor) - the shape is :math:`(N,)` if `lse_square_scale_for_zloss` is not 0.0, or the shape is :math:`(0,)` with the same dtype as `input`. This parameter is disabled for now.
-
-
-    Raises:
-        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
-        TypeError: If `input`, `target` or `weight` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn, ops
-        >>> 
-        >>> 
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.cross_entropy_loss = ops.auto_generate.CrossEntropyLoss()
-        ... 
-        ...     def construct(self, input, target, weight):
-        ...         result = self.cross_entropy_loss(input, target, weight)
-        ...         return result
-        ... 
-        >>> 
-        >>> net = Net()
-        >>> input = Tensor(np.array([[0.2, 0.7, 0.1], [0.2, 0.7, 0.1]]), mindspore.float32)
-        >>> target = Tensor(np.array([0, 1]), mindspore.int64)
-        >>> weight = Tensor(np.array([1, 0.5, 0.5]), mindspore.float32)
-        >>> output = net(input, target, weight)
-        >>> print(output[:2])
-        (Tensor(shape=[1], dtype=Float32, value= [ 1.10128295e+00]), Tensor(shape=[2, 3], dtype=Float32, value=
-        [[-1.26794958e+00, -7.67949641e-01, -1.36794960e+00],
-         [-1.26794958e+00, -7.67949641e-01, -1.36794960e+00]]))
-    """
-    return cross_entropy_loss_op(input, target, weight, reduction, ignore_index, label_smoothing, lse_square_scale_for_zloss, return_zloss)
-
-
 def cummax(input, axis):
     r"""
     Return the cumulative maximum values and their indices along the given axis of the tensor.
@@ -3632,7 +3526,7 @@ def gather(input_params, input_indices, axis, batch_dims=0):
         - The value of input_indices must be in the range of `[0, input_param.shape[axis])`.
           On CPU and GPU, an error is raised if an out of bound indice is found. On Ascend, the results may be
           undefined.
-        - The data type of input_params cannot be `mindspore.bool` .
+        - The data type of input_params cannot be `mindspore.bool_` .
         - The shape of returned tensor is :math:`input\_params.shape[:axis] + input\_indices.shape[batch\_dims:] + input\_params.shape[axis + 1:]` .
 
     Args:
@@ -4728,7 +4622,7 @@ def index(input, indices):
         [2 6 5]
         >>> input2 = Tensor(np.arange(4 * 3 * 3).reshape(4, 3, 3), mindspore.int32)
         >>> indices3 = Tensor(np.array([1, 0]), mindspore.int32)
-        >>> indices4 = Tensor(np.array([1, 1, 0]), mindspore.bool)
+        >>> indices4 = Tensor(np.array([1, 1, 0]), mindspore.bool_)
         >>> output2 = ops.auto_generate.index(input2, [indices3, indices4])
         >>> print(output2)
         [[ 9 10 11]
@@ -4804,20 +4698,6 @@ def inplace_add_ext(input, other, alpha=1):
     return inplace_add_ext_op(input, other, alpha)
 
 
-def inplace_bernoulli_scalar(input, p, seed, offset):
-    r"""
-    
-    """
-    return inplace_bernoulli_scalar_op(input, p, seed, offset)
-
-
-def inplace_bernoulli_tensor(input, p, seed, offset):
-    r"""
-    
-    """
-    return inplace_bernoulli_tensor_op(input, p, seed, offset)
-
-
 def inplace_clamp_scalar(input, min=None, max=None):
     r"""
     
@@ -4832,11 +4712,11 @@ def inplace_clamp_tensor(input, min=None, max=None):
     return inplace_clamp_tensor_op(input, min, max)
 
 
-def inplace_copy(input, src, non_blocking=False):
+def inplace_copy(input, src):
     r"""
     
     """
-    return inplace_copy_op(input, src, non_blocking)
+    return inplace_copy_op(input, src)
 
 
 def divmod_scalar_(input, other, rounding_mode=None):
@@ -5611,13 +5491,6 @@ def kthvalue(input, k, dim=-1, keepdim=False):
     return kthvalue_op(input, k, dim, keepdim)
 
 
-def kv_scale_cache(key_scale, value_scale, key_value_scale_cache, batch_valid_length, cache_mode):
-    r"""
-    
-    """
-    return kv_scale_cache_op(key_scale, value_scale, key_value_scale_cache, batch_valid_length, cache_mode)
-
-
 def l1_loss_ext(input, target, reduction='mean'):
     r"""
     Calculate the mean absolute error between the `input` value and the `target` value.
@@ -6273,7 +6146,7 @@ def masked_fill(input_x, mask, value):
     Examples:
         >>> import mindspore
         >>> input_x = mindspore.tensor([1., 2., 3., 4.], mindspore.float32)
-        >>> mask = mindspore.tensor([True, True, False, True], mindspore.bool)
+        >>> mask = mindspore.tensor([True, True, False, True], mindspore.bool_)
         >>> output = mindspore.ops.masked_fill(input_x, mask, 0.5)
         >>> print(output)
         [0.5 0.5 3.  0.5]
@@ -6281,13 +6154,6 @@ def masked_fill(input_x, mask, value):
     return masked_fill_op(input_x, mask, value)
 
 
-def masked_scatter(input, mask, source):
-    r"""
-    
-    """
-    return masked_scatter_op(input, mask, source)
-
-
 def masked_select(input, mask):
     r"""
     Return a new 1-D tensor which indexes the `input` tensor according to the boolean `mask`.
@@ -6307,7 +6173,7 @@ def masked_select(input, mask):
     Examples:
         >>> import mindspore
         >>> x = mindspore.tensor([1, 2, 3, 4], mindspore.int64)
-        >>> mask = mindspore.tensor([1, 0, 1, 0], mindspore.bool)
+        >>> mask = mindspore.tensor([1, 0, 1, 0], mindspore.bool_)
         >>> output = mindspore.ops.masked_select(x, mask)
         >>> print(output)
         [1 3]
@@ -6684,20 +6550,6 @@ def mish_ext(input):
     return mish_ext_op(input)
 
 
-def mla(query, q_rope, kv_cache, k_rope, block_tables, attn_mask=None, deq_scale_qk=None, deq_scale_pv=None, q_seq_lens=None, context_lens=None, head_num=32, scale_value=0.0, kv_head_num=1, mask_mode='MASK_NONE', is_ring=0):
-    r"""
-    
-    """
-    return mla_op(query, q_rope, kv_cache, k_rope, block_tables, attn_mask, deq_scale_qk, deq_scale_pv, q_seq_lens, context_lens, head_num, scale_value, kv_head_num, mask_mode, is_ring)
-
-
-def mla_preprocess(input1, gamma1, beta1, quant_scale1, quant_offset1, wdqkv, bias1, gamma2, beta2, quant_scale2, quant_offset2, gamma3, sin1, cos1, sin2, cos2, key_cache, slot_mapping, wuq, bias2, slot_wuk, de_scale1, de_scale2, ctkv_scale, qnope_scale, krope_cache, param_cache_mode=0):
-    r"""
-    
-    """
-    return mla_preprocess_op(input1, gamma1, beta1, quant_scale1, quant_offset1, wdqkv, bias1, gamma2, beta2, quant_scale2, quant_offset2, gamma3, sin1, cos1, sin2, cos2, key_cache, slot_mapping, wuq, bias2, slot_wuk, de_scale1, de_scale2, ctkv_scale, qnope_scale, krope_cache, param_cache_mode)
-
-
 def mm_ext(input, mat2):
     r"""
     Returns the matrix product of two arrays.
@@ -7126,7 +6978,7 @@ def mul(input, other):
         - When the two inputs have different shapes,
           they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
+          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - Support implicit type conversion and type promotion.
 
     Args:
@@ -7522,10 +7374,8 @@ def prelu(input, weight):
         :align: center
 
     .. note::
-        - Channel dim is the 2nd dim of input. When input has dims < 2, then there is
-          no channel dim and the number of channels = 1.
-        - In GE mode, the rank of the input tensor must be greater than 1;
-          otherwise, an error will be triggered.
+        Channel dim is the 2nd dim of input. When input has dims < 2, then there is
+        no channel dim and the number of channels = 1.
 
     Args:
         input (Tensor): The input Tensor of the activation function.
@@ -8170,78 +8020,6 @@ def rfft(input, n=None, dim=-1, norm=None):
     return rfft_op(input, n, dim, norm)
 
 
-def ring_attention_update(prev_attn_out, prev_softmax_max, prev_softmax_sum, cur_attn_out, cur_softmax_max, cur_softmax_sum, actual_seq_qlen=None, layout='SBH'):
-    r"""
-    The RingAttentionUpdate operator updates the output of two FlashAttention operations based on their respective softmax max and softmax sum values.
-
-    - S: Sequence length
-    - B: Batch dimension
-    - H: Hidden layer size, equals to N * D
-    - T: time, equals to B*S
-    - N: Number of attention heads
-    - D: Head dimension
-
-    .. warning::
-        - It is only supported on Atlas A2 Training Series Products.
-        - This is an experimental API that is subject to change or deletion.
-        - When `layout` is ``"TND"``, the last dimension of `prev_attn_out` must be a multiple of 64.
-        - When `layout` is ``"TND"``, `actual_seq_qlen` is mandatory.
-        - When `layout` is ``"TND"``, N x D must satisfy the constraint:
-          (AlignUp(NxD, 64)x(DataSizex6+8))+(AlignUp(Nx8, 64)x56) <= 192x1024.
-          DataSize is 4 bytes when `prev_attn_out` dtype is float32, 2 bytes when dtype is float16 / bfloat16.
-        - When `layout` is ``"TND"``, if `actual_seq_qlen` is not a non-decreasing sequence from 0 to T, the result is undefined.
-
-    Args:
-        prev_attn_out (Tensor): Output of the first FlashAttention operation. The dtype is float16, float32, bfloat16.
-            The shape is :math:`(S, B, H)` or :math:`(T, N, D)`.
-        prev_softmax_max (Tensor): The max values from the first FlashAttention softmax computation. The dtype float32.
-            The shape is :math:`(B, N, S, 8)` or :math:`(T, N, 8)`. The last dimension contains 8 identical values, which must be positive.
-        prev_softmax_sum (Tensor): The sum values from the first FlashAttention softmax computation.
-            It has the same shape and dtype as `prev_softmax_max`.
-        cur_attn_out (Tensor): Output of the second FlashAttention operation. It has the same shape and dtype as `prev_attn_out`.
-        cur_softmax_max (Tensor): The max values from the second FlashAttention softmax computation. It has the same shape and dtype as `prev_softmax_max`.
-        cur_softmax_sum (Tensor):The sum values from the second FlashAttention softmax computation. It has the same shape and dtype as `prev_softmax_max`.
-        actual_seq_qlen (Tensor, optional): Cumulative sequence length, starting from 0. Required if `layout` is ``"TND"``. Does not take effect if `layout` is ``"SBH"``.
-            The tensor must be 1D and contain non-decreasing integer values starting from 0 to T. Default: ``None``.
-        layout (str, optional): Indicates the input layout, currently support ``"TND"`` and ``"SBH"``. Default: ``"SBH"``.
-
-    Returns:
-        tuple (Tensor), tuple of 3 tensors.
-
-        - **attn_out** (Tensor) - The updated attention out, with the same shape and dtype as `prev_attn_out`.
-        - **softmax_max** (Tensor) - The updated softmax max values, with the same shape and dtype as `prev_softmax_max`.
-        - **softmax_sum** (Tensor) - The updated softmax sum values, with the same shape and dtype as `prev_softmax_max`.
-
-    Raises:
-        RuntimeError: If `layout` is ``"TND"``, and `prev_attn_out`'s last dimension is not aligned to 64.
-        RuntimeError: If `layout` is ``"TND"``, and `actual_seq_qlen` is not provided.
-        RuntimeError: If `layout` is ``"TND"``, and `actual_seq_qlen` is not a non-decreasing sequence from 0 to T.
-        RuntimeError: If `layout` is ``"TND"``, and `prev_attn_out` exceeds the size constraints.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> np.random.seed(123)
-        >>> S, B, H, N= 4, 6, 16, 8
-        >>> prev_attn_out = np.random.uniform(-1.0, 1.0, size=(S, B, H)).astype(np.float32)
-        >>> prev_softmax_max = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
-        >>> prev_softmax_sum = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
-        >>> cur_attn_out = np.random.uniform(-1.0, 1.0, size=(S, B, H)).astype(np.float32)
-        >>> cur_softmax_max = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
-        >>> cur_softmax_sum = np.random.uniform(-1.0, 1.0, size=(B, N, S, 8)).astype(np.float32)
-        >>> inputs_np = [prev_attn_out, prev_softmax_max, prev_softmax_sum, cur_attn_out, cur_softmax_max, cur_softmax_sum]
-        >>> inputs_ms = [Tensor(item) for item in inputs_np]
-        >>> out = ops.ring_attention_update(*inputs_ms)
-        >>> print(out[0].shape)
-        (4, 6, 16)
-    """
-    return ring_attention_update_op(prev_attn_out, prev_softmax_max, prev_softmax_sum, cur_attn_out, cur_softmax_max, cur_softmax_sum, actual_seq_qlen, layout)
-
-
 def rms_norm(x, gamma, epsilon=1e-6):
     r"""
     The RmsNorm(Root Mean Square Layer Normalization) operator is a normalization operation. Compared to
@@ -8437,7 +8215,7 @@ def scalar_cast(input_x, input_y):
 
     Args:
         input_x (scalar): The input scalar. Only constant value is allowed.
-        input_y (mindspore.dtype): The type to be cast. Only constant value is allowed. And the value should only be mindspore.int64, mindspore.float64, or mindspore.bool.
+        input_y (mindspore.dtype): The type to be cast. Only constant value is allowed. And the value should only be mindspore.int64, mindspore.float64, or mindspore.bool_.
 
     Returns:
         Scalar. The type is the same as the python type corresponding to `input_y`.
@@ -8947,58 +8725,6 @@ def sin(input):
     return sin_op(input)
 
 
-def smooth_l1_loss(prediction, target, beta=1.0, reduction='none'):
-    r"""
-    Calculate the smooth L1 loss, and the L1 loss function has robustness.
-
-    Refer to :func:`mindspore.ops.smooth_l1_loss` for more details.
-
-    .. warning::
-        This API has poor performance on CPU and it is recommended to run it on the Ascend/GPU.
-
-    Args:
-        beta (number, optional): A parameter used to control the point where the function will change between
-            L1 to L2 loss. Default: ``1.0`` .
-
-            - Ascend: The value should be equal to or greater than zero.
-            - CPU/GPU: The value should be greater than zero.
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'none'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-
-    Inputs:
-        - **logits** (Tensor) - Input Tensor of any dimension. Supported dtypes: 
-
-          - Ascend: float16, float32, bfloat16.
-          - CPU/GPU: float16, float32, float64.
-        - **labels** (Tensor) - Ground truth data.
-            
-          - CPU/Ascend: has the same shape as the `logits`, `logits` and `labels` comply with the implicit type conversion rules to make the data types consistent.
-          - GPU: has the same shape and dtype as the `logits`.
-
-    Outputs:
-        Tensor, if `reduction` is ``'none'``, then output is a tensor with the same shape as `logits`. Otherwise the shape of output tensor is :math:`()`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> loss = ops.SmoothL1Loss()
-        >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
-        >>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
-        >>> output = loss(logits, labels)
-        >>> print(output)
-        [0.  0.  0.5]
-    """
-    return smooth_l1_loss_impl(prediction, target, beta, reduction)
-
-
 def softplus_ext(input, beta=1, threshold=20):
     r"""
     Applies softplus function to `input` element-wise.
@@ -9458,11 +9184,11 @@ def sub_ext(input, other, alpha=1):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
@@ -9507,7 +9233,7 @@ def sub(input, other):
     Note:
         - When the two inputs have different shapes, they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
+          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - Support implicit type conversion and type promotion.
 
     Args: