Basic Statistics#

Basic statistics algorithm computes the following set of quantitative dataset characteristics:

  • minimums/maximums

  • sums

  • means

  • sums of squares

  • sums of squared differences from the means

  • second order raw moments

  • variances

  • standard deviations

  • variations

Operation

Computational methods

Programming Interface

Computing

dense

compute(…)

compute_input

compute_result

Mathematical formulation#

Refer to Developer Guide: Basic statistics.

Programming Interface#

All types and functions in this section are declared in the oneapi::dal::basic_statistics namespace and are available via inclusion of the oneapi/dal/algo/basic_statistics.hpp header file.

Descriptor#

template<typename Float = detail::descriptor_base<>::float_t, typename Method = detail::descriptor_base<>::method_t, typename Task = detail::descriptor_base<>::task_t>
class descriptor#
Template Parameters:
  • Float – The floating-point type that the algorithm uses for intermediate computations. Can be float or double.

  • Method – Tag-type that specifies an implementation of algorithm. Can be method::dense.

  • Task – Tag-type that specifies the type of the problem to solve. Can be task::compute.

Properties

result_option_id result_options#

Choose which results should be computed and returned.

Getter & Setter
result_option_id get_result_options() const
auto & set_result_options(const result_option_id &value)

Method tags#

struct dense#

Tag-type that denotes dense computational method.

using by_default = dense#

Alias tag-type for dense computational method.

Task tags#

struct compute#

Tag-type that parameterizes entities that are used to compute statistics.

using by_default = compute#

Alias tag-type for the compute task.

Training compute(...)#

Input#

template<typename Task = task::by_default>
class compute_input#
Template Parameters:

Task – Tag-type that specifies the type of the problem to solve. Can be task::compute.

Constructors

compute_input()#
compute_input(const table &data)#

Creates a new instance of the class with the given data property value.

compute_input(const table &data, const table &weights)#

Properties

const table &data#

An \(n \times p\) table with the training data, where each row stores one feature vector. Default value: table{}.

Getter & Setter
const table & get_data() const
auto & set_data(const table &data)
const table &weights#
Getter & Setter
const table & get_weights() const
auto & set_weights(const table &weights)

Result#

template<typename Task = task::by_default>
class compute_result#
Template Parameters:

Task – Tag-type that specifies the type of the problem to solve. Can be task::compute.

Constructors

compute_result()#

Creates a new instance of the class with the default property values.

Properties

const table &second_order_raw_moment#

A \(1 \times p\) table, where element \(j\) is the second_order_raw_moment result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_second_order_raw_moment() const
auto & set_second_order_raw_moment(const table &value)
const table &max#

A \(1 \times p\) table, where element \(j\) is the maximum result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_max() const
auto & set_max(const table &value)
const table &min#

A \(1 \times p\) table, where element \(j\) is the minimum result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_min() const
auto & set_min(const table &value)
const table &variation#

A \(1 \times p\) table, where element \(j\) is the variation result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_variation() const
auto & set_variation(const table &value)
const table &mean#

A \(1 \times p\) table, where element \(j\) is the mean result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_mean() const
auto & set_mean(const table &value)
const table &variance#

A \(1 \times p\) table, where element \(j\) is the variance result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_variance() const
auto & set_variance(const table &value)
const table &standard_deviation#

A \(1 \times p\) table, where element \(j\) is the standard_deviation result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_standard_deviation() const
auto & set_standard_deviation(const table &value)
const table &sum_squares#

A \(1 \times p\) table, where element \(j\) is the sum_squares result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_sum_squares() const
auto & set_sum_squares(const table &value)
const table &sum_squares_centered#

A \(1 \times p\) table, where element \(j\) is the sum_squares_centered result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_sum_squares_centered() const
auto & set_sum_squares_centered(const table &value)
const result_option_id &result_options#

Result options that indicates availability of the properties. Default value: full set of.

Getter & Setter
const result_option_id & get_result_options() const
auto & set_result_options(const result_option_id &value)
const table &sum#

A \(1 \times p\) table, where element \(j\) is the sum result for feature \(j\). Default value: table{}.

Getter & Setter
const table & get_sum() const
auto & set_sum(const table &value)

Operation#

template<typename Descriptor>
basic_statistics::compute_result compute(const Descriptor &desc, const basic_statistics::compute_input &input)#
Parameters:
  • desc – Basic statistics algorithm descriptor basic_statistics::descriptor

  • input – Input data for the computing operation

Preconditions
input.data.is_empty == false

Usage Example#

Computing#

 void run_computing(const table& data) {
 const auto bs_desc = dal::basic_statistics::descriptor{};

 const auto result = dal::compute(bs_desc, data);

 std::cout << "Minimum:\n" << result.get_min() << std::endl;
 std::cout << "Maximum:\n" << result.get_max() << std::endl;
 std::cout << "Sum:\n" << result.get_sum() << std::endl;
 std::cout << "Sum of squares:\n" << result.get_sum_squares() << std::endl;
 std::cout << "Sum of squared difference from the means:\n"
     << result.get_sum_squares_centered() << std::endl;
 std::cout << "Mean:\n" << result.get_mean() << std::endl;
 std::cout << "Second order raw moment:\n" << result.get_second_order_raw_moment() << std::endl;
 std::cout << "Variance:\n" << result.get_variance() << std::endl;
 std::cout << "Standard deviation:\n" << result.get_standard_deviation() << std::endl;
 std::cout << "Variation:\n" << result.get_variation() << std::endl;
}

Examples#