class_docstr: Class to hold results from fitting an VARMAX model.
  
  Parameters
  ----------
  model : VARMAX instance
      The fitted model instance
  
  Attributes
  ----------
  specification : dictionary
      Dictionary including all attributes from the VARMAX model instance.
  coefficient_matrices_var : ndarray
      Array containing autoregressive lag polynomial coefficient matrices,
      ordered from lowest degree to highest.
  coefficient_matrices_vma : ndarray
      Array containing moving average lag polynomial coefficients,
      ordered from lowest degree to highest.
  
  See Also
  --------
  statsmodels.tsa.statespace.kalman_filter.FilterResults
  statsmodels.tsa.statespace.mlemodel.MLEResults
code: def summary(self, alpha=0.05, start=None, separate_params=True):
      from statsmodels.iolib.summary import summary_params
  
      # Create the model name
      spec = self.specification
      if spec.k_ar > 0 and spec.k_ma > 0:
          model_name = "VARMA"
          order = "({},{})".format(spec.k_ar, spec.k_ma)
      elif spec.k_ar > 0:
          model_name = "VAR"
          order = "(%s)" % (spec.k_ar)
      else:
          model_name = "VMA"
          order = "(%s)" % (spec.k_ma)
      if spec.k_exog > 0:
          model_name += "X"
      model_name = [model_name + order]
  
      if spec.k_trend > 0:
          model_name.append("intercept")
  
      if spec.measurement_error:
          model_name.append("measurement error")
  
      summary = super().summary(
          alpha=alpha,
          start=start,
          model_name=model_name,
          display_params=not separate_params,
      )
  
      if separate_params:
          indices = np.arange(len(self.params))
  
          def make_table(self, mask, title, strip_end=True):
              res = (
                  self,
                  self.params[mask],
                  self.bse[mask],
                  self.zvalues[mask],
                  self.pvalues[mask],
                  self.conf_int(alpha)[mask],
              )
  
              param_names = []
              for name in np.array(self.data.param_names)[
                  mask
              ].tolist():
                  if strip_end:
                      param_name = ".".join(name.split(".")[:-1])
                  else:
                      param_name = name
                  if name in self.fixed_params:
                      param_name = "%s (fixed)" % param_name
                  param_names.append(param_name)
  
              return summary_params(
                  res,
                  yname=None,
                  xname=param_names,
                  alpha=alpha,
                  use_t=False,
                  title=title,
              )
  
          # Add parameter tables for each endogenous variable
          k_endog = self.model.k_endog
          k_ar = self.model.k_ar
          k_ma = self.model.k_ma
          k_trend = self.model.k_trend
          k_exog = self.model.k_exog
          endog_masks = []
          for i in range(k_endog):
              masks = []
              offset = 0
  
              # 1. Intercept terms
              if k_trend > 0:
                  masks.append(
                      np.arange(i, i + k_endog * k_trend, k_endog)
                  )
                  offset += k_endog * k_trend
  
              # 2. AR terms
              if k_ar > 0:
                  start = i * k_endog * k_ar
                  end = (i + 1) * k_endog * k_ar
                  masks.append(offset + np.arange(start, end))
                  offset += k_ar * k_endog**2
  
              # 3. MA terms
              if k_ma > 0:
                  start = i * k_endog * k_ma
                  end = (i + 1) * k_endog * k_ma
                  masks.append(offset + np.arange(start, end))
                  offset += k_ma * k_endog**2
  
              # 4. Regression terms
              if k_exog > 0:
                  masks.append(
                      offset + np.arange(i * k_exog, (i + 1) * k_exog)
                  )
                  offset += k_endog * k_exog
  
              # 5. Measurement error variance terms
              if self.model.measurement_error:
                  masks.append(
                      np.array(self.model.k_params - i - 1, ndmin=1)
                  )
  
              # Create the table
              mask = np.concatenate(masks)
              endog_masks.append(mask)
  
              endog_names = self.model.endog_names
              if not isinstance(endog_names, list):
                  endog_names = [endog_names]
              title = "Results for equation %s" % endog_names[i]
              table = make_table(self, mask, title)
              summary.tables.append(table)
  
          # State covariance terms
          state_cov_mask = np.arange(len(self.params))[
              self.model._params_state_cov
          ]
          table = make_table(
              self,
              state_cov_mask,
              "Error covariance matrix",
              strip_end=False,
          )
          summary.tables.append(table)
  
          # Add a table for all other parameters
          masks = []
          for m in (endog_masks, [state_cov_mask]):
              m = np.array(m).flatten()
              if len(m) > 0:
                  masks.append(m)
          masks = np.concatenate(masks)
          inverse_mask = np.array(
              list(set(indices).difference(set(masks)))
          )
          if len(inverse_mask) > 0:
              table = make_table(
                  self,
                  inverse_mask,
                  "Other parameters",
                  strip_end=False,
              )
              summary.tables.append(table)
  
      return summary
  
imports: import contextlib
  from warnings import warn
  import pandas
  import numpy
  from statsmodels.compat.pandas import Appender
  from statsmodels.tools.tools import Bunch
  from statsmodels.tools.data import _is_using_pandas
  from statsmodels.tsa.vector_ar import var_model
  import statsmodels.base.wrapper
  from statsmodels.tools.sm_exceptions import EstimationWarning
  from .kalman_filter import INVERT_UNIVARIATE, SOLVE_LU
  from .mlemodel import MLEModel, MLEResults, MLEResultsWrapper
  from .initialization import Initialization
  from .tools import is_invertible, concat, prepare_exog, constrain_stationary_multivariate, unconstrain_stationary_multivariate, prepare_trend_spec, prepare_trend_data
label_desc: Use image node_id 8 for calling the VARMAXResults obj's underlying member method code with example usage: obj.summary(alpha, start, separate_params) and returns: summary, summary_params