Includes all of the Statistical Accumulators Library

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::count > const count;
    }
    namespace impl {
      struct count_impl;
    }
    namespace tag {
      struct count;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::covariance< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::covariance< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::weighted_covariance< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::abstract_covariance > const covariance;
    }
    namespace impl {
      template<typename Sample, typename VariateType, typename VariateTag> 
        struct covariance_impl;
    }
    namespace tag {
      template<typename VariateType, typename VariateTag> struct covariance;
      struct abstract_covariance;
    }
  }
  namespace numeric {
    static op::outer_product const & outer_product;
    namespace functional {
      template<typename Left, typename Right, typename EnableIf = void> 
        struct outer_product_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct outer_product;

      template<typename Left, typename Right> 
        struct outer_product<Left, Right, std_vector_tag, std_vector_tag>;
    }
    namespace op {
      struct outer_product;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::density>;
    template<> struct feature_of<tag::weighted_density>;
    namespace extract {
      extractor< tag::density > const density;
    }
    namespace impl {
      template<typename Sample> struct density_impl;
    }
    namespace tag {
      struct density;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename Feature> struct as_feature<tag::error_of< Feature >>;
    template<typename Feature> 
      struct as_weighted_feature<tag::error_of< Feature >>;
    namespace extract {
    }
    namespace impl {
    }
    namespace tag {
      template<typename Feature> struct error_of;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace impl {
      template<typename Sample, typename Variance> struct error_of_mean_impl;
    }
    namespace tag {
      template<> struct error_of<mean>;
      template<> struct error_of<immediate_mean>;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::extended_p_square>;
    template<> struct feature_of<tag::weighted_extended_p_square>;
    namespace extract {
      extractor< tag::extended_p_square > const extended_p_square;
    }
    namespace impl {
      template<typename Sample> struct extended_p_square_impl;
    }
    namespace tag {
      struct extended_p_square;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::extended_p_square_quantile(linear)>;
    template<> struct as_feature<tag::extended_p_square_quantile(quadratic)>;
    template<> 
      struct as_feature<tag::weighted_extended_p_square_quantile(linear)>;
    template<> 
      struct as_feature<tag::weighted_extended_p_square_quantile(quadratic)>;
    template<> struct feature_of<tag::extended_p_square_quantile>;
    template<> struct feature_of<tag::extended_p_square_quantile_quadratic>;
    template<> struct as_weighted_feature<tag::extended_p_square_quantile>;
    template<> struct feature_of<tag::weighted_extended_p_square_quantile>;
    template<> 
      struct as_weighted_feature<tag::extended_p_square_quantile_quadratic>;
    template<> 
      struct feature_of<tag::weighted_extended_p_square_quantile_quadratic>;
    namespace extract {
      extractor< tag::extended_p_square_quantile > const extended_p_square_quantile;
      extractor< tag::extended_p_square_quantile_quadratic > const extended_p_square_quantile_quadratic;
      extractor< tag::weighted_extended_p_square_quantile > const weighted_extended_p_square_quantile;
      extractor< tag::weighted_extended_p_square_quantile_quadratic > const weighted_extended_p_square_quantile_quadratic;
    }
    namespace impl {
      template<typename Sample, typename Impl1, typename Impl2> 
        struct extended_p_square_quantile_impl;
    }
    namespace tag {
      struct extended_p_square_quantile;
      struct extended_p_square_quantile_quadratic;
      struct weighted_extended_p_square_quantile;
      struct weighted_extended_p_square_quantile_quadratic;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::kurtosis>;
    template<> struct feature_of<tag::weighted_kurtosis>;
    namespace extract {
      extractor< tag::kurtosis > const kurtosis;
    }
    namespace impl {
      template<typename Sample> struct kurtosis_impl;
    }
    namespace tag {
      struct kurtosis;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::max > const max;
    }
    namespace impl {
      template<typename Sample> struct max_impl;
    }
    namespace tag {
      struct max;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::mean(lazy)>;
    template<> struct as_feature<tag::mean(immediate)>;
    template<> struct as_feature<tag::mean_of_weights(lazy)>;
    template<> struct as_feature<tag::mean_of_weights(immediate)>;
    template<typename VariateType, typename VariateTag> 
      struct as_feature<tag::mean_of_variates< VariateType, VariateTag >(lazy)>;
    template<typename VariateType, typename VariateTag> 
      struct as_feature<tag::mean_of_variates< VariateType, VariateTag >(immediate)>;
    template<> struct feature_of<tag::immediate_mean>;
    template<> struct feature_of<tag::immediate_mean_of_weights>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::immediate_mean_of_variates< VariateType, VariateTag >>;
    template<> struct as_weighted_feature<tag::mean>;
    template<> struct feature_of<tag::weighted_mean>;
    template<> struct as_weighted_feature<tag::immediate_mean>;
    template<> struct feature_of<tag::immediate_weighted_mean>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::mean_of_variates< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::weighted_mean_of_variates< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::immediate_mean_of_variates< VariateType, VariateTag >>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::immediate_weighted_mean_of_variates< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::mean > const mean;
      extractor< tag::mean_of_weights > const mean_of_weights;
    }
    namespace impl {
      template<typename Sample, typename SumFeature> struct mean_impl;
      template<typename Sample, typename Tag> struct immediate_mean_impl;
    }
    namespace tag {
      struct mean;
      struct immediate_mean;
      struct mean_of_weights;
      struct immediate_mean_of_weights;
      template<typename VariateType, typename VariateTag> struct mean_of_variates;
      template<typename VariateType, typename VariateTag> 
        struct immediate_mean_of_variates;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::median(with_p_square_quantile)>;
    template<> struct as_feature<tag::median(with_density)>;
    template<> 
      struct as_feature<tag::median(with_p_square_cumulative_distribution)>;
    template<> struct feature_of<tag::with_density_median>;
    template<> 
      struct feature_of<tag::with_p_square_cumulative_distribution_median>;
    template<> struct as_weighted_feature<tag::median>;
    template<> struct feature_of<tag::weighted_median>;
    template<> struct as_weighted_feature<tag::with_density_median>;
    template<> struct feature_of<tag::with_density_weighted_median>;
    template<> 
      struct as_weighted_feature<tag::with_p_square_cumulative_distribution_median>;
    template<> 
      struct feature_of<tag::with_p_square_cumulative_distribution_weighted_median>;
    namespace extract {
      extractor< tag::median > const median;
      extractor< tag::with_density_median > const with_density_median;
      extractor< tag::with_p_square_cumulative_distribution_median > const with_p_square_cumulative_distribution_median;
    }
    namespace impl {
      template<typename Sample> struct median_impl;
      template<typename Sample> struct with_density_median_impl;
      template<typename Sample> 
        struct with_p_square_cumulative_distribution_median_impl;
    }
    namespace tag {
      struct median;
      struct with_density_median;
      struct with_p_square_cumulative_distribution_median;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::min > const min;
    }
    namespace impl {
      template<typename Sample> struct min_impl;
    }
    namespace tag {
      struct min;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<int N> struct as_weighted_feature<tag::moment< N >>;
    template<int N> struct feature_of<tag::weighted_moment< N >>;
    namespace extract {
    }
    namespace impl {
      template<typename N, typename Sample> struct moment_impl;
    }
    namespace tag {
      template<int N> struct moment;
    }
  }
  namespace numeric {
  }
}

namespace boost {
  namespace accumulators {
    template<> 
      struct as_weighted_feature<tag::p_square_cumulative_distribution>;
    template<> 
      struct feature_of<tag::weighted_p_square_cumulative_distribution>;
    namespace extract {
      extractor< tag::p_square_cumulative_distribution > const p_square_cumulative_distribution;
    }
    namespace impl {
      template<typename Sample> struct p_square_cumulative_distribution_impl;
    }
    namespace tag {
      struct p_square_cumulative_distribution;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::p_square_quantile>;
    template<> struct feature_of<tag::weighted_p_square_quantile>;
    namespace extract {
      extractor< tag::p_square_quantile > const p_square_quantile;
      extractor< tag::p_square_quantile_for_median > const p_square_quantile_for_median;
    }
    namespace impl {
      template<typename Sample, typename Impl> struct p_square_quantile_impl;
    }
    namespace tag {
      struct p_square_quantile;
      struct p_square_quantile_for_median;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::peaks_over_threshold< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::peaks_over_threshold< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct feature_of<tag::peaks_over_threshold< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::peaks_over_threshold_prob< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::peaks_over_threshold< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_peaks_over_threshold< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::peaks_over_threshold_prob< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_peaks_over_threshold_prob< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_peaks_over_threshold > const peaks_over_threshold;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> 
        struct peaks_over_threshold_impl;
      template<typename Sample, typename LeftRight> 
        struct peaks_over_threshold_prob_impl;
    }
    namespace tag {
      template<typename LeftRight> struct peaks_over_threshold;
      template<typename LeftRight> struct peaks_over_threshold_prob;
      struct abstract_peaks_over_threshold;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::pot_quantile< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::pot_quantile< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_quantile< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_quantile< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_quantile_prob< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_quantile_prob< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_quantile_prob< LeftRight >>;
    namespace impl {
      template<typename Sample, typename Impl, typename LeftRight> 
        struct pot_quantile_impl;
    }
    namespace tag {
      template<typename LeftRight> struct pot_quantile;
      template<typename LeftRight> struct pot_quantile_prob;
      template<typename LeftRight> struct weighted_pot_quantile;
      template<typename LeftRight> struct weighted_pot_quantile_prob;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct as_feature<tag::pot_tail_mean< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::pot_tail_mean< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_tail_mean< LeftRight >(with_threshold_value)>;
    template<typename LeftRight> 
      struct as_feature<tag::weighted_pot_tail_mean< LeftRight >(with_threshold_probability)>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::pot_tail_mean_prob< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::pot_tail_mean_prob< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_pot_tail_mean_prob< LeftRight >>;
    namespace impl {
      template<typename Sample, typename Impl, typename LeftRight> 
        struct pot_tail_mean_impl;
    }
    namespace tag {
      template<typename LeftRight> struct pot_tail_mean;
      template<typename LeftRight> struct pot_tail_mean_prob;
      template<typename LeftRight> struct weighted_pot_tail_mean;
      template<typename LeftRight> struct weighted_pot_tail_mean_prob;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::skewness>;
    template<> struct feature_of<tag::weighted_skewness>;
    namespace extract {
      extractor< tag::skewness > const skewness;
    }
    namespace impl {
      template<typename Sample> struct skewness_impl;
    }
    namespace tag {
      struct skewness;
    }
  }
}

Contains the stats<> template.

namespace boost {
  namespace accumulators {
    template<typename Stat1, typename Stat2, ... > struct stats;
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_weighted_feature<tag::sum>;
    template<> struct feature_of<tag::weighted_sum>;
    template<typename VariateType, typename VariateTag> 
      struct feature_of<tag::sum_of_variates< VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::sum > const sum;
      extractor< tag::sum_of_weights > const sum_of_weights;
      extractor< tag::abstract_sum_of_variates > const sum_of_variates;
    }
    namespace impl {
      template<typename Sample, typename Tag> struct sum_impl;
    }
    namespace tag {
      struct sum;
      struct sum_of_weights;
      template<typename VariateType, typename VariateTag> struct sum_of_variates;
      struct abstract_sum_of_variates;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename T> struct tail_cache_size_named_arg;

    template<> struct tail_cache_size_named_arg<left>;
    template<> struct tail_cache_size_named_arg<right>;
    template<typename LeftRight> struct feature_of<tag::tail< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_tail > const tail;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> struct tail_impl;
    }
    namespace tag {
      template<typename LeftRight> struct tail;
      struct abstract_tail;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct feature_of<tag::coherent_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::non_coherent_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::non_coherent_tail_mean< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::non_coherent_weighted_tail_mean< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_non_coherent_tail_mean > const non_coherent_tail_mean;
      extractor< tag::tail_mean > const coherent_tail_mean;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> 
        struct coherent_tail_mean_impl;
      template<typename Sample, typename LeftRight> 
        struct non_coherent_tail_mean_impl;
    }
    namespace tag {
      template<typename LeftRight> struct coherent_tail_mean;
      template<typename LeftRight> struct non_coherent_tail_mean;
      struct abstract_non_coherent_tail_mean;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename LeftRight> 
      struct feature_of<tag::tail_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct as_weighted_feature<tag::tail_quantile< LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::weighted_tail_quantile< LeftRight >>;
    namespace extract {
      extractor< tag::quantile > const tail_quantile;
    }
    namespace impl {
      template<typename Sample, typename LeftRight> struct tail_quantile_impl;
    }
    namespace tag {
      template<typename LeftRight> struct tail_quantile;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename VariateType, typename VariateTag, typename LeftRight> 
      struct feature_of<tag::tail_variate< VariateType, VariateTag, LeftRight >>;
    template<typename LeftRight> 
      struct feature_of<tag::tail_weights< LeftRight >>;
    namespace extract {
      extractor< tag::abstract_tail_variate > const tail_variate;
      extractor< tag::abstract_tail_weights > const tail_weights;
    }
    namespace impl {
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct tail_variate_impl;
    }
    namespace tag {
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct tail_variate;
      struct abstract_tail_variate;
      template<typename LeftRight> struct tail_weights;
      struct abstract_tail_weights;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<tag::tail_variate_means< LeftRight, VariateType, VariateTag >(absolute)>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<tag::tail_variate_means< LeftRight, VariateType, VariateTag >(relative)>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::absolute_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::relative_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::absolute_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::absolute_weighted_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_weighted_feature<tag::relative_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<tag::relative_weighted_tail_variate_means< LeftRight, VariateType, VariateTag >>;
    namespace extract {
      extractor< tag::abstract_absolute_tail_variate_means > const tail_variate_means;
      extractor< tag::abstract_relative_tail_variate_means > const relative_tail_variate_means;
    }
    namespace impl {
      template<typename Sample, typename Impl, typename LeftRight, 
               typename VariateTag> 
        struct tail_variate_means_impl;
    }
    namespace tag {
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct absolute_tail_variate_means;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct relative_tail_variate_means;
      struct abstract_absolute_tail_variate_means;
      struct abstract_relative_tail_variate_means;
    }
  }
}

namespace boost {
  namespace accumulators {
    template<> struct as_feature<tag::variance(lazy)>;
    template<> struct as_feature<tag::variance(immediate)>;
    template<> struct feature_of<tag::lazy_variance>;
    template<> struct as_weighted_feature<tag::variance>;
    template<> struct feature_of<tag::weighted_variance>;
    template<> struct as_weighted_feature<tag::lazy_variance>;
    template<> struct feature_of<tag::lazy_weighted_variance>;
    namespace extract {
      extractor< tag::lazy_variance > const lazy_variance;
      extractor< tag::variance > const variance;
    }
    namespace impl {
      template<typename Sample, typename MeanFeature> struct lazy_variance_impl;
      template<typename Sample, typename MeanFeature, typename Tag> 
        struct variance_impl;
    }
    namespace tag {
      struct lazy_variance;
      struct variance;
    }
  }
}

namespace boost {
  namespace accumulators {
    boost::parameter::keyword< tag::covariate1 > const covariate1;
    boost::parameter::keyword< tag::covariate2 > const covariate2;
    namespace tag {
      struct covariate1;
      struct covariate2;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::abstract_covariance > const weighted_covariance;
    }
    namespace impl {
      template<typename Sample, typename Weight, typename VariateType, 
               typename VariateTag> 
        struct weighted_covariance_impl;
    }
    namespace tag {
      template<typename VariateType, typename VariateTag> 
        struct weighted_covariance;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::density > const weighted_density;
    }
    namespace impl {
      template<typename Sample, typename Weight> struct weighted_density_impl;
    }
    namespace tag {
      struct weighted_density;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_extended_p_square > const weighted_extended_p_square;
    }
    namespace impl {
      template<typename Sample, typename Weight> 
        struct weighted_extended_p_square_impl;
    }
    namespace tag {
      struct weighted_extended_p_square;
    }
  }
}

namespace boost {
  namespace accumulators {
    namespace extract {
      extractor< tag::weighted_kurtosis > const weighted_kurtosis;
    }
    namespace impl {
      template<