Includes all of the Accumulators Framework

BOOST_ACCUMULATORS_MAX_FEATURES
BOOST_ACCUMULATORS_MAX_ARGS
BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)
BOOST_ACCUMULATORS_GCC_VERSION
BOOST_ACCUMULATORS_IGNORE_GLOBAL(X)

  
    struct accumulator_base;
    struct dont_care;
  }
}

  
    template<typename Stat> struct accumulator_concept;
  }
}

  
    template<typename Sample, typename Features, typename Weight> 
      struct accumulator_set;

    // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
    template<typename Feature, typename AccumulatorSet> 
       
      ( acc);
    template<typename Feature, typename AccumulatorSet> 
       
      ( acc);
    template<typename Feature, typename AccumulatorSet> 
       
      ( BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST);
  }
}

  
    template<typename Feature> struct as_feature<>;
    template<typename Feature> struct as_weighted_feature<>;

    template<typename Accumulator> struct droppable_accumulator;
    template<typename Accumulator> struct droppable_accumulator_base;

    template<typename Feature> struct feature_of<>;

    template<typename Accumulator> struct with_cached_result;
    
      template<typename Feature> struct as_droppable;

      template<typename Feature> struct as_droppable<>;

      template<typename Feature> struct droppable;
    }
  }
}

  
    template<typename Feature, typename Tag, typename AccumulatorSet> 
      struct feature_of<, , >;
    
    }
    
      template<typename Feature, typename Tag, typename AccumulatorSet> 
        struct external;

      template<typename Feature, typename Tag> struct external<, , >;
    }
  }
}

  
    template<typename ValueType, typename Tag> struct feature_of<, >;
    
    }
    
      template<typename Referent, typename Tag> struct reference_accumulator_impl;
    }
    
      template<typename Referent, typename Tag> struct reference;
      template<typename Tag> struct reference_tag;
    }
  }
}

  
    template<typename ValueType, typename Tag> struct feature_of<, >;
    
    }
    
      template<typename ValueType, typename Tag> struct value_accumulator_impl;
    }
    
      template<typename ValueType, typename Tag> struct value;
      template<typename Tag> struct value_tag;
    }
  }
}

  
    template<typename Feature> struct as_feature;
    template<typename Feature> struct as_weighted_feature;
    template<typename Feature1, typename Feature2, ... > struct depends_on;
    template<typename Feature> struct feature_of;
  }
}

BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq)

  
    template<typename Feature> struct extractor;
  }
}

  
    template<typename Feature1, typename Feature2, ... > struct features;
  }
}

