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
int	is_infinite (float8 val)
float8	float8in_internal (char *num, char **endptr_p, const char *type_name, const char *orig_string)
float8	float8in_internal_opt_error (char *num, char **endptr_p, const char *type_name, const char *orig_string, bool *have_error)
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 void	check_float4_val (const float4 val, const bool inf_is_valid, const bool zero_is_valid)
static void	check_float8_val (const float8 val, const bool inf_is_valid, const bool zero_is_valid)
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.

Referenced by cosd_0_to_60(), degrees(), init_degree_constants(), radians(), and sind_0_to_30().

Function Documentation

check_float4_val()

static void check_float4_val ( const float4  val, const bool  inf_is_valid, const bool  zero_is_valid  )

inlinestatic

Definition at line 136 of file float.h.

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

Referenced by dtof(), float4_div(), float4_mi(), float4_mul(), and float4_pl().

{
    if (!inf_is_valid && unlikely(isinf(val)))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value out of range: overflow")));

    if (!zero_is_valid && unlikely(val == 0.0))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value out of range: underflow")));
}

check_float8_val()

static void check_float8_val ( const float8  val, const bool  inf_is_valid, const bool  zero_is_valid  )

inlinestatic

Definition at line 151 of file float.h.

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

Referenced by dacos(), dacosd(), dacosh(), dasin(), dasind(), dasinh(), datan(), datan2(), datan2d(), datand(), datanh(), dcbrt(), dcos(), dcosd(), dcosh(), dcot(), dcotd(), dexp(), dlog1(), dlog10(), dpow(), dsin(), dsind(), dsinh(), dsqrt(), dtan(), dtand(), dtanh(), float8_combine(), float8_div(), float8_mi(), float8_mul(), float8_pl(), float8_regr_combine(), and pg_hypot().

{
    if (!inf_is_valid && unlikely(isinf(val)))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value out of range: overflow")));

    if (!zero_is_valid && unlikely(val == 0.0))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value out of range: underflow")));
}

float4_cmp_internal()

int float4_cmp_internal	(	float4	a,
		float4	b
	)

Definition at line 825 of file float.c.

References float4_gt(), and float4_lt().

Referenced by btfloat4cmp(), and btfloat4fastcmp().

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

float4_div()

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

inlinestatic

Definition at line 244 of file float.h.

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

Referenced by float4div(), and g_box_consider_split().

{
    float4      result;

    if (val2 == 0.0f)
        ereport(ERROR,
                (errcode(ERRCODE_DIVISION_BY_ZERO),
                 errmsg("division by zero")));

    result = val1 / val2;
    check_float4_val(result, isinf(val1) || isinf(val2), val1 == 0.0f);

    return result;
}

float4_eq()

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

inlinestatic

Definition at line 284 of file float.h.

Referenced by float4eq().

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

float4_ge()

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

inlinestatic

Definition at line 344 of file float.h.

Referenced by float4ge().

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

float4_gt()

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

inlinestatic

Definition at line 332 of file float.h.

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

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

float4_le()

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

inlinestatic

Definition at line 320 of file float.h.

Referenced by float4le().

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

float4_lt()

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

inlinestatic

Definition at line 308 of file float.h.

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

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

float4_max()

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

inlinestatic

Definition at line 368 of file float.h.

References float4_gt().

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

float4_mi()

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

inlinestatic

Definition at line 198 of file float.h.

References check_float4_val(), and isinf().

Referenced by float4mi().

{
    float4      result;

    result = val1 - val2;
    check_float4_val(result, isinf(val1) || isinf(val2), true);

    return result;
}

float4_min()

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

inlinestatic

Definition at line 356 of file float.h.

References float4_lt().

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

float4_mul()

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

inlinestatic

Definition at line 220 of file float.h.

References check_float4_val(), and isinf().

Referenced by float4mul().

{
    float4      result;

    result = val1 * val2;
    check_float4_val(result, isinf(val1) || isinf(val2),
                     val1 == 0.0f || val2 == 0.0f);

    return result;
}

float4_ne()

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

inlinestatic

Definition at line 296 of file float.h.

Referenced by float4ne().

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

float4_pl()

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

inlinestatic

Definition at line 176 of file float.h.

References check_float4_val(), and isinf().

Referenced by float4pl().

{
    float4      result;

    result = val1 + val2;
    check_float4_val(result, isinf(val1) || isinf(val2), true);

    return result;
}

float8_cmp_internal()

int float8_cmp_internal	(	float8	a,
		float8	b
	)

Definition at line 919 of file float.c.

References float8_gt(), and float8_lt().

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

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

float8_div()

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

inlinestatic

Definition at line 260 of file float.h.

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

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      result;

    if (val2 == 0.0)
        ereport(ERROR,
                (errcode(ERRCODE_DIVISION_BY_ZERO),
                 errmsg("division by zero")));

    result = val1 / val2;
    check_float8_val(result, isinf(val1) || isinf(val2), val1 == 0.0);

    return result;
}

float8_eq()

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

inlinestatic

Definition at line 290 of file float.h.

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

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

float8_ge()

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

