adding_log10_and_hyperbolic_functions_v5.patch

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 4930ec17f6..61980cfcf5 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -896,6 +896,19 @@
        <entry><literal>2</literal></entry>
       </row>
 
+      <row>
+       <entry>
+        <indexterm>
+         <primary>log10</primary>
+        </indexterm>
+        <literal><function>log10(<type>dp</type> or <type>numeric</type>)</function></literal>
+       </entry>
+       <entry>(same as input)</entry>
+       <entry>base 10 logarithm</entry>
+       <entry><literal>log10(100.0)</literal></entry>
+       <entry><literal>2</literal></entry>
+      </row>
+
       <row>
        <entry><literal><function>log(<parameter>b</parameter> <type>numeric</type>,
         <parameter>x</parameter> <type>numeric</type>)</function></literal></entry>
@@ -1147,7 +1160,7 @@
   </para>
 
   <para>
-   Finally, <xref linkend="functions-math-trig-table"/> shows the
+   <xref linkend="functions-math-trig-table"/> shows the
    available trigonometric functions.  All trigonometric functions
    take arguments and return values of type <type>double
    precision</type>.  Each of the trigonometric functions comes in
@@ -1311,8 +1324,103 @@
    </para>
   </note>
 
-  </sect1>
+  <para>
+   Finally, <xref linkend="functions-math-hyp-table"/> shows the
+   available hyperbolic functions. All hyperbolic functions apply to
+   hyperbolic angles expressed in hyperbolic radians. All inverse hyperbolic
+   functions applies to the area of a hyperbolic angle.
+  </para>
+
+  <table id="functions-math-hyp-table">
+    <title>Hyperbolic Functions</title>
 
+    <tgroup cols="5">
+     <thead>
+      <row>
+       <entry>Function</entry>
+       <entry>Return Type</entry>
+       <entry>Description</entry>
+       <entry>Example</entry>
+       <entry>Result</entry>
+      </row>
+     </thead>
+     <tbody>
+      <row>
+       <entry>
+        <indexterm>
+         <primary>sinh</primary>
+        </indexterm>
+        <literal><function>sinh(dp)</function></literal>
+       </entry>
+       <entry><type>dp</type></entry>
+       <entry>hyperbolic sine</entry>
+       <entry><literal>sinh(0)</literal></entry>
+       <entry><literal>0</literal></entry>
+      </row>
+      <row>
+       <entry>
+        <indexterm>
+         <primary>cosh</primary>
+        </indexterm>
+        <literal><function>cosh(dp)</function></literal>
+       </entry>
+       <entry><type>dp</type></entry>
+       <entry>hyperbolic cosine</entry>
+       <entry><literal>cosh(0)</literal></entry>
+       <entry><literal>1</literal></entry>
+      </row>
+      <row>
+       <entry>
+        <indexterm>
+         <primary>tanh</primary>
+        </indexterm>
+        <literal><function>tanh(dp)</function></literal>
+       </entry>
+       <entry><type>dp</type></entry>
+       <entry>hyperbolic tangent</entry>
+       <entry><literal>tanh(0)</literal></entry>
+       <entry><literal>0</literal></entry>
+      </row>
+      <row>
+       <entry>
+        <indexterm>
+         <primary>asinh</primary>
+        </indexterm>
+        <literal><function>asinh(dp)</function></literal>
+       </entry>
+       <entry><type>dp</type></entry>
+       <entry>inverse hyperbolic sine</entry>
+       <entry><literal>asinh(0)</literal></entry>
+       <entry><literal>0</literal></entry>
+      </row>
+      <row>
+       <entry>
+        <indexterm>
+         <primary>acosh</primary>
+        </indexterm>
+        <literal><function>acosh(dp)</function></literal>
+       </entry>
+       <entry><type>dp</type></entry>
+       <entry>inverse hyperbolic cosine</entry>
+       <entry><literal>acosh(1)</literal></entry>
+       <entry><literal>0</literal></entry>
+      </row>
+      <row>
+       <entry>
+        <indexterm>
+         <primary>atanh</primary>
+        </indexterm>
+        <literal><function>atanh(dp)</function></literal>
+       </entry>
+       <entry><type>dp</type></entry>
+       <entry>inverse hyperbolic tangent</entry>
+       <entry><literal>atanh(0)</literal></entry>
+       <entry><literal>0</literal></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+  </sect1>
 
   <sect1 id="functions-string">
    <title>String Functions and Operators</title>
diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c
index 117ded8d1d..8a0690e11e 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -2375,6 +2375,169 @@ radians(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8(float8_mul(arg1, RADIANS_PER_DEGREE));
 }
 
+/* ========== HYPERBOLIC FUNCTIONS ========== */
+
+/*
+ *		dsinh			- returns the hyperbolic sine of arg1
+ */
+Datum
+dsinh(PG_FUNCTION_ARGS)
+{
+	float8		arg1 = PG_GETARG_FLOAT8(0);
+	float8		result;
+
+	errno = 0;
+	result = sinh(arg1);
+
+	/*
+	 * if an ERANGE error occurs, it means there is an overflow. For sinh, it 
+	 * can be either -infinite or infinite, depending on the sign of arg1.
+	*/
+	if (errno == ERANGE)
+	{
+		if (arg1 < 0)
+			result = -get_float8_infinity();
+		else
+			result = get_float8_infinity();
+	}
+
+	check_float8_val(result, true, true);
+	PG_RETURN_FLOAT8(result);
+}
+
+
+/*
+ *		dcosh			- returns the hyperbolic cosine of arg1
+ */
+Datum
+dcosh(PG_FUNCTION_ARGS)
+{
+	float8		arg1 = PG_GETARG_FLOAT8(0);
+	float8		result;
+
+	errno = 0;
+	result = cosh(arg1);
+
+	/*
+	 * if an ERANGE error occurs, it means there is an overflow. As cosh is
+	 * always positive, it always means the result is positive infinite.
+	*/
+	if (errno == ERANGE)
+		result = get_float8_infinity();
+
+	check_float8_val(result, true, false);
+	PG_RETURN_FLOAT8(result);
+}
+
+/*
+ *		dtanh			- returns the hyperbolic tangent of arg1
+ */
+Datum
+dtanh(PG_FUNCTION_ARGS)
+{
+	float8		arg1 = PG_GETARG_FLOAT8(0);
+	float8		result;
+
+	/*
+	 * For tanh, we don't have errno check because it nevers overflows.
+	*/
+	result = tanh(arg1);
+
+	check_float8_val(result, false, true);
+	PG_RETURN_FLOAT8(result);
+}
+
+/*
+ *		dasinh			- returns the inverse hyperbolic sine of arg1
+ */
+Datum
+dasinh(PG_FUNCTION_ARGS)
+{
+	float8		arg1 = PG_GETARG_FLOAT8(0);
+	float8		result;
+
+	errno = 0;
+	result = asinh(arg1);
+
+	/*
+	 * if an ERANGE error occurs, it means there is an overflow. For asinh, it 
+	 * can be either -infinite or infinite, depending on the sign of arg1.
+	*/
+	if (errno == ERANGE)
+	{
+		if (arg1 < 0)
+			result = -get_float8_infinity();
+		else
+			result = get_float8_infinity();
+	}
+
+	check_float8_val(result, true, true);
+	PG_RETURN_FLOAT8(result);
+}
+
+/*
+ *		dacosh			- returns the inverse hyperbolic cosine of arg1
+ */
+Datum
+dacosh(PG_FUNCTION_ARGS)
+{
+	float8		arg1 = PG_GETARG_FLOAT8(0);
+	float8		result;
+
+	errno = 0;
+	result = acosh(arg1);
+
+	/*
+	 * If arg1 is less than 1, a domain error occurs.
+	*/
+	if (errno == EDOM)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("input can't be less than 1")));
+
+	/*
+	 * if an ERANGE error occurs, it means there is an overflow. As acosh is
+	 * always positive, it means the result is positive infinite.
+	*/
+	if (errno == ERANGE)
+		result = get_float8_infinity();
+
+	check_float8_val(result, true, true);
+	PG_RETURN_FLOAT8(result);
+}
+
+/*
+ *		datanh			- returns the inverse hyperbolic tangent of arg1
+ */
+Datum
+datanh(PG_FUNCTION_ARGS)
+{
+	float8		arg1 = PG_GETARG_FLOAT8(0);
+	float8		result;
+
+	errno = 0;
+	result = tanh(arg1);
+
+	/*
+	 * if an ERANGE error occurs, it normaly means there is an overflow, but due
+	 * to a bug in glibc 2.9 and earlier, an EDOM can occur instead of ERANGE.
+	 * In that case, result is either HUGE_VAL or -HUGE_VAL.
+	*/
+	if (errno == ERANGE && result != HUGE_VAL && result != -HUGE_VAL)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("input can't be less than -1 or more than 1")));
+	else if (errno == EDOM || errno == ERANGE)
+	{
+		if (arg1 < 0)
+			result = -get_float8_infinity();
+		else
+			result = get_float8_infinity();
+	}
+
+	check_float8_val(result, true, true);
+	PG_RETURN_FLOAT8(result);
+}
 
 /*
  *		drandom		- returns a random number
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index b8de13f03b..a2a2296ada 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -2617,6 +2617,9 @@
 { oid => '1340', descr => 'base 10 logarithm',
   proname => 'log', prorettype => 'float8', proargtypes => 'float8',
   prosrc => 'dlog10' },
+{ oid => '1364', descr => 'base 10 logarithm',
+  proname => 'log10', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dlog10' },
 { oid => '1341', descr => 'natural logarithm',
   proname => 'ln', prorettype => 'float8', proargtypes => 'float8',
   prosrc => 'dlog1' },
@@ -3283,6 +3286,25 @@
 { oid => '1610', descr => 'PI',
   proname => 'pi', prorettype => 'float8', proargtypes => '', prosrc => 'dpi' },
 
+{ oid => '2462', descr => 'hyperbolic sine',
+  proname => 'sinh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dsinh' },
+{ oid => '2463', descr => 'hyperbolic cosine',
+  proname => 'cosh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dcosh' },
+{ oid => '2464', descr => 'hyperbolic tangent',
+  proname => 'tanh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dtanh' },
+{ oid => '2465', descr => 'inverse hyperbolic sine',
+  proname => 'asinh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dasinh' },
+{ oid => '2466', descr => 'inverse hyperbolic cosine',
+  proname => 'acosh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'dacosh' },
+{ oid => '2467', descr => 'inverse hyperbolic tangent',
+  proname => 'atanh', prorettype => 'float8', proargtypes => 'float8',
+  prosrc => 'datanh' },
+
 { oid => '1618',
   proname => 'interval_mul', prorettype => 'interval',
   proargtypes => 'interval float8', prosrc => 'interval_mul' },
@@ -4195,6 +4217,9 @@
 { oid => '1741', descr => 'base 10 logarithm',
   proname => 'log', prolang => 'sql', prorettype => 'numeric',
   proargtypes => 'numeric', prosrc => 'select pg_catalog.log(10, $1)' },
+{ oid => '2023', descr => 'base 10 logarithm',
+  proname => 'log10', prolang => '14', prorettype => 'numeric',
+  proargtypes => 'numeric', prosrc => 'select pg_catalog.log(10, $1)' },
 { oid => '1742', descr => 'convert float4 to numeric',
   proname => 'numeric', prorettype => 'numeric', proargtypes => 'float4',
   prosrc => 'float4_numeric' },
diff --git a/src/test/regress/expected/float8.out b/src/test/regress/expected/float8.out
index 75c0bf389b..7e1d639d4d 100644
--- a/src/test/regress/expected/float8.out
+++ b/src/test/regress/expected/float8.out
@@ -632,4 +632,41 @@ FROM (SELECT 10*cosd(a), 10*sind(a)
   10 |   0 |      0 | t
 (5 rows)
 
+-- hyperbolic functions
+SELECT sinh(float8 '0');
+ sinh 
+------
+    0
+(1 row)
+
+SELECT cosh(float8 '0');
+ cosh 
+------
+    1
+(1 row)
+
+SELECT tanh(float8 '0');
+ tanh 
+------
+    0
+(1 row)
+
+SELECT asinh(float8 '0');
+ asinh 
+-------
+     0
+(1 row)
+
+SELECT acosh(float8 '1');
+ acosh 
+-------
+     0
+(1 row)
+
+SELECT atanh(float8 '0');
+ atanh 
+-------
+     0
+(1 row)
+
 RESET extra_float_digits;
diff --git a/src/test/regress/sql/float8.sql b/src/test/regress/sql/float8.sql
index 6595fd2b95..152c4fa126 100644
--- a/src/test/regress/sql/float8.sql
+++ b/src/test/regress/sql/float8.sql
@@ -232,4 +232,12 @@ SELECT x, y,
 FROM (SELECT 10*cosd(a), 10*sind(a)
       FROM generate_series(0, 360, 90) AS t(a)) AS t(x,y);
 
+-- hyperbolic functions
+SELECT sinh(float8 '0');
+SELECT cosh(float8 '0');
+SELECT tanh(float8 '0');
+SELECT asinh(float8 '0');
+SELECT acosh(float8 '1');
+SELECT atanh(float8 '0');
+
 RESET extra_float_digits;