Math.hpp

#pragma once
#include <samchon/API.hpp>

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

namespace samchon
{
namespace library
{
    class SAMCHON_FRAMEWORK_API Math
    {
    public:
        /* ========================================================
            STATIC VARIABLES
        ======================================================== */
        static const double E;

        static const double PI;

        static const double LN2;

        static const double LN10;

        static const double LOG2E;

        static const double LOG10E;


        static const double SQRT1_2;

        static const double SQRT2;

        /* ========================================================
            RANDOM
        ======================================================== */
        static auto random() -> double;

        /* ========================================================
            PIE
        ======================================================== */
        static auto degree_to_radian(double) -> double;

        static auto radian_to_degree(double) -> double;

        /* ========================================================
            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);
        };
    };
};
};