class_docstr: A multivariate normal random variable.
  
  The `mean` keyword specifies the mean. The `cov` keyword specifies the
  covariance matrix.
  
  Methods
  -------
  ``pdf(x, mean=None, cov=1, allow_singular=False)``
      Probability density function.
  ``logpdf(x, mean=None, cov=1, allow_singular=False)``
      Log of the probability density function.
  ``cdf(x, mean=None, cov=1, allow_singular=False, maxpts=1000000*dim, abseps=1e-5, releps=1e-5)``
      Cumulative distribution function.
  ``logcdf(x, mean=None, cov=1, allow_singular=False, maxpts=1000000*dim, abseps=1e-5, releps=1e-5)``
      Log of the cumulative distribution function.
  ``rvs(mean=None, cov=1, size=1, random_state=None)``
      Draw random samples from a multivariate normal distribution.
  ``entropy()``
      Compute the differential entropy of the multivariate normal.
  
  Parameters
  ----------
  x : array_like
      Quantiles, with the last axis of `x` denoting the components.
  %(_mvn_doc_default_callparams)s
  %(_doc_random_state)s
  
  Alternatively, the object may be called (as a function) to fix the mean
  and covariance parameters, returning a "frozen" multivariate normal
  random variable:
  
  rv = multivariate_normal(mean=None, cov=1, allow_singular=False)
      - Frozen object with the same methods but holding the given
        mean and covariance fixed.
  
  Notes
  -----
  %(_mvn_doc_callparams_note)s
  
  The covariance matrix `cov` must be a (symmetric) positive
  semi-definite matrix. The determinant and inverse of `cov` are computed
  as the pseudo-determinant and pseudo-inverse, respectively, so
  that `cov` does not need to have full rank.
  
  The probability density function for `multivariate_normal` is
  
  .. math::
  
      f(x) = \frac{1}{\sqrt{(2 \pi)^k \det \Sigma}}
             \exp\left( -\frac{1}{2} (x - \mu)^T \Sigma^{-1} (x - \mu) \right),
  
  where :math:`\mu` is the mean, :math:`\Sigma` the covariance matrix,
  and :math:`k` is the dimension of the space where :math:`x` takes values.
  
  .. versionadded:: 0.14.0
  
  Examples
  --------
  >>> import matplotlib.pyplot as plt
  >>> from scipy.stats import multivariate_normal
  
  >>> x = np.linspace(0, 5, 10, endpoint=False)
  >>> y = multivariate_normal.pdf(x, mean=2.5, cov=0.5); y
  array([ 0.00108914,  0.01033349,  0.05946514,  0.20755375,  0.43939129,
          0.56418958,  0.43939129,  0.20755375,  0.05946514,  0.01033349])
  >>> fig1 = plt.figure()
  >>> ax = fig1.add_subplot(111)
  >>> ax.plot(x, y)
  
  The input quantiles can be any shape of array, as long as the last
  axis labels the components.  This allows us for instance to
  display the frozen pdf for a non-isotropic random variable in 2D as
  follows:
  
  >>> x, y = np.mgrid[-1:1:.01, -1:1:.01]
  >>> pos = np.dstack((x, y))
  >>> rv = multivariate_normal([0.5, -0.2], [[2.0, 0.3], [0.3, 0.5]])
  >>> fig2 = plt.figure()
  >>> ax2 = fig2.add_subplot(111)
  >>> ax2.contourf(x, y, rv.pdf(pos))
docstr: Infer dimensionality from mean or covariance matrix, ensure that
  mean and covariance are full vector resp. matrix.
docstr_tok: ["Infer","dimensionality","from","mean","or","covariance","matrix",",","ensure","that","mean","and","covariance","are","full","vector","resp",".","matrix","."]
code: def _process_parameters(self, dim, mean, cov):
      """
      Infer dimensionality from mean or covariance matrix, ensure that
      mean and covariance are full vector resp. matrix.
  
      """
  
      # Try to infer dimensionality
      if dim is None:
          if mean is None:
              if cov is None:
                  dim = 1
              else:
                  cov = np.asarray(cov, dtype=float)
                  if cov.ndim < 2:
                      dim = 1
                  else:
                      dim = cov.shape[0]
          else:
              mean = np.asarray(mean, dtype=float)
              dim = mean.size
      else:
          if not np.isscalar(dim):
              raise ValueError(
                  "Dimension of random variable must be " "a scalar."
              )
  
      # Check input sizes and return full arrays for mean and cov if
      # necessary
      if mean is None:
          mean = np.zeros(dim)
      mean = np.asarray(mean, dtype=float)
  
      if cov is None:
          cov = 1.0
      cov = np.asarray(cov, dtype=float)
  
      if dim == 1:
          mean.shape = (1,)
          cov.shape = (1, 1)
  
      if mean.ndim != 1 or mean.shape[0] != dim:
          raise ValueError(
              "Array 'mean' must be a vector of length %d." % dim
          )
      if cov.ndim == 0:
          cov = cov * np.eye(dim)
      elif cov.ndim == 1:
          cov = np.diag(cov)
      elif cov.ndim == 2 and cov.shape != (dim, dim):
          rows, cols = cov.shape
          if rows != cols:
              msg = (
                  "Array 'cov' must be square if it is two dimensional,"
                  " but cov.shape = %s." % str(cov.shape)
              )
          else:
              msg = (
                  "Dimension mismatch: array 'cov' is of shape %s,"
                  " but 'mean' is a vector of length %d."
              )
              msg = msg % (str(cov.shape), len(mean))
          raise ValueError(msg)
      elif cov.ndim > 2:
          raise ValueError(
              "Array 'cov' must be at most two-dimensional,"
              " but cov.ndim = %d" % cov.ndim
          )
  
      return dim, mean, cov
  
imports: import numpy
  import scipy.linalg
  from scipy._lib import doccer
  from scipy.special import gammaln
  from scipy._lib._util import check_random_state
  from scipy.stats import mvn
label_desc: Use image node_id 3 for calling the multivariate_normal_gen obj's underlying member method code with example usage: obj._process_parameters(dim, mean, cov) and returns: dim,  mean,  cov