Merge pull request #16636 from hombit/cmath

Add some of missed cmath functions

src/Functions/acosh.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathUnary.h>
+
+namespace DB
+{
+namespace
+{
+    struct AcoshName
+    {
+        static constexpr auto name = "acosh";
+    };
+    using FunctionAcosh = FunctionMathUnary<UnaryFunctionVectorized<AcoshName, acosh>>;
+
+}
+
+void registerFunctionAcosh(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAcosh>();
+}
+
+}

src/Functions/asinh.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathUnary.h>
+
+namespace DB
+{
+namespace
+{
+    struct AsinhName
+    {
+        static constexpr auto name = "asinh";
+    };
+    using FunctionAsinh = FunctionMathUnary<UnaryFunctionVectorized<AsinhName, asinh>>;
+
+}
+
+void registerFunctionAsinh(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAsinh>();
+}
+
+}

src/Functions/atan2.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathBinaryFloat64.h>
+
+namespace DB
+{
+namespace
+{
+    struct Atan2Name
+    {
+        static constexpr auto name = "atan2";
+    };
+    using FunctionAtan2 = FunctionMathBinaryFloat64<BinaryFunctionVectorized<Atan2Name, atan2>>;
+
+}
+
+void registerFunctionAtan2(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAtan2>(FunctionFactory::CaseInsensitive);
+}
+
+}

src/Functions/atanh.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathUnary.h>
+
+namespace DB
+{
+namespace
+{
+    struct AtanhName
+    {
+        static constexpr auto name = "atanh";
+    };
+    using FunctionAtanh = FunctionMathUnary<UnaryFunctionVectorized<AtanhName, atanh>>;
+
+}
+
+void registerFunctionAtanh(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAtanh>();
+}
+
+}

src/Functions/cosh.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathUnary.h>
+
+namespace DB
+{
+namespace
+{
+    struct CoshName
+    {
+        static constexpr auto name = "cosh";
+    };
+    using FunctionCosh = FunctionMathUnary<UnaryFunctionVectorized<CoshName, cosh>>;
+
+}
+
+void registerFunctionCosh(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionCosh>();
+}
+
+}

src/Functions/hypot.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathBinaryFloat64.h>
+
+namespace DB
+{
+namespace
+{
+    struct HypotName
+    {
+        static constexpr auto name = "hypot";
+    };
+    using FunctionHypot = FunctionMathBinaryFloat64<BinaryFunctionVectorized<HypotName, hypot>>;
+
+}
+
+void registerFunctionHypot(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionHypot>(FunctionFactory::CaseInsensitive);
+}
+
+}

src/Functions/log1p.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathUnary.h>
+
+namespace DB
+{
+namespace
+{
+    struct Log1pName
+    {
+        static constexpr auto name = "log1p";
+    };
+    using FunctionLog1p = FunctionMathUnary<UnaryFunctionVectorized<Log1pName, log1p>>;
+
+}
+
+void registerFunctionLog1p(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionLog1p>();
+}
+
+}

src/Functions/registerFunctionsMath.cpp

 namespace DB
 {
-
 class FunctionFactory;
 
 void registerFunctionE(FunctionFactory & factory);
@@ -9,6 +8,7 @@ void registerFunctionExp(FunctionFactory & factory);
 void registerFunctionLog(FunctionFactory & factory);
 void registerFunctionExp2(FunctionFactory & factory);
 void registerFunctionLog2(FunctionFactory & factory);
+void registerFunctionLog1p(FunctionFactory & factory);
 void registerFunctionExp10(FunctionFactory & factory);
 void registerFunctionLog10(FunctionFactory & factory);
 void registerFunctionSqrt(FunctionFactory & factory);
@@ -23,8 +23,15 @@ void registerFunctionTan(FunctionFactory & factory);
 void registerFunctionAsin(FunctionFactory & factory);
 void registerFunctionAcos(FunctionFactory & factory);
 void registerFunctionAtan(FunctionFactory & factory);
+void registerFunctionAtan2(FunctionFactory & factory);
 void registerFunctionSigmoid(FunctionFactory & factory);
+void registerFunctionHypot(FunctionFactory & factory);
+void registerFunctionSinh(FunctionFactory & factory);
+void registerFunctionCosh(FunctionFactory & factory);
 void registerFunctionTanh(FunctionFactory & factory);
+void registerFunctionAsinh(FunctionFactory & factory);
+void registerFunctionAcosh(FunctionFactory & factory);
+void registerFunctionAtanh(FunctionFactory & factory);
 void registerFunctionPow(FunctionFactory & factory);
 
 
@@ -36,6 +43,7 @@ void registerFunctionsMath(FunctionFactory & factory)
     registerFunctionLog(factory);
     registerFunctionExp2(factory);
     registerFunctionLog2(factory);
+    registerFunctionLog1p(factory);
     registerFunctionExp10(factory);
     registerFunctionLog10(factory);
     registerFunctionSqrt(factory);
@@ -50,8 +58,15 @@ void registerFunctionsMath(FunctionFactory & factory)
     registerFunctionAsin(factory);
     registerFunctionAcos(factory);
     registerFunctionAtan(factory);
+    registerFunctionAtan2(factory);
     registerFunctionSigmoid(factory);
+    registerFunctionHypot(factory);
+    registerFunctionSinh(factory);
+    registerFunctionCosh(factory);
     registerFunctionTanh(factory);
+    registerFunctionAsinh(factory);
+    registerFunctionAcosh(factory);
+    registerFunctionAtanh(factory);
     registerFunctionPow(factory);
 }
 

