code: def random_normal(
      *,
      mean: Union[float, ivy.NativeArray, ivy.Array] = 0.0,
      std: Union[float, ivy.NativeArray, ivy.Array] = 1.0,
      shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None,
      dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None,
      seed: Optional[int] = None,
      device: Optional[Union[ivy.Device, ivy.NativeDevice]] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Draws samples from a normal distribution.
  
      Parameters
      ----------
      mean
          The mean of the normal distribution to sample from. Default is ``0.0``.
      std
          The standard deviation of the normal distribution to sample from.
          Must be non-negative. Default is ``1.0``.
      shape
          If the given shape is, e.g ``(m, n, k)``, then ``m * n * k`` samples are drawn.
          Can only be specified when ``mean`` and ``std`` are numeric values, else
          exception will be raised.
          Default is ``None``, where a single value is returned.
      dtype
          output array data type. If ``dtype`` is ``None``, the output array data
          type will be the default floating-point data type. Default ``None``
      seed
          A python integer. Used to create a random seed distribution
      device
          device on which to create the array 'cuda:0', 'cuda:1', 'cpu' etc.
          (Default value = None).
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
       ret
          Drawn samples from the parameterized normal distribution.
  
      Examples
      --------
      >>> ivy.random_normal()
      ivy.array(-0.22346112)
  
      >>> ivy.random_normal(shape=3)
      ivy.array([-0.73  ,  0.0922, -0.515 ])
  
      >>> ivy.random_normal(shape=(2, 3), seed=42)
      ivy.array([[ 0.49671414, -0.1382643 ,  0.64768857],
             [ 1.5230298 , -0.23415337, -0.23413695]])
  
      >>> ivy.random_normal(mean=3.0, std=6.0)
      ivy.array(4.9213753)
  
      >>> ivy.random_normal(mean=1.0, std=2.0, shape=(2,1))
      ivy.array([[2.19],
                 [2.78]])
  
      >>> z = ivy.zeros(())
      >>> ivy.random_normal(mean=1.0, std=2.0, out=z)
      ivy.array(0.12818667)
  
      >>> ivy.random_normal(mean=1.0, std=2.0, shape=(2,2), device='cpu')
      ivy.array([[ 2.91 ,  1.3  ],
                 [ 3.37 , -0.799]])
  
      >>> ivy.random_normal(mean=1.0, std=2.0, shape=(2,2), device='cpu',
      ...                   dtype='int32')
      ivy.array([[ 0, -1],
                 [ 0,  3]])
  
      >>> z = ivy.zeros((1,2))
      >>> ivy.random_normal(mean=1.0, std=2.0, shape=(1,2), device='cpu',
      ...                   dtype='float64', out=z)
      ivy.array([[-2.01, -1.95]])
  
      >>> x = ivy.array([4.8, 5.6])
      >>> y = ivy.array([9.8, 7.4])
      >>> ivy.random_normal(mean=x, std=y)
      ivy.array([ 4.43 , -0.469])
  
      >>> z = ivy.zeros((2,))
      >>> ivy.random_normal(mean=x, std=y, out=z)
      ivy.array([0.287, 8.55 ])
  
      >>> ivy.random_normal(mean=x, std=y, device='cpu')
      ivy.array([18.9, 15.2])
  
      >>> ivy.random_normal(mean=x, std=y, device='cpu', dtype='float64')
      ivy.array([-4.1   , -0.0366])
  
      >>> z = ivy.zeros((2,))
      >>> ivy.random_normal(mean=x, std=y, device='cpu', dtype='float64', out=z)
      ivy.array([12.4, 11. ])
      """
      return ivy.current_backend().random_normal(
          mean=mean,
          std=std,
          shape=shape,
          dtype=dtype,
          seed=seed,
          device=device,
          out=out,
      )
  
file_path: ivy/ivy/functional/ivy/random.py
imports: from typing import Optional, Union
  import ivy
  from ivy.func_wrapper import handle_array_function, infer_dtype, handle_out_argument, to_native_arrays_and_back, inputs_to_native_shapes, handle_nestable, handle_device, handle_backend_invalid
  from ivy.utils.backend import backend_stack
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 6 for calling a global function with example usage: random_normal() and returns: ivy