code: def runplot(
      results,
      span=None,
      logplot=False,
      kde=True,
      nkde=1000,
      color="blue",
      plot_kwargs=None,
      label_kwargs=None,
      lnz_error=True,
      lnz_truth=None,
      truth_color="red",
      truth_kwargs=None,
      max_x_ticks=8,
      max_y_ticks=3,
      use_math_text=True,
      mark_final_live=True,
      fig=None,
  ):
      """Plot live points, ln(likelihood), ln(weight), and ln(evidence) vs. ln(prior volume).
  
      Parameters
      ----------
      results : dynesty.results.Results instance
          dynesty.results.Results instance from a nested
          sampling run.
      span : iterable with shape (4,), optional
          A list where each element is either a length-2 tuple containing
          lower and upper bounds *or* a float from `(0., 1.]` giving the
          fraction below the maximum. If a fraction is provided,
          the bounds are chosen to be equal-tailed. An example would be::
  
              span = [(0., 10.), 0.001, 0.2, (5., 6.)]
  
          Default is `(0., 1.05 * max(data))` for each element.
      logplot : bool, optional
          Whether to plot the evidence on a log scale. Default is `False`.
      kde : bool, optional
          Whether to use kernel density estimation to estimate and plot
          the PDF of the importance weights as a function of log-volume
          (as opposed to the importance weights themselves). Default is
          `True`.
      nkde : int, optional
          The number of grid points used when plotting the kernel density
          estimate. Default is `1000`.
      color : str or iterable with shape (4,), optional
          A `~matplotlib`-style color (either a single color or a different
          value for each subplot) used when plotting the lines in each subplot.
          Default is `'blue'`.
      plot_kwargs : dict, optional
          Extra keyword arguments that will be passed to `plot`.
      label_kwargs : dict, optional
          Extra keyword arguments that will be sent to the
          `~matplotlib.axes.Axes.set_xlabel` and
          `~matplotlib.axes.Axes.set_ylabel` methods.
      lnz_error : bool, optional
          Whether to plot the 1, 2, and 3-sigma approximate error bars
          derived from the ln(evidence) error approximation over the course
          of the run. Default is True.
      lnz_truth : float, optional
          A reference value for the evidence that will be overplotted on the
          evidence subplot if provided.
      truth_color : str or iterable with shape (ndim,), optional
          A `~matplotlib`-style color used when plotting `lnz_truth`.
          Default is `'red'`.
      truth_kwargs : dict, optional
          Extra keyword arguments that will be used for plotting
          `lnz_truth`.
      max_x_ticks : int, optional
          Maximum number of ticks allowed for the x axis. Default is `8`.
      max_y_ticks : int, optional
          Maximum number of ticks allowed for the y axis. Default is `4`.
      use_math_text : bool, optional
          Whether the axis tick labels for very large/small exponents should be
          displayed as powers of 10 rather than using `e`. Default is `False`.
      mark_final_live : bool, optional
          Whether to indicate the final addition of recycled live points
          (if they were added to the resulting samples) using
          a dashed vertical line. Default is `True`.
      fig : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`), optional
          If provided, overplot the run onto the provided figure.
          Otherwise, by default an internal figure is generated.
  
      Returns
      -------
      runplot : (`~matplotlib.figure.Figure`, `~matplotlib.axes.Axes`)
          Output summary plot.
  
      """
      # Initialize values.
      if label_kwargs is None:
          label_kwargs = dict()
      if plot_kwargs is None:
          plot_kwargs = dict()
      if truth_kwargs is None:
          truth_kwargs = dict()
  
      # Set defaults.
      plot_kwargs["linewidth"] = plot_kwargs.get("linewidth", 5)
      plot_kwargs["alpha"] = plot_kwargs.get("alpha", 0.7)
      truth_kwargs["linestyle"] = truth_kwargs.get("linestyle", "solid")
      truth_kwargs["linewidth"] = truth_kwargs.get("linewidth", 3)
  
      # Extract results.
      niter = results["niter"]  # number of iterations
      logvol = results["logvol"]  # ln(prior volume)
      logl = results["logl"] - max(
          results["logl"]
      )  # ln(normalized likelihood)
      logwt = (
          results["logwt"] - results["logz"][-1]
      )  # ln(importance weight)
      logz = results["logz"]  # ln(evidence)
      logzerr = results["logzerr"]  # error in ln(evidence)
      weights = results["weights"]
      logzerr[~np.isfinite(logzerr)] = 0.0
      nsamps = len(logwt)  # number of samples
  
      # Check whether the run was "static" or "dynamic".
      try:
          nlive = results["samples_n"]
          mark_final_live = False
      except Exception:
          nlive = np.ones(niter) * results["nlive"]
          if nsamps - niter == results["nlive"]:
              nlive_final = np.arange(1, results["nlive"] + 1)[::-1]
              nlive = np.append(nlive, nlive_final)
  
      # Check if the final set of live points were added to the results.
      if mark_final_live:
          if nsamps - niter == results["nlive"]:
              live_idx = niter
          else:
              warnings.warn(
                  "The number of iterations and samples differ "
                  "by an amount that isn't the number of final "
                  "live points. `mark_final_live` has been disabled."
              )
              mark_final_live = False
  
      # Determine plotting bounds for each subplot.
      data = [
          nlive,
          np.exp(logl),
          weights,
          logz if logplot else np.exp(logz),
      ]
  
      kde = kde and (weights * len(logvol) > 0.1).sum() > 10
      if kde:
          try:
              # from scipy.ndimage import gaussian_filter as norm_kde
              from scipy.stats import gaussian_kde
  
              # Derive kernel density estimate.
              wt_kde = gaussian_kde(
                  resample_equal(-logvol, weights)
              )  # KDE
              logvol_new = np.linspace(
                  logvol[0], logvol[-1], nkde
              )  # resample
              data[2] = wt_kde.pdf(-logvol_new)  # evaluate KDE PDF
          except ImportError:
              kde = False
  
      if span is None:
          span = [(0.0, 1.05 * max(d)) for d in data]
          no_span = True
      else:
          no_span = False
      span = list(span)
      if len(span) != 4:
          raise ValueError(
              "More bounds provided in `span` than subplots!"
          )
      for i, _ in enumerate(span):
          try:
              ymin, ymax = span[i]
          except Exception:
              span[i] = (max(data[i]) * span[i], max(data[i]))
      if lnz_error and no_span:
          if logplot:
              zspan = (
                  logz[-1] - 10.3 * 3.0 * logzerr[-1],
                  logz[-1] + 1.3 * 3.0 * logzerr[-1],
              )
          else:
              zspan = (0.0, 1.05 * np.exp(logz[-1] + 3.0 * logzerr[-1]))
          span[3] = zspan
  
      # Setting up default plot layout.
      if fig is None:
          fig, axes = pl.subplots(4, 1, figsize=(16, 16))
          xspan = [(0.0, -min(logvol)) for _ax in axes]
          yspan = span
      else:
          fig, axes = fig
          try:
              axes.reshape(4, 1)
          except Exception:
              raise ValueError(
                  "Provided axes do not match the required shape "
                  "for plotting samples."
              )
          # If figure is provided, keep previous bounds if they were larger.
          xspan = [ax.get_xlim() for ax in axes]
          yspan = [ax.get_ylim() for ax in axes]
          # One exception: if the bounds are the plotting default `(0., 1.)`,
          # overwrite them.
          xspan = [
              t if t != (0.0, 1.0) else (None, None) for t in xspan
          ]
          yspan = [
              t if t != (0.0, 1.0) else (None, None) for t in yspan
          ]
  
      # Set up bounds for plotting.
      for i in range(4):
          if xspan[i][0] is None:
              xmin = None
          else:
              xmin = min(0.0, xspan[i][0])
          if xspan[i][1] is None:
              xmax = -min(logvol)
          else:
              xmax = max(-min(logvol), xspan[i][1])
          if yspan[i][0] is None:
              ymin = None
          else:
              ymin = min(span[i][0], yspan[i][0])
          if yspan[i][1] is None:
              ymax = span[i][1]
          else:
              ymax = max(span[i][1], yspan[i][1])
          axes[i].set_xlim([xmin, xmax])
          axes[i].set_ylim([ymin, ymax])
  
      # Plotting.
      labels = [
          "Live Points",
          "Likelihood\n(normalized)",
          "Importance\nWeight",
          "Evidence",
      ]
      if kde:
          labels[2] += " PDF"
  
      for i, d in enumerate(data):
          # Establish axes.
          ax = axes[i]
          # Set color(s)/colormap(s).
          if isinstance(color, str_type):
              c = color
          else:
              c = color[i]
          # Setup axes.
          if max_x_ticks == 0:
              ax.xaxis.set_major_locator(NullLocator())
          else:
              ax.xaxis.set_major_locator(MaxNLocator(max_x_ticks))
          if max_y_ticks == 0:
              ax.yaxis.set_major_locator(NullLocator())
          else:
              ax.yaxis.set_major_locator(MaxNLocator(max_y_ticks))
          # Label axes.
          sf = ScalarFormatter(useMathText=use_math_text)
          ax.yaxis.set_major_formatter(sf)
          ax.set_xlabel(r"$-\ln X$", **label_kwargs)
          ax.set_ylabel(labels[i], **label_kwargs)
          # Plot run.
          if logplot and i == 3:
              ax.plot(-logvol, d, color=c, **plot_kwargs)
              yspan = [ax.get_ylim() for _ax in axes]
          elif kde and i == 2:
              ax.plot(-logvol_new, d, color=c, **plot_kwargs)
          else:
              ax.plot(-logvol, d, color=c, **plot_kwargs)
          if i == 3 and lnz_error:
              if logplot:
                  mask = logz >= ax.get_ylim()[0] - 10
                  [
                      ax.fill_between(
                          -logvol[mask],
                          (logz + s * logzerr)[mask],
                          (logz - s * logzerr)[mask],
                          color=c,
                          alpha=0.2,
                      )
                      for s in range(1, 4)
                  ]
              else:
                  [
                      ax.fill_between(
                          -logvol,
                          np.exp(logz + s * logzerr),
                          np.exp(logz - s * logzerr),
                          color=c,
                          alpha=0.2,
                      )
                      for s in range(1, 4)
                  ]
          # Mark addition of final live points.
          if mark_final_live:
              ax.axvline(
                  -logvol[live_idx],
                  color=c,
                  ls="dashed",
                  lw=2,
                  **plot_kwargs,
              )
              if i == 0:
                  ax.axhline(
                      live_idx,
                      color=c,
                      ls="dashed",
                      lw=2,
                      **plot_kwargs,
                  )
          # Add truth value(s).
          if i == 3 and lnz_truth is not None:
              if logplot:
                  ax.axhline(
                      lnz_truth, color=truth_color, **truth_kwargs
                  )
              else:
                  ax.axhline(
                      np.exp(lnz_truth),
                      color=truth_color,
                      **truth_kwargs,
                  )
  
      return fig, axes
  
imports: from __future__ import print_function, division
  from six.moves import range
  import logging
  import types
  import warnings
  import numpy
  import matplotlib.pyplot
  from matplotlib.ticker import MaxNLocator, NullLocator
  from matplotlib.ticker import ScalarFormatter
  import scipy.stats
  import matplotlib.pyplot
  import numpy
  from .utils import resample_equal
  from .utils import quantile
  import corner
label_desc: Use image node_id 2 for calling a global function with example usage: runplot(results, span, logplot, kde, nkde, color, plot_kwargs, label_kwargs, lnz_error, lnz_truth, truth_color, truth_kwargs, max_x_ticks, max_y_ticks, use_math_text, mark_final_live, fig) and returns: fig,  axes