diff --git a/docker/test/fasttest/run.sh b/docker/test/fasttest/run.sh
index c95344eeca2..b286e57c206 100755
--- a/docker/test/fasttest/run.sh
+++ b/docker/test/fasttest/run.sh
@@ -288,6 +288,7 @@ TESTS_TO_SKIP=(
 
     # Require python libraries like scipy, pandas and numpy
     01322_ttest_scipy
+    01561_mann_whitney_scipy
 
     01545_system_errors
     # Checks system.errors
diff --git a/src/AggregateFunctions/AggregateFunctionMannWhitney.cpp b/src/AggregateFunctions/AggregateFunctionMannWhitney.cpp
new file mode 100644
index 00000000000..ceb0b930f73
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionMannWhitney.cpp
@@ -0,0 +1,37 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionMannWhitney.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include "registerAggregateFunctions.h"
+#include <AggregateFunctions/Helpers.h>
+
+
+namespace ErrorCodes
+{
+extern const int NOT_IMPLEMENTED;
+}
+
+namespace DB
+{
+
+namespace
+{
+
+AggregateFunctionPtr createAggregateFunctionMannWhitneyUTest(const std::string & name, const DataTypes & argument_types, const Array & parameters)
+{
+    assertBinary(name, argument_types);
+
+    if (!isNumber(argument_types[0]) || !isNumber(argument_types[1]))
+        throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::NOT_IMPLEMENTED);
+
+    return std::make_shared<AggregateFunctionMannWhitney>(argument_types, parameters);
+}
+
+}
+
+
+void registerAggregateFunctionMannWhitney(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("mannWhitneyUTest", createAggregateFunctionMannWhitneyUTest);
+}
+
+}
diff --git a/src/AggregateFunctions/AggregateFunctionMannWhitney.h b/src/AggregateFunctions/AggregateFunctionMannWhitney.h
new file mode 100644
index 00000000000..82a15c6cfae
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionMannWhitney.h
@@ -0,0 +1,246 @@
+#pragma once
+
+#include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/StatCommon.h>
+#include <Columns/ColumnArray.h>
+#include <Columns/ColumnVector.h>
+#include <Columns/ColumnTuple.h>
+#include <Common/assert_cast.h>
+#include <Common/FieldVisitors.h>
+#include <Common/PODArray_fwd.h>
+#include <common/types.h>
+#include <DataTypes/DataTypesDecimal.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
+#include <limits>
+
+#include <DataTypes/DataTypeArray.h>
+
+#include <Common/ArenaAllocator.h>
+
+#include <iostream>
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int BAD_ARGUMENTS;
+}
+
+
+struct MannWhitneyData : public StatisticalSample<Float64, Float64>
+{
+    /*Since null hypothesis is "for randomly selected values X and Y from two populations,
+     *the probability of X being greater than Y is equal to the probability of Y being greater than X".
+     *Or "the distribution F of first sample equals to the distribution G of second sample".
+     *Then alternative for this hypothesis (H1) is "two-sided"(F != G), "less"(F < G), "greater" (F > G). */
+    enum class Alternative
+    {
+        TwoSided,
+        Less,
+        Greater
+    };
+
+    /// The behaviour equals to the similar function from scipy.
+    /// https://github.com/scipy/scipy/blob/ab9e9f17e0b7b2d618c4d4d8402cd4c0c200d6c0/scipy/stats/stats.py#L6978
+    std::pair<Float64, Float64> getResult(Alternative alternative, bool continuity_correction)
+    {
+        ConcatenatedSamples both(this->x, this->y);
+        RanksArray ranks;
+        Float64 tie_correction;
+
+        /// Compute ranks according to both samples.
+        std::tie(ranks, tie_correction) = computeRanksAndTieCorrection(both);
+
+        const Float64 n1 = this->size_x;
+        const Float64 n2 = this->size_y;
+
+        Float64 r1 = 0;
+        for (size_t i = 0; i < n1; ++i)
+            r1 += ranks[i];
+
+        const Float64 u1 = n1 * n2 + (n1 * (n1 + 1.)) / 2. - r1;
+        const Float64 u2 = n1 * n2 - u1;
+
+        /// The distribution of U-statistic under null hypothesis H0  is symmetric with respect to meanrank.
+        const Float64 meanrank = n1 * n2 /2. + 0.5 * continuity_correction;
+        const Float64 sd = std::sqrt(tie_correction * n1 * n2 * (n1 + n2 + 1) / 12.0);
+
+        Float64 u = 0;
+        if (alternative == Alternative::TwoSided)
+            /// There is no difference which u_i to take as u, because z will be differ only in sign and we take std::abs() from it.
+            u = std::max(u1, u2);
+        else if (alternative == Alternative::Less)
+            u = u1;
+        else if (alternative == Alternative::Greater)
+            u = u2;
+
+        Float64 z = (u - meanrank) / sd;
+        if (alternative == Alternative::TwoSided)
+            z = std::abs(z);
+
+        /// In fact cdf is a probability function, so it is intergral of density from (-inf, z].
+        /// But since standard normal distribution is symmetric, cdf(0) = 0.5 and we have to compute integral from [0, z].
+        const Float64 cdf = integrateSimpson(0, z, [] (Float64 t) { return std::pow(M_E, -0.5 * t * t) / std::sqrt(2 * M_PI);});
+
+        Float64 p_value = 0;
+        if (alternative == Alternative::TwoSided)
+            p_value = 1 - 2 * cdf;
+        else
+            p_value = 0.5 - cdf;
+
+        return {u2, p_value};
+    }
+
+private:
+    using Sample = typename StatisticalSample<Float64, Float64>::SampleX;
+
+    /// We need to compute ranks according to all samples. Use this class to avoid extra copy and memory allocation.
+    class ConcatenatedSamples
+    {
+        public:
+            ConcatenatedSamples(const Sample & first_, const Sample & second_)
+                : first(first_), second(second_) {}
+
+            const Float64 & operator[](size_t ind) const
+            {
+                if (ind < first.size())
+                    return first[ind];
+                return second[ind % first.size()];
+            }
+
+            size_t size() const
+            {
+                return first.size() + second.size();
+            }
+
+        private:
+            const Sample & first;
+            const Sample & second;
+    };
+};
+
+class AggregateFunctionMannWhitney final:
+    public IAggregateFunctionDataHelper<MannWhitneyData, AggregateFunctionMannWhitney>
+{
+private:
+    using Alternative = typename MannWhitneyData::Alternative;
+    Alternative alternative;
+    bool continuity_correction{true};
+
+public:
+    explicit AggregateFunctionMannWhitney(const DataTypes & arguments, const Array & params)
+        :IAggregateFunctionDataHelper<MannWhitneyData, AggregateFunctionMannWhitney> ({arguments}, {})
+    {
+        if (params.size() > 2)
+            throw Exception("Aggregate function " + getName() + " require two parameter or less", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+        if (params.empty())
+        {
+            alternative = Alternative::TwoSided;
+            return;
+        }
+
+        if (params[0].getType() != Field::Types::String)
+            throw Exception("Aggregate function " + getName() + " require require first parameter to be a String", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+        auto param = params[0].get<String>();
+        if (param == "two-sided")
+            alternative = Alternative::TwoSided;
+        else if (param == "less")
+            alternative = Alternative::Less;
+        else if (param == "greater")
+            alternative = Alternative::Greater;
+        else
+            throw Exception("Unknown parameter in aggregate function " + getName() +
+                    ". It must be one of: 'two sided', 'less', 'greater'", ErrorCodes::BAD_ARGUMENTS);
+
+        if (params.size() != 2)
+            return;
+
+        if (params[1].getType() != Field::Types::UInt64)
+                throw Exception("Aggregate function " + getName() + " require require second parameter to be a UInt64", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+        continuity_correction = static_cast<bool>(params[1].get<UInt64>());
+    }
+
+    String getName() const override
+    {
+        return "mannWhitneyUTest";
+    }
+
+    DataTypePtr getReturnType() const override
+    {
+        DataTypes types
+        {
+            std::make_shared<DataTypeNumber<Float64>>(),
+            std::make_shared<DataTypeNumber<Float64>>(),
+        };
+
+        Strings names
+        {
+            "u_statistic",
+            "p_value"
+        };
+
+        return std::make_shared<DataTypeTuple>(
+            std::move(types),
+            std::move(names)
+        );
+    }
+
+    void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
+    {
+        Float64 value = columns[0]->getFloat64(row_num);
+        UInt8 is_second = columns[1]->getUInt(row_num);
+
+        if (is_second)
+            this->data(place).addY(value, arena);
+        else
+            this->data(place).addX(value, arena);
+    }
+
+    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
+    {
+        auto & a = this->data(place);
+        auto & b = this->data(rhs);
+
+        a.merge(b, arena);
+    }
+
+    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
+    {
+        this->data(place).write(buf);
+    }
+
+    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena * arena) const override
+    {
+        this->data(place).read(buf, arena);
+    }
+
+    void insertResultInto(AggregateDataPtr place, IColumn & to, Arena *) const override
+    {
+        if (!this->data(place).size_x || !this->data(place).size_y)
+            throw Exception("Aggregate function " + getName() + " require both samples to be non empty", ErrorCodes::BAD_ARGUMENTS);
+
+        auto [u_statistic, p_value] = this->data(place).getResult(alternative, continuity_correction);
+
+        /// Because p-value is a probability.
+        p_value = std::min(1.0, std::max(0.0, p_value));
+
+        auto & column_tuple = assert_cast<ColumnTuple &>(to);
+        auto & column_stat = assert_cast<ColumnVector<Float64> &>(column_tuple.getColumn(0));
+        auto & column_value = assert_cast<ColumnVector<Float64> &>(column_tuple.getColumn(1));
+
+        column_stat.getData().push_back(u_statistic);
+        column_value.getData().push_back(p_value);
+    }
+
+};
+
+};
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp b/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
index 796ff028424..87fc24f8f98 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelation.cpp
@@ -21,23 +21,10 @@ AggregateFunctionPtr createAggregateFunctionRankCorrelation(const std::string &
     assertBinary(name, argument_types);
     assertNoParameters(name, parameters);
 
-    AggregateFunctionPtr res;
-
-    if (isDecimal(argument_types[0]) || isDecimal(argument_types[1]))
-    {
+    if (!isNumber(argument_types[0]) || !isNumber(argument_types[1]))
         throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::NOT_IMPLEMENTED);
-    }
-    else
-    {
-        res.reset(createWithTwoNumericTypes<AggregateFunctionRankCorrelation>(*argument_types[0], *argument_types[1], argument_types));
-    }
 
-    if (!res)
-    {
-        throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    return res;
+    return std::make_shared<AggregateFunctionRankCorrelation>(argument_types);
 }
 
 }
diff --git a/src/AggregateFunctions/AggregateFunctionRankCorrelation.h b/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
index 75592cf5c9b..bdec03d5975 100644
--- a/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
+++ b/src/AggregateFunctions/AggregateFunctionRankCorrelation.h
@@ -1,73 +1,56 @@
 #pragma once
 
 #include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/StatCommon.h>
 #include <Columns/ColumnArray.h>
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnTuple.h>
 #include <Common/assert_cast.h>
-#include <Common/FieldVisitors.h>
+#include <Common/PODArray_fwd.h>
 #include <common/types.h>
 #include <DataTypes/DataTypesDecimal.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeTuple.h>
-#include <IO/ReadHelpers.h>
-#include <IO/WriteHelpers.h>
-#include <limits>
-
 #include <DataTypes/DataTypeArray.h>
 
 #include <Common/ArenaAllocator.h>
 
-#include <type_traits>
-
-
 namespace DB
 {
 
-template <template <typename> class Comparator>
-struct ComparePairFirst final
+
+struct RankCorrelationData : public StatisticalSample<Float64, Float64>
 {
-    template <typename X, typename Y>
-    bool operator()(const std::pair<X, Y> & lhs, const std::pair<X, Y> & rhs) const
+    Float64 getResult()
     {
-        return Comparator<X>{}(lhs.first, rhs.first);
+        RanksArray ranks_x;
+        std::tie(ranks_x, std::ignore) = computeRanksAndTieCorrection(this->x);
+
+        RanksArray ranks_y;
+        std::tie(ranks_y, std::ignore) = computeRanksAndTieCorrection(this->y);
+
+        /// In our case sizes of both samples are equal.
+        const auto size = this->size_x;
+
+        /// Count d^2 sum
+        Float64 answer = 0;
+        for (size_t j = 0; j < size; ++j)
+            answer += (ranks_x[j] - ranks_y[j]) * (ranks_x[j] - ranks_y[j]);
+
+        answer *= 6;
+        answer /= size * (size * size - 1);
+        answer = 1 - answer;
+        return answer;
     }
 };
 
-
-template <template <typename> class Comparator>
-struct ComparePairSecond final
-{
-    template <typename X, typename Y>
-    bool operator()(const std::pair<X, Y> & lhs, const std::pair<X, Y> & rhs) const
-    {
-        return Comparator<Y>{}(lhs.second, rhs.second);
-    }
-};
-
-template <typename X = Float64, typename Y = Float64>
-struct AggregateFunctionRankCorrelationData final
-{
-    size_t size_x = 0;
-
-    using Allocator = MixedAlignedArenaAllocator<alignof(std::pair<X, Y>), 4096>;
-    using Array = PODArray<std::pair<X, Y>, 32, Allocator>;
-
-    Array values;
-};
-
-template <typename X, typename Y>
 class AggregateFunctionRankCorrelation :
-    public IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationData<X, Y>, AggregateFunctionRankCorrelation<X, Y>>
+    public IAggregateFunctionDataHelper<RankCorrelationData, AggregateFunctionRankCorrelation>
 {
-    using Data = AggregateFunctionRankCorrelationData<X, Y>;
-    using Allocator = MixedAlignedArenaAllocator<alignof(std::pair<Float64, Float64>), 4096>;
-    using Array = PODArray<std::pair<Float64, Float64>, 32, Allocator>;
-
 public:
     explicit AggregateFunctionRankCorrelation(const DataTypes & arguments)
-        :IAggregateFunctionDataHelper<AggregateFunctionRankCorrelationData<X, Y>,AggregateFunctionRankCorrelation<X, Y>> ({arguments}, {})
+        :IAggregateFunctionDataHelper<RankCorrelationData, AggregateFunctionRankCorrelation> ({arguments}, {})
     {}
 
     String getName() const override
@@ -80,24 +63,12 @@ public:
         return std::make_shared<DataTypeNumber<Float64>>();
     }
 
-    void insert(Data & a, const std::pair<X, Y> & x, Arena * arena) const
-    {
-        ++a.size_x;
-        a.values.push_back(x, arena);
-    }
-
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
     {
-        auto & a = this->data(place);
-
-        auto new_x = assert_cast<const ColumnVector<X> &>(*columns[0]).getData()[row_num];
-        auto new_y = assert_cast<const ColumnVector<Y> &>(*columns[1]).getData()[row_num];
-
-        auto new_arg = std::make_pair(new_x, new_y);
-
-        a.size_x += 1;
-
-        a.values.push_back(new_arg, arena);
+        Float64 new_x = columns[0]->getFloat64(row_num);
+        Float64 new_y = columns[1]->getFloat64(row_num);
+        this->data(place).addX(new_x, arena);
+        this->data(place).addY(new_y, arena);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
@@ -105,116 +76,22 @@ public:
         auto & a = this->data(place);
         auto & b = this->data(rhs);
 
-        if (b.size_x)
-            for (size_t i = 0; i < b.size_x; ++i)
-                insert(a, b.values[i], arena);
+        a.merge(b, arena);
     }
 
     void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
     {
-        const auto & value = this->data(place).values;
-        size_t size = this->data(place).size_x;
-        writeVarUInt(size, buf);
-        buf.write(reinterpret_cast<const char *>(value.data()), size * sizeof(value[0]));
+        this->data(place).write(buf);
     }
 
     void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena * arena) const override
     {
-        size_t size = 0;
-        readVarUInt(size, buf);
-
-        auto & value = this->data(place).values;
-
-        value.resize(size, arena);
-        buf.read(reinterpret_cast<char *>(value.data()), size * sizeof(value[0]));
+        this->data(place).read(buf, arena);
     }
 
-    void insertResultInto(AggregateDataPtr place, IColumn & to, Arena * /*arena*/) const override
+    void insertResultInto(AggregateDataPtr place, IColumn & to, Arena *) const override
     {
-        const auto & value = this->data(place).values;
-        size_t size = this->data(place).size_x;
-
-        // create a copy of values not to format data
-        PODArrayWithStackMemory<std::pair<Float64, Float64>, 32> tmp_values;
-        tmp_values.resize(size);
-        for (size_t j = 0; j < size; ++ j)
-            tmp_values[j] = static_cast<std::pair<Float64, Float64>>(value[j]);
-
-        // sort x_values
-        std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairFirst<std::greater>{});
-
-        for (size_t j = 0; j < size;)
-        {
-            // replace x_values with their ranks
-            size_t rank = j + 1;
-            size_t same = 1;
-            size_t cur_sum = rank;
-            size_t cur_start = j;
-
-            while (j < size - 1)
-            {
-                if (tmp_values[j].first == tmp_values[j + 1].first)
-                {
-                    // rank of (j + 1)th number
-                    rank += 1;
-                    ++same;
-                    cur_sum += rank;
-                    ++j;
-                }
-                else
-                    break;
-            }
-
-            // insert rank is calculated as average of ranks of equal values
-            Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
-            for (size_t i = cur_start; i <= j; ++i)
-                tmp_values[i].first = insert_rank;
-            ++j;
-        }
-
-        // sort y_values
-        std::sort(std::begin(tmp_values), std::end(tmp_values), ComparePairSecond<std::greater>{});
-
-        // replace y_values with their ranks
-        for (size_t j = 0; j < size;)
-        {
-            // replace x_values with their ranks
-            size_t rank = j + 1;
-            size_t same = 1;
-            size_t cur_sum = rank;
-            size_t cur_start = j;
-
-            while (j < size - 1)
-            {
-                if (tmp_values[j].second == tmp_values[j + 1].second)
-                {
-                    // rank of (j + 1)th number
-                    rank += 1;
-                    ++same;
-                    cur_sum += rank;
-                    ++j;
-                }
-                else
-                {
-                    break;
-                }
-            }
-
-            // insert rank is calculated as average of ranks of equal values
-            Float64 insert_rank = static_cast<Float64>(cur_sum) / same;
-            for (size_t i = cur_start; i <= j; ++i)
-                tmp_values[i].second = insert_rank;
-            ++j;
-        }
-
-        // count d^2 sum
-        Float64 answer = static_cast<Float64>(0);
-        for (size_t j = 0; j < size; ++ j)
-            answer += (tmp_values[j].first - tmp_values[j].second) * (tmp_values[j].first - tmp_values[j].second);
-
-        answer *= 6;
-        answer /= size * (size * size - 1);
-        answer = 1 - answer;
+        auto answer = this->data(place).getResult();
 
         auto & column = static_cast<ColumnVector<Float64> &>(to);
         column.getData().push_back(answer);
