float.h File Reference

#include <math.h>

Include dependency graph for float.h:

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

Go to the source code of this file.

Macros
#define	M_PI   3.14159265358979323846
#define	RADIANS_PER_DEGREE   0.0174532925199432957692

Functions
void	float_overflow_error (void) pg_attribute_noreturn()
void	float_underflow_error (void) pg_attribute_noreturn()
void	float_zero_divide_error (void) pg_attribute_noreturn()
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
	)

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

float4_div()

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

inlinestatic

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

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

Referenced by float4eq().

float4_ge()

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

inlinestatic

Definition at line 322 of file float.h.

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

Referenced by float4ge().

float4_gt()

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

inlinestatic

Definition at line 310 of file float.h.

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

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 298 of file float.h.

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

Referenced by float4le().

float4_lt()

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

inlinestatic

Definition at line 286 of file float.h.

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

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 346 of file float.h.

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

References float4_gt().

float4_mi()

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

inlinestatic

Definition at line 170 of file float.h.

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

References float_overflow_error(), and unlikely.

Referenced by float4mi().

float4_min()

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

inlinestatic

Definition at line 334 of file float.h.

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

References float4_lt().

float4_mul()

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

inlinestatic

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

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

Referenced by float4ne().

float4_pl()

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

inlinestatic

Definition at line 146 of file float.h.

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

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

Definition at line 182 of file float.c.

{
    float       val;
    char       *endptr;
 
    /*
     * endptr points to the first character _after_ the sequence we recognized
     * as a valid floating point number. orig_string points to the original
     * input
     * string.
     */
 
    /* skip leading whitespace */
    while (*num != '\0' && isspace((unsigned char) *num))
        num++;
 
    /*
     * Check for an empty-string input to begin with, to avoid the vagaries of
     * strtod() on different platforms.
     */
    if (*num == '\0')
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        type_name, orig_string)));
 
    errno = 0;
    val = strtof(num, &endptr);
 
    /* did we not see anything that looks like a double? */
    if (endptr == num || errno != 0)
    {
        int         save_errno = errno;
 
        /*
         * C99 requires that strtof() accept NaN, [+-]Infinity, and [+-]Inf,
         * but not all platforms support all of these (and some accept them
         * but set ERANGE anyway...)  Therefore, we check for these inputs
         * ourselves if strtof() fails.
         *
         * Note: C99 also requires hexadecimal input as well as some extended
         * forms of NaN, but we consider these forms unportable and don't try
         * to support them.  You can use 'em if your strtof() takes 'em.
         */
        if (pg_strncasecmp(num, "NaN", 3) == 0)
        {
            val = get_float4_nan();
            endptr = num + 3;
        }
        else if (pg_strncasecmp(num, "Infinity", 8) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 8;
        }
        else if (pg_strncasecmp(num, "+Infinity", 9) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 9;
        }
        else if (pg_strncasecmp(num, "-Infinity", 9) == 0)
        {
            val = -get_float4_infinity();
            endptr = num + 9;
        }
        else if (pg_strncasecmp(num, "inf", 3) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 3;
        }
        else if (pg_strncasecmp(num, "+inf", 4) == 0)
        {
            val = get_float4_infinity();
            endptr = num + 4;
        }
        else if (pg_strncasecmp(num, "-inf", 4) == 0)
        {
            val = -get_float4_infinity();
            endptr = num + 4;
        }
        else if (save_errno == ERANGE)
        {
            /*
             * Some platforms return ERANGE for denormalized numbers (those
             * that are not zero, but are too close to zero to have full
             * precision).  We'd prefer not to throw error for that, so try to
             * detect whether it's a "real" out-of-range condition by checking
             * to see if the result is zero or huge.
             */
            if (val == 0.0 ||
#if !defined(HUGE_VALF)
                isinf(val)
#else
                (val >= HUGE_VALF || val <= -HUGE_VALF)
#endif
                )
            {
                /* see comments in float8in_internal for rationale */
                char       *errnumber = pstrdup(num);
 
                errnumber[endptr - num] = '\0';
 
                ereturn(escontext, 0,
                        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                         errmsg("\"%s\" is out of range for type real",
                                errnumber)));
            }
        }
        else
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            type_name, orig_string)));
    }
 
    /* skip trailing whitespace */
    while (*endptr != '\0' && isspace((unsigned char) *endptr))
        endptr++;
 
    /* report stopping point if wanted, else complain if not end of string */
    if (endptr_p)
        *endptr_p = endptr;
    else if (*endptr != '\0')
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        type_name, orig_string)));
 
    return val;
}

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

