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/shortest_dec.h"
#include "libpq/pqformat.h"
#include "utils/array.h"
#include "utils/fmgrprotos.h"
#include "utils/sortsupport.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)
Datum	dgamma (PG_FUNCTION_ARGS)
Datum	dlgamma (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

Macro Definition Documentation

INIT_DEGREE_CONSTANTS

#define INIT_DEGREE_CONSTANTS

(

)

Value:

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

Definition at line 2031 of file float.c.

Function Documentation

acosd_q1()

static double acosd_q1 ( double  x )

static

Definition at line 2081 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 2048 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 1001 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 880 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 889 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 898 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 1011 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 974 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 983 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 992 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 2266 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 2299 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 1755 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 2108 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 2689 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 1786 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 2145 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 2672 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 1817 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 1843 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 2214 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 2182 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 2714 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 1470 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 1380 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 1869 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 2318 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 2627 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 1910 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 2373 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 2561 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 2752 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 2772 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 1644 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 1392 of file float.c.

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

References PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dgamma()

Datum dgamma

(

PG_FUNCTION_ARGS

)

Definition at line 2796 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * Handle NaN and Inf cases explicitly.  This simplifies the overflow
     * checks on platforms that do not set errno.
     */
    if (isnan(arg1))
        result = arg1;
    else if (isinf(arg1))
    {
        /* Per POSIX, an input of -Inf causes a domain error */
        if (arg1 < 0)
        {
            float_overflow_error();
            result = get_float8_nan();  /* keep compiler quiet */
        }
        else
            result = arg1;
    }
    else
    {
        /*
         * Note: the POSIX/C99 gamma function is called "tgamma", not "gamma".
         *
         * On some platforms, tgamma() will not set errno but just return Inf,
         * NaN, or zero to report overflow/underflow; therefore, test those
         * cases explicitly (note that, like the exponential function, the
         * gamma function has no zeros).
         */
        errno = 0;
        result = tgamma(arg1);
 
        if (errno != 0 || isinf(result) || isnan(result))
        {
            if (result != 0.0)
                float_overflow_error();
            else
                float_underflow_error();
        }
        else if (result == 0.0)
            float_underflow_error();
    }
 
    PG_RETURN_FLOAT8(result);
}

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

dlgamma()

Datum dlgamma

(

PG_FUNCTION_ARGS

)

Definition at line 2850 of file float.c.

{
    float8      arg1 = PG_GETARG_FLOAT8(0);
    float8      result;
 
    /*
     * Note: lgamma may not be thread-safe because it may write to a global
     * variable signgam, which may not be thread-local. However, this doesn't
     * matter to us, since we don't use signgam.
     */
    errno = 0;
    result = lgamma(arg1);
 
    /*
     * If an ERANGE error occurs, it means there was an overflow or a pole
     * error (which happens for zero and negative integer inputs).
     *
     * On some platforms, lgamma() will not set errno but just return infinity
     * to report overflow, but it should never underflow.
     */
    if (errno == ERANGE || (isinf(result) && !isinf(arg1)))
        float_overflow_error();
 
    PG_RETURN_FLOAT8(result);
}

References float_overflow_error(), PG_GETARG_FLOAT8, and PG_RETURN_FLOAT8.

dlog1()

Datum dlog1

(

PG_FUNCTION_ARGS

)

Definition at line 1690 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 1722 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 2573 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 1489 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.

dround()

Datum dround

(

PG_FUNCTION_ARGS

)

Definition at line 1368 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 1405 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 1938 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 2439 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 2598 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 1446 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 1965 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 2495 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 2652 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 1195 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 1239 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 1214 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 1428 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 3889 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 3949 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 3994 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 3985 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 3976 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 3967 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 3871 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 3880 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 3958 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 3862 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 3124 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_builtin(transdatums, 3, FLOAT8OID);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array_builtin(), Float8GetDatumFast, 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 816 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(), btfloat4fastcmp(), and gbt_float4_ssup_cmp().

float4abs()

Datum float4abs

(

PG_FUNCTION_ARGS

)

Definition at line 591 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 755 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 826 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 871 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 862 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 164 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 183 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 620 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 853 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 844 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 737 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 746 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 835 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 319 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 728 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 339 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 350 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 634 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 602 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 612 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 3931 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 4006 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 4051 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 4042 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 4033 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 4024 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 3913 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 3922 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 4015 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 3904 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 3043 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_builtin(transdatums, 3, FLOAT8OID);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array_builtin(), Float8GetDatumFast, 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 3207 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 910 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(), gbt_float8_ssup_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_builtin(transdatums, 3, FLOAT8OID);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

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

float8_corr()

Datum float8_corr

(

PG_FUNCTION_ARGS

)

Definition at line 3729 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 3691 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 3710 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 3336 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_builtin(transdatums, 6, FLOAT8OID);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array_builtin(), Float8GetDatumFast, 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 3653 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 3672 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 3458 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_builtin(transdatums, 6, FLOAT8OID);
 
        PG_RETURN_ARRAYTYPE_P(result);
    }
}

References AggCheckCallContext(), check_float8_array(), construct_array_builtin(), float8_pl(), Float8GetDatumFast, 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 3818 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 3758 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 3791 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 3590 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 3632 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 3611 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 3271 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 3293 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 3227 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 3249 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 657 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 797 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 920 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 965 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 956 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 364 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 395 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 687 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 947 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 938 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 779 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 788 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 929 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 522 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 537 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 770 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 556 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 567 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 701 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 669 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 679 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 86 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(), dgamma(), dlgamma(), 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 94 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(), dgamma(), 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 102 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 1183 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 1313 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 1288 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 1276 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 1350 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 1264 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 1338 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 1103 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 1027 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 2019 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.

is_infinite()

int is_infinite

(

double

val

)

Definition at line 118 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 2583 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.

sind_0_to_30()

static double sind_0_to_30 ( double  x )

static

Definition at line 2252 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 2279 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 4074 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 47 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 46 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 48 of file float.c.

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

cot_45

float8 cot_45 = 0

static

Definition at line 50 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 67 of file float.c.

Referenced by init_degree_constants().

degree_c_one

float8 degree_c_one = 1.0

Definition at line 70 of file float.c.

Referenced by init_degree_constants().

degree_c_one_half

float8 degree_c_one_half = 0.5

Definition at line 69 of file float.c.

Referenced by init_degree_constants().

degree_c_sixty

float8 degree_c_sixty = 60.0

Definition at line 68 of file float.c.

Referenced by init_degree_constants().

degree_c_thirty

float8 degree_c_thirty = 30.0

Definition at line 66 of file float.c.

Referenced by init_degree_constants().

degree_consts_set

bool degree_consts_set = false

static

Definition at line 43 of file float.c.

Referenced by init_degree_constants().

extra_float_digits

int extra_float_digits = 1

Definition at line 40 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 45 of file float.c.

Referenced by cosd_0_to_60(), and init_degree_constants().

sin_30

float8 sin_30 = 0

static

Definition at line 44 of file float.c.

Referenced by init_degree_constants(), and sind_0_to_30().

tan_45

float8 tan_45 = 0

static

Definition at line 49 of file float.c.

Referenced by dtand(), and init_degree_constants().