float.c File Reference

#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/pg_prng.h"
#include "common/shortest_dec.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "utils/array.h"
#include "utils/fmgrprotos.h"
#include "utils/sortsupport.h"
#include "utils/timestamp.h"

Include dependency graph for float.c:

Go to the source code of this file.

Macros
#define	INIT_DEGREE_CONSTANTS()

Functions
static double	sind_q1 (double x)
static double	cosd_q1 (double x)
static void	init_degree_constants (void)
pg_noinline void	float_overflow_error (void)
pg_noinline void	float_underflow_error (void)
pg_noinline void	float_zero_divide_error (void)
int	is_infinite (double val)
Datum	float4in (PG_FUNCTION_ARGS)
float4	float4in_internal (char *num, char **endptr_p, const char *type_name, const char *orig_string, struct Node *escontext)
Datum	float4out (PG_FUNCTION_ARGS)
Datum	float4recv (PG_FUNCTION_ARGS)
Datum	float4send (PG_FUNCTION_ARGS)
Datum	float8in (PG_FUNCTION_ARGS)
float8	float8in_internal (char *num, char **endptr_p, const char *type_name, const char *orig_string, struct Node *escontext)
Datum	float8out (PG_FUNCTION_ARGS)
char *	float8out_internal (double num)
Datum	float8recv (PG_FUNCTION_ARGS)
Datum	float8send (PG_FUNCTION_ARGS)
Datum	float4abs (PG_FUNCTION_ARGS)
Datum	float4um (PG_FUNCTION_ARGS)
Datum	float4up (PG_FUNCTION_ARGS)
Datum	float4larger (PG_FUNCTION_ARGS)
Datum	float4smaller (PG_FUNCTION_ARGS)
Datum	float8abs (PG_FUNCTION_ARGS)
Datum	float8um (PG_FUNCTION_ARGS)
Datum	float8up (PG_FUNCTION_ARGS)
Datum	float8larger (PG_FUNCTION_ARGS)
Datum	float8smaller (PG_FUNCTION_ARGS)
Datum	float4pl (PG_FUNCTION_ARGS)
Datum	float4mi (PG_FUNCTION_ARGS)
Datum	float4mul (PG_FUNCTION_ARGS)
Datum	float4div (PG_FUNCTION_ARGS)
Datum	float8pl (PG_FUNCTION_ARGS)
Datum	float8mi (PG_FUNCTION_ARGS)
Datum	float8mul (PG_FUNCTION_ARGS)
Datum	float8div (PG_FUNCTION_ARGS)
int	float4_cmp_internal (float4 a, float4 b)
Datum	float4eq (PG_FUNCTION_ARGS)
Datum	float4ne (PG_FUNCTION_ARGS)
Datum	float4lt (PG_FUNCTION_ARGS)
Datum	float4le (PG_FUNCTION_ARGS)
Datum	float4gt (PG_FUNCTION_ARGS)
Datum	float4ge (PG_FUNCTION_ARGS)
Datum	btfloat4cmp (PG_FUNCTION_ARGS)
static int	btfloat4fastcmp (Datum x, Datum y, SortSupport ssup)
Datum	btfloat4sortsupport (PG_FUNCTION_ARGS)
int	float8_cmp_internal (float8 a, float8 b)
Datum	float8eq (PG_FUNCTION_ARGS)
Datum	float8ne (PG_FUNCTION_ARGS)
Datum	float8lt (PG_FUNCTION_ARGS)
Datum	float8le (PG_FUNCTION_ARGS)
Datum	float8gt (PG_FUNCTION_ARGS)
Datum	float8ge (PG_FUNCTION_ARGS)
Datum	btfloat8cmp (PG_FUNCTION_ARGS)
static int	btfloat8fastcmp (Datum x, Datum y, SortSupport ssup)
Datum	btfloat8sortsupport (PG_FUNCTION_ARGS)
Datum	btfloat48cmp (PG_FUNCTION_ARGS)
Datum	btfloat84cmp (PG_FUNCTION_ARGS)
Datum	in_range_float8_float8 (PG_FUNCTION_ARGS)
Datum	in_range_float4_float8 (PG_FUNCTION_ARGS)
Datum	ftod (PG_FUNCTION_ARGS)
Datum	dtof (PG_FUNCTION_ARGS)
Datum	dtoi4 (PG_FUNCTION_ARGS)
Datum	dtoi2 (PG_FUNCTION_ARGS)
Datum	i4tod (PG_FUNCTION_ARGS)
Datum	i2tod (PG_FUNCTION_ARGS)
Datum	ftoi4 (PG_FUNCTION_ARGS)
Datum	ftoi2 (PG_FUNCTION_ARGS)
Datum	i4tof (PG_FUNCTION_ARGS)
Datum	i2tof (PG_FUNCTION_ARGS)
Datum	dround (PG_FUNCTION_ARGS)
Datum	dceil (PG_FUNCTION_ARGS)
Datum	dfloor (PG_FUNCTION_ARGS)
Datum	dsign (PG_FUNCTION_ARGS)
Datum	dtrunc (PG_FUNCTION_ARGS)
Datum	dsqrt (PG_FUNCTION_ARGS)
Datum	dcbrt (PG_FUNCTION_ARGS)
Datum	dpow (PG_FUNCTION_ARGS)
Datum	dexp (PG_FUNCTION_ARGS)
Datum	dlog1 (PG_FUNCTION_ARGS)
Datum	dlog10 (PG_FUNCTION_ARGS)
Datum	dacos (PG_FUNCTION_ARGS)
Datum	dasin (PG_FUNCTION_ARGS)
Datum	datan (PG_FUNCTION_ARGS)
Datum	datan2 (PG_FUNCTION_ARGS)
Datum	dcos (PG_FUNCTION_ARGS)
Datum	dcot (PG_FUNCTION_ARGS)
Datum	dsin (PG_FUNCTION_ARGS)
Datum	dtan (PG_FUNCTION_ARGS)
static double	asind_q1 (double x)
static double	acosd_q1 (double x)
Datum	dacosd (PG_FUNCTION_ARGS)
Datum	dasind (PG_FUNCTION_ARGS)
Datum	datand (PG_FUNCTION_ARGS)
Datum	datan2d (PG_FUNCTION_ARGS)
static double	sind_0_to_30 (double x)
static double	cosd_0_to_60 (double x)
Datum	dcosd (PG_FUNCTION_ARGS)
Datum	dcotd (PG_FUNCTION_ARGS)
Datum	dsind (PG_FUNCTION_ARGS)
Datum	dtand (PG_FUNCTION_ARGS)
Datum	degrees (PG_FUNCTION_ARGS)
Datum	dpi (PG_FUNCTION_ARGS)
Datum	radians (PG_FUNCTION_ARGS)
Datum	dsinh (PG_FUNCTION_ARGS)
Datum	dcosh (PG_FUNCTION_ARGS)
Datum	dtanh (PG_FUNCTION_ARGS)
Datum	dasinh (PG_FUNCTION_ARGS)
Datum	dacosh (PG_FUNCTION_ARGS)
Datum	datanh (PG_FUNCTION_ARGS)
Datum	derf (PG_FUNCTION_ARGS)
Datum	derfc (PG_FUNCTION_ARGS)
static void	initialize_drandom_seed (void)
Datum	drandom (PG_FUNCTION_ARGS)
Datum	drandom_normal (PG_FUNCTION_ARGS)
Datum	setseed (PG_FUNCTION_ARGS)
static float8 *	check_float8_array (ArrayType *transarray, const char *caller, int n)
Datum	float8_combine (PG_FUNCTION_ARGS)
Datum	float8_accum (PG_FUNCTION_ARGS)
Datum	float4_accum (PG_FUNCTION_ARGS)
Datum	float8_avg (PG_FUNCTION_ARGS)
Datum	float8_var_pop (PG_FUNCTION_ARGS)
Datum	float8_var_samp (PG_FUNCTION_ARGS)
Datum	float8_stddev_pop (PG_FUNCTION_ARGS)
Datum	float8_stddev_samp (PG_FUNCTION_ARGS)
Datum	float8_regr_accum (PG_FUNCTION_ARGS)
Datum	float8_regr_combine (PG_FUNCTION_ARGS)
Datum	float8_regr_sxx (PG_FUNCTION_ARGS)
Datum	float8_regr_syy (PG_FUNCTION_ARGS)
Datum	float8_regr_sxy (PG_FUNCTION_ARGS)
Datum	float8_regr_avgx (PG_FUNCTION_ARGS)
Datum	float8_regr_avgy (PG_FUNCTION_ARGS)
Datum	float8_covar_pop (PG_FUNCTION_ARGS)
Datum	float8_covar_samp (PG_FUNCTION_ARGS)
Datum	float8_corr (PG_FUNCTION_ARGS)
Datum	float8_regr_r2 (PG_FUNCTION_ARGS)
Datum	float8_regr_slope (PG_FUNCTION_ARGS)
Datum	float8_regr_intercept (PG_FUNCTION_ARGS)
Datum	float48pl (PG_FUNCTION_ARGS)
Datum	float48mi (PG_FUNCTION_ARGS)
Datum	float48mul (PG_FUNCTION_ARGS)
Datum	float48div (PG_FUNCTION_ARGS)
Datum	float84pl (PG_FUNCTION_ARGS)
Datum	float84mi (PG_FUNCTION_ARGS)
Datum	float84mul (PG_FUNCTION_ARGS)
Datum	float84div (PG_FUNCTION_ARGS)
Datum	float48eq (PG_FUNCTION_ARGS)
Datum	float48ne (PG_FUNCTION_ARGS)
Datum	float48lt (PG_FUNCTION_ARGS)
Datum	float48le (PG_FUNCTION_ARGS)
Datum	float48gt (PG_FUNCTION_ARGS)
Datum	float48ge (PG_FUNCTION_ARGS)
Datum	float84eq (PG_FUNCTION_ARGS)
Datum	float84ne (PG_FUNCTION_ARGS)
Datum	float84lt (PG_FUNCTION_ARGS)
Datum	float84le (PG_FUNCTION_ARGS)
Datum	float84gt (PG_FUNCTION_ARGS)
Datum	float84ge (PG_FUNCTION_ARGS)
Datum	width_bucket_float8 (PG_FUNCTION_ARGS)

Variables
int	extra_float_digits = 1
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
float8	degree_c_thirty = 30.0
float8	degree_c_forty_five = 45.0
float8	degree_c_sixty = 60.0
float8	degree_c_one_half = 0.5
float8	degree_c_one = 1.0
static bool	drandom_seed_set = false
static pg_prng_state	drandom_seed

Macro Definition Documentation

INIT_DEGREE_CONSTANTS

#define INIT_DEGREE_CONSTANTS

(

)

Value:

do { \
    if (!degree_consts_set) \
        init_degree_constants(); \
} while(0)

Definition at line 2030 of file float.c.

Function Documentation

acosd_q1()

static double acosd_q1 ( double  x )

static

Definition at line 2080 of file float.c.

