code: def plot_dot(
      values,
      binwidth,
      dotsize,
      stackratio,
      hdi_prob,
      quartiles,
      rotated,
      dotcolor,
      intervalcolor,
      markersize,
      markercolor,
      marker,
      figsize,
      linewidth,
      point_estimate,
      nquantiles,
      point_interval,
      ax,
      show,
      backend_kwargs,
      plot_kwargs,
  ):
      """Matplotlib dotplot."""
      if backend_kwargs is None:
          backend_kwargs = {}
  
      backend_kwargs = {**backend_kwarg_defaults(), **backend_kwargs}
  
      backend_kwargs.setdefault("figsize", figsize)
      backend_kwargs["squeeze"] = True
  
      (
          figsize,
          _,
          _,
          _,
          auto_linewidth,
          auto_markersize,
      ) = _scale_fig_size(figsize, None)
  
      if plot_kwargs is None:
          plot_kwargs = {}
          plot_kwargs.setdefault("color", dotcolor)
  
      if linewidth is None:
          linewidth = auto_linewidth
  
      if markersize is None:
          markersize = auto_markersize
  
      if ax is None:
          fig_manager = _pylab_helpers.Gcf.get_active()
          if fig_manager is not None:
              ax = fig_manager.canvas.figure.gca()
          else:
              _, ax = create_axes_grid(
                  1,
                  backend_kwargs=backend_kwargs,
              )
  
      if point_interval:
          ax = plot_point_interval(
              ax,
              values,
              point_estimate,
              hdi_prob,
              quartiles,
              linewidth,
              markersize,
              markercolor,
              marker,
              rotated,
              intervalcolor,
              "matplotlib",
          )
  
      if nquantiles > values.shape[0]:
          warnings.warn(
              "nquantiles must be less than or equal to the number of data points",
              UserWarning,
          )
          nquantiles = values.shape[0]
      else:
          qlist = np.linspace(
              1 / (2 * nquantiles), 1 - 1 / (2 * nquantiles), nquantiles
          )
          values = np.quantile(values, qlist)
  
      if binwidth is None:
          binwidth = math.sqrt(
              (values[-1] - values[0] + 1) ** 2
              / (2 * nquantiles * np.pi)
          )
  
      ## Wilkinson's Algorithm
      stack_locs, stack_count = wilkinson_algorithm(values, binwidth)
      x, y = layout_stacks(
          stack_locs, stack_count, binwidth, stackratio, rotated
      )
  
      for x_i, y_i in zip(x, y):
          dot = plt.Circle(
              (x_i, y_i), dotsize * binwidth / 2, **plot_kwargs
          )
          ax.add_patch(dot)
  
      if rotated:
          ax.tick_params(bottom=False, labelbottom=False)
      else:
          ax.tick_params(left=False, labelleft=False)
  
      ax.set_aspect("equal", adjustable="datalim")
      ax.autoscale()
  
      if backend_show(show):
          plt.show()
  
      return ax
  
file_path: arviz/arviz/plots/backends/matplotlib/dotplot.py
imports: import math
  import warnings
  import numpy
  import matplotlib.pyplot
  from matplotlib import _pylab_helpers
  from ...plot_utils import _scale_fig_size
  from .None import backend_kwarg_defaults, create_axes_grid, backend_show
  from ...plot_utils import plot_point_interval
  from ...dotplot import wilkinson_algorithm, layout_stacks
label_desc: Use image node_id 1 for calling a global function with example usage: plot_dot(values, binwidth, dotsize, stackratio, hdi_prob, quartiles, rotated, dotcolor, intervalcolor, markersize, markercolor, marker, figsize, linewidth, point_estimate, nquantiles, point_interval, ax, show, backend_kwargs, plot_kwargs) and returns: ax