src/Functions/sinh.cpp

+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionMathUnary.h>
+
+namespace DB
+{
+namespace
+{
+    struct SinhName
+    {
+        static constexpr auto name = "sinh";
+    };
+    using FunctionSinh = FunctionMathUnary<UnaryFunctionVectorized<SinhName, sinh>>;
+
+}
+
+void registerFunctionSinh(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionSinh>();
+}
+
+}

src/Functions/ya.make

@@ -102,6 +102,7 @@ SRCS(
     URL/topLevelDomain.cpp
     abs.cpp
     acos.cpp
+    acosh.cpp
     addDays.cpp
     addHours.cpp
     addMinutes.cpp
@@ -170,8 +171,11 @@ SRCS(
     array/range.cpp
     array/registerFunctionsArray.cpp
     asin.cpp
+    asinh.cpp
     assumeNotNull.cpp
     atan.cpp
+    atan2.cpp
+    atanh.cpp
     bar.cpp
     base64Decode.cpp
     base64Encode.cpp
@@ -202,6 +206,7 @@ SRCS(
     concat.cpp
     convertCharset.cpp
     cos.cpp
+    cosh.cpp
     countDigits.cpp
     currentDatabase.cpp
     currentUser.cpp
@@ -273,6 +278,7 @@ SRCS(
     hasToken.cpp
     hasTokenCaseInsensitive.cpp
     hostName.cpp
+    hypot.cpp
     identity.cpp
     if.cpp
     ifNotFinite.cpp
@@ -304,6 +310,7 @@ SRCS(
     like.cpp
     log.cpp
     log10.cpp
+    log1p.cpp
     log2.cpp
     logTrace.cpp
     lowCardinalityIndices.cpp
@@ -409,6 +416,7 @@ SRCS(
     runningDifferenceStartingWithFirstValue.cpp
     sigmoid.cpp
     sin.cpp
+    sinh.cpp
     sleep.cpp
     sleepEachRow.cpp
     sqrt.cpp

tests/queries/0_stateless/00087_math_functions.reference

@@ -72,3 +72,43 @@
 1
 1
 1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1

tests/queries/0_stateless/00087_math_functions.sql

@@ -56,6 +56,12 @@ select log2(2) = 1;
 select log2(4) = 2;
 select sum(abs(log2(exp2(x)) - x) < 1.0e-9) / count() from system.one array join range(1000) as x;
 
+select log1p(-1) = -inf;
+select log1p(0) = 0;
+select abs(log1p(exp(2) - 1) - 2) < 1e8;
+select abs(log1p(exp(3) - 1) - 3) < 1e8;
+select sum(abs(log1p(exp(x) - 1) - x) < 1e-8) / count() from system.one array join range(100) as x;
+
 select sin(0) = 0;
 select sin(pi() / 4) = 1 / sqrt(2);
 select sin(pi() / 2) = 1;
@@ -82,6 +88,48 @@ select acos(-1) = pi();
 select atan(0) = 0;
 select atan(1) = pi() / 4;
 
+select atan2(0, 1) = 0;
+select atan2(0, 2) = 0;
+select atan2(1, 0) = pi() / 2;
+select atan2(1, 1) = pi() / 4;
+select atan2(-1, -1) = -3 * pi() / 4;
+
+select hypot(0, 1) = 1;
+select hypot(1, 0) = 1;
+select hypot(1, 1) = sqrt(2);
+select hypot(-1, 1) = sqrt(2);
+select hypot(3, 4) = 5;
+
+select sinh(0) = 0;
+select sinh(1) = -sinh(-1);
+select abs(sinh(1) - 0.5 * (e() - exp(-1))) < 1e-6;
+select abs(sinh(2) - 0.5 * (exp(2) - exp(-2))) < 1e-6;
+select sum(abs(sinh(x) - 0.5 * (exp(x) - exp(-x))) < 1e-6) / count() from system.one array join range(10) as x;
+
+select cosh(0) = 1;
+select cosh(1) = cosh(-1);
+select abs(cosh(1) - 0.5 * (e() + exp(-1))) < 1e-6;
+select abs(pow(cosh(1), 2) - pow(sinh(1), 2) - 1) < 1e-6;
+select sum(abs(cosh(x) * cosh(x) - sinh(x) * sinh(x) - 1) < 1e-6) / count() from system.one array join range(10) as x;
+
+select asinh(0) = 0;
+select asinh(1) = -asinh(-1);
+select abs(asinh(1) - ln(1 + sqrt(2))) < 1e-9;
+select abs(asinh(sinh(1)) - 1) < 1e-9;
+select sum(abs(asinh(sinh(x)) - x) < 1e-9) / count() from system.one array join range(100) as x;
+
+select acosh(1) = 0;
+select abs(acosh(2) - ln(2 + sqrt(3))) < 1e-9;
+select abs(acosh(cosh(2)) - 2) < 1e-9;
+select abs(acosh(cosh(3)) - 3) < 1e-9;
+select sum(abs(acosh(cosh(x)) - x) < 1e-9) / count() from system.one array join range(1, 101) as x;
+
+select atanh(0) = 0;
+select atanh(0.5) = -atanh(-0.5);
+select abs(atanh(0.9) - 0.5 * ln(19)) < 1e-5;
+select abs(atanh(tanh(1)) - 1) < 1e-5;
+select sum(abs(atanh(tanh(x)) - x) < 1e-5) / count() from system.one array join range(10) as x;
+
 select erf(0) = 0;
 select erf(-10) = -1;
 select erf(10) = 1;