Math.hpp

#pragma once

#include <cmath>
#include <random>
#include <map>
#include <samchon/IndexPair.hpp>

namespace samchon
{
namespace library
{
    class Math
    {
    public:
        /* ========================================================
            STATIC VARIABLES
        ======================================================== */
        static auto E() -> double
        {
            return exp(1.0);
        };

        static auto PI() -> double
        {
            return 3.141592653589793;
        }

        static auto LN2() -> double
        {
            return 1.0 / log2(E());
        }

        static auto LN10() -> double
        {
            return 1.0 / log10(E());
        }

        static auto LOG2E() -> double
        {
            return log2(E());
        }

        static auto LOG10E() -> double
        {
            return log10(E());
        }

        static auto SQRT1_2() -> double
        {
            return sqrt(.5);
        }

        static auto SQRT2() -> double
        {
            return sqrt(2.0);
        }

        /* ========================================================
            RANDOM
        ======================================================== */
        static auto random() -> double
        {
            static std::random_device device;
            static std::uniform_real_distribution<double> distribution(0.0, 1.0);

            return distribution(device);
        };

        /* ========================================================
            PIE
        ======================================================== */
        static auto degree_to_radian(double val) -> double
        {
            return val * PI() / 180.0;
        }

        static auto radian_to_degree(double val) -> double
        {
            return val * 180.0 / PI();
        }

        /* ========================================================
            STATISTICS
        ======================================================== */
        template <typename _Cont, typename T = _Cont::value_type>
        static auto minimum(const _Cont &container) -> IndexPair<T>
        {
            auto it = container.begin();
            size_t i = 0, position = 0;

            const T *ptr = &(*it);

            for (; it != container.end(); it++)
            {
                if (*it < *ptr)
                {
                    ptr = &(*it);
                    position = i;
                }
                i++;
            }
            return{ position, *ptr };
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto maximum(const _Cont &container) -> IndexPair<T>
        {
            auto it = container.begin();
            size_t i = 0, position = 0;

            const T *ptr = &(*it);

            for (; it != container.end(); it++)
            {
                if (*it > *ptr)
                {
                    ptr = &(*it);
                    position = i;
                }
                i++;
            }
            return{ position, *ptr };
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto mean(const _Cont &container) -> double
        {
            double val = 0.0;
            for (auto it = container.begin(); it != container.end(); it++)
                val += *it;

            return val / (double)container.size();
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto median(const _Cont &container) -> double
        {
            auto it = container.begin();

            if (container.size() % 2 == 1)
            {
                advance(it, container.size() / 2);

                return (double)*it;
            }
            else
            {
                advance(it, container.size() / 2 - 1);
                auto next_it = it;
                next_it++;

                return ((double)*it + (double)*next_it) / 2.0;
            }
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto mode(const _Cont &container) -> T
        {
            std::map<T, size_t> frequencyMap;
            for (auto it = container.begin(); it != container.end(); it++)
                if (frequencyMap.find(*it) == frequencyMap.end())
                    frequencyMap[*it] = 1;
                else
                    frequencyMap[*it]++;

            auto det_it = frequencyMap.begin();
            for (auto it = frequencyMap.begin(); it != frequencyMap.end(); it++)
                if (it->second > det_it->second)
                    det_it = it;

            return det_it->first;
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto stdev_p(const _Cont &container) -> double
        {
            return sqrt(variance_p(contaier));
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto stdev_s(const _Cont &container) -> double
        {
            return sql(variance_s(container));
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto variance_p(const _Cont &container) -> double
        {
            double val = 0.0;
            double mean = Math::mean(container);

            for (auto it = container.begin(); it != container.end(); it++)
                val += *it - mean;

            return val / (double)container.size();
        };

        template <typename _Cont, typename T = _Cont::value_type>
        static auto variance_s(const _Cont &container) -> double
        {
            double val = 0.0;
            double mean = Math::mean(container);

            for (auto it = container.begin(); it != container.end(); it++)
                val += *it - mean;

            return val / (double)(container.size() - 1);
        };
    };
};
};