'Return a summary of the estimation results.
Parameters
alpha : float 0 < `alpha` < 1, default 0.05
Significance level of the shown confidence intervals.
Returns
summary : :class:`statsmodels.iolib.summary.Summary`
A summary containing information about estimated parameters.'

def summary(self, alpha=0.05):

    from statsmodels.iolib.summary import summary_params
    summary = Summary()
    def make_table(self, params, std_err, t_values, p_values, conf_int, mask, names, title, strip_end=True):
        res = (self, params[mask], std_err[mask], t_values[mask], p_values[mask], conf_int[mask])
        param_names = [('.'.join(name.split('.')[:(-1)]) if strip_end else name) for name in np.array(names)[mask].tolist()]
        return summary_params(res, yname=None, xname=param_names, alpha=alpha, use_t=False, title=title)
    lagged_params_components = []
    stderr_lagged_params_components = []
    tvalues_lagged_params_components = []
    pvalues_lagged_params_components = []
    conf_int_lagged_params_components = []
    if (self.det_coef.size > 0):
        lagged_params_components.append(self.det_coef.flatten(order='F'))
        stderr_lagged_params_components.append(self.stderr_det_coef.flatten(order='F'))
        tvalues_lagged_params_components.append(self.tvalues_det_coef.flatten(order='F'))
        pvalues_lagged_params_components.append(self.pvalues_det_coef.flatten(order='F'))
        conf_int = self.conf_int_det_coef(alpha=alpha)
        lower = conf_int['lower'].flatten(order='F')
        upper = conf_int['upper'].flatten(order='F')
        conf_int_lagged_params_components.append(np.column_stack((lower, upper)))
    if ((self.k_ar - 1) > 0):
        lagged_params_components.append(self.gamma.flatten())
        stderr_lagged_params_components.append(self.stderr_gamma.flatten())
        tvalues_lagged_params_components.append(self.tvalues_gamma.flatten())
        pvalues_lagged_params_components.append(self.pvalues_gamma.flatten())
        conf_int = self.conf_int_gamma(alpha=alpha)
        lower = conf_int['lower'].flatten()
        upper = conf_int['upper'].flatten()
        conf_int_lagged_params_components.append(np.column_stack((lower, upper)))
    if (len(lagged_params_components) != 0):
        lagged_params = hstack(lagged_params_components)
        stderr_lagged_params = hstack(stderr_lagged_params_components)
        tvalues_lagged_params = hstack(tvalues_lagged_params_components)
        pvalues_lagged_params = hstack(pvalues_lagged_params_components)
        conf_int_lagged_params = vstack(conf_int_lagged_params_components)
        for i in range(self.neqs):
            masks = []
            offset = 0
            if ('co' in self.deterministic):
                masks.append((offset + np.array(i, ndmin=1)))
                offset += self.neqs
            if (self.seasons > 0):
                for _ in range((self.seasons - 1)):
                    masks.append((offset + np.array(i, ndmin=1)))
                    offset += self.neqs
            if ('lo' in self.deterministic):
                masks.append((offset + np.array(i, ndmin=1)))
                offset += self.neqs
            if (self.exog is not None):
                for _ in range(self.exog.shape[1]):
                    masks.append((offset + np.array(i, ndmin=1)))
                    offset += self.neqs
            if ((self.k_ar - 1) > 0):
                start = ((i * self.neqs) * (self.k_ar - 1))
                end = (((i + 1) * self.neqs) * (self.k_ar - 1))
                masks.append((offset + np.arange(start, end)))
            mask = np.concatenate(masks)
            eq_name = self.model.endog_names[i]
            title = ('Det.    terms    outside    the    coint.    relation    ' + ('&    lagged    endog.    parameters    for    equation    %s' % eq_name))
            table = make_table(self, lagged_params, stderr_lagged_params, tvalues_lagged_params, pvalues_lagged_params, conf_int_lagged_params, mask, self.model._lagged_param_names, title)
            summary.tables.append(table)
    a = self.alpha.flatten()
    se_a = self.stderr_alpha.flatten()
    t_a = self.tvalues_alpha.flatten()
    p_a = self.pvalues_alpha.flatten()
    ci_a = self.conf_int_alpha(alpha=alpha)
    lower = ci_a['lower'].flatten()
    upper = ci_a['upper'].flatten()
    ci_a = np.column_stack((lower, upper))
    a_names = self.model._load_coef_param_names
    alpha_masks = []
    for i in range(self.neqs):
        if (self.coint_rank > 0):
            start = (i * self.coint_rank)
            end = (start + self.coint_rank)
            mask = np.arange(start, end)
        alpha_masks.append(mask)
        eq_name = self.model.endog_names[i]
        title = ('Loading    coefficients    (alpha)    for    equation    %s' % eq_name)
        table = make_table(self, a, se_a, t_a, p_a, ci_a, mask, a_names, title)
        summary.tables.append(table)
    coint_components = []
    stderr_coint_components = []
    tvalues_coint_components = []
    pvalues_coint_components = []
    conf_int_coint_components = []
    if (self.coint_rank > 0):
        coint_components.append(self.beta.T.flatten())
        stderr_coint_components.append(self.stderr_beta.T.flatten())
        tvalues_coint_components.append(self.tvalues_beta.T.flatten())
        pvalues_coint_components.append(self.pvalues_beta.T.flatten())
        conf_int = self.conf_int_beta(alpha=alpha)
        lower = conf_int['lower'].T.flatten()
        upper = conf_int['upper'].T.flatten()
        conf_int_coint_components.append(np.column_stack((lower, upper)))
    if (self.det_coef_coint.size > 0):
        coint_components.append(self.det_coef_coint.flatten())
        stderr_coint_components.append(self.stderr_det_coef_coint.flatten())
        tvalues_coint_components.append(self.tvalues_det_coef_coint.flatten())
        pvalues_coint_components.append(self.pvalues_det_coef_coint.flatten())
        conf_int = self.conf_int_det_coef_coint(alpha=alpha)
        lower = conf_int['lower'].flatten()
        upper = conf_int['upper'].flatten()
        conf_int_coint_components.append(np.column_stack((lower, upper)))
    coint = hstack(coint_components)
    stderr_coint = hstack(stderr_coint_components)
    tvalues_coint = hstack(tvalues_coint_components)
    pvalues_coint = hstack(pvalues_coint_components)
    conf_int_coint = vstack(conf_int_coint_components)
    coint_names = self.model._coint_param_names
    for i in range(self.coint_rank):
        masks = []
        offset = 0
        if (self.coint_rank > 0):
            start = (i * self.neqs)
            end = (start + self.neqs)
            masks.append((offset + np.arange(start, end)))
            offset += (self.neqs * self.coint_rank)
        if ('ci' in self.deterministic):
            masks.append((offset + np.array(i, ndmin=1)))
            offset += self.coint_rank
        if ('li' in self.deterministic):
            masks.append((offset + np.array(i, ndmin=1)))
            offset += self.coint_rank
        if (self.exog_coint is not None):
            for _ in range(self.exog_coint.shape[1]):
                masks.append((offset + np.array(i, ndmin=1)))
                offset += self.coint_rank
        mask = np.concatenate(masks)
        title = ('Cointegration    relations    for    ' + ('loading-coefficients-column    %d' % (i + 1)))
        table = make_table(self, coint, stderr_coint, tvalues_coint, pvalues_coint, conf_int_coint, mask, coint_names, title)
        summary.tables.append(table)
    return summary
