1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
//! `f64` 双精度浮点类型的常量。
//!
//! *[See also the `f64` primitive type][f64].*
//!
//! `consts` 子模块中提供了数学上有效的数字。
//!
//! 对于直接在此模块中定义的常量 (不同于 `consts` 子模块中定义的常量),新代码应改为使用直接在 `f64` 类型上定义的关联常量。
//!
//!
//!

#![stable(feature = "rust1", since = "1.0.0")]

use crate::convert::FloatToInt;
#[cfg(not(test))]
use crate::intrinsics;
use crate::mem;
use crate::num::FpCategory;

/// `f64` 内部表示形式的基数或基数。
/// 请改用 [`f64::RADIX`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let r = std::f64::RADIX;
///
/// // 预期的方式
/// let r = f64::RADIX;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `RADIX` associated constant on `f64`")]
pub const RADIX: u32 = f64::RADIX;

/// 基数中的有效位数 2.
/// 请改用 [`f64::MANTISSA_DIGITS`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let d = std::f64::MANTISSA_DIGITS;
///
/// // 预期的方式
/// let d = f64::MANTISSA_DIGITS;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(
    since = "TBD",
    note = "replaced by the `MANTISSA_DIGITS` associated constant on `f64`"
)]
pub const MANTISSA_DIGITS: u32 = f64::MANTISSA_DIGITS;

/// 以 10 为基数的有效位数的大概数字。
/// 请改用 [`f64::DIGITS`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let d = std::f64::DIGITS;
///
/// // 预期的方式
/// let d = f64::DIGITS;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `DIGITS` associated constant on `f64`")]
pub const DIGITS: u32 = f64::DIGITS;

/// `f64` 的 [机器精度][Machine epsilon] 值。
/// 请改用 [`f64::EPSILON`]。
///
/// 这是 `1.0` 与下一个较大的可表示数字之间的差异。
///
/// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let e = std::f64::EPSILON;
///
/// // 预期的方式
/// let e = f64::EPSILON;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `EPSILON` associated constant on `f64`")]
pub const EPSILON: f64 = f64::EPSILON;

/// 最小的 `f64` 有限值。
/// 请改用 [`f64::MIN`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN;
///
/// // 预期的方式
/// let min = f64::MIN;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN` associated constant on `f64`")]
pub const MIN: f64 = f64::MIN;

/// 最小正 `f64` 正值。
/// 请改用 [`f64::MIN_POSITIVE`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN_POSITIVE;
///
/// // 预期的方式
/// let min = f64::MIN_POSITIVE;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN_POSITIVE` associated constant on `f64`")]
pub const MIN_POSITIVE: f64 = f64::MIN_POSITIVE;

/// 最大的有限 `f64` 值。
/// 请改用 [`f64::MAX`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let max = std::f64::MAX;
///
/// // 预期的方式
/// let max = f64::MAX;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MAX` associated constant on `f64`")]
pub const MAX: f64 = f64::MAX;

/// 比 2 的最小可能标准幂大一。
/// 请改用 [`f64::MIN_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN_EXP;
///
/// // 预期的方式
/// let min = f64::MIN_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN_EXP` associated constant on `f64`")]
pub const MIN_EXP: i32 = f64::MIN_EXP;

/// 2 指数的最大可能乘方。
/// 请改用 [`f64::MAX_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let max = std::f64::MAX_EXP;
///
/// // 预期的方式
/// let max = f64::MAX_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MAX_EXP` associated constant on `f64`")]
pub const MAX_EXP: i32 = f64::MAX_EXP;

/// 最小可能的标准幂为 10 指数。
/// 请改用 [`f64::MIN_10_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN_10_EXP;
///
/// // 预期的方式
/// let min = f64::MIN_10_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN_10_EXP` associated constant on `f64`")]
pub const MIN_10_EXP: i32 = f64::MIN_10_EXP;

/// 最大可能功效为 10 指数。
/// 请改用 [`f64::MAX_10_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let max = std::f64::MAX_10_EXP;
///
/// // 预期的方式
/// let max = f64::MAX_10_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MAX_10_EXP` associated constant on `f64`")]
pub const MAX_10_EXP: i32 = f64::MAX_10_EXP;

/// 不是数字 (NaN)。
/// 请改用 [`f64::NAN`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let nan = std::f64::NAN;
///
/// // 预期的方式
/// let nan = f64::NAN;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `NAN` associated constant on `f64`")]
pub const NAN: f64 = f64::NAN;

/// 无限 (∞)。
/// 请改用 [`f64::INFINITY`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let inf = std::f64::INFINITY;
///
/// // 预期的方式
/// let inf = f64::INFINITY;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `INFINITY` associated constant on `f64`")]
pub const INFINITY: f64 = f64::INFINITY;

/// 负无穷大 (−∞)。
/// 请改用 [`f64::NEG_INFINITY`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let ninf = std::f64::NEG_INFINITY;
///
/// // 预期的方式
/// let ninf = f64::NEG_INFINITY;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `NEG_INFINITY` associated constant on `f64`")]
pub const NEG_INFINITY: f64 = f64::NEG_INFINITY;

/// 基本数学常量。
#[stable(feature = "rust1", since = "1.0.0")]
pub mod consts {
    // FIXME: 用 cmath 中的数学常量替换。

    /// 阿基米德的恒定 (π)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const PI: f64 = 3.14159265358979323846264338327950288_f64;

    /// 整圈常量 (τ)
    ///
    /// 等于 2π。
    #[stable(feature = "tau_constant", since = "1.47.0")]
    pub const TAU: f64 = 6.28318530717958647692528676655900577_f64;

