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

float4_cmp_internal()

int float4_cmp_internal	(	float4	a,
		float4	b
	)

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

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

Referenced by float4div(), and g_box_consider_split().

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

float4_eq()

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

inlinestatic

Definition at line 261 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 321 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 309 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 297 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 285 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 345 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 169 of file float.h.

References float_overflow_error(), and unlikely.

Referenced by float4mi().

{
    float4      result;

    result = val1 - val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();

    return result;
}

float4_min()

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

inlinestatic

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

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

Referenced by float4mul().

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

float4_ne()

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

inlinestatic

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

References float_overflow_error(), and unlikely.

Referenced by float4pl().

{
    float4      result;

    result = val1 + val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();

    return result;
}

float8_cmp_internal()

int float8_cmp_internal	(	float8	a,
		float8	b
	)

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

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

float8_eq()

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

inlinestatic

Definition at line 267 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 327 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 315 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 303 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 291 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 351 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 181 of file float.h.

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

    result = val1 - val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();

    return result;
}

float8_min()

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

inlinestatic

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

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

float8_ne()

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

inlinestatic

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

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

{
    float8      result;

    result = val1 + val2;
    if (unlikely(isinf(result)) && !isinf(val1) && !isinf(val2))
        float_overflow_error();

    return result;
}

float8in_internal()

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

Definition at line 513 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 379 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);
    }

    /* 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 541 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;
}

float_overflow_error()

void float_overflow_error

(

void

)

Definition at line 84 of file float.c.

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

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

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

float_underflow_error()

void float_underflow_error

(

void

)

Definition at line 92 of file float.c.

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

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

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

float_zero_divide_error()

void float_zero_divide_error

(

void

)

Definition at line 100 of file float.c.

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

Referenced by float4_div(), and float8_div().

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

get_float4_infinity()

static float4 get_float4_infinity ( void  )

inlinestatic

Definition at line 73 of file float.h.

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

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

get_float4_nan()

static float4 get_float4_nan ( void  )

inlinestatic

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

Referenced by compute_range_stats(), datanh(), dcosh(), dsinh(), float8in_internal_opt_error(), 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().

{
#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 122 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(), hashfloat4(), hashfloat4extended(), hashfloat8(), hashfloat8extended(), 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 116 of file float.c.

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