diff --git a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
index e23c220dd3d..5caa30dbdab 100644
--- a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
+++ b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
@@ -8,6 +8,7 @@
 #include <IO/ReadHelpers.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/Moments.h>
 
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypesDecimal.h>
@@ -30,310 +31,6 @@
 namespace DB
 {
 
-namespace ErrorCodes
-{
-    extern const int DECIMAL_OVERFLOW;
-}
-
-
-/**
-    Calculating univariate central moments
-    Levels:
-        level 2 (pop & samp): var, stddev
-        level 3: skewness
-        level 4: kurtosis
-    References:
-        https://en.wikipedia.org/wiki/Moment_(mathematics)
-        https://en.wikipedia.org/wiki/Skewness
-        https://en.wikipedia.org/wiki/Kurtosis
-*/
-template <typename T, size_t _level>
-struct VarMoments
-{
-    T m[_level + 1]{};
-
-    void add(T x)
-    {
-        ++m[0];
-        m[1] += x;
-        m[2] += x * x;
-        if constexpr (_level >= 3) m[3] += x * x * x;
-        if constexpr (_level >= 4) m[4] += x * x * x * x;
-    }
-
-    void merge(const VarMoments & rhs)
-    {
-        m[0] += rhs.m[0];
-        m[1] += rhs.m[1];
-        m[2] += rhs.m[2];
-        if constexpr (_level >= 3) m[3] += rhs.m[3];
-        if constexpr (_level >= 4) m[4] += rhs.m[4];
-    }
-
-    void write(WriteBuffer & buf) const
-    {
-        writePODBinary(*this, buf);
-    }
-
-    void read(ReadBuffer & buf)
-    {
-        readPODBinary(*this, buf);
-    }
-
-    T getPopulation() const
-    {
-        if (m[0] == 0)
-            return std::numeric_limits<T>::quiet_NaN();
-
-        /// Due to numerical errors, the result can be slightly less than zero,
-        /// but it should be impossible. Trim to zero.
-
-        return std::max(T{}, (m[2] - m[1] * m[1] / m[0]) / m[0]);
-    }
-
-    T getSample() const
-    {
-        if (m[0] <= 1)
-            return std::numeric_limits<T>::quiet_NaN();
-        return std::max(T{}, (m[2] - m[1] * m[1] / m[0]) / (m[0] - 1));
-    }
-
-    T getMoment3() const
-    {
-        if (m[0] == 0)
-            return std::numeric_limits<T>::quiet_NaN();
-        // to avoid accuracy problem
-        if (m[0] == 1)
-            return 0;
-        return (m[3]
-            - (3 * m[2]
-                - 2 * m[1] * m[1] / m[0]
-            ) * m[1] / m[0]
-        ) / m[0];
-    }
-
-    T getMoment4() const
-    {
-        if (m[0] == 0)
-            return std::numeric_limits<T>::quiet_NaN();
-        // to avoid accuracy problem
-        if (m[0] == 1)
-            return 0;
-        return (m[4]
-            - (4 * m[3]
-                - (6 * m[2]
-                    - 3 * m[1] * m[1] / m[0]
-                ) * m[1] / m[0]
-            ) * m[1] / m[0]
-        ) / m[0];
-    }
-};
-
-template <typename T, size_t _level>
-class VarMomentsDecimal
-{
-public:
-    using NativeType = typename T::NativeType;
-
-    void add(NativeType x)
-    {
-        ++m0;
-        getM(1) += x;
-
-        NativeType tmp;
-        bool overflow = common::mulOverflow(x, x, tmp) || common::addOverflow(getM(2), tmp, getM(2));
-        if constexpr (_level >= 3)
-            overflow = overflow || common::mulOverflow(tmp, x, tmp) || common::addOverflow(getM(3), tmp, getM(3));
-        if constexpr (_level >= 4)
-            overflow = overflow || common::mulOverflow(tmp, x, tmp) || common::addOverflow(getM(4), tmp, getM(4));
-
-        if (overflow)
-            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
-    }
-
-    void merge(const VarMomentsDecimal & rhs)
-    {
-        m0 += rhs.m0;
-        getM(1) += rhs.getM(1);
-
-        bool overflow = common::addOverflow(getM(2), rhs.getM(2), getM(2));
-        if constexpr (_level >= 3)
-            overflow = overflow || common::addOverflow(getM(3), rhs.getM(3), getM(3));
-        if constexpr (_level >= 4)
-            overflow = overflow || common::addOverflow(getM(4), rhs.getM(4), getM(4));
-
-        if (overflow)
-            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
-    }
-
-    void write(WriteBuffer & buf) const { writePODBinary(*this, buf); }
-    void read(ReadBuffer & buf) { readPODBinary(*this, buf); }
-
-    Float64 getPopulation(UInt32 scale) const
-    {
-        if (m0 == 0)
-            return std::numeric_limits<Float64>::infinity();
-
-        NativeType tmp;
-        if (common::mulOverflow(getM(1), getM(1), tmp) ||
-            common::subOverflow(getM(2), NativeType(tmp / m0), tmp))
-            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
-        return std::max(Float64{}, DecimalUtils::convertTo<Float64>(T(tmp / m0), scale));
-    }
-
-    Float64 getSample(UInt32 scale) const
-    {
-        if (m0 == 0)
-            return std::numeric_limits<Float64>::quiet_NaN();
-        if (m0 == 1)
-            return std::numeric_limits<Float64>::infinity();
-
-        NativeType tmp;
-        if (common::mulOverflow(getM(1), getM(1), tmp) ||
-            common::subOverflow(getM(2), NativeType(tmp / m0), tmp))
-            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
-        return std::max(Float64{}, DecimalUtils::convertTo<Float64>(T(tmp / (m0 - 1)), scale));
-    }
-
-    Float64 getMoment3(UInt32 scale) const
-    {
-        if (m0 == 0)
-            return std::numeric_limits<Float64>::infinity();
-
-        NativeType tmp;
-        if (common::mulOverflow(2 * getM(1), getM(1), tmp) ||
-            common::subOverflow(3 * getM(2), NativeType(tmp / m0), tmp) ||
-            common::mulOverflow(tmp, getM(1), tmp) ||
-            common::subOverflow(getM(3), NativeType(tmp / m0), tmp))
-            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
-        return DecimalUtils::convertTo<Float64>(T(tmp / m0), scale);
-    }
-
-    Float64 getMoment4(UInt32 scale) const
-    {
-        if (m0 == 0)
-            return std::numeric_limits<Float64>::infinity();
-
-        NativeType tmp;
-        if (common::mulOverflow(3 * getM(1), getM(1), tmp) ||
-            common::subOverflow(6 * getM(2), NativeType(tmp / m0), tmp) ||
-            common::mulOverflow(tmp, getM(1), tmp) ||
-            common::subOverflow(4 * getM(3), NativeType(tmp / m0), tmp) ||
-            common::mulOverflow(tmp, getM(1), tmp) ||
-            common::subOverflow(getM(4), NativeType(tmp / m0), tmp))
-            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
-        return DecimalUtils::convertTo<Float64>(T(tmp / m0), scale);
-    }
-
-private:
-    UInt64 m0{};
-    NativeType m[_level]{};
-
-    NativeType & getM(size_t i) { return m[i - 1]; }
-    const NativeType & getM(size_t i) const { return m[i - 1]; }
-};
-
-/**
-    Calculating multivariate central moments
-    Levels:
-        level 2 (pop & samp): covar
-    References:
-        https://en.wikipedia.org/wiki/Moment_(mathematics)
-*/
-template <typename T>
-struct CovarMoments
-{
-    T m0{};
-    T x1{};
-    T y1{};
-    T xy{};
-
-    void add(T x, T y)
-    {
-        ++m0;
-        x1 += x;
-        y1 += y;
-        xy += x * y;
-    }
-
-    void merge(const CovarMoments & rhs)
-    {
-        m0 += rhs.m0;
-        x1 += rhs.x1;
-        y1 += rhs.y1;
-        xy += rhs.xy;
-    }
-
-    void write(WriteBuffer & buf) const
-    {
-        writePODBinary(*this, buf);
-    }
-
-    void read(ReadBuffer & buf)
-    {
-        readPODBinary(*this, buf);
-    }
-
-    T NO_SANITIZE_UNDEFINED getPopulation() const
-    {
-        return (xy - x1 * y1 / m0) / m0;
-    }
-
-    T NO_SANITIZE_UNDEFINED getSample() const
-    {
-        if (m0 == 0)
-            return std::numeric_limits<T>::quiet_NaN();
-        return (xy - x1 * y1 / m0) / (m0 - 1);
-    }
-};
-
-template <typename T>
-struct CorrMoments
-{
-    T m0{};
-    T x1{};
-    T y1{};
-    T xy{};
-    T x2{};
-    T y2{};
-
-    void add(T x, T y)
-    {
-        ++m0;
-        x1 += x;
-        y1 += y;
-        xy += x * y;
-        x2 += x * x;
-        y2 += y * y;
-    }
-
-    void merge(const CorrMoments & rhs)
-    {
-        m0 += rhs.m0;
-        x1 += rhs.x1;
-        y1 += rhs.y1;
-        xy += rhs.xy;
-        x2 += rhs.x2;
-        y2 += rhs.y2;
-    }
-
-    void write(WriteBuffer & buf) const
-    {
-        writePODBinary(*this, buf);
-    }
-
-    void read(ReadBuffer & buf)
-    {
-        readPODBinary(*this, buf);
-    }
-
-    T NO_SANITIZE_UNDEFINED get() const
-    {
-        return (m0 * xy - x1 * y1) / sqrt((m0 * x2 - x1 * x1) * (m0 * y2 - y1 * y1));
-    }
-};
-
-
 enum class StatisticsFunctionKind
 {
     varPop, varSamp,
diff --git a/src/AggregateFunctions/AggregateFunctionStudentTTest.cpp b/src/AggregateFunctions/AggregateFunctionStudentTTest.cpp
new file mode 100644
index 00000000000..be08ae86095
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionStudentTTest.cpp
@@ -0,0 +1,77 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionTTest.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include <AggregateFunctions/Moments.h>
+
+#include "registerAggregateFunctions.h"
+
+
+namespace ErrorCodes
+{
+    extern const int BAD_ARGUMENTS;
+}
+
+
+namespace DB
+{
+
+namespace
+{
+
+/** Student T-test applies to two samples of independent random variables
+  * that have normal distributions with equal (but unknown) variances.
+  * It allows to answer the question whether means of the distributions differ.
+  *
+  * If variances are not considered equal, Welch T-test should be used instead.
+  */
+struct StudentTTestData : public TTestMoments<Float64>
+{
+    static constexpr auto name = "studentTTest";
+
+    std::pair<Float64, Float64> getResult() const
+    {
+        Float64 mean_x = x1 / nx;
+        Float64 mean_y = y1 / ny;
+
+        /// To estimate the variance we first estimate two means.
+        /// That's why the number of degrees of freedom is the total number of values of both samples minus 2.
+        Float64 degrees_of_freedom = nx + ny - 2;
+
+        /// Calculate s^2
+        /// The original formulae looks like
+        /// \frac{\sum_{i = 1}^{n_x}{(x_i - \bar{x}) ^ 2} + \sum_{i = 1}^{n_y}{(y_i - \bar{y}) ^ 2}}{n_x + n_y - 2}
+        /// But we made some mathematical transformations not to store original sequences.
+        /// Also we dropped sqrt, because later it will be squared later.
+
+        Float64 all_x = x2 + nx * mean_x * mean_x - 2 * mean_x * x1;
+        Float64 all_y = y2 + ny * mean_y * mean_y - 2 * mean_y * y1;
+
+        Float64 s2 = (all_x + all_y) / degrees_of_freedom;
+        Float64 std_err2 = s2 * (1. / nx + 1. / ny);
+
+        /// t-statistic
+        Float64 t_stat = (mean_x - mean_y) / sqrt(std_err2);
+
+        return {t_stat, getPValue(degrees_of_freedom, t_stat * t_stat)};
+    }
+};
+
+AggregateFunctionPtr createAggregateFunctionStudentTTest(const std::string & name, const DataTypes & argument_types, const Array & parameters)
+{
+    assertBinary(name, argument_types);
+    assertNoParameters(name, parameters);
+
+    if (!isNumber(argument_types[0]) || !isNumber(argument_types[1]))
+        throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::BAD_ARGUMENTS);
+
+    return std::make_shared<AggregateFunctionTTest<StudentTTestData>>(argument_types);
+}
+
+}
+
+void registerAggregateFunctionStudentTTest(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("studentTTest", createAggregateFunctionStudentTTest);
+}
+
+}
diff --git a/src/AggregateFunctions/AggregateFunctionTTest.h b/src/AggregateFunctions/AggregateFunctionTTest.h
new file mode 100644
index 00000000000..e73ae5e4c36
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionTTest.h
@@ -0,0 +1,154 @@
+#pragma once
+
+#include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/StatCommon.h>
+#include <Columns/ColumnVector.h>
+#include <Columns/ColumnTuple.h>
+#include <Common/assert_cast.h>
+#include <Core/Types.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <cmath>
+
+
+/// This function is used in implementations of different T-Tests.
+/// On Darwin it's unavailable in math.h but actually exists in the library (can be linked successfully).
+#if defined(OS_DARWIN)
+extern "C"
+{
+    double lgamma_r(double x, int * signgamp);
+}
+#endif
+
+
+namespace DB
+{
+
+class ReadBuffer;
+class WriteBuffer;
+
+/**
+ * If you have a cumulative distribution function F, then calculating the p-value for given statistic T is simply 1−F(T)
+ * In our case p-value is two-sided, so we multiply it by 2.
+ * So cumulative distribution function F equals to
+ * \[ F(t) = \int_{-\infty}^{t} f(u)du = 1 - \frac{1}{2} I_{x(t)}(\frac{v}{2}, \frac{1}{2}) \]
+ * where \[ x(t) = \frac{v}{t^2 + v} \]: https://en.wikipedia.org/wiki/Student%27s_t-distribution#Cumulative_distribution_function
+ *
+ * so our resulting \[ p-value = I_{x(t)}(\frac{v}{2}, \frac{1}{2}) \].
+ *
+ * And I is regularized incomplete beta function: https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function
+ *
+ * Keepenig in mind that \[ \mathrm {B} (x;a,b)=\int _{0}^{x}r^{a-1}\,(1-r)^{b-1}\,\mathrm {d} r.\! \]
+ * and
+ * \[ \mathrm {B} (x,y)={\dfrac {\Gamma (x)\,\Gamma (y)}{\Gamma (x+y)}}=\
+ * \exp(\ln {\dfrac {\Gamma (x)\,\Gamma (y)}{\Gamma (x+y)}})=\exp((\ln(\Gamma (x))+\ln(\Gamma (y))-\ln(\Gamma (x+y))) \]
+ *
+ * p-value can be calculated in terms of gamma functions and integrals more simply:
+ * \[ {\frac {\int _{0}^{\frac {\nu }{t^{2}+\nu }}r^{{\frac {\nu }{2}}-1}\,(1-r)^{-0.5}\,\mathrm {d} r}\
+ * {\exp((\ln(\Gamma ({\frac {\nu }{2}}))+\ln(\Gamma (0.5))-\ln(\Gamma ({\frac {\nu }{2}}+0.5)))}} \]
+ *
+ * which simplifies to:
+ *
+ * \[ {\frac {\int _{0}^{\frac {\nu }{t^{2}+\nu }}{\frac {r^{{\frac {\nu }{2}}-1}}{\sqrt {1-r}}}\,\mathrm {d} r}\
+ * {\exp((\ln(\Gamma ({\frac {\nu }{2}}))+\ln(\Gamma (0.5))-\ln(\Gamma ({\frac {\nu }{2}}+0.5)))}} \]
+ *
+ * Read here for details https://rosettacode.org/wiki/Welch%27s_t-test#
+ *
+ * Both WelchTTest and StudentTTest have t-statistric with Student distribution but with different degrees of freedom.
+ * So the procedure of computing p-value is the same.
+*/
+static inline Float64 getPValue(Float64 degrees_of_freedom, Float64 t_stat2)
+{
+    Float64 numerator = integrateSimpson(0, degrees_of_freedom / (t_stat2 + degrees_of_freedom),
+        [degrees_of_freedom](double x) { return std::pow(x, degrees_of_freedom / 2 - 1) / std::sqrt(1 - x); });
+
+    int unused;
+    Float64 denominator = std::exp(
+        lgamma_r(degrees_of_freedom / 2, &unused)
+        + lgamma_r(0.5, &unused)
+        - lgamma_r(degrees_of_freedom / 2 + 0.5, &unused));
+
+    return std::min(1.0, std::max(0.0, numerator / denominator));
+}
+
+
+/// Returns tuple of (t-statistic, p-value)
+/// https://cpb-us-w2.wpmucdn.com/voices.uchicago.edu/dist/9/1193/files/2016/01/05b-TandP.pdf
+template <typename Data>
+class AggregateFunctionTTest :
+    public IAggregateFunctionDataHelper<Data, AggregateFunctionTTest<Data>>
+{
+public:
+    AggregateFunctionTTest(const DataTypes & arguments)
+        : IAggregateFunctionDataHelper<Data, AggregateFunctionTTest<Data>>({arguments}, {})
+    {
+    }
+
+    String getName() const override
+    {
+        return Data::name;
+    }
+
+    DataTypePtr getReturnType() const override
+    {
+        DataTypes types
+        {
+            std::make_shared<DataTypeNumber<Float64>>(),
+            std::make_shared<DataTypeNumber<Float64>>(),
+        };
+
+        Strings names
+        {
+            "t_statistic",
+            "p_value"
+        };
+
+        return std::make_shared<DataTypeTuple>(
+            std::move(types),
+            std::move(names)
+        );
+    }
+
+    void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
+    {
+        Float64 value = columns[0]->getFloat64(row_num);
+        UInt8 is_second = columns[1]->getUInt(row_num);
+
+        if (is_second)
+            this->data(place).addY(value);
+        else
+            this->data(place).addX(value);
+    }
+
+    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
+    {
+        this->data(place).merge(this->data(rhs));
+    }
+
+    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
+    {
+        this->data(place).write(buf);
+    }
+
+    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena *) const override
+    {
+        this->data(place).read(buf);
+    }
+
+    void insertResultInto(AggregateDataPtr place, IColumn & to, Arena *) const override
+    {
+        auto [t_statistic, p_value] = this->data(place).getResult();
+
+        /// Because p-value is a probability.
+        p_value = std::min(1.0, std::max(0.0, p_value));
+
+        auto & column_tuple = assert_cast<ColumnTuple &>(to);
+        auto & column_stat = assert_cast<ColumnVector<Float64> &>(column_tuple.getColumn(0));
+        auto & column_value = assert_cast<ColumnVector<Float64> &>(column_tuple.getColumn(1));
+
+        column_stat.getData().push_back(t_statistic);
+        column_value.getData().push_back(p_value);
+    }
+};
+
+};
diff --git a/src/AggregateFunctions/AggregateFunctionWelchTTest.cpp b/src/AggregateFunctions/AggregateFunctionWelchTTest.cpp
new file mode 100644
index 00000000000..bcaaf0b68fd
--- /dev/null
+++ b/src/AggregateFunctions/AggregateFunctionWelchTTest.cpp
@@ -0,0 +1,74 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionTTest.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include <AggregateFunctions/Moments.h>
+
+#include "registerAggregateFunctions.h"
+
+
+namespace ErrorCodes
+{
+    extern const int BAD_ARGUMENTS;
+}
+
+
+namespace DB
+{
+
+namespace
+{
+
+struct WelchTTestData : public TTestMoments<Float64>
+{
+    static constexpr auto name = "welchTTest";
+
+    std::pair<Float64, Float64> getResult() const
+    {
+        Float64 mean_x = x1 / nx;
+        Float64 mean_y = y1 / ny;
+
+        /// s_x^2, s_y^2
+
+        /// The original formulae looks like  \frac{1}{size_x - 1} \sum_{i = 1}^{size_x}{(x_i - \bar{x}) ^ 2}
+        /// But we made some mathematical transformations not to store original sequences.
+        /// Also we dropped sqrt, because later it will be squared later.
+
+        Float64 sx2 = (x2 + nx * mean_x * mean_x - 2 * mean_x * x1) / (nx - 1);
+        Float64 sy2 = (y2 + ny * mean_y * mean_y - 2 * mean_y * y1) / (ny - 1);
+
+        /// t-statistic
+        Float64 t_stat = (mean_x - mean_y) / sqrt(sx2 / nx + sy2 / ny);
+
+        /// degrees of freedom
+
+        Float64 numerator_sqrt = sx2 / nx + sy2 / ny;
+        Float64 numerator = numerator_sqrt * numerator_sqrt;
+
+        Float64 denominator_x = sx2 * sx2 / (nx * nx * (nx - 1));
+        Float64 denominator_y = sy2 * sy2 / (ny * ny * (ny - 1));
+
+        Float64 degrees_of_freedom = numerator / (denominator_x + denominator_y);
+
+        return {t_stat, getPValue(degrees_of_freedom, t_stat * t_stat)};
+    }
+};
+
+AggregateFunctionPtr createAggregateFunctionWelchTTest(const std::string & name, const DataTypes & argument_types, const Array & parameters)
+{
+    assertBinary(name, argument_types);
+    assertNoParameters(name, parameters);
+
+    if (!isNumber(argument_types[0]) || !isNumber(argument_types[1]))
+        throw Exception("Aggregate function " + name + " only supports numerical types", ErrorCodes::BAD_ARGUMENTS);
+
+    return std::make_shared<AggregateFunctionTTest<WelchTTestData>>(argument_types);
+}
+
+}
+
+void registerAggregateFunctionWelchTTest(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("welchTTest", createAggregateFunctionWelchTTest);
+}
+
+}
diff --git a/src/AggregateFunctions/Moments.h b/src/AggregateFunctions/Moments.h
new file mode 100644
index 00000000000..adf242693c1
--- /dev/null
+++ b/src/AggregateFunctions/Moments.h
@@ -0,0 +1,361 @@
+#pragma once
+
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int DECIMAL_OVERFLOW;
+}
+
+
+/**
+    Calculating univariate central moments
+    Levels:
+        level 2 (pop & samp): var, stddev
+        level 3: skewness
+        level 4: kurtosis
+    References:
+        https://en.wikipedia.org/wiki/Moment_(mathematics)
+        https://en.wikipedia.org/wiki/Skewness
+        https://en.wikipedia.org/wiki/Kurtosis
+*/
+template <typename T, size_t _level>
+struct VarMoments
+{
+    T m[_level + 1]{};
+
+    void add(T x)
+    {
+        ++m[0];
+        m[1] += x;
+        m[2] += x * x;
+        if constexpr (_level >= 3) m[3] += x * x * x;
+        if constexpr (_level >= 4) m[4] += x * x * x * x;
+    }
+
+    void merge(const VarMoments & rhs)
+    {
+        m[0] += rhs.m[0];
+        m[1] += rhs.m[1];
+        m[2] += rhs.m[2];
+        if constexpr (_level >= 3) m[3] += rhs.m[3];
+        if constexpr (_level >= 4) m[4] += rhs.m[4];
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writePODBinary(*this, buf);
+    }
+
+    void read(ReadBuffer & buf)
+    {
+        readPODBinary(*this, buf);
+    }
+
+    T getPopulation() const
+    {
+        if (m[0] == 0)
+            return std::numeric_limits<T>::quiet_NaN();
+
+        /// Due to numerical errors, the result can be slightly less than zero,
+        /// but it should be impossible. Trim to zero.
+
+        return std::max(T{}, (m[2] - m[1] * m[1] / m[0]) / m[0]);
+    }
+
+    T getSample() const
+    {
+        if (m[0] <= 1)
+            return std::numeric_limits<T>::quiet_NaN();
+        return std::max(T{}, (m[2] - m[1] * m[1] / m[0]) / (m[0] - 1));
+    }
+
+    T getMoment3() const
+    {
+        if (m[0] == 0)
+            return std::numeric_limits<T>::quiet_NaN();
+        // to avoid accuracy problem
+        if (m[0] == 1)
+            return 0;
+        /// \[ \frac{1}{m_0} (m_3 - (3 * m_2 - \frac{2 * {m_1}^2}{m_0}) * \frac{m_1}{m_0});\]
+        return (m[3]
+            - (3 * m[2]
+                - 2 * m[1] * m[1] / m[0]
+            ) * m[1] / m[0]
+        ) / m[0];
+    }
+
+    T getMoment4() const
+    {
+        if (m[0] == 0)
+            return std::numeric_limits<T>::quiet_NaN();
+        // to avoid accuracy problem
+        if (m[0] == 1)
+            return 0;
+        /// \[ \frac{1}{m_0}(m_4 - (4 * m_3 - (6 * m_2 - \frac{3 * m_1^2}{m_0} ) \frac{m_1}{m_0})\frac{m_1}{m_0})\]
+        return (m[4]
+            - (4 * m[3]
+                - (6 * m[2]
+                    - 3 * m[1] * m[1] / m[0]
+                ) * m[1] / m[0]
+            ) * m[1] / m[0]
+        ) / m[0];
+    }
+};
+
+template <typename T, size_t _level>
+class VarMomentsDecimal
+{
+public:
+    using NativeType = typename T::NativeType;
+
+    void add(NativeType x)
+    {
+        ++m0;
+        getM(1) += x;
+
+        NativeType tmp;
+        bool overflow = common::mulOverflow(x, x, tmp) || common::addOverflow(getM(2), tmp, getM(2));
+        if constexpr (_level >= 3)
+            overflow = overflow || common::mulOverflow(tmp, x, tmp) || common::addOverflow(getM(3), tmp, getM(3));
+        if constexpr (_level >= 4)
+            overflow = overflow || common::mulOverflow(tmp, x, tmp) || common::addOverflow(getM(4), tmp, getM(4));
+
+        if (overflow)
+            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
+    }
+
+    void merge(const VarMomentsDecimal & rhs)
+    {
+        m0 += rhs.m0;
+        getM(1) += rhs.getM(1);
+
+        bool overflow = common::addOverflow(getM(2), rhs.getM(2), getM(2));
+        if constexpr (_level >= 3)
+            overflow = overflow || common::addOverflow(getM(3), rhs.getM(3), getM(3));
+        if constexpr (_level >= 4)
+            overflow = overflow || common::addOverflow(getM(4), rhs.getM(4), getM(4));
+
+        if (overflow)
+            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
+    }
+
+    void write(WriteBuffer & buf) const { writePODBinary(*this, buf); }
+    void read(ReadBuffer & buf) { readPODBinary(*this, buf); }
+
+    Float64 getPopulation(UInt32 scale) const
+    {
+        if (m0 == 0)
+            return std::numeric_limits<Float64>::infinity();
+
+        NativeType tmp;
+        if (common::mulOverflow(getM(1), getM(1), tmp) ||
+            common::subOverflow(getM(2), NativeType(tmp / m0), tmp))
+            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
+        return std::max(Float64{}, DecimalUtils::convertTo<Float64>(T(tmp / m0), scale));
+    }
+
+    Float64 getSample(UInt32 scale) const
+    {
+        if (m0 == 0)
+            return std::numeric_limits<Float64>::quiet_NaN();
+        if (m0 == 1)
+            return std::numeric_limits<Float64>::infinity();
+
+        NativeType tmp;
+        if (common::mulOverflow(getM(1), getM(1), tmp) ||
+            common::subOverflow(getM(2), NativeType(tmp / m0), tmp))
+            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
+        return std::max(Float64{}, DecimalUtils::convertTo<Float64>(T(tmp / (m0 - 1)), scale));
+    }
+
+    Float64 getMoment3(UInt32 scale) const
+    {
+        if (m0 == 0)
+            return std::numeric_limits<Float64>::infinity();
+
+        NativeType tmp;
+        if (common::mulOverflow(2 * getM(1), getM(1), tmp) ||
+            common::subOverflow(3 * getM(2), NativeType(tmp / m0), tmp) ||
+            common::mulOverflow(tmp, getM(1), tmp) ||
+            common::subOverflow(getM(3), NativeType(tmp / m0), tmp))
+            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
+        return DecimalUtils::convertTo<Float64>(T(tmp / m0), scale);
+    }
+
+    Float64 getMoment4(UInt32 scale) const
+    {
+        if (m0 == 0)
+            return std::numeric_limits<Float64>::infinity();
+
+        NativeType tmp;
+        if (common::mulOverflow(3 * getM(1), getM(1), tmp) ||
+            common::subOverflow(6 * getM(2), NativeType(tmp / m0), tmp) ||
+            common::mulOverflow(tmp, getM(1), tmp) ||
+            common::subOverflow(4 * getM(3), NativeType(tmp / m0), tmp) ||
+            common::mulOverflow(tmp, getM(1), tmp) ||
+            common::subOverflow(getM(4), NativeType(tmp / m0), tmp))
+            throw Exception("Decimal math overflow", ErrorCodes::DECIMAL_OVERFLOW);
+        return DecimalUtils::convertTo<Float64>(T(tmp / m0), scale);
+    }
+
+private:
+    UInt64 m0{};
+    NativeType m[_level]{};
+
+    NativeType & getM(size_t i) { return m[i - 1]; }
+    const NativeType & getM(size_t i) const { return m[i - 1]; }
+};
+
+/**
+    Calculating multivariate central moments
+    Levels:
+        level 2 (pop & samp): covar
+    References:
+        https://en.wikipedia.org/wiki/Moment_(mathematics)
+*/
+template <typename T>
+struct CovarMoments
+{
+    T m0{};
+    T x1{};
+    T y1{};
+    T xy{};
+
+    void add(T x, T y)
+    {
+        ++m0;
+        x1 += x;
+        y1 += y;
+        xy += x * y;
+    }
+
+    void merge(const CovarMoments & rhs)
+    {
+        m0 += rhs.m0;
+        x1 += rhs.x1;
+        y1 += rhs.y1;
+        xy += rhs.xy;
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writePODBinary(*this, buf);
+    }
+
+    void read(ReadBuffer & buf)
+    {
+        readPODBinary(*this, buf);
+    }
+
+    T NO_SANITIZE_UNDEFINED getPopulation() const
+    {
+        return (xy - x1 * y1 / m0) / m0;
+    }
+
+    T NO_SANITIZE_UNDEFINED getSample() const
+    {
+        if (m0 == 0)
+            return std::numeric_limits<T>::quiet_NaN();
+        return (xy - x1 * y1 / m0) / (m0 - 1);
+    }
+};
+
+template <typename T>
+struct CorrMoments
+{
+    T m0{};
+    T x1{};
+    T y1{};
+    T xy{};
+    T x2{};
+    T y2{};
+
+    void add(T x, T y)
+    {
+        ++m0;
+        x1 += x;
+        y1 += y;
+        xy += x * y;
+        x2 += x * x;
+        y2 += y * y;
+    }
+
+    void merge(const CorrMoments & rhs)
+    {
+        m0 += rhs.m0;
+        x1 += rhs.x1;
+        y1 += rhs.y1;
+        xy += rhs.xy;
+        x2 += rhs.x2;
+        y2 += rhs.y2;
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writePODBinary(*this, buf);
+    }
+
+    void read(ReadBuffer & buf)
+    {
+        readPODBinary(*this, buf);
+    }
+
+    T NO_SANITIZE_UNDEFINED get() const
+    {
+        return (m0 * xy - x1 * y1) / sqrt((m0 * x2 - x1 * x1) * (m0 * y2 - y1 * y1));
+    }
+};
+
+/// Data for calculation of Student and Welch T-Tests.
+template <typename T>
+struct TTestMoments
+{
+    T nx{};
+    T ny{};
+    T x1{};
+    T y1{};
+    T x2{};
+    T y2{};
+
+    void addX(T value)
+    {
+        ++nx;
+        x1 += value;
+        x2 += value * value;
+    }
+
+    void addY(T value)
+    {
+        ++ny;
+        y1 += value;
+        y2 += value * value;
+    }
+
+    void merge(const TTestMoments & rhs)
+    {
+        nx += rhs.nx;
+        ny += rhs.ny;
+        x1 += rhs.x1;
+        y1 += rhs.y1;
+        x2 += rhs.x2;
+        y2 += rhs.y2;
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writePODBinary(*this, buf);
+    }
+
+    void read(ReadBuffer & buf)
+    {
+        readPODBinary(*this, buf);
+    }
+};
+
+}
diff --git a/src/AggregateFunctions/StatCommon.h b/src/AggregateFunctions/StatCommon.h
new file mode 100644
index 00000000000..ba887567ad8
--- /dev/null
+++ b/src/AggregateFunctions/StatCommon.h
@@ -0,0 +1,114 @@
+#pragma once
+
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
+#include <Common/ArenaAllocator.h>
+
+#include <numeric>
+#include <algorithm>
+#include <utility>
+
+namespace DB
+{
+
+template <typename F>
+static Float64 integrateSimpson(Float64 a, Float64 b, F && func)
+{
+    const size_t iterations = std::max(1e6, 1e4 * std::abs(std::round(b) - std::round(a)));
+    const long double h = (b - a) / iterations;
+    Float64 sum_odds = 0.0;
+    for (size_t i = 1; i < iterations; i += 2)
+        sum_odds += func(a + i * h);
+    Float64 sum_evens = 0.0;
+    for (size_t i = 2; i < iterations; i += 2)
+        sum_evens += func(a + i * h);
+    return (func(a) + func(b) + 2 * sum_evens + 4 * sum_odds) * h / 3;
+}
+
+/// Because ranks are adjusted, we have to store each of them in Float type.
+using RanksArray = std::vector<Float64>;
+
+template <typename Values>
+std::pair<RanksArray, Float64> computeRanksAndTieCorrection(const Values & values)
+{
+    const size_t size = values.size();
+    /// Save initial positions, than sort indices according to the values.
+    std::vector<size_t> indexes(size);
+    std::iota(indexes.begin(), indexes.end(), 0);
+    std::sort(indexes.begin(), indexes.end(),
+                [&] (size_t lhs, size_t rhs) { return values[lhs] < values[rhs]; });
+
+    size_t left = 0;
+    Float64 tie_numenator = 0;
+    RanksArray out(size);
+    while (left < size)
+    {
+        size_t right = left;
+        while (right < size && values[indexes[left]] == values[indexes[right]])
+            ++right;
+        auto adjusted = (left + right + 1.) / 2.;
+        auto count_equal = right - left;
+        tie_numenator += std::pow(count_equal, 3) - count_equal;
+        for (size_t iter = left; iter < right; ++iter)
+            out[indexes[iter]] = adjusted;
+        left = right;
+    }
+    return {out, 1 - (tie_numenator / (std::pow(size, 3) - size))};
+}
+
+
+template <typename X, typename Y>
+struct StatisticalSample
+{
+    using AllocatorXSample = MixedAlignedArenaAllocator<alignof(X), 4096>;
+    using SampleX = PODArray<X, 32, AllocatorXSample>;
+
+    using AllocatorYSample = MixedAlignedArenaAllocator<alignof(Y), 4096>;
+    using SampleY = PODArray<Y, 32, AllocatorYSample>;
+
+    SampleX x{};
+    SampleY y{};
+    size_t size_x{0};
+    size_t size_y{0};
+
+    void addX(X value, Arena * arena)
+    {
+        ++size_x;
+        x.push_back(value, arena);
+    }
+
+    void addY(Y value, Arena * arena)
+    {
+        ++size_y;
+        y.push_back(value, arena);
+    }
+
+    void merge(const StatisticalSample & rhs, Arena * arena)
+    {
+        size_x += rhs.size_x;
+        size_y += rhs.size_y;
+        x.insert(rhs.x.begin(), rhs.x.end(), arena);
+        y.insert(rhs.y.begin(), rhs.y.end(), arena);
+    }
+
+    void write(WriteBuffer & buf) const
+    {
+        writeVarUInt(size_x, buf);
+        writeVarUInt(size_y, buf);
+        buf.write(reinterpret_cast<const char *>(x.data()), size_x * sizeof(x[0]));
+        buf.write(reinterpret_cast<const char *>(y.data()), size_y * sizeof(y[0]));
+    }
+
+    void read(ReadBuffer & buf, Arena * arena)
+    {
+        readVarUInt(size_x, buf);
+        readVarUInt(size_y, buf);
+        x.resize(size_x, arena);
+        y.resize(size_y, arena);
+        buf.read(reinterpret_cast<char *>(x.data()), size_x * sizeof(x[0]));
+        buf.read(reinterpret_cast<char *>(y.data()), size_y * sizeof(y[0]));
+    }
+};
+
+}
+
diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp
index 90109a98433..41e8d32a3e3 100644
--- a/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -39,9 +39,10 @@ void registerAggregateFunctionSimpleLinearRegression(AggregateFunctionFactory &)
 void registerAggregateFunctionMoving(AggregateFunctionFactory &);
 void registerAggregateFunctionCategoricalIV(AggregateFunctionFactory &);
 void registerAggregateFunctionAggThrow(AggregateFunctionFactory &);
