class_docstr: Runs one step of the elliptic slice sampler.
  
  Elliptical Slice Sampling is a Markov Chain Monte Carlo (MCMC) algorithm
  based, as stated in [Murray, 2010][1].
  
  Given `log_likelihood_fn` and `normal_sampler_fn`, the goal of Elliptical
  Slice Sampling is to sample from:
  
  ```none
  p(f) = N(f; 0, Sigma)L(f) / Z
  ```
  
  where:
    * `L = log_likelihood_fn`
    * `Sigma` is a covariance matrix.
    * Samples from `normal_sampler_fn` are distributed as `N(f; 0, Sigma)`.
    * `Z` is a normalizing constant.
  
  In other words, sampling from a posterior distribution that is proportional
  to a multivariate gaussian prior multiplied by some likelihood function.
  
  The `one_step` function can update multiple chains in parallel. It assumes
  that all leftmost dimensions of `current_state` index independent chain states
  (and are therefore updated independently). The output of
  `log_likelihood_fn(*current_state)` should sum log-probabilities across all
  event dimensions. Slices along the rightmost dimensions may have different
  target distributions; for example, `current_state[0, :]` could have a
  different target distribution from `current_state[1, :]`.
  These semantics are governed both by `log_likelihood_fn(*current_state)` and
  `normal_sampler_fn`.
  
  Note that the sampler only supports states where all components have a common
  dtype.
  
  ### Examples:
  
  #### Simple chain with warm-up.
  
  In this example we have the following model.
  
  ```none
    p(loc | loc0, scale0) ~ N(loc0, scale0)
    p(x | loc, sigma) ~ N(mu, sigma)
  ```
  
  What we would like to do is sample from `p(loc | x, loc0, scale0)`. In other
  words, given some data, we would like to infer the posterior distribution
  of the mean that generated that data point.
  
  We can use elliptical slice sampling here.
  
  ```python
    import tensorflow as tf
    import tensorflow_probability as tfp
    import numpy as np
  
    tfd = tfp.distributions
  
    dtype = np.float64
  
    # loc0 = 0, scale0 = 1
    normal_sampler_fn = lambda seed: return tfd.Normal(
        loc=dtype(0), scale=dtype(1)).sample(seed=seed)
  
    # We saw the following data.
    data_points = np.random.randn(20)
  
    # scale = 2.
    log_likelihood_fn = lambda state: return tf.reduce_sum(
        tfd.Normal(state, dtype(2.)).log_prob(data_points))
  
    kernel = tfp.mcmc.EllipticalSliceSampler(
        normal_sampler_fn=normal_sampler_fn,
        log_likelihood_fn=log_likelihood_fn,
        seed=1234)
  
    samples = tfp.mcmc.sample_chain(
        num_results=int(3e5),
        current_state=dtype(1),
        kernel=kernel,
        num_burnin_steps=1000,
        trace_fn=None,
        parallel_iterations=1)  # For determinism.
  
    sample_mean = tf.reduce_mean(samples, axis=0)
    sample_std = tf.sqrt(
      tf.reduce_mean(tf.squared_difference(samples, sample_mean),
                     axis=0))
  
    with tf.Session() as sess:
      [sample_mean, sample_std] = sess.run([sample_mean, sample_std])
  
    print("Sample mean: ", sample_mean)
    print("Sample Std: ", sample_std)
  ```
  
  ### References
  
  [1]: Ian Murray, Ryan P. Adams, David J.C. MacKay. Elliptical slice sampling.
       proceedings.mlr.press/v9/murray10a/murray10a.pdf
docstr: Returns `dict` of ``__init__`` arguments and their values.
docstr_tok: ["Returns","`","dict","`","of","``","__init__","``","arguments","and","their","values","."]
code: def parameters(self):
      """Returns `dict` of ``__init__`` arguments and their values."""
      return self._parameters
  
imports: import collections
  import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import samplers
  from tensorflow_probability.python.mcmc import kernel
  from tensorflow_probability.python.mcmc.internal import util
label_desc: Use image node_id 5 for calling the EllipticalSliceSampler obj's underlying member method code with example usage: obj.parameters() and returns: self