{
    /*
     * 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;
    }
}

References acos_0_5, asin_0_5, and x.

Referenced by dacosd().

asind_q1()

static double asind_q1 ( double  x )

static

Definition at line 2047 of file float.c.

{
    /*
     * 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;
    }
}

References acos_0_5, asin_0_5, and x.

Referenced by dacosd(), and dasind().

btfloat48cmp()

Datum btfloat48cmp

(

PG_FUNCTION_ARGS

)

Definition at line 1000 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    /* widen float4 to float8 and then compare */
    PG_RETURN_INT32(float8_cmp_internal(arg1, arg2));
}

References float8_cmp_internal(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_INT32.

btfloat4cmp()

Datum btfloat4cmp

(

PG_FUNCTION_ARGS

)

Definition at line 879 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_INT32(float4_cmp_internal(arg1, arg2));
}

References float4_cmp_internal(), PG_GETARG_FLOAT4, and PG_RETURN_INT32.

btfloat4fastcmp()

static int btfloat4fastcmp ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 888 of file float.c.

{
    float4      arg1 = DatumGetFloat4(x);
    float4      arg2 = DatumGetFloat4(y);
 
    return float4_cmp_internal(arg1, arg2);
}

References DatumGetFloat4(), float4_cmp_internal(), x, and y.

Referenced by btfloat4sortsupport().

btfloat4sortsupport()

Datum btfloat4sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 897 of file float.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = btfloat4fastcmp;
    PG_RETURN_VOID();
}

References btfloat4fastcmp(), SortSupportData::comparator, PG_GETARG_POINTER, and PG_RETURN_VOID.

btfloat84cmp()

Datum btfloat84cmp

(

PG_FUNCTION_ARGS

)

Definition at line 1010 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    /* widen float4 to float8 and then compare */
    PG_RETURN_INT32(float8_cmp_internal(arg1, arg2));
}

References float8_cmp_internal(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_INT32.

btfloat8cmp()

Datum btfloat8cmp

(

PG_FUNCTION_ARGS

)

Definition at line 973 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_INT32(float8_cmp_internal(arg1, arg2));
}

References float8_cmp_internal(), PG_GETARG_FLOAT8, and PG_RETURN_INT32.

btfloat8fastcmp()

static int btfloat8fastcmp ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 982 of file float.c.

{
    float8      arg1 = DatumGetFloat8(x);
    float8      arg2 = DatumGetFloat8(y);
 
    return float8_cmp_internal(arg1, arg2);
}

References DatumGetFloat8(), float8_cmp_internal(), x, and y.

Referenced by btfloat8sortsupport().

btfloat8sortsupport()

Datum btfloat8sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 991 of file float.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = btfloat8fastcmp;
    PG_RETURN_VOID();
}

References btfloat8fastcmp(), SortSupportData::comparator, PG_GETARG_POINTER, and PG_RETURN_VOID.

check_float8_array()

static float8* check_float8_array ( ArrayType *  transarray, const char *  caller, int  n  )

static

Definition at line 2927 of file float.c.

{
    /*
     * 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 ||
        ARR_DIMS(transarray)[0] != n ||
        ARR_HASNULL(transarray) ||
        ARR_ELEMTYPE(transarray) != FLOAT8OID)
        elog(ERROR, "%s: expected %d-element float8 array", caller, n);
    return (float8 *) ARR_DATA_PTR(transarray);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, elog(), and ERROR.

Referenced by float4_accum(), float8_accum(), float8_avg(), float8_combine(), float8_corr(), float8_covar_pop(), float8_covar_samp(), float8_regr_accum(), float8_regr_avgx(), float8_regr_avgy(), float8_regr_combine(), float8_regr_intercept(), float8_regr_r2(), float8_regr_slope(), float8_regr_sxx(), float8_regr_sxy(), float8_regr_syy(), float8_stddev_pop(), float8_stddev_samp(), float8_var_pop(), and float8_var_samp().

cosd_0_to_60()

static double cosd_0_to_60 ( double  x )

static

Definition at line 2265 of file float.c.

{
    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;
}

References one_minus_cos_60, RADIANS_PER_DEGREE, and x.

Referenced by cosd_q1(), and sind_q1().

cosd_q1()

static double cosd_q1 ( double  x )

static

Definition at line 2298 of file float.c.

{
    /*
     * 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);
}

References cosd_0_to_60(), sind_0_to_30(), and x.

Referenced by dcosd(), dcotd(), dtand(), and init_degree_constants().

dacos()

Datum dacos

(

PG_FUNCTION_ARGS

)

Definition at line 1754 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    result = acos(arg1);
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dacosd()

Datum dacosd

(

PG_FUNCTION_ARGS

)

Definition at line 2107 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    INIT_DEGREE_CONSTANTS();
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    if (arg1 >= 0.0)
        result = acosd_q1(arg1);
    else
        result = 90.0 + asind_q1(-arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References acosd_q1(), asind_q1(), ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dacosh()

Datum dacosh

(

PG_FUNCTION_ARGS

)

Definition at line 2688 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    result = acosh(arg1);
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dasin()

Datum dasin

(

PG_FUNCTION_ARGS

)

Definition at line 1785 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    result = asin(arg1);
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dasind()

Datum dasind

(

PG_FUNCTION_ARGS

)

Definition at line 2144 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    INIT_DEGREE_CONSTANTS();
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    if (arg1 >= 0.0)
        result = asind_q1(arg1);
    else
        result = -asind_q1(-arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References asind_q1(), ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dasinh()

Datum dasinh

(

PG_FUNCTION_ARGS

)

Definition at line 2671 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * For asinh, we don't need an errno check because it never overflows.
     */
    result = asinh(arg1);
 
    PG_RETURN_FLOAT8(result);
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

datan()

Datum datan

(

PG_FUNCTION_ARGS

)

Definition at line 1816 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /*
     * 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.
     */
    result = atan(arg1);
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

datan2()

Datum datan2

(

PG_FUNCTION_ARGS

)

Definition at line 1842 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
    float8      result;
 
    /* Per the POSIX spec, return NaN if either input is NaN */
    if (isnan(arg1) || isnan(arg2))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /*
     * atan2 maps all inputs to values in the range [-Pi, Pi], so the result
     * should always be finite, even if the inputs are infinite.
     */
    result = atan2(arg1, arg2);
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

datan2d()

Datum datan2d

(

PG_FUNCTION_ARGS

)

Definition at line 2213 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
    float8      result;
    volatile float8 atan2_arg1_arg2;
 
    /* Per the POSIX spec, return NaN if either input is NaN */
    if (isnan(arg1) || isnan(arg2))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    INIT_DEGREE_CONSTANTS();
 
    /*
     * 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.
     */
    atan2_arg1_arg2 = atan2(arg1, arg2);
    result = (atan2_arg1_arg2 / atan_1_0) * 45.0;
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References atan_1_0, float_overflow_error(), get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

datand()

Datum datand

(

PG_FUNCTION_ARGS

)

Definition at line 2181 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
    volatile float8 atan_arg1;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    INIT_DEGREE_CONSTANTS();
 
    /*
     * 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.
     */
    atan_arg1 = atan(arg1);
    result = (atan_arg1 / atan_1_0) * 45.0;
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References atan_1_0, float_overflow_error(), get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

datanh()

Datum datanh

(

PG_FUNCTION_ARGS

)

Definition at line 2713 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("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)
        result = -get_float8_infinity();
    else if (arg1 == 1.0)
        result = get_float8_infinity();
    else
        result = atanh(arg1);
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, get_float8_infinity(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dcbrt()

Datum dcbrt

(

PG_FUNCTION_ARGS

)

Definition at line 1469 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    result = cbrt(arg1);
    if (unlikely(isinf(result)) && !isinf(arg1))
        float_overflow_error();
    if (unlikely(result == 0.0) && arg1 != 0.0)
        float_underflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), float_underflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dceil()

Datum dceil

(

PG_FUNCTION_ARGS

)

Definition at line 1379 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(ceil(arg1));
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dcos()

Datum dcos

(

PG_FUNCTION_ARGS

)

Definition at line 1868 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /*
     * 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.
     */
    errno = 0;
    result = cos(arg1);
    if (errno != 0 || isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dcosd()

Datum dcosd

(

PG_FUNCTION_ARGS

)

Definition at line 2317 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
    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))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    if (isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    INIT_DEGREE_CONSTANTS();
 
    /* Reduce the range of the input to [0,90] degrees */
    arg1 = fmod(arg1, 360.0);
 
    if (arg1 < 0.0)
    {
        /* cosd(-x) = cosd(x) */
        arg1 = -arg1;
    }
 
    if (arg1 > 180.0)
    {
        /* cosd(360-x) = cosd(x) */
        arg1 = 360.0 - arg1;
    }
 
    if (arg1 > 90.0)
    {
        /* cosd(180-x) = -cosd(x) */
        arg1 = 180.0 - arg1;
        sign = -sign;
    }
 
    result = sign * cosd_q1(arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References cosd_q1(), ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, sign, and unlikely.

dcosh()

Datum dcosh

(

PG_FUNCTION_ARGS

)

Definition at line 2626 of file float.c.

{
    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 infinity.
     */
    if (errno == ERANGE)
        result = get_float8_infinity();
 
    if (unlikely(result == 0.0))
        float_underflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_underflow_error(), get_float8_infinity(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dcot()

Datum dcot

(

PG_FUNCTION_ARGS

)

Definition at line 1909 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /* Be sure to throw an error if the input is infinite --- see dcos() */
    errno = 0;
    result = tan(arg1);
    if (errno != 0 || isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    result = 1.0 / result;
    /* Not checking for overflow because cot(0) == Inf */
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, get_float8_nan(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dcotd()

Datum dcotd

(

PG_FUNCTION_ARGS

)

Definition at line 2372 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
    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))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    if (isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    INIT_DEGREE_CONSTANTS();
 
    /* Reduce the range of the input to [0,90] degrees */
    arg1 = fmod(arg1, 360.0);
 
    if (arg1 < 0.0)
    {
        /* cotd(-x) = -cotd(x) */
        arg1 = -arg1;
        sign = -sign;
    }
 
    if (arg1 > 180.0)
    {
        /* cotd(360-x) = -cotd(x) */
        arg1 = 360.0 - arg1;
        sign = -sign;
    }
 
    if (arg1 > 90.0)
    {
        /* cotd(180-x) = -cotd(x) */
        arg1 = 180.0 - arg1;
        sign = -sign;
    }
 
    cot_arg1 = cosd_q1(arg1) / sind_q1(arg1);
    result = sign * (cot_arg1 / cot_45);
 
    /*
     * 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)
        result = 0.0;
 
    /* Not checking for overflow because cotd(0) == Inf */
 
    PG_RETURN_FLOAT8(result);
}

References cosd_q1(), cot_45, ereport, errcode(), errmsg(), ERROR, get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, sign, and sind_q1().

degrees()

Datum degrees

(

PG_FUNCTION_ARGS

)

Definition at line 2560 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(float8_div(arg1, RADIANS_PER_DEGREE));
}

References float8_div(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and RADIANS_PER_DEGREE.

Referenced by degtorad().

derf()

Datum derf

(

PG_FUNCTION_ARGS

)

Definition at line 2751 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * For erf, we don't need an errno check because it never overflows.
     */
    result = erf(arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

derfc()

Datum derfc

(

PG_FUNCTION_ARGS

)

Definition at line 2771 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * For erfc, we don't need an errno check because it never overflows.
     */
    result = erfc(arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dexp()

Datum dexp

(

PG_FUNCTION_ARGS

)

Definition at line 1643 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * 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))
        result = arg1;
    else if (isinf(arg1))
    {
        /* Per POSIX, exp(-Inf) is 0 */
        result = (arg1 > 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.
         */
        errno = 0;
        result = exp(arg1);
        if (unlikely(errno == ERANGE))
        {
            if (result != 0.0)
                float_overflow_error();
            else
                float_underflow_error();
        }
        else if (unlikely(isinf(result)))
            float_overflow_error();
        else if (unlikely(result == 0.0))
            float_underflow_error();
    }
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), float_underflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dfloor()

Datum dfloor

(

PG_FUNCTION_ARGS

)

Definition at line 1391 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(floor(arg1));
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dlog1()

Datum dlog1

(

PG_FUNCTION_ARGS

)

Definition at line 1689 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * Emit particular SQLSTATE error codes for ln(). This is required by the
     * SQL standard.
     */
    if (arg1 == 0.0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                 errmsg("cannot take logarithm of zero")));
    if (arg1 < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                 errmsg("cannot take logarithm of a negative number")));
 
    result = log(arg1);
    if (unlikely(isinf(result)) && !isinf(arg1))
        float_overflow_error();
    if (unlikely(result == 0.0) && arg1 != 1.0)
        float_underflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), float_underflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dlog10()

Datum dlog10

(

PG_FUNCTION_ARGS

)

Definition at line 1721 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                 errmsg("cannot take logarithm of zero")));
    if (arg1 < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                 errmsg("cannot take logarithm of a negative number")));
 
    result = log10(arg1);
    if (unlikely(isinf(result)) && !isinf(arg1))
        float_overflow_error();
    if (unlikely(result == 0.0) && arg1 != 1.0)
        float_underflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), float_underflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dpi()