+void registerAggregateFunctionRankCorrelation(AggregateFunctionFactory &);
+void registerAggregateFunctionMannWhitney(AggregateFunctionFactory &);
 void registerAggregateFunctionWelchTTest(AggregateFunctionFactory &);
 void registerAggregateFunctionStudentTTest(AggregateFunctionFactory &);
-void registerAggregateFunctionRankCorrelation(AggregateFunctionFactory &);
 
 class AggregateFunctionCombinatorFactory;
 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
@@ -94,6 +95,9 @@ void registerAggregateFunctions()
         registerAggregateFunctionCategoricalIV(factory);
         registerAggregateFunctionAggThrow(factory);
         registerAggregateFunctionRankCorrelation(factory);
+        registerAggregateFunctionMannWhitney(factory);
+        registerAggregateFunctionWelchTTest(factory);
+        registerAggregateFunctionStudentTTest(factory);
     }
 
     {
diff --git a/src/AggregateFunctions/tests/gtest_ranks.cpp b/src/AggregateFunctions/tests/gtest_ranks.cpp
new file mode 100644
index 00000000000..b29271cbec7
--- /dev/null
+++ b/src/AggregateFunctions/tests/gtest_ranks.cpp
@@ -0,0 +1,27 @@
+#include <IO/WriteBufferFromString.h>
+#include <IO/ReadBufferFromString.h>
+#include <Common/PODArray.h>
+#include <AggregateFunctions/StatCommon.h>
+#include <iostream>
+
+#include <gtest/gtest.h>
+
+
+TEST(Ranks, Simple)
+{
+    using namespace DB;
+    RanksArray sample = {310, 195, 480, 530, 155, 530, 245, 385, 450, 450, 465, 545, 170, 180, 125, 180, 230, 170, 75, 430, 480, 495, 295};
+
+    RanksArray ranks;
+    Float64 t = 0;
+    std::tie(ranks, t) = computeRanksAndTieCorrection(sample);
+
+    RanksArray expected{12.0, 8.0, 18.5, 21.5, 3.0, 21.5, 10.0, 13.0, 15.5, 15.5, 17.0, 23.0, 4.5, 6.5, 2.0, 6.5, 9.0, 4.5, 1.0, 14.0, 18.5, 20.0, 11.0};
+
+    ASSERT_EQ(ranks.size(), expected.size());
+
+    for (size_t i = 0; i < ranks.size(); ++i)
+        ASSERT_DOUBLE_EQ(ranks[i], expected[i]);
+
+    ASSERT_DOUBLE_EQ(t, 0.9975296442687747);
+}
diff --git a/src/AggregateFunctions/ya.make b/src/AggregateFunctions/ya.make
index f5e64f1471b..30b0efdc77f 100644
--- a/src/AggregateFunctions/ya.make
+++ b/src/AggregateFunctions/ya.make
@@ -29,6 +29,7 @@ SRCS(
     AggregateFunctionHistogram.cpp
     AggregateFunctionIf.cpp
     AggregateFunctionMLMethod.cpp
+    AggregateFunctionMannWhitney.cpp
     AggregateFunctionMaxIntersections.cpp
     AggregateFunctionMerge.cpp
     AggregateFunctionMinMaxAny.cpp
@@ -43,6 +44,7 @@ SRCS(
     AggregateFunctionState.cpp
     AggregateFunctionStatistics.cpp
     AggregateFunctionStatisticsSimple.cpp
+    AggregateFunctionStudentTTest.cpp
     AggregateFunctionSum.cpp
     AggregateFunctionSumMap.cpp
     AggregateFunctionTimeSeriesGroupSum.cpp
@@ -50,6 +52,7 @@ SRCS(
     AggregateFunctionUniq.cpp
     AggregateFunctionUniqCombined.cpp
     AggregateFunctionUniqUpTo.cpp
+    AggregateFunctionWelchTTest.cpp
     AggregateFunctionWindowFunnel.cpp
     UniqCombinedBiasData.cpp
     UniqVariadicHash.cpp
diff --git a/tests/queries/0_stateless/01455_rank_correlation_spearman.sql b/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
index f99969e6736..e770b0bb4ff 100644
--- a/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
+++ b/tests/queries/0_stateless/01455_rank_correlation_spearman.sql
@@ -7,7 +7,7 @@ SELECT '1';
 SELECT rankCorr(number, number) FROM numbers(100);
 
 SELECT '-1';
-SELECT rankCorr(number, -1 * number) FROM numbers(100);
+SELECT rankCorr(number, -1 * CAST(number AS Int64)) FROM numbers(100);
 
 SELECT '-0.037';
 SELECT roundBankers(rankCorr(exp(number), sin(number)), 3) FROM numbers(100);
diff --git a/tests/queries/0_stateless/01558_ttest.reference b/tests/queries/0_stateless/01558_ttest.reference
new file mode 100644
index 00000000000..473960c0e7c
--- /dev/null
+++ b/tests/queries/0_stateless/01558_ttest.reference
@@ -0,0 +1,14 @@
+0.021378001462867
+0.0213780014628671
+0.090773324285671
+0.0907733242891952
+0.00339907162713746
+0.0033990715715539
+-0.5028215369186904	0.6152361677168877
+-0.5028215369187079	0.6152361677171103
+14.971190998235835	5.898143508382202e-44
+14.971190998235837	0
+-2.610898982580138	0.00916587538237954
+-2.610898982580134	0.0091658753823834
+-28.740781574102936	7.667329672103986e-133
+-28.74078157410298	0
diff --git a/tests/queries/0_stateless/01558_ttest.sql b/tests/queries/0_stateless/01558_ttest.sql
new file mode 100644
index 00000000000..7a66bba9d2a
--- /dev/null
+++ b/tests/queries/0_stateless/01558_ttest.sql
@@ -0,0 +1,55 @@
+DROP TABLE IF EXISTS welch_ttest;
+CREATE TABLE welch_ttest (left Float64, right UInt8) ENGINE = Memory;
+INSERT INTO welch_ttest VALUES (27.5, 0), (21.0, 0), (19.0, 0), (23.6, 0), (17.0, 0), (17.9, 0), (16.9, 0), (20.1, 0), (21.9, 0), (22.6, 0), (23.1, 0), (19.6, 0), (19.0, 0), (21.7, 0), (21.4, 0), (27.1, 1), (22.0, 1), (20.8, 1), (23.4, 1), (23.4, 1), (23.5, 1), (25.8, 1), (22.0, 1), (24.8, 1), (20.2, 1), (21.9, 1), (22.1, 1), (22.9, 1), (20.5, 1), (24.4, 1);
+
+SELECT '0.021378001462867';
+SELECT roundBankers(welchTTest(left, right).2, 16) from welch_ttest;
+DROP TABLE IF EXISTS welch_ttest;
+
+
+CREATE TABLE welch_ttest (left Float64, right Float64) ENGINE = Memory;
+INSERT INTO welch_ttest VALUES (30.02, 0), (29.99, 0), (30.11, 0), (29.97, 0), (30.01, 0), (29.99, 0), (29.89, 1), (29.93, 1), (29.72, 1), (29.98, 1), (30.02, 1), (29.98, 1);
+SELECT '0.090773324285671';
+SELECT roundBankers(welchTTest(left, right).2, 16) from welch_ttest;
+DROP TABLE IF EXISTS welch_ttest;
+
+CREATE TABLE welch_ttest (left Float64, right Float64) ENGINE = Memory;
+INSERT INTO welch_ttest VALUES (0.010268, 0), (0.000167, 0), (0.000167, 0), (0.159258, 1), (0.136278, 1), (0.122389, 1);
+SELECT '0.00339907162713746';
+SELECT roundBankers(welchTTest(left, right).2, 16) from welch_ttest;
+DROP TABLE IF EXISTS welch_ttest;
+
+CREATE TABLE welch_ttest (left Float64, right Float64) ENGINE = Memory;
+INSERT INTO welch_ttest VALUES (14.72789, 0), (9.61661, 0), (13.57615, 0), (3.98392, 0), (11.98889, 0), (10.99422, 0), (5.44792, 0), (20.29346, 0), (7.05926, 0), (9.22732, 0), (12.06847, 0), (13.52612, 0), (8.24597, 0), (9.35245, 0), (10.12297, 0), (15.80624, 0), (13.68613, 0), (10.72729, 0), (5.62078, 0), (6.12229, 0), (6.03801, 0), (8.95585, 0), (24.04613, 0), (9.04757, 0), (2.68263, 0), (15.43935, 0), (2.89423, 0), (4.01423, 0), (4.30568, 0), (11.99948, 0), (8.40574, 0), (10.86642, 0), (9.4266, 0), (-8.12752, 0), (7.91634, 0), (7.3967, 0), (2.26431, 0), (14.20118, 0), (6.68233, 0), (15.46221, 0), (7.88467, 0), (11.20011, 0), (8.92027, 0), (10.27926, 0), (5.14395, 0), (5.62178, 0), (12.84383, 0), (9.98009, 0), (-0.69789, 0), (11.41386, 0), (7.76863, 0), (7.21743, 0), (1.81176, 0), (9.43762, 0), (19.22117, 0), (2.97128, 0), (14.32851, 0), (7.54959, 0), (3.81545, 0), (10.1281, 0), (2.48596, 0), (10.0461, 0), (3.59714, 0), (9.73522, 0), (18.8077, 0), (3.15148, 0), (12.26062, 0), (5.66707, 0), (6.58623, 0), (17.30902, 0), (9.91391, 0), (5.36946, 0), (15.73637, 0), (16.96281, 0), (11.54063, 0), (18.37358, 0), (11.38255, 0), (10.53256, 0), (8.08833, 0), (16.27556, 0), (2.42969, 0), (9.56127, 0), (7.32998, 0), (9.19511, 0), (9.66903, 0), (4.15029, 0), (8.83511, 0), (14.60617, 0), (14.06143, 0), (5.39556, 0), (10.11871, 0), (10.56619, 0), (14.4462, 0), (10.42106, 0), (7.75551, 0), (11.00418, 0), (4.47226, 0), (16.35461, 0), (18.55174, 0), (11.82044, 0), (7.39454, 0), (11.27767, 0), (6.83827, 0), (7.76858, 0), (15.97614, 0), (14.53781, 0), (12.99546, 0), (16.91151, 0), (9.65012, 0), (14.25487, 0), (14.03618, 0), (2.57382, 0), (2.50779, 0), (14.24787, 0), (13.34666, 0), (7.31102, 0), (10.22981, 0), (17.4435, 0), (21.2074, 0), (6.64191, 0), (18.7086, 0), (14.78686, 0), (9.85287, 0), (4.48263, 0), (14.17469, 0), (14.4342, 0), (19.2481, 0), (3.47165, 0), (8.28712, 0), (8.81657, 0), (0.92319, 0), (20.41106, 0), (6.76127, 0), (22.00242, 0), (8.66129, 0), (10.9929, 0), (17.95494, 0), (17.20996, 0), (12.18888, 0), (12.14257, 0), (15.81243, 0), (4.43362, 0), (1.17567, 0), (15.60881, 0), (9.34833, 0), (6.33513, 0), (-0.83095, 0), (12.43268, 0), (6.63207, 0), (11.96877, 0), (14.81029, 0), (21.84876, 0), (3.75896, 0), (6.91307, 0), (13.73015, 0), (8.63753, 0), (15.71679, 0), (1.74565, 0), (9.16895, 0), (5.70685, 0), (5.00117, 0), (13.06888, 0), (7.51204, 0), (15.34885, 0), (5.20264, 0), (8.59043, 0), (6.45619, 0), (14.61979, 0), (11.7075, 0), (14.04901, 0), (4.20525, 0), (15.1733, 0), (3.12934, 0), (8.08049, 0), (15.41273, 0), (16.90751, 0), (5.86893, 0), (7.1086, 0), (4.418, 0), (12.0614, 0), (7.07887, 0), (3.61585, 0), (11.73001, 0), (10.80449, 0), (8.40311, 0), (9.91276, 0), (16.4164, 0), (5.25034, 0), (15.20283, 0), (10.42909, 0), (9.53888, 0), (14.68939, 0), (6.60007, 0), (18.31058, 0), (7.01885, 0), (18.71631, 0), (10.50002, 0), (10.7517, 0), (4.23224, 0), (2.28924, 0), (8.56059, 0), (8.25095, 0), (9.15673, 0), (13.28409, 0), (8.4513, 0), (2.83911, 0), (2.79676, 0), (9.11055, 0), (7.18529, 0), (-4.1258, 0), (5.28306, 0), (6.82757, 0), (10.89035, 0), (5.24822, 0), (11.935, 0), (6.45675, 0), (10.18088, 0), (4.9932, 0), (18.09939, 0), (8.11738, 0), (5.37883, 0), (10.50339, 0), (16.64093, 0), (14.77263, 0), (13.71385, 0), (6.98746, 0), (10.74635, 0), (5.49432, 0), (13.46078, 0), (10.67565, 0), (9.0291, 0), (11.51417, 0), (13.07118, 0), (9.5049, 0), (8.50611, 0), (6.47606, 0), (13.06526, 0), (19.08658, 0), (9.49741, 0), (10.60865, 0), (2.28996, 0), (8.12846, 0), (5.62241, 0), (4.07712, 0), (17.98526, 0), (9.466, 0), (11.38904, 0), (5.91826, 0), (1.52059, 0), (18.79161, 0), (18.20669, 0), (-1.67829, 0), (18.01586, 0), (16.31577, 0), (7.88281, 0), (8.46179, 0), (10.31113, 0), (14.88377, 0), (1.31835, 0), (2.53176, 0), (9.48625, 0), (3.97936, 0), (11.52319, 0), (13.24178, 0), (7.58739, 0), (10.00959, 0), (9.73361, 0), (8.35716, 0), (1.65491, 0), (11.11521, 0), (6.08355, 0), (10.04582, 0), (11.58237, 0), (16.40249, 0), (1.9691, 0), (13.22776, 0), (2.67059, 0), (9.83651, 0), (2.12539, 0), (9.27114, 0), (9.0699, 0), (2.78179, 0), (12.49311, 0), (12.97662, 0), (15.06359, 0), (16.91565, 0), (5.92011, 0), (5.81304, 0), (8.46425, 0), (9.48705, 0), (4.68191, 0), (5.70028, 0), (-0.78798, 0), (10.03442, 0), (15.45433, 0), (9.43845, 0), (3.05825, 0), (6.92126, 0), (14.05905, 0), (19.71579, 0), (15.0131, 0), (4.50386, 0), (1.31061, 0), (10.81197, 0), (14.32942, 0), (9.26469, 0), (7.27679, 0), (22.69295, 0), (12.03763, 0), (7.34876, 0), (16.60689, 0), (7.48786, 0), (15.78602, 0), (17.21048, 0), (13.93482, 0), (9.69911, 0), (12.24315, 0), (10.58131, 0), (19.57006, 0), (9.8856, 0), (11.70302, 0), (7.89864, 0), (12.24831, 0), (16.93707, 0), (9.65467, 0), (4.221, 0), (15.45229, 0), (12.83088, 0), (7.58313, 0), (12.895, 0), (10.02471, 0), (13.36059, 0), (5.07864, 0), (9.72017, 0), (11.05809, 0), (15.28528, 0), (13.99834, 0), (19.26989, 0), (9.41846, 0), (11.65425, 0), (8.49638, 0), (6.38592, 0), (-4.69837, 0), (12.22061, 0), (9.41331, 0), (13.2075, 0), (12.97005, 0), (11.44352, 0), (9.79805, 0), (6.93116, 0), (10.07691, 0), (22.05892, 0), (7.80353, 0), (-2.17276, 0), (0.61509, 0), (8.35842, 0), (17.77108, 0), (14.70841, 0), (1.27992, 0), (15.62699, 0), (9.32914, 0), (15.41866, 0), (10.82009, 0), (3.29902, 0), (9.21998, 0), (7.93845, 0), (10.33344, 0), (12.06399, 0), (5.5308, 0), (8.38727, 0), (18.11104, 0), (8.86565, 0), (19.41825, 0), (9.52376, 0), (3.94552, 0), (9.37587, 0), (15.44954, 0), (15.90527, 0), (13.18927, 0), (7.01646, 0), (9.06005, 0), (9.06431, 0), (5.76006, 0), (9.18705, 0), (-3.48446, 0), (15.89817, 0), (12.94719, 0), (23.69426, 0), (17.47755, 0), (15.61528, 0), (0.54832, 0), (14.32916, 0), (9.55305, 0), (13.79891, 0), (0.82544, 0), (13.34875, 0), (9.07614, 0), (5.19621, 0), (2.1451, 0), (9.87726, 0), (8.45439, 0), (-1.41842, 0), (7.93598, 0), (11.23151, 0), (17.84458, 0), (7.02237, 0), (10.7842, 0), (4.42832, 0), (4.45044, 0), (1.50938, 0), (21.21651, 0), (6.2097, 0), (6.84354, 0), (18.53804, 0), (12.01072, 0), (4.8345, 0), (20.41587, 0), (14.48353, 0), (8.71116, 0), (12.42818, 0), (14.89244, 0), (8.03033, 0), (5.25917, 0), (2.30092, 0), (10.22504, 0), (15.37573, 0), (7.13666, 0), (4.45018, 0), (10.18405, 0), (3.91025, 0), (14.52304, 0), (13.14771, 0), (11.99219, 0), (9.21345, 0), (8.85106, 0), (12.91887, 0), (15.62308, 0), (11.88034, 0), (15.12097, 0), (11.58168, 0), (16.83051, 0), (5.25405, 0), (2.19976, 0), (4.56716, 0), (16.46053, 0), (5.61995, 0), (8.67704, 0), (5.62789, 0), (9.84815, 0), (13.05834, 0), (11.74205, 0), (3.88393, 0), (16.15321, 0), (4.83925, 0), (13.00334, 0), (4.4028, 0), (4.35794, 0), (4.47478, 0), (2.38713, 0), (4.25235, 0), (10.87509, 0), (9.82411, 0), (13.61518, 0), (10.25507, 0), (4.0335, 0), (10.69881, 0), (5.70321, 0), (6.96244, 0), (9.35874, 0), (6.28076, 0), (8.29015, 0), (6.88653, 0), (7.70687, 0), (8.2001, 0), (6.73415, 0), (3.82052, 0), (3.94469, 0), (15.82384, 0), (2.54004, 0), (10.74876, 0), (12.60517, 0), (17.7024, 0), (4.6722, 0), (13.67341, 0), (6.4565, 0), (12.95699, 0), (4.56912, 0), (5.58464, 0), (4.0638, 0), (13.05559, 0), (5.38269, 0), (0.16354, 0), (7.23962, 0), (7.38577, 0), (8.50951, 0), (13.72574, 0), (17.80421, 0), (3.01135, 0), (8.02608, 0), (14.23847, 0), (-8.65656, 1), (22.98234, 1), (23.80821, 1), (13.33939, 1), (-4.05537, 1), (23.5155, 1), (-6.45272, 1), (17.7903, 1), (11.463, 1), (5.28021, 1), (8.39157, 1), (6.02464, 1), (14.43732, 1), (15.76584, 1), (1.54391, 1), (1.24897, 1), (27.1507, 1), (7.71091, 1), (15.71846, 1), (32.97808, 1), (-1.79334, 1), (-9.23439, 1), (11.27838, 1), (0.72703, 1), (18.51557, 1), (9.16619, 1), (17.29624, 1), (-1.30208, 1), (-3.48018, 1), (10.12082, 1), (-8.01318, 1), (-14.22264, 1), (16.58174, 1), (-0.55975, 1), (5.61449, 1), (1.44626, 1), (7.89158, 1), (1.13369, 1), (-0.82609, 1), (12.23365, 1), (12.45443, 1), (14.46915, 1), (13.72627, 1), (18.41459, 1), (29.66702, 1), (1.51619, 1), (10.40078, 1), (3.33266, 1), (6.12036, 1), (11.86553, 1), (6.59422, 1), (22.0948, 1), (1.79623, 1), (14.29513, 1), (19.69162, 1), (-7.98033, 1), (5.48433, 1), (-2.28474, 1), (9.91876, 1), (10.64097, 1), (0.22523, 1), (17.01773, 1), (22.37388, 1), (14.04215, 1), (23.1244, 1), (18.96958, 1), (8.42663, 1), (3.7165, 1), (14.29366, 1), (23.50886, 1), (26.33722, 1), (26.72396, 1), (13.26287, 1), (12.97607, 1), (17.41838, 1), (8.63875, 1), (17.08943, 1), (23.15356, 1), (-4.4965, 1), (7.58895, 1), (26.04074, 1), (6.84245, 1), (20.56287, 1), (3.84735, 1), (-2.76304, 1), (13.1615, 1), (8.21954, 1), (-3.49943, 1), (22.12419, 1), (7.08323, 1), (16.12937, 1), (-0.32672, 1), (16.5942, 1), (7.68977, 1), (11.39484, 1), (-5.11987, 1), (20.87404, 1), (8.01007, 1), (3.26497, 1), (5.61253, 1), (20.69182, 1), (0.0296, 1), (21.904, 1), (22.46572, 1), (3.63685, 1), (-5.10846, 1), (14.86389, 1), (5.47188, 1), (18.44095, 1), (16.71368, 1), (6.36704, 1), (8.82663, 1), (14.6727, 1), (7.98383, 1), (2.65568, 1), (21.45827, 1), (11.77948, 1), (4.71979, 1), (3.17951, 1), (13.90226, 1), (15.50578, 1), (10.8026, 1), (16.91369, 1), (9.90552, 1), (13.87322, 1), (4.12366, 1), (-3.78985, 1), (1.7599, 1), (3.43715, 1), (-3.45246, 1), (23.64571, 1), (-4.96877, 1), (3.93514, 1), (1.49914, 1), (12.71519, 1), (5.11521, 1), (4.79872, 1), (20.89391, 1), (5.363, 1), (8.02765, 1), (14.30804, 1), (11.49002, 1), (14.25281, 1), (7.6573, 1), (15.49686, 1), (3.29327, 1), (2.27236, 1), (12.58104, 1), (19.19128, 1), (15.25901, 1), (6.5221, 1), (10.10965, 1), (12.75249, 1), (16.50977, 1), (-8.6697, 1), (8.28553, 1), (1.44315, 1), (4.65869, 1), (0.98149, 1), (0.16623, 1), (17.66332, 1), (4.35346, 1), (6.52742, 1), (-1.06631, 1), (-5.28454, 1), (14.25583, 1), (8.74058, 1), (1.89553, 1), (-0.92959, 1), (10.30289, 1), (-6.3744, 1), (-8.1706, 1), (10.95369, 1), (4.94384, 1), (28.40568, 1), (3.7004, 1), (2.52363, 1), (4.07997, 1), (7.8849, 1), (17.95409, 1), (16.67021, 1), (11.34377, 1), (-0.07446, 1), (22.00223, 1), (3.31778, 1), (18.50719, 1), (-3.58655, 1), (6.5394, 1), (12.40459, 1), (16.59866, 1), (7.54176, 1), (-1.51044, 1), (12.69758, 1), (2.9842, 1), (2.49187, 1), (2.04113, 1), (-2.46544, 1), (15.18368, 1), (-0.04058, 1), (-0.4127, 1), (10.5526, 1), (12.03982, 1), (12.10923, 1), (11.54954, 1), (-1.18613, 1), (11.30984, 1), (23.54105, 1), (10.67321, 1), (24.09196, 1), (7.5008, 1), (12.52233, 1), (4.30673, 1), (9.35793, 1), (4.44472, 1), (-7.00679, 1), (8.56241, 1), (23.73891, 1), (15.62708, 1), (16.09205, 1), (12.52074, 1), (14.58927, 1), (-4.80187, 1), (8.47964, 1), (7.75477, 1), (12.6893, 1), (7.14147, 1), (12.12654, 1), (12.32334, 1), (7.98909, 1), (3.26652, 1), (20.53684, 1), (32.3369, 1), (19.74911, 1), (-4.62897, 1), (8.26483, 1), (20.88451, 1), (-2.12982, 1), (25.61459, 1), (5.32091, 1), (-4.1196, 1), (7.57937, 1), (21.15847, 1), (6.46355, 1), (7.74846, 1), (19.62636, 1), (28.34629, 1), (26.73919, 1), (20.40427, 1), (3.03378, 1), (10.2537, 1), (7.47745, 1), (10.79184, 1), (3.91962, 1), (19.97973, 1), (18.87711, 1), (12.56157, 1), (11.46033, 1), (3.78661, 1), (-9.45748, 1), (12.06033, 1), (-0.74615, 1), (13.2815, 1), (24.78052, 1), (5.83337, 1), (17.4111, 1), (19.70331, 1), (11.78446, 1), (-1.366, 1), (1.37458, 1), (16.31483, 1), (32.63464, 1), (-3.79736, 1), (19.17984, 1), (-0.27705, 1), (-3.69456, 1), (28.38058, 1), (-1.36876, 1), (-25.63301, 1), (3.58644, 1), (-6.85667, 1), (13.42225, 1), (12.04671, 1), (28.99468, 1), (7.87662, 1), (2.61119, 1), (-3.56022, 1), (1.50022, 1), (14.55836, 1), (9.35831, 1), (16.9366, 1), (29.23126, 1), (15.31386, 1), (13.46112, 1), (7.39667, 1), (11.15599, 1), (9.80499, 1), (22.64923, 1), (8.67693, 1), (18.67335, 1), (-3.19127, 1), (22.94716, 1), (17.86834, 1), (16.98267, 1), (15.91653, 1), (11.79718, 1), (18.50208, 1), (8.90755, 1), (10.44843, 1), (4.67433, 1), (6.82287, 1), (10.82228, 1), (-4.18631, 1), (20.3872, 1), (11.84735, 1), (21.25376, 1), (10.55032, 1), (12.19023, 1), (0.63369, 1), (7.92381, 1), (17.90933, 1), (15.30781, 1), (10.01877, 1), (0.88744, 1), (22.20967, 1), (-4.23117, 1), (21.50819, 1), (11.27421, 1), (-16.23179, 1), (33.43085, 1), (5.15093, 1), (1.34505, 1), (6.027, 1), (-10.43035, 1), (27.45998, 1), (19.24886, 1), (-4.44761, 1), (5.453, 1), (12.73758, 1), (11.2897, 1), (31.032, 1), (7.39168, 1), (11.95245, 1), (26.279, 1), (-1.0255, 1), (10.36675, 1), (11.58439, 1), (27.8405, 1), (13.1707, 1), (31.39133, 1), (27.08301, 1), (-2.14368, 1), (4.08476, 1), (21.5573, 1), (16.69822, 1), (7.69955, 1), (8.32793, 1), (6.49235, 1), (-7.3284, 1), (10.58264, 1), (-6.17006, 1), (34.55782, 1), (10.93221, 1), (44.24299, 1), (14.6224, 1), (-7.42798, 1), (15.52351, 1), (11.33982, 1), (10.46716, 1), (13.0986, 1), (-4.25988, 1), (9.55316, 1), (0.75489, 1), (25.99212, 1), (-0.81401, 1), (3.49551, 1), (22.99402, 1), (10.99628, 1), (23.70223, 1), (2.71482, 1), (22.82309, 1), (31.25686, 1), (4.86318, 1), (-1.06476, 1), (15.10298, 1), (-0.61015, 1), (17.81246, 1), (-1.55788, 1), (18.09709, 1), (9.11271, 1), (9.94682, 1), (-7.33194, 1), (-4.67293, 1), (21.81717, 1), (7.16318, 1), (13.25649, 1), (13.88776, 1), (4.95793, 1), (17.65303, 1), (14.47382, 1), (13.19373, 1), (31.86093, 1), (5.73161, 1), (10.96492, 1), (6.97951, 1), (1.75136, 1), (10.96144, 1), (15.08137, 1), (9.95311, 1), (7.07729, 1), (3.08148, 1), (22.37954, 1), (8.51951, 1), (2.88746, 1), (26.73509, 1), (-2.88939, 1), (-2.82367, 1), (-0.35783, 1), (14.22076, 1), (11.50295, 1), (7.10171, 1), (8.28488, 1), (0.54178, 1), (13.8022, 1), (15.62157, 1), (10.79173, 1), (28.18946, 1), (30.43524, 1), (2.54914, 1), (9.89421, 1), (13.08631, 1), (4.68761, 1), (5.61516, 1), (22.88072, 1), (7.4735, 1), (11.27382, 1), (2.39559, 1), (-3.31889, 1), (9.61957, 1), (23.01381, 1), (-1.23467, 1), (9.07691, 1), (15.78056, 1), (12.28421, 1), (9.44888, 1), (13.16928, 1), (4.33357, 1), (2.21737, 1), (33.17833, 1), (13.25407, 1), (-2.47961, 1), (6.41401, 1), (18.8439, 1), (-4.63375, 1), (-8.2909, 1), (12.18221, 1), (-2.95356, 1), (19.61659, 1), (12.45056, 1), (-4.17198, 1), (21.9641, 1), (11.96416, 1), (12.74573, 1), (10.47873, 1), (12.73295, 1), (11.31373, 1), (9.9827, 1), (5.87138, 1), (4.24372, 1), (-23.72256, 1), (28.41337, 1), (4.88103, 1), (3.61902, 1), (8.93586, 1), (16.40759, 1), (27.84494, 1), (5.6001, 1), (14.51379, 1), (13.5576, 1), (12.92213, 1), (3.90686, 1), (17.07104, 1), (15.84268, 1), (17.38777, 1), (16.54766, 1), (5.94487, 1), (17.02804, 1), (7.66386, 1), (10.43088, 1), (6.16059, 1), (20.46178, 1), (20.02888, 1), (20.95949, 1), (6.50808, 1), (7.22366, 1), (8.06659, 1), (16.08241, 1), (13.83514, 1), (-0.33454, 1), (12.98848, 1), (12.99024, 1);
+SELECT '-0.5028215369186904', '0.6152361677168877';
+SELECT roundBankers(welchTTest(left, right).1, 16) as t_stat, roundBankers(welchTTest(left, right).2, 16) as p_value from welch_ttest;
+DROP TABLE IF EXISTS welch_ttest;
+
+
+CREATE TABLE welch_ttest (left Float64, right Float64) ENGINE = Memory;
+INSERT INTO welch_ttest VALUES (4.82025, 0), (6.13896, 0), (15.20277, 0), (14.15351, 0), (7.21338, 0), (8.55506, 0), (13.80816, 0), (11.28411, 0), (7.4612, 0), (7.43759, 0), (12.9832, 0), (-5.74783, 0), (12.47114, 0), (15.14223, 0), (3.40603, 0), (9.27323, 0), (7.88547, 0), (8.56456, 0), (4.59731, 0), (7.91213, 0), (7.33894, 0), (21.74811, 0), (11.92111, 0), (0.18828, 0), (10.47314, 0), (20.37396, 0), (11.04991, 0), (13.30083, 0), (14.28065, 0), (2.86942, 0), (24.96072, 0), (14.20164, 0), (18.28769, 0), (10.50949, 0), (9.22273, 0), (11.77608, 0), (8.56872, 0), (13.74535, 0), (11.65209, 0), (12.51894, 0), (17.76256, 0), (13.52122, 0), (8.70796, 0), (6.04749, 0), (16.33064, 0), (8.35636, 0), (14.03496, 0), (11.05834, 0), (14.49261, 0), (2.59383, 0), (8.01022, 0), (4.05458, 0), (13.26384, 0), (14.62058, 0), (10.52489, 0), (8.46357, 0), (6.4147, 0), (9.70071, 0), (12.47581, 0), (4.38333, 0), (17.54172, 0), (10.12109, 0), (7.73186, 0), (14.0279, 0), (11.6621, 0), (17.47045, 0), (15.50223, 0), (15.46034, 0), (13.39964, 0), (14.98025, 0), (15.87912, 0), (17.67374, 0), (9.64073, 0), (12.84904, 0), (7.70278, 0), (13.03156, 0), (9.04512, 0), (15.97014, 0), (8.96389, 0), (11.48009, 0), (9.71153, 0), (13.00084, 0), (12.39803, 0), (13.08188, 0), (5.82244, 0), (10.81871, 0), (8.2539, 0), (7.52114, 0), (9.11488, 0), (8.37482, 0), (14.48652, 0), (11.42152, 0), (16.03111, 0), (13.14057, 0), (-2.26351, 0), (15.50394, 0), (14.88603, 0), (13.37257, 0), (11.84026, 0), (7.66558, 0), (6.24584, 0), (3.6312, 0), (2.7018, 0), (5.63656, 0), (5.82643, 0), (10.06745, 0), (-0.5831, 0), (14.84202, 0), (9.5524, 0), (19.71713, 0), (14.23109, 0), (8.69105, 0), (5.33742, 0), (7.30372, 0), (7.93342, 0), (15.20884, 0), (7.53839, 0), (13.45311, 0), (11.04473, 0), (10.76673, 0), (15.44145, 0), (14.06596, 0), (9.14873, 0), (12.88372, 0), (8.74994, 0), (10.53263, 0), (16.16694, 0), (8.37197, 0), (3.43739, 0), (4.72799, 0), (9.08802, 0), (11.2531, 0), (5.16115, 0), (10.20895, 0), (18.70884, 0), (15.88924, 0), (3.38758, 0), (6.46449, 0), (10.21088, 0), (14.08458, 0), (15.74508, 0), (19.31896, 0), (13.19641, 0), (11.95409, 0), (10.70718, 0), (1.05245, 0), (10.04772, 0), (17.01369, 0), (10.2286, 0), (19.58323, 0), (7.02892, 0), (4.16866, 0), (8.94326, 0), (4.99854, 0), (8.88352, 0), (18.65422, 0), (17.32328, 0), (9.33492, 0), (14.94788, 0), (8.05863, 0), (14.6737, 0), (10.93801, 0), (0.54036, 0), (-0.34242, 0), (5.89076, 0), (3.15189, 0), (1.94421, 0), (6.38698, 0), (10.50654, 0), (8.95362, 0), (6.23711, 0), (11.75359, 0), (12.42155, 0), (-1.55472, 0), (4.6688, 0), (10.48087, 0), (11.74615, 0), (9.26822, 0), (7.55517, 0), (12.76005, 0), (16.47102, 0), (11.31297, 0), (14.37437, 0), (2.38799, 0), (6.44577, 0), (5.07471, 0), (11.55123, 0), (7.76795, 0), (10.60116, 0), (14.40885, 0), (11.58158, 0), (8.81648, 0), (12.92299, 0), (11.26939, 0), (17.95014, 0), (2.95002, 0), (17.41959, 0), (11.12455, 0), (8.78541, 0), (14.36413, 0), (12.98554, 0), (12.58505, 0), (15.49789, 0), (11.70999, 0), (0.65596, 0), (11.08202, 0), (14.75752, 0), (6.84385, 0), (9.27245, 0), (13.78243, 0), (17.4863, 0), (4.01777, 0), (11.82861, 0), (13.86551, 0), (6.16591, 0), (8.71589, 0), (16.77195, 0), (17.23243, 0), (-2.12941, 0), (5.66629, 0), (12.45153, 0), (1.63971, 0), (13.84031, 0), (4.6144, 0), (5.26169, 0), (9.27769, 0), (9.14288, 0), (9.71953, 0), (9.38446, 0), (1.64788, 0), (11.72922, 0), (13.68926, 0), (9.42952, 0), (12.05574, 0), (9.09148, 0), (5.32273, 0), (20.25258, 0), (10.14599, 0), (10.82156, 0), (5.75736, 0), (7.13567, 0), (9.29746, 0), (5.1618, 0), (10.076, 0), (21.65669, 0), (13.35486, 0), (6.79957, 0), (8.76243, 0), (14.59294, 0), (16.90609, 0), (10.50337, 0), (-0.07923, 0), (13.51648, 0), (12.0676, 0), (0.86482, 0), (9.03563, 0), (5.38751, 0), (17.16866, 0), (2.78702, 0), (11.15548, 0), (12.30843, 0), (8.04897, 0), (9.95814, 0), (11.29308, 0), (14.13032, 0), (21.05877, 0), (3.57386, 0), (7.96631, 0), (3.30484, 0), (18.61856, 0), (16.35184, 0), (7.65236, 0), (18.02895, 0), (9.79458, 0), (16.7274, 0), (8.84453, 0), (13.05709, 0), (10.91447, 0), (8.40171, 0), (16.95211, 0), (11.82194, 0), (19.87978, 0), (12.88455, 0), (-0.00947, 0), (12.28109, 0), (6.96462, 0), (13.75282, 0), (14.39141, 0), (11.07193, 0), (12.88039, 0), (11.38253, 0), (21.02707, 0), (7.51955, 0), (6.31984, 0), (15.6543, 0), (14.80315, 0), (8.38024, 0), (21.7516, 0), (14.31336, 0), (15.04703, 0), (5.73787, 0), (13.16911, 0), (12.40695, 0), (9.88968, 0), (8.46703, 0), (8.70637, 0), (8.03551, 0), (5.9757, 0), (12.22951, 0), (3.14736, 0), (10.51266, 0), (18.593, 0), (10.82213, 0), (7.14216, 0), (6.81154, 0), (-0.6486, 0), (20.56136, 0), (11.35367, 0), (11.38205, 0), (17.14, 0), (14.91215, 0), (15.50207, 0), (5.93162, 0), (3.74869, 0), (14.11532, 0), (7.38954, 0), (5.45764, 0), (18.33733, 0), (9.91923, 0), (2.38991, 0), (14.16756, 0), (2.39791, 0), (6.92586, 0), (5.32474, 0), (2.28812, 0), (5.71718, 0), (5.84197, 0), (2.76206, 0), (19.05928, 0), (11.51788, 0), (6.56648, 0), (3.35735, 0), (7.55948, 0), (19.99908, 0), (13.00634, 0), (18.36886, 0), (11.14675, 0), (16.72931, 0), (12.50106, 0), (6.00605, 0), (23.06653, 0), (5.39694, 0), (9.53167, 0), (12.76944, 0), (7.20604, 0), (13.25391, 0), (13.7341, 0), (10.85292, 0), (-7.75835, 0), (10.29728, 0), (13.70099, 0), (10.17959, 0), (9.98399, 0), (12.69389, 0), (-0.28848, 0), (-2.18319, 0), (13.36378, 0), (10.09232, 0), (5.49489, 0), (5.46156, 0), (0.94225, 0), (12.79205, 0), (10.09593, 0), (6.06218, 0), (0.89463, 0), (11.88986, 0), (10.79733, 0), (1.51371, 0), (2.20967, 0), (15.45732, 0), (16.5262, 0), (5.99724, 0), (8.3613, 0), (15.68183, 0), (15.32117, 0), (14.15674, 0), (6.64553, 0), (4.20777, 0), (-0.10521, 0), (-0.88169, 0), (1.85913, 0), (9.73673, 0), (0.30926, 0), (6.17559, 0), (11.76602, 0), (5.68385, 0), (14.57088, 0), (12.81509, 0), (9.85682, 0), (12.06376, 0), (6.08874, 0), (11.63921, 0), (14.86722, 0), (10.41035, 0), (2.93794, 0), (12.21841, 0), (0.23804, 0), (3.14845, 0), (7.29748, 0), (3.06134, 0), (13.77684, 0), (16.21992, 0), (5.33511, 0), (9.68959, 0), (9.44169, 0), (18.08012, 0), (4.04224, 0), (8.77918, 0), (10.18324, 0), (9.38914, 0), (11.76995, 0), (14.19963, 0), (6.88817, 0), (16.56123, 0), (15.39885, 0), (5.21241, 0), (4.44408, 0), (17.87587, 0), (12.53337, 0), (13.60916, 0), (6.60104, 0), (7.35453, 0), (18.61572, 0), (6.10437, 0), (13.08682, 0), (12.15404, 0), (4.90789, 0), (2.13353, 0), (12.49593, 0), (11.93056, 0), (13.29408, 0), (5.70038, 0), (8.40271, 0), (5.19456, 0), (-5.51028, 0), (14.0329, 0), (10.38365, 0), (6.56812, 0), (4.21129, 0), (9.7157, 0), (9.88553, 0), (13.45346, 0), (4.97752, 0), (12.77595, 0), (8.56465, 0), (4.27703, 0), (18.12502, 0), (12.45735, 0), (12.42912, 0), (12.08125, 0), (10.85779, 0), (4.36013, 0), (11.85062, 0), (8.47776, 0), (9.60822, 0), (11.3069, 0), (14.25525, 0), (1.55168, 0), (14.57782, 0), (7.84786, 0), (9.87774, 0), (14.75575, 0), (3.68774, 0), (9.37667, 0), (20.28676, 0), (12.10027, 0), (8.01819, 0), (18.78158, 0), (20.85402, 0), (18.98069, 0), (16.1429, 0), (9.24047, 0), (14.12487, 0), (10.18841, 0), (-3.04478, 0), (5.7552, 0), (9.30376, 0), (11.42837, 0), (6.02364, 0), (8.86984, 0), (10.91177, 0), (10.04418, 0), (18.10774, 0), (7.49384, 0), (9.11556, 0), (9.7051, 0), (5.23268, 0), (9.04647, 0), (8.81547, 0), (2.65098, 0), (-2.69857, 1), (15.80943, 1), (7.31555, 1), (3.96517, 1), (4.77809, 1), (9.6472, 1), (-26.41717, 1), (-10.85635, 1), (-1.4376, 1), (-0.96308, 1), (2.84315, 1), (5.79467, 1), (-3.06091, 1), (-14.62902, 1), (22.08022, 1), (-2.11982, 1), (-4.84824, 1), (-10.50447, 1), (2.4891, 1), (9.90324, 1), (-22.66866, 1), (-0.97103, 1), (-16.57608, 1), (-3.78749, 1), (25.84511, 1), (5.30797, 1), (-18.19466, 1), (11.72708, 1), (0.2891, 1), (-9.83474, 1), (6.69942, 1), (18.09604, 1), (18.52651, 1), (1.38201, 1), (7.64615, 1), (17.66598, 1), (-2.44141, 1), (-9.01598, 1), (27.69142, 1), (4.06946, 1), (-15.0077, 1), (-10.49648, 1), (-4.88322, 1), (-25.09805, 1), (-4.64024, 1), (20.94434, 1), (24.12126, 1), (-14.10962, 1), (10.6512, 1), (14.50687, 1), (-19.88081, 1), (-11.55271, 1), (13.16921, 1), (16.63864, 1), (-24.08114, 1), (-9.09949, 1), (-10.54702, 1), (0.20813, 1), (8.19066, 1), (-2.70523, 1), (-0.23954, 1), (7.19398, 1), (-7.1618, 1), (-7.44322, 1), (-17.92031, 1), (-1.58146, 1), (9.18338, 1), (3.25838, 1), (-14.30234, 1), (1.84695, 1), (31.13794, 1), (-0.85067, 1), (19.02787, 1), (-3.09594, 1), (13.45584, 1), (-5.48104, 1), (-22.74928, 1), (-8.03697, 1), (17.31143, 1), (-16.65231, 1), (-18.58713, 1), (-16.52641, 1), (14.95261, 1), (12.56762, 1), (15.00188, 1), (1.85858, 1), (2.1926, 1), (-2.4095, 1), (21.56873, 1), (3.35509, 1), (-4.98672, 1), (35.08603, 1), (-10.01602, 1), (-3.85153, 1), (-6.81974, 1), (19.56525, 1), (-9.35488, 1), (0.24268, 1), (-3.51488, 1), (-0.37066, 1), (24.20888, 1), (-11.73537, 1), (0.01282, 1), (0.03963, 1), (-9.65589, 1), (-0.37429, 1), (5.61255, 1), (0.49984, 1), (-10.15066, 1), (-14.54314, 1), (16.56889, 1), (-7.73873, 1), (-3.76422, 1), (1.40722, 1), (2.28818, 1), (-13.12643, 1), (5.17082, 1), (4.79089, 1), (-17.42643, 1), (8.72548, 1), (-3.70285, 1), (16.77893, 1), (13.382, 1), (19.98418, 1), (0.00483, 1), (-4.75951, 1), (2.35391, 1), (21.65809, 1), (-9.2714, 1), (-18.38253, 1), (7.23097, 1), (14.97927, 1), (-4.02197, 1), (-29.8189, 1), (-12.8554, 1), (-7.60124, 1), (-14.90158, 1), (-3.31486, 1), (31.38144, 1), (-8.61288, 1), (15.31895, 1), (-10.19488, 1), (13.796, 1), (-0.32912, 1), (-0.0684, 1), (-30.06834, 1), (24.93912, 1), (-3.26506, 1), (-8.29751, 1), (-5.39189, 1), (-25.08603, 1), (-1.45318, 1), (16.72724, 1), (-3.38467, 1), (-26.00478, 1), (7.28369, 1), (16.96226, 1), (16.5858, 1), (10.46583, 1), (3.84345, 1), (-2.99382, 1), (1.42078, 1), (-11.0123, 1), (2.09909, 1), (1.21064, 1), (15.36079, 1), (-21.61349, 1), (22.7726, 1), (10.50512, 1), (-6.95825, 1), (9.20036, 1), (15.66902, 1), (3.28098, 1), (-9.05692, 1), (0.32882, 1), (-1.64934, 1), (-4.81406, 1), (-5.06006, 1), (19.97493, 1), (2.88646, 1), (-0.34552, 1), (7.55186, 1), (-22.96115, 1), (31.29166, 1), (6.18798, 1), (-2.52715, 1), (-11.58799, 1), (14.13596, 1), (13.45069, 1), (12.15179, 1), (3.44491, 1), (-8.78006, 1), (18.32087, 1), (11.91757, 1), (-2.00179, 1), (10.88411, 1), (9.09327, 1), (6.62484, 1), (8.87178, 1), (11.52254, 1), (-14.15988, 1), (-17.19515, 1), (14.03089, 1), (-2.4095, 1), (-16.83575, 1), (2.71469, 1), (4.84351, 1), (-1.17651, 1), (-3.37529, 1), (-19.92137, 1), (4.48952, 1), (-12.4906, 1), (-5.65277, 1), (8.50819, 1), (-19.61261, 1), (12.54156, 1), (11.06784, 1), (-12.59285, 1), (3.43683, 1), (-3.00325, 1), (12.49082, 1), (7.20955, 1), (17.6547, 1), (15.8619, 1), (24.3048, 1), (-8.05434, 1), (-6.06901, 1), (-15.69515, 1), (-11.13917, 1), (-3.90757, 1), (-2.57038, 1), (5.14065, 1), (17.8497, 1), (-8.64665, 1), (-18.68331, 1), (5.8567, 1), (-20.93884, 1), (4.40583, 1), (14.35985, 1), (4.18134, 1), (4.3635, 1), (9.35428, 1), (2.8908, 1), (16.01017, 1), (-1.48499, 1), (-9.97949, 1), (1.03055, 1), (-2.79697, 1), (6.85977, 1), (4.73213, 1), (2.7815, 1), (-2.46866, 1), (18.39425, 1), (-0.80378, 1), (-0.22982, 1), (-16.11608, 1), (3.0862, 1), (3.20779, 1), (10.50146, 1), (-0.21305, 1), (11.21012, 1), (-0.99825, 1), (18.39633, 1), (-3.39003, 1), (-0.64411, 1), (-1.39932, 1), (15.45319, 1), (-0.66044, 1), (-15.2223, 1), (-34.39907, 1), (-3.57836, 1), (16.82828, 1), (1.66624, 1), (15.43475, 1), (8.17776, 1), (5.50486, 1), (10.43082, 1), (-6.63332, 1), (2.28008, 1), (16.37203, 1), (5.16313, 1), (-8.85281, 1), (13.26692, 1), (-7.46842, 1), (8.43091, 1), (-13.18172, 1), (-0.72401, 1), (22.3881, 1), (10.65448, 1), (2.81289, 1), (10.92405, 1), (-8.95358, 1), (19.80653, 1), (-12.86527, 1), (5.38826, 1), (-6.83501, 1), (-15.7647, 1), (-27.67412, 1), (8.6499, 1), (-4.89542, 1), (16.76167, 1), (12.84284, 1), (-17.27324, 1), (-4.18726, 1), (-14.62366, 1), (-5.49863, 1), (-16.22846, 1), (10.60329, 1), (6.46781, 1), (1.70458, 1), (10.77448, 1), (0.8463, 1), (13.0482, 1), (-4.36264, 1), (3.22647, 1), (2.38828, 1), (6.7946, 1), (-0.25254, 1), (1.2497, 1), (1.6544, 1), (4.1019, 1), (11.27839, 1), (-5.04127, 1), (18.11674, 1), (0.51231, 1), (-0.51029, 1), (13.52556, 1), (16.10171, 1), (5.68197, 1), (-2.85904, 1), (-8.89167, 1), (6.24489, 1), (10.85319, 1), (-0.39816, 1), (3.87079, 1), (-3.1867, 1), (1.55322, 1), (16.86779, 1), (-14.60321, 1), (-1.81952, 1), (-3.11624, 1), (1.24193, 1), (10.18179, 1), (4.69796, 1), (0.69032, 1), (11.7723, 1), (7.62896, 1), (9.89741, 1), (9.11484, 1), (-3.84676, 1), (-0.4777, 1), (0.95958, 1), (-7.95056, 1), (-10.97474, 1), (-6.54861, 1), (34.74933, 1), (27.39463, 1), (4.18299, 1), (6.02476, 1), (-1.99397, 1), (1.26478, 1), (23.37106, 1), (10.49682, 1), (-11.04354, 1), (-12.22284, 1), (-9.87635, 1), (28.90511, 1), (6.77613, 1), (0.55352, 1), (0.37031, 1), (7.1418, 1), (3.24897, 1), (-1.60918, 1), (3.1675, 1), (-17.97072, 1), (-5.61743, 1), (14.1422, 1), (14.87695, 1), (-4.65961, 1), (-0.99174, 1), (-2.96623, 1), (-9.02263, 1), (-17.2088, 1), (2.78608, 1), (6.74239, 1), (4.8524, 1), (7.46731, 1), (1.04894, 1), (-12.8023, 1), (-17.18188, 1), (-5.08801, 1), (22.13942, 1), (-0.36384, 1), (17.80564, 1), (7.67504, 1), (1.59779, 1), (4.10942, 1), (0.61074, 1), (-14.40767, 1), (10.59906, 1), (16.57017, 1), (-15.17526, 1), (-6.98549, 1), (-0.64548, 1), (3.23756, 1), (14.65504, 1), (4.583, 1), (12.72378, 1), (5.26547, 1), (0.81781, 1), (9.38273, 1), (10.37636, 1), (10.70325, 1), (-0.83043, 1), (-7.53149, 1), (-9.09147, 1), (-19.51381, 1), (-28.44508, 1), (6.44392, 1), (11.10201, 1), (-2.86184, 1), (8.30673, 1), (8.8797, 1), (10.68053, 1), (15.62919, 1), (8.00579, 1), (6.4651, 1), (-4.50029, 1), (18.04514, 1), (11.12996, 1), (-5.14007, 1), (9.43857, 1), (3.13476, 1), (4.9772, 1), (-17.45782, 1), (0.05552, 1), (-1.90283, 1), (2.67908, 1), (-2.62243, 1), (-3.22767, 1), (-8.70222, 1), (-23.11605, 1), (21.6757, 1), (12.70076, 1), (4.4322, 1), (11.69344, 1), (9.18052, 1), (-2.2549, 1), (-2.15615, 1), (20.29765, 1), (-0.29536, 1), (15.50109, 1), (8.79187, 1), (5.11533, 1), (-20.44436, 1), (-3.00909, 1), (-4.48291, 1), (21.84462, 1), (1.94225, 1), (-2.81908, 1), (17.19418, 1), (-9.33528, 1), (-0.17346, 1), (0.03958, 1), (-35.17786, 1), (8.36887, 1), (-9.02292, 1), (-10.98804, 1), (0.29335, 1), (4.29634, 1), (3.87718, 1), (-9.08532, 1), (7.13922, 1), (-7.62463, 1), (-10.5666, 1), (4.68165, 1), (-3.30172, 1), (13.04852, 1), (13.45616, 1), (2.41043, 1), (-0.36501, 1), (-15.67383, 1), (17.92217, 1), (8.42106, 1), (3.22063, 1), (-7.31753, 1), (21.99596, 1), (-36.8273, 1), (-20.46391, 1), (5.74179, 1), (-15.83178, 1), (14.90454, 1), (-8.84645, 1), (3.72036, 1), (4.6877, 1), (16.35418, 1), (3.15441, 1), (2.39907, 1), (-17.58664, 1), (-13.18269, 1);
+SELECT '14.971190998235835', '5.898143508382202e-44';
+SELECT roundBankers(welchTTest(left, right).1, 16) as t_stat, roundBankers(welchTTest(left, right).2, 16) as p_value from welch_ttest;
+DROP TABLE IF EXISTS welch_ttest;
+
+
+DROP TABLE IF EXISTS student_ttest;
+
+/*Check t-stat and p-value and compare it with scipy.stat implementation
+  First: a=1, sigma (not sigma^2)=5, size=500
+  Second: a=1, sigma = 5, size = 500 */
+CREATE TABLE student_ttest (left Float64, right Float64) ENGINE = Memory;
+INSERT INTO student_ttest VALUES (0.88854, 0), (-5.76966, 0), (6.76618, 0), (3.55546, 0), (-9.76948, 0), (4.92323, 0), (-0.36352, 0), (0.97018, 0), (4.61656, 0), (-6.78292, 0), (4.02008, 0), (12.41838, 0), (5.14417, 0), (3.86836, 0), (-1.26199, 0), (12.44106, 0), (3.28349, 0), (1.77261, 0), (-8.94748, 0), (-1.01449, 0), (-1.26377, 0), (6.79682, 0), (6.32333, 0), (-8.21214, 0), (-1.68565, 0), (9.7557, 0), (3.66694, 0), (1.39967, 0), (-5.52035, 0), (-10.95601, 0), (0.93877, 0), (1.45933, 0), (-5.40551, 0), (-0.83857, 0), (8.50794, 0), (-6.68686, 0), (5.03099, 0), (1.56251, 0), (4.17381, 0), (-2.92644, 0), (5.11068, 0), (2.09617, 0), (11.7787, 0), (6.50336, 0), (0.62098, 0), (-7.97121, 0), (3.81902, 0), (0.33151, 0), (10.68584, 0), (0.56007, 0), (-7.38621, 0), (5.05882, 0), (2.34616, 0), (11.3806, 0), (5.95276, 0), (-3.01429, 0), (5.98169, 0), (0.96985, 0), (-1.15932, 0), (2.11547, 0), (2.49668, 0), (-12.49569, 0), (-4.94667, 0), (-3.64215, 0), (-8.35595, 0), (3.211, 0), (2.33805, 0), (2.38608, 0), (-3.2862, 0), (-0.80454, 0), (-0.53483, 0), (10.66445, 0), (-0.37619, 0), (0.48246, 0), (7.41919, 0), (0.42414, 0), (-2.32335, 0), (-0.70223, 0), (-5.9332, 0), (-1.20561, 0), (3.39865, 0), (9.61739, 0), (-0.78651, 0), (-4.00256, 0), (-7.99646, 0), (8.72923, 0), (0.71859, 0), (-1.62726, 0), (5.11234, 0), (-0.95625, 0), (-3.75573, 0), (1.03141, 0), (-3.33588, 0), (1.51804, 0), (-3.30935, 0), (-1.97507, 0), (4.06456, 0), (3.27195, 0), (-7.81761, 0), (-3.81785, 0), (-4.18311, 0), (-11.33313, 0), (-0.25221, 0), (7.2514, 0), (5.30301, 0), (2.46762, 0), (4.22716, 0), (0.33916, 0), (9.7638, 0), (-7.58684, 0), (-4.09888, 0), (4.26617, 0), (-0.56744, 0), (4.65125, 0), (-1.30301, 0), (4.53771, 0), (9.96929, 0), (3.72939, 0), (-2.29818, 0), (3.09417, 0), (0.82251, 0), (5.29975, 0), (2.8685, 0), (-5.73321, 0), (-1.85651, 0), (-1.07984, 0), (9.78342, 0), (-13.49652, 0), (3.68791, 0), (1.9998, 0), (1.11674, 0), (9.43869, 0), (4.07029, 0), (5.32715, 0), (7.16504, 0), (6.66096, 0), (-5.7111, 0), (-0.38575, 0), (4.49165, 0), (-3.36489, 0), (7.71814, 0), (-1.58966, 0), (-1.61063, 0), (-0.91602, 0), (0.73459, 0), (-3.24463, 0), (6.3947, 0), (-2.77845, 0), (4.45899, 0), (-8.84186, 0), (2.62276, 0), (1.774, 0), (4.3692, 0), (0.05942, 0), (-1.44042, 0), (-2.53594, 0), (-2.24752, 0), (4.98874, 0), (4.05434, 0), (-2.56483, 0), (-6.79286, 0), (-2.06165, 0), (-0.26056, 0), (1.89567, 0), (-3.15145, 0), (-7.31321, 0), (0.28936, 0), (-0.63111, 0), (0.22611, 0), (-9.3377, 0), (-5.76638, 0), (3.87306, 0), (6.7011, 0), (9.03915, 0), (-1.21835, 0), (0.82892, 0), (2.80656, 0), (-1.34746, 0), (-1.99912, 0), (0.6036, 0), (-3.46117, 0), (5.23732, 0), (-1.86702, 0), (-5.86115, 0), (6.48523, 0), (-7.40158, 0), (-1.38913, 0), (4.94613, 0), (-2.07818, 0), (2.39808, 0), (4.89238, 0), (4.39481, 0), (5.20425, 0), (13.62598, 0), (-2.86293, 0), (-3.62396, 0), (-4.28695, 0), (4.66425, 0), (2.20871, 0), (1.60382, 0), (-9.87024, 0), (-7.37302, 0), (-4.17814, 0), (2.5148, 0), (3.21708, 0), (-11.48089, 0), (1.19821, 0), (-0.07436, 0), (-1.10652, 0), (4.03395, 0), (-4.35883, 0), (2.04013, 0), (0.52264, 0), (8.14004, 0), (-8.86949, 0), (-0.35807, 0), (-10.71113, 0), (-2.13755, 0), (0.50715, 0), (6.30826, 0), (2.37527, 0), (0.20872, 0), (-5.85729, 0), (-4.97217, 0), (-9.78434, 0), (-1.53277, 0), (0.14827, 0), (-1.053, 0), (1.74558, 0), (11.17194, 0), (9.35487, 0), (-9.17209, 0), (10.41814, 0), (7.41206, 0), (3.71775, 0), (-2.04674, 0), (6.18037, 0), (5.6383, 0), (-0.90058, 0), (-1.27073, 0), (-2.3473, 0), (-8.44271, 0), (2.75551, 0), (-1.15521, 0), (4.08722, 0), (-1.70399, 0), (7.24114, 0), (-8.43976, 0), (-1.53052, 0), (-0.00526, 0), (-4.04813, 0), (-2.84299, 0), (-5.201, 0), (7.75774, 0), (-2.85791, 0), (-3.86071, 0), (-1.80029, 0), (-5.26015, 0), (-3.158, 0), (7.71014, 0), (-4.84866, 0), (-8.38785, 0), (7.67021, 0), (4.96521, 0), (-0.40919, 0), (-3.25711, 0), (3.07685, 0), (2.89376, 0), (-10.47331, 0), (-3.48942, 0), (1.13906, 0), (-8.57454, 0), (-3.38963, 0), (-2.3195, 0), (-1.60694, 0), (-5.57406, 0), (-0.93075, 0), (-11.76579, 0), (10.68283, 0), (8.74324, 0), (7.66409, 0), (4.76715, 0), (0.44539, 0), (-1.35941, 0), (4.18849, 0), (-6.17097, 0), (0.27977, 0), (-1.45006, 0), (-4.81694, 0), (-3.0297, 0), (0.02145, 0), (2.46883, 0), (9.60317, 0), (-9.93898, 0), (1.05549, 0), (5.55366, 0), (-3.80722, 0), (-4.18851, 0), (1.00351, 0), (3.11385, 0), (-5.17623, 0), (-3.18396, 0), (-6.65302, 0), (-0.50832, 0), (-4.04375, 0), (4.52707, 0), (6.63124, 0), (-3.72082, 0), (5.79825, 0), (-2.0158, 0), (-2.78369, 0), (-1.91821, 0), (6.31714, 0), (-1.80869, 0), (8.55586, 0), (2.40826, 0), (-8.46361, 0), (5.04452, 0), (-0.84665, 0), (2.30903, 0), (-3.71837, 0), (-0.69419, 0), (3.6733, 0), (-1.96098, 0), (2.36747, 0), (-12.03622, 0), (4.38481, 0), (2.93955, 0), (2.16804, 0), (-0.08218, 0), (-3.97934, 0), (-7.43985, 0), (0.91666, 0), (7.23432, 0), (-6.13303, 0), (-10.23217, 0), (-6.21681, 0), (-0.80934, 0), (0.17914, 0), (2.13338, 0), (6.97656, 0), (6.90455, 0), (6.25943, 0), (-6.04019, 0), (-7.30909, 0), (1.4589, 0), (12.00208, 0), (2.22457, 0), (-2.45912, 0), (-6.92213, 0), (4.05547, 0), (0.04709, 0), (-7.70952, 0), (-1.47883, 0), (1.3701, 0), (-4.92928, 0), (-2.75872, 0), (-0.09178, 0), (2.62642, 0), (-1.14623, 0), (2.76609, 0), (4.94404, 0), (-7.01764, 0), (-10.91568, 0), (-2.49738, 0), (0.73576, 0), (2.25436, 0), (-1.72956, 0), (2.41054, 0), (5.72149, 0), (-6.41371, 0), (3.38217, 0), (1.24133, 0), (10.03634, 0), (-2.37303, 0), (-1.35543, 0), (-1.4387, 0), (-4.0976, 0), (-0.82501, 0), (-1.93498, 0), (5.59955, 0), (5.46656, 0), (2.43568, 0), (-0.23926, 0), (-4.9945, 0), (-4.96655, 0), (-0.59258, 0), (2.02497, 0), (0.67583, 0), (3.16522, 0), (-1.9673, 0), (-6.75319, 0), (-6.69723, 0), (0.81148, 0), (4.44531, 0), (-4.43522, 0), (-5.28602, 0), (-3.58829, 0), (-7.97395, 0), (-2.84891, 0), (-3.95112, 0), (3.54945, 0), (12.12376, 0), (-3.12347, 0), (3.65209, 0), (9.34031, 0), (-0.26348, 0), (-5.23968, 0), (2.22336, 0), (-10.70405, 0), (-4.41319, 0), (-5.94912, 0), (1.8147, 0), (7.69287, 0), (9.46125, 0), (4.72497, 0), (-0.57565, 0), (-1.12303, 0), (2.90272, 0), (-4.4584, 0), (4.28819, 0), (11.64512, 0), (-1.80395, 0), (2.51605, 0), (-3.18439, 0), (-0.70213, 0), (-7.68383, 0), (-8.32268, 0), (-8.71115, 0), (9.96933, 0), (0.95675, 0), (3.35114, 0), (-2.66008, 0), (7.75456, 0), (0.73568, 0), (0.3483, 0), (-1.09203, 0), (-7.76963, 0), (5.81902, 0), (-3.41424, 0), (-0.39209, 0), (4.67608, 0), (0.68753, 0), (5.17179, 0), (4.98983, 0), (-0.12659, 0), (3.25267, 0), (1.50184, 0), (2.94507, 0), (-0.42333, 0), (-3.66227, 0), (8.90812, 0), (4.74411, 0), (2.22018, 0), (-2.07976, 0), (4.8711, 0), (0.5023, 0), (6.31569, 0), (-4.36903, 0), (3.82146, 0), (-6.99477, 0), (3.61225, 0), (14.69335, 0), (0.58368, 0), (4.65341, 0), (-3.14272, 0), (2.67048, 0), (4.64963, 0), (-2.70828, 0), (1.42923, 0), (5.84498, 0), (-4.76568, 0), (0.19907, 0), (1.67486, 0), (5.32145, 0), (-8.03477, 0), (3.46776, 0), (4.66374, 0), (-5.37394, 0), (5.39045, 0), (-1.44756, 0), (-1.64419, 0), (3.39699, 0), (-2.94659, 0), (-2.38437, 0), (-0.23958, 0), (6.88389, 0), (-2.7172, 0), (-1.53419, 0), (7.38841, 0), (-5.44178, 0), (-0.89287, 0), (2.93546, 0), (-0.26901, 0), (-4.70044, 0), (2.25846, 0), (-9.28813, 0), (6.04268, 0), (4.41693, 0), (1.75714, 0), (-2.90702, 1), (3.61651, 1), (4.27458, 1), (4.82133, 1), (9.59483, 1), (1.00424, 1), (2.04147, 1), (-3.58214, 1), (6.59543, 1), (-1.00532, 1), (-3.59794, 1), (-2.82434, 1), (-3.13194, 1), (9.90977, 1), (0.523, 1), (4.62779, 1), (-2.56872, 1), (2.25807, 1), (1.04044, 1), (-2.35744, 1), (10.81531, 1), (-9.68469, 1), (3.80885, 1), (12.70435, 1), (-6.01112, 1), (1.89065, 1), (5.08892, 1), (3.45254, 1), (11.58151, 1), (0.85035, 1), (8.38397, 1), (1.17169, 1), (4.74621, 1), (-1.66614, 1), (4.2414, 1), (1.68765, 1), (1.85223, 1), (9.10111, 1), (-2.38085, 1), (-14.79595, 1), (-3.8938, 1), (-3.41864, 1), (-3.15282, 1), (-0.56684, 1), (12.87997, 1), (6.89115, 1), (12.921, 1), (-7.94908, 1), (2.45687, 1), (2.14957, 1), (7.55081, 1), (-3.71534, 1), (-2.41064, 1), (-0.80734, 1), (-4.75651, 1), (2.05241, 1), (-5.44523, 1), (-2.75054, 1), (-13.00131, 1), (-2.74451, 1), (-1.39004, 1), (-3.02854, 1), (7.65112, 1), (1.1245, 1), (6.74117, 1), (-0.75777, 1), (8.93451, 1), (-8.85559, 1), (-0.36405, 1), (4.02742, 1), (6.88718, 1), (-1.05124, 1), (3.04085, 1), (3.32368, 1), (1.147, 1), (3.41554, 1), (-3.47851, 1), (-0.47684, 1), (-0.55605, 1), (-0.17006, 1), (2.26218, 1), (12.45494, 1), (-1.84097, 1), (1.64934, 1), (-7.07496, 1), (-9.99462, 1), (6.09954, 1), (-1.05319, 1), (3.04757, 1), (0.93899, 1), (-4.63243, 1), (-7.43322, 1), (-7.298, 1), (-6.59016, 1), (-6.11649, 1), (0.56682, 1), (2.00661, 1), (-2.79814, 1), (2.84482, 1), (3.65348, 1), (-4.22807, 1), (-4.54336, 1), (-3.63343, 1), (2.96878, 1), (6.11661, 1), (-1.70919, 1), (-4.71133, 1), (6.09652, 1), (-6.83454, 1), (0.18006, 1), (1.51676, 1), (-5.31646, 1), (-3.21215, 1), (-5.07599, 1), (-2.36591, 1), (3.55724, 1), (4.8904, 1), (-3.22586, 1), (-1.74928, 1), (5.73458, 1), (1.41188, 1), (2.86255, 1), (2.90179, 1), (-2.19949, 1), (1.72727, 1), (1.76939, 1), (-0.12848, 1), (-0.52, 1), (3.48333, 1), (7.8262, 1), (0.09099, 1), (7.77017, 1), (9.49484, 1), (1.42825, 1), (1.99624, 1), (4.00419, 1), (1.07925, 1), (-0.09987, 1), (-5.48733, 1), (-1.83517, 1), (2.38059, 1), (1.42075, 1), (-1.11968, 1), (-6.46035, 1), (7.66576, 1), (4.6307, 1), (5.55989, 1), (3.16684, 1), (5.07671, 1), (-10.20566, 1), (-4.73386, 1), (1.28353, 1), (6.75679, 1), (12.09895, 1), (7.0049, 1), (7.16156, 1), (-0.64311, 1), (-0.66747, 1), (3.99996, 1), (9.07298, 1), (-4.60971, 1), (0.70744, 1), (2.56774, 1), (9.32424, 1), (3.95087, 1), (7.11372, 1), (-0.89284, 1), (8.6155, 1), (-0.14141, 1), (-4.86319, 1), (-6.95801, 1), (4.44883, 1), (4.6156, 1), (-2.3579, 1), (-5.1186, 1), (8.12819, 1), (2.78392, 1), (-4.30221, 1), (-1.47506, 1), (6.8598, 1), (0.47636, 1), (0.95383, 1), (7.79779, 1), (-2.61767, 1), (-10.5087, 1), (-2.74299, 1), (3.87369, 1), (-1.07093, 1), (4.98864, 1), (-7.50772, 1), (6.41316, 1), (1.39061, 1), (-3.1747, 1), (-2.13621, 1), (-0.02203, 1), (0.89025, 1), (-5.87746, 1), (3.60026, 1), (-0.23178, 1), (-2.1897, 1), (-5.85101, 1), (-1.6053, 1), (3.6184, 1), (-8.53795, 1), (-0.35987, 1), (2.15301, 1), (-6.60692, 1), (9.54341, 1), (1.11511, 1), (2.94025, 1), (12.05657, 1), (3.75156, 1), (7.95597, 1), (-0.99449, 1), (0.90597, 1), (-7.90627, 1), (3.50863, 1), (-1.47493, 1), (4.11671, 1), (10.06325, 1), (-1.06059, 1), (-1.37737, 1), (-0.42542, 1), (-3.90267, 1), (9.35037, 1), (-7.91219, 1), (-4.69945, 1), (3.63776, 1), (3.46492, 1), (2.84518, 1), (-3.04301, 1), (8.82764, 1), (7.80134, 1), (7.87755, 1), (7.01035, 1), (2.43271, 1), (11.36418, 1), (-6.92659, 1), (5.95541, 1), (3.59436, 1), (5.18429, 1), (4.20225, 1), (0.5029, 1), (4.03074, 1), (5.23152, 1), (10.65409, 1), (-0.69845, 1), (11.70096, 1), (5.80692, 1), (-8.1819, 1), (4.31485, 1), (5.7227, 1), (5.67398, 1), (-1.75826, 1), (7.54164, 1), (-1.79026, 1), (-1.7395, 1), (5.65042, 1), (0.38765, 1), (-4.64719, 1), (-10.22048, 1), (-2.05447, 1), (-2.43441, 1), (-5.38551, 1), (5.47764, 1), (8.26637, 1), (-3.6421, 1), (-11.66269, 1), (3.972, 1), (5.46642, 1), (-3.72304, 1), (5.75251, 1), (5.12841, 1), (0.59067, 1), (5.21138, 1), (-4.58702, 1), (-8.737, 1), (-2.12737, 1), (0.22888, 1), (-1.46448, 1), (2.40311, 1), (-5.21814, 1), (13.94749, 1), (-2.77448, 1), (-3.7867, 1), (3.4954, 1), (3.12586, 1), (-7.01485, 1), (-3.20727, 1), (6.31415, 1), (2.37521, 1), (8.13787, 1), (2.15956, 1), (-0.40842, 1), (-7.27283, 1), (4.27575, 1), (-2.89126, 1), (6.84344, 1), (7.0869, 1), (-5.18837, 1), (2.67648, 1), (-6.57021, 1), (0.60429, 1), (-1.04921, 1), (7.12873, 1), (1.68973, 1), (-2.58404, 1), (-3.83114, 1), (-7.26546, 1), (-5.07153, 1), (-0.80395, 1), (2.09455, 1), (4.33374, 1), (8.54335, 1), (0.80566, 1), (-8.38085, 1), (7.54812, 1), (8.78007, 1), (1.5857, 1), (8.43855, 1), (-1.90846, 1), (-1.2434, 1), (7.16172, 1), (-3.44129, 1), (-6.37542, 1), (-4.99486, 1), (4.99033, 1), (-1.83734, 1), (-2.83289, 1), (-4.13997, 1), (1.40163, 1), (8.57867, 1), (-1.87639, 1), (3.41667, 1), (6.31762, 1), (1.58473, 1), (1.63625, 1), (-6.93618, 1), (3.58046, 1), (-6.8097, 1), (4.69978, 1), (-1.72912, 1), (5.29491, 1), (-1.63062, 1), (5.83818, 1), (17.0769, 1), (4.54301, 1), (-1.33801, 1), (5.64339, 1), (1.26913, 1), (-1.01553, 1), (4.8316, 1), (3.08635, 1), (-2.27738, 1), (-1.13761, 1), (10.08698, 1), (5.33827, 1), (2.84345, 1), (-1.51132, 1), (13.46078, 1), (8.58965, 1), (-2.36683, 1), (-1.8217, 1), (1.96981, 1), (2.31718, 1), (3.66493, 1), (1.93104, 1), (5.20332, 1), (3.20519, 1), (3.34631, 1), (7.0087, 1), (-7.96126, 1), (-0.62182, 1), (-4.65227, 1), (10.6572, 1), (4.50891, 1), (9.74298, 1), (3.85707, 1), (6.41144, 1), (1.48649, 1), (2.28076, 1), (2.75342, 1), (-5.40401, 1), (7.11389, 1), (5.74368, 1), (6.78345, 1), (3.83773, 1), (0.70959, 1), (0.57434, 1), (1.5888, 1), (3.94889, 1), (5.8234, 1), (7.78366, 1), (9.08354, 1), (-7.99182, 1), (-2.77033, 1), (-10.29342, 1), (1.76251, 1), (2.09266, 1), (4.20614, 1), (-3.63064, 1), (-2.17794, 1), (-2.66225, 1), (-2.74707, 1), (-1.93431, 1), (1.38629, 1), (4.12816, 1), (-1.58902, 1), (-5.08864, 1), (-2.30491, 1), (2.64605, 1), (1.16158, 1), (2.63534, 1), (1.4956, 1), (-4.60768, 1), (0.60771, 1), (3.29549, 1), (-1.42592, 1), (0.8883, 1), (-1.10612, 1), (-2.57296, 1), (5.88085, 1), (7.40745, 1), (13.48116, 1), (5.53539, 1), (-1.46014, 1), (3.73304, 1), (3.5435, 1), (-3.89151, 1), (4.16265, 1), (2.32663, 1), (5.31735, 1), (6.33485, 1), (2.1339, 1), (0.82708, 1), (-2.95155, 1), (-6.76019, 1), (-4.20179, 1), (8.78354, 1), (1.41863, 1), (7.65689, 1), (-6.52601, 1), (-4.4426, 1), (-4.49483, 1), (-3.91479, 1), (-2.84562, 1), (2.58974, 1), (2.24424, 1), (-4.65846, 1), (8.4062, 1), (8.20262, 1), (-8.63752, 1), (4.97966, 1), (-0.35563, 1), (-4.72116, 1), (-2.95997, 1), (2.73959, 1), (-0.23956, 1), (10.13915, 1), (11.83775, 1), (-2.50332, 1), (-0.58181, 1), (-7.62836, 1), (2.26478, 1), (-3.50179, 1), (-2.08023, 1), (4.07256, 1), (-1.40826, 1), (-2.33644, 1), (3.00197, 1), (4.23668, 1), (-2.24647, 1), (1.0445, 1), (-0.31901, 1), (8.62657, 1), (3.92817, 1), (0.08462, 1), (10.15884, 1), (0.4113, 1), (4.45847, 1), (5.82941, 1), (6.59202, 1), (-3.73441, 1), (-5.86969, 1), (-4.56543, 1), (-1.32636, 1), (-0.17884, 1), (-3.56181, 1), (-0.66932, 1), (6.87538, 1), (0.73527, 1), (-0.24177, 1), (-0.8657, 1), (-0.22977, 1), (1.02095, 1), (6.16311, 1), (-5.68027, 1), (-3.7619, 1), (4.22959, 1), (-1.5249, 1);
+SELECT '-2.610898982580138', '0.00916587538237954';
+SELECT roundBankers(studentTTest(left, right).1, 16) as t_stat, roundBankers(studentTTest(left, right).2, 16) as p_value from student_ttest;
+DROP TABLE IF EXISTS student_ttest;
+
+/*Check t-stat and p-value and compare it with scipy.stat implementation
+  First: a=1, sigma (not sigma^2)=5, size=500
+  Second: a=1, sigma = 5, size = 500 */
+CREATE TABLE student_ttest (left Float64, right Float64) ENGINE = Memory;
+
+INSERT INTO student_ttest VALUES (4.52546, 0), (8.69444, 1), (3.73628, 0), (3.81414, 1), (-0.39478, 0), (12.38442, 1), (5.15633, 0), (8.9738, 1), (0.50539, 0), (9.19594, 1), (-5.34036, 0), (7.21009, 1), (0.19336, 0), (4.97743, 1), (8.35729, 0), (4.94756, 1), (6.95818, 0), (19.80911, 1), (-2.93812, 0), (13.75358, 1), (8.30807, 0), (16.56373, 1), (-3.3517, 0), (9.72882, 1), (4.16279, 0), (4.64509, 1), (-3.17231, 0), (17.76854, 1), (1.93545, 0), (4.80693, 1), (11.06606, 0), (8.79505, 1), (-4.22678, 0), (10.88868, 1), (-1.99975, 0), (6.21932, 1), (-4.51178, 0), (15.11614, 1), (-4.50711, 0), (13.24703, 1), (1.89786, 0), (14.76476, 1), (-6.19638, 0), (-0.6117, 1), (-3.70188, 0), (17.48993, 1), (5.01334, 0), (12.11847, 1), (1.79036, 0), (4.87439, 1), (2.14435, 0), (18.56479, 1), (3.0282, 0), (1.23712, 1), (2.35528, 0), (5.41596, 1), (-12.18535, 0), (4.54994, 1), (5.59709, 0), (11.37668, 1), (-12.92336, 0), (9.5982, 1), (-0.04281, 0), (6.59822, 1), (-0.16923, 0), (1.16703, 1), (0.88924, 0), (8.88418, 1), (-4.68414, 0), (10.95047, 1), (8.01099, 0), (5.52787, 1), (2.61686, 0), (-1.11647, 1), (-2.76895, 0), (14.49946, 1), (3.32165, 0), (3.27585, 1), (-0.85135, 0), (-0.42025, 1), (1.21368, 0), (6.37906, 1), (4.38673, 0), (2.5242, 1), (6.20964, 0), (8.1405, 1), (-1.23172, 0), (6.46732, 1), (4.65516, 0), (9.89332, 1), (-1.87143, 0), (10.4374, 1), (0.86429, 0), (-1.06465, 1), (2.51184, 0), (6.84902, 1), (-1.88822, 0), (10.96576, 1), (-1.61802, 0), (7.83319, 1), (1.93653, 0), (14.39823, 1), (-3.66631, 0), (7.02594, 1), (-1.05294, 0), (13.46629, 1), (-10.74718, 0), (10.39531, 1), (16.49295, 0), (11.27348, 1), (-7.65494, 0), (9.32187, 1), (-3.39303, 0), (12.32667, 1), (-4.89418, 0), (8.98905, 1), (3.2521, 0), (9.54757, 1), (0.05831, 0), (5.98325, 1), (-3.00409, 0), (3.47248, 1), (5.76702, 0), (9.26966, 1), (2.67674, 0), (5.77816, 1), (10.52623, 0), (6.32966, 1), (-0.54501, 0), (9.49313, 1), (-4.89835, 0), (6.21337, 1), (3.52457, 0), (10.00242, 1), (-0.0451, 0), (6.25167, 1), (-6.61226, 0), (15.64671, 1), (9.02391, 0), (2.78968, 1), (5.52571, 0), (6.55442, 1), (4.54352, 0), (3.68819, 1), (-3.8394, 0), (9.55934, 1), (-7.75295, 0), (4.166, 1), (5.91167, 0), (12.32471, 1), (1.38897, 0), (7.10969, 1), (6.24166, 0), (16.31723, 1), (5.58536, 0), (12.99482, 1), (4.7591, 0), (10.11585, 1), (-2.58336, 0), (10.29455, 1), (-1.91263, 0), (18.27524, 1), (3.31575, 0), (12.84435, 1), (5.3507, 0), (13.11954, 1), (-15.22081, 0), (12.84147, 1), (-0.84775, 0), (15.55658, 1), (-4.538, 0), (11.45329, 1), (6.71177, 0), (7.50912, 1), (0.52882, 0), (8.56226, 1), (2.0242, 0), (8.63104, 1), (5.69146, 0), (15.68026, 1), (4.63328, 0), (21.6361, 1), (0.22984, 0), (6.23925, 1), (-2.84052, 0), (8.65714, 1), (7.91867, 0), (9.9423, 1), (1.11001, 0), (12.28213, 1), (-0.11251, 0), (3.11279, 1), (-0.20905, 0), (13.58128, 1), (0.03287, 0), (16.51407, 1), (-1.59397, 0), (16.60476, 1), (-5.39405, 0), (12.02022, 1), (-7.1233, 0), (12.11035, 1), (4.51517, 0), (9.47832, 1), (-0.70967, 0), (6.40742, 1), (5.67299, 0), (8.87252, 1), (-0.33835, 0), (15.14265, 1), (-1.83047, 0), (2.23572, 1), (-0.62877, 0), (11.57144, 1), (-7.23148, 0), (18.87737, 1), (0.1802, 0), (12.1833, 1), (11.73325, 0), (11.17519, 1), (2.17603, 0), (16.80422, 1), (-0.11683, 0), (6.81423, 1), (-1.29102, 0), (12.12546, 1), (-0.23201, 0), (8.06153, 1), (-6.8643, 0), (10.97228, 1), (-6.85153, 0), (7.30596, 1), (-4.77163, 0), (15.44026, 1), (6.11721, 0), (8.00993, 1), (5.96406, 0), (12.60196, 1), (3.59135, 0), (13.96832, 1), (-0.60095, 0), (14.03207, 1), (3.11163, 0), (4.53758, 1), (-0.18831, 0), (8.08297, 1), (0.67657, 0), (4.90451, 1), (-3.16117, 0), (8.14253, 1), (0.26957, 0), (19.88605, 1), (2.18653, 0), (13.85254, 1), (-5.94611, 0), (23.01839, 1), (-4.39352, 0), (6.02084, 1), (-3.71525, 0), (9.60319, 1), (5.11103, 0), (1.90511, 1), (1.33998, 0), (10.35237, 1), (1.01629, 0), (16.27082, 1), (-3.36917, 0), (12.52379, 1), (-3.99661, 0), (11.37435, 1), (8.19336, 0), (13.61823, 1), (2.89168, 0), (15.77622, 1), (-11.10373, 0), (15.17254, 1), (11.68005, 0), (6.711, 1), (3.08282, 0), (4.74205, 1), (-6.81506, 0), (10.09812, 1), (-2.34587, 0), (6.61722, 1), (-2.68725, 0), (10.34164, 1), (0.3577, 0), (8.96602, 1), (-3.05682, 0), (12.32157, 1), (9.08062, 0), (11.75711, 1), (-0.77913, 0), (13.49499, 1), (10.35215, 0), (8.57713, 1), (6.82565, 0), (11.50313, 1), (-1.24674, 0), (1.13097, 1), (5.18822, 0), (7.83205, 1), (-3.70743, 0), (5.77957, 1), (1.40319, 0), (15.5519, 1), (5.89432, 0), (10.82676, 1), (1.43152, 0), (11.51218, 1), (6.70638, 0), (9.29779, 1), (9.76613, 0), (9.77021, 1), (4.27604, 0), (9.94114, 1), (-2.63141, 0), (15.54513, 1), (-7.8133, 0), (19.10736, 1), (-0.06668, 0), (15.04205, 1), (1.05391, 0), (9.03114, 1), (4.41797, 0), (24.0104, 1), (0.09337, 0), (9.94205, 1), (6.16075, 0), (2.5925, 1), (7.49413, 0), (8.82726, 1), (-3.52872, 0), (10.0209, 1), (-2.17126, 0), (8.1635, 1), (-3.87605, 0), (4.24074, 1), (3.26607, 0), (7.67291, 1), (-3.28045, 0), (5.21642, 1), (2.1429, 0), (11.2808, 1), (1.53386, 0), (6.88172, 1), (0.21169, 0), (5.98743, 1), (-0.63674, 0), (17.97249, 1), (5.84893, 0), (6.46323, 1), (-0.63498, 0), (15.37416, 1), (8.29526, 0), (2.89957, 1), (-1.08358, 0), (17.13044, 1), (-2.306, 0), (11.06355, 1), (2.86991, 0), (3.09625, 1), (-0.76074, 0), (-2.33019, 1), (5.49191, 0), (7.42675, 1), (1.82883, 0), (15.06792, 1), (-3.70497, 0), (8.81116, 1), (-0.53232, 0), (19.17446, 1), (-11.49722, 0), (18.77181, 1), (3.44877, 0), (14.06443, 1), (-1.8596, 0), (12.81241, 1), (-10.34851, 0), (2.72299, 1), (1.13093, 0), (18.67739, 1), (-10.93389, 0), (11.63275, 1), (-3.39703, 0), (2.23891, 1), (0.19749, 0), (13.01195, 1), (-3.68389, 0), (7.43402, 1), (-4.67863, 0), (8.14599, 1), (10.78916, 0), (16.65328, 1), (0.37675, 0), (1.362, 1), (3.98094, 0), (3.87957, 1), (-3.64775, 0), (11.16134, 1), (-4.8443, 0), (6.25357, 1), (1.102, 0), (4.21945, 1), (8.72112, 0), (12.50047, 1), (-1.47361, 0), (6.45486, 1), (6.24183, 0), (18.99924, 1), (6.83569, 0), (18.09508, 1), (-3.11684, 0), (13.59528, 1), (4.91306, 0), (3.39681, 1), (-0.03628, 0), (13.33157, 1), (5.1282, 0), (5.8945, 1), (-2.38558, 0), (5.61212, 1), (2.33351, 0), (8.41149, 1), (-0.97191, 0), (13.78608, 1), (-0.05588, 0), (6.08609, 1), (-4.70019, 0), (12.76962, 1), (-5.12371, 0), (3.26206, 1), (0.65606, 0), (0.25528, 1), (-0.11574, 0), (11.9083, 1), (4.4238, 0), (4.35071, 1), (6.93399, 0), (11.19855, 1), (3.68712, 0), (13.87404, 1), (-0.01187, 0), (6.87986, 1), (1.8332, 0), (8.32566, 1), (5.81322, 0), (22.51334, 1), (-4.04709, 0), (2.5226, 1), (-8.26397, 0), (16.84498, 1), (-2.11273, 0), (6.26108, 1), (5.28396, 0), (13.84824, 1), (0.73054, 0), (6.03262, 1), (6.43559, 0), (14.12668, 1), (4.35565, 0), (16.01939, 1), (-1.05545, 0), (8.19237, 1), (5.00087, 0), (18.01595, 1), (-2.72239, 0), (9.45609, 1), (7.32313, 0), (6.90459, 1), (2.11548, 0), (12.83115, 1), (-3.40953, 0), (10.603, 1), (6.97051, 0), (13.70439, 1), (-0.45567, 0), (6.1633, 1), (1.31699, 0), (4.1151, 1), (-1.49871, 0), (8.20499, 1), (7.14772, 0), (11.67903, 1), (0.79277, 0), (7.30851, 1), (6.9698, 0), (6.50941, 1), (2.08733, 0), (7.3949, 1), (-3.55962, 0), (12.80075, 1), (0.75601, 0), (5.62043, 1), (1.21, 0), (18.2542, 1), (-2.17877, 0), (17.9393, 1), (1.83206, 0), (16.4569, 1), (5.72463, 0), (8.78811, 1), (7.42257, 0), (4.85949, 1), (0.97829, 0), (-3.36394, 1), (7.54238, 0), (5.38683, 1), (9.91081, 0), (12.26083, 1), (-4.61743, 0), (10.27907, 1), (-4.40799, 0), (11.5144, 1), (9.99854, 0), (11.57335, 1), (8.53725, 0), (1.94203, 1), (3.2905, 0), (7.78228, 1), (0.38634, 0), (11.79385, 1), (-2.53374, 0), (10.18415, 1), (4.94758, 0), (14.67613, 1), (4.79624, 0), (4.70301, 1), (5.57664, 0), (12.72151, 1), (-6.44871, 0), (-3.35508, 1), (3.34431, 0), (17.63775, 1), (0.14209, 0), (2.53883, 1), (10.88431, 0), (14.01483, 1), (0.31846, 0), (12.4387, 1), (-0.54703, 0), (11.15408, 1), (-4.67791, 0), (7.74882, 1), (-5.68011, 0), (13.60956, 1), (-4.93362, 0), (7.81991, 1), (1.2271, 0), (10.90969, 1), (5.27512, 0), (8.19828, 1), (-3.84611, 0), (-1.18523, 1), (6.81706, 0), (0.5916, 1), (10.33033, 0), (0.35805, 1), (5.13979, 0), (12.98364, 1), (3.66534, 0), (11.38628, 1), (-2.07219, 0), (13.94644, 1), (10.65442, 0), (2.03781, 1), (-3.31751, 0), (10.74447, 1), (-1.82011, 0), (12.35656, 1), (-0.39886, 0), (7.08701, 1), (1.77052, 0), (2.69871, 1), (1.29049, 0), (19.66653, 1), (7.92344, 0), (7.88636, 1), (-2.92595, 0), (10.36916, 1), (-2.67107, 0), (1.632, 1), (5.64708, 0), (11.86081, 1), (0.34639, 0), (13.47602, 1), (-3.04356, 0), (6.60204, 1), (3.98828, 0), (7.01303, 1), (-1.36695, 0), (20.19992, 1), (-8.48462, 0), (18.88249, 1), (-4.04669, 0), (11.34367, 1), (9.84561, 0), (12.97305, 1), (-6.1537, 0), (9.5776, 1), (0.82433, 0), (17.91364, 1), (1.92449, 0), (18.3247, 1), (2.51288, 0), (9.9211, 1), (0.40965, 0), (7.14257, 1), (2.89183, 0), (6.59133, 1), (3.84347, 0), (12.35274, 1), (0.66829, 0), (10.57523, 1), (-3.45094, 0), (12.12859, 1), (1.3544, 0), (9.47177, 1), (-9.85456, 0), (0.60659, 1), (5.25689, 0), (4.72996, 1), (-5.26018, 0), (4.51121, 1), (-6.16912, 0), (13.28893, 1), (-1.77163, 0), (8.09014, 1), (3.96687, 0), (8.02511, 1), (0.70893, 0), (13.85406, 1), (-5.45342, 0), (1.75412, 1), (-3.89706, 0), (6.00641, 1), (3.11868, 0), (6.35554, 1), (4.41714, 0), (7.11293, 1), (7.64841, 0), (8.30442, 1), (0.00489, 0), (12.63024, 1), (3.2263, 0), (12.38966, 1), (-5.33042, 0), (7.6801, 1), (2.52189, 0), (11.33744, 1), (-7.40308, 0), (4.67713, 1), (0.67891, 0), (7.62276, 1), (2.49343, 0), (2.14478, 1), (5.43133, 0), (15.32988, 1), (-0.67541, 0), (1.52299, 1), (-0.60299, 0), (17.00017, 1), (-6.32903, 0), (8.29701, 1), (-3.44336, 0), (10.92961, 1), (-0.23963, 0), (6.78449, 1), (6.94686, 0), (7.02698, 1), (6.59442, 0), (11.51719, 1), (-4.18532, 0), (9.97926, 1), (-1.8228, 0), (7.44251, 1), (-0.29443, 0), (7.58541, 1), (2.99821, 0), (4.76058, 1), (2.51942, 0), (12.88959, 1), (-3.49176, 0), (9.974, 1), (-0.57979, 0), (17.03689, 1), (8.69471, 0), (11.14554, 1), (-1.19427, 0), (11.7392, 1), (-3.17119, 0), (11.50029, 1), (-2.99566, 0), (19.41759, 1), (-3.34493, 0), (9.65127, 1), (-2.33826, 0), (9.87673, 1), (-5.04164, 0), (14.13485, 1), (-0.48214, 0), (9.78034, 1), (7.45097, 0), (1.57826, 1), (3.04787, 0), (3.72091, 1), (2.92632, 0), (9.4054, 1), (1.39694, 0), (23.22816, 1), (4.38686, 0), (-0.12571, 1), (3.25753, 0), (6.97343, 1), (7.14218, 0), (10.09049, 1), (-4.04341, 0), (11.78393, 1), (-9.19352, 0), (3.01909, 1), (2.78473, 0), (16.09448, 1), (0.33331, 0), (6.25485, 1), (9.89238, 0), (7.13164, 1), (6.00566, 0), (7.75879, 1), (-1.7511, 0), (9.56834, 1), (4.77815, 0), (6.14824, 1), (5.07457, 0), (13.53454, 1), (2.56132, 0), (8.26364, 1), (2.38317, 0), (8.7095, 1), (-1.63486, 0), (10.61607, 1), (-1.46871, 0), (10.64418, 1), (-5.8681, 0), (23.9106, 1), (-2.96227, 0), (11.38978, 1), (-1.90638, 0), (11.4383, 1), (-13.3052, 0), (18.41498, 1), (-2.14705, 0), (3.70959, 1), (-9.62069, 0), (19.95918, 1), (2.29313, 0), (9.53847, 1), (0.22162, 0), (14.04957, 1), (-1.83956, 0), (13.70151, 1), (4.1853, 0), (5.45046, 1), (6.05965, 0), (10.95061, 1), (-0.23737, 0), (9.55156, 1), (6.07452, 0), (17.92345, 1), (4.34629, 0), (6.23976, 1), (4.02922, 0), (8.71029, 1), (3.62622, 0), (13.58736, 1), (-3.95825, 0), (8.78527, 1), (-1.63412, 0), (11.14213, 1), (-1.25727, 0), (12.23717, 1), (5.06323, 0), (16.44557, 1), (-0.66176, 0), (0.47144, 1), (2.36606, 0), (9.7198, 1), (-5.77792, 0), (13.50981, 1), (4.535, 0), (14.27806, 1), (1.02031, 0), (13.50793, 1), (4.49345, 0), (7.47381, 1), (-4.99791, 0), (11.07844, 1), (2.46716, 0), (9.89844, 1), (3.65471, 0), (21.48548, 1), (11.2283, 0), (6.92085, 1), (6.69743, 0), (4.44074, 1), (-5.60375, 0), (19.98074, 1), (0.28683, 0), (7.92826, 1), (-0.85737, 0), (16.6313, 1), (4.26726, 0), (17.17618, 1), (-3.4322, 0), (13.80807, 1), (-2.07039, 0), (5.37083, 1), (-2.26798, 0), (9.73962, 1), (-0.99818, 0), (10.66273, 1), (0.41335, 0), (8.90639, 1), (5.18124, 0), (12.24596, 1), (-5.01858, 0), (16.89203, 1), (2.05561, 0), (12.69184, 1), (-0.12117, 0), (15.59077, 1), (0.99471, 0), (6.94287, 1), (6.89979, 0), (-0.1801, 1), (-4.18527, 0), (3.25318, 1), (-6.35104, 0), (8.08804, 1), (3.89734, 0), (13.78384, 1), (-1.979, 0), (0.46434, 1), (3.15404, 0), (7.78224, 1), (3.52672, 0), (9.10987, 1), (2.48372, 0), (-0.89391, 1), (-6.13089, 0), (14.3696, 1), (2.2968, 0), (3.01763, 1), (-2.74324, 0), (8.03559, 1), (-0.12876, 0), (7.24609, 1), (-1.51135, 0), (11.86271, 1), (-3.92434, 0), (6.28196, 1), (-1.71254, 0), (8.9725, 1), (-1.25878, 0), (14.46114, 1), (2.03021, 0), (9.50216, 1), (4.31726, 0), (16.30413, 1), (-3.02908, 0), (1.02795, 1), (9.7093, 0), (1.88717, 1), (-3.36284, 0), (9.80106, 1), (6.70938, 0), (4.53487, 1), (0.42762, 0), (16.34543, 1), (5.04726, 0), (7.71098, 1), (2.78386, 0), (2.74639, 1), (6.83022, 0), (6.51875, 1), (-3.02109, 0), (10.42308, 1), (-0.65382, 0), (13.57901, 1), (-15.58675, 0), (0.52784, 1), (5.89746, 0), (4.4708, 1), (-4.11598, 0), (6.39619, 1), (-1.37208, 0), (14.57666, 1), (10.08082, 0), (2.71602, 1), (5.35686, 0), (12.53905, 1), (1.93331, 0), (11.4292, 1), (10.47444, 0), (12.44641, 1), (-2.36872, 0), (14.50894, 1), (6.50752, 0), (17.64374, 1), (2.54603, 0), (11.03218, 1), (-0.4332, 0), (9.82789, 1), (5.26572, 0), (10.11104, 1), (2.09016, 0), (2.16137, 1), (1.15513, 0), (10.24054, 1), (14.95941, 0), (12.86909, 1), (-3.85505, 0), (15.22845, 1), (-2.36239, 0), (5.05411, 1), (1.64338, 0), (10.84836, 1), (-4.25074, 0), (11.15717, 1), (7.29744, 0), (0.91782, 1), (-1.18964, 0), (13.29961, 1), (5.60612, 0), (15.11314, 1), (-3.77011, 0), (11.54004, 1), (6.67642, 0), (-0.94238, 1), (-0.06862, 0), (19.32581, 1), (5.60514, 0), (10.20744, 1), (3.7341, 0), (6.54857, 1), (9.59001, 0), (8.69108, 1), (3.30093, 0), (8.2296, 1), (-2.75658, 0), (8.4474, 1), (4.71994, 0), (6.81178, 1), (0.74699, 0), (5.99415, 1), (2.91095, 0), (13.99336, 1), (-7.36829, 0), (8.7469, 1), (-5.29487, 0), (8.62349, 1), (3.31079, 0), (1.84212, 1), (1.06974, 0), (4.4762, 1), (-1.18424, 0), (9.25421, 1), (-7.415, 0), (10.44229, 1), (3.40595, 0), (12.21649, 1), (-7.63085, 0), (10.45968, 1), (1.13336, 0), (15.34722, 1), (-0.0096, 0), (5.50868, 1), (0.8928, 0), (10.93609, 1), (-0.5943, 0), (2.78631, 1), (7.48306, 0), (11.86145, 1), (10.11943, 0), (18.67385, 1), (5.60459, 0), (10.64051, 1), (4.00189, 0), (12.75565, 1), (2.35823, 0), (6.63666, 1), (0.33475, 0), (12.19343, 1), (3.47072, 0), (9.08636, 1), (-6.68867, 0), (11.67256, 1), (3.31031, 0), (20.31392, 1), (2.17159, 0), (11.66443, 1);
+SELECT '-28.740781574102936', '7.667329672103986e-133';
+SELECT roundBankers(studentTTest(left, right).1, 16) as t_stat, roundBankers(studentTTest(left, right).2, 16) as p_value from student_ttest;
+DROP TABLE IF EXISTS student_ttest;
diff --git a/tests/queries/0_stateless/01558_ttest_scipy.python b/tests/queries/0_stateless/01558_ttest_scipy.python
new file mode 100644
index 00000000000..4d913d4292f
--- /dev/null
+++ b/tests/queries/0_stateless/01558_ttest_scipy.python
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3                                                                                                                                                                                              
+import os
+import sys
+from scipy import stats
+import pandas as pd
+import numpy as np
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
+
+from pure_http_client import ClickHouseClient
+
+def test_and_check(name, a, b, t_stat, p_value, precision=1e-2):
+    client = ClickHouseClient()
+    client.query("DROP TABLE IF EXISTS ttest;")
+    client.query("CREATE TABLE ttest (left Float64, right UInt8) ENGINE = Memory;");
+    client.query("INSERT INTO ttest VALUES {};".format(", ".join(['({},{})'.format(i, 0) for i in a])))
+    client.query("INSERT INTO ttest VALUES {};".format(", ".join(['({},{})'.format(j, 1) for j in b])))
+    real = client.query_return_df(
+        "SELECT roundBankers({}(left, right).1, 16) as t_stat, ".format(name) +
+               "roundBankers({}(left, right).2, 16) as p_value ".format(name) + 
+        "FROM ttest FORMAT TabSeparatedWithNames;")
+    real_t_stat = real['t_stat'][0]
+    real_p_value = real['p_value'][0]
+    assert(abs(real_t_stat - np.float64(t_stat)) < precision), "clickhouse_t_stat {}, scipy_t_stat {}".format(real_t_stat, t_stat)
+    assert(abs(real_p_value - np.float64(p_value)) < precision), "clickhouse_p_value {}, scipy_p_value {}".format(real_p_value, p_value)
+    client.query("DROP TABLE IF EXISTS ttest;")
+
+
+def test_student():
+    rvs1 = np.round(stats.norm.rvs(loc=1, scale=5,size=500), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=10, scale=5,size=500), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = True)
+    test_and_check("studentTTest", rvs1, rvs2, s, p)
+
+    rvs1 = np.round(stats.norm.rvs(loc=0, scale=5,size=500), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=0, scale=5,size=500), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = True)
+    test_and_check("studentTTest", rvs1, rvs2, s, p)
+
+    rvs1 = np.round(stats.norm.rvs(loc=2, scale=10,size=512), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=5, scale=20,size=1024), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = True)
+    test_and_check("studentTTest", rvs1, rvs2, s, p)
+
+    rvs1 = np.round(stats.norm.rvs(loc=0, scale=10,size=1024), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=0, scale=10,size=512), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = True)
+    test_and_check("studentTTest", rvs1, rvs2, s, p)
+
+def test_welch():
+    rvs1 = np.round(stats.norm.rvs(loc=1, scale=15,size=500), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=10, scale=5,size=500), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = False)
+    test_and_check("welchTTest", rvs1, rvs2, s, p)
+
+    rvs1 = np.round(stats.norm.rvs(loc=0, scale=7,size=500), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=0, scale=3,size=500), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = False)
+    test_and_check("welchTTest", rvs1, rvs2, s, p)
+
+    rvs1 = np.round(stats.norm.rvs(loc=0, scale=10,size=1024), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=5, scale=1,size=512), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = False)
+    test_and_check("welchTTest", rvs1, rvs2, s, p)
+
+    rvs1 = np.round(stats.norm.rvs(loc=5, scale=10,size=512), 2)
+    rvs2 = np.round(stats.norm.rvs(loc=5, scale=10,size=1024), 2)
+    s, p = stats.ttest_ind(rvs1, rvs2, equal_var = False)
+    test_and_check("welchTTest", rvs1, rvs2, s, p)
+
+if __name__ == "__main__":
+    test_student()
+    test_welch()
+    print("Ok.")
\ No newline at end of file
diff --git a/tests/queries/0_stateless/01558_ttest_scipy.reference b/tests/queries/0_stateless/01558_ttest_scipy.reference
new file mode 100644
index 00000000000..587579af915
--- /dev/null
+++ b/tests/queries/0_stateless/01558_ttest_scipy.reference
@@ -0,0 +1 @@
+Ok.
diff --git a/tests/queries/0_stateless/01558_ttest_scipy.sh b/tests/queries/0_stateless/01558_ttest_scipy.sh
new file mode 100755
index 00000000000..bd203478586
--- /dev/null
+++ b/tests/queries/0_stateless/01558_ttest_scipy.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. "$CURDIR"/../shell_config.sh
+
+# We should have correct env vars from shell_config.sh to run this test
+
+python3 "$CURDIR"/01558_ttest_scipy.python
diff --git a/tests/queries/0_stateless/01560_mann_whitney.reference b/tests/queries/0_stateless/01560_mann_whitney.reference
new file mode 100644
index 00000000000..5a718fdca97
--- /dev/null
+++ b/tests/queries/0_stateless/01560_mann_whitney.reference
@@ -0,0 +1,5 @@
+(223,0.5426959774289524)
+223.0	0.5426959774289482
+223	0.5426959774289524
+223	0.5426959774289524
+223	0.5426959774289524
diff --git a/tests/queries/0_stateless/01560_mann_whitney.sql b/tests/queries/0_stateless/01560_mann_whitney.sql
new file mode 100644
index 00000000000..6e1ac55349d
--- /dev/null
+++ b/tests/queries/0_stateless/01560_mann_whitney.sql
@@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS mann_whitney_test;
+CREATE TABLE mann_whitney_test (left Float64, right UInt8) ENGINE = Memory;
+INSERT INTO mann_whitney_test VALUES (310, 0), (195, 0), (530, 0), (155, 0), (530, 0), (245, 0), (385, 0), (450, 0), (465, 0), (545, 0), (170, 0), (180, 0), (125, 0), (180, 0), (230, 0), (75, 0), (430, 0), (480, 0), (495, 0), (295, 0), (116, 1), (171, 1), (176, 1), (421, 1), (111, 1), (326, 1), (481, 1), (111, 1), (346, 1), (441, 1), (261, 1), (411, 1), (206, 1), (521, 1), (456, 1), (446, 1), (296, 1), (51, 1), (426, 1), (261, 1);
+SELECT mannWhitneyUTest(left, right) from mann_whitney_test;
+SELECT '223.0', '0.5426959774289482';
+WITH mannWhitneyUTest(left, right) AS pair SELECT roundBankers(pair.1, 16) as t_stat, roundBankers(pair.2, 16) as p_value from mann_whitney_test;
+WITH mannWhitneyUTest('two-sided', 1)(left, right) as pair SELECT roundBankers(pair.1, 16) as t_stat, roundBankers(pair.2, 16) as p_value from mann_whitney_test;
+WITH mannWhitneyUTest('two-sided')(left, right) as pair SELECT roundBankers(pair.1, 16) as t_stat, roundBankers(pair.2, 16) as p_value from mann_whitney_test;
+DROP TABLE IF EXISTS mann_whitney_test;
diff --git a/tests/queries/0_stateless/01561_mann_whitney_scipy.python b/tests/queries/0_stateless/01561_mann_whitney_scipy.python
new file mode 100644
index 00000000000..7958e8bbaf1
--- /dev/null
+++ b/tests/queries/0_stateless/01561_mann_whitney_scipy.python
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+import os
+import sys
+from scipy import stats
+import pandas as pd
+import numpy as np
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
+
+from pure_http_client import ClickHouseClient
+
+
+def test_and_check(name, a, b, t_stat, p_value):
+    client = ClickHouseClient()
+    client.query("DROP TABLE IF EXISTS mann_whitney;")
+    client.query("CREATE TABLE mann_whitney (left Float64, right UInt8) ENGINE = Memory;");
+    client.query("INSERT INTO mann_whitney VALUES {};".format(", ".join(['({},{}), ({},{})'.format(i, 0, j, 1) for i,j in zip(a, b)])))
+
+    real = client.query_return_df(
+        "SELECT roundBankers({}(left, right).1, 16) as t_stat, ".format(name) +
+               "roundBankers({}(left, right).2, 16) as p_value ".format(name) + 
+        "FROM mann_whitney FORMAT TabSeparatedWithNames;")
+    real_t_stat = real['t_stat'][0]
+    real_p_value = real['p_value'][0]
+    assert(abs(real_t_stat - np.float64(t_stat) < 1e-2)), "clickhouse_t_stat {}, scipy_t_stat {}".format(real_t_stat, t_stat)
+    assert(abs(real_p_value - np.float64(p_value)) < 1e-2), "clickhouse_p_value {}, scipy_p_value {}".format(real_p_value, p_value)
+    client.query("DROP TABLE IF EXISTS mann_whitney;")
+
+
+def test_mann_whitney():
+    rvs1 = np.round(stats.norm.rvs(loc=1, scale=5,size=500), 5)
+    rvs2 = np.round(stats.expon.rvs(scale=0.2,size=500), 5)
+    s, p = stats.mannwhitneyu(rvs1, rvs2, alternative='two-sided')
+    test_and_check("mannWhitneyUTest", rvs1, rvs2, s, p)
+    test_and_check("mannWhitneyUTest('two-sided')", rvs1, rvs2, s, p)
+
+    equal = np.round(stats.cauchy.rvs(scale=5, size=500), 5)
+    s, p = stats.mannwhitneyu(equal, equal, alternative='two-sided')
+    test_and_check("mannWhitneyUTest('two-sided')", equal, equal, s, p)
+
+    s, p = stats.mannwhitneyu(equal, equal, alternative='less', use_continuity=False)
+    test_and_check("mannWhitneyUTest('less', 0)", equal, equal, s, p)
+
+
+    rvs1 = np.round(stats.cauchy.rvs(scale=10,size=65536), 5)
+    rvs2 = np.round(stats.norm.rvs(loc=0, scale=10,size=65536), 5)
+    s, p = stats.mannwhitneyu(rvs1, rvs2, alternative='greater')
+    test_and_check("mannWhitneyUTest('greater')", rvs1, rvs2, s, p)
+
+if __name__ == "__main__":
+    test_mann_whitney()
+    print("Ok.") 
\ No newline at end of file
diff --git a/tests/queries/0_stateless/01561_mann_whitney_scipy.reference b/tests/queries/0_stateless/01561_mann_whitney_scipy.reference
new file mode 100644
index 00000000000..587579af915
--- /dev/null
+++ b/tests/queries/0_stateless/01561_mann_whitney_scipy.reference
@@ -0,0 +1 @@
+Ok.
diff --git a/tests/queries/0_stateless/01561_mann_whitney_scipy.sh b/tests/queries/0_stateless/01561_mann_whitney_scipy.sh
new file mode 100755
index 00000000000..e4e9152a97d
--- /dev/null
+++ b/tests/queries/0_stateless/01561_mann_whitney_scipy.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. "$CURDIR"/../shell_config.sh
+
+# We should have correct env vars from shell_config.sh to run this test
+
+python3 "$CURDIR"/01561_mann_whitney_scipy.python
\ No newline at end of file
diff --git a/tests/queries/0_stateless/helpers/pure_http_client.py b/tests/queries/0_stateless/helpers/pure_http_client.py
new file mode 100644
index 00000000000..4e18ab3a0f4
--- /dev/null
+++ b/tests/queries/0_stateless/helpers/pure_http_client.py
@@ -0,0 +1,49 @@
+import os  
+import io                                                                                                                                                                                                         
+import sys       
+import requests
+import time
+import pandas as pd
+
+CLICKHOUSE_HOST = os.environ.get('CLICKHOUSE_HOST', '127.0.0.1')
+CLICKHOUSE_PORT_HTTP = os.environ.get('CLICKHOUSE_PORT_HTTP', '8123')
+CLICKHOUSE_SERVER_URL_STR = 'http://' + ':'.join(str(s) for s in [CLICKHOUSE_HOST, CLICKHOUSE_PORT_HTTP]) + "/"
+
+class ClickHouseClient:
+    def __init__(self, host = CLICKHOUSE_SERVER_URL_STR):
+        self.host = host
+
+    def query(self, query, connection_timeout = 1500):
+        NUMBER_OF_TRIES = 30
+        DELAY = 10
+
+        for i in range(NUMBER_OF_TRIES):
+            r = requests.post(
+                self.host, 
+                params = {'timeout_before_checking_execution_speed': 120, 'max_execution_time': 6000},
+                timeout = connection_timeout,
+                data = query)
+            if r.status_code == 200:
+                return r.text
+            else:
+                print('ATTENTION: try #%d failed' % i)
+                if i != (NUMBER_OF_TRIES-1):
+                    print(query)
+                    print(r.text)
+                    time.sleep(DELAY*(i+1))
+                else:
+                    raise ValueError(r.text)
+
+    def query_return_df(self, query, connection_timeout = 1500):
+        data = self.query(query, connection_timeout) 
+        df = pd.read_csv(io.StringIO(data), sep = '\t')
+        return df
+
+    def query_with_data(self, query, content):
+        content = content.encode('utf-8')
+        r = requests.post(self.host, data=content)
+        result = r.text
+        if r.status_code == 200:
+            return result
+        else:
+            raise ValueError(r.text)
\ No newline at end of file