add hyphen in floating-point · patricklam/verify-rust-std@081353c (original) (raw)

`@@ -1127,7 +1127,7 @@ impl (T,) {}

1127

1128

`#[rustc_doc_primitive = "f16"]

1129

`#[doc(alias = "half")]

1130

/// A 16-bit floating point type (specifically, the "binary16" type defined in IEEE 754-2008).

1130

/// A 16-bit floating-point type (specifically, the "binary16" type defined in IEEE 754-2008).

1131

`///

1132

`` /// This type is very similar to [prim@f32] but has decreased precision because it uses half as many

1133

`` /// bits. Please see the documentation for f32 or [Wikipedia on half-precision

`@@ -1147,11 +1147,11 @@ mod prim_f16 {}

1147

1148

`#[rustc_doc_primitive = "f32"]

1149

`#[doc(alias = "single")]

1150

/// A 32-bit floating point type (specifically, the "binary32" type defined in IEEE 754-2008).

1150

/// A 32-bit floating-point type (specifically, the "binary32" type defined in IEEE 754-2008).

1151

`///

1152

`` /// This type can represent a wide range of decimal numbers, like 3.5, 27,

1153

`` /// -113.75, 0.0078125, 34359738368, 0, -1. So unlike integer types

1154

`` -

/// (such as i32), floating point types can represent non-integer numbers,

1154

`` +

/// (such as i32), floating-point types can represent non-integer numbers,

1155

`/// too.

1156

`///

1157

`/// However, being able to represent this wide range of numbers comes at the

`@@ -1165,8 +1165,8 @@ mod prim_f16 {}

1165

`///

1166

`` /// Additionally, f32 can represent some special values:

1167

`///

1168

/// - −0.0: IEEE 754 floating point numbers have a bit that indicates their sign, so −0.0 is a

1169

/// possible value. For comparison −0.0 = +0.0, but floating point operations can carry

1168

/// - −0.0: IEEE 754 floating-point numbers have a bit that indicates their sign, so −0.0 is a

1169

/// possible value. For comparison −0.0 = +0.0, but floating-point operations can carry

1170

`/// the sign bit through arithmetic operations. This means −0.0 × +0.0 produces −0.0 and

1171

`/// a negative number rounded to a value smaller than a float can represent also produces −0.0.

1172

`/// - ∞ and

`@@ -1211,17 +1211,17 @@ mod prim_f16 {}

1211

`` /// both arguments were negative, then it is -0.0. Subtraction a - b is

1212

`` /// regarded as a sum a + (-b).

1213

`///

1214

/// For more information on floating point numbers, see [Wikipedia][wikipedia].

1214

/// For more information on floating-point numbers, see [Wikipedia][wikipedia].

1215

`///

1216

1217

`///

1218

`/// [wikipedia]: https://en.wikipedia.org/wiki/Single-precision_floating-point_format

1219

`///

1220

`/// # NaN bit patterns

1221

`///

1222

/// This section defines the possible NaN bit patterns returned by floating point operations.

1222

/// This section defines the possible NaN bit patterns returned by floating-point operations.

1223

`///

1224

/// The bit pattern of a floating point NaN value is defined by:

1224

/// The bit pattern of a floating-point NaN value is defined by:

1225

`/// - a sign bit.

1226

`` /// - a quiet/signaling bit. Rust assumes that the quiet/signaling bit being set to 1 indicates a

1227

`` /// quiet NaN (QNaN), and a value of 0 indicates a signaling NaN (SNaN). In the following we

`@@ -1262,7 +1262,7 @@ mod prim_f16 {}

1262

`/// does not have any "extra" NaN payloads, then the output NaN is guaranteed to be preferred.

1263

`///

1264

`/// The non-deterministic choice happens when the operation is executed; i.e., the result of a

1265

/// NaN-producing floating point operation is a stable bit pattern (looking at these bits multiple

1265

/// NaN-producing floating-point operation is a stable bit pattern (looking at these bits multiple

1266

`/// times will yield consistent results), but running the same operation twice with the same inputs

1267

`/// can produce different results.

1268

`///

`@@ -1276,7 +1276,7 @@ mod prim_f16 {}

1276

`` /// (e.g. min, minimum, max, maximum); other aspects of their semantics and which IEEE 754

1277

`/// operation they correspond to are documented with the respective functions.

1278

`///

1279

`` -

/// When an arithmetic floating point operation is executed in const context, the same rules

1279

`` +

/// When an arithmetic floating-point operation is executed in const context, the same rules

1280

`/// apply: no guarantee is made about which of the NaN bit patterns described above will be

1281

`/// returned. The result does not have to match what happens when executing the same code at

1282

`/// runtime, and the result can vary depending on factors such as compiler version and flags.

`@@ -1297,7 +1297,7 @@ mod prim_f32 {}

1297

1298

`#[rustc_doc_primitive = "f64"]

1299

`#[doc(alias = "double")]

1300

/// A 64-bit floating point type (specifically, the "binary64" type defined in IEEE 754-2008).

1300

/// A 64-bit floating-point type (specifically, the "binary64" type defined in IEEE 754-2008).

1301

`///

1302

`` /// This type is very similar to [prim@f32], but has increased precision by using twice as many

1303

`` /// bits. Please see the documentation for f32 or [Wikipedia on double-precision

`@@ -1311,7 +1311,7 @@ mod prim_f64 {}

1311

1312

`#[rustc_doc_primitive = "f128"]

1313

`#[doc(alias = "quad")]

1314

/// A 128-bit floating point type (specifically, the "binary128" type defined in IEEE 754-2008).

1314

/// A 128-bit floating-point type (specifically, the "binary128" type defined in IEEE 754-2008).

1315

`///

1316

`` /// This type is very similar to [prim@f32] and [prim@f64], but has increased precision by using twice

1317

`` /// as many bits as f64. Please see the documentation for f32 or [Wikipedia on