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 815 of file float.c.

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

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

Referenced by btfloat4cmp(), and btfloat4fastcmp().

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 909 of file float.c.

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

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

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

float8_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 394 of file float.c.

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

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

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

float8out_internal()

char* float8out_internal

(

float8

num

)

Definition at line 536 of file float.c.

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

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

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

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(), derf(), derfc(), dexp(), dlog1(), dlog10(), dpow(), dsin(), dsind(), dsqrt(), dtanh(), dtof(), float4_accum(), float4_dist(), float4_div(), float4_mi(), float4_mul(), float4_pl(), float8_accum(), float8_combine(), float8_dist(), float8_div(), float8_mi(), float8_mul(), float8_pl(), float8_regr_accum(), float8_regr_combine(), gbt_float8_dist(), and pg_hypot().

float_underflow_error()

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