def print_aggregate()

in monte_carlo_tests/monte_carlo_statsmodels.py [0:0]

• 77 lines of code
• 4 McCabe index (conditional complexity)

def print_aggregate(mean_coverage, std_coverage, q_coverage, file_gen=lambda: None):
    for key, cov in mean_coverage.items():
        print(key, file=file_gen())
        with np.printoptions(formatter={'float': '{:.2f}'.format}, suppress=True):
            print("Mean Coef (True, RMSE) \t (Coverage, Mean Length) \t Mean StdErr (True, RMSE)\t "
                  "[Mean Lower (std), Mean Upper (std)]\t (True Quantiles)\r\n{}".format(
                      "\r\n".join(["{:.2f} ({:.2f}, {:.2f}) \t ({:.2f}, {:.2f}) \t {:.2f} ({:.2f}, {:.2f}) "
                                   " \t [{:.2f} ({:.2f}), {:.2f} ({:.2f})] \t {}".format(est,
                                                                                         true,
                                                                                         np.sqrt(
                                                                                             sqerr),
                                                                                         coverage,
                                                                                         length,
                                                                                         stderr,
                                                                                         true_stderr,
                                                                                         np.sqrt(
                                                                                             std_stderr**2 +
                                                                                             (stderr -
                                                                                              true_stderr)**2),
                                                                                         lower,
                                                                                         std_lower,
                                                                                         upper,
                                                                                         std_upper,
                                                                                         true_qs)
                                   for (est, true, sqerr, coverage, length, stderr, std_stderr,
                                        true_stderr, lower, std_lower, upper, std_upper, true_qs)
                                   in zip(cov['coef'],
                                          cov['true_coef'],
                                          cov['coef_sqerror'],
                                          cov['coef_cov'],
                                          cov['coef_length'],
                                          cov['coef_stderr'],
                                          std_coverage[key]['coef_stderr'],
                                          std_coverage[key]['coef'],
                                          cov['coef_lower'],
                                          std_coverage[key]['coef_lower'],
                                          cov['coef_upper'],
                                          std_coverage[key]['coef_upper'],
                                          q_coverage[key]['coef'].T)])), file=file_gen())
            print("Effect SqError: {}".format(np.mean(cov['effect_sqerror'])), file=file_gen())

            print("Point\t Mean Coef (True, RMSE) \t (Coverage, Mean Length)\t Mean StdErr (True, RMSE)\t "
                  " [Mean Lower (std), Mean Upper (std)]\t (True Quantiles)\r\n{}".format(
                      "\r\n".join(["{}\t {:.2f} ({:.2f}, {:.2f}) \t ({:.2f}, {:.2f}) \t {:.2f} ({:.2f}, {:.2f}) \t "
                                   "[{:.2f} ({:.2f}), {:.2f} ({:.2f})] \t "
                                   "{}".format(','.join(x.astype(int).astype(str)),
                                               est,
                                               true,
                                               np.sqrt(
                                       sqerr),
                                       coverage,
                                       length,
                                       stderr,
                                       true_stderr,
                                       np.sqrt(
                                       std_stderr**2 + (stderr - true_stderr)**2),
                                       lower,
                                       std_lower,
                                       upper,
                                       std_upper,
                                       true_qs)
                                   for (x, est, true, sqerr, coverage, length, stderr, std_stderr,
                                        true_stderr, lower, std_lower, upper, std_upper, true_qs)
                                   in zip(cov['x_test'],
                                          cov['effect'],
                                          cov['true_effect'],
                                          cov['effect_sqerror'],
                                          cov['effect_cov'],
                                          cov['effect_length'],
                                          cov['effect_stderr'],
                                          std_coverage[key]['effect_stderr'],
                                          std_coverage[key]['effect'],
                                          cov['effect_lower'],
                                          std_coverage[key]['effect_lower'],
                                          cov['effect_upper'],
                                          std_coverage[key]['effect_upper'],
                                          q_coverage[key]['effect'].T)])), file=file_gen())
            print("Effect SqError: {}".format(np.mean(cov['effect_sqerror'])), file=file_gen())