#include <math.h>

Include dependency graph for float.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	M_PI 3.14159265358979323846

#define	RADIANS_PER_DEGREE 0.0174532925199432957692

Functions
pg_noreturn void	float_overflow_error (void)

pg_noreturn void	float_underflow_error (void)

pg_noreturn void	float_zero_divide_error (void)

int	is_infinite (float8 val)

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

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

char *	float8out_internal (float8 num)

int	float4_cmp_internal (float4 a, float4 b)

int	float8_cmp_internal (float8 a, float8 b)

static float4	get_float4_infinity (void)

static float8	get_float8_infinity (void)

static float4	get_float4_nan (void)

static float8	get_float8_nan (void)

static float4	float4_pl (const float4 val1, const float4 val2)

static float8	float8_pl (const float8 val1, const float8 val2)

static float4	float4_mi (const float4 val1, const float4 val2)

static float8	float8_mi (const float8 val1, const float8 val2)

static float4	float4_mul (const float4 val1, const float4 val2)

static float8	float8_mul (const float8 val1, const float8 val2)

static float4	float4_div (const float4 val1, const float4 val2)

static float8	float8_div (const float8 val1, const float8 val2)

static bool	float4_eq (const float4 val1, const float4 val2)

static bool	float8_eq (const float8 val1, const float8 val2)

static bool	float4_ne (const float4 val1, const float4 val2)

static bool	float8_ne (const float8 val1, const float8 val2)

static bool	float4_lt (const float4 val1, const float4 val2)

static bool	float8_lt (const float8 val1, const float8 val2)

static bool	float4_le (const float4 val1, const float4 val2)

static bool	float8_le (const float8 val1, const float8 val2)

static bool	float4_gt (const float4 val1, const float4 val2)

static bool	float8_gt (const float8 val1, const float8 val2)

static bool	float4_ge (const float4 val1, const float4 val2)

static bool	float8_ge (const float8 val1, const float8 val2)

static float4	float4_min (const float4 val1, const float4 val2)

static float8	float8_min (const float8 val1, const float8 val2)

static float4	float4_max (const float4 val1, const float4 val2)

static float8	float8_max (const float8 val1, const float8 val2)

Variables
PGDLLIMPORT int	extra_float_digits

Macro Definition Documentation

◆ M_PI

#define M_PI 3.14159265358979323846

Definition at line 22 of file float.h.

◆ RADIANS_PER_DEGREE

#define RADIANS_PER_DEGREE 0.0174532925199432957692

Definition at line 26 of file float.h.

Function Documentation

◆ float4_cmp_internal()

int float4_cmp_internal	(	float4	a,
		float4	b
	)

extern

Definition at line 833 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().

◆ float4_div()

static float4 float4_div	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 177 of file float.h.

{
    float4      result;
 
    if (unlikely(val2 == 0.0f) && !isnan(val1))
        float_zero_divide_error();
    result = val1 / val2;
    if (unlikely(isinf(result)) && !isinf(val1))
        float_overflow_error();
    if (unlikely(result == 0.0f) && val1 != 0.0f && !isinf(val2))
        float_underflow_error();
 
    return result;
}

References fb(), float_overflow_error(), float_underflow_error(), float_zero_divide_error(), and unlikely.

Referenced by float4div(), and g_box_consider_split().

◆ float4_eq()

static bool float4_eq	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 217 of file float.h.

{
    return isnan(val1) ? isnan(val2) : !isnan(val2) && val1 == val2;
}

References fb().

Referenced by float4eq().

◆ float4_ge()

static bool float4_ge	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 277 of file float.h.

{
    return isnan(val1) || (!isnan(val2) && val1 >= val2);
}

References fb().

Referenced by float4ge().

◆ float4_gt()

static bool float4_gt	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 265 of file float.h.

{
    return !isnan(val2) && (isnan(val1) || val1 > val2);
}

References fb().

Referenced by float4_cmp_internal(), float4_max(), float4gt(), and float4larger().

◆ float4_le()

static bool float4_le	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 253 of file float.h.

{
    return isnan(val2) || (!isnan(val1) && val1 <= val2);
}

References fb().

Referenced by float4le().

◆ float4_lt()

static bool float4_lt	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 241 of file float.h.