Includes all of the Statistical Accumulators Library

  
    
      extractor<  count;
    }
    
      struct count_impl;
    }
    
      struct count;
    }
  }
}

  
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<, >;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    
      extractor<  covariance;
    }
    
      template<typename Sample, typename VariateType, typename VariateTag> 
        struct covariance_impl;
    }
    
      struct abstract_covariance;
      template<typename VariateType, typename VariateTag> struct covariance;
    }
  }
  
    
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct outer_product;

      template<typename Left, typename Right> struct outer_product<, , , >;

      template<typename Left, typename Right, typename EnableIf> 
        struct outer_product_base;
    }
    
      struct outer_product;
    }
  }
}

  
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    
      extractor<  density;
    }
    
      template<typename Sample> struct density_impl;
    }
    
      struct density;
    }
  }
}

  
    template<typename Feature> struct as_feature<>;
    template<typename Feature> struct as_weighted_feature<>;
    
    }
    
    }
    
      template<typename Feature> struct error_of;
    }
  }
}

  
    
      template<typename Sample, typename Variance> struct error_of_mean_impl;
    }
    
      template<> struct error_of<>;
      template<> struct error_of<>;
    }
  }
}

  
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    
      extractor<  extended_p_square;
    }
    
      template<typename Sample> struct extended_p_square_impl;
    }
    
      struct extended_p_square;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    
      extractor<  extended_p_square_quantile;
      extractor<  extended_p_square_quantile_quadratic;
      extractor<  weighted_extended_p_square_quantile;
      extractor<  weighted_extended_p_square_quantile_quadratic;
    }
    
      template<typename Sample, typename Impl1, typename Impl2> 
        struct extended_p_square_quantile_impl;
    }
    
      struct extended_p_square_quantile;
      struct extended_p_square_quantile_quadratic;
      struct weighted_extended_p_square_quantile;
      struct weighted_extended_p_square_quantile_quadratic;
    }
  }
}

  
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    
      extractor< tag::kurtosis >  kurtosis;
    }
    
      template<typename Sample> struct kurtosis_impl;
    }
    
      struct kurtosis;
    }
  }
}

  
    
      extractor<  max;
    }
    
      template<typename Sample> struct max_impl;
    }
    
      struct max;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<typename VariateType, typename VariateTag> struct as_feature<, >;
    template<typename VariateType, typename VariateTag> struct as_feature<, >;
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_weighted_feature<>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<, >;
    template<> struct as_weighted_feature<>;
    template<typename VariateType, typename VariateTag> 
      struct as_weighted_feature<, >;
    template<> struct feature_of<>;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    template<> struct feature_of<>;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    
      extractor<  mean;
      extractor<  mean_of_weights;
    }
    
      template<typename Sample, typename Tag> struct immediate_mean_impl;
      template<typename Sample, typename SumFeature> struct mean_impl;
    }
    
      struct immediate_mean;
      template<typename VariateType, typename VariateTag> 
        struct immediate_mean_of_variates;
      struct immediate_mean_of_weights;
      struct mean;
      template<typename VariateType, typename VariateTag> struct mean_of_variates;
      struct mean_of_weights;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    
      extractor<  median;
      extractor<  with_density_median;
      extractor<  with_p_square_cumulative_distribution_median;
    }
    
      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;
    }
    
      struct median;
      struct with_density_median;
      struct with_p_square_cumulative_distribution_median;
    }
  }
}

  
    
      extractor<  min;
    }
    
      template<typename Sample> struct min_impl;
    }
    
      struct min;
    }
  }
}

  
    template< N> struct as_weighted_feature<>;
    template< N> struct feature_of<>;
    
    }
    
      template<typename N, typename Sample> struct moment_impl;
    }
    
      template< N> struct moment;
    }
  }
  
  }
}

  
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    
      extractor<  p_square_cumulative_distribution;
    }
    
      template<typename Sample> struct p_square_cumulative_distribution_impl;
    }
    
      struct p_square_cumulative_distribution;
    }
  }
}

  
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    
      extractor<  p_square_quantile;
      extractor<  p_square_quantile_for_median;
    }
    
      template<typename Sample, typename Impl> struct p_square_quantile_impl;
    }
    
      struct p_square_quantile;
      struct p_square_quantile_for_median;
    }
  }
}

  
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    
      extractor<  peaks_over_threshold;
    }
    
      template<typename Sample, typename LeftRight> 
        struct peaks_over_threshold_impl;
      template<typename Sample, typename LeftRight> 
        struct peaks_over_threshold_prob_impl;
    }
    
      struct abstract_peaks_over_threshold;
      template<typename LeftRight> struct peaks_over_threshold;
      template<typename LeftRight> struct peaks_over_threshold_prob;
    }
  }
}

  
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    
      template<typename Sample, typename Impl, typename LeftRight> 
        struct pot_quantile_impl;
    }
    
      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;
    }
  }
}

  
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    
      template<typename Sample, typename Impl, typename LeftRight> 
        struct pot_tail_mean_impl;
    }
    
      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;
    }
  }
}

  
    
      extractor< tag::rolling_count >  rolling_count;
    }
    
      template<typename Sample> struct rolling_count_impl;
    }
    
      struct rolling_count;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    
      extractor<  lazy_rolling_mean;
      extractor<  immediate_rolling_mean;
      extractor<  rolling_mean;
    }
    
      template<typename Sample> struct immediate_rolling_mean_impl;
      template<typename Sample> struct lazy_rolling_mean_impl;
    }
    
      struct immediate_rolling_mean;
      struct lazy_rolling_mean;
      struct rolling_mean;
    }
  }
}

  
    
    }
    
      template<typename N, typename Sample> struct rolling_moment_impl;
    }
    
      template< N> struct rolling_moment;
    }
  }
}

  
    
      extractor<  rolling_sum;
    }
    
      template<typename Sample> struct rolling_sum_impl;
    }
    
      struct rolling_sum;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    
      extractor<  lazy_rolling_variance;
      extractor<  immediate_rolling_variance;
      extractor<  rolling_variance;
    }
    
      template<typename Sample> struct immediate_rolling_variance_impl;
      template<typename Sample> struct lazy_rolling_variance_impl;
    }
    
      struct immediate_rolling_variance;
      struct lazy_rolling_variance;
      struct rolling_variance;
    }
  }
}

  
    
      extractor< tag::rolling_window_plus1 >  rolling_window_plus1;
      extractor< tag::rolling_window >  rolling_window;
    }
    
      template<typename Sample> struct rolling_window_impl;
      template<typename Sample> struct rolling_window_plus1_impl;
      template<typename Args> 
         ( args);
    }
    
      struct rolling_window;
      struct rolling_window_plus1;
    }
  }
  
    template<typename Archive, typename T> 
       ( ar,  b, 
                );
    template<typename Archive, typename T> 
       ( ar,  b, );
    template<typename Archive, typename T> 
       ( ar,  b, 
                      version);
  }
}

  
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    
      extractor< tag::skewness >  skewness;
    }
    
      template<typename Sample> struct skewness_impl;
    }
    
      struct skewness;
    }
  }
}

