code: def conv1d(
      x: Union[ivy.Array, ivy.NativeArray],
      filters: Union[ivy.Array, ivy.NativeArray],
      strides: Union[int, Tuple[int]],
      padding: Union[str, int, Sequence[Tuple[int, int]]],
      /,
      *,
      data_format: str = "NWC",
      filter_format: str = "channel_last",
      x_dilations: Union[int, Tuple[int]] = 1,
      dilations: Union[int, Tuple[int]] = 1,
      bias: Optional[ivy.Array] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute a 1-D convolution given 3-D input x and filters arrays.
  
      Parameters
      ----------
      x
          Input image *[batch_size,w,d_in]* or *[batch_size,d_in,w]*.
      filters
          Convolution filters *[fw,d_in,d_out]*.
      strides
          The stride of the sliding window for each dimension of input.
      padding
          either the string ‘SAME’ (padding with zeros evenly), the string ‘VALID’ (no
          padding), or a sequence of n (low, high) integer pairs that give the padding to
          apply before and after each spatial dimension.
      data_format
          The ordering of the dimensions in the input, one of "NWC" or "NCW". "NWC"
          corresponds to input with shape (batch_size, width, channels), while "NCW"
          corresponds to input with shape (batch_size, channels, width).
      filter_format
          Either "channel_first" or "channel_last". "channel_first" corresponds to "OIW",
           input data formats, while "channel_last" corresponds to "WIO", "HWIO", "DHWIO".
       x_dilations
          The dilation factor for each dimension of input. (Default value = 1)
      dilations
          The dilation factor for each dimension of input. (Default value = 1)
      bias
          Bias array of shape *[d_out]*.
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          The result of the convolution operation.
  
      Both the description and the type hints above assumes an array input for simplicity,
      but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
      instances in place of any of the arguments.
  
      Examples
      --------
      With :class:`ivy.Array` input:
  
      >>> x = ivy.asarray([[[0.], [3.], [0.]]]) #NWC
      >>> filters = ivy.array([[[0.]], [[1.]], [[0.]]]) #WIO
      >>> result = ivy.conv1d(x, filters, (1,), 'SAME', data_format='NWC',dilations= (1,))
      >>> print(result)
      ivy.array([[[0.], [3.], [0.]]])
  
      With :class:`ivy.NativeArray` input:
  
      >>> x = ivy.native_array([[[1., 3.], [2., 4.], [5., 7]]])
      >>> filters = ivy.native_array([[[0., 1.], [1., 0.]]])
      >>> result = ivy.conv1d(x, filters, (2,),'VALID')
      >>> print(result)
      ivy.array([[[3., 1.],
      ...         [7., 5.]]])
  
      With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs:
  
      >>> x = ivy.Container(a=ivy.array([[[1.2, 3.1, 4.8], [5.9, 2.2, 3.3],
      ...                                 [10.8, 7.6, 4.9], [6.1, 2.2, 9.5]]]),
      ...                   b=ivy.array([[[8.8, 7.7, 6.6], [1.1, 2.2, 3.5]]]))
      >>> filters = ivy.array([[[1., 0., 1.], [0., 1., 0.], [1., 1., 0.]]])
      >>> result  = ivy.conv1d(x, filters, 3, 'VALID')
      >>> print(result)
      {
              a: ivy.array([[[6., 7.9, 1.2],
      ...                    [15.6, 11.7, 6.1]]]),
      ...     b: ivy.array([[[15.4, 14.3, 8.8]]])
      }
      """
      return current_backend(x).conv1d(
          x,
          filters,
          strides,
          padding,
          data_format=data_format,
          filter_format=filter_format,
          x_dilations=x_dilations,
          dilations=dilations,
          bias=bias,
          out=out,
      )
  
imports: from typing import Optional, Tuple, Union, Sequence
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, handle_partial_mixed_function, inputs_to_ivy_arrays, to_native_arrays_and_back, inputs_to_native_shapes, handle_out_argument, handle_nestable, handle_array_like_without_promotion, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 7 for calling a global function with example usage: conv1d() and returns: current_backend