Datum dpi

(

PG_FUNCTION_ARGS

)

Definition at line 2572 of file float.c.

{
    PG_RETURN_FLOAT8(M_PI);
}

References M_PI, and PG_RETURN_FLOAT8.

dpow()

Datum dpow

(

PG_FUNCTION_ARGS

)

Definition at line 1488 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
    float8      result;
 
    /*
     * 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)
            PG_RETURN_FLOAT8(get_float8_nan());
        PG_RETURN_FLOAT8(1.0);
    }
    if (isnan(arg2))
    {
        if (arg1 != 1.0)
            PG_RETURN_FLOAT8(get_float8_nan());
        PG_RETURN_FLOAT8(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)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                 errmsg("zero raised to a negative power is undefined")));
    if (arg1 < 0 && floor(arg2) != arg2)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                 errmsg("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))
    {
        float8      absx = fabs(arg1);
 
        if (absx == 1.0)
            result = 1.0;
        else if (arg2 > 0.0)    /* y = +Inf */
        {
            if (absx > 1.0)
                result = arg2;
            else
                result = 0.0;
        }
        else                    /* y = -Inf */
        {
            if (absx > 1.0)
                result = 0.0;
            else
                result = -arg2;
        }
    }
    else if (isinf(arg1))
    {
        if (arg2 == 0.0)
            result = 1.0;
        else if (arg1 > 0.0)    /* x = +Inf */
        {
            if (arg2 > 0.0)
                result = arg1;
            else
                result = 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.
             */
            float8      halfy = arg2 / 2;   /* should be computed exactly */
            bool        yisoddinteger = (floor(halfy) != halfy);
 
            if (arg2 > 0.0)
                result = yisoddinteger ? arg1 : -arg1;
            else
                result = yisoddinteger ? -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.)
         */
        errno = 0;
        result = pow(arg1, arg2);
        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)
                result = 0.0;   /* we already verified y is positive */
            else
            {
                float8      absx = fabs(arg1);
 
                if (absx == 1.0)
                    result = 1.0;
                else if (arg2 >= 0.0 ? (absx > 1.0) : (absx < 1.0))
                    float_overflow_error();
                else
                    float_underflow_error();
            }
        }
        else if (errno == ERANGE)
        {
            if (result != 0.0)
                float_overflow_error();
            else
                float_underflow_error();
        }
        else
        {
            if (unlikely(isinf(result)))
                float_overflow_error();
            if (unlikely(result == 0.0) && arg1 != 0.0)
                float_underflow_error();
        }
    }
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), float_underflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

drandom()

Datum drandom

(

PG_FUNCTION_ARGS

)

Definition at line 2822 of file float.c.

{
    float8      result;
 
    initialize_drandom_seed();
 
    /* pg_prng_double produces desired result range [0.0 - 1.0) */
    result = pg_prng_double(&drandom_seed);
 
    PG_RETURN_FLOAT8(result);
}

References drandom_seed, initialize_drandom_seed(), pg_prng_double(), and PG_RETURN_FLOAT8.

drandom_normal()

Datum drandom_normal

(

PG_FUNCTION_ARGS

)

Definition at line 2838 of file float.c.

{
    float8      mean = PG_GETARG_FLOAT8(0);
    float8      stddev = PG_GETARG_FLOAT8(1);
    float8      result,
                z;
 
    initialize_drandom_seed();
 
    /* Get random value from standard normal(mean = 0.0, stddev = 1.0) */
    z = pg_prng_double_normal(&drandom_seed);
    /* Transform the normal standard variable (z) */
    /* using the target normal distribution parameters */
    result = (stddev * z) + mean;
 
    PG_RETURN_FLOAT8(result);
}

References drandom_seed, initialize_drandom_seed(), PG_GETARG_FLOAT8, pg_prng_double_normal(), and PG_RETURN_FLOAT8.

dround()

Datum dround

(

PG_FUNCTION_ARGS

)

Definition at line 1367 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(rint(arg1));
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dsign()

Datum dsign

(

PG_FUNCTION_ARGS

)

Definition at line 1404 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    if (arg1 > 0)
        result = 1.0;
    else if (arg1 < 0)
        result = -1.0;
    else
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dsin()

Datum dsin

(

PG_FUNCTION_ARGS

)

Definition at line 1937 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /* Be sure to throw an error if the input is infinite --- see dcos() */
    errno = 0;
    result = sin(arg1);
    if (errno != 0 || isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dsind()

Datum dsind

(

PG_FUNCTION_ARGS

)

Definition at line 2438 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
    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))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    if (isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    INIT_DEGREE_CONSTANTS();
 
    /* Reduce the range of the input to [0,90] degrees */
    arg1 = fmod(arg1, 360.0);
 
    if (arg1 < 0.0)
    {
        /* sind(-x) = -sind(x) */
        arg1 = -arg1;
        sign = -sign;
    }
 
    if (arg1 > 180.0)
    {
        /* sind(360-x) = -sind(x) */
        arg1 = 360.0 - arg1;
        sign = -sign;
    }
 
    if (arg1 > 90.0)
    {
        /* sind(180-x) = sind(x) */
        arg1 = 180.0 - arg1;
    }
 
    result = sign * sind_q1(arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, sign, sind_q1(), and unlikely.

dsinh()

Datum dsinh

(

PG_FUNCTION_ARGS

)

Definition at line 2597 of file float.c.

{
    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,
     * the result should be either -infinity or infinity, depending on the
     * sign of arg1.
     */
    if (errno == ERANGE)
    {
        if (arg1 < 0)
            result = -get_float8_infinity();
        else
            result = get_float8_infinity();
    }
 
    PG_RETURN_FLOAT8(result);
}

References get_float8_infinity(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dsqrt()

Datum dsqrt

(

PG_FUNCTION_ARGS

)

Definition at line 1445 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    if (arg1 < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                 errmsg("cannot take square root of a negative number")));
 
    result = sqrt(arg1);
    if (unlikely(isinf(result)) && !isinf(arg1))
        float_overflow_error();
    if (unlikely(result == 0.0) && arg1 != 0.0)
        float_underflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, float_overflow_error(), float_underflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dtan()

Datum dtan

(

PG_FUNCTION_ARGS

)

Definition at line 1964 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /* Per the POSIX spec, return NaN if the input is NaN */
    if (isnan(arg1))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    /* Be sure to throw an error if the input is infinite --- see dcos() */
    errno = 0;
    result = tan(arg1);
    if (errno != 0 || isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
    /* Not checking for overflow because tan(pi/2) == Inf */
 
    PG_RETURN_FLOAT8(result);
}

References ereport, errcode(), errmsg(), ERROR, get_float8_nan(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dtand()

Datum dtand

(

PG_FUNCTION_ARGS

)

Definition at line 2494 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
    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))
        PG_RETURN_FLOAT8(get_float8_nan());
 
    if (isinf(arg1))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("input is out of range")));
 
    INIT_DEGREE_CONSTANTS();
 
    /* Reduce the range of the input to [0,90] degrees */
    arg1 = fmod(arg1, 360.0);
 
    if (arg1 < 0.0)
    {
        /* tand(-x) = -tand(x) */
        arg1 = -arg1;
        sign = -sign;
    }
 
    if (arg1 > 180.0)
    {
        /* tand(360-x) = -tand(x) */
        arg1 = 360.0 - arg1;
        sign = -sign;
    }
 
    if (arg1 > 90.0)
    {
        /* tand(180-x) = -tand(x) */
        arg1 = 180.0 - arg1;
        sign = -sign;
    }
 
    tan_arg1 = sind_q1(arg1) / cosd_q1(arg1);
    result = sign * (tan_arg1 / tan_45);
 
    /*
     * 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)
        result = 0.0;
 
    /* Not checking for overflow because tand(90) == Inf */
 
    PG_RETURN_FLOAT8(result);
}

References cosd_q1(), ereport, errcode(), errmsg(), ERROR, get_float8_nan(), INIT_DEGREE_CONSTANTS, PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, sign, sind_q1(), and tan_45.

dtanh()

Datum dtanh

(

PG_FUNCTION_ARGS

)

