basic_statistics.hpp

Go to the documentation of this file.

/*
Copyrightrandom_unique_numbers 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_STATIC_UTIL_HPP
#define SIG_UTIL_STATIC_UTIL_HPP

#include "../calculation/for_each.hpp"


namespace sig
{


template <class R = void, class C = void>
auto sum(C const& data)
    ->typename impl::SameIf<R, void, typename impl::container_traits<C>::value_type, R>::type
{
    using RT = typename impl::SameIf<R, void, typename impl::container_traits<C>::value_type, R>::type;

    return std::accumulate(std::begin(data), std::end(data), static_cast<RT>(0), std::plus<RT>{});
}


template <class R = void, class C = void, class Pred = void>
auto sum(C const& data, Pred const& access_func)
    ->typename impl::SameIf<R, void, decltype(impl::eval(access_func, std::declval<typename impl::container_traits<C>::value_type>())), R>::type
{
    using T = typename impl::container_traits<C>::value_type;
    using RT = typename impl::SameIf<R, void, decltype(impl::eval(access_func, std::declval<T>())), R>::type;

    return std::accumulate(std::begin(data), std::end(data), static_cast<RT>(0), [&](RT sum, T const& e){ return sum + access_func(e); });
}


template <class R = void, class CC = void>
auto sum_row(CC const& matrix, uint index)
{
    assert(index < matrix.size());
    return sum<R>(matrix[index]);
}


template <class R = void, class CC = void>
auto sum_col(CC const& matrix, uint index)
{
    using T = typename impl::container_traits<CC>::value_type;

    return sum<R>(matrix, [index](T const& row){ assert(index < row.size()); return row[index]; });
}



template <class R = void, class C = void>
auto product(C const& data)
    ->typename impl::SameIf<R, void, typename impl::container_traits<C>::value_type, R>::type
{
    using RT = typename impl::SameIf<R, void, typename impl::container_traits<C>::value_type, R>::type;

    return std::accumulate(std::begin(data), std::end(data), static_cast<RT>(1), std::multiplies<RT>{});
}


template <class R = void, class C = void, class Pred = void>
auto product(C const& data, Pred const& access_func)
    ->typename impl::SameIf<R, void, decltype(impl::eval(access_func, std::declval<typename impl::container_traits<C>::value_type>())), R>::type
{
    using T = typename impl::container_traits<C>::value_type;
    using RT = typename impl::SameIf<R, void, decltype(impl::eval(access_func, std::declval<T>())), R>::type;

    return std::accumulate(std::begin(data), std::end(data), static_cast<RT>(1), [&](RT sum, T const& e){ return sum * access_func(e); });
}


template <class R = void, class CC = void>
auto product_row(CC const& matrix, uint index)
{
    assert(index < matrix.size());
    return product<R>(matrix[index]);
}


template <class R = void, class CC = void>
auto product_col(CC const& matrix, uint index)
{
    using T = typename impl::container_traits<CC>::value_type;

    return product<R>(matrix, [index](T const& row){ assert(index < row.size()); return row[index]; });
}



template <class C>
double average(C const& data)
{
    return static_cast<double>(sum<double>(data)) / data.size();
}


template <class C>
double variance(C const& data)
{
    using T = typename impl::container_traits<C>::value_type;

    double mean = average(data);
    return std::accumulate(std::begin(data), std::end(data), 0.0, [mean](double sum, T e){ return sum + std::pow(e - mean, 2); }) / data.size();
}


template <class C, typename std::enable_if<std::is_floating_point<typename impl::container_traits<C>::value_type>::value>::type*& = enabler>
bool normalize(C& data)
{
    using T = typename impl::container_traits<C>::value_type;

    T min = *std::begin(data);
    T max = *std::begin(data);

    for (auto e : data){
        if (e < min) min = e;
        else if (e > max) max = e;
    }
    T diff = max - min;
    for_each([min, max, diff](T& e){ e = (e - min) / (diff); }, data);

    return true;
}


template <class R = double, class C = void>
auto normalize(C const& data, int dummy = 0)
    ->typename impl::container_traits<C>::template rebind<R>
{
    using RT = typename impl::container_traits<C>::template rebind<R>;

    auto result = sig::copy<RT>(data);
    normalize(result);

    return result;
}


template <class C, typename std::enable_if<std::is_floating_point<typename impl::container_traits<C>::value_type>::value>::type*& = enabler>
bool standardize(C& data)
{
    using T = typename impl::container_traits<C>::value_type;

    double mean = average(data);
    double var = variance(data);

    for_each([mean, var](T& e){ e = (e - mean) / var; }, data);

    return true;
}


template <class R = double, class C = void>
auto standardize(C const& data, int dummy = 0)
    ->typename impl::container_traits<C>::template rebind<R>
{
    using RT = typename impl::container_traits<C>::template rebind<R>;

    auto result = sig::copy<RT>(data);
    standardize(result);

    return result;
}


template <class C,
    typename std::enable_if<std::is_floating_point<typename impl::container_traits<C>::value_type>::value>::type*& = enabler
>
bool normalize_dist(C& data)
{
    double sum = sig::sum(data);
    for (auto& e : data) e /= sum;

    return true;
}


template <class R = double, class C = void>
auto normalize_dist(C const& data, int dummy = 0)
    ->typename impl::container_traits<C>::template rebind<R>
{
    using RT = typename impl::container_traits<C>::template rebind<R>;

    auto result = sig::copy<RT>(data);
    normalize_dist(result);

    return result;
}

}

#endif