Quelle float.c
Sprache: C
/*------------------------------------------------------------------------- * * float . c * Functions for the built - in floating - point types . * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * * IDENTIFICATION * src / backend / utils / adt / float . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include <ctype.h>#include <float .h>#include <math.h>#include <limits.h>#include "catalog/pg_type.h" #include "common/int.h" #include "common/shortest_dec.h" #include "libpq/pqformat.h" #include "utils/array.h" #include "utils/float.h" #include "utils/fmgrprotos.h" #include "utils/sortsupport.h" /* * Configurable GUC parameter * * If > 0 , use shortest - decimal format for output ; this is both the default and * allows for compatibility with clients that explicitly set a value here to * get round - trip - accurate results . If 0 or less , then use the old , slow , * decimal rounding method . int extra_float_digits = 1 ;/* Cached constants for degree-based trig functions */ static bool degree_consts_set = false ;static float8 sin_30 = 0 ;static float8 one_minus_cos_60 = 0 ;static float8 asin_0_5 = 0 ;static float8 acos_0_5 = 0 ;static float8 atan_1_0 = 0 ;static float8 tan_45 = 0 ;static float8 cot_45 = 0 ;/* * These are intentionally not static ; don ' t " fix " them . They will never * be referenced by other files , much less changed ; but we don ' t want the * compiler to know that , else it might try to precompute expressions * involving them . See comments for init_degree_constants ( ) . * * The additional extern declarations are to silence * - Wmissing - variable - declarations . extern float8 degree_c_thirty;extern float8 degree_c_forty_five;extern float8 degree_c_sixty;extern float8 degree_c_one_half;extern float8 degree_c_one;30 .0 ;45 .0 ;60 .0 ;0 .5 ;1 .0 ;/* Local function prototypes */ static double sind_q1(double x);static double cosd_q1(double x);static void init_degree_constants(void );/* * We use these out - of - line ereport ( ) calls to report float overflow , * underflow , and zero - divide , because following our usual practice of * repeating them at each call site would lead to a lot of code bloat . * * This does mean that you don ' t get a useful error location indicator . void void )"value out of range: overflow" )));void void )"value out of range: underflow" )));void void )"division by zero" )));/* * Returns - 1 if ' val ' represents negative infinity , 1 if ' val ' * represents ( positive ) infinity , and 0 otherwise . On some platforms , * this is equivalent to the isinf ( ) macro , but not everywhere : C99 * does not specify that isinf ( ) needs to distinguish between positive * and negative infinity . int double val)int inf = isinf(val);if (inf == 0 )return 0 ;else if (val > 0 )return 1 ;else return -1 ;/* ========== USER I/O ROUTINES ========== */ /* * float4in - converts " num " to float4 * * Note that this code now uses strtof ( ) , where it used to use strtod ( ) . * * The motivation for using strtof ( ) is to avoid a double - rounding problem : * for certain decimal inputs , if you round the input correctly to a double , * and then round the double to a float , the result is incorrect in that it * does not match the result of rounding the decimal value to float directly . * * One of the best examples is 7 . 038531 e - 26 : * * 0 xAE43FDp - 107 = 7 . 03853069185120912085 . . . e - 26 * midpoint 7 . 03853100000000022281 . . . e - 26 * 0 xAE43FEp - 107 = 7 . 03853130814879132477 . . . e - 26 * * making 0 xAE43FDp - 107 the correct float result , but if you do the conversion * via a double , you get * * 0 xAE43FD . 7 FFFFFF8p - 107 = 7 . 03853099999999907487 . . . e - 26 * midpoint 7 . 03853099999999964884 . . . e - 26 * 0 xAE43FD . 80000000 p - 107 = 7 . 03853100000000022281 . . . e - 26 * 0 xAE43FD . 80000008 p - 107 = 7 . 03853100000000137076 . . . e - 26 * * so the value rounds to the double exactly on the midpoint between the two * nearest floats , and then rounding again to a float gives the incorrect * result of 0 xAE43FEp - 107 . * char *num = PG_GETARG_CSTRING(0 );"real" , num,/* * float4in_internal - guts of float4in ( ) * * This is exposed for use by functions that want a reasonably * platform - independent way of inputting floats . The behavior is * essentially like strtof + ereturn on error . * * Uses the same API as float8in_internal below , so most of its * comments also apply here , except regarding use in geometric types . char *num, char **endptr_p,const char *type_name, const char *orig_string,struct Node *escontext)float val;char *endptr;/* * endptr points to the first character _ after_ the sequence we recognized * as a valid floating point number . orig_string points to the original * input string . /* skip leading whitespace */ while (*num != '\0' && isspace((unsigned char ) *num))/* * Check for an empty - string input to begin with , to avoid the vagaries of * strtod ( ) on different platforms . if (*num == '\0' )0 ,"invalid input syntax for type %s: \" %s\"" ,0 ;/* did we not see anything that looks like a double? */ if (endptr == num || errno != 0 )int save_errno = errno;/* * C99 requires that strtof ( ) accept NaN , [ + - ] Infinity , and [ + - ] Inf , * but not all platforms support all of these ( and some accept them * but set ERANGE anyway . . . ) Therefore , we check for these inputs * ourselves if strtof ( ) fails . * * Note : C99 also requires hexadecimal input as well as some extended * forms of NaN , but we consider these forms unportable and don ' t try * to support them . You can use ' em if your strtof ( ) takes ' em . if (pg_strncasecmp(num, "NaN" , 3 ) == 0 )3 ;else if (pg_strncasecmp(num, "Infinity" , 8 ) == 0 )8 ;else if (pg_strncasecmp(num, "+Infinity" , 9 ) == 0 )9 ;else if (pg_strncasecmp(num, "-Infinity" , 9 ) == 0 )9 ;else if (pg_strncasecmp(num, "inf" , 3 ) == 0 )3 ;else if (pg_strncasecmp(num, "+inf" , 4 ) == 0 )4 ;else if (pg_strncasecmp(num, "-inf" , 4 ) == 0 )4 ;else if (save_errno == ERANGE)/* * Some platforms return ERANGE for denormalized numbers ( those * that are not zero , but are too close to zero to have full * precision ) . We ' d prefer not to throw error for that , so try to * detect whether it ' s a " real " out - of - range condition by checking * to see if the result is zero or huge . if (val == 0 .0 ||#if !defined (HUGE_VALF)#else #endif /* see comments in float8in_internal for rationale */ char *errnumber = pstrdup(num);'\0' ;0 ,"\" %s\" is out of range for type real" ,else 0 ,"invalid input syntax for type %s: \" %s\"" ,/* skip trailing whitespace */ while (*endptr != '\0' && isspace((unsigned char ) *endptr))/* report stopping point if wanted, else complain if not end of string */ if (endptr_p)else if (*endptr != '\0' )0 ,"invalid input syntax for type %s: \" %s\"" ,return val;/* * float4out - converts a float4 number to a string * using a standard output format 0 );char *ascii = (char *) palloc(32 );int ndig = FLT_DIG + extra_float_digits;if (extra_float_digits > 0 )void ) pg_strfromd(ascii, 32 , ndig, num);/* * float4recv - converts external binary format to float4 0 );/* * float4send - converts float4 to binary format 0 );/* * float8in - converts " num " to float8 char *num = PG_GETARG_CSTRING(0 );"double precision" , num,/* * float8in_internal - guts of float8in ( ) * * This is exposed for use by functions that want a reasonably * platform - independent way of inputting doubles . The behavior is * essentially like strtod + ereturn on error , but note the following * differences : * 1 . Both leading and trailing whitespace are skipped . * 2 . If endptr_p is NULL , we report error if there ' s trailing junk . * Otherwise , it ' s up to the caller to complain about trailing junk . * 3 . In event of a syntax error , the report mentions the given type_name * and prints orig_string as the input ; this is meant to support use of * this function with types such as " box " and " point " , where what we are * parsing here is just a substring of orig_string . * * If escontext points to an ErrorSaveContext node , that is filled instead * of throwing an error ; the caller must check SOFT_ERROR_OCCURRED ( ) * to detect errors . * * " num " could validly be declared " const char * " , but that results in an * unreasonable amount of extra casting both here and in callers , so we don ' t . char *num, char **endptr_p,const char *type_name, const char *orig_string,struct Node *escontext)double val;char *endptr;/* skip leading whitespace */ while (*num != '\0' && isspace((unsigned char ) *num))/* * Check for an empty - string input to begin with , to avoid the vagaries of * strtod ( ) on different platforms . if (*num == '\0' )0 ,"invalid input syntax for type %s: \" %s\"" ,0 ;/* did we not see anything that looks like a double? */ if (endptr == num || errno != 0 )int save_errno = errno;/* * C99 requires that strtod ( ) accept NaN , [ + - ] Infinity , and [ + - ] Inf , * but not all platforms support all of these ( and some accept them * but set ERANGE anyway . . . ) Therefore , we check for these inputs * ourselves if strtod ( ) fails . * * Note : C99 also requires hexadecimal input as well as some extended * forms of NaN , but we consider these forms unportable and don ' t try * to support them . You can use ' em if your strtod ( ) takes ' em . if (pg_strncasecmp(num, "NaN" , 3 ) == 0 )3 ;else if (pg_strncasecmp(num, "Infinity" , 8 ) == 0 )8 ;else if (pg_strncasecmp(num, "+Infinity" , 9 ) == 0 )9 ;else if (pg_strncasecmp(num, "-Infinity" , 9 ) == 0 )9 ;else if (pg_strncasecmp(num, "inf" , 3 ) == 0 )3 ;else if (pg_strncasecmp(num, "+inf" , 4 ) == 0 )4 ;else if (pg_strncasecmp(num, "-inf" , 4 ) == 0 )4 ;else if (save_errno == ERANGE)/* * Some platforms return ERANGE for denormalized numbers ( those * that are not zero , but are too close to zero to have full * precision ) . We ' d prefer not to throw error for that , so try to * detect whether it ' s a " real " out - of - range condition by checking * to see if the result is zero or huge . * * On error , we intentionally complain about double precision not * the given type name , and we print only the part of the string * that is the current number . if (val == 0 .0 || val >= HUGE_VAL || val <= -HUGE_VAL)char *errnumber = pstrdup(num);'\0' ;0 ,"\" %s\" is out of range for type double precision" ,else 0 ,"invalid input syntax for type %s: \" %s\"" ,/* skip trailing whitespace */ while (*endptr != '\0' && isspace((unsigned char ) *endptr))/* report stopping point if wanted, else complain if not end of string */ if (endptr_p)else if (*endptr != '\0' )0 ,"invalid input syntax for type %s: \" %s\"" ,return val;/* * float8out - converts float8 number to a string * using a standard output format 0 );/* * float8out_internal - guts of float8out ( ) * * This is exposed for use by functions that want a reasonably * platform - independent way of outputting doubles . * The result is always palloc ' d . char *double num)char *ascii = (char *) palloc(32 );int ndig = DBL_DIG + extra_float_digits;if (extra_float_digits > 0 )return ascii;void ) pg_strfromd(ascii, 32 , ndig, num);return ascii;/* * float8recv - converts external binary format to float8 0 );/* * float8send - converts float8 to binary format 0 );/* ========== PUBLIC ROUTINES ========== */ /* * = = = = = = = = = = = = = = = = = = = = = = * FLOAT4 BASE OPERATIONS * = = = = = = = = = = = = = = = = = = = = = = /* * float4abs - returns | arg1 | ( absolute value ) 0 );/* * float4um - returns - arg1 ( unary minus ) 0 );0 );0 );1 );if (float4_gt(arg1, arg2))else 0 );1 );if (float4_lt(arg1, arg2))else /* * = = = = = = = = = = = = = = = = = = = = = = * FLOAT8 BASE OPERATIONS * = = = = = = = = = = = = = = = = = = = = = = /* * float8abs - returns | arg1 | ( absolute value ) 0 );/* * float8um - returns - arg1 ( unary minus ) 0 );0 );0 );1 );if (float8_gt(arg1, arg2))else 0 );1 );if (float8_lt(arg1, arg2))else /* * = = = = = = = = = = = = = = = = = = = = * ARITHMETIC OPERATORS * = = = = = = = = = = = = = = = = = = = = /* * float4pl - returns arg1 + arg2 * float4mi - returns arg1 - arg2 * float4mul - returns arg1 * arg2 * float4div - returns arg1 / arg2 0 );1 );0 );1 );0 );1 );0 );1 );/* * float8pl - returns arg1 + arg2 * float8mi - returns arg1 - arg2 * float8mul - returns arg1 * arg2 * float8div - returns arg1 / arg2 0 );1 );0 );1 );0 );1 );0 );1 );/* * = = = = = = = = = = = = = = = = = = = = * COMPARISON OPERATORS * = = = = = = = = = = = = = = = = = = = = /* * float4 { eq , ne , lt , le , gt , ge } - float4 / float4 comparison operations int if (float4_gt(a, b))return 1 ;if (float4_lt(a, b))return -1 ;return 0 ;0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );static int return float4_cmp_internal(arg1, arg2);0 );/* * float8 { eq , ne , lt , le , gt , ge } - float8 / float8 comparison operations int if (float8_gt(a, b))return 1 ;if (float8_lt(a, b))return -1 ;return 0 ;0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );static int return float8_cmp_internal(arg1, arg2);0 );0 );1 );/* widen float4 to float8 and then compare */ 0 );1 );/* widen float4 to float8 and then compare */ /* * in_range support function for float8 . * * Note : we needn ' t supply a float8_float4 variant , as implicit coercion * of the offset value takes care of that scenario just as well . 0 );1 );2 );bool sub = PG_GETARG_BOOL(3 );bool less = PG_GETARG_BOOL(4 );/* * Reject negative or NaN offset . Negative is per spec , and NaN is * because appropriate semantics for that seem non - obvious . if (isnan(offset) || offset < 0 )"invalid preceding or following size in window function" )));/* * Deal with cases where val and / or base is NaN , following the rule that * NaN sorts after non - NaN ( cf float8_cmp_internal ) . The offset cannot * affect the conclusion . if (isnan(val))if (isnan(base))true ); /* NAN = NAN */ else /* NAN > non-NAN */ else if (isnan(base))/* non-NAN < NAN */ /* * Deal with cases where both base and offset are infinite , and computing * base + / - offset would produce NaN . This corresponds to a window frame * whose boundary infinitely precedes + inf or infinitely follows - inf , * which is not well - defined . For consistency with other cases involving * infinities , such as the fact that + inf infinitely follows + inf , we * choose to assume that + inf infinitely precedes + inf and - inf infinitely * follows - inf , and therefore that all finite and infinite values are in * such a window frame . * * offset is known positive , so we need only check the sign of base in * this test . if (isinf(offset) && isinf(base) &&0 : base < 0 ))true );/* * Otherwise it should be safe to compute base + / - offset . We trust the * FPU to cope if an input is + / - inf or the true sum would overflow , and * produce a suitably signed infinity , which will compare properly against * val whether or not that ' s infinity . if (sub)else if (less)else /* * in_range support function for float4 . * * We would need a float4_float8 variant in any case , so we supply that and * let implicit coercion take care of the float4_float4 case . 0 );1 );2 );bool sub = PG_GETARG_BOOL(3 );bool less = PG_GETARG_BOOL(4 );/* * Reject negative or NaN offset . Negative is per spec , and NaN is * because appropriate semantics for that seem non - obvious . if (isnan(offset) || offset < 0 )"invalid preceding or following size in window function" )));/* * Deal with cases where val and / or base is NaN , following the rule that * NaN sorts after non - NaN ( cf float8_cmp_internal ) . The offset cannot * affect the conclusion . if (isnan(val))if (isnan(base))true ); /* NAN = NAN */ else /* NAN > non-NAN */ else if (isnan(base))/* non-NAN < NAN */ /* * Deal with cases where both base and offset are infinite , and computing * base + / - offset would produce NaN . This corresponds to a window frame * whose boundary infinitely precedes + inf or infinitely follows - inf , * which is not well - defined . For consistency with other cases involving * infinities , such as the fact that + inf infinitely follows + inf , we * choose to assume that + inf infinitely precedes + inf and - inf infinitely * follows - inf , and therefore that all finite and infinite values are in * such a window frame . * * offset is known positive , so we need only check the sign of base in * this test . if (isinf(offset) && isinf(base) &&0 : base < 0 ))true );/* * Otherwise it should be safe to compute base + / - offset . We trust the * FPU to cope if an input is + / - inf or the true sum would overflow , and * produce a suitably signed infinity , which will compare properly against * val whether or not that ' s infinity . if (sub)else if (less)else /* * = = = = = = = = = = = = = = = = = = = * CONVERSION ROUTINES * = = = = = = = = = = = = = = = = = = = /* * ftod - converts a float4 number to a float8 number 0 );/* * dtof - converts a float8 number to a float4 number 0 );if (unlikely(isinf(result)) && !isinf(num))if (unlikely(result == 0 .0 f) && num != 0 .0 )/* * dtoi4 - converts a float8 number to an int4 number 0 );/* * Get rid of any fractional part in the input . This is so we don ' t fail * on just - out - of - range values that would round into range . Note * assumption that rint ( ) will pass through a NaN or Inf unchanged . /* Range check */ if (unlikely(isnan(num) || !FLOAT8_FITS_IN_INT32(num)))"integer out of range" )));/* * dtoi2 - converts a float8 number to an int2 number 0 );/* * Get rid of any fractional part in the input . This is so we don ' t fail * on just - out - of - range values that would round into range . Note * assumption that rint ( ) will pass through a NaN or Inf unchanged . /* Range check */ if (unlikely(isnan(num) || !FLOAT8_FITS_IN_INT16(num)))"smallint out of range" )));/* * i4tod - converts an int4 number to a float8 number 0 );/* * i2tod - converts an int2 number to a float8 number 0 );/* * ftoi4 - converts a float4 number to an int4 number 0 );/* * Get rid of any fractional part in the input . This is so we don ' t fail * on just - out - of - range values that would round into range . Note * assumption that rint ( ) will pass through a NaN or Inf unchanged . /* Range check */ if (unlikely(isnan(num) || !FLOAT4_FITS_IN_INT32(num)))"integer out of range" )));/* * ftoi2 - converts a float4 number to an int2 number 0 );/* * Get rid of any fractional part in the input . This is so we don ' t fail * on just - out - of - range values that would round into range . Note * assumption that rint ( ) will pass through a NaN or Inf unchanged . /* Range check */ if (unlikely(isnan(num) || !FLOAT4_FITS_IN_INT16(num)))"smallint out of range" )));/* * i4tof - converts an int4 number to a float4 number 0 );/* * i2tof - converts an int2 number to a float4 number 0 );/* * = = = = = = = = = = = = = = = = = = = = = = = * RANDOM FLOAT8 OPERATORS * = = = = = = = = = = = = = = = = = = = = = = = /* * dround - returns ROUND ( arg1 ) 0 );/* * dceil - returns the smallest integer greater than or * equal to the specified float 0 );/* * dfloor - returns the largest integer lesser than or * equal to the specified float 0 );/* * dsign - returns - 1 if the argument is less than 0 , 0 * if the argument is equal to 0 , and 1 if the * argument is greater than zero . 0 );if (arg1 > 0 )1 .0 ;else if (arg1 < 0 )1 .0 ;else 0 .0 ;/* * dtrunc - returns truncation - towards - zero of arg1 , * arg1 > = 0 . . . the greatest integer less * than or equal to arg1 * arg1 < 0 . . . the least integer greater * than or equal to arg1 0 );if (arg1 >= 0 )else /* * dsqrt - returns square root of arg1 0 );if (arg1 < 0 )"cannot take square root of a negative number" )));if (unlikely(isinf(result)) && !isinf(arg1))if (unlikely(result == 0 .0 ) && arg1 != 0 .0 )/* * dcbrt - returns cube root of arg1 0 );if (unlikely(isinf(result)) && !isinf(arg1))if (unlikely(result == 0 .0 ) && arg1 != 0 .0 )/* * dpow - returns pow ( arg1 , arg2 ) 0 );1 );/* * The POSIX spec says that NaN ^ 0 = 1 , and 1 ^ NaN = 1 , while all other * cases with NaN inputs yield NaN ( with no error ) . Many older platforms * get one or more of these cases wrong , so deal with them via explicit * logic rather than trusting pow ( 3 ) . if (isnan(arg1))if (isnan(arg2) || arg2 != 0 .0 )1 .0 );if (isnan(arg2))if (arg1 != 1 .0 )1 .0 );/* * The SQL spec requires that we emit a particular SQLSTATE error code for * certain error conditions . Specifically , we don ' t return a * divide - by - zero error code for 0 ^ - 1 . if (arg1 == 0 && arg2 < 0 )"zero raised to a negative power is undefined" )));if (arg1 < 0 && floor(arg2) != arg2)"a negative number raised to a non-integer power yields a complex result" )));/* * We don ' t trust the platform ' s pow ( ) to handle infinity cases per POSIX * spec either , so deal with those explicitly too . It ' s easier to handle * infinite y first , so that it doesn ' t matter if x is also infinite . if (isinf(arg2))if (absx == 1 .0 )1 .0 ;else if (arg2 > 0 .0 ) /* y = +Inf */ if (absx > 1 .0 )else 0 .0 ;else /* y = -Inf */ if (absx > 1 .0 )0 .0 ;else else if (isinf(arg1))if (arg2 == 0 .0 )1 .0 ;else if (arg1 > 0 .0 ) /* x = +Inf */ if (arg2 > 0 .0 )else 0 .0 ;else /* x = -Inf */ /* * Per POSIX , the sign of the result depends on whether y is an * odd integer . Since x < 0 , we already know from the previous * domain check that y is an integer . It is odd if y / 2 is not * also an integer . 2 ; /* should be computed exactly */ bool yisoddinteger = (floor(halfy) != halfy);if (arg2 > 0 .0 )else 0 .0 : 0 .0 ;else /* * pow ( ) sets errno on only some platforms , depending on whether it * follows _ IEEE_ , _ POSIX_ , _ XOPEN_ , or _ SVID_ , so we must check both * errno and invalid output values . ( We can ' t rely on just the * latter , either ; some old platforms return a large - but - finite * HUGE_VAL when reporting overflow . ) 0 ;if (errno == EDOM || isnan(result))/* * We handled all possible domain errors above , so this should be * impossible . However , old glibc versions on x86 have a bug that * causes them to fail this way for abs ( y ) greater than 2 ^ 63 : * * https : //sourceware.org/bugzilla/show_bug.cgi?id=3866 * * Hence , if we get here , assume y is finite but large ( large * enough to be certainly even ) . The result should be 0 if x = = 0 , * 1 . 0 if abs ( x ) = = 1 . 0 , otherwise an overflow or underflow error . if (arg1 == 0 .0 )0 .0 ; /* we already verified y is positive */ else if (absx == 1 .0 )1 .0 ;else if (arg2 >= 0 .0 ? (absx > 1 .0 ) : (absx < 1 .0 ))else else if (errno == ERANGE)if (result != 0 .0 )else else if (unlikely(isinf(result)))if (unlikely(result == 0 .0 ) && arg1 != 0 .0 )/* * dexp - returns the exponential function of arg1 0 );/* * Handle NaN and Inf cases explicitly . This avoids needing to assume * that the platform ' s exp ( ) conforms to POSIX for these cases , and it * removes some edge cases for the overflow checks below . if (isnan(arg1))else if (isinf(arg1))/* Per POSIX, exp(-Inf) is 0 */ 0 .0 ) ? arg1 : 0 ;else /* * On some platforms , exp ( ) will not set errno but just return Inf or * zero to report overflow / underflow ; therefore , test both cases . 0 ;if (unlikely(errno == ERANGE))if (result != 0 .0 )else else if (unlikely(isinf(result)))else if (unlikely(result == 0 .0 ))/* * dlog1 - returns the natural logarithm of arg1 0 );/* * Emit particular SQLSTATE error codes for ln ( ) . This is required by the * SQL standard . if (arg1 == 0 .0 )"cannot take logarithm of zero" )));if (arg1 < 0 )"cannot take logarithm of a negative number" )));if (unlikely(isinf(result)) && !isinf(arg1))if (unlikely(result == 0 .0 ) && arg1 != 1 .0 )/* * dlog10 - returns the base 10 logarithm of arg1 0 );/* * Emit particular SQLSTATE error codes for log ( ) . The SQL spec doesn ' t * define log ( ) , but it does define ln ( ) , so it makes sense to emit the * same error code for an analogous error condition . if (arg1 == 0 .0 )"cannot take logarithm of zero" )));if (arg1 < 0 )"cannot take logarithm of a negative number" )));if (unlikely(isinf(result)) && !isinf(arg1))if (unlikely(result == 0 .0 ) && arg1 != 1 .0 )/* * dacos - returns the arccos of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * The principal branch of the inverse cosine function maps values in the * range [ - 1 , 1 ] to values in the range [ 0 , Pi ] , so we should reject any * inputs outside that range and the result will always be finite . if (arg1 < -1 .0 || arg1 > 1 .0 )"input is out of range" )));if (unlikely(isinf(result)))/* * dasin - returns the arcsin of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * The principal branch of the inverse sine function maps values in the * range [ - 1 , 1 ] to values in the range [ - Pi / 2 , Pi / 2 ] , so we should reject * any inputs outside that range and the result will always be finite . if (arg1 < -1 .0 || arg1 > 1 .0 )"input is out of range" )));if (unlikely(isinf(result)))/* * datan - returns the arctan of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * The principal branch of the inverse tangent function maps all inputs to * values in the range [ - Pi / 2 , Pi / 2 ] , so the result should always be * finite , even if the input is infinite . if (unlikely(isinf(result)))/* * atan2 - returns the arctan of arg1 / arg2 ( radians ) 0 );1 );/* Per the POSIX spec, return NaN if either input is NaN */ if (isnan(arg1) || isnan(arg2))/* * atan2 maps all inputs to values in the range [ - Pi , Pi ] , so the result * should always be finite , even if the inputs are infinite . if (unlikely(isinf(result)))/* * dcos - returns the cosine of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * cos ( ) is periodic and so theoretically can work for all finite inputs , * but some implementations may choose to throw error if the input is so * large that there are no significant digits in the result . So we should * check for errors . POSIX allows an error to be reported either via * errno or via fetestexcept ( ) , but currently we only support checking * errno . ( fetestexcept ( ) is rumored to report underflow unreasonably * early on some platforms , so it ' s not clear that believing it would be a * net improvement anyway . ) * * For infinite inputs , POSIX specifies that the trigonometric functions * should return a domain error ; but we won ' t notice that unless the * platform reports via errno , so also explicitly test for infinite * inputs . 0 ;if (errno != 0 || isinf(arg1))"input is out of range" )));if (unlikely(isinf(result)))/* * dcot - returns the cotangent of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* Be sure to throw an error if the input is infinite --- see dcos() */ 0 ;if (errno != 0 || isinf(arg1))"input is out of range" )));1 .0 / result;/* Not checking for overflow because cot(0) == Inf */ /* * dsin - returns the sine of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* Be sure to throw an error if the input is infinite --- see dcos() */ 0 ;if (errno != 0 || isinf(arg1))"input is out of range" )));if (unlikely(isinf(result)))/* * dtan - returns the tangent of arg1 ( radians ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* Be sure to throw an error if the input is infinite --- see dcos() */ 0 ;if (errno != 0 || isinf(arg1))"input is out of range" )));/* Not checking for overflow because tan(pi/2) == Inf */ /* ========== DEGREE-BASED TRIGONOMETRIC FUNCTIONS ========== */ /* * Initialize the cached constants declared at the head of this file * ( sin_30 etc ) . The fact that we need those at all , let alone need this * Rube - Goldberg - worthy method of initializing them , is because there are * compilers out there that will precompute expressions such as sin ( constant ) * using a sin ( ) function different from what will be used at runtime . If we * want exact results , we must ensure that none of the scaling constants used * in the degree - based trig functions are computed that way . To do so , we * compute them from the variables degree_c_thirty etc , which are also really * constants , but the compiler cannot assume that . * * Other hazards we are trying to forestall with this kluge include the * possibility that compilers will rearrange the expressions , or compute * some intermediate results in registers wider than a standard double . * * In the places where we use these constants , the typical pattern is like * volatile float8 sin_x = sin ( x * RADIANS_PER_DEGREE ) ; * return ( sin_x / sin_30 ) ; * where we hope to get a value of exactly 1 . 0 from the division when x = 30 . * The volatile temporary variable is needed on machines with wide float * registers , to ensure that the result of sin ( x ) is rounded to double width * the same as the value of sin_30 has been . Experimentation with gcc shows * that marking the temp variable volatile is necessary to make the store and * reload actually happen ; hopefully the same trick works for other compilers . * ( gcc ' s documentation suggests using the - ffloat - store compiler switch to * ensure this , but that is compiler - specific and it also pessimizes code in * many places where we don ' t care about this . ) static void void )1 .0 - cos(degree_c_sixty * RADIANS_PER_DEGREE);true ;#define INIT_DEGREE_CONSTANTS() \do { \if (!degree_consts_set) \while (0 )/* * asind_q1 - returns the inverse sine of x in degrees , for x in * the range [ 0 , 1 ] . The result is an angle in the * first quadrant - - - [ 0 , 90 ] degrees . * * For the 3 special case inputs ( 0 , 0 . 5 and 1 ) , this * function will return exact values ( 0 , 30 and 90 * degrees respectively ) . static double double x)/* * Stitch together inverse sine and cosine functions for the ranges [ 0 , * 0 . 5 ] and ( 0 . 5 , 1 ] . Each expression below is guaranteed to return * exactly 30 for x = 0 . 5 , so the result is a continuous monotonic function * over the full range . if (x <= 0 .5 )volatile float8 asin_x = asin(x);return (asin_x / asin_0_5) * 30 .0 ;else volatile float8 acos_x = acos(x);return 90 .0 - (acos_x / acos_0_5) * 60 .0 ;/* * acosd_q1 - returns the inverse cosine of x in degrees , for x in * the range [ 0 , 1 ] . The result is an angle in the * first quadrant - - - [ 0 , 90 ] degrees . * * For the 3 special case inputs ( 0 , 0 . 5 and 1 ) , this * function will return exact values ( 0 , 60 and 90 * degrees respectively ) . static double double x)/* * Stitch together inverse sine and cosine functions for the ranges [ 0 , * 0 . 5 ] and ( 0 . 5 , 1 ] . Each expression below is guaranteed to return * exactly 60 for x = 0 . 5 , so the result is a continuous monotonic function * over the full range . if (x <= 0 .5 )volatile float8 asin_x = asin(x);return 90 .0 - (asin_x / asin_0_5) * 30 .0 ;else volatile float8 acos_x = acos(x);return (acos_x / acos_0_5) * 60 .0 ;/* * dacosd - returns the arccos of arg1 ( degrees ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * The principal branch of the inverse cosine function maps values in the * range [ - 1 , 1 ] to values in the range [ 0 , 180 ] , so we should reject any * inputs outside that range and the result will always be finite . if (arg1 < -1 .0 || arg1 > 1 .0 )"input is out of range" )));if (arg1 >= 0 .0 )else 90 .0 + asind_q1(-arg1);if (unlikely(isinf(result)))/* * dasind - returns the arcsin of arg1 ( degrees ) 0 );/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * The principal branch of the inverse sine function maps values in the * range [ - 1 , 1 ] to values in the range [ - 90 , 90 ] , so we should reject any * inputs outside that range and the result will always be finite . if (arg1 < -1 .0 || arg1 > 1 .0 )"input is out of range" )));if (arg1 >= 0 .0 )else if (unlikely(isinf(result)))/* * datand - returns the arctan of arg1 ( degrees ) 0 );volatile float8 atan_arg1;/* Per the POSIX spec, return NaN if the input is NaN */ if (isnan(arg1))/* * The principal branch of the inverse tangent function maps all inputs to * values in the range [ - 90 , 90 ] , so the result should always be finite , * even if the input is infinite . Additionally , we take care to ensure * than when arg1 is 1 , the result is exactly 45 . 45 .0 ;if (unlikely(isinf(result)))/* * atan2d - returns the arctan of arg1 / arg2 ( degrees ) 0 );1 );volatile float8 atan2_arg1_arg2;/* Per the POSIX spec, return NaN if either input is NaN */ if (isnan(arg1) || isnan(arg2))/* * atan2d maps all inputs to values in the range [ - 180 , 180 ] , so the * result should always be finite , even if the inputs are infinite . * * Note : this coding assumes that atan ( 1 . 0 ) is a suitable scaling constant * to get an exact result from atan2 ( ) . This might well fail on us at * some point , requiring us to decide exactly what inputs we think we ' re * going to guarantee an exact result for . 45 .0 ;if (unlikely(isinf(result)))/* * sind_0_to_30 - returns the sine of an angle that lies between 0 and * 30 degrees . This will return exactly 0 when x is 0 , * and exactly 0 . 5 when x is 30 degrees . static double double x)volatile float8 sin_x = sin(x * RADIANS_PER_DEGREE);return (sin_x / sin_30) / 2 .0 ;/* * cosd_0_to_60 - returns the cosine of an angle that lies between 0 * and 60 degrees . This will return exactly 1 when x * is 0 , and exactly 0 . 5 when x is 60 degrees . static double double x)volatile float8 one_minus_cos_x = 1 .0 - cos(x * RADIANS_PER_DEGREE);return 1 .0 - (one_minus_cos_x / one_minus_cos_60) / 2 .0 ;/* * sind_q1 - returns the sine of an angle in the first quadrant * ( 0 to 90 degrees ) . static double double x)/* * Stitch together the sine and cosine functions for the ranges [ 0 , 30 ] * and ( 30 , 90 ] . These guarantee to return exact answers at their * endpoints , so the overall result is a continuous monotonic function * that gives exact results when x = 0 , 30 and 90 degrees . if (x <= 30 .0 )return sind_0_to_30(x);else return cosd_0_to_60(90 .0 - x);/* * cosd_q1 - returns the cosine of an angle in the first quadrant * ( 0 to 90 degrees ) . static double double x)/* * Stitch together the sine and cosine functions for the ranges [ 0 , 60 ] * and ( 60 , 90 ] . These guarantee to return exact answers at their * endpoints , so the overall result is a continuous monotonic function * that gives exact results when x = 0 , 60 and 90 degrees . if (x <= 60 .0 )return cosd_0_to_60(x);else return sind_0_to_30(90 .0 - x);/* * dcosd - returns the cosine of arg1 ( degrees ) 0 );int sign = 1 ;/* * Per the POSIX spec , return NaN if the input is NaN and throw an error * if the input is infinite . if (isnan(arg1))if (isinf(arg1))"input is out of range" )));/* Reduce the range of the input to [0,90] degrees */ 360 .0 );if (arg1 < 0 .0 )/* cosd(-x) = cosd(x) */ if (arg1 > 180 .0 )/* cosd(360-x) = cosd(x) */ 360 .0 - arg1;if (arg1 > 90 .0 )/* cosd(180-x) = -cosd(x) */ 180 .0 - arg1;if (unlikely(isinf(result)))/* * dcotd - returns the cotangent of arg1 ( degrees ) 0 );volatile float8 cot_arg1;int sign = 1 ;/* * Per the POSIX spec , return NaN if the input is NaN and throw an error * if the input is infinite . if (isnan(arg1))if (isinf(arg1))"input is out of range" )));/* Reduce the range of the input to [0,90] degrees */ 360 .0 );if (arg1 < 0 .0 )/* cotd(-x) = -cotd(x) */ if (arg1 > 180 .0 )/* cotd(360-x) = -cotd(x) */ 360 .0 - arg1;if (arg1 > 90 .0 )/* cotd(180-x) = -cotd(x) */ 180 .0 - arg1;/* * On some machines we get cotd ( 270 ) = minus zero , but this isn ' t always * true . For portability , and because the user constituency for this * function probably doesn ' t want minus zero , force it to plain zero . if (result == 0 .0 )0 .0 ;/* Not checking for overflow because cotd(0) == Inf */ /* * dsind - returns the sine of arg1 ( degrees ) 0 );int sign = 1 ;/* * Per the POSIX spec , return NaN if the input is NaN and throw an error * if the input is infinite . if (isnan(arg1))if (isinf(arg1))"input is out of range" )));/* Reduce the range of the input to [0,90] degrees */ 360 .0 );if (arg1 < 0 .0 )/* sind(-x) = -sind(x) */ if (arg1 > 180 .0 )/* sind(360-x) = -sind(x) */ 360 .0 - arg1;if (arg1 > 90 .0 )/* sind(180-x) = sind(x) */ 180 .0 - arg1;if (unlikely(isinf(result)))/* * dtand - returns the tangent of arg1 ( degrees ) 0 );volatile float8 tan_arg1;int sign = 1 ;/* * Per the POSIX spec , return NaN if the input is NaN and throw an error * if the input is infinite . if (isnan(arg1))if (isinf(arg1))"input is out of range" )));/* Reduce the range of the input to [0,90] degrees */ 360 .0 );if (arg1 < 0 .0 )/* tand(-x) = -tand(x) */ if (arg1 > 180 .0 )/* tand(360-x) = -tand(x) */ 360 .0 - arg1;if (arg1 > 90 .0 )/* tand(180-x) = -tand(x) */ 180 .0 - arg1;/* * On some machines we get tand ( 180 ) = minus zero , but this isn ' t always * true . For portability , and because the user constituency for this * function probably doesn ' t want minus zero , force it to plain zero . if (result == 0 .0 )0 .0 ;/* Not checking for overflow because tand(90) == Inf */ /* * degrees - returns degrees converted from radians 0 );/* * dpi - returns the constant PI /* * radians - returns radians converted from degrees 0 );/* ========== HYPERBOLIC FUNCTIONS ========== */ /* * dsinh - returns the hyperbolic sine of arg1 0 );0 ;/* * if an ERANGE error occurs , it means there is an overflow . For sinh , * the result should be either - infinity or infinity , depending on the * sign of arg1 . if (errno == ERANGE)if (arg1 < 0 )else /* * dcosh - returns the hyperbolic cosine of arg1 0 );0 ;/* * if an ERANGE error occurs , it means there is an overflow . As cosh is * always positive , it always means the result is positive infinity . if (errno == ERANGE)if (unlikely(result == 0 .0 ))/* * dtanh - returns the hyperbolic tangent of arg1 0 );/* * For tanh , we don ' t need an errno check because it never overflows . if (unlikely(isinf(result)))/* * dasinh - returns the inverse hyperbolic sine of arg1 0 );/* * For asinh , we don ' t need an errno check because it never overflows . /* * dacosh - returns the inverse hyperbolic cosine of arg1 0 );/* * acosh is only defined for inputs > = 1 . 0 . By checking this ourselves , * we need not worry about checking for an EDOM error , which is a good * thing because some implementations will report that for NaN . Otherwise , * no error is possible . if (arg1 < 1 .0 )"input is out of range" )));/* * datanh - returns the inverse hyperbolic tangent of arg1 0 );/* * atanh is only defined for inputs between - 1 and 1 . By checking this * ourselves , we need not worry about checking for an EDOM error , which is * a good thing because some implementations will report that for NaN . if (arg1 < -1 .0 || arg1 > 1 .0 )"input is out of range" )));/* * Also handle the infinity cases ourselves ; this is helpful because old * glibc versions may produce the wrong errno for this . All other inputs * cannot produce an error . if (arg1 == -1 .0 )else if (arg1 == 1 .0 )else /* ========== ERROR FUNCTIONS ========== */ /* * derf - returns the error function : erf ( arg1 ) 0 );/* * For erf , we don ' t need an errno check because it never overflows . if (unlikely(isinf(result)))/* * derfc - returns the complementary error function : 1 - erf ( arg1 ) 0 );/* * For erfc , we don ' t need an errno check because it never overflows . if (unlikely(isinf(result)))/* ========== GAMMA FUNCTIONS ========== */ /* * dgamma - returns the gamma function of arg1 0 );/* * Handle NaN and Inf cases explicitly . This simplifies the overflow * checks on platforms that do not set errno . if (isnan(arg1))else if (isinf(arg1))/* Per POSIX, an input of -Inf causes a domain error */ if (arg1 < 0 )/* keep compiler quiet */ else else /* * Note : the POSIX / C99 gamma function is called " tgamma " , not " gamma " . * * On some platforms , tgamma ( ) will not set errno but just return Inf , * NaN , or zero to report overflow / underflow ; therefore , test those * cases explicitly ( note that , like the exponential function , the * gamma function has no zeros ) . 0 ;if (errno != 0 || isinf(result) || isnan(result))if (result != 0 .0 )else else if (result == 0 .0 )/* * dlgamma - natural logarithm of absolute value of gamma of arg1 0 );/* * Note : lgamma may not be thread - safe because it may write to a global * variable signgam , which may not be thread - local . However , this doesn ' t * matter to us , since we don ' t use signgam . 0 ;/* * If an ERANGE error occurs , it means there was an overflow or a pole * error ( which happens for zero and negative integer inputs ) . * * On some platforms , lgamma ( ) will not set errno but just return infinity * to report overflow , but it should never underflow . if (errno == ERANGE || (isinf(result) && !isinf(arg1)))/* * = = = = = = = = = = = = = = = = = = = = = = = = = * FLOAT AGGREGATE OPERATORS * = = = = = = = = = = = = = = = = = = = = = = = = = * * float8_accum - accumulate for AVG ( ) , variance aggregates , etc . * float4_accum - same , but input data is float4 * float8_avg - produce final result for float AVG ( ) * float8_var_samp - produce final result for float VAR_SAMP ( ) * float8_var_pop - produce final result for float VAR_POP ( ) * float8_stddev_samp - produce final result for float STDDEV_SAMP ( ) * float8_stddev_pop - produce final result for float STDDEV_POP ( ) * * The naive schoolbook implementation of these aggregates works by * accumulating sum ( X ) and sum ( X ^ 2 ) . However , this approach suffers from * large rounding errors in the final computation of quantities like the * population variance ( N * sum ( X ^ 2 ) - sum ( X ) ^ 2 ) / N ^ 2 , since each of the * intermediate terms is potentially very large , while the difference is often * quite small . * * Instead we use the Youngs - Cramer algorithm [ 1 ] which works by accumulating * Sx = sum ( X ) and Sxx = sum ( ( X - Sx / N ) ^ 2 ) , using a numerically stable algorithm to * incrementally update those quantities . The final computations of each of * the aggregate values is then trivial and gives more accurate results ( for * example , the population variance is just Sxx / N ) . This algorithm is also * fairly easy to generalize to allow parallel execution without loss of * precision ( see , for example , [ 2 ] ) . For more details , and a comparison of * this with other algorithms , see [ 3 ] . * * The transition datatype for all these aggregates is a 3 - element array * of float8 , holding the values N , Sx , Sxx in that order . * * Note that we represent N as a float to avoid having to build a special * datatype . Given a reasonable floating - point implementation , there should * be no accuracy loss unless N exceeds 2 ^ 52 or so ( by which time the * user will have doubtless lost interest anyway . . . ) * * [ 1 ] Some Results Relevant to Choice of Sum and Sum - of - Product Algorithms , * E . A . Youngs and E . M . Cramer , Technometrics Vol 13 , No 3 , August 1971 . * * [ 2 ] Updating Formulae and a Pairwise Algorithm for Computing Sample * Variances , T . F . Chan , G . H . Golub & R . J . LeVeque , COMPSTAT 1982 . * * [ 3 ] Numerically Stable Parallel Computation of ( Co - ) Variance , Erich * Schubert and Michael Gertz , Proceedings of the 30 th International * Conference on Scientific and Statistical Database Management , 2018 . static float8 *const char *caller, int n)/* * We expect the input to be an N - element float array ; verify that . We * don ' t need to use deconstruct_array ( ) since the array data is just * going to look like a C array of N float8 values . if (ARR_NDIM(transarray) != 1 ||0 ] != n ||"%s: expected %d-element float8 array" , caller, n);return (float8 *) ARR_DATA_PTR(transarray);/* * float8_combine * * An aggregate combine function used to combine two 3 fields * aggregate transition data into a single transition data . * This function is used only in two stage aggregation and * shouldn ' t be called outside aggregate context . 0 );1 );"float8_combine" , 3 );"float8_combine" , 3 );0 ];1 ];2 ];0 ];1 ];2 ];/*-------------------- * The transition values combine using a generalization of the * Youngs - Cramer algorithm as follows : * * N = N1 + N2 * Sx = Sx1 + Sx2 * Sxx = Sxx1 + Sxx2 + N1 * N2 * ( Sx1 / N1 - Sx2 / N2 ) ^ 2 / N ; * * It ' s worth handling the special cases N1 = 0 and N2 = 0 separately * since those cases are trivial , and we then don ' t need to worry about * division - by - zero errors in the general case . * - - - - - - - - - - - - - - - - - - - - if (N1 == 0 .0 )else if (N2 == 0 .0 )else if (unlikely(isinf(Sxx)) && !isinf(Sxx1) && !isinf(Sxx2))/* * If we ' re invoked as an aggregate , we can cheat and modify our first * parameter in - place to reduce palloc overhead . Otherwise we construct a * new array with the updated transition data and return it . if (AggCheckCallContext(fcinfo, NULL))0 ] = N;1 ] = Sx;2 ] = Sxx;else 3 ];0 ] = Float8GetDatumFast(N);1 ] = Float8GetDatumFast(Sx);2 ] = Float8GetDatumFast(Sxx);3 , FLOAT8OID);0 );1 );"float8_accum" , 3 );0 ];1 ];2 ];/* * Use the Youngs - Cramer algorithm to incorporate the new value into the * transition values . 1 .0 ;if (transvalues[0 ] > 0 .0 )0 ]);/* * Overflow check . We only report an overflow error when finite * inputs lead to infinite results . Note also that Sxx should be NaN * if any of the inputs are infinite , so we intentionally prevent Sxx * from becoming infinite . if (isinf(Sx) || isinf(Sxx))if (!isinf(transvalues[1 ]) && !isinf(newval))else /* * At the first input , we normally can leave Sxx as 0 . However , if * the first input is Inf or NaN , we ' d better force Sxx to NaN ; * otherwise we will falsely report variance zero when there are no * more inputs . if (isnan(newval) || isinf(newval))/* * If we ' re invoked as an aggregate , we can cheat and modify our first * parameter in - place to reduce palloc overhead . Otherwise we construct a * new array with the updated transition data and return it . if (AggCheckCallContext(fcinfo, NULL))0 ] = N;1 ] = Sx;2 ] = Sxx;else 3 ];0 ] = Float8GetDatumFast(N);1 ] = Float8GetDatumFast(Sx);2 ] = Float8GetDatumFast(Sxx);3 , FLOAT8OID);0 );/* do computations as float8 */ 1 );"float4_accum" , 3 );0 ];1 ];2 ];/* * Use the Youngs - Cramer algorithm to incorporate the new value into the * transition values . 1 .0 ;if (transvalues[0 ] > 0 .0 )0 ]);/* * Overflow check . We only report an overflow error when finite * inputs lead to infinite results . Note also that Sxx should be NaN * if any of the inputs are infinite , so we intentionally prevent Sxx * from becoming infinite . if (isinf(Sx) || isinf(Sxx))if (!isinf(transvalues[1 ]) && !isinf(newval))else /* * At the first input , we normally can leave Sxx as 0 . However , if * the first input is Inf or NaN , we ' d better force Sxx to NaN ; * otherwise we will falsely report variance zero when there are no * more inputs . if (isnan(newval) || isinf(newval))/* * If we ' re invoked as an aggregate , we can cheat and modify our first * parameter in - place to reduce palloc overhead . Otherwise we construct a * new array with the updated transition data and return it . if (AggCheckCallContext(fcinfo, NULL))0 ] = N;1 ] = Sx;2 ] = Sxx;else 3 ];0 ] = Float8GetDatumFast(N);1 ] = Float8GetDatumFast(Sx);2 ] = Float8GetDatumFast(Sxx);3 , FLOAT8OID);0 );"float8_avg" , 3 );0 ];1 ];/* ignore Sxx */ /* SQL defines AVG of no values to be NULL */ if (N == 0 .0 )0 );"float8_var_pop" , 3 );0 ];/* ignore Sx */ 2 ];/* Population variance is undefined when N is 0, so return NULL */ if (N == 0 .0 )/* Note that Sxx is guaranteed to be non-negative */ 0 );"float8_var_samp" , 3 );0 ];/* ignore Sx */ 2 ];/* Sample variance is undefined when N is 0 or 1, so return NULL */ if (N <= 1 .0 )/* Note that Sxx is guaranteed to be non-negative */ 1 .0 ));0 );"float8_stddev_pop" , 3 );0 ];/* ignore Sx */ 2 ];/* Population stddev is undefined when N is 0, so return NULL */ if (N == 0 .0 )/* Note that Sxx is guaranteed to be non-negative */ 0 );"float8_stddev_samp" , 3 );0 ];/* ignore Sx */ 2 ];/* Sample stddev is undefined when N is 0 or 1, so return NULL */ if (N <= 1 .0 )/* Note that Sxx is guaranteed to be non-negative */ 1 .0 )));/* * = = = = = = = = = = = = = = = = = = = = = = = = = * SQL2003 BINARY AGGREGATES * = = = = = = = = = = = = = = = = = = = = = = = = = * * As with the preceding aggregates , we use the Youngs - Cramer algorithm to * reduce rounding errors in the aggregate final functions . * * The transition datatype for all these aggregates is a 6 - element array of * float8 , holding the values N , Sx = sum ( X ) , Sxx = sum ( ( X - Sx / N ) ^ 2 ) , Sy = sum ( Y ) , * Syy = sum ( ( Y - Sy / N ) ^ 2 ) , Sxy = sum ( ( X - Sx / N ) * ( Y - Sy / N ) ) in that order . * * Note that Y is the first argument to all these aggregates ! * * It might seem attractive to optimize this by having multiple accumulator * functions that only calculate the sums actually needed . But on most * modern machines , a couple of extra floating - point multiplies will be * insignificant compared to the other per - tuple overhead , so I ' ve chosen * to minimize code space instead . 0 );1 );2 );"float8_regr_accum" , 6 );0 ];1 ];2 ];3 ];4 ];5 ];/* * Use the Youngs - Cramer algorithm to incorporate the new values into the * transition values . 1 .0 ;if (transvalues[0 ] > 0 .0 )1 .0 / (N * transvalues[0 ]);/* * Overflow check . We only report an overflow error when finite * inputs lead to infinite results . Note also that Sxx , Syy and Sxy * should be NaN if any of the relevant inputs are infinite , so we * intentionally prevent them from becoming infinite . if (isinf(Sx) || isinf(Sxx) || isinf(Sy) || isinf(Syy) || isinf(Sxy))if (((isinf(Sx) || isinf(Sxx)) &&1 ]) && !isinf(newvalX)) ||3 ]) && !isinf(newvalY)) ||1 ]) && !isinf(newvalX) &&3 ]) && !isinf(newvalY)))if (isinf(Sxx))if (isinf(Syy))if (isinf(Sxy))else /* * At the first input , we normally can leave Sxx et al as 0 . However , * if the first input is Inf or NaN , we ' d better force the dependent * sums to NaN ; otherwise we will falsely report variance zero when * there are no more inputs . if (isnan(newvalX) || isinf(newvalX))if (isnan(newvalY) || isinf(newvalY))/* * If we ' re invoked as an aggregate , we can cheat and modify our first * parameter in - place to reduce palloc overhead . Otherwise we construct a * new array with the updated transition data and return it . if (AggCheckCallContext(fcinfo, NULL))0 ] = N;1 ] = Sx;2 ] = Sxx;3 ] = Sy;4 ] = Syy;5 ] = Sxy;else 6 ];0 ] = Float8GetDatumFast(N);1 ] = Float8GetDatumFast(Sx);2 ] = Float8GetDatumFast(Sxx);3 ] = Float8GetDatumFast(Sy);4 ] = Float8GetDatumFast(Syy);5 ] = Float8GetDatumFast(Sxy);6 , FLOAT8OID);/* * float8_regr_combine * * An aggregate combine function used to combine two 6 fields * aggregate transition data into a single transition data . * This function is used only in two stage aggregation and * shouldn ' t be called outside aggregate context . 0 );1 );"float8_regr_combine" , 6 );"float8_regr_combine" , 6 );0 ];1 ];2 ];3 ];4 ];5 ];0 ];1 ];2 ];3 ];4 ];5 ];/*-------------------- * The transition values combine using a generalization of the * Youngs - Cramer algorithm as follows : * * N = N1 + N2 * Sx = Sx1 + Sx2 * Sxx = Sxx1 + Sxx2 + N1 * N2 * ( Sx1 / N1 - Sx2 / N2 ) ^ 2 / N * Sy = Sy1 + Sy2 * Syy = Syy1 + Syy2 + N1 * N2 * ( Sy1 / N1 - Sy2 / N2 ) ^ 2 / N * Sxy = Sxy1 + Sxy2 + N1 * N2 * ( Sx1 / N1 - Sx2 / N2 ) * ( Sy1 / N1 - Sy2 / N2 ) / N * * It ' s worth handling the special cases N1 = 0 and N2 = 0 separately * since those cases are trivial , and we then don ' t need to worry about * division - by - zero errors in the general case . * - - - - - - - - - - - - - - - - - - - - if (N1 == 0 .0 )else if (N2 == 0 .0 )else if (unlikely(isinf(Sxx)) && !isinf(Sxx1) && !isinf(Sxx2))if (unlikely(isinf(Syy)) && !isinf(Syy1) && !isinf(Syy2))if (unlikely(isinf(Sxy)) && !isinf(Sxy1) && !isinf(Sxy2))/* * If we ' re invoked as an aggregate , we can cheat and modify our first * parameter in - place to reduce palloc overhead . Otherwise we construct a * new array with the updated transition data and return it . if (AggCheckCallContext(fcinfo, NULL))0 ] = N;1 ] = Sx;2 ] = Sxx;3 ] = Sy;4 ] = Syy;5 ] = Sxy;else 6 ];0 ] = Float8GetDatumFast(N);1 ] = Float8GetDatumFast(Sx);2 ] = Float8GetDatumFast(Sxx);3 ] = Float8GetDatumFast(Sy);4 ] = Float8GetDatumFast(Syy);5 ] = Float8GetDatumFast(Sxy);6 , FLOAT8OID);0 );"float8_regr_sxx" , 6 );0 ];2 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* Note that Sxx is guaranteed to be non-negative */ 0 );"float8_regr_syy" , 6 );0 ];4 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* Note that Syy is guaranteed to be non-negative */ 0 );"float8_regr_sxy" , 6 );0 ];5 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* A negative result is valid here */ 0 );"float8_regr_avgx" , 6 );0 ];1 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )0 );"float8_regr_avgy" , 6 );0 ];3 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )0 );"float8_covar_pop" , 6 );0 ];5 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )0 );"float8_covar_samp" , 6 );0 ];5 ];/* if N is <= 1 we should return NULL */ if (N < 2 .0 )1 .0 ));0 );"float8_corr" , 6 );0 ];2 ];4 ];5 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* Note that Sxx and Syy are guaranteed to be non-negative */ /* per spec, return NULL for horizontal and vertical lines */ if (Sxx == 0 || Syy == 0 )0 );"float8_regr_r2" , 6 );0 ];2 ];4 ];5 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* Note that Sxx and Syy are guaranteed to be non-negative */ /* per spec, return NULL for a vertical line */ if (Sxx == 0 )/* per spec, return 1.0 for a horizontal line */ if (Syy == 0 )1 .0 );0 );"float8_regr_slope" , 6 );0 ];2 ];5 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* Note that Sxx is guaranteed to be non-negative */ /* per spec, return NULL for a vertical line */ if (Sxx == 0 )0 );"float8_regr_intercept" , 6 );0 ];1 ];2 ];3 ];5 ];/* if N is 0 we should return NULL */ if (N < 1 .0 )/* Note that Sxx is guaranteed to be non-negative */ /* per spec, return NULL for a vertical line */ if (Sxx == 0 )/* * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * MIXED - PRECISION ARITHMETIC OPERATORS * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = /* * float48pl - returns arg1 + arg2 * float48mi - returns arg1 - arg2 * float48mul - returns arg1 * arg2 * float48div - returns arg1 / arg2 0 );1 );0 );1 );0 );1 );0 );1 );/* * float84pl - returns arg1 + arg2 * float84mi - returns arg1 - arg2 * float84mul - returns arg1 * arg2 * float84div - returns arg1 / arg2 0 );1 );0 );1 );0 );1 );0 );1 );/* * = = = = = = = = = = = = = = = = = = = = * COMPARISON OPERATORS * = = = = = = = = = = = = = = = = = = = = /* * float48 { eq , ne , lt , le , gt , ge } - float4 / float8 comparison operations 0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );/* * float84 { eq , ne , lt , le , gt , ge } - float8 / float4 comparison operations 0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );0 );1 );/* * Implements the float8 version of the width_bucket ( ) function * defined by SQL2003 . See also width_bucket_numeric ( ) . * * ' bound1 ' and ' bound2 ' are the lower and upper bounds of the * histogram ' s range , respectively . ' count ' is the number of buckets * in the histogram . width_bucket ( ) returns an integer indicating the * bucket number that ' operand ' belongs to in an equiwidth histogram * with the specified characteristics . An operand smaller than the * lower bound is assigned to bucket 0 . An operand greater than or equal * to the upper bound is assigned to an additional bucket ( with number * count + 1 ) . We don ' t allow " NaN " for any of the float8 inputs , and we * don ' t allow either of the histogram bounds to be + / - infinity . 0 );1 );2 );3 );if (count <= 0 )"count must be greater than zero" )));if (isnan(operand) || isnan(bound1) || isnan(bound2))"operand, lower bound, and upper bound cannot be NaN" )));/* Note that we allow "operand" to be infinite */ if (isinf(bound1) || isinf(bound2))"lower and upper bounds must be finite" )));if (bound1 < bound2)if (operand < bound1)0 ;else if (operand >= bound2)if (pg_add_s32_overflow(count, 1 , &result))"integer out of range" )));else if (!isinf(bound2 - bound1))/* The quotient is surely in [0,1], so this can't overflow */ else /* * We get here if bound2 - bound1 overflows DBL_MAX . Since * both bounds are finite , their difference can ' t exceed twice * DBL_MAX ; so we can perform the computation without overflow * by dividing all the inputs by 2 . That should be exact too , * except in the case where a very small operand underflows to * zero , which would have negligible impact on the result * given such large bounds . 2 - bound1 / 2 ) / (bound2 / 2 - bound1 / 2 ));/* The quotient could round to 1.0, which would be a lie */ if (result >= count)1 ;/* Having done that, we can add 1 without fear of overflow */ else if (bound1 > bound2)if (operand > bound1)0 ;else if (operand <= bound2)if (pg_add_s32_overflow(count, 1 , &result))"integer out of range" )));else if (!isinf(bound1 - bound2))else 2 - operand / 2 ) / (bound1 / 2 - bound2 / 2 ));if (result >= count)1 ;else "lower bound cannot equal upper bound" )));0 ; /* keep the compiler quiet */
Messung V0.5 in Prozent C=94 H=94 G=93
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.164Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-08-08)
¤ *Bot Zugriff
2026-08-25
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=141584 #Domains=752002