Definition at line 2651 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * For tanh, we don't need an errno check because it never overflows.
     */
    result = tanh(arg1);
 
    if (unlikely(isinf(result)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and unlikely.

dtof()

Datum dtof

(

PG_FUNCTION_ARGS

)

Definition at line 1194 of file float.c.

{
    float8      num = PG_GETARG_FLOAT8(0);
    float4      result;
 
    result = (float4) num;
    if (unlikely(isinf(result)) && !isinf(num))
        float_overflow_error();
    if (unlikely(result == 0.0f) && num != 0.0)
        float_underflow_error();
 
    PG_RETURN_FLOAT4(result);
}

References float_overflow_error(), float_underflow_error(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT4, and unlikely.

dtoi2()

Datum dtoi2

(

PG_FUNCTION_ARGS

)

Definition at line 1238 of file float.c.

{
    float8      num = PG_GETARG_FLOAT8(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.
     */
    num = rint(num);
 
    /* Range check */
    if (unlikely(isnan(num) || !FLOAT8_FITS_IN_INT16(num)))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("smallint out of range")));
 
    PG_RETURN_INT16((int16) num);
}

References ereport, errcode(), errmsg(), ERROR, FLOAT8_FITS_IN_INT16, PG_GETARG_FLOAT8, PG_RETURN_INT16, and unlikely.

dtoi4()

Datum dtoi4

(

PG_FUNCTION_ARGS

)

Definition at line 1213 of file float.c.

{
    float8      num = PG_GETARG_FLOAT8(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.
     */
    num = rint(num);
 
    /* Range check */
    if (unlikely(isnan(num) || !FLOAT8_FITS_IN_INT32(num)))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("integer out of range")));
 
    PG_RETURN_INT32((int32) num);
}

References ereport, errcode(), errmsg(), ERROR, FLOAT8_FITS_IN_INT32, PG_GETARG_FLOAT8, PG_RETURN_INT32, and unlikely.

dtrunc()

Datum dtrunc

(

PG_FUNCTION_ARGS

)

Definition at line 1427 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    if (arg1 >= 0)
        result = floor(arg1);
    else
        result = -floor(-arg1);
 
    PG_RETURN_FLOAT8(result);
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float48div()

Datum float48div

(

PG_FUNCTION_ARGS

)

Definition at line 3899 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_div((float8) arg1, arg2));
}

References float8_div(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float48eq()

Datum float48eq

(

PG_FUNCTION_ARGS

)

Definition at line 3959 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_eq((float8) arg1, arg2));
}

References float8_eq(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float48ge()

Datum float48ge

(

PG_FUNCTION_ARGS

)

Definition at line 4004 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_ge((float8) arg1, arg2));
}

References float8_ge(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float48gt()

Datum float48gt

(

PG_FUNCTION_ARGS

)

Definition at line 3995 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_gt((float8) arg1, arg2));
}

References float8_gt(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float48le()

Datum float48le

(

PG_FUNCTION_ARGS

)

Definition at line 3986 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_le((float8) arg1, arg2));
}

References float8_le(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float48lt()

Datum float48lt

(

PG_FUNCTION_ARGS

)

Definition at line 3977 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_lt((float8) arg1, arg2));
}

References float8_lt(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float48mi()

Datum float48mi

(

PG_FUNCTION_ARGS

)

Definition at line 3881 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_mi((float8) arg1, arg2));
}

References float8_mi(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float48mul()

Datum float48mul

(

PG_FUNCTION_ARGS

)

Definition at line 3890 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_mul((float8) arg1, arg2));
}

References float8_mul(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float48ne()

Datum float48ne

(

PG_FUNCTION_ARGS

)

Definition at line 3968 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_ne((float8) arg1, arg2));
}

References float8_ne(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float48pl()

Datum float48pl

(

PG_FUNCTION_ARGS

)

Definition at line 3872 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_pl((float8) arg1, arg2));
}

References float8_pl(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float4_accum()

Datum float4_accum

(

PG_FUNCTION_ARGS

)

Definition at line 3128 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
 
    /* do computations as float8 */
    float8      newval = PG_GETARG_FLOAT4(1);
    float8     *transvalues;
    float8      N,
                Sx,
                Sxx,
                tmp;
 
    transvalues = check_float8_array(transarray, "float4_accum", 3);
    N = transvalues[0];
    Sx = transvalues[1];
    Sxx = transvalues[2];
 
    /*
     * Use the Youngs-Cramer algorithm to incorporate the new value into the
     * transition values.
     */
    N += 1.0;
    Sx += newval;
    if (transvalues[0] > 0.0)
    {
        tmp = newval * N - Sx;
        Sxx += tmp * tmp / (N * transvalues[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))
                float_overflow_error();
 
            Sxx = get_float8_nan();
        }
    }
    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))
            Sxx = get_float8_nan();
    }
 
    /*
     * 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))
    {
        transvalues[0] = N;
        transvalues[1] = Sx;
        transvalues[2] = Sxx;
 
        PG_RETURN_ARRAYTYPE_P(transarray);
    }
    else
    {
        Datum       transdatums[3];
        ArrayType  *result;
 
        transdatums[0] = Float8GetDatumFast(N);
        transdatums[1] = Float8GetDatumFast(Sx);
        transdatums[2] = Float8GetDatumFast(Sxx);
 
        result = construct_array(transdatums, 3,
                                 FLOAT8OID,
                                 sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array(), Float8GetDatumFast, FLOAT8PASSBYVAL, float_overflow_error(), get_float8_nan(), newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_FLOAT4, and PG_RETURN_ARRAYTYPE_P.

float4_cmp_internal()

int float4_cmp_internal	(	float4	a,
		float4	b
	)

Definition at line 815 of file float.c.

{
    if (float4_gt(a, b))
        return 1;
    if (float4_lt(a, b))
        return -1;
    return 0;
}

References a, b, float4_gt(), and float4_lt().

Referenced by btfloat4cmp(), and btfloat4fastcmp().

float4abs()

Datum float4abs

(

PG_FUNCTION_ARGS

)

Definition at line 590 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
 
    PG_RETURN_FLOAT4(fabsf(arg1));
}

References PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4div()

Datum float4div

(

PG_FUNCTION_ARGS

)

Definition at line 754 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT4(float4_div(arg1, arg2));
}

References float4_div(), PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4eq()

Datum float4eq

(

PG_FUNCTION_ARGS

)

Definition at line 825 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float4_eq(arg1, arg2));
}

References float4_eq(), PG_GETARG_FLOAT4, and PG_RETURN_BOOL.

float4ge()

Datum float4ge

(

PG_FUNCTION_ARGS

)

Definition at line 870 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float4_ge(arg1, arg2));
}

References float4_ge(), PG_GETARG_FLOAT4, and PG_RETURN_BOOL.

float4gt()

Datum float4gt

(

PG_FUNCTION_ARGS

)

Definition at line 861 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float4_gt(arg1, arg2));
}

References float4_gt(), PG_GETARG_FLOAT4, and PG_RETURN_BOOL.

float4in()

Datum float4in

(

PG_FUNCTION_ARGS

)

Definition at line 163 of file float.c.

{
    char       *num = PG_GETARG_CSTRING(0);
 
    PG_RETURN_FLOAT4(float4in_internal(num, NULL, "real", num,
                                       fcinfo->context));
}

References float4in_internal(), PG_GETARG_CSTRING, and PG_RETURN_FLOAT4.

Referenced by numeric_float4().

float4in_internal()

float4 float4in_internal	(	char *	num,
		char **	endptr_p,
		const char *	type_name,
		const char *	orig_string,
		struct Node *	escontext
	)

Definition at line 182 of file float.c.

{
    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))
        num++;
 
    /*
     * Check for an empty-string input to begin with, to avoid the vagaries of
     * strtod() on different platforms.
     */
    if (*num == '\0')
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        type_name, orig_string)));
 
    errno = 0;
    val = strtof(num, &endptr);
 
    /* 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)
        {
            val = get_float4_nan();
            endptr = num + 3;
        }
        else if (pg_strncasecmp(num, "Infinity", 8) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 8;
        }
        else if (pg_strncasecmp(num, "+Infinity", 9) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 9;
        }
        else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
        {
            val = -get_float4_infinity();
            endptr = num + 9;
        }
        else if (pg_strncasecmp(num, "inf", 3) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 3;
        }
        else if (pg_strncasecmp(num, "+inf", 4) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 4;
        }
        else if (pg_strncasecmp(num, "-inf", 4) == 0)
        {
            val = -get_float4_infinity();
            endptr = num + 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)
                isinf(val)
#else
                (val >= HUGE_VALF || val <= -HUGE_VALF)
#endif
                )
            {
                /* see comments in float8in_internal for rationale */
                char       *errnumber = pstrdup(num);
 
                errnumber[endptr - num] = '\0';
 
                ereturn(escontext, 0,
                        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                         errmsg("\"%s\" is out of range for type real",
                                errnumber)));
            }
        }
        else
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            type_name, orig_string)));
    }
 
    /* skip trailing whitespace */
    while (*endptr != '\0' && isspace((unsigned char) *endptr))
        endptr++;
 
    /* report stopping point if wanted, else complain if not end of string */
    if (endptr_p)
        *endptr_p = endptr;
    else if (*endptr != '\0')
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        type_name, orig_string)));
 
    return val;
}

References ereturn, errcode(), errmsg(), get_float4_infinity(), get_float4_nan(), pg_strncasecmp(), pstrdup(), and val.

Referenced by float4in().

float4larger()

Datum float4larger

(

PG_FUNCTION_ARGS

)

Definition at line 619 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
    float4      result;
 
    if (float4_gt(arg1, arg2))
        result = arg1;
    else
        result = arg2;
    PG_RETURN_FLOAT4(result);
}

References float4_gt(), PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4le()

Datum float4le

(

PG_FUNCTION_ARGS

)

Definition at line 852 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float4_le(arg1, arg2));
}

References float4_le(), PG_GETARG_FLOAT4, and PG_RETURN_BOOL.

float4lt()

Datum float4lt

(

PG_FUNCTION_ARGS

)

Definition at line 843 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float4_lt(arg1, arg2));
}

References float4_lt(), PG_GETARG_FLOAT4, and PG_RETURN_BOOL.

float4mi()

Datum float4mi

(

PG_FUNCTION_ARGS

)

Definition at line 736 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT4(float4_mi(arg1, arg2));
}

References float4_mi(), PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4mul()

Datum float4mul

(

PG_FUNCTION_ARGS

)

Definition at line 745 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT4(float4_mul(arg1, arg2));
}

References float4_mul(), PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4ne()

Datum float4ne

(

PG_FUNCTION_ARGS

)

Definition at line 834 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float4_ne(arg1, arg2));
}

References float4_ne(), PG_GETARG_FLOAT4, and PG_RETURN_BOOL.

float4out()

Datum float4out

(

PG_FUNCTION_ARGS

)

Definition at line 318 of file float.c.

{
    float4      num = PG_GETARG_FLOAT4(0);
    char       *ascii = (char *) palloc(32);
    int         ndig = FLT_DIG + extra_float_digits;
 
    if (extra_float_digits > 0)
    {
        float_to_shortest_decimal_buf(num, ascii);
        PG_RETURN_CSTRING(ascii);
    }
 
    (void) pg_strfromd(ascii, 32, ndig, num);
    PG_RETURN_CSTRING(ascii);
}

References ascii(), extra_float_digits, float_to_shortest_decimal_buf(), palloc(), PG_GETARG_FLOAT4, PG_RETURN_CSTRING, and pg_strfromd().

