Add some of missed cmath functions

acosh
asinh
atan2
atanh
cosh
hypot
log1p
sinh

src/Functions/acosh.cpp

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathUnary.h>
+#include <Functions/FunctionFactory.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

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathUnary.h>
+#include <Functions/FunctionFactory.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

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathBinaryFloat64.h>
+#include <Functions/FunctionFactory.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

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathUnary.h>
+#include <Functions/FunctionFactory.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

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathUnary.h>
+#include <Functions/FunctionFactory.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

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathBinaryFloat64.h>
+#include <Functions/FunctionFactory.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

@@ -0,0 +1,19 @@
+#include <Functions/FunctionMathUnary.h>
+#include <Functions/FunctionFactory.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

@@ -1,6 +1,5 @@
 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

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