inlinestatic

Definition at line 350 of file float.h.

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

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

float8_gt()

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

inlinestatic

Definition at line 338 of file float.h.

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

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

float8_le()

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

inlinestatic

Definition at line 326 of file float.h.

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

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

float8_lt()

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

inlinestatic

Definition at line 314 of file float.h.

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

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

float8_max()

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

inlinestatic

Definition at line 374 of file float.h.

References float8_gt().

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

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

float8_mi()

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

inlinestatic

Definition at line 209 of file float.h.

References check_float8_val(), and isinf().

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      result;

    result = val1 - val2;
    check_float8_val(result, isinf(val1) || isinf(val2), true);

    return result;
}

float8_min()

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

inlinestatic

Definition at line 362 of file float.h.

References float8_lt().

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

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

float8_mul()

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

inlinestatic

Definition at line 232 of file float.h.

References check_float8_val(), and isinf().

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      result;

    result = val1 * val2;
    check_float8_val(result, isinf(val1) || isinf(val2),
                     val1 == 0.0 || val2 == 0.0);

    return result;
}

float8_ne()

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

inlinestatic

Definition at line 302 of file float.h.

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

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

float8_pl()

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

inlinestatic

Definition at line 187 of file float.h.

References check_float8_val(), and isinf().

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

{
    float8      result;

    result = val1 + val2;
    check_float8_val(result, isinf(val1) || isinf(val2), true);

    return result;
}

float8in_internal()

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

Definition at line 518 of file float.c.

References float8in_internal_opt_error().

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

{
    return float8in_internal_opt_error(num, endptr_p, type_name,
                                       orig_string, NULL);
}

float8in_internal_opt_error()

float8 float8in_internal_opt_error	(	char *	num,
		char **	endptr_p,
		const char *	type_name,
		const char *	orig_string,
		bool *	have_error
	)

Definition at line 372 of file float.c.

References ereport, errcode(), errmsg(), ERROR, get_float8_infinity(), get_float8_nan(), pg_strncasecmp(), pstrdup(), RETURN_ERROR, and val.

Referenced by executeItemOptUnwrapTarget(), and float8in_internal().

{
    double      val;
    char       *endptr;

    if (have_error)
        *have_error = false;

    /* 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')
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                              errmsg("invalid input syntax for type %s: \"%s\"",
                                     type_name, orig_string))),
                     have_error);

    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';
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                                      errmsg("\"%s\" is out of range for type double precision",
                                             errnumber))),
                             have_error);
            }
        }
        else
            RETURN_ERROR(ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                  errmsg("invalid input syntax for type "
                                         "%s: \"%s\"",
                                         type_name, orig_string))),
                         have_error);
    }
#ifdef HAVE_BUGGY_SOLARIS_STRTOD
    else
    {
        /*
         * Many versions of Solaris have a bug wherein strtod sets endptr to
         * point one byte beyond the end of the string when given "inf" or
         * "infinity".
         */
        if (endptr != num && endptr[-1] == '\0')
            endptr--;
    }
#endif                          /* HAVE_BUGGY_SOLARIS_STRTOD */

    /* 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')
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                              errmsg("invalid input syntax for type "
                                     "%s: \"%s\"",
                                     type_name, orig_string))),
                     have_error);

    return val;
}

float8out_internal()

char* float8out_internal

(

float8

num

)

Definition at line 546 of file float.c.

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

{
    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;
}

get_float4_infinity()

static float4 get_float4_infinity ( void  )

inlinestatic

Definition at line 70 of file float.h.

Referenced by float4in(), gistpenalty(), leftmostvalue_float4(), and range_gist_penalty().

{
#ifdef INFINITY
    /* C99 standard way */
    return (float4) INFINITY;
#else
#if (_MSC_VER >= 1800)
#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
}

get_float4_nan()

static float4 get_float4_nan ( void  )

inlinestatic

Definition at line 107 of file float.h.

Referenced by float4in(), and numeric_float4().

{
#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
}

get_float8_infinity()

static float8 get_float8_infinity ( void  )

inlinestatic

Definition at line 90 of file float.h.

Referenced by compute_range_stats(), datanh(), dcosh(), dexp(), dpow(), dsinh(), float8in_internal_opt_error(), gbt_ts_dist(), get_distance(), gistindex_keytest(), initRectBox(), leftmostvalue_float8(), NonFiniteTimestampTzPart(), pg_hypot(), size_box(), spg_kd_inner_consistent(), spg_quad_inner_consistent(), and spgbeginscan().

{
#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
}

get_float8_nan()

static float8 get_float8_nan ( void  )

inlinestatic

Definition at line 119 of file float.h.

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_opt_error(), line_closept_point(), numeric_float8(), numeric_float8_no_overflow(), pg_hypot(), and point_box_distance().

{
    /* (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
}

is_infinite()

int is_infinite

(

float8

val

)

Definition at line 97 of file float.c.

References isinf().

{
    int         inf = isinf(val);

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

Variable Documentation

extra_float_digits

PGDLLIMPORT int extra_float_digits

Definition at line 42 of file float.c.

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