#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)

float8	float_overflow_error_ext (struct Node *escontext)

float8	float_underflow_error_ext (struct Node *escontext)

float8	float_zero_divide_error_ext (struct Node *escontext)

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_safe (const float8 val1, const float8 val2, struct Node *escontext)

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

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

static float8	float8_mi_safe (const float8 val1, const float8 val2, struct Node *escontext)

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

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

static float8	float8_mul_safe (const float8 val1, const float8 val2, struct Node *escontext)

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

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

static float8	float8_div_safe (const float8 val1, const float8 val2, struct Node *escontext)

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 857 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 198 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(), result, 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 244 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 304 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 292 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 280 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 268 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 328 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 134 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(), result, and unlikely.

Referenced by float4mi().

◆ float4_min()

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

inlinestatic

Definition at line 316 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 164 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(), result, and unlikely.

Referenced by float4mul().

◆ float4_ne()

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

inlinestatic

Definition at line 256 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 104 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(), result, 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 224 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 951 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 230 of file float.h.

{
    return float8_div_safe(val1, val2, NULL);
}

References fb(), and float8_div_safe().

Referenced by cash_div_float8(), circle_div_pt(), circle_poly_internal(), degrees(), float48div(), float84div(), float8div(), g_box_consider_split(), line_distance(), line_eq(), line_interpt_line(), line_invsl(), line_perp(), line_sl(), lseg_inside_poly(), path_area(), point_div_point(), point_invsl(), and point_sl().

◆ float8_div_safe()

static float8 float8_div_safe	(	const float8	val1,
		const float8	val2,
		struct Node *	escontext
	)

inlinestatic

Definition at line 214 of file float.h.

{
    float8      result;
 
    if (unlikely(val2 == 0.0) && !isnan(val1))
        return float_zero_divide_error_ext(escontext);
    result = val1 / val2;
    if (unlikely(isinf(result)) && !isinf(val1))
        return float_overflow_error_ext(escontext);
    if (unlikely(result == 0.0) && val1 != 0.0 && !isinf(val2))
        return float_underflow_error_ext(escontext);
 
    return result;
}

References fb(), float_overflow_error_ext(), float_underflow_error_ext(), float_zero_divide_error_ext(), result, and unlikely.

Referenced by box_circle(), box_cn(), circle_box(), float8_div(), lseg_center(), and poly_to_circle().

◆ float8_eq()

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

inlinestatic

Definition at line 250 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 310 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 298 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 286 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 274 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 334 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 158 of file float.h.

{
    return float8_mi_safe(val1, val2, NULL);
}

References fb(), and float8_mi_safe().

Referenced by box_ht(), box_penalty(), box_wd(), circle_above(), circle_below(), circle_contain(), circle_contained(), circle_distance(), circle_left(), circle_overabove(), circle_overright(), 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_inside(), point_invsl(), point_mul_point(), point_sl(), point_sub_point(), and size_box().

◆ float8_mi_safe()

static float8 float8_mi_safe	(	const float8	val1,
		const float8	val2,
		struct Node *	escontext
	)

inlinestatic

Definition at line 146 of file float.h.

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

References fb(), float_overflow_error_ext(), result, and unlikely.

Referenced by circle_box(), circle_poly_internal(), float8_mi(), and point_dt().

◆ float8_min()

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

inlinestatic

Definition at line 322 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 192 of file float.h.

{
    return float8_mul_safe(val1, val2, NULL);
}

References fb(), and float8_mul_safe().

Referenced by box_ar(), cash_mul_float8(), circle_ar(), circle_diameter(), circle_mul_pt(), 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_mul_safe()

static float8 float8_mul_safe	(	const float8	val1,
		const float8	val2,
		struct Node *	escontext
	)

inlinestatic

Definition at line 178 of file float.h.

{
    float8      result;
 
    result = val1 * val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        return float_overflow_error_ext(escontext);
    if (unlikely(result == 0.0) && val1 != 0.0 && val2 != 0.0)
        return float_underflow_error_ext(escontext);
 
    return result;
}

References fb(), float_overflow_error_ext(), float_underflow_error_ext(), result, and unlikely.

Referenced by circle_poly_internal(), and float8_mul().

◆ float8_ne()

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

inlinestatic

Definition at line 262 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 128 of file float.h.

{
    return float8_pl_safe(val1, val2, NULL);
}

References fb(), and float8_pl_safe().

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

◆ float8_pl_safe()

static float8 float8_pl_safe	(	const float8	val1,
		const float8	val2,
		struct Node *	escontext
	)

inlinestatic

Definition at line 116 of file float.h.

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

References fb(), float_overflow_error_ext(), result, and unlikely.

Referenced by box_circle(), box_cn(), circle_box(), circle_poly_internal(), float8_pl(), lseg_center(), point_add_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 436 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 578 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(), float4_accum(), float4_dist(), float4_div(), float4_mi(), float4_mul(), float4_pl(), float8_accum(), float8_combine(), float8_dist(), float8_regr_accum(), float8_regr_combine(), and gbt_float8_dist().

◆ float_overflow_error_ext()

float8 float_overflow_error_ext ( struct Node * escontext )

extern

Definition at line 127 of file float.c.

{
    ereturn(escontext, 0.0,
            errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
            errmsg("value out of range: overflow"));
}

References ereturn, errcode(), errmsg, and fb().

Referenced by dtof(), float8_div_safe(), float8_mi_safe(), float8_mul_safe(), and float8_pl_safe().

◆ 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(), float4_div(), and float4_mul().

◆ float_underflow_error_ext()

float8 float_underflow_error_ext ( struct Node * escontext )

extern

Definition at line 135 of file float.c.

{
    ereturn(escontext, 0.0,
            errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
            errmsg("value out of range: underflow"));
}

References ereturn, errcode(), errmsg, and fb().

Referenced by dtof(), float8_div_safe(), and float8_mul_safe().

◆ 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().

◆ float_zero_divide_error_ext()

float8 float_zero_divide_error_ext ( struct Node * escontext )

extern

Definition at line 143 of file float.c.

{
    ereturn(escontext, 0.0,
            (errcode(ERRCODE_DIVISION_BY_ZERO),
             errmsg("division by zero")));
}

References ereturn, errcode(), errmsg, and fb().

Referenced by float8_div_safe().

◆ get_float4_infinity()

static float4 get_float4_infinity ( void )

inlinestatic

Definition at line 61 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 80 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 68 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 87 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 159 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_div_safe()

◆ float8_eq()

◆ float8_ge()

◆ float8_gt()

◆ float8_le()

◆ float8_lt()

◆ float8_max()

◆ float8_mi()

◆ float8_mi_safe()

◆ float8_min()

◆ float8_mul()

◆ float8_mul_safe()

◆ float8_ne()

◆ float8_pl()

◆ float8_pl_safe()

◆ float8in_internal()

◆ float8out_internal()

◆ float_overflow_error()

◆ float_overflow_error_ext()

◆ float_underflow_error()

◆ float_underflow_error_ext()

◆ float_zero_divide_error()

◆ float_zero_divide_error_ext()

◆ get_float4_infinity()

◆ get_float4_nan()

◆ get_float8_infinity()

◆ get_float8_nan()

◆ is_infinite()

Variable Documentation

◆ extra_float_digits