    /// π/2
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64;

    /// π/3
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64;

    /// π/4
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64;

    /// π/6
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64;

    /// π/8
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64;

    /// 1/π
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64;

    /// 2/π
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64;

    /// 2/sqrt(π)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64;

    /// sqrt(2)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64;

    /// 1/sqrt(2)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;

    /// 欧拉数 (e)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const E: f64 = 2.71828182845904523536028747135266250_f64;

    /// log<sub>2</sub>(10)
    #[stable(feature = "extra_log_consts", since = "1.43.0")]
    pub const LOG2_10: f64 = 3.32192809488736234787031942948939018_f64;

    /// log<sub>2</sub>(e)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64;

    /// log<sub>10</sub>(2)
    #[stable(feature = "extra_log_consts", since = "1.43.0")]
    pub const LOG10_2: f64 = 0.301029995663981195213738894724493027_f64;

    /// log<sub>10</sub>(e)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64;

    /// ln(2)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64;

    /// ln(10)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
}

#[cfg(not(test))]
impl f64 {
    /// `f64` 内部表示形式的基数或基数。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const RADIX: u32 = 2;

    /// 基数中的有效位数 2.
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MANTISSA_DIGITS: u32 = 53;
    /// 以 10 为基数的有效位数的大概数字。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const DIGITS: u32 = 15;

    /// `f64` 的 [机器精度][Machine epsilon] 值。
    ///
    /// 这是 `1.0` 与下一个较大的可表示数字之间的差异。
    ///
    /// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const EPSILON: f64 = 2.2204460492503131e-16_f64;

    /// 最小的 `f64` 有限值。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN: f64 = -1.7976931348623157e+308_f64;
    /// 最小正 `f64` 正值。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64;
    /// 最大的有限 `f64` 值。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MAX: f64 = 1.7976931348623157e+308_f64;

    /// 比 2 的最小可能标准幂大一。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN_EXP: i32 = -1021;
    /// 2 指数的最大可能乘方。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MAX_EXP: i32 = 1024;

    /// 最小可能的标准幂为 10 指数。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN_10_EXP: i32 = -307;
    /// 最大可能功效为 10 指数。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MAX_10_EXP: i32 = 308;

    /// 不是数字 (NaN)。
    ///
    /// 请注意,IEEE 754 不只定义一个 NaN 值;
    /// 过多的位模式被认为是 NaN。
    /// 此外,该标准区分了 "signaling" 和 "quiet" NaN,并允许检查其 "payload" (位模式中未指定的位)。
    /// 不保证此特性等于任何特定的 NaN 位模式,并且不保证其表示在 Rust 版本和目标平台上的稳定性。
    ///
    ///
    ///
    ///
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const NAN: f64 = 0.0_f64 / 0.0_f64;
    /// 无限 (∞)。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const INFINITY: f64 = 1.0_f64 / 0.0_f64;
    /// 负无穷大 (−∞)。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64;

    /// 如果此值为 NaN,则返回 `true`。
    ///
    /// ```
    /// let nan = f64::NAN;
    /// let f = 7.0_f64;
    ///
    /// assert!(nan.is_nan());
    /// assert!(!f.is_nan());
    /// ```
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_nan(self) -> bool {
        self != self
    }