float4pl()

Datum float4pl

(

PG_FUNCTION_ARGS

)

Definition at line 727 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT4(float4_pl(arg1, arg2));
}

References float4_pl(), PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4recv()

Datum float4recv

(

PG_FUNCTION_ARGS

)

Definition at line 338 of file float.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
    PG_RETURN_FLOAT4(pq_getmsgfloat4(buf));
}

References buf, PG_GETARG_POINTER, PG_RETURN_FLOAT4, and pq_getmsgfloat4().

float4send()

Datum float4send

(

PG_FUNCTION_ARGS

)

Definition at line 349 of file float.c.

{
    float4      num = PG_GETARG_FLOAT4(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat4(&buf, num);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_FLOAT4, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat4().

float4smaller()

Datum float4smaller

(

PG_FUNCTION_ARGS

)

Definition at line 633 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
    float4      result;
 
    if (float4_lt(arg1, arg2))
        result = arg1;
    else
        result = arg2;
    PG_RETURN_FLOAT4(result);
}

References float4_lt(), PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4um()

Datum float4um

(

PG_FUNCTION_ARGS

)

Definition at line 601 of file float.c.

{
    float4      arg1 = PG_GETARG_FLOAT4(0);
    float4      result;
 
    result = -arg1;
    PG_RETURN_FLOAT4(result);
}

References PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float4up()

Datum float4up

(

PG_FUNCTION_ARGS

)

Definition at line 611 of file float.c.

{
    float4      arg = PG_GETARG_FLOAT4(0);
 
    PG_RETURN_FLOAT4(arg);
}

References arg, PG_GETARG_FLOAT4, and PG_RETURN_FLOAT4.

float84div()

Datum float84div

(

PG_FUNCTION_ARGS

)

Definition at line 3941 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT8(float8_div(arg1, (float8) arg2));
}

References float8_div(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float84eq()

Datum float84eq

(

PG_FUNCTION_ARGS

)

Definition at line 4016 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float8_eq(arg1, (float8) arg2));
}

References float8_eq(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float84ge()

Datum float84ge

(

PG_FUNCTION_ARGS

)

Definition at line 4061 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float8_ge(arg1, (float8) arg2));
}

References float8_ge(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float84gt()

Datum float84gt

(

PG_FUNCTION_ARGS

)

Definition at line 4052 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float8_gt(arg1, (float8) arg2));
}

References float8_gt(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float84le()

Datum float84le

(

PG_FUNCTION_ARGS

)

Definition at line 4043 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float8_le(arg1, (float8) arg2));
}

References float8_le(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float84lt()

Datum float84lt

(

PG_FUNCTION_ARGS

)

Definition at line 4034 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float8_lt(arg1, (float8) arg2));
}

References float8_lt(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float84mi()

Datum float84mi

(

PG_FUNCTION_ARGS

)

Definition at line 3923 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT8(float8_mi(arg1, (float8) arg2));
}

References float8_mi(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float84mul()

Datum float84mul

(

PG_FUNCTION_ARGS

)

Definition at line 3932 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT8(float8_mul(arg1, (float8) arg2));
}

References float8_mul(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float84ne()

Datum float84ne

(

PG_FUNCTION_ARGS

)

Definition at line 4025 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_BOOL(float8_ne(arg1, (float8) arg2));
}

References float8_ne(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float84pl()

Datum float84pl

(

PG_FUNCTION_ARGS

)

Definition at line 3914 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float4      arg2 = PG_GETARG_FLOAT4(1);
 
    PG_RETURN_FLOAT8(float8_pl(arg1, (float8) arg2));
}

References float8_pl(), PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8_accum()

Datum float8_accum

(

PG_FUNCTION_ARGS

)

Definition at line 3045 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8      newval = PG_GETARG_FLOAT8(1);
    float8     *transvalues;
    float8      N,
                Sx,
                Sxx,
                tmp;
 
    transvalues = check_float8_array(transarray, "float8_accum", 3);
    N = transvalues[0];
    Sx = transvalues[1];
    Sxx = transvalues[2];
 
    /*
     * Use the Youngs-Cramer algorithm to incorporate the new value into the
     * transition values.
     */
    N += 1.0;
    Sx += newval;
    if (transvalues[0] > 0.0)
    {
        tmp = newval * N - Sx;
        Sxx += tmp * tmp / (N * transvalues[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))
                float_overflow_error();
 
            Sxx = get_float8_nan();
        }
    }
    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))
            Sxx = get_float8_nan();
    }
 
    /*
     * 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))
    {
        transvalues[0] = N;
        transvalues[1] = Sx;
        transvalues[2] = Sxx;
 
        PG_RETURN_ARRAYTYPE_P(transarray);
    }
    else
    {
        Datum       transdatums[3];
        ArrayType  *result;
 
        transdatums[0] = Float8GetDatumFast(N);
        transdatums[1] = Float8GetDatumFast(Sx);
        transdatums[2] = Float8GetDatumFast(Sxx);
 
        result = construct_array(transdatums, 3,
                                 FLOAT8OID,
                                 sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array(), Float8GetDatumFast, FLOAT8PASSBYVAL, float_overflow_error(), get_float8_nan(), newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_FLOAT8, and PG_RETURN_ARRAYTYPE_P.

float8_avg()

Datum float8_avg

(

PG_FUNCTION_ARGS

)

Definition at line 3213 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sx;
 
    transvalues = check_float8_array(transarray, "float8_avg", 3);
    N = transvalues[0];
    Sx = transvalues[1];
    /* ignore Sxx */
 
    /* SQL defines AVG of no values to be NULL */
    if (N == 0.0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sx / N);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_cmp_internal()

int float8_cmp_internal	(	float8	a,
		float8	b
	)

Definition at line 909 of file float.c.

{
    if (float8_gt(a, b))
        return 1;
    if (float8_lt(a, b))
        return -1;
    return 0;
}

References a, b, float8_gt(), and float8_lt().

Referenced by btfloat48cmp(), btfloat84cmp(), btfloat8cmp(), btfloat8fastcmp(), common_entry_cmp(), interval_cmp_lower(), interval_cmp_upper(), and pairingheap_GISTSearchItem_cmp().

float8_combine()

Datum float8_combine

(

PG_FUNCTION_ARGS

)

Definition at line 2951 of file float.c.

