• abbegm 0.7.4/src/lib.rs
    229
    		 
    	#[allow(clippy::suspicious_arithmetic_impl)]
    230
    		 
    	fn add(self, right: Duration) -> Self::Output {
  • abe_gpsw 2.0.0/src/core/bilinear_map/bls12_381.rs
    58
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    59
    		 
    impl<'a> Div<&'a Self> for Scalar {
  • acid2 0.2.1/src/simd.rs
    461
    		 
        #[inline]
    462
    		 
        #[allow(clippy::suspicious_arithmetic_impl)] // lol
    463
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • acir_field 0.3.1/src/generic_ark.rs
    362
    		 
        type Output = FieldElement<F>;
    363
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    364
    		 
        fn div(self, rhs: FieldElement<F>) -> Self::Output {
  • algebraics 0.3.0/src/polynomial/mul.rs
    13
    		 
        type Output = Polynomial<T>;
    14
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    15
    		 
        fn mul(self, rhs: &Polynomial<T>) -> Polynomial<T> {
  • algeo 0.1.0/src/poly/poly.rs
    369
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    370
    		 
        fn mul(self, other: &Polynomial<F>) -> Self::Output {
  • array_map 0.4.0/src/set.rs
    381
    		 
      #[allow(clippy::suspicious_arithmetic_impl)]
    382
    		 
      // Adding two sets is the same as performing a bitwise or on them
  • au 0.10.0/src/polynomial/arithmetic.rs
    346
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    347
    		 
        fn mul(self, rhs: Self) -> Poly<T> {
  • au 0.10.0/src/rational_function/arithmetic.rs
    63
    		 
    /// Implementation of rational function addition
    64
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    65
    		 
    impl<T: Clone + Mul<Output = T> + One + PartialEq + Zero> Add for &Rf<T> {
    87
    		 
    /// Implementation of rational function addition
    88
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    89
    		 
    impl<T: Clone + One + PartialEq + Zero> Add for Rf<T> {
    131
    		 
    /// Implementation of rational function subtraction
    132
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    133
    		 
    impl<T: Clone + Neg<Output = T> + PartialEq + Sub<Output = T> + Zero + One> Sub for &Rf<T> {
    155
    		 
    /// Implementation of rational function subtraction
    156
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    157
    		 
    impl<T: Clone + Neg<Output = T> + One + PartialEq + Sub<Output = T> + Zero> Sub for Rf<T> {
    221
    		 
    /// Implementation of rational function division
    222
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    223
    		 
    impl<T: Clone + One + PartialEq + Zero> Div for &Rf<T> {
  • au 0.10.0/src/transfer_function/mod.rs
    325
    		 
    /// Implementation of transfer function addition
    326
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    327
    		 
    impl<T: Float, U: Time> Add for &TfGen<T, U> {
  • automatica 1.0.0/src/rational_function/arithmetic.rs
    68
    		 
    /// Implementation of rational function addition
    69
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    70
    		 
    impl<T> Add for &Rf<T>
    95
    		 
    /// Implementation of rational function addition
    96
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    97
    		 
    impl<T> Add for Rf<T>
    147
    		 
    /// Implementation of rational function subtraction
    148
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    149
    		 
    impl<T> Sub for &Rf<T>
    181
    		 
    /// Implementation of rational function subtraction
    182
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    183
    		 
    impl<T> Sub for Rf<T>
    265
    		 
    /// Implementation of rational function division
    266
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    267
    		 
    impl<T> Div for &Rf<T>
  • automatica 1.0.0/src/transfer_function/mod.rs
    409
    		 
    /// Implementation of transfer function addition
    410
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    411
    		 
    impl<T, U> Add for &TfGen<T, U>
  • bardecoder 0.4.0/src/decode/qr/galois.rs
    11
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    12
    		 
        fn add(self, other: GF8) -> GF8 {
    21
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    22
    		 
        fn sub(self, other: GF8) -> GF8 {
    31
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    32
    		 
        fn mul(self, other: GF8) -> GF8 {
    47
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    48
    		 
        fn div(self, other: GF8) -> GF8 {
    65
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    66
    		 
        fn add(self, other: GF4) -> GF4 {
  • bellman 0.13.1/src/lib.rs
    220
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    221
    		 
        fn sub(self, (coeff, var): (Scalar, Variable)) -> LinearCombination<Scalar> {
  • bellperson 0.24.1/src/lc.rs
    296
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    297
    		 
        fn sub(self, (coeff, var): (Scalar, Variable)) -> LinearCombination<Scalar> {
  • bigint-base10 0.1.1/src/lib.rs
    353
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    354
    		 
        fn mul(self, other: &BigInteger) -> BigInteger {
  • blstrs 0.6.1/src/gt.rs
    76
    		 
        #[inline]
    77
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    78
    		 
        fn add(self, rhs: &Gt) -> Gt {
    95
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    96
    		 
        fn mul(self, scalar: &Scalar) -> Self::Output {
  • blstrs 0.6.1/src/pairing.rs
    180
    		 
        #[inline]
    181
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    182
    		 
        fn add(self, rhs: &'b MillerLoopResult) -> MillerLoopResult {
  • blsttc 8.0.1/src/poly.rs
    170
    		 
    // Clippy thinks using any `+` and `-` in a `Mul` implementation is suspicious.
    171
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    172
    		 
    impl<'a, B: Borrow<Poly>> ops::Mul<B> for &'a Poly {
  • break-eternity 0.1.1/src/lib.rs
    1903
    		 
        /// Division of two decimals by multiplying the denominator by the reciprocal of the numerator.
    1904
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    1905
    		 
        fn div(self, rhs: Decimal) -> Self::Output {
  • break_infinity 0.3.0/src/lib.rs
    241
    		 
    	#[allow(clippy::suspicious_arithmetic_impl)]
    242
    		 
    	fn sub(self, decimal: Decimal) -> Decimal {
    306
    		 
    	#[allow(clippy::suspicious_arithmetic_impl)]
    307
    		 
    	fn div(self, decimal: Decimal) -> Decimal {
  • cairo-felt 0.1.3/src/bigint_felt.rs
    483
    		 
        // In Felts `x / y` needs to be expressed as `x * y^-1`
    484
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    485
    		 
        fn div(self, rhs: Self) -> Self::Output {
    498
    		 
        // In Felts `x / y` needs to be expressed as `x * y^-1`
    499
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    500
    		 
        fn div(self, rhs: Self) -> Self::Output {
    513
    		 
        // In Felts `x / y` needs to be expressed as `x * y^-1`
    514
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    515
    		 
        fn div(self, rhs: FeltBigInt<PH, PL>) -> Self::Output {
  • cala 0.9.0/src/when.rs
    50
    		 
        // use, even though it's the division operator.
    51
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    52
    		 
        fn div(mut self, mut other: i32) -> Self::Output {
  • camel-up 0.1.0/src/fraction.rs
    69
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    70
    		 
        fn add(self, other: F) -> Self::Output {
    120
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    121
    		 
        fn div(self, other: F) -> Self::Output {
  • cao-lang 0.1.108/src/collections/handle_table.rs
    202
    		 
        fn add(self, rhs: Self) -> Self::Output {
    203
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    204
    		 
            Self(self.0 ^ rhs.0)
  • cargo-crev 0.23.3/src/deps.rs
    143
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    144
    		 
        fn add(self, other: Self) -> Self {
  • chksum 0.1.0-rc5/src/hash/md5/block.rs
    98
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    99
    		 
        #[cfg_attr(nightly, optimize(speed))]
  • chksum 0.1.0-rc5/src/hash/sha1/block.rs
    98
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    99
    		 
        #[cfg_attr(nightly, optimize(speed))]
  • chksum 0.1.0-rc5/src/hash/sha2/sha224/block.rs
    98
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    99
    		 
        #[cfg_attr(nightly, optimize(speed))]
  • chksum 0.1.0-rc5/src/hash/sha2/sha256/block.rs
    98
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    99
    		 
        #[cfg_attr(nightly, optimize(speed))]
  • chksum 0.1.0-rc5/src/hash/sha2/sha384/block.rs
    163
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    164
    		 
        #[cfg_attr(nightly, optimize(speed))]
  • chksum 0.1.0-rc5/src/hash/sha2/sha512/block.rs
    163
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    164
    		 
        #[cfg_attr(nightly, optimize(speed))]
  • clipivot 0.3.4/src/parsing.rs
    117
    		 
        /// Returns the total number of days between two dates
    118
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    119
    		 
        fn sub(self, other: CustomDateObject) -> f64 {
  • contest-algorithms 0.3.0/src/math/num.rs
    57
    		 
    }
    58
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    59
    		 
    impl Add for Rational {
    67
    		 
    }
    68
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    69
    		 
    impl Sub for Rational {
    83
    		 
    }
    84
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    85
    		 
    impl Div for Rational {
    159
    		 
    }
    160
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    161
    		 
    impl Div for Complex {
    237
    		 
    }
    238
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    239
    		 
    impl<const M: i64> Div for Modulo<M> {
  • cosmian_abe_gpsw 2.0.3/src/core/bilinear_map/bls12_381.rs
    58
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    59
    		 
    impl<'a> Div<&'a Self> for Scalar {
  • cosmian_crypto_core 6.0.0/src/asymmetric_crypto/curve25519.rs
    170
    		 
        fn div(self, rhs: &X25519PrivateKey) -> Self::Output {
    171
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    172
    		 
            X25519PrivateKey(self.0 * rhs.0.invert())
  • cosmwasm-bignumber 2.2.0/src/math.rs
    348
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    349
    		 
        fn mul(self, rhs: Uint256) -> Self::Output {
    365
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    366
    		 
        fn mul(self, rhs: Decimal256) -> Self::Output {
  • cosmwasm-std 1.2.1/src/math/decimal.rs
    553
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    554
    		 
        fn mul(self, other: Self) -> Self {
    583
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    584
    		 
        fn mul(self, rhs: Decimal) -> Self::Output {
  • cosmwasm-std 1.2.1/src/math/decimal256.rs
    578
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    579
    		 
        fn mul(self, other: Self) -> Self {
    608
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    609
    		 
        fn mul(self, rhs: Decimal256) -> Self::Output {
  • crassipes 0.2.1/src/units/rquantity.rs
    71
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    72
    		 
    impl<
    120
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    121
    		 
    impl<
  • cryptonight-hash 0.1.2/src/aes/u64p.rs
    76
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    77
    		 
            U64p((r >> 64) as u64, r as u64)
  • cryptoxide 0.4.2/src/curve25519/fe/fe32/mod.rs
    168
    		 
        #[rustfmt::skip]
    169
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    170
    		 
        fn mul(self, rhs: &Fe) -> Fe {
  • cryptoxide 0.4.2/src/curve25519/ge.rs
    380
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    381
    		 
        fn add(self, _rhs: &GeCached) -> GeP1P1 {
    406
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    407
    		 
        fn add(self, _rhs: &GePrecomp) -> GeP1P1 {
    439
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    440
    		 
        fn sub(self, _rhs: &GeCached) -> GeP1P1 {
    473
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    474
    		 
        fn sub(self, _rhs: &GePrecomp) -> GeP1P1 {
  • cute-dnd-dice 4.0.0/src/lib.rs
    86
    		 
                Modifier::Minus(modifier) => match other >= modifier {
    87
    		 
                    #[allow(clippy::suspicious_arithmetic_impl)]
    88
    		 
                    true => Modifier::Plus(other - modifier),
    89
    		 
                    #[allow(clippy::suspicious_arithmetic_impl)]
    90
    		 
                    false => Modifier::Minus(modifier - other),
  • cyfs-raptorq 1.6.1/src/octet.rs
    169
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    170
    		 
        fn add(self, other: Octet) -> Octet {
    181
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    182
    		 
        fn add(self, other: &'b Octet) -> Octet {
    190
    		 
    impl AddAssign for Octet {
    191
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::suspicious_op_assign_impl)]
    192
    		 
        fn add_assign(&mut self, other: Octet) {
    197
    		 
    impl<'a> AddAssign<&'a Octet> for Octet {
    198
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::suspicious_op_assign_impl)]
    199
    		 
        fn add_assign(&mut self, other: &'a Octet) {
    207
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    208
    		 
        fn sub(self, rhs: Octet) -> Octet {
  • dashu-int 0.3.1/src/modular/div.rs
    160
    		 
            // Clippy doesn't like that div is implemented using mul.
    161
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    162
    		 
            match rhs.inv() {
  • datamatrix 0.3.0/src/errorcode/galois.rs
    102
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    103
    		 
        fn add(self, rhs: Self) -> Self {
    117
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    118
    		 
        fn sub(self, rhs: Self) -> Self {
  • datetime 0.5.2/src/duration.rs
    46
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    47
    		 
    impl Add<Duration> for Duration {
    61
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    62
    		 
    impl Sub<Duration> for Duration {
    76
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    77
    		 
    impl Mul<i64> for Duration {
  • ddshow 0.2.2/src/dataflow/operators/min_max.rs
    62
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    63
    		 
    impl<T> Mul<Self> for Min<T>
    192
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    193
    		 
    impl<T> Mul<Self> for Max<T>
  • dusk-jubjub 0.12.1/src/lib.rs
    34
    		 
    // binary operators, and so this lint is triggered unnecessarily.
    35
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    866
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    867
    		 
        fn add(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    905
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    906
    		 
        fn sub(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    927
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    928
    		 
        fn add(self, other: &'b AffineNielsPoint) -> JubJubExtended {
    953
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    954
    		 
        fn sub(self, other: &'b AffineNielsPoint) -> JubJubExtended {
  • easyfft 0.3.5/src/const_size/realfft.rs
    287
    		 
        fn mul(self, rhs: T) -> Self::Output {
    288
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    289
    		 
            let mut inner = [Complex::default(); SIZE / 2 + 1];
  • ed448-rust 0.1.1/src/point.rs
    232
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    233
    		 
    impl Div<&'_ Self> for Field {
  • embedded-time 0.12.1/src/fraction.rs
    123
    		 
        /// Panicky u32 / `Fraction` = u32
    124
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    125
    		 
        fn div(self, rhs: Fraction) -> Self::Output {
    142
    		 
        /// Panicky u64 / `Fraction` = u64
    143
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    144
    		 
        fn div(self, rhs: Fraction) -> Self::Output {
  • euphony-units 0.1.1/src/time/beat.rs
    50
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    51
    		 
        fn mul(self, time_signature: TimeSignature) -> Self::Output {
  • everscale-raptorq 1.7.0/src/octet.rs
    169
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    170
    		 
        fn add(self, other: Octet) -> Octet {
    181
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    182
    		 
        fn add(self, other: &'b Octet) -> Octet {
    190
    		 
    impl AddAssign for Octet {
    191
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::suspicious_op_assign_impl)]
    192
    		 
        fn add_assign(&mut self, other: Octet) {
    197
    		 
    impl<'a> AddAssign<&'a Octet> for Octet {
    198
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::suspicious_op_assign_impl)]
    199
    		 
        fn add_assign(&mut self, other: &'a Octet) {
    207
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    208
    		 
        fn sub(self, rhs: Octet) -> Octet {
  • fawkes-crypto 4.4.0/src/circuit/r1cs/num.rs
    383
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    384
    		 
    impl<'l, C: CS> Div<&'l CNum<C>> for Num<C::Fr> {
  • fullcodec-jubjub 0.2.0/src/lib.rs
    34
    		 
    // binary operators, and so this lint is triggered unnecessarily.
    35
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    839
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    840
    		 
        fn add(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    878
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    879
    		 
        fn sub(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    900
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    901
    		 
        fn add(self, other: &'b AffineNielsPoint) -> JubJubExtended {
    926
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    927
    		 
        fn sub(self, other: &'b AffineNielsPoint) -> JubJubExtended {
  • g2poly 1.0.1/src/lib.rs
    228
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    229
    		 
        fn add(self, rhs: G2Poly) -> G2Poly {
    237
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    238
    		 
        fn sub(self, rhs: G2Poly) -> G2Poly {
  • geo-aid 0.2.0/src/script.rs
    432
    		 
                // Clippy doesn't like exponentiation. Thanks, Clippy
    433
    		 
                #[allow(clippy::suspicious_arithmetic_impl)]
    434
    		 
                _ => self[rhs as usize] += 1,
    458
    		 
                // Oh, c'mon, Clippy
    459
    		 
                #[allow(clippy::suspicious_arithmetic_impl)]
    460
    		 
                _ => self[rhs as usize] -= 1,
  • halo2_gadgets 0.2.0/src/sinsemilla/primitives/addition.rs
    28
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    29
    		 
        fn add(self, rhs: Self) -> Self::Output {
    52
    		 
        /// Specialisation of incomplete addition for mixed addition.
    53
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    54
    		 
        fn add(self, rhs: pallas::Affine) -> Self::Output {
  • harpo 0.7.0/src/math.rs
    204
    		 
        // This directive is required because division uses multiplication with the inverse element.
    205
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    206
    		 
        /// The function defines division for finite field elements.
  • heim-cpu 0.1.0-rc.1/src/usage.rs
    22
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::cast_lossless)]
    23
    		 
        fn sub(self, rhs: CpuUsage) -> Self::Output {
  • heim-process 0.1.1-rc.1/src/process/cpu_usage.rs
    21
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::cast_lossless)]
    22
    		 
        fn sub(self, rhs: CpuUsage) -> Self::Output {
  • httproxide-h3 0.0.0/src/proto/stream.rs
    164
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    165
    		 
        fn add(self, rhs: usize) -> Self::Output {
  • hugefloat 0.1.0/src/lib.rs
    465
    		 
      #[allow(clippy::suspicious_arithmetic_impl)]
    466
    		 
      fn mul(self, other: Self) -> Self::Output {
    502
    		 
      #[allow(clippy::suspicious_arithmetic_impl)]
    503
    		 
      fn div(self, other: Self) -> Self::Output {
  • hyperdual 1.1.0/src/lib.rs
    593
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    594
    		 
        #[inline]
    609
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    610
    		 
        #[inline]
    673
    		 
        #[inline]
    674
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    675
    		 
        fn div(self, rhs: Self) -> Self {
    691
    		 
        #[inline]
    692
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    693
    		 
        fn div(self, rhs: &Self) -> Self {
  • ibig 0.3.6/src/modular/div.rs
    66
    		 
            // Clippy doesn't like that division is implemented using multiplication.
    67
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    68
    		 
            match rhs.inverse() {
  • ichen-openprotocol 0.5.0/src/filters.rs
    149
    		 
        /// ~~~
    150
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    151
    		 
        fn add(self, rhs: Self) -> Self::Output {
  • isochronous_finite_fields 1.0.1/src/lib.rs
    120
    		 
        fn add(self, rhs: Self) -> Self::Output {
    121
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    122
    		 
            Self(self.0 ^ rhs.0)
  • jk-cosmwasm-std 0.16.2/src/math/decimal.rs
    214
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    215
    		 
        fn mul(self, rhs: Decimal) -> Self::Output {
  • jk-cosmwasm-std 0.16.2/src/math/decimal256.rs
    223
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    224
    		 
        fn mul(self, rhs: Decimal256) -> Self::Output {
  • jubjub 0.9.0/src/lib.rs
    28
    		 
    // operators, and so this lint is triggered unnecessarily.
    29
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    886
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    887
    		 
        fn add(self, other: &'b ExtendedNielsPoint) -> ExtendedPoint {
    925
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    926
    		 
        fn sub(self, other: &'b ExtendedNielsPoint) -> ExtendedPoint {
    947
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    948
    		 
        fn add(self, other: &'b AffineNielsPoint) -> ExtendedPoint {
    973
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    974
    		 
        fn sub(self, other: &'b AffineNielsPoint) -> ExtendedPoint {
  • kurbo 0.9.0/src/ellipse.rs
    158
    		 
        #[inline]
    159
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    160
    		 
        fn add(self, v: Vec2) -> Ellipse {
  • kurbo 0.9.0/src/insets.rs
    262
    		 
        #[inline]
    263
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    264
    		 
        fn add(self, other: Rect) -> Rect {
  • kurbo 0.9.0/src/vec2.rs
    329
    		 
        #[inline]
    330
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    331
    		 
        fn div(self, other: f64) -> Vec2 {
  • lset 0.3.0/src/span.rs
    172
    		 
        #[inline(always)]
    173
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    174
    		 
        fn shl(self, rhs: T) -> Self::Output {
    213
    		 
        #[inline(always)]
    214
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    215
    		 
        fn shr(self, rhs: T) -> Self::Output {
  • lunardate 0.2.1/src/lib.rs
    358
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    359
    		 
    impl Sub<time::Duration> for LunarDate {
  • magnesia 0.9.2/src/linalg/svector.rs
    240
    		 
        /// ```
    241
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    242
    		 
        fn mul(self, other: &Self) -> Self::Output {
  • mars-core 1.0.0/src/math/decimal.rs
    264
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    265
    		 
        fn mul(self, rhs: Decimal) -> Self::Output {
  • mg-shamir 1.0.0/src/field/gf256.rs
    185
    		 
        #[inline]
    186
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    187
    		 
        fn add(self, rhs: Gf256) -> Gf256 {
    201
    		 
        #[inline]
    202
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    203
    		 
        fn sub(self, rhs: Gf256) -> Gf256 {
  • minimal-ed448 0.1.2/src/point.rs
    138
    		 
      type Output = Point;
    139
    		 
      #[allow(clippy::suspicious_arithmetic_impl)]
    140
    		 
      fn sub(self, other: Self) -> Self {
  • nalgebra 0.32.1/src/geometry/unit_complex_ops.rs
    99
    		 
        fn div(self, rhs: Self) -> Self::Output {
    100
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    101
    		 
            Unit::new_unchecked(self.into_inner() * rhs.conjugate().into_inner())
    112
    		 
        fn div(self, rhs: UnitComplex<T>) -> Self::Output {
    113
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    114
    		 
            Unit::new_unchecked(self.complex() * rhs.conjugate().into_inner())
    125
    		 
        fn div(self, rhs: &'b UnitComplex<T>) -> Self::Output {
    126
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    127
    		 
            Unit::new_unchecked(self.into_inner() * rhs.conjugate().into_inner())
    138
    		 
        fn div(self, rhs: &'b UnitComplex<T>) -> Self::Output {
    139
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    140
    		 
            Unit::new_unchecked(self.complex() * rhs.conjugate().into_inner())
  • negatable-set 0.1.0/src/lib.rs
    445
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    446
    		 
    impl<'a, I: MutableSet> Sub for &'a NegatableSet<I>
  • nimiq-tree-primitives 0.2.0/src/address_nibbles.rs
    193
    		 
        type Output = AddressNibbles;
    194
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    195
    		 
        fn add(self, other: &'b AddressNibbles) -> AddressNibbles {
  • nnv-rs 0.6.1/src/affine.rs
    304
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    305
    		 
        fn mul(self, rhs: &'b Affine2) -> Affine2 {
    316
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    317
    		 
        fn mul(self, rhs: &Self) -> Self {
  • nova-math 0.5.0/src/quaternion.rs
    183
    		 
        #[inline]
    184
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    185
    		 
        fn mul(self, rhs: TVec3<T>) -> Self::Output {
  • ntex-util 0.2.0/src/time/types.rs
    65
    		 
        #[inline]
    66
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    67
    		 
        fn add(self, other: Seconds) -> Millis {
  • numb_rs 0.0.4/src/fraction.rs
    104
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    105
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • orchard 0.3.0/src/value.rs
    130
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    131
    		 
        fn sub(self, rhs: Self) -> Self::Output {
    184
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    185
    		 
        fn add(self, rhs: Self) -> Self::Output {
  • pako-tools 0.1.2/src/duration.rs
    30
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    31
    		 
        fn add(self, other: Duration) -> Self::Output {
    47
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    48
    		 
        fn sub(self, other: Duration) -> Self::Output {
  • plonk-jubjub 0.2.0/src/lib.rs
    34
    		 
    // binary operators, and so this lint is triggered unnecessarily.
    35
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    839
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    840
    		 
        fn add(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    878
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    879
    		 
        fn sub(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    900
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    901
    		 
        fn add(self, other: &'b AffineNielsPoint) -> JubJubExtended {
    926
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    927
    		 
        fn sub(self, other: &'b AffineNielsPoint) -> JubJubExtended {
  • plonky2_field 0.1.0/src/extension/quadratic.rs
    218
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    219
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • plonky2_field 0.1.0/src/extension/quartic.rs
    244
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    245
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • plonky2_field 0.1.0/src/extension/quintic.rs
    259
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    260
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • plonky2_field 0.1.0/src/goldilocks_field.rs
    198
    		 
        #[inline]
    199
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    200
    		 
        fn add(self, rhs: Self) -> Self {
    235
    		 
        #[inline]
    236
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    237
    		 
        fn sub(self, rhs: Self) -> Self {
    288
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    289
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • plonky2_field 0.1.0/src/polynomial/mod.rs
    423
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    424
    		 
        fn mul(self, rhs: Self) -> Self::Output {
  • plonky2_field 0.1.0/src/secp256k1_base.rs
    199
    		 
        #[inline]
    200
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    201
    		 
        fn sub(self, rhs: Self) -> Self {
    241
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    242
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • plonky2_field 0.1.0/src/secp256k1_scalar.rs
    207
    		 
        #[inline]
    208
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    209
    		 
        fn sub(self, rhs: Self) -> Self {
  • poly 0.1.0/src/mul.rs
    47
    		 
    					// oddly enough, the later += doesn't trigger a warning
    48
    		 
    					#[allow(clippy::suspicious_arithmetic_impl)]
    49
    		 
    					rev_coeffs.get_unchecked_mut(el + er)
  • polynomen 1.0.0/src/arithmetic.rs
    338
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    339
    		 
        fn mul(self, rhs: Self) -> Poly<T> {
  • polyval 0.6.0/src/backend/soft32.rs
    133
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    134
    		 
    impl Add for U32x4 {
    148
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    149
    		 
    impl Mul for U32x4 {
  • polyval 0.6.0/src/backend/soft64.rs
    108
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    109
    		 
    impl Add for U64x2 {
    118
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    119
    		 
    impl Mul for U64x2 {
  • prefixset 0.1.0-rc.2/src/node/gluemap.rs
    90
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    91
    		 
        fn add(self, other: Self) -> Self::Output {
    99
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    100
    		 
        fn mul(self, other: Self) -> Self::Output {
  • prefixset 0.1.0-rc.2/src/set/ops.rs
    75
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    76
    		 
        fn add(self, rhs: Self) -> Self::Output {
    97
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    98
    		 
        fn mul(self, rhs: Self) -> Self::Output {
  • prov-cosmwasm-std 1.0.0-provbeta3/src/math/decimal.rs
    308
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    309
    		 
        fn mul(self, other: Self) -> Self {
    330
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    331
    		 
        fn mul(self, rhs: Decimal) -> Self::Output {
  • prov-cosmwasm-std 1.0.0-provbeta3/src/math/decimal256.rs
    321
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    322
    		 
        fn mul(self, other: Self) -> Self {
    343
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    344
    		 
        fn mul(self, rhs: Decimal256) -> Self::Output {
  • puny2d 0.0.2/src/vector/transformation.rs
    31
    		 
        type Output = Self;
    32
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    33
    		 
        fn mul(self, other: Self) -> Self::Output {
  • quantity 0.6.0/src/si.rs
    154
    		 
        type Output = Self;
    155
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    156
    		 
        fn mul(self, other: Self) -> Self {
    170
    		 
        type Output = Self;
    171
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    172
    		 
        fn div(self, other: Self) -> Self {
    497
    		 
        type Output = SINumber;
    498
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    499
    		 
        fn mul(self, _: CELSIUS) -> SINumber {
    508
    		 
        type Output = SIArray<D>;
    509
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    510
    		 
        fn mul(self, _: CELSIUS) -> SIArray<D> {
    519
    		 
        type Output = f64;
    520
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    521
    		 
        fn div(self, _: CELSIUS) -> f64 {
  • r1cs 0.4.7/src/field.rs
    441
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    442
    		 
        fn div(self, rhs: &Element<F>) -> Element<F> {
  • ranged_type 0.1.0/src/ranged_i32/add/ranged_i32.rs
    10
    		 
    {
    11
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    12
    		 
        type Output = RangedI32<{ START + START_RHS }, { END + END_RHS - 1 }>;
  • ranged_type 0.1.0/src/ranged_i32/sub/ranged_i32.rs
    10
    		 
    {
    11
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    12
    		 
        type Output = RangedI32<{ START - END_RHS + 1 }, { END - START_RHS - 1 }>;
  • raptorq 1.7.0/src/octet.rs
    169
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    170
    		 
        fn add(self, other: Octet) -> Octet {
    181
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    182
    		 
        fn add(self, other: &'b Octet) -> Octet {
    190
    		 
    impl AddAssign for Octet {
    191
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::suspicious_op_assign_impl)]
    192
    		 
        fn add_assign(&mut self, other: Octet) {
    197
    		 
    impl<'a> AddAssign<&'a Octet> for Octet {
    198
    		 
        #[allow(clippy::suspicious_arithmetic_impl, clippy::suspicious_op_assign_impl)]
    199
    		 
        fn add_assign(&mut self, other: &'a Octet) {
    207
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    208
    		 
        fn sub(self, rhs: Octet) -> Octet {
  • rbop 0.2.0/src/number.rs
    292
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    293
    		 
        fn div(self, rhs: Self) -> Self::Output {
  • redis-cell 0.2.2/src/redis/mod.rs
    6
    		 
    #[cfg_attr(feature = "cargo-clippy",
    7
    		 
               allow(redundant_field_names, suspicious_arithmetic_impl))]
    8
    		 
    pub mod raw;
  • reverie-zk 0.3.2/src/algebra/mod.rs
    15
    		 
    #[allow(clippy::suspicious_arithmetic_impl)] // Clippy thinks GF2 arithmetic is suspicious
    16
    		 
    pub mod gf2;
  • rink-core 0.6.2/src/number.rs
    950
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    951
    		 
        fn mul(self, other: &Number) -> Self::Output {
    969
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    970
    		 
        fn div(self, other: &Number) -> Self::Output {
  • rink-core 0.6.2/src/substance.rs
    399
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    400
    		 
        fn add(self, other: &'b Substance) -> Self::Output {
  • risq 0.4.1/src/domain/amount.rs
    79
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    80
    		 
        fn mul(self, right: Self) -> Self {
    114
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    115
    		 
        fn div(self, rhs: u64) -> Self::Output {
  • roaring 0.10.1/src/bitmap/store/array_store/mod.rs
    290
    		 
        fn bitor(self, rhs: Self) -> Self::Output {
    291
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    292
    		 
            let capacity = self.vec.len() + rhs.vec.len();
    383
    		 
        fn bitxor(self, rhs: Self) -> Self::Output {
    384
    		 
            #[allow(clippy::suspicious_arithmetic_impl)]
    385
    		 
            let capacity = self.vec.len() + rhs.vec.len();
  • robocopyrs 1.0.0/src/filter.rs
    199
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    200
    		 
        fn add(self, rhs: Self) -> Self::Output {
    276
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    277
    		 
        fn add(self, rhs: Self) -> Self::Output {
  • robocopyrs 1.0.0/src/lib.rs
    58
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    59
    		 
        fn add(self, rhs: Self) -> Self::Output {
    162
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    163
    		 
        fn add(self, rhs: Self) -> Self::Output {
    260
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    261
    		 
        fn add(self, rhs: Self) -> Self::Output {
  • rtlola-interpreter 0.9.0/src/storage/window_aggregations.rs
    61
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    62
    		 
    impl Add for ConjIv {
    102
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    103
    		 
    impl Add for DisjIv {
    216
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    217
    		 
    impl Add for IntegralIv {
  • rubble 0.0.4/src/link/seq_num.rs
    34
    		 
        #[allow(clippy::suspicious_arithmetic_impl)] // Use of `^` is correct
    35
    		 
        fn add(self, rhs: Self) -> Self {
  • RustQuant 0.0.13/src/autodiff/overload.rs
    328
    		 
        #[inline]
    329
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    330
    		 
        fn div(self, other: f64) -> Self::Output {
  • s3find 0.7.2/src/command.rs
    261
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    262
    		 
        fn add(mut self: FindStat, list: &[Object]) -> Self {
  • salvo-http3 0.0.0/src/proto/stream.rs
    158
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    159
    		 
        fn add(self, rhs: usize) -> Self::Output {
  • salvo-quinn 0.0.1/src/proto/stream.rs
    164
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    165
    		 
        fn add(self, rhs: usize) -> Self::Output {
  • scriptful 0.4.0/src/core/value.rs
    58
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    59
    		 
    impl core::ops::Add for Value {
    75
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    76
    		 
    impl core::ops::Mul for Value {
  • secret-cosmwasm-std 1.0.0/src/math/decimal.rs
    392
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    393
    		 
        fn mul(self, other: Self) -> Self {
    422
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    423
    		 
        fn mul(self, rhs: Decimal) -> Self::Output {
  • secret-cosmwasm-std 1.0.0/src/math/decimal256.rs
    404
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    405
    		 
        fn mul(self, other: Self) -> Self {
    434
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    435
    		 
        fn mul(self, rhs: Decimal256) -> Self::Output {
  • secure-reliable-transport 0.2.1/src/protocol/mod.rs
    73
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    74
    		 
        fn add(self, rhs: TimeSpan) -> Self::Output {
  • shamir_file_secret_sharing 1.0.0/src/galois_field_256.rs
    109
    		 
        /// New element, sum of `self` and `rhs`.
    110
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    111
    		 
        fn add(self, rhs: Self) -> Self {
  • sharks 0.5.0/src/field.rs
    73
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    74
    		 
    impl Add for GF256 {
    82
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    83
    		 
    impl Sub for GF256 {
    91
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    92
    		 
    impl Mul for GF256 {
    107
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    108
    		 
    impl Div for GF256 {
  • snarkvm-algorithms 0.9.11/src/fft/polynomial/dense.rs
    409
    		 
        #[inline]
    410
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    411
    		 
        fn mul(self, other: &'a DensePolynomial<F>) -> DensePolynomial<F> {
    446
    		 
    impl<F: Field> MulAssign<F> for DensePolynomial<F> {
    447
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    448
    		 
        fn mul_assign(&mut self, other: F) {
  • snarkvm-curves 0.9.11/src/templates/short_weierstrass_jacobian/projective.rs
    505
    		 
        /// Performs scalar multiplication of this element.
    506
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    507
    		 
        #[inline]
  • snarkvm-curves 0.9.11/src/templates/twisted_edwards_extended/projective.rs
    370
    		 
        /// Performs scalar multiplication of this element.
    371
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    372
    		 
        #[inline]
  • snarkvm-models 0.0.6/src/gadgets/r1cs/constraint_variable.rs
    300
    		 
        #[inline]
    301
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    302
    		 
        fn sub(self, (coeff, other): (F, &'a Self)) -> Self {
  • snarkvm-models 0.0.6/src/gadgets/r1cs/linear_combination.rs
    370
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    371
    		 
        fn add(self, (mul_coeff, other): (F, &LinearCombination<F>)) -> LinearCombination<F> {
    391
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    392
    		 
        fn add(self, (mul_coeff, other): (F, &'a LinearCombination<F>)) -> LinearCombination<F> {
    412
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    413
    		 
        fn add(self, (mul_coeff, mut other): (F, LinearCombination<F>)) -> LinearCombination<F> {
    432
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    433
    		 
        fn add(self, (mul_coeff, other): (F, Self)) -> Self {
  • snarkvm-r1cs 0.9.11/src/constraint_variable.rs
    298
    		 
        #[inline]
    299
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    300
    		 
        fn sub(self, (coeff, other): (F, &'a Self)) -> Self {
  • snarkvm-r1cs 0.9.11/src/linear_combination.rs
    335
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    336
    		 
        fn add(self, (mul_coeff, other): (F, &LinearCombination<F>)) -> LinearCombination<F> {
    351
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    352
    		 
        fn add(self, (mul_coeff, other): (F, &'a LinearCombination<F>)) -> LinearCombination<F> {
    367
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    368
    		 
        fn add(self, (mul_coeff, mut other): (F, LinearCombination<F>)) -> LinearCombination<F> {
    382
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    383
    		 
        fn add(self, (mul_coeff, other): (F, Self)) -> Self {
  • spectrusty-core 0.4.0/src/clock/ops.rs
    136
    		 
        #[inline]
    137
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    138
    		 
        fn add(self, delta: FTs) -> Self {
    159
    		 
        #[inline]
    160
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    161
    		 
        fn sub(self, delta: FTs) -> Self {
    182
    		 
        #[inline]
    183
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    184
    		 
        fn add(self, delta: u32) -> Self {
    206
    		 
        #[inline]
    207
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    208
    		 
        fn sub(self, delta: u32) -> Self {
  • spl-zk-token-sdk 0.1.0/src/encryption/pedersen.rs
    155
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    156
    		 
        fn div(self, other: &'b Scalar) -> PedersenOpening {
    231
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    232
    		 
        fn div(self, other: &'b Scalar) -> PedersenCommitment {
    315
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    316
    		 
        fn div(self, other: &'b Scalar) -> PedersenDecryptHandle {
  • sssmc39 0.0.3/src/field/gf256.rs
    184
    		 
    	#[inline]
    185
    		 
    	#[allow(clippy::suspicious_arithmetic_impl)]
    186
    		 
    	fn add(self, rhs: Gf256) -> Gf256 {
    200
    		 
    	#[inline]
    201
    		 
    	#[allow(clippy::suspicious_arithmetic_impl)]
    202
    		 
    	fn sub(self, rhs: Gf256) -> Gf256 {
  • starknet-curve 0.1.0/src/ec_point.rs
    130
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    131
    		 
        fn mul(self, rhs: &[bool]) -> Self::Output {
    279
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    280
    		 
        fn mul(self, rhs: &[bool]) -> Self::Output {
  • static-math 0.2.3/src/quaternion.rs
    179
    		 
    // q / q
    180
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    181
    		 
    impl<T: Float + Signed> Div for Quaternion<T> {
  • tai64 4.0.0/src/lib.rs
    257
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    258
    		 
    impl ops::Add<Duration> for Tai64N {
  • threshold_crypto 0.4.0/src/poly.rs
    152
    		 
    // Clippy thinks using `+` in a `Sub` implementation is suspicious.
    153
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    154
    		 
    impl<'a> ops::Sub<Fr> for Poly {
    171
    		 
    // Clippy thinks using any `+` and `-` in a `Mul` implementation is suspicious.
    172
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    173
    		 
    impl<'a, B: Borrow<Poly>> ops::Mul<B> for &'a Poly {
  • threshold_crypto_ce 0.4.0/src/bls12/poly.rs
    145
    		 
    // Clippy thinks using `+` in a `Sub` implementation is suspicious.
    146
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    147
    		 
    impl<'a> ops::Sub<Fr> for Poly {
    164
    		 
    // Clippy thinks using any `+` and `-` in a `Mul` implementation is suspicious.
    165
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    166
    		 
    impl<'a, B: Borrow<Poly>> ops::Mul<B> for &'a Poly {
  • threshold_crypto_ce 0.4.0/src/bn256/poly.rs
    145
    		 
    // Clippy thinks using `+` in a `Sub` implementation is suspicious.
    146
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    147
    		 
    impl<'a> ops::Sub<Fr> for Poly {
    164
    		 
    // Clippy thinks using any `+` and `-` in a `Mul` implementation is suspicious.
    165
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    166
    		 
    impl<'a, B: Borrow<Poly>> ops::Mul<B> for &'a Poly {
  • todo-txt 3.0.0-beta.2/src/task/recurrence.rs
    62
    		 
            let delta_months = match self.period {
    63
    		 
                #[allow(clippy::suspicious_arithmetic_impl)]
    64
    		 
                Year => 12 * self.num as u32,
  • twenty-first 0.15.0/src/shared_math/b_field_element.rs
    425
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    426
    		 
        #[inline(always)]
    487
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    488
    		 
        #[inline]
    512
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    513
    		 
        fn div(self, other: Self) -> Self {
  • twenty-first 0.15.0/src/shared_math/x_field_element.rs
    522
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    523
    		 
        fn div(self, other: Self) -> Self {
  • ucum 0.1.0/src/dimension.rs
    173
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    174
    		 
        fn mul(self, other: Dimension) -> Self::Output {
    193
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    194
    		 
        fn div(self, other: Dimension) -> Self::Output {
  • uncertainty 0.2.1/src/ops/div.rs
    8
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    9
    		 
        fn div(self, other: RelUnc) -> Self::Output {
  • uncertainty 0.2.1/src/ops/mul.rs
    8
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    9
    		 
        fn mul(self, other: RelUnc) -> Self::Output {
  • uncertainty 0.2.1/src/ops/sub.rs
    8
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    9
    		 
        fn sub(self, other: Self) -> Self::Output {
  • uncertainty-rs 0.1.0/src/ops/div.rs
    8
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    9
    		 
        fn div(self, other: RelUnc) -> Self::Output {
  • uncertainty-rs 0.1.0/src/ops/mul.rs
    8
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    9
    		 
        fn mul(self, other: RelUnc) -> Self::Output {
  • uncertainty-rs 0.1.0/src/ops/sub.rs
    8
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    9
    		 
        fn sub(self, other: Self) -> Self::Output {
  • vec-collections 0.4.3/src/total_vec_set.rs
    275
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    276
    		 
    impl<T: Ord + Clone, A: Array<Item = T>> Sub for &TotalVecSet<A> {
  • vecmat 0.7.8/src/complex/complex_.rs
    404
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    405
    		 
    impl<T> Div for Complex<T>
  • vecmat 0.7.8/src/complex/quaternion.rs
    531
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    532
    		 
    impl<T> Div for Quaternion<T>
    540
    		 
    }
    541
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    542
    		 
    impl<T> Div<Complex<T>> for Quaternion<T>
    550
    		 
    }
    551
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    552
    		 
    impl<T> Div<Quaternion<T>> for Complex<T>
  • voile-util 0.2.2/src/loc.rs
    47
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    48
    		 
        fn add(self, rhs: Self) -> Self::Output {
  • vortex-common 0.3.1/src/utils.rs
    201
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    202
    		 
        fn mul(self, other: Self) -> Self {
  • w5500-tls 0.1.3/src/crypto/aes/ghash.rs
    81
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    82
    		 
    impl Add for U32x4 {
    96
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    97
    		 
    impl Mul for U32x4 {
  • weresocool_ast 1.0.43/src/operations/mod.rs
    194
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    195
    		 
    impl Mul<PointOp> for PointOp {
    226
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    227
    		 
    impl<'a, 'b> Mul<&'b PointOp> for &'a PointOp {
  • winter-math 0.4.2/src/field/extensions/cubic.rs
    223
    		 
        #[inline]
    224
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    225
    		 
        fn div(self, rhs: Self) -> Self {
  • winter-math 0.4.2/src/field/extensions/quadratic.rs
    214
    		 
        #[inline]
    215
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    216
    		 
        fn div(self, rhs: Self) -> Self {
  • winter-math 0.4.2/src/field/f64/mod.rs
    265
    		 
        #[inline]
    266
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    267
    		 
        fn add(self, rhs: Self) -> Self {
    285
    		 
        #[inline]
    286
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    287
    		 
        fn sub(self, rhs: Self) -> Self {
    320
    		 
        #[inline]
    321
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    322
    		 
        fn div(self, rhs: Self) -> Self {
  • yolol-devices 0.3.3/src/value/int.rs
    165
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    166
    		 
        fn mul(self, rhs: Self) -> Self::Output {
  • ysbell 0.1.2/src/lib.rs
    244
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    245
    		 
        fn sub(self, (mut coeff, var): (E::Fr, Variable)) -> LinearCombination<E> {
  • zcash_primitives 0.10.0/src/sapling/value/sums.rs
    44
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    45
    		 
        fn add(self, rhs: NoteValue) -> Self::Output {
    53
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    54
    		 
        fn sub(self, rhs: NoteValue) -> Self::Output {
  • zenoh-protocol-core 0.7.0-rc/src/key_expr/owned.rs
    76
    		 
    }
    77
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    78
    		 
    impl std::ops::Div<&keyexpr> for OwnedKeyExpr {
    83
    		 
    }
    84
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    85
    		 
    impl std::ops::Div<&keyexpr> for &OwnedKeyExpr {
  • zero-jubjub 0.2.5/src/curve.rs
    959
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    960
    		 
        fn add(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    998
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    999
    		 
        fn sub(self, other: &'b ExtendedNielsPoint) -> JubJubExtended {
    1020
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    1021
    		 
        fn add(self, other: &'b AffineNielsPoint) -> JubJubExtended {
    1046
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    1047
    		 
        fn sub(self, other: &'b AffineNielsPoint) -> JubJubExtended {
  • zkp-primefield 0.2.0/src/ops.rs
    161
    		 
        // Division suspiciously requires multiplication
    162
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    163
    		 
        #[inline(always)]
    172
    		 
        // Division suspiciously requires multiplication
    173
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    174
    		 
        #[inline(always)]
    183
    		 
        // Division suspiciously requires multiplication
    184
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    185
    		 
        #[inline(always)]
    194
    		 
        // Division suspiciously requires multiplication
    195
    		 
        #[allow(clippy::suspicious_arithmetic_impl)]
    196
    		 
        #[inline(always)]
  • zkp-stark 0.2.1/src/rational_expression.rs
    114
    		 
    // Clippy false positive
    115
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    116
    		 
    impl<T: Into<RationalExpression>> Sub<T> for RationalExpression {
    132
    		 
    // Clippy false positive
    133
    		 
    #[allow(clippy::suspicious_arithmetic_impl)]
    134
    		 
    impl<T: Into<RationalExpression>> Div<T> for RationalExpression {
  • ark-poly 0.4.0/src/lib.rs
    14
    		 
        clippy::suspicious_op_assign_impl,
    15
    		 
        clippy::suspicious_arithmetic_impl
    16
    		 
    )]
  • ark-relations 0.4.0/src/r1cs/impl_lc.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • bellperson 0.24.1/src/lib.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    2
    		 
    //! `bellperson` is a crate for building zk-SNARK circuits. It provides circuit
  • bigdecimal 0.3.0/src/lib.rs
    43
    		 
    #![allow(clippy::needless_return)]
    44
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    45
    		 
    #![allow(clippy::suspicious_op_assign_impl)]
  • bls12_381 0.7.1/src/lib.rs
    23
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    24
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • bls12_381_plus 0.7.0/src/lib.rs
    23
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    24
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • competitive-programming-rs 41.0.0/src/lib.rs
    4
    		 
    #![allow(clippy::module_inception)]
    5
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    6
    		 
    /// Algorithms related to graph theory.
  • cosmian_bls12_381 0.4.1/src/lib.rs
    23
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    24
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • curst 0.1.0/src/lib.rs
    37
    		 
        clippy::implicit_return, // Goes against rust convention and requires return calls in places it is not helpful (e.g. closures).
    38
    		 
        clippy::suspicious_arithmetic_impl, // Not always valid; issues should be detected by tests or other lints.
    39
    		 
        clippy::suspicious_op_assign_impl, // Not always valid; issues should be detected by tests or other lints.
  • dashu-ratio 0.3.1/src/add.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)] // Clippy doesn't like that add/sub is implemented with mul.
  • dashu-ratio 0.3.1/src/div.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)] // Clippy doesn't like that div is implemented with mul.
  • dimensional_quantity 0.0.1/src/si/extended/operations_generic.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • dimensional_quantity 0.0.1/src/si/isq/operations_generic.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • dusk-bls12_381 0.11.2/src/lib.rs
    22
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    23
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • dusk-plonk 0.13.1/src/lib.rs
    40
    		 
    // Bitshift/Bitwise ops are allowed to gain performance.
    41
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    42
    		 
    // Some structs do not have AddAssign or MulAssign impl.
  • ed25519-compact 2.0.4/src/lib.rs
    101
    		 
        clippy::cast_lossless,
    102
    		 
        clippy::suspicious_arithmetic_impl,
    103
    		 
        clippy::identity_op
  • etcd-rs 1.0.0/src/lib.rs
    2
    		 
        clippy::suspicious_op_assign_impl,
    3
    		 
        clippy::suspicious_arithmetic_impl,
    4
    		 
        clippy::module_inception
  • fullcodec-bls12_381 0.2.0/src/lib.rs
    22
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    23
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • fullcodec-plonk 0.2.0/src/lib.rs
    43
    		 
    // Bitshift/Bitwise ops are allowed to gain performance.
    44
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    45
    		 
    // Some structs do not have AddAssign or MulAssign impl.
  • gf 0.6.1/src/impls.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • halo2-core 0.1.0-beta.2/src/lib.rs
    14
    		 
        clippy::too_many_arguments,
    15
    		 
        clippy::suspicious_arithmetic_impl,
    16
    		 
        clippy::many_single_char_names,
  • halo2_proofs 0.2.0/src/lib.rs
    14
    		 
        clippy::too_many_arguments,
    15
    		 
        clippy::suspicious_arithmetic_impl,
    16
    		 
        clippy::many_single_char_names,
  • ic_bls12_381 0.7.1/src/lib.rs
    23
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    24
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • inve-etcd 0.0.1/src/lib.rs
    2
    		 
        clippy::suspicious_op_assign_impl,
    3
    		 
        clippy::suspicious_arithmetic_impl,
    4
    		 
        clippy::module_inception
  • irmaseal-curve 0.1.4/src/lib.rs
    23
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    24
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • malachite-nz 0.3.2/src/lib.rs
    113
    		 
        clippy::range_plus_one,
    114
    		 
        clippy::suspicious_arithmetic_impl,
    115
    		 
        clippy::suspicious_op_assign_impl,
  • malachite-nz 0.3.2/tests/lib.rs
    8
    		 
        clippy::range_plus_one,
    9
    		 
        clippy::suspicious_arithmetic_impl,
    10
    		 
        clippy::suspicious_op_assign_impl,
  • malachite-q 0.3.2/src/lib.rs
    65
    		 
        clippy::range_plus_one,
    66
    		 
        clippy::suspicious_arithmetic_impl,
    67
    		 
        clippy::suspicious_op_assign_impl,
  • malachite-q 0.3.2/tests/lib.rs
    8
    		 
        clippy::range_plus_one,
    9
    		 
        clippy::suspicious_arithmetic_impl,
    10
    		 
        clippy::suspicious_op_assign_impl,
  • minisign 0.7.2/src/crypto/mod.rs
    7
    		 
        clippy::cast_lossless,
    8
    		 
        clippy::suspicious_arithmetic_impl,
    9
    		 
        clippy::identity_op
  • num-bigint 0.4.3/src/bigint.rs
    1
    		 
    // `Add`/`Sub` ops may flip from `BigInt` to its `BigUint` magnitude
    2
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • num-bigint-dig 0.8.2/src/bigint.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    2
    		 
    #[allow(deprecated, unused_imports)]
  • num-rational 0.4.1/src/lib.rs
    19
    		 
    // Ratio ops often use other "suspicious" ops
    20
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    21
    		 
    #![allow(clippy::suspicious_op_assign_impl)]
  • oxygen_quark 0.0.11/src/fraction.rs
    1
    		 
    #![allow(clippy::suspicious_op_assign_impl, clippy::suspicious_arithmetic_impl)]
  • oxygen_quark 0.0.11/src/imaginary/quaternion.rs
    1
    		 
    #![allow(clippy::suspicious_op_assign_impl, clippy::suspicious_arithmetic_impl)]
  • oxygen_quark 0.0.11/src/matrix/matrix2x2.rs
    4
    		 
        clippy::suspicious_op_assign_impl,
    5
    		 
        clippy::suspicious_arithmetic_impl
    6
    		 
    )]
  • oxygen_quark 0.0.11/src/matrix/matrix3x3.rs
    4
    		 
        clippy::suspicious_op_assign_impl,
    5
    		 
        clippy::suspicious_arithmetic_impl
    6
    		 
    )]
  • oxygen_quark 0.0.11/src/matrix/matrix4x4.rs
    4
    		 
        clippy::suspicious_op_assign_impl,
    5
    		 
        clippy::suspicious_arithmetic_impl
    6
    		 
    )]
  • parity-plonk 0.2.0/src/lib.rs
    43
    		 
    // Bitshift/Bitwise ops are allowed to gain performance.
    44
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    45
    		 
    // Some structs do not have AddAssign or MulAssign impl.
  • pix 0.13.2/src/chan.rs
    350
    		 
        fn div(self, rhs: R) -> Self {
    351
    		 
            #![allow(clippy::single_match, clippy::suspicious_arithmetic_impl)]
    352
    		 
            let rhs = Self::from(rhs);
    507
    		 
        fn div(self, rhs: R) -> Self {
    508
    		 
            #![allow(clippy::single_match, clippy::suspicious_arithmetic_impl)]
    509
    		 
            let rhs = Self::from(rhs);
  • plonk-bls12_381 0.2.0/src/lib.rs
    22
    		 
    // involve various binary operators, and so this lint is triggered unnecessarily.
    23
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • plonk_gadgets 0.6.0/src/lib.rs
    26
    		 
    // We need to perform bitshifting sometimes.
    27
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    28
    		 
    // We have cases where we just have `Variables` which don't have any descriptive name.
  • plonkup 0.9.2/src/lib.rs
    43
    		 
    // Bitshift/Bitwise ops are allowed to gain performance.
    44
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    45
    		 
    // Some structs do not have AddAssign or MulAssign impl.
  • prcn_lib 0.3.1/examples/abc166_f.rs
    2
    		 
    #![allow(clippy::many_single_char_names)]
    3
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • prcn_lib 0.3.1/src/modint.rs
    6
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    7
    		 
    #![allow(unused_imports)]
  • rec 0.11.0/src/lib.rs
    92
    		 
        clippy::suspicious_op_assign_impl,
    93
    		 
        clippy::suspicious_arithmetic_impl,
    94
    		 
        clippy::fallible_impl_from, // Above lints assume a given use; issues should be detected by tests or other lints.
  • rec_derive 0.1.0/src/lib.rs
    44
    		 
        clippy::suspicious_op_assign_impl,
    45
    		 
        clippy::suspicious_arithmetic_impl,
    46
    		 
        clippy::fallible_impl_from, // Above lints are not always correct; issues should be detected by tests or other lints.
  • reverse 0.2.2/src/lib.rs
    39
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • rusty-matrix 0.1.2/src/lib.rs
    2
    		 
        clippy::pedantic,
    3
    		 
        clippy::suspicious_arithmetic_impl,
    4
    		 
        dead_code,
  • rypt 0.8.0/src/shamir/gf256.rs
    1
    		 
    #![allow(clippy::wrong_self_convention, clippy::suspicious_arithmetic_impl)]
    2
    		 
    use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
  • sfcpl 0.1.1/examples/abc166_f.rs
    2
    		 
    #![allow(clippy::many_single_char_names)]
    3
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • sized-chunks 0.7.0/src/lib.rs
    105
    		 
    // Jeremy Francis Corbyn, clippy devs need to calm down 🤦‍♀️
    106
    		 
    #![allow(clippy::suspicious_op_assign_impl, clippy::suspicious_arithmetic_impl)]
  • softposit 0.4.0/src/lib.rs
    4
    		 
    #![allow(clippy::many_single_char_names)]
    5
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    6
    		 
    #![allow(clippy::verbose_bit_mask)]
  • sp-sized-chunks 0.1.0/src/lib.rs
    105
    		 
    // Jeremy Francis Corbyn, clippy devs need to calm down 🤦‍♀️
    106
    		 
    #![allow(clippy::suspicious_op_assign_impl, clippy::suspicious_arithmetic_impl)]
  • time-macros-impl 0.1.2/src/lib.rs
    45
    		 
        clippy::redundant_pub_crate,
    46
    		 
        clippy::suspicious_arithmetic_impl,
    47
    		 
        clippy::use_self,
  • tock-registers 0.8.1/src/fields.rs
    65
    		 
    #![allow(clippy::suspicious_op_assign_impl)]
    66
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
  • turing 0.1.0/src/lib.rs
    1
    		 
    #![allow(clippy::suspicious_op_assign_impl, clippy::suspicious_arithmetic_impl)]
    2
    		 
    #![deny(
  • twofloat 0.6.1/src/lib.rs
    64
    		 
    #![allow(clippy::float_cmp)]
    65
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    66
    		 
    #![allow(clippy::suspicious_op_assign_impl)]
  • ukebox 0.9.1/src/pitch_class.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    2
    		 
    use std::ops::{Add, Sub};
  • vectrix 0.3.0/src/ops.rs
    1
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    2
    		 
    #![allow(clippy::suspicious_op_assign_impl)]
  • yogcrypt 0.0.0/src/lib.rs
    26
    		 
    // which is not a mistake
    27
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(suspicious_arithmetic_impl))]
    28
    		 
    // single characters names are used in accordance to
  • zero-plonk 0.2.5/src/lib.rs
    39
    		 
    // Bitshift/Bitwise ops are allowed to gain performance.
    40
    		 
    #![allow(clippy::suspicious_arithmetic_impl)]
    41
    		 
    // Some structs do not have AddAssign or MulAssign impl.