{
    return !isnan(val1) && (isnan(val2) || val1 < val2);
}

References fb().

Referenced by float4_cmp_internal(), float4_min(), float4lt(), and float4smaller().

◆ float4_max()

static float4 float4_max	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 301 of file float.h.

{
    return float4_gt(val1, val2) ? val1 : val2;
}

References fb(), and float4_gt().

◆ float4_mi()

static float4 float4_mi	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 125 of file float.h.

{
    float4      result;
 
    result = val1 - val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();
 
    return result;
}

References fb(), float_overflow_error(), and unlikely.

Referenced by float4mi().

◆ float4_min()

static float4 float4_min	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 289 of file float.h.

{
    return float4_lt(val1, val2) ? val1 : val2;
}

References fb(), and float4_lt().

◆ float4_mul()

static float4 float4_mul	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 149 of file float.h.

{
    float4      result;
 
    result = val1 * val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();
    if (unlikely(result == 0.0f) && val1 != 0.0f && val2 != 0.0f)
        float_underflow_error();
 
    return result;
}

References fb(), float_overflow_error(), float_underflow_error(), and unlikely.

Referenced by float4mul().

◆ float4_ne()

static bool float4_ne	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 229 of file float.h.

{
    return isnan(val1) ? !isnan(val2) : isnan(val2) || val1 != val2;
}

References fb().

Referenced by float4ne().

◆ float4_pl()

static float4 float4_pl	(	const float4	val1,
		const float4	val2
	)

inlinestatic

Definition at line 101 of file float.h.

{
    float4      result;
 
    result = val1 + val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();
 
    return result;
}

References fb(), float_overflow_error(), and unlikely.

Referenced by float4pl().

◆ float4in_internal()

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

extern

Definition at line 200 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, fb(), get_float4_infinity(), get_float4_nan(), pg_strncasecmp(), pstrdup(), and val.

Referenced by float4in().

◆ float8_cmp_internal()

int float8_cmp_internal	(	float8	a,
		float8	b
	)

extern

Definition at line 927 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_div()

static float8 float8_div	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 193 of file float.h.

{
    float8      result;
 
    if (unlikely(val2 == 0.0) && !isnan(val1))
        float_zero_divide_error();
    result = val1 / val2;
    if (unlikely(isinf(result)) && !isinf(val1))
        float_overflow_error();
    if (unlikely(result == 0.0) && val1 != 0.0 && !isinf(val2))
        float_underflow_error();
 
    return result;
}

References fb(), float_overflow_error(), float_underflow_error(), float_zero_divide_error(), and unlikely.

Referenced by box_circle(), box_cn(), cash_div_float8(), circle_box(), circle_div_pt(), circle_poly(), degrees(), float48div(), float84div(), float8div(), g_box_consider_split(), line_distance(), line_eq(), line_interpt_line(), line_invsl(), line_perp(), line_sl(), lseg_center(), lseg_inside_poly(), path_area(), point_div_point(), point_invsl(), point_sl(), and poly_to_circle().

◆ float8_eq()

static bool float8_eq	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 223 of file float.h.

{
    return isnan(val1) ? isnan(val2) : !isnan(val2) && val1 == val2;
}

References fb().

Referenced by float48eq(), float84eq(), float8_regr_combine(), float8eq(), gist_box_picksplit(), gist_box_same(), line_eq(), and point_eq_point().

◆ float8_ge()

static bool float8_ge	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 283 of file float.h.

{
    return isnan(val1) || (!isnan(val2) && val1 >= val2);
}

References fb().

Referenced by float48ge(), float84ge(), float8ge(), and gist_box_picksplit().

◆ float8_gt()

static bool float8_gt	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 271 of file float.h.

{
    return !isnan(val2) && (isnan(val1) || val1 > val2);
}

References fb().

Referenced by adjustBox(), box_construct(), float48gt(), float84gt(), float8_cmp_internal(), float8_max(), float8gt(), float8larger(), gist_box_picksplit(), and make_bound_box().

◆ float8_le()

static bool float8_le	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 259 of file float.h.

{
    return isnan(val2) || (!isnan(val1) && val1 <= val2);
}

References fb().