{
    ArrayType  *transarray1 = PG_GETARG_ARRAYTYPE_P(0);
    ArrayType  *transarray2 = PG_GETARG_ARRAYTYPE_P(1);
    float8     *transvalues1;
    float8     *transvalues2;
    float8      N1,
                Sx1,
                Sxx1,
                N2,
                Sx2,
                Sxx2,
                tmp,
                N,
                Sx,
                Sxx;
 
    transvalues1 = check_float8_array(transarray1, "float8_combine", 3);
    transvalues2 = check_float8_array(transarray2, "float8_combine", 3);
 
    N1 = transvalues1[0];
    Sx1 = transvalues1[1];
    Sxx1 = transvalues1[2];
 
    N2 = transvalues2[0];
    Sx2 = transvalues2[1];
    Sxx2 = transvalues2[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)
    {
        N = N2;
        Sx = Sx2;
        Sxx = Sxx2;
    }
    else if (N2 == 0.0)
    {
        N = N1;
        Sx = Sx1;
        Sxx = Sxx1;
    }
    else
    {
        N = N1 + N2;
        Sx = float8_pl(Sx1, Sx2);
        tmp = Sx1 / N1 - Sx2 / N2;
        Sxx = Sxx1 + Sxx2 + N1 * N2 * tmp * tmp / N;
        if (unlikely(isinf(Sxx)) && !isinf(Sxx1) && !isinf(Sxx2))
            float_overflow_error();
    }
 
    /*
     * 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))
    {
        transvalues1[0] = N;
        transvalues1[1] = Sx;
        transvalues1[2] = Sxx;
 
        PG_RETURN_ARRAYTYPE_P(transarray1);
    }
    else
    {
        Datum       transdatums[3];
        ArrayType  *result;
 
        transdatums[0] = Float8GetDatumFast(N);
        transdatums[1] = Float8GetDatumFast(Sx);
        transdatums[2] = Float8GetDatumFast(Sxx);
 
        result = construct_array(transdatums, 3,
                                 FLOAT8OID,
                                 sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array(), float8_pl(), Float8GetDatumFast, FLOAT8PASSBYVAL, float_overflow_error(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_ARRAYTYPE_P, and unlikely.

float8_corr()

Datum float8_corr

(

PG_FUNCTION_ARGS

)

Definition at line 3739 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx,
                Syy,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_corr", 6);
    N = transvalues[0];
    Sxx = transvalues[2];
    Syy = transvalues[4];
    Sxy = transvalues[5];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* 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)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sxy / sqrt(Sxx * Syy));
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_covar_pop()

Datum float8_covar_pop

(

PG_FUNCTION_ARGS

)

Definition at line 3701 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_covar_pop", 6);
    N = transvalues[0];
    Sxy = transvalues[5];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sxy / N);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_covar_samp()

Datum float8_covar_samp

(

PG_FUNCTION_ARGS

)

Definition at line 3720 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_covar_samp", 6);
    N = transvalues[0];
    Sxy = transvalues[5];
 
    /* if N is <= 1 we should return NULL */
    if (N < 2.0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sxy / (N - 1.0));
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_accum()

Datum float8_regr_accum

(

PG_FUNCTION_ARGS

)

Definition at line 3342 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8      newvalY = PG_GETARG_FLOAT8(1);
    float8      newvalX = PG_GETARG_FLOAT8(2);
    float8     *transvalues;
    float8      N,
                Sx,
                Sxx,
                Sy,
                Syy,
                Sxy,
                tmpX,
                tmpY,
                scale;
 
    transvalues = check_float8_array(transarray, "float8_regr_accum", 6);
    N = transvalues[0];
    Sx = transvalues[1];
    Sxx = transvalues[2];
    Sy = transvalues[3];
    Syy = transvalues[4];
    Sxy = transvalues[5];
 
    /*
     * Use the Youngs-Cramer algorithm to incorporate the new values into the
     * transition values.
     */
    N += 1.0;
    Sx += newvalX;
    Sy += newvalY;
    if (transvalues[0] > 0.0)
    {
        tmpX = newvalX * N - Sx;
        tmpY = newvalY * N - Sy;
        scale = 1.0 / (N * transvalues[0]);
        Sxx += tmpX * tmpX * scale;
        Syy += tmpY * tmpY * scale;
        Sxy += tmpX * tmpY * scale;
 
        /*
         * 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)) &&
                 !isinf(transvalues[1]) && !isinf(newvalX)) ||
                ((isinf(Sy) || isinf(Syy)) &&
                 !isinf(transvalues[3]) && !isinf(newvalY)) ||
                (isinf(Sxy) &&
                 !isinf(transvalues[1]) && !isinf(newvalX) &&
                 !isinf(transvalues[3]) && !isinf(newvalY)))
                float_overflow_error();
 
            if (isinf(Sxx))
                Sxx = get_float8_nan();
            if (isinf(Syy))
                Syy = get_float8_nan();
            if (isinf(Sxy))
                Sxy = get_float8_nan();
        }
    }
    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))
            Sxx = Sxy = get_float8_nan();
        if (isnan(newvalY) || isinf(newvalY))
            Syy = Sxy = get_float8_nan();
    }
 
    /*
     * 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))
    {
        transvalues[0] = N;
        transvalues[1] = Sx;
        transvalues[2] = Sxx;
        transvalues[3] = Sy;
        transvalues[4] = Syy;
        transvalues[5] = Sxy;
 
        PG_RETURN_ARRAYTYPE_P(transarray);
    }
    else
    {
        Datum       transdatums[6];
        ArrayType  *result;
 
        transdatums[0] = Float8GetDatumFast(N);
        transdatums[1] = Float8GetDatumFast(Sx);
        transdatums[2] = Float8GetDatumFast(Sxx);
        transdatums[3] = Float8GetDatumFast(Sy);
        transdatums[4] = Float8GetDatumFast(Syy);
        transdatums[5] = Float8GetDatumFast(Sxy);
 
        result = construct_array(transdatums, 6,
                                 FLOAT8OID,
                                 sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array(), Float8GetDatumFast, FLOAT8PASSBYVAL, float_overflow_error(), get_float8_nan(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_FLOAT8, PG_RETURN_ARRAYTYPE_P, and scale.

float8_regr_avgx()

Datum float8_regr_avgx

(

PG_FUNCTION_ARGS

)

Definition at line 3663 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sx;
 
    transvalues = check_float8_array(transarray, "float8_regr_avgx", 6);
    N = transvalues[0];
    Sx = transvalues[1];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sx / N);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_avgy()

Datum float8_regr_avgy

(

PG_FUNCTION_ARGS

)

Definition at line 3682 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sy;
 
    transvalues = check_float8_array(transarray, "float8_regr_avgy", 6);
    N = transvalues[0];
    Sy = transvalues[3];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sy / N);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_combine()

Datum float8_regr_combine

(

PG_FUNCTION_ARGS

)

Definition at line 3466 of file float.c.

{
    ArrayType  *transarray1 = PG_GETARG_ARRAYTYPE_P(0);
    ArrayType  *transarray2 = PG_GETARG_ARRAYTYPE_P(1);
    float8     *transvalues1;
    float8     *transvalues2;
    float8      N1,
                Sx1,
                Sxx1,
                Sy1,
                Syy1,
                Sxy1,
                N2,
                Sx2,
                Sxx2,
                Sy2,
                Syy2,
                Sxy2,
                tmp1,
                tmp2,
                N,
                Sx,
                Sxx,
                Sy,
                Syy,
                Sxy;
 
    transvalues1 = check_float8_array(transarray1, "float8_regr_combine", 6);
    transvalues2 = check_float8_array(transarray2, "float8_regr_combine", 6);
 
    N1 = transvalues1[0];
    Sx1 = transvalues1[1];
    Sxx1 = transvalues1[2];
    Sy1 = transvalues1[3];
    Syy1 = transvalues1[4];
    Sxy1 = transvalues1[5];
 
    N2 = transvalues2[0];
    Sx2 = transvalues2[1];
    Sxx2 = transvalues2[2];
    Sy2 = transvalues2[3];
    Syy2 = transvalues2[4];
    Sxy2 = transvalues2[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)
    {
        N = N2;
        Sx = Sx2;
        Sxx = Sxx2;
        Sy = Sy2;
        Syy = Syy2;
        Sxy = Sxy2;
    }
    else if (N2 == 0.0)
    {
        N = N1;
        Sx = Sx1;
        Sxx = Sxx1;
        Sy = Sy1;
        Syy = Syy1;
        Sxy = Sxy1;
    }
    else
    {
        N = N1 + N2;
        Sx = float8_pl(Sx1, Sx2);
        tmp1 = Sx1 / N1 - Sx2 / N2;
        Sxx = Sxx1 + Sxx2 + N1 * N2 * tmp1 * tmp1 / N;
        if (unlikely(isinf(Sxx)) && !isinf(Sxx1) && !isinf(Sxx2))
            float_overflow_error();
        Sy = float8_pl(Sy1, Sy2);
        tmp2 = Sy1 / N1 - Sy2 / N2;
        Syy = Syy1 + Syy2 + N1 * N2 * tmp2 * tmp2 / N;
        if (unlikely(isinf(Syy)) && !isinf(Syy1) && !isinf(Syy2))
            float_overflow_error();
        Sxy = Sxy1 + Sxy2 + N1 * N2 * tmp1 * tmp2 / N;
        if (unlikely(isinf(Sxy)) && !isinf(Sxy1) && !isinf(Sxy2))
            float_overflow_error();
    }
 
    /*
     * 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))
    {
        transvalues1[0] = N;
        transvalues1[1] = Sx;
        transvalues1[2] = Sxx;
        transvalues1[3] = Sy;
        transvalues1[4] = Syy;
        transvalues1[5] = Sxy;
 
        PG_RETURN_ARRAYTYPE_P(transarray1);
    }
    else
    {
        Datum       transdatums[6];
        ArrayType  *result;
 
        transdatums[0] = Float8GetDatumFast(N);
        transdatums[1] = Float8GetDatumFast(Sx);
        transdatums[2] = Float8GetDatumFast(Sxx);
        transdatums[3] = Float8GetDatumFast(Sy);
        transdatums[4] = Float8GetDatumFast(Syy);
        transdatums[5] = Float8GetDatumFast(Sxy);
 
        result = construct_array(transdatums, 6,
                                 FLOAT8OID,
                                 sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array(), float8_pl(), Float8GetDatumFast, FLOAT8PASSBYVAL, float_overflow_error(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_ARRAYTYPE_P, and unlikely.

float8_regr_intercept()

Datum float8_regr_intercept

(

PG_FUNCTION_ARGS

)

Definition at line 3828 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sx,
                Sxx,
                Sy,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_regr_intercept", 6);
    N = transvalues[0];
    Sx = transvalues[1];
    Sxx = transvalues[2];
    Sy = transvalues[3];
    Sxy = transvalues[5];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    /* per spec, return NULL for a vertical line */
    if (Sxx == 0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8((Sy - Sx * Sxy / Sxx) / N);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_r2()

Datum float8_regr_r2

(

PG_FUNCTION_ARGS

)

Definition at line 3768 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx,
                Syy,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_regr_r2", 6);
    N = transvalues[0];
    Sxx = transvalues[2];
    Syy = transvalues[4];
    Sxy = transvalues[5];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx and Syy are guaranteed to be non-negative */
 
    /* per spec, return NULL for a vertical line */
    if (Sxx == 0)
        PG_RETURN_NULL();
 
    /* per spec, return 1.0 for a horizontal line */
    if (Syy == 0)
        PG_RETURN_FLOAT8(1.0);
 
    PG_RETURN_FLOAT8((Sxy * Sxy) / (Sxx * Syy));
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_slope()

Datum float8_regr_slope

(

PG_FUNCTION_ARGS

)

Definition at line 3801 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_regr_slope", 6);
    N = transvalues[0];
    Sxx = transvalues[2];
    Sxy = transvalues[5];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    /* per spec, return NULL for a vertical line */
    if (Sxx == 0)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(Sxy / Sxx);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_sxx()

Datum float8_regr_sxx

(

PG_FUNCTION_ARGS

)

Definition at line 3600 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx;
 
    transvalues = check_float8_array(transarray, "float8_regr_sxx", 6);
    N = transvalues[0];
    Sxx = transvalues[2];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    PG_RETURN_FLOAT8(Sxx);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_sxy()

Datum float8_regr_sxy

(

PG_FUNCTION_ARGS

)

Definition at line 3642 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxy;
 
    transvalues = check_float8_array(transarray, "float8_regr_sxy", 6);
    N = transvalues[0];
    Sxy = transvalues[5];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* A negative result is valid here */
 
    PG_RETURN_FLOAT8(Sxy);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_regr_syy()

Datum float8_regr_syy

(

PG_FUNCTION_ARGS

)

Definition at line 3621 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Syy;
 
    transvalues = check_float8_array(transarray, "float8_regr_syy", 6);
    N = transvalues[0];
    Syy = transvalues[4];
 
    /* if N is 0 we should return NULL */
    if (N < 1.0)
        PG_RETURN_NULL();
 
    /* Note that Syy is guaranteed to be non-negative */
 
    PG_RETURN_FLOAT8(Syy);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_stddev_pop()

Datum float8_stddev_pop

(

PG_FUNCTION_ARGS

)

Definition at line 3277 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx;
 
    transvalues = check_float8_array(transarray, "float8_stddev_pop", 3);
    N = transvalues[0];
    /* ignore Sx */
    Sxx = transvalues[2];
 
    /* Population stddev is undefined when N is 0, so return NULL */
    if (N == 0.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    PG_RETURN_FLOAT8(sqrt(Sxx / N));
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_stddev_samp()

Datum float8_stddev_samp

(

PG_FUNCTION_ARGS

)

Definition at line 3299 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx;
 
    transvalues = check_float8_array(transarray, "float8_stddev_samp", 3);
    N = transvalues[0];
    /* ignore Sx */
    Sxx = transvalues[2];
 
    /* Sample stddev is undefined when N is 0 or 1, so return NULL */
    if (N <= 1.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    PG_RETURN_FLOAT8(sqrt(Sxx / (N - 1.0)));
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_var_pop()

Datum float8_var_pop

(

PG_FUNCTION_ARGS

)

Definition at line 3233 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx;
 
    transvalues = check_float8_array(transarray, "float8_var_pop", 3);
    N = transvalues[0];
    /* ignore Sx */
    Sxx = transvalues[2];
 
    /* Population variance is undefined when N is 0, so return NULL */
    if (N == 0.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    PG_RETURN_FLOAT8(Sxx / N);
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8_var_samp()

Datum float8_var_samp

(

PG_FUNCTION_ARGS

)

Definition at line 3255 of file float.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    float8     *transvalues;
    float8      N,
                Sxx;
 
    transvalues = check_float8_array(transarray, "float8_var_samp", 3);
    N = transvalues[0];
    /* ignore Sx */
    Sxx = transvalues[2];
 
    /* Sample variance is undefined when N is 0 or 1, so return NULL */
    if (N <= 1.0)
        PG_RETURN_NULL();
 
    /* Note that Sxx is guaranteed to be non-negative */
 
    PG_RETURN_FLOAT8(Sxx / (N - 1.0));
}

References check_float8_array(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_FLOAT8, and PG_RETURN_NULL.

float8abs()

Datum float8abs

(

PG_FUNCTION_ARGS

)

Definition at line 656 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(fabs(arg1));
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8div()

Datum float8div

(

PG_FUNCTION_ARGS

)

Definition at line 796 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_div(arg1, arg2));
}

References float8_div(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8eq()

Datum float8eq

(

PG_FUNCTION_ARGS

)

Definition at line 919 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_eq(arg1, arg2));
}

References float8_eq(), PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float8ge()

Datum float8ge

(

PG_FUNCTION_ARGS

)

Definition at line 964 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_ge(arg1, arg2));
}

References float8_ge(), PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float8gt()

Datum float8gt

(

PG_FUNCTION_ARGS

)

Definition at line 955 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_gt(arg1, arg2));
}