    // FIXME(#50145): 由于对可移植性的担忧,`abs` 在核心中是公开不可用的,所以这个实现是供内部 private 使用的。
    //
    //
    #[inline]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    pub(crate) const fn abs_private(self) -> f64 {
        // SAFETY: 这个转变很好。大概吧。可能因为 std 使用它的原因。
        unsafe {
            mem::transmute::<u64, f64>(mem::transmute::<f64, u64>(self) & 0x7fff_ffff_ffff_ffff)
        }
    }

    /// 如果此值是正无穷大或负无穷大,则返回 `true`,否则返回 `false`。
    ///
    ///
    /// ```
    /// let f = 7.0f64;
    /// let inf = f64::INFINITY;
    /// let neg_inf = f64::NEG_INFINITY;
    /// let nan = f64::NAN;
    ///
    /// assert!(!f.is_infinite());
    /// assert!(!nan.is_infinite());
    ///
    /// assert!(inf.is_infinite());
    /// assert!(neg_inf.is_infinite());
    /// ```
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_infinite(self) -> bool {
        // 使用转变可能会导致某些 FPU 的错误答复
        // FIXME: 改变 Rust <-> Rust 调用约定来防止这个问题。
        // See https://github.com/rust-lang/rust/issues/72327
        (self == f64::INFINITY) | (self == f64::NEG_INFINITY)
    }

    /// 如果此数字既不是无穷大也不是 NaN,则返回 `true`。
    ///
    /// ```
    /// let f = 7.0f64;
    /// let inf: f64 = f64::INFINITY;
    /// let neg_inf: f64 = f64::NEG_INFINITY;
    /// let nan: f64 = f64::NAN;
    ///
    /// assert!(f.is_finite());
    ///
    /// assert!(!nan.is_finite());
    /// assert!(!inf.is_finite());
    /// assert!(!neg_inf.is_finite());
    /// ```
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_finite(self) -> bool {
        // 无需单独处理 NaN: 如果 self 是 NaN,则比较不完全正确。
        //
        self.abs_private() < Self::INFINITY
    }

    /// 如果数字为 [subnormal],则返回 `true`。
    ///
    /// ```
    /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308_f64
    /// let max = f64::MAX;
    /// let lower_than_min = 1.0e-308_f64;
    /// let zero = 0.0_f64;
    ///
    /// assert!(!min.is_subnormal());
    /// assert!(!max.is_subnormal());
    ///
    /// assert!(!zero.is_subnormal());
    /// assert!(!f64::NAN.is_subnormal());
    /// assert!(!f64::INFINITY.is_subnormal());
    /// // `0` 和 `min` 之间的值是次标准的。
    /// assert!(lower_than_min.is_subnormal());
    /// ```
    /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number
    #[must_use]
    #[stable(feature = "is_subnormal", since = "1.53.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_subnormal(self) -> bool {
        matches!(self.classify(), FpCategory::Subnormal)
    }

    /// 如果数字既不是零、无穷大、[subnormal] 或 NaN,则返回 `true`。
    ///
    ///
    /// ```
    /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64
    /// let max = f64::MAX;
    /// let lower_than_min = 1.0e-308_f64;
    /// let zero = 0.0f64;
    ///
    /// assert!(min.is_normal());
    /// assert!(max.is_normal());
    ///
    /// assert!(!zero.is_normal());
    /// assert!(!f64::NAN.is_normal());
    /// assert!(!f64::INFINITY.is_normal());
    /// // `0` 和 `min` 之间的值是次标准的。
    /// assert!(!lower_than_min.is_normal());
    /// ```
    /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_normal(self) -> bool {
        matches!(self.classify(), FpCategory::Normal)
    }

    /// 返回数字的浮点类别。
    /// 如果仅要测试一个属性,则通常使用特定谓词会更快。
    ///
    ///
    /// ```
    /// use std::num::FpCategory;
    ///
    /// let num = 12.4_f64;
    /// let inf = f64::INFINITY;
    ///
    /// assert_eq!(num.classify(), FpCategory::Normal);
    /// assert_eq!(inf.classify(), FpCategory::Infinite);
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    pub const fn classify(self) -> FpCategory {
        // 以前的实现尝试仅使用基于位掩码的检查,使用 f64::to_bits 将浮点数转换为它的位 repr 并在其上进行匹配。
        // 不幸的是,浮点数可能比这更糟糕。
        // 这也不需要导致对 f64::to_bits 的递归计算。
        //
        // 在某些处理器上,在某些情况下,LLVM 将有益地降低浮点运算,尽管要求它们使用 f32 和 f64,但对 x87 运算之类的操作。
        //
        // 它们有一个 f64 的尾数,但可以具有比正常指数更大的指数。
        // FIXME(jubilee): 为了在 x86 处理器上进行 Rust 到 Rust 的调用,永远不需要使用 x87 操作,所以不应该发生这个问题。
        // 应调整代码生成以使用非 C 调用约定,从而避免这种情况。
        //
        // 因此,一个值可能比较不等于无穷大,尽管具有 "full" 指数掩码。
        // 它可能不是 NaN,因为它可以简单地是一个 "overextended" 有限值。
        //
        //
        if self.is_nan() {
            FpCategory::Nan
        } else {
            // 但是,std 也不能简单地与零比较来检查是否为零,因为正确性需要避免可能是 Subnormal == -0.0 的相等测试,因为它在 "denormals are zero" 和 "flush to zero" 模式下可能是错误的。
            //
            // 大多数 std 的目标不使用这些,但它们用于 thumbv7neon。
            // 因此,这确实使用了其余部分的位模式匹配。
            //

            // SAFETY: f64 到 u64 没问题。Usually.
            // 如果控制流已经走到了这一步,那么该值肯定属于 f64::partial_classify 可以正确分析的类别之一。
            //
            unsafe { f64::partial_classify(self) }
        }
    }

    // 这实际上并没有故意返回 NaN 的正确答案,因为它无法正确区分浮点 NaN 和从 x87 FPU 截断的一些正常浮点数。
    //
    //
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    const unsafe fn partial_classify(self) -> FpCategory {
        const EXP_MASK: u64 = 0x7ff0000000000000;
        const MAN_MASK: u64 = 0x000fffffffffffff;

        // SAFETY: 调用者不会问这样会说谎的问题。
        let b = unsafe { mem::transmute::<f64, u64>(self) };
        match (b & MAN_MASK, b & EXP_MASK) {
            (0, EXP_MASK) => FpCategory::Infinite,
            (0, 0) => FpCategory::Zero,
            (_, 0) => FpCategory::Subnormal,
            _ => FpCategory::Normal,
        }
    }

    // 它对位进行操作,并且仅对位进行操作,因此它可以忽略对奇怪 FPU 的担忧。
    // FIXME(jubilee): 在一个公正的世界里,这将是分类的整个 impl,加上一个 transmute。
    // 我们并不生活在一个公正的世界里,但我们可以让它变得更加公正。
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    const fn classify_bits(b: u64) -> FpCategory {
        const EXP_MASK: u64 = 0x7ff0000000000000;
        const MAN_MASK: u64 = 0x000fffffffffffff;

        match (b & MAN_MASK, b & EXP_MASK) {
            (0, EXP_MASK) => FpCategory::Infinite,
            (_, EXP_MASK) => FpCategory::Nan,
            (0, 0) => FpCategory::Zero,
            (_, 0) => FpCategory::Subnormal,
            _ => FpCategory::Normal,
        }
    }

    /// 如果 `self` 有正号,则返回 `true`,包括 `+0.0`、带正号位的 NaN 和正无穷大。
    /// 请注意,在 NaN 的情况下,IEEE 754 不会为符号位分配任何含义,并且由于 Rust 不保证 NaN 的位模式在算术运算中保持不变,因此 `is_sign_positive` 对 NaN 的结果可能会产生意外在某些情况下导致。
    ///
    /// 有关详细信息,请参见 [将 NaN 解释为特殊值](f32)。
    ///
    /// ```
    /// let f = 7.0_f64;
    /// let g = -7.0_f64;
    ///
    /// assert!(f.is_sign_positive());
    /// assert!(!g.is_sign_positive());
    /// ```
    ///
    ///
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_sign_positive(self) -> bool {
        !self.is_sign_negative()
    }

    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[deprecated(since = "1.0.0", note = "renamed to is_sign_positive")]
    #[inline]
    #[doc(hidden)]
    pub fn is_positive(self) -> bool {
        self.is_sign_positive()
    }

    /// 如果 `self` 具有 negative 符号,则返回 `true`,包括 `-0.0`、具有 negative 符号位的 NaN 和 negative 无穷大。
    /// 请注意,在 NaN 的情况下,IEEE 754 不会为符号位分配任何含义,并且由于 Rust 不保证 NaN 的位模式在算术运算中保持不变,因此 `is_sign_negative` 对 NaN 的结果可能会产生意外在某些情况下导致。
    ///
    /// 有关详细信息,请参见 [将 NaN 解释为特殊值](f32)。
    ///
    /// ```
    /// let f = 7.0_f64;
    /// let g = -7.0_f64;
    ///
    /// assert!(!f.is_sign_negative());
    /// assert!(g.is_sign_negative());
    /// ```
    ///
    ///
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_sign_negative(self) -> bool {
        // IEEE754 说:当且仅当 x 具有负号时,isSignMinus(x) 才为 true。
        // isSignMinus 也适用于零和 NaN。
        // SAFETY: 这只是为了得到符号位而转换,没关系。
        unsafe { mem::transmute::<f64, u64>(self) & 0x8000_0000_0000_0000 != 0 }
    }

    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[deprecated(since = "1.0.0", note = "renamed to is_sign_negative")]
    #[inline]
    #[doc(hidden)]
    pub fn is_negative(self) -> bool {
        self.is_sign_negative()
    }

    /// 返回大于 `self` 的最小数字。
    ///
    /// 令 `TINY` 为可表示的最小正 `f64`。
    /// Then,
    ///  - 如果是 `self.is_nan()`,则返回 `self`;
    ///  - 如果 `self` 是 [`NEG_INFINITY`],则返回 [`MIN`];
    ///  - 如果 `self` 是 `-TINY`,则返回 - 0.0;
    ///  - 如果 `self` 为 - 0.0 或 + 0.0,则返回 `TINY`;
    ///  - 如果 `self` 是 [`MAX`] 或 [`INFINITY`],则返回 [`INFINITY`];
    ///  - 否则返回大于 `self` 的唯一最小值。
    ///
    /// 恒等式 `x.next_up() == -(-x).next_down()` 适用于所有非 NaN `x`。当 `x` 为有限时,`x == x.next_up().next_down()` 也成立。
    ///
    /// ```rust
    /// #![feature(float_next_up_down)]
    /// // f64::EPSILON 是 1.0 和下一个数字之间的差。
    /// assert_eq!(1.0f64.next_up(), 1.0 + f64::EPSILON);
    /// // 但不适用于大多数数字。
    /// assert!(0.1f64.next_up() < 0.1 + f64::EPSILON);
    /// assert_eq!(9007199254740992f64.next_up(), 9007199254740994.0);
    /// ```
    ///
    /// [`NEG_INFINITY`]: Self::NEG_INFINITY
    /// [`INFINITY`]: Self::INFINITY
    /// [`MIN`]: Self::MIN
    /// [`MAX`]: Self::MAX
    #[unstable(feature = "float_next_up_down", issue = "91399")]
    #[rustc_const_unstable(feature = "float_next_up_down", issue = "91399")]
    pub const fn next_up(self) -> Self {
        // 我们必须使用严格的整数算术来防止非正规在某些平台上的算术运算后刷新为零。
        //
        const TINY_BITS: u64 = 0x1; // 最小正 f64。
        const CLEAR_SIGN_MASK: u64 = 0x7fff_ffff_ffff_ffff;

        let bits = self.to_bits();
        if self.is_nan() || bits == Self::INFINITY.to_bits() {
            return self;
        }

        let abs = bits & CLEAR_SIGN_MASK;
        let next_bits = if abs == 0 {
            TINY_BITS
        } else if bits == abs {
            bits + 1
        } else {
            bits - 1
        };
        Self::from_bits(next_bits)
    }

    /// 返回小于 `self` 的最大数。
    ///
    /// 令 `TINY` 为可表示的最小正 `f64`。
    /// Then,
    ///  - 如果是 `self.is_nan()`,则返回 `self`;
    ///  - 如果 `self` 是 [`INFINITY`],则返回 [`MAX`];
    ///  - 如果 `self` 是 `TINY`,则返回 0.0;
    ///  - 如果 `self` 为 - 0.0 或 + 0.0,则返回 `-TINY`;
    ///  - 如果 `self` 是 [`MIN`] 或 [`NEG_INFINITY`],则返回 [`NEG_INFINITY`];
    ///  - 否则返回小于 `self` 的唯一最大值。
    ///
    /// 恒等式 `x.next_down() == -(-x).next_up()` 适用于所有非 NaN `x`。当 `x` 为有限时,`x == x.next_down().next_up()` 也成立。
    ///
    /// ```rust
    /// #![feature(float_next_up_down)]
    /// let x = 1.0f64;
    /// // 将值限制在 [0, 1) 范围内。
    /// let clamped = x.clamp(0.0, 1.0f64.next_down());
    /// assert!(clamped < 1.0);
    /// assert_eq!(clamped.next_up(), 1.0);
    /// ```
    ///
    /// [`NEG_INFINITY`]: Self::NEG_INFINITY
    /// [`INFINITY`]: Self::INFINITY
    /// [`MIN`]: Self::MIN
    /// [`MAX`]: Self::MAX
    #[unstable(feature = "float_next_up_down", issue = "91399")]
    #[rustc_const_unstable(feature = "float_next_up_down", issue = "91399")]
    pub const fn next_down(self) -> Self {
        // 我们必须使用严格的整数算术来防止非正规在某些平台上的算术运算后刷新为零。
        //
        const NEG_TINY_BITS: u64 = 0x8000_0000_0000_0001; // 最小 (幅度) negative f64。
        const CLEAR_SIGN_MASK: u64 = 0x7fff_ffff_ffff_ffff;

        let bits = self.to_bits();
        if self.is_nan() || bits == Self::NEG_INFINITY.to_bits() {
            return self;
        }

        let abs = bits & CLEAR_SIGN_MASK;
        let next_bits = if abs == 0 {
            NEG_TINY_BITS
        } else if bits == abs {
            bits - 1
        } else {
            bits + 1
        };
        Self::from_bits(next_bits)
    }

    /// 取一个数 `1/x` 的倒数 (inverse)。
    ///
    /// ```
    /// let x = 2.0_f64;
    /// let abs_difference = (x.recip() - (1.0 / x)).abs();
    ///
    /// assert!(abs_difference < 1e-10);
    /// ```
    #[must_use = "this returns the result of the operation, without modifying the original"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn recip(self) -> f64 {
        1.0 / self
    }

    /// 将弧度转换为度数。
    ///
    /// ```
    /// let angle = std::f64::consts::PI;
    ///
    /// let abs_difference = (angle.to_degrees() - 180.0).abs();
    ///
    /// assert!(abs_difference < 1e-10);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn to_degrees(self) -> f64 {
        // 此处的除法相对于 180/π 的真实值正确取整。
        // (这与 f32 不同,在 f32 中,必须使用常量来确保正确舍入结果。)
        //
        self * (180.0f64 / consts::PI)
    }

    /// 将度数转换为弧度。
    ///
    /// ```
    /// let angle = 180.0_f64;
    ///
    /// let abs_difference = (angle.to_radians() - std::f64::consts::PI).abs();
    ///
    /// assert!(abs_difference < 1e-10);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn to_radians(self) -> f64 {
        let value: f64 = consts::PI;
        self * (value / 180.0)
    }

    /// 返回两个数字中的最大值,忽略 NaN。
    ///
    /// 如果参数之一是 NaN,则返回另一个参数。
    /// 这遵循 maxNum 的 IEEE 754-2008 语义,除了处理信令 NaN;
    /// 这个函数以相同的方式处理所有的 NaN,并避免了 maxNum 的关联性问题。
    /// 这也符合 libm 的 fmax 的行为。
    ///
    /// ```
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.max(y), y);
    /// ```
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn max(self, other: f64) -> f64 {
        intrinsics::maxnumf64(self, other)
    }

    /// 返回两个数字中的最小值,忽略 NaN。
    ///
    /// 如果参数之一是 NaN,则返回另一个参数。
    /// 这遵循 minNum 的 IEEE 754-2008 语义,除了处理信令 NaN;
    /// 这个函数以相同的方式处理所有的 NaN,并避免了 minNum 的关联性问题。
    /// 这也符合 libm 的 fmin 的行为。
    ///
    /// ```
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.min(y), x);
    /// ```
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn min(self, other: f64) -> f64 {
        intrinsics::minnumf64(self, other)
    }

    /// 返回两个数字中的最大值,传播 NaN。
    ///
    /// 当任一参数为 NaN 时,这将返回 NaN,而 [`f64::max`] 仅当两个参数都为 NaN 时才返回 NaN。
    ///
    /// ```
    /// #![feature(float_minimum_maximum)]
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.maximum(y), y);
    /// assert!(x.maximum(f64::NAN).is_nan());
    /// ```
    ///
    /// 如果参数之一是 NaN,则返回 NaN。否则,这将返回两个数字中较大的一个。对于此操作,`-0.0` 被认为小于 `+0.0`。
    /// 请注意,这遵循 IEEE 754-2019 中指定的语义。
    ///
    /// 另请注意,此处 NaN 的 "propagation" 并不一定意味着 NaN 操作数的位模式是守恒的; 有关详细信息,请参见 [将 NaN 解释为特殊值](f32)。
    ///
    ///
    ///
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[unstable(feature = "float_minimum_maximum", issue = "91079")]
    #[inline]
    pub fn maximum(self, other: f64) -> f64 {
        if self > other {
            self
        } else if other > self {
            other
        } else if self == other {
            if self.is_sign_positive() && other.is_sign_negative() { self } else { other }
        } else {
            self + other
        }
    }

    /// 返回两个数字中的最小值,传播 NaN。
    ///
    /// 当任一参数为 NaN 时返回 NaN,而 [`f64::min`] 仅当两个参数都为 NaN 时才返回 NaN。
    ///
    /// ```
    /// #![feature(float_minimum_maximum)]
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.minimum(y), x);
    /// assert!(x.minimum(f64::NAN).is_nan());
    /// ```
    ///
    /// 如果参数之一是 NaN,则返回 NaN。否则,这将返回两个数字中的较小者。对于此操作,`-0.0` 被认为小于 `+0.0`。
    /// 请注意,这遵循 IEEE 754-2019 中指定的语义。
    ///
    /// 另请注意,此处 NaN 的 "propagation" 并不一定意味着 NaN 操作数的位模式是守恒的; 有关详细信息,请参见 [将 NaN 解释为特殊值](f32)。
    ///
    ///
    ///
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[unstable(feature = "float_minimum_maximum", issue = "91079")]
    #[inline]
    pub fn minimum(self, other: f64) -> f64 {
        if self < other {
            self
        } else if other < self {
            other
        } else if self == other {
            if self.is_sign_negative() && other.is_sign_positive() { self } else { other }
        } else {
            self + other
        }
    }

    /// 计算 `self` 和 `rhs` 的中点。
    ///
    /// 当 * 参数为 NaN 或者 + inf 和 -inf 的组合作为参数提供时,这将返回 NaN。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(num_midpoint)]
    /// assert_eq!(1f64.midpoint(4.0), 2.5);
    /// assert_eq!((-5.5f64).midpoint(8.0), 1.25);
    /// ```
    #[unstable(feature = "num_midpoint", issue = "110840")]
    pub fn midpoint(self, other: f64) -> f64 {
        const LO: f64 = f64::MIN_POSITIVE * 2.;
        const HI: f64 = f64::MAX / 2.;

        let (a, b) = (self, other);
        let abs_a = a.abs_private();
        let abs_b = b.abs_private();

        if abs_a <= HI && abs_b <= HI {
            // 溢出是不可能的
            (a + b) / 2.
        } else if abs_a < LO {
            // 减半不安全
            a + (b / 2.)
        } else if abs_b < LO {
            // 减半 b 不安全
            (a / 2.) + b
        } else {
            // 将 a 和 b 减半不安全
            (a / 2.) + (b / 2.)
        }
    }

    /// 舍入为零并转换为任何原始整数类型,前提是该值是有限的并且适合该类型。
    ///
    ///
    /// ```
    /// let value = 4.6_f64;
    /// let rounded = unsafe { value.to_int_unchecked::<u16>() };
    /// assert_eq!(rounded, 4);
    ///
    /// let value = -128.9_f64;
    /// let rounded = unsafe { value.to_int_unchecked::<i8>() };
    /// assert_eq!(rounded, i8::MIN);
    /// ```
    ///
    /// # Safety
    ///
    /// 该值必须:
    ///
    /// * 不是 `NaN`
    /// * 不是无限的
    /// * 截断小数部分后,可以在返回类型 `Int` 中表示
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_approx_unchecked_to", since = "1.44.0")]
    #[inline]
    pub unsafe fn to_int_unchecked<Int>(self) -> Int
    where
        Self: FloatToInt<Int>,
    {
        // SAFETY: 调用者必须遵守 `FloatToInt::to_int_unchecked` 的安全保证。
        //
        unsafe { FloatToInt::<Int>::to_int_unchecked(self) }
    }

    /// 原始 trans 变为 `u64`。
    ///
    /// 当前,这与所有平台上的 `transmute::<f64, u64>(self)` 相同。
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    /// 请注意,此函数与 `as` 强制转换不同,后者试图保留 *数字* 值,而不是按位值。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// assert!((1f64).to_bits() != 1f64 as u64); // to_bits() 不是 casting!
    /// assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
    ///
    /// ```
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_bits_conv", since = "1.20.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_bits(self) -> u64 {
        // SAFETY: `u64` 是一个普通的旧数据类型,所以我们总是可以转换成它。
        // ...sorta.
        //
        // 有关更多信息,请参见 f64::from_bits 中的 SAFETY 注释。
        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
        const fn ct_f64_to_u64(ct: f64) -> u64 {
            match ct.classify() {
                FpCategory::Nan => {
                    panic!("const-eval error: cannot use f64::to_bits on a NaN")
                }
                FpCategory::Subnormal => {
                    panic!("const-eval error: cannot use f64::to_bits on a subnormal number")
                }
                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
                    // SAFETY: 我们有一个普通的浮点数。现在我们进行转换,即进行位复制。
                    unsafe { mem::transmute::<f64, u64>(ct) }
                }
            }
        }

        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
        fn rt_f64_to_u64(rt: f64) -> u64 {
            // SAFETY: `u64` 是一个普通的旧数据类型,所以我们总是可以...... uh ...
            // ...看,假装您忘记了刚刚读到的内容。
            // 稳定性问题。
            unsafe { mem::transmute::<f64, u64>(rt) }
        }
        // SAFETY: 我们使用在编译时要么总是工作要么失败的内部实现。
        unsafe { intrinsics::const_eval_select((self,), ct_f64_to_u64, rt_f64_to_u64) }
    }

    /// 来自 `u64` 的原始 mut 变。
    ///
    /// 当前,这与所有平台上的 `transmute::<u64, f64>(v)` 相同。
    /// 事实证明,此方法具有很高的可移植性,其原因有两个:
    ///
    /// * 浮点数和整数在所有受支持的平台上具有相同的字节序。
    /// * IEEE 754 非常精确地指定了浮点数的位布局。
    ///
    /// 但是有一个警告: 在 2008 年版本的 IEEE 754 之前,实际上并未指定如何解释 NaN 信号位。
    /// 大多数平台 (特别是 x86 和 ARM) 采用了最终在 2008 年标准化的解释,但有些则没有 (特别是 MIPS)。
    /// 结果,MIPS 上的所有信令 NaN 都是 x86 上的安静 NaN,反之亦然。
    ///
    /// 该实现方式不是尝试保留跨信令的信令,而是倾向于保留确切的位。
    /// 这意味着,即使此方法的结果通过网络从 x86 机器发送到 MIPS 机器,任何以 NaN 编码的有效载荷也将被保留。
    ///
    ///
    /// 如果这个方法的结果只由产生它们的同一个架构操纵,那么就没有可移植性的问题。
    ///
    /// 如果输入的不是 NaN,则不存在可移植性问题。
    ///
    /// 如果您不太在意信号传递性,那么就不必担心可移植性。
    ///
    /// 请注意,此函数与 `as` 强制转换不同,后者试图保留 *数字* 值,而不是按位值。
    ///
    /// # Examples
    ///
    /// ```
    /// let v = f64::from_bits(0x4029000000000000);
    /// assert_eq!(v, 12.5);
    /// ```
    ///
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "float_bits_conv", since = "1.20.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_bits(v: u64) -> Self {
        // 事实证明,sNaN 的安全问题被夸大了! Hooray!
        // SAFETY: `u64` 是一个普通的旧数据类型,所以我们总是可以从它变形...... 排序。
        //
        // 事实证明,在运行时,浮点数可能会受到浮点模式的影响,这些模式在读取和写入时将非零 subnormal 数更改为零,即 "denormals are zero" 和 "flush to zero"。
        // 这通常不是问题,但 Rust 的至少一个 tier2 平台实际上默认表现出 FTZ 行为: thumbv7neon aka "the Neon FPU in AArch32 state"
        //
        // 即使这样,并非所有指令都在 thumbv7neon 上表现出 FTZ 行为,因此如果 LLVM 发出 "correct" 指令,这应该加载相同的位,但 LLVM 有时会做出有趣的浮点优化选择,其他 FPU 可能会做类似的事情。
        //
        // 因此,谨慎地放纵奢华是明智的。
        //
        // 此外,在禁用 SSE 或 SSE2 并启用 x87 FPU 的 x86 目标上,即
        // 不是软浮点,Rust 进行参数传递的方式实际上可以以稍微不可预测的方式将 "not infinity" 的数字更改为具有与无穷大相同的指数。
        //
        // 而且,当然评估到 NaN 值是相当不确定的。
        // 更准确地说: 什么时候应该返回 NaN 是可知的,但是哪个 NaN 呢?
        // 到目前为止,这是由 LLVM 和 CPU 的组合定义的,而不是 Rust。
        // 然而,这个函数允许观察 NaN 的位串,从而对 CTFE 进行内省。
        //
        // 为了至少暂时保持 const 到运行时的等价性,拒绝任何这些可能的情况发生。
        //
        //
        //
        //
        //
        //
        //
        //
        //
        //
        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
        const fn ct_u64_to_f64(ct: u64) -> f64 {
            match f64::classify_bits(ct) {
                FpCategory::Subnormal => {
                    panic!("const-eval error: cannot use f64::from_bits on a subnormal number")
                }
                FpCategory::Nan => {
                    panic!("const-eval error: cannot use f64::from_bits on NaN")
                }
                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
                    // SAFETY: 这不是一个有趣的数字
                    unsafe { mem::transmute::<u64, f64>(ct) }
                }
            }
        }

        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
        fn rt_u64_to_f64(rt: u64) -> f64 {
            // SAFETY: `u64` 是一个普通的旧数据类型,所以我们总是可以...... uh ...
            // ...看,假装您忘记了刚刚读到的内容。
            // 稳定性问题。
            unsafe { mem::transmute::<u64, f64>(rt) }
        }
        // SAFETY: 我们使用在编译时要么总是工作要么失败的内部实现。
        unsafe { intrinsics::const_eval_select((v,), ct_u64_to_f64, rt_u64_to_f64) }
    }

    /// 以大端 (网络) 字节顺序的字节数组形式返回此浮点数的内存表示形式。
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let bytes = 12.5f64.to_be_bytes();
    /// assert_eq!(bytes, [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
    /// ```
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_be_bytes(self) -> [u8; 8] {
        self.to_bits().to_be_bytes()
    }

    /// 以小字节序字节顺序将浮点数的内存表示形式返回为字节数组。
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let bytes = 12.5f64.to_le_bytes();
    /// assert_eq!(bytes, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
    /// ```
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_le_bytes(self) -> [u8; 8] {
        self.to_bits().to_le_bytes()
    }

    /// 返回此浮点数的内存表示形式,以原生字节顺序的字节数组形式。
    ///
    /// 由于使用了目标平台的原生字节序,因此,可移植代码应酌情使用 [`to_be_bytes`] 或 [`to_le_bytes`]。
    ///
    ///
    /// [`to_be_bytes`]: f64::to_be_bytes
    /// [`to_le_bytes`]: f64::to_le_bytes
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    /// # Examples
    ///
    /// ```
    /// let bytes = 12.5f64.to_ne_bytes();
    /// assert_eq!(
    ///     bytes,
    ///     if cfg!(target_endian = "big") {
    ///         [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
    ///     } else {
    ///         [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
    ///     }
    /// );
    /// ```
    ///
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_ne_bytes(self) -> [u8; 8] {
        self.to_bits().to_ne_bytes()
    }

    /// 从其表示形式以 big endian 的字节数组创建一个浮点值。
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let value = f64::from_be_bytes([0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
    /// assert_eq!(value, 12.5);
    /// ```
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_be_bytes(bytes: [u8; 8]) -> Self {
        Self::from_bits(u64::from_be_bytes(bytes))
    }

    /// 从它的表示形式以 Little Endian 的字节数组创建一个浮点值。
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let value = f64::from_le_bytes([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
    /// assert_eq!(value, 12.5);
    /// ```
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_le_bytes(bytes: [u8; 8]) -> Self {
        Self::from_bits(u64::from_le_bytes(bytes))
    }

    /// 从其表示形式 (以原生字节序形式的字节数组形式) 创建浮点值。
    ///
    /// 由于使用了目标平台的原生字节序,因此可移植代码可能希望酌情使用 [`from_be_bytes`] 或 [`from_le_bytes`]。
    ///
    ///
    /// [`from_be_bytes`]: f64::from_be_bytes
    /// [`from_le_bytes`]: f64::from_le_bytes
    ///
    /// 有关此操作的可移植性的一些讨论,请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    /// # Examples
    ///
    /// ```
    /// let value = f64::from_ne_bytes(if cfg!(target_endian = "big") {
    ///     [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
    /// } else {
    ///     [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
    /// });
    /// assert_eq!(value, 12.5);
    /// ```
    ///
    ///
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_ne_bytes(bytes: [u8; 8]) -> Self {
        Self::from_bits(u64::from_ne_bytes(bytes))
    }

    /// 返回 `self` 和 `other` 之间的顺序。
    ///
    /// 与浮点数之间的标准部分比较不同,此比较始终根据 IEEE 754 (2008 修订版) 浮点标准中定义的 `totalOrder` 谓词生成排序。
    /// 这些值按以下顺序排序:
    ///
    /// - negative quiet NaN
    /// - negative signaling NaN
    /// - negative infinity
    /// - negative numbers
    /// - negative subnormal numbers
    /// - negative zero
    /// - positive zero
    /// - positive subnormal numbers
    /// - positive numbers
    /// - positive infinity
    /// - positive signaling NaN
    /// - positive quiet NaN.
    ///
    /// 这个函数建立的顺序并不总是与 `f64` 的 [`PartialOrd`] 和 [`PartialEq`] 实现一致。
    /// 例如,他们认为负零和正零相等,而 `total_cmp`
    /// doesn't.
    ///
    /// 信令 NaN 位的解释遵循 IEEE 754 标准中的定义,这可能与一些旧的、不符合标准的 (例如 MIPS) 硬件实现的解释不匹配。
    ///
    /// # Example
    ///
    /// ```
    /// struct GoodBoy {
    ///     name: String,
    ///     weight: f64,
    /// }
    ///
    /// let mut bois = vec![
    ///     GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    ///     GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    ///     GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    ///     GoodBoy { name: "Chonk".to_owned(), weight: f64::INFINITY },
    ///     GoodBoy { name: "Abs. Unit".to_owned(), weight: f64::NAN },
    ///     GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
    /// ];
    ///
    /// bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));
    /// # assert!(bois.into_iter().map(|b| b.weight)
    /// #     .zip([-5.0, 0.1, 10.0, 99.0, f64::INFINITY, f64::NAN].iter())
    /// #     .all(|(a, b)| a.to_bits() == b.to_bits()))
    /// ```
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "total_cmp", since = "1.62.0")]
    #[must_use]
    #[inline]
    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
        let mut left = self.to_bits() as i64;
        let mut right = other.to_bits() as i64;

        // 如果是负数,将除符号外的所有位翻转以实现与二进制补码整数相似的布局
        //
        // 为什么这样做? IEEE 754 浮点数包含三个字段:
        // 符号位,指数和尾数。整个指数和尾数字段具有以下属性:它们的按位顺序等于定义大小的数字大小。
        // 幅度通常不是在 NaN 值上定义的,但是 IEEE 754 totalOrder 将 NaN 值也定义为遵循位顺序。这导致了文档注释中解释的顺序。
        // 但是,对于负数和正数,幅值的表示是相同的 - 仅符号位不同。
        // 为了轻松地将浮点数与带符号整数进行比较,在负数的情况下,我们需要翻转指数位和尾数位。
        // 我们将数字有效地转换为 "二进制补码" 的形式。
        //
        // 为了进行翻转,我们构造了一个掩码并对它进行 XOR。
        // 我们从负号值无分支地计算 "除符号位之外的全 1" 掩码: 右移符号以扩展整数,因此我们用符号位 "fill" 掩码,然后转换为无符号以压入另一个零位。
        //
        // 如果为正值,则掩码全为零,因此是空操作。
        //
        //
        //
        //
        //
        //
        //
        //
        //
        left ^= (((left >> 63) as u64) >> 1) as i64;
        right ^= (((right >> 63) as u64) >> 1) as i64;

        left.cmp(&right)
    }

    /// 除非是 NaN,否则将值限制为一定的时间间隔。
    ///
    /// 如果 `self` 大于 `max`,则返回 `max`; 如果 `self` 小于 `min`,则返回 `min`。
    /// 否则,将返回 `self`。
    ///
    /// 请注意,如果初始值也为 NaN,则此函数将返回 NaN。
    ///
    /// # Panics
    ///
    /// 如果 `min > max`,`min` 为 NaN 或 `max` 为 NaN,就会出现 panics。
    ///
    /// # Examples
    ///
    /// ```
    /// assert!((-3.0f64).clamp(-2.0, 1.0) == -2.0);
    /// assert!((0.0f64).clamp(-2.0, 1.0) == 0.0);
    /// assert!((2.0f64).clamp(-2.0, 1.0) == 1.0);
    /// assert!((f64::NAN).clamp(-2.0, 1.0).is_nan());
    /// ```
    ///
    #[must_use = "method returns a new number and does not mutate the original value"]
    #[stable(feature = "clamp", since = "1.50.0")]
    #[inline]
    pub fn clamp(mut self, min: f64, max: f64) -> f64 {
        assert!(min <= max, "min > max, or either was NaN. min = {min:?}, max = {max:?}");
        if self < min {
            self = min;
        }
        if self > max {
            self = max;
        }
        self
    }
}