Referenced by float48le(), float84le(), float8le(), gist_box_picksplit(), and size_box().

◆ float8_lt()

static bool float8_lt	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 247 of file float.h.

{
    return !isnan(val1) && (isnan(val2) || val1 < val2);
}

References fb().

Referenced by adjustBox(), box_closept_lseg(), box_closept_point(), box_in(), box_recv(), dist_ppath_internal(), dist_ppoly_internal(), float48lt(), float84lt(), float8_cmp_internal(), float8_min(), float8lt(), float8smaller(), gist_box_picksplit(), lseg_closept_lseg(), make_bound_box(), path_distance(), and poly_distance().

◆ float8_max()

static float8 float8_max	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 307 of file float.h.

{
    return float8_gt(val1, val2) ? val1 : val2;
}

References fb(), and float8_gt().

Referenced by box_interpt_lseg(), box_intersect(), boxes_bound_box(), path_inter(), and rt_box_union().

◆ float8_mi()

static float8 float8_mi	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 137 of file float.h.

{
    float8      result;
 
    result = val1 - val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();
 
    return result;
}

References fb(), float_overflow_error(), and unlikely.

Referenced by box_ht(), box_penalty(), box_wd(), circle_above(), circle_below(), circle_box(), circle_contain(), circle_contained(), circle_distance(), circle_left(), circle_overabove(), circle_overright(), circle_poly(), circle_right(), computeDistance(), dist_cpoint(), dist_cpoly_internal(), dist_pc(), float48mi(), float84mi(), float8mi(), g_box_consider_split(), gist_box_picksplit(), gist_circle_compress(), gist_circle_consistent(), line_construct(), line_distance(), line_interpt_line(), lseg_crossing(), path_area(), point_div_point(), point_dt(), point_inside(), point_invsl(), point_mul_point(), point_sl(), point_sub_point(), and size_box().

◆ float8_min()

static float8 float8_min	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 295 of file float.h.

{
    return float8_lt(val1, val2) ? val1 : val2;
}

References fb(), and float8_lt().

Referenced by box_interpt_lseg(), box_intersect(), boxes_bound_box(), path_inter(), and rt_box_union().

◆ float8_mul()

static float8 float8_mul	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 163 of file float.h.

{
    float8      result;
 
    result = val1 * val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();
    if (unlikely(result == 0.0) && val1 != 0.0 && val2 != 0.0)
        float_underflow_error();
 
    return result;
}

References fb(), float_overflow_error(), float_underflow_error(), and unlikely.

Referenced by box_ar(), cash_mul_float8(), circle_ar(), circle_diameter(), circle_mul_pt(), circle_poly(), float48mul(), float84mul(), float8mul(), line_construct(), line_contain_point(), line_distance(), line_eq(), line_interpt_line(), line_perp(), lseg_crossing(), make_interval(), path_area(), point_div_point(), point_mul_point(), radians(), and size_box().

◆ float8_ne()

static bool float8_ne	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 235 of file float.h.

{
    return isnan(val1) ? !isnan(val2) : isnan(val2) || val1 != val2;
}

References fb().

Referenced by float48ne(), float84ne(), and float8ne().

◆ float8_pl()

static float8 float8_pl	(	const float8	val1,
		const float8	val2
	)

inlinestatic

Definition at line 113 of file float.h.

{
    float8      result;
 
    result = val1 + val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();
 
    return result;
}

References fb(), float_overflow_error(), and unlikely.

Referenced by box_circle(), box_cn(), circle_above(), circle_below(), circle_box(), circle_distance(), circle_left(), circle_overbelow(), circle_overlap(), circle_overleft(), circle_poly(), circle_right(), float48pl(), float84pl(), float8_combine(), float8_regr_combine(), float8pl(), gist_circle_compress(), gist_circle_consistent(), line_contain_point(), line_interpt_line(), lseg_center(), lseg_inside_poly(), on_ppath(), path_area(), path_length(), point_add_point(), point_div_point(), point_mul_point(), and poly_to_circle().

◆ float8in_internal()

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

extern

Definition at line 412 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, fb(), get_float8_infinity(), get_float8_nan(), pg_strncasecmp(), pstrdup(), and val.

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

◆ float8out_internal()

char * float8out_internal ( float8 num )

