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 @@ 2 + + + + log10 + + log10(dp or numeric) + + (same as input) + base 10 logarithm + log10(100.0) + 2 + + log(b numeric, x numeric) @@ -1147,7 +1160,7 @@ - Finally, shows the + shows the available trigonometric functions. All trigonometric functions take arguments and return values of type double precision. Each of the trigonometric functions comes in @@ -1311,8 +1324,103 @@ - + + Finally, 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. + + + + Hyperbolic Functions + + + + Function + Return Type + Description + Example + Result + + + + + + + sinh + + sinh(dp) + + dp + hyperbolic sine + sinh(0) + 0 + + + + + cosh + + cosh(dp) + + dp + hyperbolic cosine + cosh(0) + 1 + + + + + tanh + + tanh(dp) + + dp + hyperbolic tangent + tanh(0) + 0 + + + + + asinh + + asinh(dp) + + dp + inverse hyperbolic sine + asinh(0) + 0 + + + + + acosh + + acosh(dp) + + dp + inverse hyperbolic cosine + acosh(1) + 0 + + + + + atanh + + atanh(dp) + + dp + inverse hyperbolic tangent + atanh(0) + 0 + + + +
+ String Functions and Operators 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;