Skip to content

Commit ccc12af

Browse files
dr-orlovskydr-orlovsky
committed
chore: another cargo fmt
1 parent 43494dc commit ccc12af

File tree

10 files changed

+551
-807
lines changed

10 files changed

+551
-807
lines changed

‎.github/workflows/lint.yml

+1-1
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,7 @@ jobs:
3939
name: Clippy
4040
with:
4141
command: clippy
42-
args: --workspace --all-features --all-targets
42+
args: --workspace --all-features
4343
doc:
4444
runs-on: ubuntu-latest
4545
steps:

‎apfloat/src/ieee.rs

+45-59
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,10 @@ use std::vec::Vec;
2020

2121
use amplify_num::u256;
2222

23-
use crate::{Category, ExpInt, IEK_INF, IEK_NAN, IEK_ZERO};
24-
use crate::{Float, FloatConvert, ParseError, Round, Status, StatusAnd};
23+
use crate::{
24+
Category, ExpInt, Float, FloatConvert, ParseError, Round, Status, StatusAnd, IEK_INF, IEK_NAN,
25+
IEK_ZERO,
26+
};
2527

2628
#[must_use]
2729
pub struct IeeeFloat<S> {
@@ -44,9 +46,7 @@ pub struct IeeeFloat<S> {
4446
/// large to store the largest significands by itself.
4547
type Limb = u256;
4648
const LIMB_BITS: usize = 256;
47-
fn limbs_for_bits(bits: usize) -> usize {
48-
(bits + LIMB_BITS - 1) / LIMB_BITS
49-
}
49+
fn limbs_for_bits(bits: usize) -> usize { (bits + LIMB_BITS - 1) / LIMB_BITS }
5050

5151
/// Enum that represents what fraction of the LSB truncated bits of an fp number
5252
/// represent.
@@ -163,9 +163,7 @@ pub trait Semantics: Sized {
163163

164164
impl<S> Copy for IeeeFloat<S> {}
165165
impl<S> Clone for IeeeFloat<S> {
166-
fn clone(&self) -> Self {
167-
*self
168-
}
166+
fn clone(&self) -> Self { *self }
169167
}
170168

171169
macro_rules! ieee_semantics {
@@ -281,9 +279,7 @@ impl Semantics for X87DoubleExtendedS {
281279
float_common_impls!(IeeeFloat<S>);
282280

283281
impl<S: Semantics> PartialEq for IeeeFloat<S> {
284-
fn eq(&self, rhs: &Self) -> bool {
285-
self.partial_cmp(rhs) == Some(Ordering::Equal)
286-
}
282+
fn eq(&self, rhs: &Self) -> bool { self.partial_cmp(rhs) == Some(Ordering::Equal) }
287283
}
288284

289285
impl<S: Semantics> PartialOrd for IeeeFloat<S> {
@@ -309,11 +305,7 @@ impl<S: Semantics> PartialOrd for IeeeFloat<S> {
309305
// Compare absolute values; invert result if negative.
310306
let result = self.cmp_abs_normal(*rhs);
311307

312-
if self.sign {
313-
result.reverse()
314-
} else {
315-
result
316-
}
308+
if self.sign { result.reverse() } else { result }
317309
}))
318310
}
319311
}
@@ -695,8 +687,8 @@ impl<S: Semantics> Float for IeeeFloat<S> {
695687

696688
fn qnan(payload: Option<u256>) -> Self {
697689
IeeeFloat {
698-
sig: [S::QNAN_SIGNIFICAND
699-
| payload.map_or(u256::ZERO, |payload| {
690+
sig: [S::QNAN_SIGNIFICAND |
691+
payload.map_or(u256::ZERO, |payload| {
700692
// Zero out the excess bits of the significand.
701693
payload & ((u256::ONE << S::QNAN_BIT) - u256::ONE)
702694
})],
@@ -806,8 +798,8 @@ impl<S: Semantics> Float for IeeeFloat<S> {
806798
// If two numbers add (exactly) to zero, IEEE 754 decrees it is a
807799
// positive zero unless rounding to minus infinity, except that
808800
// adding two like-signed zeroes gives that zero.
809-
if self.category == Category::Zero
810-
&& (rhs.category != Category::Zero || self.sign != rhs.sign)
801+
if self.category == Category::Zero &&
802+
(rhs.category != Category::Zero || self.sign != rhs.sign)
811803
{
812804
self.sign = round == Round::TowardNegative;
813805
}
@@ -958,9 +950,9 @@ impl<S: Semantics> Float for IeeeFloat<S> {
958950
// If two numbers add (exactly) to zero, IEEE 754 decrees it is a
959951
// positive zero unless rounding to minus infinity, except that
960952
// adding two like-signed zeroes gives that zero.
961-
if self.category == Category::Zero
962-
&& !status.intersects(Status::UNDERFLOW)
963-
&& self.sign != addend.sign
953+
if self.category == Category::Zero &&
954+
!status.intersects(Status::UNDERFLOW) &&
955+
self.sign != addend.sign
964956
{
965957
self.sign = round == Round::TowardNegative;
966958
}
@@ -1022,10 +1014,10 @@ impl<S: Semantics> Float for IeeeFloat<S> {
10221014

10231015
fn c_fmod(mut self, rhs: Self) -> StatusAnd<Self> {
10241016
match (self.category, rhs.category) {
1025-
(Category::NaN, _)
1026-
| (Category::Zero, Category::Infinity)
1027-
| (Category::Zero, Category::Normal)
1028-
| (Category::Normal, Category::Infinity) => Status::OK.and(self),
1017+
(Category::NaN, _) |
1018+
(Category::Zero, Category::Infinity) |
1019+
(Category::Zero, Category::Normal) |
1020+
(Category::Normal, Category::Infinity) => Status::OK.and(self),
10291021

10301022
(_, Category::NaN) => {
10311023
self.sign = false;
@@ -1037,9 +1029,9 @@ impl<S: Semantics> Float for IeeeFloat<S> {
10371029
(Category::Infinity, _) | (_, Category::Zero) => Status::INVALID_OP.and(Self::NAN),
10381030

10391031
(Category::Normal, Category::Normal) => {
1040-
while self.is_finite_non_zero()
1041-
&& rhs.is_finite_non_zero()
1042-
&& self.cmp_abs_normal(rhs) != Ordering::Less
1032+
while self.is_finite_non_zero() &&
1033+
rhs.is_finite_non_zero() &&
1034+
self.cmp_abs_normal(rhs) != Ordering::Less
10431035
{
10441036
let mut v = rhs.scalbn(self.ilogb() - rhs.ilogb());
10451037
if self.cmp_abs_normal(v) == Ordering::Less {
@@ -1182,8 +1174,8 @@ impl<S: Semantics> Float for IeeeFloat<S> {
11821174
assert_ne!(
11831175
self.exp,
11841176
S::MAX_EXP,
1185-
"We can not increment an exponent beyond the MAX_EXP \
1186-
allowed by the given floating point semantics."
1177+
"We can not increment an exponent beyond the MAX_EXP allowed by the \
1178+
given floating point semantics."
11871179
);
11881180
self.exp += 1;
11891181
} else {
@@ -1317,8 +1309,8 @@ impl<S: Semantics> Float for IeeeFloat<S> {
13171309
let mut loss = Loss::ExactlyZero;
13181310
if truncated_bits > 0 {
13191311
loss = Loss::through_truncation(&self.sig, truncated_bits);
1320-
if loss != Loss::ExactlyZero
1321-
&& self.round_away_from_zero(round, loss, truncated_bits)
1312+
if loss != Loss::ExactlyZero &&
1313+
self.round_away_from_zero(round, loss, truncated_bits)
13221314
{
13231315
r = r.wrapping_add(Limb::ONE);
13241316
if r.is_zero() {
@@ -1368,14 +1360,12 @@ impl<S: Semantics> Float for IeeeFloat<S> {
13681360
self.sig == rhs.sig
13691361
}
13701362

1371-
fn is_negative(self) -> bool {
1372-
self.sign
1373-
}
1363+
fn is_negative(self) -> bool { self.sign }
13741364

13751365
fn is_denormal(self) -> bool {
1376-
self.is_finite_non_zero()
1377-
&& self.exp == S::MIN_EXP
1378-
&& !sig::get_bit(&self.sig, S::PRECISION - 1)
1366+
self.is_finite_non_zero() &&
1367+
self.exp == S::MIN_EXP &&
1368+
!sig::get_bit(&self.sig, S::PRECISION - 1)
13791369
}
13801370

13811371
fn is_signaling(self) -> bool {
@@ -1384,9 +1374,7 @@ impl<S: Semantics> Float for IeeeFloat<S> {
13841374
self.is_nan() && !sig::get_bit(&self.sig, S::QNAN_BIT)
13851375
}
13861376

1387-
fn category(self) -> Category {
1388-
self.category
1389-
}
1377+
fn category(self) -> Category { self.category }
13901378

13911379
fn get_exact_inverse(self) -> Option<Self> {
13921380
// Special floats and denormals have no exact inverse.
@@ -1501,10 +1489,10 @@ impl<S: Semantics, T: Semantics> FloatConvert<IeeeFloat<T>> for IeeeFloat<S> {
15011489
fn is_x87_double_extended<S: Semantics>() -> bool {
15021490
S::QNAN_SIGNIFICAND == X87DoubleExtendedS::QNAN_SIGNIFICAND
15031491
}
1504-
let x87_special_nan = is_x87_double_extended::<S>()
1505-
&& !is_x87_double_extended::<T>()
1506-
&& r.category == Category::NaN
1507-
&& (r.sig[0] & S::QNAN_SIGNIFICAND) != S::QNAN_SIGNIFICAND;
1492+
let x87_special_nan = is_x87_double_extended::<S>() &&
1493+
!is_x87_double_extended::<T>() &&
1494+
r.category == Category::NaN &&
1495+
(r.sig[0] & S::QNAN_SIGNIFICAND) != S::QNAN_SIGNIFICAND;
15081496

15091497
// If this is a truncation of a denormal number, and the target semantics
15101498
// has larger exponent range than the source semantics (this can happen
@@ -1948,8 +1936,8 @@ impl<S: Semantics> IeeeFloat<S> {
19481936
} else {
19491937
dec_exp = dec_exp.saturating_sub((last_sig_digit - dot) as i32);
19501938
}
1951-
let significand_digits = last_sig_digit - first_sig_digit + 1
1952-
- (dot > first_sig_digit && dot < last_sig_digit) as usize;
1939+
let significand_digits = last_sig_digit - first_sig_digit + 1 -
1940+
(dot > first_sig_digit && dot < last_sig_digit) as usize;
19531941
let normalized_exp = dec_exp.saturating_add(significand_digits as i32 - 1);
19541942

19551943
// Handle the cases where exponents are obviously too large or too
@@ -1968,16 +1956,16 @@ impl<S: Semantics> IeeeFloat<S> {
19681956
// 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
19691957

19701958
// Check for MAX_EXP.
1971-
if normalized_exp.saturating_sub(1).saturating_mul(42039) as i64
1972-
>= 12655 * S::MAX_EXP as i64
1959+
if normalized_exp.saturating_sub(1).saturating_mul(42039) as i64 >=
1960+
12655 * S::MAX_EXP as i64
19731961
{
19741962
// Overflow and round.
19751963
return Ok(Self::overflow_result(round));
19761964
}
19771965

19781966
// Check for MIN_EXP.
1979-
if normalized_exp.saturating_add(1).saturating_mul(28738) as i64
1980-
<= 8651 * (S::MIN_EXP as i64 - S::PRECISION as i64)
1967+
if normalized_exp.saturating_add(1).saturating_mul(28738) as i64 <=
1968+
8651 * (S::MIN_EXP as i64 - S::PRECISION as i64)
19811969
{
19821970
// Underflow to zero and round.
19831971
let r = if round == Round::TowardPositive {
@@ -2227,9 +2215,9 @@ impl<S: Semantics> IeeeFloat<S> {
22272215
//
22282216
// See "How to Read Floating Point Numbers Accurately" by William D Clinger.
22292217
assert!(
2230-
half_ulp_err1 < 2u8.into()
2231-
|| half_ulp_err2 < 2u8.into()
2232-
|| (half_ulp_err1 + half_ulp_err2 < 8u8.into())
2218+
half_ulp_err1 < 2u8.into() ||
2219+
half_ulp_err2 < 2u8.into() ||
2220+
(half_ulp_err1 + half_ulp_err2 < 8u8.into())
22332221
);
22342222

22352223
let inexact = Limb::from(calc_loss != Loss::ExactlyZero);
@@ -2341,9 +2329,7 @@ mod sig {
23412329

23422330
use super::{limbs_for_bits, ExpInt, Limb, Loss, LIMB_BITS};
23432331

2344-
pub(super) fn is_all_zeros(limbs: &[Limb]) -> bool {
2345-
limbs.iter().all(|&l| l.is_zero())
2346-
}
2332+
pub(super) fn is_all_zeros(limbs: &[Limb]) -> bool { limbs.iter().all(|&l| l.is_zero()) }
23472333

23482334
/// One, not zero, based LSB. That is, returns 0 for a zeroed significand.
23492335
pub(super) fn olsb(limbs: &[Limb]) -> usize {

0 commit comments

Comments
 (0)