extern

Definition at line 554 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, fb(), palloc(), and pg_strfromd().

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

◆ float_overflow_error()

pg_noreturn void float_overflow_error ( void )

extern

Definition at line 103 of file float.c.

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

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

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(), and gbt_float8_dist().

◆ float_underflow_error()

pg_noreturn void float_underflow_error ( void )

extern

Definition at line 111 of file float.c.

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

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

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

◆ float_zero_divide_error()

pg_noreturn void float_zero_divide_error ( void )

extern

Definition at line 119 of file float.c.

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

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

Referenced by float4_div(), and float8_div().

◆ get_float4_infinity()

static float4 get_float4_infinity ( void )

inlinestatic

Definition at line 58 of file float.h.

{
    /* C99 standard way */
    return (float4) INFINITY;
}

References fb().

Referenced by float4in_internal(), gistpenalty(), leftmostvalue_float4(), numeric_float4(), and range_gist_penalty().

◆ get_float4_nan()

static float4 get_float4_nan ( void )

inlinestatic

Definition at line 77 of file float.h.

{
    /* C99 standard way */
    return (float4) NAN;
}

References fb().

Referenced by float4in_internal(), and numeric_float4().

◆ get_float8_infinity()

static float8 get_float8_infinity ( void )

inlinestatic

Definition at line 65 of file float.h.

{
    /* C99 standard way */
    return (float8) INFINITY;
}

References fb().

Referenced by brin_minmax_multi_distance_float4(), brin_minmax_multi_distance_float8(), compute_range_stats(), datanh(), dcosh(), dsinh(), float8in_internal(), gbt_ts_dist(), get_distance(), get_distance(), gistindex_keytest(), initRectBox(), leftmostvalue_float8(), line_invsl(), line_sl(), NonFiniteIntervalPart(), NonFiniteTimestampTzPart(), numeric_float8(), point_invsl(), point_sl(), size_box(), spg_kd_inner_consistent(), spg_quad_inner_consistent(), and spgbeginscan().

◆ get_float8_nan()

static float8 get_float8_nan ( void )

inlinestatic

Definition at line 84 of file float.h.

{
    /* C99 standard way */
    return (float8) NAN;
}

References fb().

Referenced by dacos(), dacosd(), dasin(), dasind(), datan(), datan2(), datan2d(), datand(), dcos(), dcosd(), dcot(), dcotd(), dgamma(), dpow(), dsin(), dsind(), dtan(), dtand(), float4_accum(), float8_accum(), float8_regr_accum(), float8_regr_combine(), float8in_internal(), hashfloat4(), hashfloat4extended(), hashfloat8(), hashfloat8extended(), line_closept_point(), numeric_float8(), numeric_float8_no_overflow(), and point_box_distance().

◆ is_infinite()

int is_infinite ( float8 val )

extern

Definition at line 135 of file float.c.

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

References fb(), and val.

Variable Documentation

◆ extra_float_digits

PGDLLIMPORT int extra_float_digits

extern

Definition at line 57 of file float.c.

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

Macros

Functions

Variables

Macro Definition Documentation

◆ M_PI

◆ RADIANS_PER_DEGREE

Function Documentation

◆ float4_cmp_internal()

◆ float4_div()

◆ float4_eq()

◆ float4_ge()

◆ float4_gt()

◆ float4_le()

◆ float4_lt()

◆ float4_max()

◆ float4_mi()

◆ float4_min()

◆ float4_mul()

◆ float4_ne()

◆ float4_pl()

◆ float4in_internal()

◆ float8_cmp_internal()

◆ float8_div()

◆ float8_eq()

◆ float8_ge()

◆ float8_gt()

◆ float8_le()

◆ float8_lt()

◆ float8_max()

◆ float8_mi()

◆ float8_min()

◆ float8_mul()

◆ float8_ne()

◆ float8_pl()

◆ float8in_internal()

◆ float8out_internal()

◆ float_overflow_error()

◆ float_underflow_error()

◆ float_zero_divide_error()

◆ get_float4_infinity()

◆ get_float4_nan()

◆ get_float8_infinity()

◆ get_float8_nan()

◆ is_infinite()

Variable Documentation

◆ extra_float_digits