• bies 0.2.0/src/lib.rs
    108
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    109
    		 
        fn from_bies_matrix_1a(
  • bo-bin 0.4.0/src/navigator.rs
    162
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    163
    		 
        #[must_use]
  • boostvoronoi_core 0.10.3/src/builder.rs
    679
    		 
            let site1 = *it_first.get_k()?.left_site();
    680
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    681
    		 
            let site3 = if !site1.is_segment() && site3.is_segment() && site3.point1() == site1.point0()
  • boostvoronoi_core 0.10.3/src/predicate/circle_existence.rs
    86
    		 
    ) -> bool {
    87
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    88
    		 
        if segment_index != SiteIndex::Two {
  • boostvoronoi_core 0.10.3/src/predicate/exact_circle_formation.rs
    500
    		 
    #[allow(clippy::many_single_char_names)]
    501
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    502
    		 
    pub(crate) fn sss<I: InputType, F: OutputType>(
  • boostvoronoi_core 0.10.3/src/predicate/lazy_circle_formation.rs
    263
    		 
            );
    264
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    265
    		 
            let dot = (v_3_c.0 * v_3.0 + v_3_c.1 * v_3.1) / (v_3.0 * v_3.0 + v_3.1 * v_3.1);
    339
    		 
        // re-calculating it again with lossy floats.
    340
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    341
    		 
        if (point1 == site2.point0() || point1 == site2.point1())
  • boostvoronoi_core 0.10.3/src/predicate.rs
    459
    		 
                // Avoid subtraction while computing k.
    460
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    461
    		 
                if !b1.is_sign_negative() {
  • boostvoronoi_core 0.10.3/src/site_event.rs
    360
    		 
        #[allow(unknown_lints)]
    361
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    362
    		 
        pub fn is_primary_edge(site1: &SiteEvent<I, F>, site2: &SiteEvent<I, F>) -> bool {
  • boostvoronoi_core 0.10.3/src/visual_utils.rs
    102
    		 
                let mut dist = (new_y - cur_y) * (mid_x - cur_x) - (new_x - cur_x) * (mid_y - cur_y);
    103
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    104
    		 
                {
    131
    		 
        #[inline(always)]
    132
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    133
    		 
        fn parabola_y<I: InputType, F: OutputType>(x: F, a: F, b: F) -> F {
  • bottom 0.8.0/src/app/layout_manager.rs
    24
    		 
        pub fn get_movement_mappings(&mut self) {
    25
    		 
            #[allow(clippy::suspicious_operation_groupings)] // Have to enable this, clippy really doesn't like me doing this with tuples...
    26
    		 
            fn is_intersecting(a: LineSegment, b: LineSegment) -> bool {
  • cdx 0.1.21/src/text.rs
    222
    		 
            #[allow(clippy::suspicious_operation_groupings)] // clippy false positive
    223
    		 
            while !buff.is_empty() && !wild.is_empty() && (wild.first() != self.ascii(b'*')) {
  • dangerous 0.10.0/src/input/span.rs
    145
    		 
        #[inline(always)]
    146
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    147
    		 
        pub fn is_start_within(self, other: Span) -> bool {
    153
    		 
        #[inline(always)]
    154
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    155
    		 
        pub fn is_end_within(self, other: Span) -> bool {
  • df_st_db 0.3.0-development-2/src/df_world/site/structure.rs
    239
    		 
                    // `structure_local_id` refers to the `local_id`. This is correct.
    240
    		 
                    #[allow(clippy::suspicious_operation_groupings)]
    241
    		 
                    if copied_artifact_ids.site_id == core_item.site_id
    251
    		 
                    // `structure_local_id` refers to the `local_id`. This is correct.
    252
    		 
                    #[allow(clippy::suspicious_operation_groupings)]
    253
    		 
                    if structure_inhabitant_hf_ids.site_id == core_item.site_id
  • df_st_legends 0.3.0-development-2/src/df_world/historical_figures.rs
    628
    		 
    // We want to compare `hfid` with `hf_id_other` as `other.hfid` refers to the main hfid.
    629
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    630
    		 
    impl PartialEq<df_st_core::HFLink> for HFLink {
  • df_st_legends_plus 0.3.0-development-2/src/df_world/written_contents.rs
    119
    		 
    // `self.id` refers to the `type_id`. This is correct.
    120
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    121
    		 
    impl PartialEq<df_st_core::WCReference> for Reference {
  • echonet-lite 0.1.5/src/el_packet.rs
    51
    		 
        /// Returns whether `self` is a response for the `req`.
    52
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    53
    		 
        pub fn is_response_for(&self, req: &ElPacket) -> bool {
  • fm 0.2.1/src/lib.rs
    375
    		 
                            }
    376
    		 
                            #[allow(clippy::suspicious_operation_groupings)]
    377
    		 
                            if ptnm.start() > text.len() || ptn[..ptnm.start()] != text[..ptnm.start()]
  • gad 0.2.0/src/arrayfire.rs
    118
    		 
        /// Estimate gradient along the given direction.
    119
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    120
    		 
        pub fn estimate_gradient<T, F>(
  • geo 0.23.1/src/algorithm/line_intersection.rs
    131
    		 
            // false positives for this overzealous clippy https://github.com/rust-lang/rust-clippy/issues/6747
    132
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    133
    		 
            if p.start == q.start || p.start == q.end {
  • glam 0.22.0/src/f32/scalar/mat2.rs
    240
    		 
        pub fn mul_vec2(&self, rhs: Vec2) -> Vec2 {
    241
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    242
    		 
            Vec2::new(
  • glam 0.22.0/src/f64/dmat2.rs
    230
    		 
        pub fn mul_vec2(&self, rhs: DVec2) -> DVec2 {
    231
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    232
    		 
            DVec2::new(
  • gomez 0.3.1/src/solver/trust_region.rs
    432
    		 
                        #[allow(clippy::suspicious_operation_groupings)]
    433
    		 
                        let d = (b * b + a * c_neg).sqrt();
  • h3o 0.3.0/src/geom/geometry/bbox.rs
    96
    		 
        // Clamped to 3 as higher values tend to rapidly drag the estimate to zero.
    97
    		 
        #[allow(clippy::suspicious_operation_groupings)] // False positive.
    98
    		 
        let area = (diagonal * diagonal) / (length / width);
  • intersect2d 0.4.2/src/lib.rs
    180
    		 
    {
    181
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    182
    		 
        {
  • lancelot-bin 0.8.6/src/bin/mapa.rs
    186
    		 
                // ```
    187
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    188
    		 
                if child.start <= range.end && child.end >= range.end {
  • leptos_core 0.0.22/src/map.rs
    83
    		 
                let mut new_end = new_items.len();
    84
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    85
    		 
                // FIXME: make code clearer so that clippy won't complain
  • libstratis 2.4.2/src/engine/strat_engine/liminal/device_info.rs
    262
    		 
            #[allow(unknown_lints)]
    263
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    264
    		 
            fn luks_luks_compatible(info_1: &LLuksInfo, info_2: &LuksInfo) -> bool {
  • linestring 0.8.0/src/linestring_2d.rs
    83
    		 
        #[allow(clippy::many_single_char_names)]
    84
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    85
    		 
        pub fn intersection_point(self, other: Self) -> Option<Intersection<T>> {
    357
    		 
                let mut dist = (new_y - cur_y) * (mid_x - cur_x) - (new_x - cur_x) * (mid_y - cur_y);
    358
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    359
    		 
                {
    463
    		 
                let mut dist = (new_y - cur_y) * (mid_x - cur_x) - (new_x - cur_x) * (mid_y - cur_y);
    464
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    465
    		 
                {
    492
    		 
        #[inline(always)]
    493
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    494
    		 
        fn parabola_y(x: T, a: T, b: T) -> T {
    1520
    		 
    #[inline(always)]
    1521
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    1522
    		 
    /// The distance between the line a->b to the point p is the same as
  • lyon_geom 1.0.4/src/line.rs
    214
    		 
        /// at the corresponding value.
    215
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    216
    		 
        pub fn intersection_t(&self, other: &Self) -> Option<(S, S)> {
  • malachite-base 0.3.2/src/test_util/stats/moments.rs
    79
    		 
    // From https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
    80
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    81
    		 
    pub fn moment_stats<I: Iterator>(xs: I) -> MomentStats
    677
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    678
    		 
    fn pop_double_truncated_geometric_dist_2_mean(b: f64, a: f64, unadjusted_mean: f64) -> f64 {
  • mediasoup 0.11.2/src/ortc.rs
    641
    		 
    /// codecs' RTCP feedback and header extensions, and also enables or disabled RTX.
    642
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    643
    		 
    pub(crate) fn get_consumer_rtp_parameters(
  • nalgebra 0.32.1/src/linalg/balancing.rs
    54
    		 
                let eps: T = crate::convert(0.95);
    55
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    56
    		 
                if n_col.clone() * n_col + n_row.clone() * n_row < eps * s {
  • neptune 8.1.0/src/proteus/sources.rs
    33
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    34
    		 
    impl DerivedConstants {
  • numb_rs 0.0.4/src/core.rs
    468
    		 
        fn approx_eq(&self, other: &Dense<f64>, tolerance: Self::Check) -> bool {
    469
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    470
    		 
            if self.n != other.n || self.n != other.m {
    485
    		 
            // note symmetric does not have a self.m field as n=m in a symmetric matrix
    486
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    487
    		 
            if self.n != other.n || self.n != other.m {
    521
    		 
        fn approx_eq(&self, other: &Symmetric<f64>, tolerance: Self::Check) -> bool {
    522
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    523
    		 
            if self.n != other.n || self.m != other.n {
    537
    		 
        fn assert_approx_eq(&self, other: &Symmetric<f64>, tolerance: Self::Check) {
    538
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    539
    		 
            if self.n != other.n || self.m != other.n {
  • numfmt 1.0.0/lib.rs
    562
    		 
    impl PartialEq for Formatter {
    563
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    564
    		 
        fn eq(&self, other: &Self) -> bool {
  • opening-hours 0.6.4/src/schedule.rs
    159
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    160
    		 
            while before
    170
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    171
    		 
            while after
  • piecewise_polynomial 0.1.0/src/spline.rs
    81
    		 
        let c = (1.0 / 2.0) * (x1 * f_x0_dx_dx - x0 * f_x1_dx_dx) / dx;
    82
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    83
    		 
        let b = slope - c * (x1 + x0) - d * (x1 * x1 + x1 * x0 + x0x0);
  • portion-rs 0.3.1/src/ops.rs
    123
    		 
            // TODO: return a union of two intervals?
    124
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    125
    		 
            if !self.singleton() && !rhs.singleton() && self.upper < rhs.lower {
  • quinn-proto 0.9.2/src/connection/mod.rs
    1478
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    1479
    		 
        fn peer_completed_address_validation(&self) -> bool {
  • r3_kernel 0.1.4/src/timeout.rs
    803
    		 
    // I didn't mean `Traits::MAX_TICK_COUNT == UTicks::MAX_TICK_COUNT`
    804
    		 
    #[allow(clippy::suspicious_operation_groupings)]
    805
    		 
    fn duration_since_last_tick<Traits: KernelTraits>(
  • rangemap 1.3.0/src/map.rs
    242
    		 
                // then we don't want to keep looping forever trying to find more!
    243
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    244
    		 
                if stored_start_wrapper.end_wrapper.range.start
  • raui-tesselate-renderer 0.38.4/src/tesselation.rs
    50
    		 
        fn is_continuous(&self, other: &Self) -> bool {
    51
    		 
            #[allow(clippy::suspicious_operation_groupings)]
    52
    		 
            match (self, other) {
  • rebound 0.4.4/src/info/fields.rs
    174
    		 
        /// and `other` are of the correct type and the operation is supported.
    175
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    176
    		 
        pub fn set(&self, this: &mut Value<'_>, other: Value<'static>) -> Result<(), Error> {
  • rebound 0.4.4/src/info/union_fields.rs
    77
    		 
        /// reading the field may require the union content be read as a value of the type being set.
    78
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    79
    		 
        pub unsafe fn set(&self, this: &mut Value<'_>, other: Value<'static>) -> Result<(), Error> {
  • reductive 0.9.0/src/linalg.rs
    95
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    96
    		 
        fn squared_euclidean_distance<S2>(&self, other: ArrayBase<S2, Ix1>) -> A
  • ruint 1.7.0/src/algorithms/gcd/matrix.rs
    23
    		 
        /// Returns the matrix product `self * other`.
    24
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    25
    		 
        #[must_use]
  • rv 0.15.0-rc.1/src/dist/gaussian.rs
    350
    		 
    impl KlDivergence for Gaussian {
    351
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    352
    		 
        fn kl(&self, other: &Self) -> f64 {
  • swash 0.1.6/src/scale/cff/cff.rs
    957
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    958
    		 
        fn combine(a: &Transform, b: &Transform) -> Self {
  • transit_model 0.54.1/src/objects.rs
    702
    		 
                }
    703
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    704
    		 
                if (curr_st.arrival_time > curr_st.departure_time)
  • tremor-script 0.13.0-rc.11/src/ast/eq.rs
    208
    		 
    {
    209
    		 
        #[allow(clippy::suspicious_operation_groupings)]
    210
    		 
        fn ast_eq(&self, other: &Self) -> bool {
  • tremor-script 0.13.0-rc.11/src/ast/raw.rs
    2058
    		 
        // No clippy, we really mean j.exclusive(k) || k.exclusive(j)...
    2059
    		 
        clippy::suspicious_operation_groupings,
    2060
    		 
        // also what is wrong with you clippy ...
  • trust-dns-resolver 0.22.0/src/caching_client.rs
    381
    		 
                            // standard evaluation, it's an any type or it's the requested type and the search_name matches
    382
    		 
                            #[allow(clippy::suspicious_operation_groupings)]
    383
    		 
                            if (query.query_type().is_any() || query.query_type() == r.rr_type())
  • url 2.3.1/src/lib.rs
    2240
    		 
        /// ```
    2241
    		 
        #[allow(clippy::result_unit_err, clippy::suspicious_operation_groupings)]
    2242
    		 
        pub fn set_scheme(&mut self, scheme: &str) -> Result<(), ()> {
  • vulkano 0.32.3/src/range_map.rs
    201
    		 
                // then we don't want to keep looping forever trying to find more!
    202
    		 
                #[allow(clippy::suspicious_operation_groupings)]
    203
    		 
                if stored_range_start_wrapper.range.start == new_range_start_wrapper.range.end
  • yata 0.6.1/src/methods/lin_reg.rs
    70
    		 
    		#![allow(clippy::all)]
    71
    		 
    		#[allow(clippy::suspicious_operation_groupings)] // s_x * s_x looks suspicious, but it's not
    72
    		 
    		match length {
    170
    		 
    				#[allow(clippy::suspicious_operation_groupings)]
    171
    		 
    				// s_x * s_x looks suspicious, but it's not
  • average 0.13.1/src/lib.rs
    92
    		 
        clippy::float_cmp,
    93
    		 
        clippy::suspicious_operation_groupings,
    94
    		 
    )]
  • feos 0.4.1/src/pets/mod.rs
    10
    		 
    #![allow(clippy::many_single_char_names)]
    11
    		 
    #![allow(clippy::suspicious_operation_groupings)]
  • feos-dft 0.4.0/src/lib.rs
    1
    		 
    #![warn(clippy::all)]
    2
    		 
    #![allow(clippy::suspicious_operation_groupings)]
    3
    		 
    #![allow(clippy::too_many_arguments)]
  • feos-pets 0.1.0/src/lib.rs
    3
    		 
    #![allow(clippy::many_single_char_names)]
    4
    		 
    #![allow(clippy::suspicious_operation_groupings)]
  • nalgebra 0.32.1/src/linalg/schur.rs
    1
    		 
    #![allow(clippy::suspicious_operation_groupings)]
    2
    		 
    #[cfg(feature = "serde-serialize-no-std")]
  • smartcore 0.3.0/src/optimization/first_order/lbfgs.rs
    1
    		 
    #![allow(clippy::suspicious_operation_groupings)]