• ahrs 0.6.0/tests/unit.rs
    152
    		 
        #[allow(clippy::excessive_precision)]
    153
    		 
        let expected = UnitQuaternion::new_unchecked(Quaternion::new(
    171
    		 
    fn test_mahony_update_imu() {
    172
    		 
        #[allow(clippy::excessive_precision)]
    173
    		 
        let start_quat = UnitQuaternion::new_unchecked(Quaternion::new(
  • akaze 0.7.0/src/scale_space_extrema.rs
    149
    		 
    /// A 7x7 Gaussian kernel.
    150
    		 
    #[allow(clippy::excessive_precision)]
    151
    		 
    static GAUSS25: [[f32; 7usize]; 7usize] = [
  • ambisonic 0.4.1/src/renderer.rs
    283
    		 
    #[allow(clippy::excessive_precision)]
    284
    		 
    #[allow(clippy::unreadable_literal)]
  • autd 9.0.1/src/utils/directivity.rs
    16
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    17
    		 
    static DIR_COEF_A: &[Float] = &[
    29
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    30
    		 
    static DIR_COEF_B: &[Float] = &[
    42
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    43
    		 
    static DIR_COEF_C: &[Float] = &[
    55
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    56
    		 
    static DIR_COEF_D: &[Float] = &[
  • autd-utils 0.1.0/src/directivity.rs
    14
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    15
    		 
    static DIR_COEF_A: &[f64] = &[
    27
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    28
    		 
    static DIR_COEF_B: &[f64] = &[
    40
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    41
    		 
    static DIR_COEF_C: &[f64] = &[
    53
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    54
    		 
    static DIR_COEF_D: &[f64] = &[
  • autd3-core 2.8.0/src/acoustics.rs
    14
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    15
    		 
    static DIR_COEF_A: &[f64] = &[
    27
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    28
    		 
    static DIR_COEF_B: &[f64] = &[
    40
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    41
    		 
    static DIR_COEF_C: &[f64] = &[
    53
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    54
    		 
    static DIR_COEF_D: &[f64] = &[
  • av-metrics 0.9.0/src/video/ciede/rgbtolab/mod.rs
    15
    		 
    #[allow(clippy::excessive_precision)]
    16
    		 
    fn rgb_to_xyz(rgb: &[f32; 3]) -> [f32; 3] {
    260
    		 
        #[target_feature(enable = "avx2")]
    261
    		 
        #[allow(clippy::excessive_precision)]
    262
    		 
        #[allow(clippy::many_single_char_names)]
  • aym 0.15.0/src/backends/precise.rs
    372
    		 
    #[allow(clippy::excessive_precision)]
    373
    		 
    fn decimate(x: &mut [f64]) -> f64 {
  • babycat 0.0.14/src/backend/resample/babycat_sinc.rs
    13
    		 
    #[allow(clippy::excessive_precision)]
    14
    		 
    #[allow(clippy::unreadable_literal)]
  • bacon-sci 0.13.1/src/integrate/tables.rs
    5817
    		 
    // which is published under the BSD license
    5818
    		 
    #[allow(clippy::excessive_precision)]
    5819
    		 
    pub const WEIGHTS_DE: [&[(f64, f64)]; 7] = [
  • bacon-sci-1 0.11.0/src/integrate/tables.rs
    5817
    		 
    // which is published under the BSD license
    5818
    		 
    #[allow(clippy::excessive_precision)]
    5819
    		 
    pub const WEIGHTS_DE: [&[(f64, f64)]; 7] = [
  • bandit 0.12.4/src/softmax.rs
    18
    		 
    #[allow(clippy::excessive_precision)]
    19
    		 
    const E : f64 = 2.71828_18284_59045_23536;
  • birli 0.8.0/src/passband_gains.rs
    6418
    		 
    /// of the 65th."
    6419
    		 
    #[allow(clippy::excessive_precision)]
    6420
    		 
    pub const PFB_COTTER_2014_10KHZ: &[f64] = &[
  • bracket-noise 0.8.7/src/fastnoise.rs
    96
    		 
    #[allow(clippy::unreadable_literal)]
    97
    		 
    #[allow(clippy::excessive_precision)]
    98
    		 
    const VAL_LUT: [f32; 256] = [
    357
    		 
    #[allow(clippy::unreadable_literal)]
    358
    		 
    #[allow(clippy::excessive_precision)]
    359
    		 
    const CELL_2D_X: [f32; 256] = [
    618
    		 
    #[allow(clippy::unreadable_literal)]
    619
    		 
    #[allow(clippy::excessive_precision)]
    620
    		 
    const CELL_2D_Y: [f32; 256] = [
    879
    		 
    #[allow(clippy::unreadable_literal)]
    880
    		 
    #[allow(clippy::excessive_precision)]
    881
    		 
    const CELL_3D_X: [f32; 256] = [
    1140
    		 
    #[allow(clippy::unreadable_literal)]
    1141
    		 
    #[allow(clippy::excessive_precision)]
    1142
    		 
    const CELL_3D_Y: [f32; 256] = [
  • cbor-data 0.8.15/src/tests.rs
    178
    		 
    #[allow(clippy::float_cmp)]
    179
    		 
    #[allow(clippy::excessive_precision)]
    180
    		 
    fn numbers() {
  • ciborium 0.2.0/tests/codec.rs
    37
    		 
    // Keep the first "case" aligned to a line number ending in 1 for ease in finding tests.
    38
    		 
    #[allow(clippy::excessive_precision)]
    39
    		 
    #[rstest(input, value, bytes, alternate, equality,
  • ciborium-ll 0.2.0/src/lib.rs
    228
    		 
        #[allow(clippy::excessive_precision)]
    229
    		 
        #[test]
  • compute-float 0.1.0/src/lib.rs
    823
    		 
    #[cfg(test)]
    824
    		 
    #[allow(clippy::excessive_precision)]
    825
    		 
    mod test {
  • d3_geo_rs 0.1.5/tests/area_test.rs
    93
    		 
            #[allow(clippy::excessive_precision)]
    94
    		 
            let g = polygon![
    123
    		 
            #[allow(clippy::excessive_precision)]
    124
    		 
            let g = polygon![
  • d3_geo_rs 0.1.5/tests/equirectangular.rs
    1
    		 
    #[cfg(not(tarpaulin_include))]
    2
    		 
    #[allow(clippy::excessive_precision)]
    3
    		 
    mod equirectangular {
    244
    		 
        #[test]
    245
    		 
        #[allow(clippy::excessive_precision)]
    246
    		 
        fn rotate_30_30() {
  • decimal-rs 0.1.41/benches/benchmark.rs
    54
    		 
    #[allow(clippy::excessive_precision)]
    55
    		 
    fn decimal_from_f64(bench: &mut Bencher) {
  • decimal-rs 0.1.41/src/convert.rs
    706
    		 
        #[test]
    707
    		 
        #[allow(clippy::excessive_precision)]
    708
    		 
        fn test_try_from_f32() {
    735
    		 
        #[test]
    736
    		 
        #[allow(clippy::excessive_precision)]
    737
    		 
        fn test_try_from_f64() {
    803
    		 
        #[test]
    804
    		 
        #[allow(clippy::excessive_precision)]
    805
    		 
        fn test_into_f64() {
  • deser-json 0.8.0/src/de.rs
    639
    		 
    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/5201
    640
    		 
    #[allow(clippy::excessive_precision)]
    641
    		 
    static POW10: [f64; 309] = [
  • dify 0.6.0/src/yiq.rs
    10
    		 
    impl Yiq {
    11
    		 
        #[allow(clippy::many_single_char_names, clippy::excessive_precision)]
    12
    		 
        pub fn rgb2y(rgb: &image::Rgb<u8>) -> f32 {
    21
    		 
        #[allow(clippy::many_single_char_names, clippy::excessive_precision)]
    22
    		 
        fn rgb2i(rgb: &image::Rgb<u8>) -> f32 {
    31
    		 
        #[allow(clippy::many_single_char_names, clippy::excessive_precision)]
    32
    		 
        fn rgb2q(rgb: &image::Rgb<u8>) -> f32 {
  • ebur128 0.1.7/src/lib.rs
    55
    		 
    #[allow(clippy::excessive_precision)]
    56
    		 
    mod histogram_bins;
  • egobox-moe 0.7.1/src/algorithm.rs
    1109
    		 
        #[allow(clippy::excessive_precision)]
    1110
    		 
        fn test_variance_derivatives(f: fn(&Array2<f64>) -> Array2<f64>) {
  • ethers-primitive-types-rs 0.12.1/tests/fp_conversion.rs
    25
    		 
    #[allow(
    26
    		 
        clippy::excessive_precision,
    27
    		 
        clippy::float_cmp,
  • etterna 0.1.0/src/rating_calc.rs
    94
    		 
    		// itself, only slightly modified to be standalone
    95
    		 
    		#[allow(clippy::excessive_precision)] // yes, we're being excessively precise around here
    96
    		 
    		let test_values: &[([f32; 7], f32, f32, f32, f32)] = &[
  • etterna 0.1.0/src/wife/mod.rs
    72
    		 
    		#[allow(clippy::excessive_precision)]
    73
    		 
    		let test_data: &[[[f32; TEST_WIFE_FNS.len()]; TEST_JUDGES.len()]; TEST_DEVIATIONS.len()] = &[
  • etterna 0.1.0/src/wife/wife3.rs
    3
    		 
    // lol who the fuck cares about excessive precision
    4
    		 
    #[allow(clippy::excessive_precision)]
  • feos 0.4.1/src/saftvrqmie/eos/dispersion.rs
    439
    		 
    #[allow(clippy::excessive_precision)]
    440
    		 
    #[cfg(test)]
  • feos 0.4.1/src/saftvrqmie/eos/non_additive_hs.rs
    103
    		 
        #[allow(clippy::excessive_precision)]
    104
    		 
        #[test]
  • fundsp 0.12.0/src/oversample.rs
    14
    		 
    const HALFBAND_LEN: usize = 85;
    15
    		 
    #[allow(clippy::excessive_precision)]
    16
    		 
    const HALFBAND: [f32; HALFBAND_LEN] = [
  • funutd 0.11.0/src/lib.rs
    3
    		 
    #[allow(non_snake_case)]
    4
    		 
    #[allow(clippy::excessive_precision)]
    5
    		 
    pub mod color;
  • futuredsp 0.0.6/src/firdes.rs
    395
    		 
        #[cfg(test)]
    396
    		 
        #[allow(clippy::excessive_precision)]
    397
    		 
        mod tests {
  • futuredsp 0.0.6/src/math/special_funs.rs
    47
    		 
    #[cfg(test)]
    48
    		 
    #[allow(clippy::excessive_precision)]
    49
    		 
    mod tests {
  • futuredsp 0.0.6/src/windows.rs
    153
    		 
    #[cfg(test)]
    154
    		 
    #[allow(clippy::excessive_precision)]
    155
    		 
    mod tests {
  • gsw 0.1.1/src/gsw_internal_funcs/mod.rs
    223
    		 
    #[allow(dead_code, clippy::excessive_precision, clippy::manual_range_contains)]
    224
    		 
    /// Gibbs energy and its derivatives
  • gsw 0.1.1/src/volume.rs
    121
    		 
        #[allow(clippy::excessive_precision)]
    122
    		 
        #[test]
  • impl-vol 0.0.6/src/erf_cody.rs
    12
    		 
    /// SUBROUTINE CALERF(ARG,RESULT,JINT)
    13
    		 
    #[allow(clippy::excessive_precision)]
    14
    		 
    fn calerf(x: f64, jint: i64) -> f64 {
  • impl-vol 0.0.6/src/lets_be_rational.rs
    7
    		 
    #[allow(clippy::excessive_precision)]
    8
    		 
    const TWO_PI: f64 = 6.283185307179586476925286766559005768394338798750;
    9
    		 
    #[allow(clippy::excessive_precision)]
    10
    		 
    const SQRT_THREE: f64 = 1.732050807568877293527446341505872366942805253810;
    11
    		 
    #[allow(clippy::excessive_precision)]
    12
    		 
    const SQRT_PI_OVER_TWO: f64 = 1.253314137315500251207882642405522626503493370305; // sqrt(pi/2) to avoid misinterpretation.
    13
    		 
    #[allow(clippy::excessive_precision)]
    14
    		 
    const SQRT_ONE_OVER_THREE: f64 = 0.577350269189625764509148780501957455647601751270;
    15
    		 
    #[allow(clippy::excessive_precision)]
    16
    		 
    const TWO_PI_OVER_SQRT_TWENTY_SEVEN: f64 = 1.209199576156145233729385505094770488189377498728; // 2*pi/sqrt(27)
  • impl-vol 0.0.6/src/normal_distribution.rs
    20
    		 
    pub const ONE_OVER_SQRT_TWO: f64 = std::f64::consts::FRAC_1_SQRT_2;
    21
    		 
    #[allow(clippy::excessive_precision)]
    22
    		 
    pub const ONE_OVER_SQRT_TWO_PI: f64 = 0.3989422804014326779399460599343818684758586311649;
    23
    		 
    #[allow(clippy::excessive_precision)]
    24
    		 
    pub const SQRT_TWO_PI: f64 = 2.506628274631000502415765284811045253006986740610;
    56
    		 
    #[allow(clippy::excessive_precision)]
    57
    		 
    pub fn inverse_norm_cdf(u: f64) -> f64 {
  • inari 1.0.0/tests/itf1788.rs
    7
    		 
        clippy::eq_op,
    8
    		 
        clippy::excessive_precision,
    9
    		 
        clippy::float_cmp
  • kolor 0.1.8/kolor/src/lib.rs
    145
    		 
        pub mod conversion;
    146
    		 
        #[allow(clippy::excessive_precision)]
    147
    		 
        #[cfg(feature = "color-matrices")]
    149
    		 
        pub mod math;
    150
    		 
        #[allow(clippy::excessive_precision)]
    151
    		 
        #[allow(non_snake_case)]
  • kolor-64 0.1.8/kolor/src/lib.rs
    145
    		 
        pub mod conversion;
    146
    		 
        #[allow(clippy::excessive_precision)]
    147
    		 
        #[cfg(feature = "color-matrices")]
    149
    		 
        pub mod math;
    150
    		 
        #[allow(clippy::excessive_precision)]
    151
    		 
        #[allow(non_snake_case)]
  • levenberg-marquardt 0.13.0/src/lm.rs
    13
    		 
        clippy::float_cmp,
    14
    		 
        clippy::excessive_precision,
    15
    		 
        clippy::redundant_clone
  • lexical-util 0.8.5/src/num.rs
    1245
    		 
    #[allow(clippy::eq_op, clippy::excessive_precision)]
    1246
    		 
    #[cfg(all(not(feature = "std"), feature = "floats"))]
    1317
    		 
    #[allow(clippy::eq_op, clippy::excessive_precision)]
    1318
    		 
    #[cfg(all(not(feature = "std"), feature = "floats"))]
  • light-curve-dmdt 0.7.1/src/erf.rs
    89
    		 
    #[allow(clippy::excessive_precision)]
    90
    		 
    impl ErfFloat for f32 {
  • light-curve-feature 0.5.2/src/features/amplitude.rs
    73
    		 
    #[allow(clippy::unreadable_literal)]
    74
    		 
    #[allow(clippy::excessive_precision)]
    75
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/anderson_darling_normal.rs
    91
    		 
    #[allow(clippy::unreadable_literal)]
    92
    		 
    #[allow(clippy::excessive_precision)]
    93
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/bazin_fit.rs
    402
    		 
    #[allow(clippy::unreadable_literal)]
    403
    		 
    #[allow(clippy::excessive_precision)]
    404
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/beyond_n_std.rs
    166
    		 
    #[allow(clippy::unreadable_literal)]
    167
    		 
    #[allow(clippy::excessive_precision)]
    168
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/bins.rs
    263
    		 
    #[allow(clippy::unreadable_literal)]
    264
    		 
    #[allow(clippy::excessive_precision)]
    265
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/cusum.rs
    81
    		 
    #[allow(clippy::unreadable_literal)]
    82
    		 
    #[allow(clippy::excessive_precision)]
    83
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/duration.rs
    65
    		 
    #[allow(clippy::unreadable_literal)]
    66
    		 
    #[allow(clippy::excessive_precision)]
    67
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/eta.rs
    77
    		 
    #[allow(clippy::unreadable_literal)]
    78
    		 
    #[allow(clippy::excessive_precision)]
    79
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/eta_e.rs
    85
    		 
    #[allow(clippy::unreadable_literal)]
    86
    		 
    #[allow(clippy::excessive_precision)]
    87
    		 
    mod tests {
  • light-curve-feature 0.5.2/src/features/excess_variance.rs
    71
    		 
    #[allow(clippy::unreadable_literal)]
    72
    		 
    #[allow(clippy::excessive_precision)]
    73
    		 
    mod tests {
  • light-curve-interpol 0.1.1/benches/lib.rs
    8
    		 
    #[allow(clippy::unreadable_literal)]
    9
    		 
    #[allow(clippy::excessive_precision)]
    10
    		 
    fn bench_interpolator(c: &mut Criterion) {
  • linfa-elasticnet 0.6.1/src/algorithm.rs
    457
    		 
        #[test]
    458
    		 
        #[allow(clippy::excessive_precision)]
    459
    		 
        fn elastic_net_diabetes_1_works_like_sklearn() {
    517
    		 
        #[test]
    518
    		 
        #[allow(clippy::excessive_precision)]
    519
    		 
        fn elastic_net_diabetes_2_works_like_sklearn() {
  • malachite-base 0.3.2/src/num/arithmetic/root.rs
    533
    		 
    #[allow(clippy::excessive_precision)]
    534
    		 
    const COEFF: [[f32; 3]; 16] = [
  • map-engine 0.1.0/src/tests/affine.rs
    16
    		 
        let inv = geo_transform.inv().unwrap();
    17
    		 
        #[allow(clippy::excessive_precision)]
    18
    		 
        let expected_inv = GeoTransform::new(&[
  • metrix 0.13.13/src/instruments/fundamentals/metrics_meter.rs
    251
    		 
    #[allow(clippy::unreadable_literal)]
    252
    		 
    #[allow(clippy::excessive_precision)]
    253
    		 
    mod test_ewma {
  • micromath 2.0.0/src/float/ln.rs
    14
    		 
        // ln(1.0->2.0) polynomial
    15
    		 
        #[allow(clippy::excessive_precision)]
    16
    		 
        pub fn ln(self) -> Self {
  • microserde 0.1.13/src/json/de.rs
    647
    		 
    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/5201
    648
    		 
    #[allow(clippy::excessive_precision)]
    649
    		 
    static POW10: [f64; 309] = [
  • miniserde 0.1.28/src/json/de.rs
    655
    		 
    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/5201
    656
    		 
    #[allow(clippy::excessive_precision)]
    657
    		 
    static POW10: [f64; 309] = [
  • miniserde-miku 0.1.23/src/json/de.rs
    655
    		 
    // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/5201
    656
    		 
    #[allow(clippy::excessive_precision)]
    657
    		 
    static POW10: [f64; 309] = [
  • mlx9064x 0.2.1/src/calculations.rs
    748
    		 
    #[cfg(test)]
    749
    		 
    #[allow(clippy::excessive_precision)]
    750
    		 
    mod test {
  • mlx9064x 0.2.1/src/driver.rs
    612
    		 
    #[cfg(test)]
    613
    		 
    #[allow(clippy::excessive_precision)]
    614
    		 
    mod test {
  • mlx9064x 0.2.1/src/mlx90640/eeprom.rs
    653
    		 
    #[cfg(test)]
    654
    		 
    #[allow(clippy::excessive_precision)]
    655
    		 
    pub(crate) mod test {
  • mlx9064x 0.2.1/src/mlx90641/eeprom.rs
    456
    		 
    #[cfg(test)]
    457
    		 
    #[allow(clippy::excessive_precision)]
    458
    		 
    pub(crate) mod test {
  • norad 0.8.0/src/shared_types.rs
    120
    		 
            #[allow(clippy::excessive_precision)]
    121
    		 
            let c5 = Color { red: 0.123456789, green: 0.456789123, blue: 0.789123456, alpha: 0.1 };
    124
    		 
            #[allow(clippy::excessive_precision)]
    125
    		 
            let c6 = Color { red: 0.123456789, green: 0.456789123, blue: 0.789123456, alpha: 0.1 };
  • pdbtbx 0.10.1/src/save/mmcif.rs
    377
    		 
        #[test]
    378
    		 
        #[allow(clippy::excessive_precision, clippy::print_literal)]
    379
    		 
        fn test_print_float() {
  • pdf-canvas 0.7.0/src/canvas.rs
    154
    		 
            let right = x + r;
    155
    		 
            #[allow(clippy::excessive_precision)]
    156
    		 
            let c = 0.551_915_024_494;
  • primitive-types 0.12.1/tests/fp_conversion.rs
    21
    		 
    #[test]
    22
    		 
    #[allow(clippy::excessive_precision, clippy::float_cmp, clippy::unreadable_literal)]
    23
    		 
    #[cfg(feature = "std")]
  • probability 0.20.3/src/distribution/binomial.rs
    375
    		 
        // See [Loader, 2000, pp. 7].
    376
    		 
        #[allow(clippy::excessive_precision)]
    377
    		 
        const SFE: [f64; 16] = [
  • probability 0.20.3/src/distribution/gaussian.rs
    174
    		 
    /// Gaussian distribution.
    175
    		 
    #[allow(clippy::excessive_precision)]
    176
    		 
    pub fn inverse(p: f64) -> f64 {
  • psg 1.0.1/src/decimator.rs
    20
    		 
        /// Apply anti-alias filter and downsample.
    21
    		 
        #[allow(clippy::excessive_precision)]
    22
    		 
        pub fn render(&mut self, start: usize) -> f64 {
  • puremp3 0.1.0/src/tables.rs
    590
    		 
    #[allow(clippy::unreadable_literal)]
    591
    		 
    #[allow(clippy::excessive_precision)]
    592
    		 
    pub const SYNTH_DTBL: [f32; 512] = [
    1107
    		 
    #[allow(clippy::unreadable_literal)]
    1108
    		 
    #[allow(clippy::excessive_precision)]
    1109
    		 
    #[allow(clippy::approx_constant)]
  • quartz_nbt 0.2.6/tests/assets/mod.rs
    14
    		 
        #[allow(clippy::excessive_precision)]
    15
    		 
        {
  • quartz_nbt 0.2.6/tests/serde.rs
    181
    		 
        #[allow(clippy::excessive_precision, clippy::approx_constant)]
    182
    		 
        let test_struct = Foo {
    203
    		 
        #[allow(clippy::excessive_precision, clippy::approx_constant)]
    204
    		 
        let validation_nbt = compound! {
    874
    		 
        #[allow(clippy::excessive_precision, clippy::approx_constant)]
    875
    		 
        let inlined = Inlined {
    903
    		 
        #[allow(clippy::excessive_precision, clippy::approx_constant)]
    904
    		 
        let validation_nbt = compound! {
  • quicksilver 0.4.0/src/graphics/circle_points.rs
    34
    		 
    #[allow(clippy::unreadable_literal)]
    35
    		 
    #[allow(clippy::excessive_precision)]
    36
    		 
    pub const CIRCLE_POINTS: [Vector; CIRCLE_LEN] = [
  • rgb2spec 0.1.1/src/optimize/cie1931.rs
    313
    		 
    #[allow(clippy::excessive_precision)]
    314
    		 
    pub(crate) static ILLUMINANT_D65: [f64; SAMPLES] = [
  • rusty_sword_arena 2.0.0/src/bin/server.rs
    22
    		 
    // Why not just a Vec?  Because I've reimplemented this a half-dozen times...
    23
    		 
    #[allow(clippy::excessive_precision, clippy::unreadable_literal)]
    24
    		 
    impl ColorPicker {
  • rv 0.15.0-rc.1/src/misc/bessel.rs
    98
    		 
    #[allow(clippy::unreadable_literal)]
    99
    		 
    #[allow(clippy::excessive_precision)]
    100
    		 
    const BESSI1_COEFFS_B: [f64; 25] = [
  • ryu-js 0.2.2/tests/s2d_test.rs
    28
    		 
        clippy::cast_sign_loss,
    29
    		 
        clippy::excessive_precision,
    30
    		 
        clippy::float_cmp,
    145
    		 
    #[test]
    146
    		 
    #[allow(clippy::excessive_precision)]
    147
    		 
    fn test_issue157() {
  • saltwater 0.11.0/src/lex/tests.rs
    167
    		 
            "1.797693134862315708e+308L",
    168
    		 
            #[allow(clippy::excessive_precision)]
    169
    		 
            1.797_693_134_862_315_730_8e+308,
  • sgp4 0.9.1/src/deep_space.rs
    13
    		 
    // θ̇ = 4.37526908801129966 × 10⁻³ rad.min⁻¹
    14
    		 
    #[allow(clippy::excessive_precision)]
    15
    		 
    const SIDEREAL_SPEED: f64 = 4.37526908801129966e-3;
    106
    		 
            // θ = θ₀ + 4.37526908801129966 × 10⁻³ t rem 2π
    107
    		 
            #[allow(clippy::excessive_precision)]
    108
    		 
            let sidereal_time =
  • sgp4 0.9.1/src/model.rs
    98
    		 
        //      + 5.07551419432269442 × 10⁻¹⁵ t₁₉₇₀² mod 2π
    99
    		 
        #[allow(clippy::excessive_precision)]
    100
    		 
        (1.7321343856509374
  • skia-safe 0.58.0/src/core/color_space.rs
    90
    		 
        #[allow(clippy::excessive_precision)]
    91
    		 
        pub const HLG: ColorSpaceTransferFn = ColorSpaceTransferFn {
  • skillratings 0.24.0/src/trueskill.rs
    938
    		 
    #[allow(clippy::excessive_precision)]
    939
    		 
    /// The inverse of the complementary error function.
  • spectrusty-peripherals 0.4.0/src/ay/audio.rs
    34
    		 
    /// [game-music-emu]: https://bitbucket.org/mpyne/game-music-emu/src/013d4676c689dc49f363f99dcfb8b88f22278236/gme/Ay_Apu.cpp#lines-32
    35
    		 
    #[allow(clippy::approx_constant,clippy::excessive_precision)]
    36
    		 
    pub const AMPS: [f32;16] = [0.000_000, 0.007_813, 0.011_049, 0.015_625,
    64
    		 
    /// ["Free Unix Spectrum Emulator"]: http://fuse-emulator.sourceforge.net/
    65
    		 
    #[allow(clippy::unreadable_literal,clippy::excessive_precision)]
    66
    		 
    pub const FUSE_AMPS: [f32;16] = [0.000000000, 0.0137483785, 0.020462349, 0.029053178,
  • starstuff-types 0.1.8/src/time.rs
    14
    		 
     */
    15
    		 
    #[allow(clippy::excessive_precision)] // NOTE: actual equation has that much precision
    16
    		 
    pub fn earth_rotation_angle(time_julian_ut1: JulianDate) -> Angle {
  • symphonia-codec-vorbis 0.5.2/src/floor.rs
    18
    		 
    #[allow(clippy::unreadable_literal)]
    19
    		 
    #[allow(clippy::excessive_precision)]
    20
    		 
    #[rustfmt::skip]
  • sysinfo 0.27.7/src/windows/cpu.rs
    34
    		 
    // https://github.com/torvalds/linux/blob/345671ea0f9258f410eb057b9ced9cefbbe5dc78/include/linux/sched/loadavg.h#L20-L23
    35
    		 
    #[allow(clippy::excessive_precision)]
    36
    		 
    const LOADAVG_FACTOR_1F: f64 = 0.9200444146293232478931553241;
    37
    		 
    #[allow(clippy::excessive_precision)]
    38
    		 
    const LOADAVG_FACTOR_5F: f64 = 0.9834714538216174894737477501;
    39
    		 
    #[allow(clippy::excessive_precision)]
    40
    		 
    const LOADAVG_FACTOR_15F: f64 = 0.9944598480048967508795473394;
  • tetsy-primitive-types 0.9.1/tests/fp_conversion.rs
    21
    		 
    #[test]
    22
    		 
    #[allow(clippy::excessive_precision, clippy::float_cmp, clippy::unreadable_literal)]
    23
    		 
    #[cfg(feature = "std")]
  • tpk 0.0.2/tests/write.rs
    143
    		 
    #[test]
    144
    		 
    #[allow(clippy::excessive_precision)]
    145
    		 
    fn test_write_float64() {
  • tract-linalg 0.19.2/src/generic/erf.rs
    3
    		 
    #[allow(non_upper_case_globals)]
    4
    		 
    #[allow(clippy::excessive_precision)]
    5
    		 
    fn serf(x: &mut f32) {
  • uu_od 0.0.17/src/prn_float.rs
    93
    		 
    #[test]
    94
    		 
    #[allow(clippy::excessive_precision)]
    95
    		 
    fn test_format_flo32() {
  • visual-odometry-rs 0.1.0/src/dataset/tum_rgbd.rs
    29
    		 
    /// Intrinsics parameters of freiburg 1 (fr1) scenes in the TUM RGB-D dataset.
    30
    		 
    #[allow(clippy::excessive_precision)]
    31
    		 
    pub const INTRINSICS_FR1: Intrinsics = Intrinsics {
    37
    		 
    /// Intrinsics parameters of freiburg 2 (fr2) scenes in the TUM RGB-D dataset.
    38
    		 
    #[allow(clippy::excessive_precision)]
    39
    		 
    pub const INTRINSICS_FR2: Intrinsics = Intrinsics {
    45
    		 
    /// Intrinsics parameters of freiburg 3 (fr3) scenes in the TUM RGB-D dataset.
    46
    		 
    #[allow(clippy::excessive_precision)]
    47
    		 
    pub const INTRINSICS_FR3: Intrinsics = Intrinsics {
  • web-audio-api 0.28.0/src/node/biquad_filter.rs
    766
    		 
        #[test]
    767
    		 
        #[allow(clippy::excessive_precision)]
    768
    		 
        fn test_frequency_responses() {
  • airkorea 0.4.3/tests/integration.rs
    1
    		 
    #![allow(clippy::unreadable_literal, clippy::excessive_precision)]
  • alt_serde_json 1.0.61/src/lib.rs
    309
    		 
        clippy::doc_markdown,
    310
    		 
        clippy::excessive_precision,
    311
    		 
        clippy::float_cmp,
  • borrow_trait 0.1.1/src/lib.rs
    9
    		 
    #![allow(
    10
    		 
        clippy::excessive_precision,
    11
    		 
        clippy::unreadable_literal,
  • boys 0.1.0/src/micb25/data.rs
    1
    		 
    #![allow(clippy::excessive_precision, clippy::unreadable_literal)]
    2
    		 
    pub const BOYS_FUNC_VALUES_S: [[f64; 24]; 201] = [
  • cc1101-rust 0.2.1/src/config.rs
    822
    		 
    mod tests {
    823
    		 
        #![allow(clippy::excessive_precision)]
    824
    		 
        use super::*;
  • colorspace 0.1.0/src/chromatic_adaptation.rs
    1
    		 
    #![allow(non_snake_case)]
    2
    		 
    #![allow(clippy::excessive_precision, clippy::unreadable_literal)]
    3
    		 
    use super::math::*;
  • colorspace 0.1.0/src/color_space_rgb.rs
    4
    		 
    //! and [model_f64] submodules.
    5
    		 
    #![allow(clippy::excessive_precision, clippy::unreadable_literal)]
    6
    		 
    use super::chromaticity::*;
  • compute 0.2.3/src/functions/gamma.rs
    3
    		 
    #![allow(clippy::excessive_precision)]
  • concrete-core-experimental 1.0.0-beta/src/backends/core/private/math/fft/twiddles.rs
    1
    		 
    #![allow(clippy::excessive_precision, clippy::approx_constant)]
  • concrete-fft 0.1.0/src/lib.rs
    67
    		 
        clippy::zero_prefixed_literal,
    68
    		 
        clippy::excessive_precision,
    69
    		 
        clippy::type_complexity,
  • concrete-integer 0.1.1/src/lib.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    //! Welcome the the `concrete-integer` documentation!
  • concrete-shortint 0.1.1/src/lib.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    //! Welcome the the `concrete-shortint` documentation!
  • daisy_bsp 0.5.1/examples/dsp/wavetable.rs
    1
    		 
    #![allow(clippy::unreadable_literal)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • daummap 0.4.0/tests/integration.rs
    1
    		 
    #![allow(clippy::unreadable_literal)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • dimensional_quantity 0.0.1/src/lib.rs
    244
    		 
    #![allow(clippy::excessive_precision)]
  • dimensional_quantity 0.0.1/src/si/extended/f32/constants.rs
    1
    		 
    //! Dimensional physical constants with f64 precision, CODATA 2018 values.
    2
    		 
    #![allow(clippy::excessive_precision)]
    3
    		 
    #![allow(clippy::inconsistent_digit_grouping)]
  • dimensional_quantity 0.0.1/src/si/isq/f32/constants.rs
    1
    		 
    //! Dimensional physical constants with f32 precision, CODATA 2018 values.
    2
    		 
    #![allow(clippy::excessive_precision)]
    3
    		 
    #![allow(clippy::inconsistent_digit_grouping)]
  • dimensioned 0.8.0/src/lib.rs
    126
    		 
        // good.
    127
    		 
        clippy::excessive_precision,
    128
    		 
    )]
  • dims 0.4.1/src/lib.rs
    2
    		 
    // In the event of f64, the numbers are not excessive
    3
    		 
    #![allow(clippy::excessive_precision)]
  • directx_math 0.2.2/src/lib.rs
    77
    		 
    #![allow(clippy::collapsible_if)]
    78
    		 
    #![allow(clippy::excessive_precision)]
    79
    		 
    #![allow(clippy::approx_constant)]
  • dragonbox 0.1.4/tests/binary64_test.rs
    22
    		 
        clippy::cast_lossless,
    23
    		 
        clippy::excessive_precision,
    24
    		 
        clippy::float_cmp,
  • dtoa 1.0.5/benches/bench.rs
    3
    		 
        clippy::approx_constant,
    4
    		 
        clippy::excessive_precision,
    5
    		 
        clippy::unreadable_literal
  • erfa 0.2.1/src/constants.rs
    7
    		 
    #![allow(clippy::excessive_precision)]
  • erfa-sys 0.2.1/src/lib.rs
    8
    		 
    #![allow(clippy::approx_constant)]
    9
    		 
    #![allow(clippy::excessive_precision)]
    10
    		 
    // deref_nullptr hides clippy warnings from erfa.rs, which was produced by bindgen.
  • esri_ascii_grid 0.1.2/src/lib.rs
    71
    		 
        clippy::cast_possible_truncation,
    72
    		 
        clippy::excessive_precision,
    73
    		 
        clippy::module_name_repetitions,
  • feos 0.4.1/src/saftvrqmie/eos/hard_sphere.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    use crate::saftvrqmie::parameters::SaftVRQMieParameters;
  • feos 0.4.1/src/uvtheory/eos/mod.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    #![allow(clippy::needless_range_loop)]
  • feos 0.4.1/tests/gc_pcsaft/dft.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    #![cfg(feature = "dft")]
  • feos 0.4.1/tests/pcsaft/dft.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    #![cfg(feature = "dft")]
  • feos-gc-pcsaft 0.1.1/tests/dft.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    use approx::assert_relative_eq;
  • feos-pcsaft 0.2.0/tests/dft.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    use approx::assert_relative_eq;
  • flattiverse_connector 36.1.1/src/lib.rs
    2
    		 
    #![allow(clippy::too_many_arguments)]
    3
    		 
    #![allow(clippy::excessive_precision)]
    4
    		 
    #![allow(clippy::new_ret_no_self)]
  • geographiclib-rs 0.2.2/src/geodesic.rs
    1
    		 
    #![allow(non_snake_case)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • geographiclib-rs 0.2.2/src/geomath.rs
    1
    		 
    #![allow(non_snake_case)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • gkquad 0.0.4/src/lib.rs
    22
    		 
        clippy::uninit_assumed_init,
    23
    		 
        clippy::excessive_precision,
    24
    		 
        clippy::unreadable_literal
  • glam 0.22.0/tests/quat.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • glam 0.22.0/tests/vec2.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • glam 0.22.0/tests/vec3.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • glam 0.22.0/tests/vec4.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • GSL 6.0.0/src/lib.rs
    11
    		 
    #![allow(clippy::too_many_arguments)]
    12
    		 
    #![allow(clippy::excessive_precision)]
    13
    		 
    #![allow(clippy::many_single_char_names)]
  • hsluv 0.3.1/src/lib.rs
    1
    		 
    #![cfg_attr(not(feature = "std"), no_std)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • islam 1.0.0/src/lib.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • jpeg-decoder 0.3.0/src/idct.rs
    6
    		 
    // Do not warn on them or try to automatically change them.
    7
    		 
    #![allow(clippy::excessive_precision)]
    8
    		 
    // Note: consistency for unrolled, scaled offset loops
  • kurbo 0.9.0/src/lib.rs
    77
    		 
        clippy::many_single_char_names,
    78
    		 
        clippy::excessive_precision,
    79
    		 
        clippy::bool_to_int_with_if
  • lc3-codec 0.2.0/src/encoder/long_term_post_filter.rs
    2
    		 
    // when we squash a 64 bit constant into a 32 bit one but this is perfectly fine
    3
    		 
    #![allow(clippy::excessive_precision)]
  • lc3-codec 0.2.0/src/encoder/temporal_noise_shaping.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • levenberg-marquardt 0.13.0/src/qr.rs
    5
    		 
    //! solved in the LM algorithm.
    6
    		 
    #![allow(clippy::excessive_precision)]
  • levenberg-marquardt 0.13.0/src/trust_region.rs
    1
    		 
    //! Solver for the trust-region sub-problem in the LM algorithm.
    2
    		 
    #![allow(clippy::excessive_precision)]
  • lexical-parse-float 0.8.5/src/table_radix.rs
    5
    		 
    #![doc(hidden)]
    6
    		 
    #![allow(clippy::excessive_precision)]
  • malachite-base 0.3.2/tests/lib.rs
    27
    		 
        clippy::cognitive_complexity,
    28
    		 
        clippy::excessive_precision,
    29
    		 
        clippy::float_cmp,
  • malachite-nz 0.3.2/tests/lib.rs
    5
    		 
        clippy::cognitive_complexity,
    6
    		 
        clippy::excessive_precision,
    7
    		 
        clippy::many_single_char_names,
  • malachite-q 0.3.2/tests/lib.rs
    5
    		 
        clippy::cognitive_complexity,
    6
    		 
        clippy::excessive_precision,
    7
    		 
        clippy::many_single_char_names,
  • mappers 0.3.2/src/ellipsoids.rs
    1
    		 
    #![allow(non_snake_case)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • marlu 0.8.0/src/pos/pal.rs
    12
    		 
    #![allow(non_snake_case)]
    13
    		 
    #![allow(clippy::excessive_precision)]
  • microfft 0.5.0/src/tables.rs
    3
    		 
    #![allow(clippy::excessive_precision)]
    4
    		 
    #![allow(clippy::unreadable_literal)]
  • mlx9064x 0.2.1/src/test/mlx90640_example_data.rs
    17
    		 
    #![allow(clippy::excessive_precision)]
  • mwa_rust_core 0.2.0/src/pos/pal.rs
    12
    		 
    #![allow(non_snake_case)]
    13
    		 
    #![allow(clippy::excessive_precision)]
  • nucleo-h7xx 0.2.1/examples/dsp/wavetable.rs
    1
    		 
    #![allow(clippy::unreadable_literal)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • num-dual 0.6.0/src/bessel.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    use crate::DualNum;
  • oal-sys 0.0.2/src/lib.rs
    3
    		 
    #![allow(non_snake_case, non_upper_case_globals)]
    4
    		 
    #![allow(clippy::excessive_precision, clippy::redundant_static_lifetimes)]
  • ode_solvers 0.3.7/src/butcher_tableau.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • opencv 0.76.3/docs/hub/alphamat.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/aruco.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/barcode.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/bgsegm.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/bioinspired.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/calib3d.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/ccalib.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/core.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/cudaarithm.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • opencv 0.76.3/docs/hub/cudabgsegm.rs
    2
    		 
    	unused_parens,
    3
    		 
    	clippy::excessive_precision,
    4
    		 
    	clippy::missing_safety_doc,
  • rand_distr 0.4.3/src/lib.rs
    16
    		 
    #![allow(
    17
    		 
        clippy::excessive_precision,
    18
    		 
        clippy::float_cmp,
  • rasterize 0.3.2/src/lib.rs
    23
    		 
    #![deny(warnings)]
    24
    		 
    #![allow(clippy::excessive_precision)]
  • ryu 1.0.12/benches/bench.rs
    5
    		 
        clippy::approx_constant,
    6
    		 
        clippy::excessive_precision,
    7
    		 
        clippy::unreadable_literal
  • ryu 1.0.12/tests/common_test.rs
    25
    		 
        clippy::cast_sign_loss,
    26
    		 
        clippy::excessive_precision,
    27
    		 
        clippy::unreadable_literal,
  • ryu 1.0.12/tests/s2d_test.rs
    27
    		 
        clippy::cast_sign_loss,
    28
    		 
        clippy::excessive_precision,
    29
    		 
        clippy::float_cmp,
  • ryu-js 0.2.2/benches/bench.rs
    5
    		 
        clippy::approx_constant,
    6
    		 
        clippy::excessive_precision,
    7
    		 
        clippy::unreadable_literal
  • ryu-js 0.2.2/tests/common_test.rs
    25
    		 
        clippy::cast_sign_loss,
    26
    		 
        clippy::excessive_precision,
    27
    		 
        clippy::unreadable_literal,
  • ryu-js 0.2.2/tests/d2s_test.rs
    22
    		 
        clippy::approx_constant,
    23
    		 
        clippy::excessive_precision,
    24
    		 
        clippy::cast_lossless,
  • sbp 4.11.0/tests/integration/main.rs
    14
    		 
    #![allow(clippy::excessive_precision)]
    15
    		 
    mod auto_check_sbp_acquisition_msg_acq_result_dep_a;
  • serde_json 1.0.91/src/lib.rs
    309
    		 
        clippy::doc_markdown,
    310
    		 
        clippy::excessive_precision,
    311
    		 
        clippy::explicit_auto_deref,
  • serde_json 1.0.91/tests/lexical.rs
    8
    		 
        clippy::doc_markdown,
    9
    		 
        clippy::excessive_precision,
    10
    		 
        clippy::float_cmp,
  • serde_json 1.0.91/tests/test.rs
    5
    		 
        clippy::derive_partial_eq_without_eq,
    6
    		 
        clippy::excessive_precision,
    7
    		 
        clippy::float_cmp,
  • serde_json_lenient 0.1.4/src/lib.rs
    317
    		 
        clippy::doc_markdown,
    318
    		 
        clippy::excessive_precision,
    319
    		 
        clippy::float_cmp,
  • serde_partiql 1.1.65/src/lib.rs
    309
    		 
        clippy::doc_markdown,
    310
    		 
        clippy::excessive_precision,
    311
    		 
        clippy::float_cmp,
  • signalo_filters 0.6.0/src/wavelet/daubechies.rs
    8
    		 
        clippy::wildcard_imports,
    9
    		 
        clippy::excessive_precision,
    10
    		 
        clippy::approx_constant
  • sise-atom 0.5.0/src/tests.rs
    8
    		 
    #![allow(clippy::excessive_precision)]
  • sleef 0.3.0/src/lib.rs
    4
    		 
    #![allow(clippy::mistyped_literal_suffixes)]
    5
    		 
    #![allow(clippy::excessive_precision)]
    6
    		 
    #![allow(clippy::approx_constant)]
  • sofa-sys 2020.7.21-beta.2/src/lib.rs
    1
    		 
    #![allow(non_snake_case)]
    2
    		 
    #![allow(clippy::excessive_precision)]
  • softposit 0.4.0/src/lib.rs
    6
    		 
    #![allow(clippy::verbose_bit_mask)]
    7
    		 
    #![allow(clippy::excessive_precision)]
  • statrs 0.16.0/src/lib.rs
    27
    		 
    #![crate_name = "statrs"]
    28
    		 
    #![allow(clippy::excessive_precision)]
    29
    		 
    #![allow(clippy::many_single_char_names)]
  • statrs-fork 0.17.0/src/lib.rs
    27
    		 
    #![crate_name = "statrs"]
    28
    		 
    #![allow(clippy::excessive_precision)]
    29
    		 
    #![allow(clippy::many_single_char_names)]
  • stb_rect_pack_sys 0.1.4/src/lib.rs
    5
    		 
    #![allow(non_snake_case)]
    6
    		 
    #![allow(clippy::excessive_precision)]
  • stb-sys 0.6.0/src/lib.rs
    5
    		 
    #![allow(non_snake_case)]
    6
    		 
    #![allow(clippy::excessive_precision)]
  • stylish 0.1.0/tests/std/float.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • surf_n_term 0.7.3/src/lib.rs
    35
    		 
    #![allow(clippy::reversed_empty_ranges)]
    36
    		 
    #![allow(clippy::excessive_precision)]
    37
    		 
    #![deny(warnings)]
  • suzy 0.2.0/src/platform/opengl/matrix.rs
    254
    		 
        // TODO: clippy is probably right
    255
    		 
        #![allow(clippy::excessive_precision)]
  • symphonia-bundle-flac 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-bundle-mp3 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-codec-aac 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-codec-adpcm 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-codec-alac 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-codec-pcm 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-codec-vorbis 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-core 0.5.2/src/lib.rs
    10
    		 
    #![allow(clippy::comparison_chain)]
    11
    		 
    #![allow(clippy::excessive_precision)]
    12
    		 
    #![allow(clippy::identity_op)]
  • symphonia-format-isomp4 0.5.2/src/lib.rs
    11
    		 
    #![allow(clippy::comparison_chain)]
    12
    		 
    #![allow(clippy::excessive_precision)]
    13
    		 
    #![allow(clippy::identity_op)]
  • symphonia-format-mkv 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-format-ogg 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-format-wav 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-metadata 0.5.2/src/lib.rs
    12
    		 
    #![allow(clippy::comparison_chain)]
    13
    		 
    #![allow(clippy::excessive_precision)]
    14
    		 
    #![allow(clippy::identity_op)]
  • symphonia-utils-xiph 0.5.2/src/lib.rs
    10
    		 
    #![allow(clippy::comparison_chain)]
    11
    		 
    #![allow(clippy::excessive_precision)]
    12
    		 
    #![allow(clippy::identity_op)]
  • talos 0.1.0/src/functions.rs
    3
    		 
    #![allow(clippy::excessive_precision)]
  • tfhe 0.1.7/src/shortint/parameters/mod.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    //! Module with the definition of cryptographic parameters.
  • tincture 1.0.0/src/lib.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
  • tiny-skia 0.8.2/src/lib.rs
    21
    		 
    #![allow(clippy::enum_variant_names)]
    22
    		 
    #![allow(clippy::excessive_precision)]
    23
    		 
    #![allow(clippy::identity_op)]
  • tiny-skia-path 0.8.2/src/lib.rs
    21
    		 
    #![allow(clippy::eq_op)]
    22
    		 
    #![allow(clippy::excessive_precision)]
    23
    		 
    #![allow(clippy::identity_op)]
  • toml-test 0.3.5/src/decoded.rs
    270
    		 
        fn float_binary_equality() {
    271
    		 
            #![allow(clippy::excessive_precision)]
  • tract-linalg 0.19.2/src/arm64.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    mod arm64simd;
  • tract-linalg 0.19.2/src/generic/sigmoid.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    use crate::frame::element_wise::ElementWiseKer;
  • tract-linalg 0.19.2/src/generic/tanh.rs
    1
    		 
    #![allow(clippy::excessive_precision)]
    2
    		 
    use crate::frame::element_wise::ElementWiseKer;
  • twofloat 0.6.1/src/lib.rs
    62
    		 
    #![allow(clippy::approx_constant)]
    63
    		 
    #![allow(clippy::excessive_precision)]
    64
    		 
    #![allow(clippy::float_cmp)]
  • ux-dx 0.2.1/src/lib.rs
    23
    		 
        clippy::clone_on_copy,
    24
    		 
        clippy::excessive_precision,
    25
    		 
        clippy::ptr_arg,
  • vsop87 2.1.0/src/lib.rs
    92
    		 
        clippy::unreadable_literal,
    93
    		 
        clippy::excessive_precision,
    94
    		 
        clippy::must_use_candidate
  • wide 0.7.5/src/lib.rs
    4
    		 
    #![allow(clippy::eq_op)]
    5
    		 
    #![allow(clippy::excessive_precision)]
    6
    		 
    #![allow(clippy::let_and_return)]
  • wthr 0.1.0/src/client.rs
    166
    		 
        fn round_coords() {
    167
    		 
            #![allow(clippy::excessive_precision)]
    168
    		 
            let latitude: f64 = 53.473894723894738;
  • zune-jpeg 0.2.0/src/idct.rs
    20
    		 
    #![allow(
    21
    		 
        clippy::excessive_precision,
    22
    		 
        clippy::unreadable_literal,