Referenced by float4in().

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(), 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 238 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 float_overflow_error(), float_underflow_error(), float_zero_divide_error(), and unlikely.

Referenced by box_circle(), box_cn(), 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 268 of file float.h.

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

Referenced by float48eq(), float84eq(), 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 328 of file float.h.

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

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 316 of file float.h.

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

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 304 of file float.h.

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

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 292 of file float.h.

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

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 352 of file float.h.

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

References 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 182 of file float.h.

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

References 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 340 of file float.h.

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

References 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 208 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 float_overflow_error(), float_underflow_error(), and unlikely.

Referenced by box_ar(), 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(), 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 280 of file float.h.

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

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

float8_pl()

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

inlinestatic

Definition at line 158 of file float.h.

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

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

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

float8out_internal()

char* float8out_internal

(

float8

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

float_overflow_error()

void float_overflow_error

(

void

)

Definition at line 85 of file float.c.

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

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

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

float_underflow_error()

void float_underflow_error

(

void

)

Definition at line 93 of file float.c.

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

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

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

float_zero_divide_error()

void float_zero_divide_error

(

void

)

Definition at line 101 of file float.c.

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

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

Referenced by float4_div(), and float8_div().

get_float4_infinity()

static float4 get_float4_infinity ( void  )

inlinestatic

Definition at line 74 of file float.h.

{
#ifdef INFINITY
    /* C99 standard way */
    return (float4) INFINITY;
#else
#ifdef _MSC_VER
#pragma warning(default:4756)
#endif
 
    /*
     * On some platforms, HUGE_VAL is an infinity, elsewhere it's just the
     * largest normal float8.  We assume forcing an overflow will get us a
     * true infinity.
     */
    return (float4) (HUGE_VAL * HUGE_VAL);
#endif
}

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 111 of file float.h.

{
#ifdef NAN
    /* C99 standard way */
    return (float4) NAN;
#else
    /* Assume we can get a NAN via zero divide */
    return (float4) (0.0 / 0.0);
#endif
}

Referenced by float4in_internal(), and numeric_float4().

get_float8_infinity()

static float8 get_float8_infinity ( void  )

inlinestatic

Definition at line 94 of file float.h.

{
#ifdef INFINITY
    /* C99 standard way */
    return (float8) INFINITY;
#else
 
    /*
     * On some platforms, HUGE_VAL is an infinity, elsewhere it's just the
     * largest normal float8.  We assume forcing an overflow will get us a
     * true infinity.
     */
    return (float8) (HUGE_VAL * HUGE_VAL);
#endif
}

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(), gistindex_keytest(), initRectBox(), leftmostvalue_float8(), line_invsl(), line_sl(), NonFiniteTimestampTzPart(), numeric_float8(), pg_hypot(), 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 123 of file float.h.

{
    /* (float8) NAN doesn't work on some NetBSD/MIPS releases */
#if defined(NAN) && !(defined(__NetBSD__) && defined(__mips__))
    /* C99 standard way */
    return (float8) NAN;
#else
    /* Assume we can get a NaN via zero divide */
    return (float8) (0.0 / 0.0);
#endif
}

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

is_infinite()

int is_infinite

(

float8

val

)

Definition at line 117 of file float.c.

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

References val.

Variable Documentation

extra_float_digits

PGDLLIMPORT int extra_float_digits

extern

Definition at line 43 of file float.c.

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