code: def _docs_math():
      _docs.set_doc(
          chainerx.negative,
          """negative(x)
  Numerical negative, element-wise.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = -x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.negative`
  """,
      )
  
      _docs.set_doc(
          chainerx.add,
          """add(x1, x2)
  Add arguments, element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = x_1 + x_2`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.add`
  """,
      )
  
      _docs.set_doc(
          chainerx.subtract,
          """subtract(x1, x2)
  Subtract arguments, element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = x_1 - x_2`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.subtract`
  """,
      )
  
      _docs.set_doc(
          chainerx.multiply,
          """multiply(x1, x2)
  Multiply arguments, element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = x_1 \\times x_2`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.multiply`
  """,
      )
  
      _docs.set_doc(
          chainerx.divide,
          """divide(x1, x2)
  Divide arguments, element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\frac{x_1}{x_2}`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.divide`
  """,
      )
  
      _docs.set_doc(
          chainerx.sum,
          """sum(a, axis=None, keepdims=False)
  Sum of array elements over a given axis.
  
  Args:
      a (~chainerx.ndarray): Input array.
      axis (None or int or tuple of ints):
          Axis or axes along which a sum is performed.
          The flattened array is used by default.
      keepdims (bool):
          If this is set to ``True``, the reduced axes are left in the result
          as dimensions with size one.
  
  Returns:
      :class:`~chainerx.ndarray`: The sum of input elements over a given axis.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``a``.
  
  .. seealso:: :func:`numpy.sum`
  """,
      )
  
      _docs.set_doc(
          chainerx.maximum,
          """maximum(x1, x2)
  Maximum arguments, element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`:
          Returned array: :math:`y = max(\\{x_1, x_2\\})`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.maximum`
  """,
      )
  
      _docs.set_doc(
          chainerx.minimum,
          """minimum(x1, x2)
  Minimum arguments, element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`:
          Returned array: :math:`y = min(\\{x_1, x_2\\})`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.minimum`
  """,
      )
  
      _docs.set_doc(
          chainerx.remainder,
          """remainder(x1, x2)
  Return element-wise remainder of division.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array.
      x2 (~chainerx.ndarray or scalar): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`:
          Returned array: The element-wise remainder of
          the quotient ``floor_divide(x1, x2)``.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input arrays ``x1`` and ``x2``.
  
  .. seealso:: :data:`numpy.remainder`
  """,
      )
  
      _docs.set_doc(
          chainerx.exp,
          """exp(x)
  Numerical exponential, element-wise.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\exp x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.exp`
  """,
      )
  
      _docs.set_doc(
          chainerx.log,
          """log(x)
  Natural logarithm, element-wise.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\ln x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.log`
  """,
      )
  
      _docs.set_doc(
          chainerx.log10,
          """log10(x)
  Base 10 logarithm, element-wise.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\log_{10} x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.log10`
  """,
      )
  
      _docs.set_doc(
          chainerx.log2,
          """log2(x)
  Base 2 logarithm, element-wise.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\log_{2} x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.log2`
  """,
      )
  
      _docs.set_doc(
          chainerx.log1p,
          """log1p(x)
  Natural logarithm of one plus the input, element-wise.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\log(1 + x)`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.log1p`
  """,
      )
  
      _docs.set_doc(
          chainerx.logsumexp,
          """logsumexp(x, axis=None, keepdims=False)
  The log of the sum of exponentials of input array.
  
  Args:
      x (~chainerx.ndarray): Input array.
      axis (None or int or tuple of ints):
          Axis or axes along which a sum is performed.
          The flattened array is used by default.
      keepdims (bool):
          If this is set to ``True``, the reduced axes are left in the result
          as dimensions with size one.
  
  Returns:
      :class:`~chainerx.ndarray`: The log of the sum of exponentials of
      input elements over a given axis.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  """,
      )
  
      _docs.set_doc(
          chainerx.log_softmax,
          """log_softmax(x, axis=None)
  The log of the softmax of input array.
  
  Args:
      x (~chainerx.ndarray): Input array.
      axis (None or int or tuple of ints):
          Axis or axes along which a sum is performed.
          The flattened array is used by default.
  
  Returns:
      :class:`~chainerx.ndarray`: The log of the softmax of input elements
      over a given axis.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  """,
      )
  
      _docs.set_doc(
          chainerx.square,
          """square(x)
  Returns the element-wise square of the input.
  
  Args:
      x (~chainerx.ndarray or scalar): Input data
  
  Returns:
      ~chainerx.ndarray: Returned array: :math:`y = x * x`.
      A scalar is returned if ``x`` is a scalar.
  
  Note:
      During backpropagation, this function propagates the gradient
      of the output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.square`
  """,
      )
  
      _docs.set_doc(
          chainerx.sqrt,
          """sqrt(x)
  Non-negative square-root, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\sqrt x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.sqrt`
  """,
      )
  
      _docs.set_doc(
          chainerx.sinh,
          """sinh(x)
  Hyperbolic Sine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\sinh x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.sinh`
  """,
      )
  
      _docs.set_doc(
          chainerx.cosh,
          """cosh(x)
  Hyperbolic Cosine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\cosh x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.cosh`
  """,
      )
  
      _docs.set_doc(
          chainerx.tanh,
          """tanh(x)
  Element-wise hyperbolic tangent function.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\tanh x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.tanh`
  """,
      )
  
      _docs.set_doc(
          chainerx.sigmoid,
          """sigmoid(x)
  Element-wise sigmoid logistic function.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array:
      :math:`f(x) = (1 + \\exp(-x))^{-1}`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :func:`chainer.functions.sigmoid`
  """,
      )
  
      _docs.set_doc(
          chainerx.sin,
          """sin(x)
  Sine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\sin x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.sin`
  """,
      )
  
      _docs.set_doc(
          chainerx.cos,
          """cos(x)
  Cosine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\cos x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.cos`
  """,
      )
  
      _docs.set_doc(
          chainerx.ceil,
          """ceil(x)
  Return the ceiling of the input, element-wise..
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: The ceiling of each element in array.
  
  .. seealso:: :data:`numpy.ceil`
  """,
      )
  
      _docs.set_doc(
          chainerx.tan,
          """tan(x)
  Tangent, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\tan x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.tan`
  """,
      )
  
      _docs.set_doc(
          chainerx.relu,
          """Rectified Linear Unit function.
  Args:
      x (~chainerx.ndarray): Input array.
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\max (0, x)`.
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  """,
      )
  
      _docs.set_doc(
          chainerx.tree_lstm,
          """tree_lstm(*inputs)
  TreeLSTM unit as an activation function.
  
  This function implements TreeLSTM units both for
  N-ary TreeLSTM and Child-Sum TreeLSTM.
  Let the children cell states
  :math:`c_{\\text{1}}, c_{\\text{2}}, \\dots, c_{\\text{N}}`,
  and the incoming signal :math:`x`.
  First, the incoming signal :math:`x` is split into (3 + N) arrays
  :math:`a, i, o, f_{\\text{1}}, f_{\\text{2}}, ..., f_{\\text{N}}`
  of the same shapes along the second axis.
  It means that :math:`x` 's second axis must have (3 + N) times
  of the length of each :math:`c_{n}`.
  The splitted input signals are corresponding to
  
      - :math:`a` : sources of cell input
      - :math:`i` : sources of input gate
      - :math:`o` : sources of output gate
      - :math:`f_{n}` : sources of forget gate for n-th ary
  
  Second, it computes outputs as
  
  .. math::
      c &= \\tanh(a) \\text{sigmoid}(i) \\\\
        & + c_{\\text{1}} \\text{sigmoid}(f_{\\text{1}}), \\\\
        & + c_{\\text{2}} \\text{sigmoid}(f_{\\text{2}}), \\\\
        & + ..., \\\\
        & + c_{\\text{N}} \\text{sigmoid}(f_{\\text{N}}), \\\\
      h &= \\tanh(c) \\text{sigmoid}(o).
  
  These are returned as a tuple of (N + 1) variables.
  
  Args:
      inputs (list of :class:`~chainerx.array`): Variable arguments which
          include all cell vectors from child-nodes, and an input vector.
          Each of the cell vectors and the input vector is
          :class:`~chainerx.array`.
          The input vector must have the second dimension whose size
          is (N + 3) times of that of each cell,
          where N denotes the total number of cells.
  
  Returns:
      tuple: Two :class:`~chainerx.array` objects ``c`` and ``h``. ``c`` is
      the updated cell state. ``h`` indicates the outgoing signal.
  
  See the papers for details: `Improved Semantic Representations From
  Tree-Structured Long Short-Term Memory Networks
  <https://www.aclweb.org/anthology/P15-1150>`_ and
  `A Fast Unified Model for Parsing and Sentence Understanding
  <https://arxiv.org/pdf/1603.06021.pdf>`_.
  Tai et al.'s N-Ary TreeLSTM is little extended in
  Bowman et al., and this link is based on
  the variant by Bowman et al.
  Specifically, eq. 10 in Tai et al. only has one :math:`W` matrix
  to be applied to :math:`x`, consistently for all children.
  On the other hand, Bowman et al.'s model has multiple matrices,
  each of which affects the forget gate for each child's cell individually.
  
  .. admonition:: Example
  
      Assuming ``y`` is the current input signal, ``c`` is the previous cell
      state, and ``h`` is the previous output signal from an
      :meth:`~chainerx.tree_lstm` function.
      Each of ``y``, ``c`` and ``h`` has ``n_units`` channels.
      Using 2-ary (binary) TreeLSTM,
  
      most typical preparation of ``x`` is
  
      >>> c1 = chainerx.ones((4, 10), dtype = chainerx.float32)
      >>> c2 = chainerx.ones((4, 10), dtype = chainerx.float32)
      >>> x = chainerx.ones((4, 50), dtype = chainerx.float32)
      >>> c, h = chainerx.tree_lstm(c1, c2, x)
      """,
      )
  
      _docs.set_doc(
          chainerx.slstm,
          """slstm(c_prev1, c_prev2, x1, x2)
  S-LSTM units as an activation function.
  
  This function implements S-LSTM unit. It is an extension of LSTM unit
  applied to tree structures.
  The function is applied to binary trees. Each node has two child nodes.
  It gets four arguments, previous cell states ``c_prev1`` and ``c_prev2``,
  and input arrays ``x1`` and ``x2``.
  First both input arrays ``x1`` and ``x2`` are split into eight arrays
  :math:`a_1, i_1, f_1, o_1`, and :math:`a_2, i_2, f_2, o_2`. They have the
  same shape along the second axis.
  It means that ``x1`` and ``x2`` 's second axis must have 4 times
  the length of ``c_prev1`` and ``c_prev2``.
  The split input arrays are corresponding to
  
      - :math:`a_i` : sources of cell input
      - :math:`i_i` : sources of input gate
      - :math:`f_i` : sources of forget gate
      - :math:`o_i` : sources of output gate
  
  It computes the updated cell state ``c`` and the outgoing signal
  ``h`` as.
  
  .. math::
      c &= \\tanh(a_1 + a_2) \\sigma(i_1 + i_2)
         + c_{\\text{prev}1} \\sigma(f_1)
         + c_{\\text{prev}2} \\sigma(f_2), \\\\
      h &= \\tanh(c) \\sigma(o_1 + o_2),
  
  where :math:`\\sigma` is the elementwise sigmoid function.
  The function returns ``c`` and ``h`` as a tuple.
  
  Args:
      c_prev1 (:class:`~chainerx.array`):
          Variable that holds the previous cell state of the first child
          node. The cell state should be a zero array or the output of
          the previous call of LSTM.
      c_prev2 (:class:`~chainerx.array`):
          Variable that holds the previous cell state of the second child
          node.
      x1 (:class:`~chainerx.array`):
          Variable that holds the sources of cell input, input gate, forget
          gate and output gate from the first child node. It must have the
          second dimension whose size is four times of that of the cell
          state.
      x2 (:class:`~chainerx.array`):
          Variable that holds the input sources from the second child node.
  
  Returns:
      tuple: Two :class:`~chainerx.array` objects ``c`` and ``h``. ``c`` is
      the cell state. ``h`` indicates the outgoing signal.
  
  See detail in paper: `Long Short-Term Memory Over Tree Structures
  <https://arxiv.org/abs/1503.04881>`_.
  
  .. admonition:: Example
  
      Assuming ``c1``, ``c2`` is the previous cell state of children,
      and ``h1``, ``h2`` is the previous outgoing signal from children.
      Each of ``c1``, ``c2``, ``h1`` and ``h2`` has ``n_units`` channels.
      Most typical preparation of ``x1``, ``x2`` is:
  
      >>> n_units = 100
      >>> c1 = chainerx.ones((1, n_units), np.float32)
      >>> c2 = chainerx.ones((1, n_units), np.float32)
      >>> x1 = chainerx.ones((1, 4 * n_units), chainerx.float32)
      >>> x2 = chainerx.ones((1, 4 * n_units), chainerx.float32)
      >>> c, h = chainerx.slstm(c1, c2, x1, x2)
      """,
      )
  
      _docs.set_doc(
          chainerx.arcsin,
          """arcsin(x)
  Inverse sine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\arcsin x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.arcsin`
  """,
      )
  
      _docs.set_doc(
          chainerx.arccos,
          """arccos(x)
  Trigonometric inverse cosine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\arccos x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.arccos`
  """,
      )
  
      _docs.set_doc(
          chainerx.arctan,
          """arctan(x)
  Trigonometric inverse tangent, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\arctan x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.arctan`
  """,
      )
  
      _docs.set_doc(
          chainerx.arctan2,
          """arctan2(x1, x2)
  Element-wise arc tangent of :math:`\\frac{x_1}{x_2}` choosing the quadrant
  correctly.
  
  Args:
      x1 (~chainerx.ndarray): Input array.
      x2 (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returns an array where each element
      represents :math:`\\theta` in the range :math:`[-\\pi, \\pi]`, such
      that :math:`x_1 = r \\sin(\\theta)` and :math:`x_2 = r \\cos(\\theta)`
      for some :math:`r > 0`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x1`` and/or ``x2``.
  
  .. seealso:: :data:`numpy.arctan2`
  """,
      )
  
      _docs.set_doc(
          chainerx.arcsinh,
          """arcsinh(x)
  Inverse hyperbolic sine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\arcsinh x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.arcsinh`
  """,
      )
  
      _docs.set_doc(
          chainerx.arccosh,
          """arccosh(x)
  Inverse hypberbolic inverse cosine, element-wise
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = \\arccosh x`.
  
  Note:
      During backpropagation, this function propagates the gradient of the
      output array to the input array ``x``.
  
  .. seealso:: :data:`numpy.arccosh`
  """,
      )
  
      _docs.set_doc(
          chainerx.fabs,
          """fabs(x)
  Compute the absolute values element-wise.
  Args:
      x (~chainerx.ndarray): Input array.
  Returns:
      :class:`~chainerx.ndarray`: The absolute values of x, the returned values
      are always floats.
  .. seealso:: :data:`numpy.fabs`
  """,
      )
  
      _docs.set_doc(
          chainerx.sign,
          """sign(x)
  Returns an element-wise indication of the sign of a number.
  The sign function returns :math:`-1 if x < 0, 0 if x==0, 1 if x > 0`.
  ``nan`` is returned for ``nan`` inputs.
  Args:
      x (~chainerx.ndarray): Input array.
  Returns:
      :class:`~chainerx.ndarray`: The sign of x.
  .. seealso:: :data:`numpy.sign`
  """,
      )
  
      _docs.set_doc(
          chainerx.floor,
          """floor(x)
  Return the floor of the input, element-wise.
  Args:
      x (~chainerx.ndarray): Input array.
  Returns:
      :class:`~chainerx.ndarray`: The floor of each element in array.
  .. seealso:: :data:`numpy.floor`
  """,
      )
  
      _docs.set_doc(
          chainerx.isnan,
          """isnan(x)
  Test element-wise for NaN and return result as a boolean array.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: True where ``x`` is NaN, false otherwise
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.isnan`
  """,
      )
  
      _docs.set_doc(
          chainerx.isfinite,
          """isfinite(x)
  Test element-wise for finiteness (not infinity or not Not a Number).
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: True where x is not positive infinity,
      negative infinity, or NaN; false otherwise.
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.isfinite`
  """,
      )
  
      _docs.set_doc(
          chainerx.isinf,
          """isinf(x)
  Test element-wise for positive or negative infinity.
  
  Args:
      x (~chainerx.ndarray): Input array.
  
  Returns:
      :class:`~chainerx.ndarray`: True where ``x`` is positive or negative
      infinity, false otherwise.
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.isinf`
  """,
      )
  
      _docs.set_doc(
          chainerx.bitwise_and,
          """bitwise_and(x1, x2)
  Compute the bit-wise AND of two arrays element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array of integers.
      x2 (~chainerx.ndarray or scalar): Input array of integers.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = x_1 \\& x_2`
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.bitwise_and`
  """,
      )
  
      _docs.set_doc(
          chainerx.bitwise_or,
          """bitwise_or(x1, x2)
  Compute the bit-wise OR of two arrays element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array of integers.
      x2 (~chainerx.ndarray or scalar): Input array of integers.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = x_1 | x_2`
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.bitwise_or`
  """,
      )
  
      _docs.set_doc(
          chainerx.bitwise_xor,
          """bitwise_xor(x1, x2)
  Compute the bit-wise XOR of two arrays element-wise.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array of integers.
      x2 (~chainerx.ndarray or scalar): Input array of integers.
  
  Returns:
      :class:`~chainerx.ndarray`: Returned array: :math:`y = x_1 \\oplus x_2`
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.bitwise_xor`
  """,
      )
  
      _docs.set_doc(
          chainerx.left_shift,
          """left_shift(x1, x2)
  Shift the bits of an integer to the left.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array of integers.
      x2 (~chainerx.ndarray or scalar): Input array of integers.
  
  Returns:
      :class:`~chainerx.ndarray`: Return `x1` with bits shifted `x2` times to the left.
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.left_shift`
  """,
      )  # NOQA
  
      _docs.set_doc(
          chainerx.right_shift,
          """right_shift(x1, x2)
  Shift the bits of an integer to the right.
  
  Args:
      x1 (~chainerx.ndarray or scalar): Input array of integers.
      x2 (~chainerx.ndarray or scalar): Input array of integers.
  
  Returns:
      :class:`~chainerx.ndarray`: Return `x1` with bits shifted `x2` times to the right.
  
  Note:
      During backpropagation, this function does not propagate gradients.
  
  .. seealso:: :data:`numpy.right_shift`
  """,
      )
  
file_path: chainer/chainerx/_docs/routines.py
imports: import chainerx
  from chainerx import _docs
label_desc: Use image node_id 9 for calling a global function with example usage: _docs_math() without return types