docs: def sample(self, initial_pos, num_adapt, num_samples, stepsize=None, return_type='dataframe'):
          """
          Returns samples using No U Turn Sampler with dual averaging
  
          Parameters
          ----------
          initial_pos: A 1d array like object
              Vector representing values of parameter position, the starting
              state in markov chain.
  
          num_adapt: int
              The number of interations to run the adaptation of stepsize
  
          num_samples: int
              Number of samples to be generated
  
          stepsize: float , defaults to None
              The stepsize for proposing new values of position and momentum in simulate_dynamics
              If None, then will be choosen suitably
  
          return_type: string (dataframe | recarray)
              Return type for samples, either of 'dataframe' or 'recarray'.
              Defaults to 'dataframe'
  
          Returns
          -------
          sampled: A pandas.DataFrame or a numpy.recarray object depending upon return_type argument
  
  
          Examples
          ---------
          >>> from pgmpy.sampling import NoUTurnSamplerDA as NUTSda, GradLogPDFGaussian, LeapFrog
          >>> from pgmpy.factors.continuous import GaussianDistribution as JGD
          >>> import numpy as np
          >>> mean = np.array([10, -13])
          >>> covariance = np.array([[16, -3], [-3, 13]])
          >>> model = JGD(['x', 'y'], mean, covariance)
          >>> sampler = NUTSda(model=model, grad_log_pdf=GradLogPDFGaussian, simulate_dynamics=LeapFrog)
          >>> samples = sampler.sample(initial_pos=np.array([12, -4]), num_adapt=10, num_samples=10,
          ...                          stepsize=0.1, return_type='dataframe')
          >>> samples
                     x          y
          0  12.000000  -4.000000
          1  11.864821  -3.696109
          2  10.546986  -4.892169
          3   8.526596 -21.555793
          4   8.526596 -21.555793
          5  11.343194  -6.353789
          6  -1.583269 -12.802931
          7  12.411957 -11.704859
          8  13.253336 -20.169492
          9  11.295901  -7.665058
          """
          initial_pos = _check_1d_array_object(initial_pos, 'initial_pos')
          _check_length_equal(initial_pos, self.model.variables, 'initial_pos', 'model.variables')
  
          if stepsize is None:
              stepsize = self._find_reasonable_stepsize(initial_pos)
  
          if num_adapt <= 1:
              return NoUTurnSampler(self.model, self.grad_log_pdf,
                                    self.simulate_dynamics).sample(initial_pos, num_samples, stepsize)
  
          mu = np.log(10.0 * stepsize)
          stepsize_bar = 1.0
          h_bar = 0.0
  
          types = [(var_name, 'float') for var_name in self.model.variables]
          samples = np.zeros(num_samples, dtype=types).view(np.recarray)
          samples[0] = tuple(initial_pos)
          position_m = initial_pos
  
          for i in range(1, num_samples):
  
              position_m, alpha, n_alpha = self._sample(position_m, stepsize)
              samples[i] = tuple(position_m)
  
              if i <= num_adapt:
                  stepsize, stepsize_bar, h_bar = self._adapt_params(stepsize, stepsize_bar, h_bar, mu,
                                                                     i, alpha, n_alpha)
              else:
                  stepsize = stepsize_bar
  
          return _return_samples(return_type, samples)