References float8_gt(), PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float8in()

Datum float8in

(

PG_FUNCTION_ARGS

)

Definition at line 363 of file float.c.

{
    char       *num = PG_GETARG_CSTRING(0);
 
    PG_RETURN_FLOAT8(float8in_internal(num, NULL, "double precision", num,
                                       fcinfo->context));
}

References float8in_internal(), PG_GETARG_CSTRING, and PG_RETURN_FLOAT8.

Referenced by numeric_float8().

float8in_internal()

float8 float8in_internal	(	char *	num,
		char **	endptr_p,
		const char *	type_name,
		const char *	orig_string,
		struct Node *	escontext
	)

Definition at line 394 of file float.c.

{
    double      val;
    char       *endptr;
 
    /* skip leading whitespace */
    while (*num != '\0' && isspace((unsigned char) *num))
        num++;
 
    /*
     * Check for an empty-string input to begin with, to avoid the vagaries of
     * strtod() on different platforms.
     */
    if (*num == '\0')
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        type_name, orig_string)));
 
    errno = 0;
    val = strtod(num, &endptr);
 
    /* 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)
        {
            val = get_float8_nan();
            endptr = num + 3;
        }
        else if (pg_strncasecmp(num, "Infinity", 8) == 0)
        {
            val = get_float8_infinity();
            endptr = num + 8;
        }
        else if (pg_strncasecmp(num, "+Infinity", 9) == 0)
        {
            val = get_float8_infinity();
            endptr = num + 9;
        }
        else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
        {
            val = -get_float8_infinity();
            endptr = num + 9;
        }
        else if (pg_strncasecmp(num, "inf", 3) == 0)
        {
            val = get_float8_infinity();
            endptr = num + 3;
        }
        else if (pg_strncasecmp(num, "+inf", 4) == 0)
        {
            val = get_float8_infinity();
            endptr = num + 4;
        }
        else if (pg_strncasecmp(num, "-inf", 4) == 0)
        {
            val = -get_float8_infinity();
            endptr = num + 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);
 
                errnumber[endptr - num] = '\0';
                ereturn(escontext, 0,
                        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                         errmsg("\"%s\" is out of range for type double precision",
                                errnumber)));
            }
        }
        else
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            type_name, orig_string)));
    }
 
    /* skip trailing whitespace */
    while (*endptr != '\0' && isspace((unsigned char) *endptr))
        endptr++;
 
    /* report stopping point if wanted, else complain if not end of string */
    if (endptr_p)
        *endptr_p = endptr;
    else if (*endptr != '\0')
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        type_name, orig_string)));
 
    return val;
}

References ereturn, errcode(), errmsg(), get_float8_infinity(), get_float8_nan(), pg_strncasecmp(), pstrdup(), and val.

Referenced by executeItemOptUnwrapTarget(), float8in(), and single_decode().

float8larger()

Datum float8larger

(

PG_FUNCTION_ARGS

)

Definition at line 686 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
    float8      result;
 
    if (float8_gt(arg1, arg2))
        result = arg1;
    else
        result = arg2;
    PG_RETURN_FLOAT8(result);
}

References float8_gt(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8le()

Datum float8le

(

PG_FUNCTION_ARGS

)

Definition at line 946 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_le(arg1, arg2));
}

References float8_le(), PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float8lt()

Datum float8lt

(

PG_FUNCTION_ARGS

)

Definition at line 937 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_lt(arg1, arg2));
}

References float8_lt(), PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float8mi()

Datum float8mi

(

PG_FUNCTION_ARGS

)

Definition at line 778 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_mi(arg1, arg2));
}

References float8_mi(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8mul()

Datum float8mul

(

PG_FUNCTION_ARGS

)

Definition at line 787 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_mul(arg1, arg2));
}

References float8_mul(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8ne()

Datum float8ne

(

PG_FUNCTION_ARGS

)

Definition at line 928 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_BOOL(float8_ne(arg1, arg2));
}

References float8_ne(), PG_GETARG_FLOAT8, and PG_RETURN_BOOL.

float8out()

Datum float8out

(

PG_FUNCTION_ARGS

)

Definition at line 521 of file float.c.

{
    float8      num = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_CSTRING(float8out_internal(num));
}

References float8out_internal(), PG_GETARG_FLOAT8, and PG_RETURN_CSTRING.

float8out_internal()

char* float8out_internal

(

double

num

)

Definition at line 536 of file float.c.

{
    char       *ascii = (char *) palloc(32);
    int         ndig = DBL_DIG + extra_float_digits;
 
    if (extra_float_digits > 0)
    {
        double_to_shortest_decimal_buf(num, ascii);
        return ascii;
    }
 
    (void) pg_strfromd(ascii, 32, ndig, num);
    return ascii;
}

References ascii(), double_to_shortest_decimal_buf(), extra_float_digits, palloc(), and pg_strfromd().

Referenced by cube_out(), float8out(), line_out(), pair_encode(), and single_encode().

float8pl()

Datum float8pl

(

PG_FUNCTION_ARGS

)

Definition at line 769 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
 
    PG_RETURN_FLOAT8(float8_pl(arg1, arg2));
}

References float8_pl(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8recv()

Datum float8recv

(

PG_FUNCTION_ARGS

)

Definition at line 555 of file float.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
    PG_RETURN_FLOAT8(pq_getmsgfloat8(buf));
}

References buf, PG_GETARG_POINTER, PG_RETURN_FLOAT8, and pq_getmsgfloat8().

float8send()

Datum float8send

(

PG_FUNCTION_ARGS

)

Definition at line 566 of file float.c.

{
    float8      num = PG_GETARG_FLOAT8(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat8(&buf, num);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_FLOAT8, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat8().

float8smaller()

Datum float8smaller

(

PG_FUNCTION_ARGS

)

Definition at line 700 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      arg2 = PG_GETARG_FLOAT8(1);
    float8      result;
 
    if (float8_lt(arg1, arg2))
        result = arg1;
    else
        result = arg2;
    PG_RETURN_FLOAT8(result);
}

References float8_lt(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8um()

Datum float8um

(

PG_FUNCTION_ARGS

)

Definition at line 668 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    result = -arg1;
    PG_RETURN_FLOAT8(result);
}

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float8up()

Datum float8up

(

PG_FUNCTION_ARGS

)

Definition at line 678 of file float.c.

{
    float8      arg = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(arg);
}

References arg, PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

float_overflow_error()

pg_noinline void float_overflow_error

(

void

)

Definition at line 85 of file float.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value out of range: overflow")));
}

References ereport, errcode(), errmsg(), and ERROR.

Referenced by dacos(), dacosd(), dasin(), dasind(), datan(), datan2(), datan2d(), datand(), dcbrt(), dcos(), dcosd(), derf(), derfc(), dexp(), dlog1(), dlog10(), dpow(), dsin(), dsind(), dsqrt(), dtanh(), dtof(), float4_accum(), float4_dist(), float4_div(), float4_mi(), float4_mul(), float4_pl(), float8_accum(), float8_combine(), float8_dist(), float8_div(), float8_mi(), float8_mul(), float8_pl(), float8_regr_accum(), float8_regr_combine(), gbt_float8_dist(), and pg_hypot().

float_underflow_error()

pg_noinline void float_underflow_error

(

void

)

Definition at line 93 of file float.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value out of range: underflow")));
}

References ereport, errcode(), errmsg(), and ERROR.

Referenced by dcbrt(), dcosh(), dexp(), dlog1(), dlog10(), dpow(), dsqrt(), dtof(), float4_div(), float4_mul(), float8_div(), float8_mul(), and pg_hypot().

float_zero_divide_error()

pg_noinline void float_zero_divide_error

(

void

)

Definition at line 101 of file float.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_DIVISION_BY_ZERO),
             errmsg("division by zero")));
}

References ereport, errcode(), errmsg(), and ERROR.

Referenced by float4_div(), and float8_div().

ftod()

Datum ftod

(

PG_FUNCTION_ARGS

)

Definition at line 1182 of file float.c.

{
    float4      num = PG_GETARG_FLOAT4(0);
 
    PG_RETURN_FLOAT8((float8) num);
}

References PG_GETARG_FLOAT4, and PG_RETURN_FLOAT8.

ftoi2()

Datum ftoi2

(

PG_FUNCTION_ARGS

)

Definition at line 1312 of file float.c.

{
    float4      num = PG_GETARG_FLOAT4(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.
     */
    num = rint(num);
 
    /* Range check */
    if (unlikely(isnan(num) || !FLOAT4_FITS_IN_INT16(num)))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("smallint out of range")));
 
    PG_RETURN_INT16((int16) num);
}

References ereport, errcode(), errmsg(), ERROR, FLOAT4_FITS_IN_INT16, PG_GETARG_FLOAT4, PG_RETURN_INT16, and unlikely.

ftoi4()

Datum ftoi4

(

PG_FUNCTION_ARGS

)

Definition at line 1287 of file float.c.

{
    float4      num = PG_GETARG_FLOAT4(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.
     */
    num = rint(num);
 
    /* Range check */
    if (unlikely(isnan(num) || !FLOAT4_FITS_IN_INT32(num)))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("integer out of range")));
 
    PG_RETURN_INT32((int32) num);
}

References ereport, errcode(), errmsg(), ERROR, FLOAT4_FITS_IN_INT32, PG_GETARG_FLOAT4, PG_RETURN_INT32, and unlikely.

i2tod()

Datum i2tod

(

PG_FUNCTION_ARGS

)

Definition at line 1275 of file float.c.

{
    int16       num = PG_GETARG_INT16(0);
 
    PG_RETURN_FLOAT8((float8) num);
}

References PG_GETARG_INT16, and PG_RETURN_FLOAT8.

i2tof()

Datum i2tof

(

PG_FUNCTION_ARGS

)

Definition at line 1349 of file float.c.

{
    int16       num = PG_GETARG_INT16(0);
 
    PG_RETURN_FLOAT4((float4) num);
}

References PG_GETARG_INT16, and PG_RETURN_FLOAT4.

i4tod()

Datum i4tod

(

PG_FUNCTION_ARGS

)

Definition at line 1263 of file float.c.

{
    int32       num = PG_GETARG_INT32(0);
 
    PG_RETURN_FLOAT8((float8) num);
}

References PG_GETARG_INT32, and PG_RETURN_FLOAT8.

i4tof()

Datum i4tof

(

PG_FUNCTION_ARGS

)

Definition at line 1337 of file float.c.

{
    int32       num = PG_GETARG_INT32(0);
 
    PG_RETURN_FLOAT4((float4) num);
}

References PG_GETARG_INT32, and PG_RETURN_FLOAT4.