Contains the stats<> template.

  
    template<typename Stat1, typename Stat2, ... > struct stats;
  }
}

  
    template<> struct as_weighted_feature<>;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    template<> struct feature_of<>;
    
      extractor<  sum;
      extractor<  sum_of_weights;
      extractor<  sum_of_variates;
    }
    
      template<typename Sample, typename Tag> struct sum_impl;
    }
    
      struct abstract_sum_of_variates;
      struct sum;
      template<typename VariateType, typename VariateTag> struct sum_of_variates;
      struct sum_of_weights;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    
      extractor<  sum_kahan;
      extractor<  sum_of_weights_kahan;
      extractor<  sum_of_variates_kahan;
    }
    
      template<typename Sample, typename Tag> struct sum_kahan_impl;
    }
    
      struct sum_kahan;
      template<typename VariateType, typename VariateTag> 
        struct sum_of_variates_kahan;
      struct sum_of_weights_kahan;
    }
  }
}

  
    template<typename LeftRight> struct feature_of<>;

    template<typename T> struct tail_cache_size_named_arg;

    template<> struct tail_cache_size_named_arg<>;
    template<> struct tail_cache_size_named_arg<>;
    
      extractor< tag::abstract_tail >  tail;
    }
    
      template<typename Sample, typename LeftRight> struct tail_impl;
    }
    
      struct abstract_tail;
      template<typename LeftRight> struct tail;
    }
  }
}

  
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    
      extractor< tag::abstract_non_coherent_tail_mean >  non_coherent_tail_mean;
      extractor< tag::tail_mean >  coherent_tail_mean;
    }
    
      template<typename Sample, typename LeftRight> 
        struct coherent_tail_mean_impl;
      template<typename Sample, typename LeftRight> 
        struct non_coherent_tail_mean_impl;
    }
    
      struct abstract_non_coherent_tail_mean;
      template<typename LeftRight> struct coherent_tail_mean;
      template<typename LeftRight> struct non_coherent_tail_mean;
    }
  }
}

  
    template<typename LeftRight> struct as_weighted_feature<>;
    template<typename LeftRight> struct feature_of<>;
    template<typename LeftRight> struct feature_of<>;
    
      extractor< tag::quantile >  tail_quantile;
    }
    
      template<typename Sample, typename LeftRight> struct tail_quantile_impl;
    }
    
      template<typename LeftRight> struct tail_quantile;
    }
  }
}

  
    template<typename VariateType, typename VariateTag, typename LeftRight> 
      struct feature_of<, , >;
    template<typename LeftRight> struct feature_of<>;
    
      extractor<  tail_variate;
      extractor<  tail_weights;
    }
    
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct tail_variate_impl;
    }
    
      struct abstract_tail_variate;
      struct abstract_tail_weights;
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct tail_variate;
      template<typename LeftRight> struct tail_weights;
    }
  }
}

  
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_weighted_feature<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_weighted_feature<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct feature_of<, , >;
    
      extractor<  tail_variate_means;
      extractor<  relative_tail_variate_means;
    }
    
      template<typename Sample, typename Impl, typename LeftRight, 
               typename VariateTag> 
        struct tail_variate_means_impl;
    }
    
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct absolute_tail_variate_means;
      struct abstract_absolute_tail_variate_means;
      struct abstract_relative_tail_variate_means;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct relative_tail_variate_means;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct as_weighted_feature<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    template<> struct feature_of<>;
    
      extractor<  lazy_variance;
      extractor<  variance;
    }
    
      template<typename Sample, typename MeanFeature> struct lazy_variance_impl;
      template<typename Sample, typename MeanFeature, typename Tag> 
        struct variance_impl;
    }
    
      struct lazy_variance;
      struct variance;
    }
  }
}

  
     covariate1;
     covariate2;
    
      struct covariate1;
      struct covariate2;
    }
  }
}

  
    
      extractor<  weighted_covariance;
    }
    
      template<typename Sample, typename Weight, typename VariateType, 
               typename VariateTag> 
        struct weighted_covariance_impl;
    }
    
      template<typename VariateType, typename VariateTag> 
        struct weighted_covariance;
    }
  }
}

  
    
      extractor<  weighted_density;
    }
    
      template<typename Sample, typename Weight> struct weighted_density_impl;
    }
    
      struct weighted_density;
    }
  }
}

  
    
      extractor<  weighted_extended_p_square;
    }
    
      template<typename Sample, typename Weight> 
        struct weighted_extended_p_square_impl;
    }
    
      struct weighted_extended_p_square;
    }
  }
}

  
    
      extractor< tag::weighted_kurtosis >  weighted_kurtosis;
    }
    
      template<typename Sample, typename Weight> struct weighted_kurtosis_impl;
    }
    
      struct weighted_kurtosis;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<typename VariateType, typename VariateTag> struct as_feature<, >;
    template<typename VariateType, typename VariateTag> struct as_feature<, >;
    
      extractor<  weighted_mean;
    }
    
      template<typename Sample, typename Weight, typename Tag> 
        struct immediate_weighted_mean_impl;
      template<typename Sample, typename Weight, typename Tag> 
        struct weighted_mean_impl;
    }
    
      struct immediate_weighted_mean;
      template<typename VariateType, typename VariateTag> 
        struct immediate_weighted_mean_of_variates;
      struct weighted_mean;
      template<typename VariateType, typename VariateTag> 
        struct weighted_mean_of_variates;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    
      extractor<  weighted_median;
    }
    
      template<typename Sample> struct weighted_median_impl;
      template<typename Sample> struct with_density_weighted_median_impl;
      template<typename Sample, typename Weight> 
        struct with_p_square_cumulative_distribution_weighted_median_impl;
    }
    
      struct weighted_median;
      struct with_density_weighted_median;
      struct with_p_square_cumulative_distribution_weighted_median;
    }
  }
}

  
    
    }
    
      template<typename N, typename Sample, typename Weight> 
        struct weighted_moment_impl;
    }
    
      template< N> struct weighted_moment;
    }
  }
}

  
    
      extractor<  weighted_p_square_cumulative_distribution;
    }
    
      template<typename Sample, typename Weight> 
        struct weighted_p_square_cumulative_distribution_impl;
    }
    
      struct weighted_p_square_cumulative_distribution;
    }
  }
}

  
    
      extractor<  weighted_p_square_quantile;
      extractor<  weighted_p_square_quantile_for_median;
    }
    
      template<typename Sample, typename Weight, typename Impl> 
        struct weighted_p_square_quantile_impl;
    }
    
      struct weighted_p_square_quantile;
      struct weighted_p_square_quantile_for_median;
    }
  }
}

  
    template<typename LeftRight> struct as_feature<>;
    template<typename LeftRight> struct as_feature<>;
    
      extractor<  weighted_peaks_over_threshold;
    }
    
      template<typename Sample, typename Weight, typename LeftRight> 
        struct weighted_peaks_over_threshold_impl;
      template<typename Sample, typename Weight, typename LeftRight> 
        struct weighted_peaks_over_threshold_prob_impl;
    }
    
      template<typename LeftRight> struct weighted_peaks_over_threshold;
      template<typename LeftRight> struct weighted_peaks_over_threshold_prob;
    }
  }
}

  
    
      extractor< tag::weighted_skewness >  weighted_skewness;
    }
    
      template<typename Sample, typename Weight> struct weighted_skewness_impl;
    }
    
      struct weighted_skewness;
    }
  }
}

  
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    
      extractor<  weighted_sum;
      extractor<  weighted_sum_of_variates;
    }
    
      template<typename Sample, typename Weight, typename Tag> 
        struct weighted_sum_impl;
    }
    
      struct abstract_weighted_sum_of_variates;
      struct weighted_sum;
      template<typename VariateType, typename VariateTag> 
        struct weighted_sum_of_variates;
    }
  }
}

  
    template<> struct as_feature<>;
    template<typename VariateType, typename VariateTag> struct feature_of<, >;
    
      extractor<  weighted_sum_kahan;
      extractor<  weighted_sum_of_variates_kahan;
    }
    
      template<typename Sample, typename Weight, typename Tag> 
        struct weighted_sum_kahan_impl;
    }
    
      struct weighted_sum_kahan;
      template<typename VariateType, typename VariateTag> 
        struct weighted_sum_of_variates_kahan;
    }
  }
}

  
    
      extractor< tag::abstract_non_coherent_tail_mean >  non_coherent_weighted_tail_mean;
    }
    
      template<typename Sample, typename Weight, typename LeftRight> 
        struct non_coherent_weighted_tail_mean_impl;
    }
    
      template<typename LeftRight> struct non_coherent_weighted_tail_mean;
    }
  }
}

  
    
      extractor< tag::quantile >  weighted_tail_quantile;
    }
    
      template<typename Sample, typename Weight, typename LeftRight> 
        struct weighted_tail_quantile_impl;
    }
    
      template<typename LeftRight> struct weighted_tail_quantile;
    }
  }
}

  
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<, , >;
    template<typename LeftRight, typename VariateType, typename VariateTag> 
      struct as_feature<, , >;
    
      extractor<  weighted_tail_variate_means;
      extractor<  relative_weighted_tail_variate_means;
    }
    
      template<typename Sample, typename Weight, typename Impl, 
               typename LeftRight, typename VariateType> 
        struct weighted_tail_variate_means_impl;
    }
    
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct absolute_weighted_tail_variate_means;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct relative_weighted_tail_variate_means;
    }
  }
  
    
      template<typename T, typename U> struct multiply_and_promote_to_double;
    }
  }
}

  
    template<> struct as_feature<>;
    template<> struct as_feature<>;
    
      extractor<  lazy_weighted_variance;
      extractor<  weighted_variance;
    }
    
      template<typename Sample, typename Weight, typename MeanFeature> 
        struct lazy_weighted_variance_impl;
      template<typename Sample, typename Weight, typename MeanFeature, 
               typename Tag> 
        struct weighted_variance_impl;
    }
    
      struct lazy_weighted_variance;
      struct weighted_variance;
    }
  }
}

  
    template<typename Feature1, typename Feature2, ... > struct with_error;
  }
}

  
    struct absolute;
    struct for_median;
    struct immediate;
    struct kahan;
    struct lazy;
    struct left;
    struct linear;
    struct quadratic;
    struct regular;
    struct relative;
    struct right;
    struct unweighted;
    struct weighted;
    struct with_density;
    struct with_p_square_cumulative_distribution;
    struct with_p_square_quantile;
    struct with_threshold_probability;
    struct with_threshold_value;
    
      extractor< tag::quantile >  quantile;
      extractor< tag::tail_mean >  tail_mean;
    }
    
      template<typename Sample> struct rolling_mean_impl;
    }
    
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct left_tail_variate;
      struct quantile;
      template<typename VariateType, typename VariateTag, typename LeftRight> 
        struct right_tail_variate;
      struct tail_mean;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct tail_variate_means;
      template<typename LeftRight, typename VariateType, typename VariateTag> 
        struct weighted_tail_variate_means;
    }
  }
}

  
    template<typename T> struct default_;
    template<typename T> struct one;
    template<typename T> struct one_or_default;
    template<typename T> struct zero;
    template<typename T> struct zero_or_default;
    template<typename To, typename From> 
       
      ( from);
    template<typename To, typename From> 
       
      ( from);
    
      template<typename Arg, typename Tag> struct as_max;
      template<typename Arg, typename EnableIf> struct as_max_base;
      template<typename Arg, typename Tag> struct as_min;
      template<typename Arg, typename EnableIf> struct as_min_base;

      template<typename Arg> struct as_min_base<, >;

      template<typename Arg, typename Tag> struct as_one;
      template<typename Arg, typename EnableIf> struct as_one_base;
      template<typename Arg, typename Tag> struct as_zero;
      template<typename Arg, typename EnableIf> struct as_zero_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct assign_base;
      template<typename Arg, typename Tag> struct complement;
      template<typename Arg, typename EnableIf> struct complement_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct divides;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct divides_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct divides_assign_base;
      template<typename Left, typename Right, typename EnableIf> 
        struct divides_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct equal_to;
      template<typename Left, typename Right, typename EnableIf> 
        struct equal_to_base;
      template<typename Left, typename Right, typename LeftTag, 
               typename RightTag> 
        struct fdiv;
      template<typename Left, typename Right, typename EnableIf> struct fdiv_base;

      template<typename Left, typename Right> struct fdiv_base<, , , >;

      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct greater;
      template<typename Left, typename Right, typename EnableIf> 
        struct greater_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct greater_equal;
      template<typename Left, typename Right, typename EnableIf> 
        struct greater_equal_base;
      template<typename Left, typename Right> struct left_ref;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct less;
      template<typename Left, typename Right, typename EnableIf> struct less_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct less_equal;
      template<typename Left, typename Right, typename EnableIf> 
        struct less_equal_base;
      template<typename Arg, typename Tag> struct logical_not;
      template<typename Arg, typename EnableIf> struct logical_not_base;
      template<typename Left, typename Right, typename LeftTag, 
               typename RightTag> 
        struct max_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct max_assign_base;
      template<typename Left, typename Right, typename LeftTag, 
               typename RightTag> 
        struct min_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct min_assign_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct minus;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct minus_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct minus_assign_base;
      template<typename Left, typename Right, typename EnableIf> 
        struct minus_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct modulus;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct modulus_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct modulus_assign_base;
      template<typename Left, typename Right, typename EnableIf> 
        struct modulus_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct multiplies;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct multiplies_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct multiplies_assign_base;
      template<typename Left, typename Right, typename EnableIf> 
        struct multiplies_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct not_equal_to;
      template<typename Left, typename Right, typename EnableIf> 
        struct not_equal_to_base;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct plus;
      template<typename Left, typename Right, 
               typename LeftTag, 
               typename RightTag> 
        struct plus_assign;
      template<typename Left, typename Right, typename EnableIf> 
        struct plus_assign_base;
      template<typename Left, typename Right, typename EnableIf> struct plus_base;
      template<typename To, typename From, typename ToTag, typename FromTag> 
        struct promote;
      template<typename To, typename From, typename EnableIf> struct promote_base;

      template<typename ToFrom> struct promote_base<, , >;

      template<typename Arg, typename Tag> struct unary_minus;
      template<typename Arg, typename EnableIf> struct unary_minus_base;
      template<typename Arg, typename Tag> struct unary_plus;
      template<typename Arg, typename EnableIf> struct unary_plus_base;
    }
    
      struct as_max;
      struct as_min;
      struct as_one;
      struct as_zero;
      struct assign;
      struct complement;
      struct divides;
      struct divides_assign;
      struct equal_to;
      struct fdiv;
      struct greater;
      struct greater_equal;
      struct less;
      struct less_equal;
      struct logical_not;
      struct max_assign;
      struct min_assign;
      struct minus;
      struct minus_assign;
      struct modulus;
      struct modulus_assign;
      struct multiplies;
      struct multiplies_assign;
      struct not_equal_to;
      struct plus;
      struct plus_assign;
      template<typename To> struct promote;
      struct unary_minus;
      struct unary_plus;
    }
  }
}

  
    
      template<typename T, typename U> 
         
        ( ri,  u);
      template<typename T, typename U> 
         
        ( ri,  u);
    }
  }
}

  
    
      template<typename T> struct as_max<, >;
      template<typename T> struct as_min<, >;
      template<typename T> struct as_one<, >;
      template<typename T> struct as_zero<, >;
      template<typename Left, typename Right, typename RightTag> 
        struct fdiv<, , , >;
      template<typename Left, typename Right> struct max_assign<, , , >;
      template<typename Left, typename Right> struct min_assign<, , , >;
      template<typename From> struct promote<, , , >;
      template<typename From> struct promote<, , , >;
      template<typename To, typename From> struct promote<, , , >;
      template<typename ToFrom> struct promote<, , , >;
      template<typename T> struct tag<>;
    }
    
      template<typename Left, typename Right> 
         ( left, 
                               right);
      template<typename Left, typename Right> 
         ( left, 
                               right);
      template<typename Left, typename Right> 
         ( left, 
                               right);
    }
  }
}

  
    
      template<typename T> struct as_max<, >;
      template<typename T> struct as_min<, >;
      template<typename T> struct as_one<, >;
      template<typename T> struct as_zero<, >;
      template<typename Left, typename Right> struct fdiv<, , , >;
      template<typename Left, typename Right> struct max_assign<, , , >;
      template<typename Left, typename Right> struct min_assign<, , , >;
      template<typename To, typename From> struct promote<, , , >;
      template<typename ToFrom> struct promote<, , , >;
      template<typename T, typename Al> struct tag<, >;
    }
    
      template<typename Left, typename Right> 
         ( left, 
                               right);
      template<typename Left, typename Right> 
        functional::divides<  
        ( left, 
                   right);
      template<typename Left, typename Right> 
         ( left, 
                               right);
      template<typename Left, typename Right> 
         ( left, 
                               right);
      template<typename Left, typename Right> 
        functional::multiplies<  
        ( left, 
                   right);
      template<typename Left, typename Right> 
        functional::plus<  
        ( left, 
                   right);
      template<typename Left, typename Right> 
        functional::minus<  
        ( left, 
                   right);
      template<typename Left> 
         
        ( left, 
                    right);
      template<typename Arg> 
        functional::unary_minus<  
        ( arg);
    }
  }
}