in_range_float4_float8()

Datum in_range_float4_float8

(

PG_FUNCTION_ARGS

)

Definition at line 1102 of file float.c.

{
    float4      val = PG_GETARG_FLOAT4(0);
    float4      base = PG_GETARG_FLOAT4(1);
    float8      offset = PG_GETARG_FLOAT8(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    float8      sum;
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("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))
            PG_RETURN_BOOL(true);   /* NAN = NAN */
        else
            PG_RETURN_BOOL(!less);  /* NAN > non-NAN */
    }
    else if (isnan(base))
    {
        PG_RETURN_BOOL(less);   /* 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) &&
        (sub ? base > 0 : base < 0))
        PG_RETURN_BOOL(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)
        sum = base - offset;
    else
        sum = base + offset;
 
    if (less)
        PG_RETURN_BOOL(val <= sum);
    else
        PG_RETURN_BOOL(val >= sum);
}

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_BOOL, PG_GETARG_FLOAT4, PG_GETARG_FLOAT8, PG_RETURN_BOOL, and val.

in_range_float8_float8()

Datum in_range_float8_float8

(

PG_FUNCTION_ARGS

)

Definition at line 1026 of file float.c.

{
    float8      val = PG_GETARG_FLOAT8(0);
    float8      base = PG_GETARG_FLOAT8(1);
    float8      offset = PG_GETARG_FLOAT8(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    float8      sum;
 
    /*
     * 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)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("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))
            PG_RETURN_BOOL(true);   /* NAN = NAN */
        else
            PG_RETURN_BOOL(!less);  /* NAN > non-NAN */
    }
    else if (isnan(base))
    {
        PG_RETURN_BOOL(less);   /* 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) &&
        (sub ? base > 0 : base < 0))
        PG_RETURN_BOOL(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)
        sum = base - offset;
    else
        sum = base + offset;
 
    if (less)
        PG_RETURN_BOOL(val <= sum);
    else
        PG_RETURN_BOOL(val >= sum);
}

References ereport, errcode(), errmsg(), ERROR, PG_GETARG_BOOL, PG_GETARG_FLOAT8, PG_RETURN_BOOL, and val.

init_degree_constants()

static void init_degree_constants ( void  )

static

Definition at line 2018 of file float.c.

{
    sin_30 = sin(degree_c_thirty * RADIANS_PER_DEGREE);
    one_minus_cos_60 = 1.0 - cos(degree_c_sixty * RADIANS_PER_DEGREE);
    asin_0_5 = asin(degree_c_one_half);
    acos_0_5 = acos(degree_c_one_half);
    atan_1_0 = atan(degree_c_one);
    tan_45 = sind_q1(degree_c_forty_five) / cosd_q1(degree_c_forty_five);
    cot_45 = cosd_q1(degree_c_forty_five) / sind_q1(degree_c_forty_five);
    degree_consts_set = true;
}

References acos_0_5, asin_0_5, atan_1_0, cosd_q1(), cot_45, degree_c_forty_five, degree_c_one, degree_c_one_half, degree_c_sixty, degree_c_thirty, degree_consts_set, one_minus_cos_60, RADIANS_PER_DEGREE, sin_30, sind_q1(), and tan_45.

initialize_drandom_seed()

static void initialize_drandom_seed ( void  )

static

Definition at line 2795 of file float.c.

{
    /* Initialize random seed, if not done yet in this process */
    if (unlikely(!drandom_seed_set))
    {
        /*
         * If possible, initialize the seed using high-quality random bits.
         * Should that fail for some reason, we fall back on a lower-quality
         * seed based on current time and PID.
         */
        if (unlikely(!pg_prng_strong_seed(&drandom_seed)))
        {
            TimestampTz now = GetCurrentTimestamp();
            uint64      iseed;
 
            /* Mix the PID with the most predictable bits of the timestamp */
            iseed = (uint64) now ^ ((uint64) MyProcPid << 32);
            pg_prng_seed(&drandom_seed, iseed);
        }
        drandom_seed_set = true;
    }
}

References drandom_seed, drandom_seed_set, GetCurrentTimestamp(), MyProcPid, now(), pg_prng_seed(), pg_prng_strong_seed, and unlikely.

Referenced by drandom(), and drandom_normal().

is_infinite()

int is_infinite

(

double

val

)

Definition at line 117 of file float.c.

{
    int         inf = isinf(val);
 
    if (inf == 0)
        return 0;
    else if (val > 0)
        return 1;
    else
        return -1;
}

References val.

radians()

Datum radians

(

PG_FUNCTION_ARGS

)

Definition at line 2582 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
 
    PG_RETURN_FLOAT8(float8_mul(arg1, RADIANS_PER_DEGREE));
}

References float8_mul(), PG_GETARG_FLOAT8, PG_RETURN_FLOAT8, and RADIANS_PER_DEGREE.

setseed()

Datum setseed

(

PG_FUNCTION_ARGS

)

Definition at line 2860 of file float.c.

{
    float8      seed = PG_GETARG_FLOAT8(0);
 
    if (seed < -1 || seed > 1 || isnan(seed))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("setseed parameter %g is out of allowed range [-1,1]",
                        seed)));
 
    pg_prng_fseed(&drandom_seed, seed);
    drandom_seed_set = true;
 
    PG_RETURN_VOID();
}

References drandom_seed, drandom_seed_set, ereport, errcode(), errmsg(), ERROR, PG_GETARG_FLOAT8, pg_prng_fseed(), and PG_RETURN_VOID.

Referenced by assign_random_seed().

sind_0_to_30()

static double sind_0_to_30 ( double  x )

static

Definition at line 2251 of file float.c.

{
    volatile float8 sin_x = sin(x * RADIANS_PER_DEGREE);
 
    return (sin_x / sin_30) / 2.0;
}

References RADIANS_PER_DEGREE, sin_30, and x.

Referenced by cosd_q1(), and sind_q1().

sind_q1()

static double sind_q1 ( double  x )

static

Definition at line 2278 of file float.c.

{
    /*
     * 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);
}

References cosd_0_to_60(), sind_0_to_30(), and x.

Referenced by dcotd(), dsind(), dtand(), and init_degree_constants().

width_bucket_float8()

Datum width_bucket_float8

(

PG_FUNCTION_ARGS

)

Definition at line 4084 of file float.c.

{
    float8      operand = PG_GETARG_FLOAT8(0);
    float8      bound1 = PG_GETARG_FLOAT8(1);
    float8      bound2 = PG_GETARG_FLOAT8(2);
    int32       count = PG_GETARG_INT32(3);
    int32       result;
 
    if (count <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                 errmsg("count must be greater than zero")));
 
    if (isnan(operand) || isnan(bound1) || isnan(bound2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                 errmsg("operand, lower bound, and upper bound cannot be NaN")));
 
    /* Note that we allow "operand" to be infinite */
    if (isinf(bound1) || isinf(bound2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                 errmsg("lower and upper bounds must be finite")));
 
    if (bound1 < bound2)
    {
        if (operand < bound1)
            result = 0;
        else if (operand >= bound2)
        {
            if (pg_add_s32_overflow(count, 1, &result))
                ereport(ERROR,
                        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                         errmsg("integer out of range")));
        }
        else
        {
            if (!isinf(bound2 - bound1))
            {
                /* The quotient is surely in [0,1], so this can't overflow */
                result = count * ((operand - bound1) / (bound2 - bound1));
            }
            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.
                 */
                result = count * ((operand / 2 - bound1 / 2) / (bound2 / 2 - bound1 / 2));
            }
            /* The quotient could round to 1.0, which would be a lie */
            if (result >= count)
                result = count - 1;
            /* Having done that, we can add 1 without fear of overflow */
            result++;
        }
    }
    else if (bound1 > bound2)
    {
        if (operand > bound1)
            result = 0;
        else if (operand <= bound2)
        {
            if (pg_add_s32_overflow(count, 1, &result))
                ereport(ERROR,
                        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                         errmsg("integer out of range")));
        }
        else
        {
            if (!isinf(bound1 - bound2))
                result = count * ((bound1 - operand) / (bound1 - bound2));
            else
                result = count * ((bound1 / 2 - operand / 2) / (bound1 / 2 - bound2 / 2));
            if (result >= count)
                result = count - 1;
            result++;
        }
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                 errmsg("lower bound cannot equal upper bound")));
        result = 0;             /* keep the compiler quiet */
    }
 
    PG_RETURN_INT32(result);
}

References ereport, errcode(), errmsg(), ERROR, pg_add_s32_overflow(), PG_GETARG_FLOAT8, PG_GETARG_INT32, and PG_RETURN_INT32.

Variable Documentation

acos_0_5

float8 acos_0_5 = 0

static

Definition at line 50 of file float.c.

Referenced by acosd_q1(), asind_q1(), and init_degree_constants().

asin_0_5

float8 asin_0_5 = 0

static

Definition at line 49 of file float.c.

Referenced by acosd_q1(), asind_q1(), and init_degree_constants().

atan_1_0

float8 atan_1_0 = 0

static

Definition at line 51 of file float.c.

Referenced by datan2d(), datand(), and init_degree_constants().

cot_45

float8 cot_45 = 0

static

Definition at line 53 of file float.c.

Referenced by dcotd(), and init_degree_constants().

degree_c_forty_five

float8 degree_c_forty_five = 45.0

Definition at line 62 of file float.c.

Referenced by init_degree_constants().

degree_c_one

float8 degree_c_one = 1.0

Definition at line 65 of file float.c.

Referenced by init_degree_constants().

degree_c_one_half

float8 degree_c_one_half = 0.5

Definition at line 64 of file float.c.

Referenced by init_degree_constants().

degree_c_sixty

float8 degree_c_sixty = 60.0

Definition at line 63 of file float.c.

Referenced by init_degree_constants().

degree_c_thirty

float8 degree_c_thirty = 30.0

Definition at line 61 of file float.c.

Referenced by init_degree_constants().

degree_consts_set

bool degree_consts_set = false

static

Definition at line 46 of file float.c.

Referenced by init_degree_constants().

drandom_seed

pg_prng_state drandom_seed

static

Definition at line 69 of file float.c.

Referenced by drandom(), drandom_normal(), initialize_drandom_seed(), and setseed().

drandom_seed_set

bool drandom_seed_set = false

static

Definition at line 68 of file float.c.

Referenced by initialize_drandom_seed(), and setseed().

extra_float_digits

int extra_float_digits = 1

Definition at line 43 of file float.c.

Referenced by float4out(), float8out_internal(), and set_transmission_modes().

one_minus_cos_60

float8 one_minus_cos_60 = 0

static

Definition at line 48 of file float.c.

Referenced by cosd_0_to_60(), and init_degree_constants().

sin_30

float8 sin_30 = 0

static

Definition at line 47 of file float.c.

Referenced by init_degree_constants(), and sind_0_to_30().

tan_45

float8 tan_45 = 0

static

Definition at line 52 of file float.c.

Referenced by dtand(), and init_degree_constants().