actyx_sdk 0.3.0/src/offset.rs

76	let i = v as i64;
77	#[allow(clippy::float_cmp)]
78	if i as f64 == v {

actyxos_sdk 0.6.0/src/event/offsets.rs

83	let i = v as i64;
84	#[allow(clippy::float_cmp)]
85	if i as f64 == v {

all-is-cubes 0.5.0/src/camera.rs

152	#[track_caller]
153	#[allow(clippy::float_cmp)]
154	pub fn set_view_transform(&mut self, eye_to_world_transform: ViewTransform) {

all-is-cubes 0.5.0/src/math/matrix.rs

300	if axis == 3 {
301	#[allow(clippy::float_cmp)]
302	if rounded != expected_w {

amadeus-core 0.4.3/src/util.rs

239	clippy::cast_precision_loss,
240	clippy::float_cmp
241	)]

amethyst_renderer 0.10.4/src/renderer.rs

73

    /// Draws a scene with the given pipeline.

74

    #[cfg_attr(feature = "cargo-clippy", allow(float_cmp))] // cmp just used to recognize change

75

    pub fn draw<'a, P>(&mut self, pipe: &mut P, data: <P as PipelineData<'a>>::Data)

amethyst_utils 0.15.3/src/ortho_camera.rs

250	#[allow(clippy::float_cmp)] // cmp just used to recognize change
251	fn run(&mut self, (dimensions, mut cameras, mut ortho_cameras): Self::SystemData) {

aoflagger_sys 0.1.1/src/cxx_aoflagger.rs

152	// TODO: Why does clippy think CxxImageSet.ImageBuffer() is &[f64]?
153	#[allow(clippy::float_cmp)]
154	mod tests_aoflagger {

apollo-parser 0.4.1/src/parser/grammar/value.rs

220	// floats, but is here to ensure we are able to extract an f64 value
221	#[allow(clippy::float_cmp)]
222	fn it_returns_f64_for_float_values() {

argmin-math 0.3.0/src/nalgebra_m/random.rs

37	// We do want to know if a and b are exactly the same.
38	#[allow(clippy::float_cmp)]
39	if a == b {

arrow-buffer 32.0.0/src/buffer/immutable.rs

472	#[test]
473	#[allow(clippy::float_cmp)]
474	fn test_as_typed_data() {

askama_shared 0.12.2/src/filters/mod.rs

586	#[test]
587	#[allow(clippy::float_cmp)]
588	fn test_into_f64() {
639	#[test]
640	#[allow(clippy::float_cmp)]
641	fn test_abs() {

au 0.10.0/src/linear_system/solver.rs

739	#[test]
740	#[allow(clippy::float_cmp)]
741	fn runge_kutta_fehlberg_struct() {

au 0.10.0/src/polynomial/roots.rs

652	#[allow(clippy::float_cmp)]
653	#[test]

aubio 0.2.1/src/vec.rs

451	#[test]
452	#[allow(clippy::float_cmp)]
453	fn test_from_fmat() {

aubio-rs 0.2.0/src/vec.rs

451	#[test]
452	#[allow(clippy::float_cmp)]
453	fn test_from_fmat() {

automatica 1.0.0/src/linear_system/mod.rs

861	#[test]
862	#[allow(clippy::float_cmp)]
863	fn leverrier_algorithm_f64() {
893	#[test]
894	#[allow(clippy::float_cmp)]
895	fn leverrier_algorithm_f32() {
926	#[test]
927	#[allow(clippy::float_cmp)]
928	fn leverrier_1x1_matrix_f32() {
942	#[test]
943	#[allow(clippy::float_cmp)]
944	fn leverrier_1x1_matrix_f64() {

automatica 1.0.0/src/linear_system/solver.rs

853	#[test]
854	#[allow(clippy::float_cmp)]
855	fn runge_kutta_fehlberg_struct() {

automatica 1.0.0/src/matrix.rs

400	#[test]
401	#[allow(clippy::float_cmp)]
402	fn matrix_trace() {
461	#[test]
462	#[allow(clippy::float_cmp)]
463	fn maximum_absolute_value() {
469	#[test]
470	#[allow(clippy::float_cmp)]
471	fn identity_matrix() {

automatica 1.0.0/src/polynomial_matrix.rs

475	#[test]
476	#[allow(clippy::float_cmp)]
477	fn indexing() {

automatica 1.0.0/src/rational_function/mod.rs

322	#[test]
323	#[allow(clippy::float_cmp)]
324	fn rational_function_creation() {

avocado 0.6.0/src/bsn.rs

69	impl BsonExt for Bson {
70	#[allow(clippy::float_cmp)]
71	fn try_as_bool(&self) -> Option<bool> {

avocado 0.6.0/src/literal.rs

154	#[allow(clippy::float_cmp, clippy::cast_lossless, clippy::cast_precision_loss)]
155	fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<Self::Value, E> {

bbecs 0.3.0/tests/deleting.rs

58	#[test]
59	#[allow(clippy::float_cmp)]
60	fn inserting_an_entity_after_deleting_should_work() -> Result<()> {

bbecs 0.3.0/tests/integration_tests_color.rs

27	#[test]
28	#[allow(clippy::float_cmp)]
29	fn integration_test_point_resource_mut() -> Result<()> {

bbecs 0.3.0/tests/integration_tests_point.rs

30	#[test]
31	#[allow(clippy::float_cmp)]
32	fn integration_test_point_resource_mut() -> Result<()> {

bbecs_tutorial 1.0.3/src/entities/query.rs

108	#[test]
109	#[allow(clippy::float_cmp)]
110	fn run_query() -> Result<()> {

bbecs_tutorial 1.0.3/src/resource.rs

41	#[cfg(test)]
42	#[allow(clippy::float_cmp)]
43	mod test {

bbecs_tutorial 1.0.3/tests/entities.rs

19	#[test]
20	#[allow(clippy::float_cmp)]
21	fn query_for_entities() -> Result<()> {
120	#[test]
121	#[allow(clippy::float_cmp)]
122	fn deleting_an_entity() -> Result<()> {

bevy_ecs 0.9.1/src/system/commands/mod.rs

910	#[cfg(test)]
911	#[allow(clippy::float_cmp, clippy::approx_constant)]
912	mod tests {

bevy_megaui 0.1.4/src/transform_node.rs

72	) {
73	#[allow(clippy::float_cmp)]
74	if state.prev_window_size == *window_size

bevy_reflect 0.9.1/src/path.rs

362	#[cfg(test)]
363	#[allow(clippy::float_cmp, clippy::approx_constant)]
364	mod tests {

bevy_ron 0.1.3/src/parse.rs

163	// Instead, this code checks if a f64 fits inside an f32.
164	#[allow(clippy::float_cmp)]
165	fn any_float(f: f64) -> Result<AnyNum> {

bevy_time 0.9.1/src/time.rs

434	#[cfg(test)]
435	#[allow(clippy::float_cmp)]
436	mod tests {

bevy_time 0.9.1/src/timer.rs

417	#[cfg(test)]
418	#[allow(clippy::float_cmp)]
419	mod tests {

bevy_ui 0.9.1/src/widget/text.rs

82	#[allow(clippy::float_cmp)]
83	if *last_scale_factor == scale_factor {

bevy_window 0.9.1/src/window.rs

559	/// width and height.
560	#[allow(clippy::float_cmp)]
561	pub fn set_resolution(&mut self, width: f32, height: f32) {
574	/// Override the os-reported scaling factor.
575	#[allow(clippy::float_cmp)]
576	pub fn set_scale_factor_override(&mut self, scale_factor: Option<f64>) {

billy 0.1.3/src/entities/query.rs

139	#[test]
140	#[allow(clippy::float_cmp)]
141	fn run_query() -> Result<()> {

billy 0.1.3/src/resources.rs

60	#[cfg(test)]
61	#[allow(clippy::float_cmp)]
62	mod tests {

billy 0.1.3/tests/entities.rs

26	#[test]
27	#[allow(clippy::float_cmp)]
28	fn query_for_entities() -> Result<()> {
139	#[test]
140	#[allow(clippy::float_cmp)]
141	fn deleting_an_entity() -> Result<()> {

bliss-audio-aubio-rs 0.2.0/src/vec.rs

451	#[test]
452	#[allow(clippy::float_cmp)]
453	fn test_from_fmat() {

Boa 0.13.1/src/builtins/function/tests.rs

8	#[allow(clippy::float_cmp)]
9	#[test]
111	#[test]
112	#[allow(clippy::float_cmp)]
113	fn function_prototype_length() {

Boa 0.13.1/src/builtins/number/conversions.rs

4	#[inline]
5	#[allow(clippy::float_cmp)]
6	pub(crate) fn f64_to_int32(number: f64) -> i32 {

Boa 0.13.1/src/builtins/number/mod.rs

1052	#[inline]
1053	#[allow(clippy::float_cmp)]
1054	pub(crate) fn is_float_integer(number: f64) -> bool {
1062	#[inline]
1063	#[allow(clippy::float_cmp)]
1064	pub(crate) fn equal(x: f64, y: f64) -> bool {
1071	/// <https://tc39.es/ecma262/#sec-numeric-types-number-sameValue>
1072	#[allow(clippy::float_cmp)]
1073	pub(crate) fn same_value(a: f64, b: f64) -> bool {
1084	#[inline]
1085	#[allow(clippy::float_cmp)]
1086	pub(crate) fn same_value_zero(x: f64, y: f64) -> bool {
1094	#[inline]
1095	#[allow(clippy::float_cmp)]
1096	pub(crate) fn less_than(x: f64, y: f64) -> AbstractRelation {

boa_engine 0.16.0/src/builtins/function/tests.rs

8	#[allow(clippy::float_cmp)]
9	#[test]
111	#[test]
112	#[allow(clippy::float_cmp)]
113	fn function_prototype_length() {

boa_engine 0.16.0/src/builtins/math/mod.rs

689	/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow
690	#[allow(clippy::float_cmp)]
691	pub(crate) fn pow(_: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
728	/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
729	#[allow(clippy::float_cmp)]
730	pub(crate) fn round(_: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {

boa_engine 0.16.0/src/builtins/number/conversions.rs

4	#[inline]
5	#[allow(clippy::float_cmp)]
6	pub(crate) fn f64_to_int32(number: f64) -> i32 {

boa_engine 0.16.0/src/builtins/number/mod.rs

1098	#[inline]
1099	#[allow(clippy::float_cmp)]
1100	pub(crate) fn is_float_integer(number: f64) -> bool {
1108	#[inline]
1109	#[allow(clippy::float_cmp)]
1110	pub(crate) fn equal(x: f64, y: f64) -> bool {
1117	/// <https://tc39.es/ecma262/#sec-numeric-types-number-sameValue>
1118	#[allow(clippy::float_cmp)]
1119	pub(crate) fn same_value(a: f64, b: f64) -> bool {
1130	#[inline]
1131	#[allow(clippy::float_cmp)]
1132	pub(crate) fn same_value_zero(x: f64, y: f64) -> bool {

brawllib_rs 0.24.1/examples/lint.rs

79	for hitbox_group in &mut hitbox_groups {
80	#[allow(clippy::float_cmp)]
81	if hitbox_group[0].next_size == hitbox.next_size

brawllib_rs 0.24.1/src/renderer/draw.rs

292	// transN
293	#[allow(clippy::float_cmp)]
294	let _color = if frame.ecb.transn_y == frame.ecb.bottom {

brawllib_rs 0.24.1/src/script_runner.rs

1451	}
1452	#[allow(clippy::float_cmp)]
1453	Expression::Binary (binary) => {

calculi 0.2.0/src/parser.rs

111	#[allow(clippy::float_cmp)]
112	fn simplify_binary(operator: &Operator, left: &Component, right: &Component) -> Simplified {

cbe-sdk 1.15.0/src/inflation.rs

114	#[test]
115	#[allow(clippy::float_cmp)]
116	fn test_inflation_basic() {
134	#[test]
135	#[allow(clippy::float_cmp)]
136	fn test_inflation_fixed() {

cbe-sdk 1.15.0/src/timing.rs

129	#[test]
130	#[allow(clippy::float_cmp)]
131	fn test_years_as_slots() {

cbor-data 0.8.15/src/tests.rs

177	#[test]
178	#[allow(clippy::float_cmp)]
179	#[allow(clippy::excessive_precision)]
235	#[test]
236	#[allow(clippy::float_cmp)]
237	fn tags() {

cborg 0.3.0/tests/test.rs

268	#[test]
269	#[allow(clippy::float_cmp)]
270	fn type_test() {
320	#[test]
321	#[allow(clippy::float_cmp)]
322	fn decode_to_test() {

cc1101-rust 0.2.1/src/config.rs

418	for exponent in 0..8 {
419	#[allow(clippy::float_cmp)]
420	if CommonConfig::config_to_deviation(mantissa, exponent) == deviation {
549	for exponent in 0..4 {
550	#[allow(clippy::float_cmp)]
551	if bandwidth == RXConfig::config_to_bandwidth(mantissa, exponent) {

cgmath_dolly 0.1.0/src/util.rs

59	#[allow(clippy::float_cmp)]
60	if params.output_offset_scale != 1.0 {

color-operators 0.0.3/src/hsl/convert_hsv.rs

27	saturation = 0.0;
28	#[allow(clippy::float_cmp)]
29	if lightness != 0.0 && lightness != 1.0 {

color-operators 0.0.3/src/hsl/convert_rgb.rs

37	let mut hue = 0.0;
38	#[allow(clippy::float_cmp)]
39	if max_scaled == values_scaled[0] {

colorsys 0.6.7/src/converters/rgb_cmyk.rs

25	#[allow(clippy::float_cmp)]
26	#[cfg(test)]

comparable 0.5.4/src/scalar.rs

276	#[allow(clippy::float_cmp)]
277	fn comparison(&self, other: &Self) -> Changed<Self::Change> {
299	#[allow(clippy::float_cmp)]
300	fn comparison(&self, other: &Self) -> Changed<Self::Change> {

config_struct 0.5.0/src/ron_parsing.rs

53	#[allow(clippy::float_cmp)]
54	fn ron_to_raw_value(

conjure-runtime 4.2.0/src/service/node/limiter/ciad.rs

252	#[tokio::test]
253	#[allow(clippy::float_cmp)]
254	async fn ignore_does_not_change_limits() {
263	#[tokio::test]
264	#[allow(clippy::float_cmp)]
265	async fn dropped_reduces_limit() {
275	#[tokio::test]
276	#[allow(clippy::float_cmp)]
277	async fn success_increases_limit_if_sufficient_requests_are_in_flight() {

conjure-serde 3.5.0/src/json/test.rs

86	#[allow(clippy::float_cmp)]
87	fn test_doubles(value: f64, string: &str) {

const-field-offset 0.1.2/src/lib.rs

56	#[test]
57	#[allow(clippy::float_cmp)] // We want bit-wise equality here
58	fn test_simple() {
79	#[test]
80	#[allow(clippy::float_cmp)] // We want bit-wise equality here
81	fn test_nested() {
96	#[test]
97	#[allow(clippy::float_cmp)] // We want bit-wise equality here
98	fn test_pin() {

const_fixedp 0.1.1/src/lib.rs

1022	#[test]
1023	#[allow(clippy::float_cmp)]
1024	fn no_basic_rounding_error() -> Result<(), Box<dyn std::error::Error>> {
1037	#[test]
1038	#[allow(clippy::float_cmp)]
1039	fn no_edge_case_rounding_error_f32() -> Result<(), Box<dyn std::error::Error>> {
1058	#[test]
1059	#[allow(clippy::float_cmp)]
1060	fn no_edge_case_rounding_error_f64() -> Result<(), Box<dyn std::error::Error>> {

coolor 0.5.1/src/rgb.rs

48	}
49	#[allow(clippy::float_cmp)]
50	pub fn to_hsl(self) -> Hsl {

corsairmi 2.0.0/src/lib.rs

697	#[test]
698	#[allow(clippy::float_cmp)]
699	fn half_convert() {

cpal 0.15.0/src/host/coreaudio/macos/mod.rs

513	#[allow(clippy::while_immutable_condition)]
514	#[allow(clippy::float_cmp)]
515	fn build_input_stream_raw<D, E>(

crow 0.7.2/src/backend/state.rs

258	// so checking for equality should be fine here.
259	#[allow(clippy::float_cmp)]
260	pub fn update_depth(&mut self, depth: Option<f32>) {

crystal_packing 0.6.0/src/transform.rs

307	// The value should be exact in this case
308	#[allow(clippy::float_cmp)]
309	fn rotation_and_trans_value(rotation: f64, translation: (f64, f64)) -> bool {

crystalorb 0.3.0/src/client.rs

152	let positive_delta_seconds = delta_seconds.max(0.0);
153	#[allow(clippy::float_cmp)]
154	if delta_seconds != positive_delta_seconds {

crystalorb 0.3.0/src/server.rs

159	let positive_delta_seconds = delta_seconds.max(0.0);
160	#[allow(clippy::float_cmp)]
161	if delta_seconds != positive_delta_seconds {

cs_serde_cbor 0.12.0/src/ser.rs

310	#[inline]
311	#[allow(clippy::float_cmp)]
312	fn serialize_f32(self, value: f32) -> Result<()> {
333	#[inline]
334	#[allow(clippy::float_cmp)]
335	fn serialize_f64(self, value: f64) -> Result<()> {

csscolorparser 0.6.2/src/color.rs

882	#[allow(clippy::float_cmp)]
883	fn hsv_to_hsl(h: f64, s: f64, v: f64) -> (f64, f64, f64) {
906	#[allow(clippy::float_cmp)]
907	fn rgb_to_hsv(r: f64, g: f64, b: f64) -> (f64, f64, f64) {
932	#[allow(clippy::float_cmp)]
933	fn rgb_to_hsl(r: f64, g: f64, b: f64) -> (f64, f64, f64) {

cubic-splines 0.2.0/src/cubic_poly.rs

194	#[cfg(test)]
195	#[allow(clippy::float_cmp)]
196	mod tests {

cvr 0.1.2/src/convert.rs

190	#[must_use]
191	#[allow(clippy::float_cmp, clippy::many_single_char_names)]
192	pub fn linear_to_hsv([r, g, b]: [f32; 3]) -> [f32; 3] {

dae-parser 0.8.8/src/physics/model.rs

362	impl XNodeWrite for InstanceRigidBodyCommon {
363	#[allow(clippy::float_cmp)]
364	fn write_to<W: Write>(&self, w: &mut XWriter<W>) -> Result<()> {

dag-cbor 0.1.0/src/encode.rs

138	#[inline]
139	#[allow(clippy::float_cmp)]
140	fn write_cbor<W: Write>(&self, w: &mut W) -> Result<()> {
159	#[inline]
160	#[allow(clippy::float_cmp)]
161	fn write_cbor<W: Write>(&self, w: &mut W) -> Result<()> {

darling_core 0.14.2/src/from_meta.rs

660	#[test]
661	#[allow(clippy::float_cmp)] // we want exact equality
662	fn number_succeeds() {
678	#[test]
679	#[allow(clippy::float_cmp)] // we want exact equality
680	fn float_without_quotes() {

dashu-int 0.3.1/tests/convert.rs

183	#[test]
184	#[allow(clippy::float_cmp)]
185	fn test_to_f32() {
249	#[test]
250	#[allow(clippy::float_cmp)]
251	fn test_to_f64() {

dbc-codegen 0.2.0/src/lib.rs

873	#[allow(clippy::float_cmp)]
874	fn signal_is_float_in_rust(signal: &Signal) -> bool {

decorum 0.3.1/src/cmp.rs

385	#[test]
386	#[allow(clippy::float_cmp)]
387	fn intrinsic_ord_primitive() {

decorum 0.3.1/src/proxy.rs

1844	#[allow(clippy::eq_op)]
1845	#[allow(clippy::float_cmp)]
1846	#[allow(clippy::zero_divided_by_zero)]
1864	#[allow(clippy::eq_op)]
1865	#[allow(clippy::float_cmp)]
1866	#[allow(clippy::zero_divided_by_zero)]

definitely-not-piet-direct2d-please-ignore 0.6.0/src/text.rs

572	#[test]
573	#[allow(clippy::float_cmp)]
574	fn hit_test_empty_string() {

dolly 0.4.0/src/util.rs

48	#[allow(clippy::float_cmp)]
49	if params.output_offset_scale != 1.0 {

doryen-extra 0.2.1/src/base.rs

178	#[test]
179	#[allow(clippy::float_cmp)]
180	fn new_sets_values() {
203	#[test]
204	#[allow(clippy::float_cmp)]
205	fn from_sets_values() {
219	#[test]
220	#[allow(clippy::float_cmp)]
221	fn from_gets_values() {
545	#[test]
546	#[allow(clippy::float_cmp)]
547	fn area() {

druid 0.8.2/examples/text.rs

61	impl Controller<AppState, RawLabel<AppState>> for LabelController {
62	#[allow(clippy::float_cmp)]
63	fn update(

dxf 0.5.0/src/helper_functions.rs

100	#[test]
101	#[allow(clippy::float_cmp)]
102	fn as_double_conversion_test() {
230	#[test]
231	#[allow(clippy::float_cmp)]
232	fn parse_f64_test() {

ecs-lib-rs 0.1.1/src/entities/query.rs

95	#[allow(clippy::float_cmp)]
96	#[test]

ecs-lib-rs 0.1.1/src/resources.rs

36	#[allow(clippy::float_cmp)]
37	#[cfg(test)]

emulsion 10.0.0/src/widgets/bottom_bar.rs

179	match scaling {
180	#[allow(clippy::float_cmp)]
181	ScalingMode::Fixed => {

emulsion 10.0.0/src/widgets/picture_widget.rs

244	fn animate_value(v: &mut f32, dir: f32, dt: f32, next_update: &mut NextUpdate) {
245	#[allow(clippy::float_cmp)]
246	if v.signum() != dir {

esbat 0.1.0/src/conv.rs

28	#[cfg(test)]
29	#[allow(clippy::float_cmp)]
30	#[test]

esl 0.17.1/src/lib.rs

444	#[allow(clippy::float_cmp)]
445	#[test]

esplora-tapyrus 0.4.1/src/daemon.rs

528

    // Missing estimates are logged but do not cause a failure, whatever is available is returned

529

    #[allow(clippy::float_cmp)]

530

    pub fn estimatesmartfee_batch(&self, conf_targets: &[u16]) -> Result<HashMap<u16, f64>> {

estring 0.3.0/src/std/number.rs

58	match estr.parse::<f32>() {
59	#[allow(clippy::float_cmp)]
60	Ok(res) => assert_eq!(res, -0.15),

ethers-middleware 1.0.2/src/gas_escalator/geometric.rs

91	#[test]
92	#[allow(clippy::float_cmp)]
93	fn behaves_with_realistic_values() {

ethers-primitive-types-rs 0.12.1/tests/fp_conversion.rs

13	#[test]
14	#[allow(clippy::float_cmp)]
15	fn convert_u256_to_f64() {
26	clippy::excessive_precision,
27	clippy::float_cmp,
28	clippy::unreadable_literal

ethnum 1.3.2/src/int.rs

254	#[test]
255	#[allow(clippy::float_cmp)]
256	fn converts_to_f64() {

ethnum 1.3.2/src/uint.rs

257	#[test]
258	#[allow(clippy::float_cmp)]
259	fn converts_to_f64() {

etterna 0.1.0/src/rating_calc.rs

134	#[allow(clippy::float_cmp)]
135	// yeah, I am doing == with floats. That's because I thrive for bit-perfect accuracy

ezing 0.2.1/src/lib.rs

163	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
164	#[inline]
173	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
174	#[inline]

fann 0.1.7/src/lib.rs

701

    /// Get the activation steepness for neuron number `neuron` in layer number `layer`.

702

    #[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]

703

    pub fn get_activation_steepness(&self, layer: c_int, neuron: c_int) -> Option<FannType> {

fast_ode 0.1.3/src/unit_tests.rs

83	let z = y.0[1];
84	#[allow(clippy::float_cmp)]
85	{
110	let z = *q.get(1);
111	#[allow(clippy::float_cmp)]
112	{
124	fn init_cond(&self) -> Vector<f64> {
125	#[allow(clippy::float_cmp)]
126	// It's ok, because startsign is the output of the signum function

fastnbt 2.3.2/src/test/mod.rs

7	#[allow(clippy::float_cmp)]
8	mod de;
10	#[allow(clippy::float_cmp)]
11	mod value;

fifthtry-mdbook 0.4.8/tests/rendered_output.rs

566	#[test]
567	#[allow(clippy::float_cmp)]
568	fn book_creates_reasonable_search_index() {

finalfrontier 0.9.4/src/vec_simd.rs

126	#[target_feature(enable = "sse")]
127	#[allow(dead_code, clippy::float_cmp)]
128	pub unsafe fn scaled_add(mut u: ArrayViewMut1<f32>, v: ArrayView1<f32>, a: f32) {
226	#[target_feature(enable = "avx")]
227	#[allow(clippy::float_cmp)]
228	pub unsafe fn scaled_add(mut u: ArrayViewMut1<f32>, v: ArrayView1<f32>, a: f32) {
318	#[allow(clippy::float_cmp)]
319	fn scaled_add_unvectorized(u: &mut [f32], v: &[f32], a: f32) {

fixnum 0.9.1/tests/test_convert_f64.rs

9	#[test]
10	#[allow(clippy::float_cmp)]
11	fn to_f64() -> Result<()> {

flatc 0.2.1+2.0.0/flatbuffers/samples/sample_binary.rs

31	// Example how to use FlatBuffers to create and read binary buffers.
32	#[allow(clippy::float_cmp)]
33	fn main() {

flatc 0.2.1+2.0.0/flatbuffers/samples/sample_flexbuffers.rs

33	// }
34	#[allow(clippy::float_cmp)]
35	fn main() {

flexbuffers 2.0.0/src/bitwidth.rs

89	#[allow(clippy::float_cmp)]
90	impl From<f64> for BitWidth {

forma-render 0.1.3/src/composition/layer.rs

299	// much.
300	#[allow(clippy::float_cmp)]
301	let affine_transform = (!transform.is_identity()).then_some(transform);

fuzzcheck 0.12.1/src/mutators/mod.rs

321	#[allow(clippy::float_cmp)]
322	#[test]

fuzzcheck 0.12.1/src/mutators/vose_alias.rs

52	);
53	#[allow(clippy::float_cmp)]
54	if sum != 1.0 {

fuzzcheck 0.12.1/src/sensors_and_pools/simplest_to_activate_counter_pool.rs

434	#[allow(clippy::float_cmp)]
435	let equal_cplx = analyzed_f.least_complexity == input.complexity;
753	#[allow(clippy::float_cmp)]
754	if max_cplx == 1.0 {

gdal 0.14.0/src/raster/tests.rs

380	#[test]
381	#[allow(clippy::float_cmp)]
382	fn test_geo_transform() {
554	#[test]
555	#[allow(clippy::float_cmp)]
556	fn test_set_no_data_value() {

gdal 0.14.0/src/vector/geometry.rs

489	#[test]
490	#[allow(clippy::float_cmp)]
491	pub fn test_area() {

gdal 0.14.0/src/vector/ops/geometry/intersection.rs

46	#[test]
47	#[allow(clippy::float_cmp)]
48	fn test_intersection_success() {
76	#[test]
77	#[allow(clippy::float_cmp)]
78	fn test_intersection_no_intersects() {

gdal 0.14.0/src/vector/vector_tests/mod.rs

280	#[test]
281	#[allow(clippy::float_cmp)]
282	fn test_get_field_as_x_by_name() {
339	#[test]
340	#[allow(clippy::float_cmp)]
341	fn test_get_field_as_x() {

gemachain-gossip 1.8.0/src/crds_gossip_pull.rs

1498	#[test]
1499	#[allow(clippy::float_cmp)]
1500	fn test_crds_filter_mask() {

gemachain-runtime 1.8.2/src/bank.rs

1433	/// Create a bank from explicit arguments and deserialized fields from snapshot
1434	#[allow(clippy::float_cmp)]
1435	pub(crate) fn new_from_fields(
5912	#[test]
5913	#[allow(clippy::float_cmp)]
5914	fn test_bank_new() {

gemachain-sdk 1.8.2/src/inflation.rs

114	#[test]
115	#[allow(clippy::float_cmp)]
116	fn test_inflation_basic() {
134	#[test]
135	#[allow(clippy::float_cmp)]
136	fn test_inflation_fixed() {

gemachain-sdk 1.8.2/src/timing.rs

120	#[test]
121	#[allow(clippy::float_cmp)]
122	fn test_years_as_slots() {

geo-visibility 0.5.0/src/utils.rs

12	#[cfg(test)]
13	#[allow(clippy::float_cmp)]
14	mod tests {

geodesy 0.9.2/src/inner_op/adapt.rs

186	#[allow(clippy::float_cmp)]
187	fn coordinate_order_descriptor(desc: &str) -> Option<CoordinateOrderDescriptor> {
265	#[allow(clippy::float_cmp)]
266	fn combine_descriptors(

geodesy 0.9.2/src/inner_op/helmert.rs

52	// Necessary to update parameters?
53	#[allow(clippy::float_cmp)]
54	if c[3] != prev_t {

gifski 1.10.0/src/bin/gifski.rs

42	#[allow(clippy::float_cmp)]
43	fn bin_main() -> BinResult<()> {

glib 0.16.7/src/variant.rs

2013	assert_eq!(v.type_().as_str(), "ad");
2014	#[allow(clippy::float_cmp)]
2015	{

glyph_brush_layout 0.2.3/src/builtin.rs

267	#[allow(clippy::float_cmp)]
268	fn recalculate_glyphs<F, S, P>(

gomez 0.3.1/src/core/domain.rs

271	#[cfg(test)]
272	#[allow(clippy::float_cmp)]
273	mod tests {

good_lp 1.3.3/src/expression.rs

365	#[allow(clippy::float_cmp)]
366	#[test]

goose 0.17.0/src/graph.rs

1185	#[test]
1186	#[allow(clippy::float_cmp)]
1187	fn test_record_average_response_time_per_second() {

gpl-governance 2.1.2/src/state/proposal.rs

317	/// If yes then Some(ProposalState) is returned and None otherwise
318	#[allow(clippy::float_cmp)]
319	pub fn try_get_tipped_vote_state(

gstreamer 0.19.7/src/segment.rs

213	#[allow(clippy::float_cmp)]
214	pub fn set_rate(&mut self, rate: f64) {
224	#[allow(clippy::float_cmp)]
225	pub fn set_applied_rate(&mut self, applied_rate: f64) {

h3o 0.3.0/src/geom/geometry/ring.rs

49	// Those strict comparisons are done on purpose.
50	#[allow(clippy::float_cmp)]
51	pub fn contains(&self, mut coord: Coord<f64>) -> bool {

h3o 0.3.0/tests/api/latlng.rs

34	#[test]
35	#[allow(clippy::float_cmp)] // On purpose.
36	fn lat_lng() {

half 2.2.1/src/bfloat.rs

1320	clippy::cognitive_complexity,
1321	clippy::float_cmp,
1322	clippy::neg_cmp_op_on_partial_ord

half 2.2.1/src/binary16.rs

1335	clippy::cognitive_complexity,
1336	clippy::float_cmp,
1337	clippy::neg_cmp_op_on_partial_ord

half 2.2.1/src/slice.rs

513	#[allow(clippy::float_cmp)]
514	#[cfg(test)]

hdrhistogram 7.5.2/src/iterators/quantile.rs

36	impl<'a, T: 'a + Counter> PickyIterator<T> for Iter<'a, T> {
37	#[allow(clippy::float_cmp)]
38	fn pick(&mut self, _: usize, running_total: u64, count_at_index: T) -> Option<PickMetadata> {

hdrhistogram 7.5.2/src/serialization/deserializer.rs

136	#[allow(clippy::float_cmp)]
137	fn deser_v2<T: Counter, R: Read>(

hdrhistogram 7.5.2/src/serialization/interval_log/mod.rs

302	/// Build a LogWriter and apply any configured headers.
303	#[allow(clippy::float_cmp)]
304	pub fn begin_log_with<'a, 'b, W: 'a + io::Write, S: 'b + Serializer>(

hdrsample 6.0.4/src/iterators/quantile.rs

36

impl<'a, T: 'a + Counter> PickyIterator<T> for Iter<'a, T> {

37

    #[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]

38

    fn pick(&mut self, _: usize, running_total: u64, count_at_index: T) -> Option<PickMetadata> {

hdrsample 6.0.4/src/serialization/deserializer.rs

95	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
96	fn deser_v2<T: Counter, R: Read>(

heron_core 5.0.2/src/physics_time.rs

89	#[cfg(test)]
90	#[allow(clippy::float_cmp)]
91	mod tests {

hexodsp 0.2.1/src/dsp/node_sampl.rs

161	#[allow(clippy::float_cmp)]
162	#[allow(clippy::too_many_arguments)]

highs 1.5.0/src/matrix_row.rs

111	#[allow(clippy::float_cmp)]
112	#[test]

hko 1.7.2/src/opendata/hlt.rs

175	#[allow(clippy::float_cmp)]
176	#[test]

i-slint-core 0.3.4/graphics/brush.rs

282	#[test]
283	#[allow(clippy::float_cmp)] // We want bit-wise equality here
284	fn test_linear_gradient_encoding() {

i-slint-core 0.3.4/graphics/color.rs

234	#[allow(clippy::float_cmp)] // `max` is either `red`, `green` or `blue`
235	let hue = 60.

i-slint-core 0.3.4/layout.rs

250	#[test]
251	#[allow(clippy::float_cmp)] // We want bit-wise equality here
252	fn test_layout_items() {

ibig 0.3.6/tests/convert.rs

197	#[test]
198	#[allow(clippy::float_cmp)]
199	fn test_to_f32() {
266	#[test]
267	#[allow(clippy::float_cmp)]
268	fn test_to_f64() {

icebox 0.0.0/parametric.rs

114	#[allow(clippy::float_cmp)]
115	let h = if rgb.x == lmh.z {

inari 1.0.0/tests/itf1788.rs

8	clippy::excessive_precision,
9	clippy::float_cmp
10	)]
82	impl Eq2 for f64 {
83	#[allow(clippy::float_cmp)]
84	fn eq2(&self, rhs: &Self) -> bool {

indicatif 0.17.3/src/progress_bar.rs

676	#[allow(clippy::float_cmp)]
677	#[test]
683	#[allow(clippy::float_cmp)]
684	#[test]

instant-distance 0.6.0/tests/all.rs

9	#[test]
10	#[allow(clippy::float_cmp, clippy::approx_constant)]
11	fn map() {

interledger-settlement 0.3.0/src/core/types.rs

308	#[allow(clippy::float_cmp)]
309	#[test]

investments 4.16.1/src/portfolio/rebalancing.rs

559	Some(best_trade) => {
560	#[allow(clippy::float_cmp)]
561	if best_trade.result == trade.result {

ipfs 0.2.1/src/ipld/dag_cbor.rs

205	#[inline]
206	#[allow(clippy::float_cmp)]
207	fn write_cbor<W: Write>(&self, w: &mut W) -> CborResult<()> {
226	#[inline]
227	#[allow(clippy::float_cmp)]
228	fn write_cbor<W: Write>(&self, w: &mut W) -> CborResult<()> {

iscc-rs 0.2.0/src/cid_image.rs

138	#[test]
139	#[allow(clippy::float_cmp)]
140	fn test_median() {

jecs 0.1.1/src/entities/query.rs

88	#[test]
89	#[allow(clippy::float_cmp)]
90	fn run_query() -> Result<()> {

jecs 0.1.1/src/entities.rs

206	#[test]
207	#[allow(clippy::float_cmp)]
208	fn add_component_by_entity_id() -> Result<()> {

jecs 0.1.1/tests/entities.rs

18	#[test]
19	#[allow(clippy::float_cmp)]
20	fn query_for_entities() -> Result<()> {
117	#[test]
118	#[allow(clippy::float_cmp)]
119	fn delete_entity() -> Result<()> {

jelly_ecs 1.0.1/src/entities/query.rs

88	#[test]
89	#[allow(clippy::float_cmp)]
90	fn run_query() -> Result<()> {

jelly_ecs 1.0.1/src/entities.rs

204	#[test]
205	#[allow(clippy::float_cmp)]
206	fn add_component_by_entity_id() -> Result<()> {

jelly_ecs 1.0.1/src/resources.rs

39	#[cfg(test)]
40	#[allow(clippy::float_cmp)]
41	mod tests {

jelly_ecs 1.0.1/tests/entities.rs

18	#[test]
19	#[allow(clippy::float_cmp)]
20	fn query_for_entities() -> Result<()> {
117	#[test]
118	#[allow(clippy::float_cmp)]
119	fn delete_entity() -> Result<()> {

json-compare 0.0.1/src/lib.rs

34	// and https://www.ecma-international.org/ecma-262/#sec-abstract-equality-comparison
35	#[allow(clippy::float_cmp)]
36	pub fn is_abstract_equal(a: &Value, b: &Value) -> bool {
205	#[allow(clippy::float_cmp)]
206	fn equal_numbers(a: &Number, b: &Number) -> bool {

jsonlogic 0.5.1/src/operators/logic.rs

31	// and https://www.ecma-international.org/ecma-262/#sec-abstract-equality-comparison
32	#[allow(clippy::float_cmp)]
33	pub fn is_abstract_equal(a: &Value, b: &Value) -> bool {
202	#[allow(clippy::float_cmp)]
203	fn equal_numbers(a: &Number, b: &Number) -> bool {

jsonschema-valid 0.5.1/src/validators.rs

516	#[allow(clippy::float_cmp)]
517	pub fn multipleOf<'a>(
730	#[allow(clippy::float_cmp)]
731	fn single_type(instance: &Value, schema: &Value) -> bool {

jsonschema-valid-compat 0.4.1-alpha.2/src/validators.rs

518	#[allow(clippy::float_cmp)]
519	pub fn multipleOf<'a>(
732	#[allow(clippy::float_cmp)]
733	fn single_type(instance: &Value, schema: &Value) -> bool {

kas-theme 0.12.0/src/config.rs

201	/// Currently this is just "set". Later, maybe some type of merge.
202	#[allow(clippy::float_cmp)]
203	pub fn apply_config(&mut self, other: &Config) -> TkAction {

kdash 0.3.6/src/app/utils.rs

119	#[cfg(test)]
120	#[allow(clippy::float_cmp)]
121	mod tests {

kdash 0.3.6/src/ui/overview.rs

219	#[test]
220	#[allow(clippy::float_cmp)]
221	fn test_get_nm_ratio() {

kg-tree 0.2.1/src/tree/mod.rs

                (_, &Value::Boolean(b)) => a.as_boolean() == b,
                #[allow(clippy::float_cmp)]
                (&Value::Float(a), &Value::Float(b)) => a == b,
                #[allow(clippy::float_cmp)]
                (&Value::Float(a), _) => a == b.as_float(),
                #[allow(clippy::float_cmp)]
                (_, &Value::Float(b)) => a.as_float() == b,

kind-config 0.2.7/src/lib.rs

30	pub fn same_as(&self, other: &Value) -> bool {
31	#[allow(clippy::float_cmp)]
32	match (&self, &other) {

kira 0.7.1/src/clock_speed.rs

60	#[test]
61	#[allow(clippy::float_cmp)]
62	fn test() {

kira 0.7.1/src/dsp/frame.rs

37	/// represents a hard right panning.
38	#[allow(clippy::float_cmp)]
39	pub fn panned(self, x: f32) -> Self {

kira 0.7.1/src/playback_rate.rs

58	#[test]
59	#[allow(clippy::float_cmp)]
60	fn test() {

kira 0.7.1/src/sound/static_sound/sound/test.rs

76	#[test]
77	#[allow(clippy::float_cmp)]
78	fn reports_playback_position() {
98	#[test]
99	#[allow(clippy::float_cmp)]
100	fn pauses_and_resumes_with_fades() {
183	#[test]
184	#[allow(clippy::float_cmp)]
185	fn stops_with_fade_out() {
236	#[test]
237	#[allow(clippy::float_cmp)]
238	fn waits_for_start_time() {
454	#[test]
455	#[allow(clippy::float_cmp)]
456	fn start_position() {

kira 0.7.1/src/sound/streaming/sound/test.rs

108	#[test]
109	#[allow(clippy::float_cmp)]
110	fn waits_for_samples() {
170	#[test]
171	#[allow(clippy::float_cmp)]
172	fn reports_playback_position() {

kira-loaders 0.1.0-beta.3/src/streaming/sound/test.rs

101	#[test]
102	#[allow(clippy::float_cmp)]
103	fn waits_for_samples() {
154	#[test]
155	#[allow(clippy::float_cmp)]
156	fn reports_playback_position() {
173	#[test]
174	#[allow(clippy::float_cmp)]
175	fn pauses_and_resumes_with_fades() {
253	#[test]
254	#[allow(clippy::float_cmp)]
255	fn stops_with_fade_out() {
304	#[test]
305	#[allow(clippy::float_cmp)]
306	fn waits_for_start_time() {

koto_runtime 0.11.0/tests/external_value_tests.rs

144	\|data_a: &TestExternalData, data_b, _, _\| {
145	#[allow(clippy::float_cmp)]
146	Ok(Bool(data_a.x == data_b.x))
152	\|data_a: &TestExternalData, data_b, _, _\| {
153	#[allow(clippy::float_cmp)]
154	Ok(Bool(data_a.x != data_b.x))

kq 1.0.6/src/evaluation.rs

46	KdlValue::Float(lhs) => match rhs {
47	#[allow(clippy::float_cmp)]
48	KdlValue::Float(rhs) => lhs == rhs,
140	KdlValue::Float(lhs) => match rhs {
141	#[allow(clippy::float_cmp)]
142	KdlValue::Float(rhs) => lhs != rhs,

kurbo 0.9.0/src/cubicbez.rs

732	#[test]
733	#[allow(clippy::float_cmp)]
734	fn cubicbez_signed_area_linear() {

kurbo 0.9.0/src/point.rs

293	#[test]
294	#[allow(clippy::float_cmp)]
295	fn distance() {

kurbo 0.9.0/src/svg.rs

505	#[test]
506	#[allow(clippy::float_cmp)]
507	fn test_parse_svg_arc_pie() {

launchdarkly-server-sdk-evaluation 1.0.0/src/attribute_value.rs

235	#[allow(clippy::float_cmp)]
236	pub(crate) fn as_bucketable(&self) -> Option<String> {

legion 0.4.0/src/internals/entry.rs

569	#[test]
570	#[allow(clippy::float_cmp)]
571	fn add_component() {

legion 0.4.0/src/internals/world.rs

1488	#[test]
1489	#[allow(clippy::float_cmp)]
1490	fn clone_from_convert() {

legion-systems 0.2.4/src/system.rs

960	#[cfg(feature = "par-schedule")]
961	#[allow(clippy::float_cmp)]
962	fn par_comp_readwrite() {

lemmy_utils 0.17.0/src/rate_limit/rate_limiter.rs

51	/// Returns true if the request passed the rate limit, false if it failed and should be rejected.
52	#[allow(clippy::float_cmp)]
53	pub(super) fn check_rate_limit_full(

levenberg-marquardt 0.13.0/src/lm.rs

12	#[allow(
13	clippy::float_cmp,
14	clippy::excessive_precision,
22	#[cfg(test)]
23	#[allow(clippy::float_cmp, clippy::clone_on_copy, clippy::redundant_clone)]
24	mod test_update_diag;

libfranka-rs 0.9.0/src/robot/control_tools.rs

56	/// transform is represented as a 4x4 matrix in column-major format
57	#[allow(clippy::float_cmp)]
58	pub fn is_homogeneous_transformation(transform: &[f64; 16]) -> bool {

libfranka-rs 0.9.0/src/robot/control_types.rs

326	/// Determines whether the given elbow configuration is valid or not.
327	#[allow(clippy::float_cmp)]
328	pub fn is_valid_elbow(elbow: &[f64; 2]) -> bool {

libipld-raw-cbor 0.1.1/src/encode.rs

122	impl Encode<RawCborCodec> for f32 {
123	#[allow(clippy::float_cmp)]
124	fn encode<W: Write>(&self, _: RawCborCodec, w: &mut W) -> Result<()> {
142	impl Encode<RawCborCodec> for f64 {
143	#[allow(clippy::float_cmp)]
144	fn encode<W: Write>(&self, c: RawCborCodec, w: &mut W) -> Result<()> {

light-curve-feature 0.5.2/src/peak_indices.rs

37	#[cfg(test)]
38	#[allow(clippy::float_cmp)]
39	mod tests {

light-curve-feature 0.5.2/src/periodogram/fft.rs

123	#[test]
124	#[allow(clippy::float_cmp)]
125	fn unity() {

light-curve-feature 0.5.2/src/periodogram/power_fft.rs

368	#[test]
369	#[allow(clippy::float_cmp)]
370	fn spread_arrays_for_fft_one_to_one_resolution() {

light-curve-feature 0.5.2/src/sorted_array.rs

108	#[allow(clippy::float_cmp)]
109	#[cfg(test)]

lignin 0.1.0/src/callback_registry.rs

722	#[allow(clippy::float_cmp)]
723	if key.trunc() != key \|\| key > u32::MAX.into() \|\| key < 1.0 {

liquid-lib 0.26.0/src/stdlib/filters/array.rs

581	#[test]
582	#[allow(clippy::float_cmp)] // Need to dig into this
583	fn unit_first() {
658	#[test]
659	#[allow(clippy::float_cmp)] // Need to dig into this
660	fn unit_last() {

livesplit-core 0.13.0/src/settings/color.rs

234	#[allow(clippy::float_cmp)]
235	#[test]

lodestone_core 0.2.3/src/utils/comparison.rs

9	/// Taken from [https://floating-point-gui.de/errors/comparison/](https://floating-point-gui.de/errors/comparison/)
10	#[allow(clippy::float_cmp)]
11	pub fn nearly_equal(a: f64, b: f64) -> bool {

lokacore 0.3.0/tests/sse.rs

838	#[test]
839	#[allow(clippy::float_cmp)]
840	fn m128_reciprocal0() {
859	#[test]
860	#[allow(clippy::float_cmp)]
861	fn m128_reciprocal_sqrt0() {
870	#[test]
871	#[allow(clippy::float_cmp)]
872	fn m128_set() {
887	#[test]
888	#[allow(clippy::float_cmp)]
889	fn m128_set0() {
896	#[test]
897	#[allow(clippy::float_cmp)]
898	fn m128_set_reverse() {

lokacore 0.3.0/tests/sse2.rs

739	#[test]
740	#[allow(clippy::float_cmp)]
741	fn m128d_extract0() {
1062	#[test]
1063	#[allow(clippy::float_cmp)]
1064	fn m128d_store_low() {
1071	#[test]
1072	#[allow(clippy::float_cmp)]
1073	fn m128d_store_high() {
1944	#[test]
1945	#[allow(clippy::float_cmp)]
1946	fn m128_ceil_sse2() {

lpn 0.2.0/src/codes/repetition.rs

139	#[test]
140	#[allow(clippy::float_cmp)]
141	fn test_bias_even() {
163	#[test]
164	#[allow(clippy::float_cmp)]
165	fn test_bias_odd() {

luallaby 0.1.0-alpha.3/src/vm/operators.rs

186	let n2 = n2.to_float();
187	#[allow(clippy::float_cmp)]
188	if n1.is_finite() && n2.is_finite() {

lv2-core 3.0.0/src/feature/mod.rs

104	#[cfg(test)]
105	#[allow(clippy::float_cmp)]
106	mod tests {

macaw 0.18.0/src/utils.rs

61	#[allow(clippy::float_cmp)]
62	#[cfg(test)]

makepad-shader-compiler 0.3.0/src/const_eval.rs

108	#[allow(clippy::float_cmp)]
109	fn try_const_eval_bin_expr(

makepad-shader-compiler 0.3.0/src/const_gather.rs

115	#[allow(clippy::float_cmp)]
116	fn const_gather_bin_expr(&self, _span: TokenSpan, _op: BinOp, left_expr: &Expr, right_expr: &Expr) {

material-yew 0.3.0/src/list/list_index.rs

28	} else if let Some(value) = val.as_f64() {
29	#[allow(clippy::float_cmp)]
30	ListIndex::Single(if value != -1.0 {

maxminddb 0.23.0/src/maxminddb/reader_test.rs

8	#[allow(clippy::float_cmp)]
9	#[test]

mcsdf-font-tech-demo 1.0.1/src/ui/slider.rs

258	#[allow(clippy::float_cmp)]
259	fn update_input(

mdbook 0.4.25/tests/rendered_output.rs

741	#[test]
742	#[allow(clippy::float_cmp)]
743	fn book_creates_reasonable_search_index() {

mdxbook 0.4.21/tests/rendered_output.rs

619	#[test]
620	#[allow(clippy::float_cmp)]
621	fn book_creates_reasonable_search_index() {

meiosis 0.1.0/src/operators/selection/fitness_proportionate.rs

282	#[allow(clippy::float_cmp)]
283	for _ in 1..=iterations {
353	#[allow(clippy::indexing_slicing, clippy::float_cmp)]
354	for _ in 1..=iterations {

metrix 0.13.13/src/instruments/fundamentals/metrics_meter.rs

83	/// Return the given EWMA for a rate like 1, 5, 15 minutes
84	#[allow(clippy::float_cmp)]
85	fn rate(&self, rate: f64) -> f64 {
249	#[cfg(test)]
250	#[allow(clippy::float_cmp)]
251	#[allow(clippy::unreadable_literal)]

metrix 0.13.13/src/instruments/gauge/tracking.rs

129	#[cfg(test)]
130	#[allow(clippy::float_cmp)]
131	mod test {

minivec 0.4.0/tests/mine.rs

1015	#[allow(clippy::many_single_char_names, clippy::float_cmp, clippy::identity_op)]
1016	#[cfg(target_feature = "avx")]

miratope 0.1.0/src/ui/mod.rs

352	// Updates the slicing depth.
353	#[allow(clippy::float_cmp)]
354	if hyperplane_pos != new_hyperplane_pos {

mlx9064x 0.2.1/src/calculations.rs

533	// value "1.0" is also used as a default value.
534	#[allow(clippy::float_cmp)]
535	if emissivity == 1.0 {

mlx9064x 0.2.1/src/register.rs

587	/// ```
588	#[allow(clippy::float_cmp)]
589	fn try_from(value: f32) -> Result<Self, Self::Error> {

moenarchbook 0.1.1/tests/rendered_output.rs

618	#[test]
619	#[allow(clippy::float_cmp)]
620	fn book_creates_reasonable_search_index() {

molt 0.3.1/src/expr.rs

294	#[allow(clippy::cognitive_complexity)]
295	#[allow(clippy::float_cmp)]
296	fn expr_get_value<'a>(interp: &mut Interp, info: &'a mut ExprInfo, prec: i32) -> DatumResult {
1454	// verifying that we got the number we expected, so this is probably OK.
1455	#[allow(clippy::float_cmp)]
1456	fn veq(val1: &Datum, val2: &Datum) -> bool {

molt-ng 0.3.2/src/expr.rs

294	#[allow(clippy::cognitive_complexity)]
295	#[allow(clippy::float_cmp)]
296	fn expr_get_value<'a>(interp: &mut Interp, info: &'a mut ExprInfo, prec: i32) -> DatumResult {
1454	// verifying that we got the number we expected, so this is probably OK.
1455	#[allow(clippy::float_cmp)]
1456	fn veq(val1: &Datum, val2: &Datum) -> bool {

monero 0.18.2/src/util/amount.rs

1370	#[test]
1371	#[allow(clippy::float_cmp)]
1372	fn floating_point() {

mp4parse 0.12.0/src/tests.rs

1296	match sample_entry {
1297	#[allow(clippy::float_cmp)] // The float comparison below is valid and intended.
1298	super::SampleEntry::Audio(a) => {

ms-converter 1.4.0/src/tests.rs

85	#[test]
86	#[allow(clippy::float_cmp)]
87	fn ms_macro_2_5h() {
146	#[test]
147	#[allow(clippy::float_cmp)]
148	fn parse_empty_dot() {
153	#[test]
154	#[allow(clippy::float_cmp)]
155	fn parse_num() {
160	#[test]
161	#[allow(clippy::float_cmp)]
162	fn parse_dec_num() {

mwa_hyperbeam 0.5.0/src/legendre.rs

141	// code does, so...
142	#[allow(clippy::float_cmp)]
143	if u == 1.0 {

nalgebra 0.32.1/examples/raw_pointer.rs

22	#[allow(clippy::float_cmp)]
23	unsafe {

nalgebra 0.32.1/examples/transformation_pointer.rs

15	#[allow(clippy::float_cmp)]
16	unsafe {

nalgebra 0.32.1/src/linalg/exp.rs

555	#[test]
556	#[allow(clippy::float_cmp)]
557	fn one_norm() {

ndhistogram 0.8.0/tests/test_binrange.rs

71	#[test]
72	#[allow(clippy::float_cmp)]
73	fn test_binrange_bin_conversion() {
84	#[test]
85	#[allow(clippy::float_cmp)]
86	fn test_binrange_underflow_conversion() {
95	#[test]
96	#[allow(clippy::float_cmp)]
97	fn test_binrange_overflow_conversion() {

ndhistogram 0.8.0/tests/test_ndhistogram_1d.rs

9	#[test]
10	#[allow(clippy::float_cmp)]
11	fn test_histogram_uniform_1d_unweighted_fill_once() {
19	#[test]
20	#[allow(clippy::float_cmp)]
21	fn test_histogram_uniform_1d_unfilled_is_empty() {
28	#[test]
29	#[allow(clippy::float_cmp)]
30	fn test_histogram_uniform_1d_weighted_fill_once() {
38	#[test]
39	#[allow(clippy::float_cmp)]
40	fn test_histogram_uniform_1d_unweighted_fill_bin_edges() {

ndhistogram 0.8.0/tests/test_ndhistogram_1d_category.rs

32	#[test]
33	#[allow(clippy::float_cmp)]
34	fn test_histogram_category_1d_multifill() {

ndhistogram 0.8.0/tests/test_ndhistogram_2d.rs

6	#[test]
7	#[allow(clippy::float_cmp)]
8	fn test_histogram_uniform_2d_unweighted_fill_once() {
16	#[test]
17	#[allow(clippy::float_cmp)]
18	fn test_histogram_uniform_2d_unfilled_is_empty() {

neon-serde3 0.10.0/src/de.rs

78	let v = val.value(self.cx);
79	#[allow(clippy::float_cmp)]
80	if v.trunc() == v {

nif 0.4.0/src/gltf.rs

176	#[allow(clippy::float_cmp)]
177	fn get_or_create_material(

nonepad 0.1.0/src/widgets/editor_view.rs

208	#[allow(clippy::float_cmp)] // The equality will be true if we don't touch at all at self.delta_[xy]
209	if old_dx != self.delta_x \|\| old_dy != self.delta_y {

norad 0.8.0/src/font.rs

696	#[allow(clippy::float_cmp)]
697	{

norad 0.8.0/src/glyph/tests.rs

7	#[test]
8	#[allow(clippy::float_cmp)]
9	fn transform() {
237	#[test]
238	#[allow(clippy::float_cmp)]
239	fn guidelines() {
398	#[test]
399	#[allow(clippy::float_cmp)]
400	fn save() {

norad 0.8.0/src/layer.rs

602	#[test]
603	#[allow(clippy::float_cmp)]
604	fn load_layer() {
672	#[test]
673	#[allow(clippy::float_cmp)]
674	fn set_glyph() {

noria 0.6.1/src/data.rs

818	#[test]
819	#[allow(clippy::float_cmp)]
820	fn real_to_float() {

nu-command 0.75.0/tests/commands/math/sum.rs

37	#[allow(clippy::unreadable_literal)]
38	#[allow(clippy::float_cmp)]
39	fn compute_sum_of_individual_row() -> Result<(), String> {
58	#[allow(clippy::unreadable_literal)]
59	#[allow(clippy::float_cmp)]
60	fn compute_sum_of_table() -> Result<(), String> {

num-bigint 0.4.3/tests/bigint.rs

372	#[test]
373	#[allow(clippy::float_cmp)]
374	fn test_convert_f32() {
470	#[test]
471	#[allow(clippy::float_cmp)]
472	fn test_convert_f64() {

num-bigint 0.4.3/tests/biguint.rs

604	#[test]
605	#[allow(clippy::float_cmp)]
606	fn test_convert_f32() {
685	#[test]
686	#[allow(clippy::float_cmp)]
687	fn test_convert_f64() {

num-complex 0.4.3/src/lib.rs

1685	#[test]
1686	#[allow(clippy::float_cmp)]
1687	fn test_l1_norm() {
1732	// FIXME #7158: (maybe?) currently failing on x86.
1733	#[allow(clippy::float_cmp)]
1734	fn test_norm() {
2877	#[test]
2878	#[allow(clippy::float_cmp)]
2879	fn test_const() {

oddio 0.6.2/src/fader.rs

35	#[allow(clippy::float_cmp)]
36	fn sample(&self, interval: f32, mut out: &mut [T::Frame]) {

oddio 0.6.2/src/gain.rs

109	#[allow(clippy::float_cmp)]
110	fn sample(&self, interval: f32, out: &mut [T::Frame]) {

oddio 0.6.2/src/stream.rs

89	#[allow(clippy::float_cmp)]
90	fn is_finished(&self) -> bool {

ofdb-entities 0.12.0/src/geo.rs

597	#[cfg(test)]
598	#[allow(clippy::unreadable_literal, clippy::float_cmp)]
599	mod tests {

off-rs 1.0.0/src/geometry/color.rs

173	#[test]
174	#[allow(clippy::float_cmp)]
175	fn color() {

off-rs 1.0.0/src/geometry/position.rs

70	#[test]
71	#[allow(clippy::float_cmp)]
72	fn position() {

optimization 0.2.0/src/utils.rs

14	#[cfg(test)]
15	#[allow(clippy::float_cmp)]
16	pub fn are_close(a: f64, b: f64, eps: f64) -> bool {

ord_subset 3.1.1/src/ord_subset_trait.rs

36	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp, eq_op))]
37	impl OrdSubset for f64 {
45	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp, eq_op))]
46	impl OrdSubset for f32 {

oxigraph 0.3.11/src/sparql/eval.rs

2277	#[allow(
2278	clippy::float_cmp,
2279	clippy::cast_possible_truncation,

packed_simd_2 0.3.8/tests/endianness.rs

82	// would be very unusual for them to actually fail to compare.
83	#[allow(clippy::float_cmp)]
84	{
150	// would be very unusual for them to actually fail to compare.
151	#[allow(clippy::float_cmp)]
152	{

pact_matching 1.0.3/src/matchers.rs

399	impl Matches<f64> for f64 {
400	#[allow(clippy::float_cmp)]
401	#[instrument(level = "trace")]

pdbtbx 0.10.1/src/read/mmcif/parser.rs

576	clippy::cast_sign_loss,
577	clippy::float_cmp
578	)]
601	clippy::cast_possible_truncation,
602	clippy::float_cmp
603	)]

pdbtbx 0.10.1/src/transformation.rs

468	fn close(a: f64, b: f64) -> bool {
469	#[allow(clippy::float_cmp)]
470	if a == b {

pdf 0.8.0/src/content.rs

542	#[allow(clippy::float_cmp)] // TODO
543	pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {

pdf 0.8.0/src/font.rs

164	}
165	#[allow(clippy::float_cmp)] // TODO
166	fn set(&mut self, cid: usize, width: f32) {

pickledb 0.5.1/tests/pickledb_advanced_tests.rs

38	// read keys and lists
39	#[allow(clippy::float_cmp)]
40	{

pico-common 0.3.1/src/config.rs

87	#[cfg(test)]
88	#[allow(clippy::float_cmp)]
89	mod tests {

pico-sdk 0.3.1/tests/stream_data.rs

11	#[test]
12	#[allow(clippy::float_cmp)]
13	#[ignore]

piecewise_polynomial 0.1.0/src/log_poly.rs

609	#[cfg(test)]
610	#[allow(clippy::float_cmp)]
611	mod tests {

piecewise_polynomial 0.1.0/src/piecewise.rs

562	#[cfg(test)]
563	#[allow(clippy::float_cmp)]
564	mod tests {

piet-cairo 0.6.2/src/text.rs

609	#[test]
610	#[allow(clippy::float_cmp)]
611	fn hit_test_empty_string() {

piet-coregraphics 0.6.2/src/text.rs

764	// this used to be part of the TextLayout trait; see https://github.com/linebender/piet/issues/298
765	#[allow(clippy::float_cmp)]
766	fn update_width(&mut self, new_width: impl Into<Option<f64>>) {
1028	#[cfg(test)]
1029	#[allow(clippy::float_cmp)]
1030	mod tests {

piet-direct2d 0.6.2/src/text.rs

572	#[test]
573	#[allow(clippy::float_cmp)]
574	fn hit_test_empty_string() {

piet-svg 0.6.2/src/lib.rs

517	// allow clippy warning for `width != 1.0` in if statement
518	#[allow(clippy::float_cmp)]
519	fn apply_to(&self, node: &mut impl Node) {

piston2d-wgpu_graphics 0.8.0/src/lib.rs

388	#[allow(clippy::float_cmp)]
389	impl<'a> CreateTexture<TextureContext<'a>> for Texture {

plotters-conrod 0.3.12/src/utils/shape.rs

40	#[allow(clippy::float_cmp)]
41	pub(crate) fn collect(&mut self) -> Vec<Vec<ShapeSplitterPoint>> {
92	#[allow(clippy::many_single_char_names, clippy::float_cmp)]
93	fn intersects(
138	#[inline(always)]
139	#[allow(clippy::float_cmp)]
140	fn append_point(container: &mut Vec<ShapeSplitterPoint>, point: ShapeSplitterPoint) {

png 0.17.7/src/common.rs

349	/// Gets whether the value can be exactly converted in round-trip.
350	#[allow(clippy::float_cmp)] // Stupid tool, the exact float compare is _the entire point_.
351	pub fn exact(value: f32) -> bool {

pnglitcher 0.2.0/src/common.rs

325	/// Gets whether the value can be exactly converted in round-trip.
326	#[allow(clippy::float_cmp)] // Stupid tool, the exact float compare is _the entire point_.
327	pub fn exact(value: f32) -> bool {

poem 1.3.52/src/web/path/de.rs

541	#[cfg(test)]
542	#[allow(clippy::float_cmp)]
543	mod tests {

polar-core 0.26.4/src/lexer.rs

657	#[test]
658	#[allow(clippy::float_cmp)]
659	fn test_numbers() {

polars 0.26.1/tests/it/core/joins.rs

73	#[test]
74	#[allow(clippy::float_cmp)]
75	#[cfg_attr(miri, ignore)]

polars-plan 0.26.1/src/logical_plan/optimizer/simplify_expr.rs

430	impl OptimizationRule for SimplifyExprRule {
431	#[allow(clippy::float_cmp)]
432	fn optimize_expr(

polynomen 1.0.0/src/norms.rs

75	#[test]
76	#[allow(clippy::float_cmp)]
77	fn l_2_norm() {
83	#[test]
84	#[allow(clippy::float_cmp)]
85	fn l_infinity_norm() {

polynomen 1.0.0/src/roots.rs

769	#[allow(clippy::float_cmp)]
770	#[test]

portion 0.3.0/src/f32.rs

253	impl Ord for Portion {
254	#[allow(clippy::float_cmp)]
255	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
544	impl Ord for SPortion {
545	#[allow(clippy::float_cmp)]
546	fn cmp(&self, other: &Self) -> std::cmp::Ordering {

portion 0.3.0/src/f64.rs

253	impl Ord for Portion {
254	#[allow(clippy::float_cmp)]
255	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
544	impl Ord for SPortion {
545	#[allow(clippy::float_cmp)]
546	fn cmp(&self, other: &Self) -> std::cmp::Ordering {

postgres-protocol 0.6.4/src/types/test.rs

41	#[test]
42	#[allow(clippy::float_cmp)]
43	fn float4() {
49	#[test]
50	#[allow(clippy::float_cmp)]
51	fn float8() {

pot 1.0.2/src/format.rs

384	/// Writes an [`Kind::Float`] atom with the given value.
385	#[allow(clippy::cast_possible_truncation, clippy::float_cmp)]
386	pub fn write_f32<W: WriteBytesExt>(writer: &mut W, value: f32) -> std::io::Result<usize> {
414	/// Writes an [`Kind::Float`] atom with the given value.
415	#[allow(clippy::cast_possible_truncation, clippy::float_cmp)]
416	pub fn write_f64<W: WriteBytesExt>(writer: &mut W, value: f64) -> std::io::Result<usize> {
1051	/// Returns this number as an f32, if it can be done without losing precision.
1052	#[allow(clippy::float_cmp, clippy::cast_possible_truncation)]
1053	pub fn as_f32(&self) -> Result<f32, Error> {

primitive-types 0.12.1/tests/fp_conversion.rs

13	#[test]
14	#[allow(clippy::float_cmp)]
15	fn convert_u256_to_f64() {
21	#[test]
22	#[allow(clippy::excessive_precision, clippy::float_cmp, clippy::unreadable_literal)]
23	#[cfg(feature = "std")]

proj 0.27.0/src/proj.rs

655	// floating point comparison
656	#[allow(clippy::float_cmp)]
657	let area = if west != -1000.0 && south != -1000.0 && east != -1000.0 && north != -1000.0

py-marshal 0.3.3/src/lib.rs

834	#[allow(clippy::float_cmp, clippy::cast_precision_loss)]
835	#[test]
1002	#[allow(clippy::float_cmp)]
1003	#[test]

py27-marshal 0.3.4/src/read.rs

453	#[allow(clippy::float_cmp, clippy::cast_precision_loss)]
454	#[test]
620	#[allow(clippy::float_cmp)]
621	#[test]

qasmsim 1.2.0/src/interpreter/expression_solver.rs

50	#[test]
51	#[allow(clippy::float_cmp)]
52	fn test_expression_solver() {
80	#[test]
81	#[allow(clippy::float_cmp)]
82	fn test_expression_solver_with_functions() {
108	#[test]
109	#[allow(clippy::float_cmp)]
110	fn test_expression_solver_with_symbol_substitution() {

quilt-lang 0.1.1/src/hsl.rs

60	/// [go-color]: https://github.com/bthomson/go-color
61	#[allow(clippy::float_cmp, clippy::many_single_char_names)]
62	pub fn from_rgb(rgb: &[u8]) -> HslFloats {

raft-engine 0.3.0/src/codec.rs

603	#[test]
604	#[allow(clippy::float_cmp)]
605	fn test_var_f64_le() {

rand-array-iid 0.2.0/src/lib.rs

213	#[test]
214	#[allow(clippy::float_cmp)]
215	fn sample_standard_array_3() {

redisgraph 0.5.0/tests/conversions_test.rs

57	fn test_float() {
58	#[allow(clippy::float_cmp)]
59	with_graph(\|graph\| {

relearn 0.3.1/src/envs/bandits.rs

264	let (_, feedback) = env.step((), &0, &mut rng, &mut ());
265	#[allow(clippy::float_cmp)] // Expecting exact values without error
266	if feedback < Reward(0.5) {
296	#[test]
297	#[allow(clippy::float_cmp)] // Expecting exact values without error
298	fn rewards() {

relearn 0.3.1/src/envs/meta.rs

619	#[cfg(test)]
620	#[allow(clippy::float_cmp)] // Comparing exact reward values; 0.0 or 1.0 without error
621	mod meta_env_bandits {

relearn 0.3.1/src/envs/testing.rs

59

/// Test that the [`EnvStructure`] of an [`EnvDistribution`] is a superset of its sampled envs.

60

#[allow(clippy::float_cmp)] // discount factor should be exactly equal

61

pub fn check_env_distribution_structure<D>(env_dist: &D, num_samples: usize)

relearn 0.3.1/src/envs/wrappers/step_limit.rs

282	#[test]
283	#[allow(clippy::float_cmp)] // expecting exact values
284	fn step_limit() {

relearn 0.3.1/src/spaces/testing.rs

106

/// Check that any excess output passed to [`FeatureSpace::features_out`] remains unchanged.

107

#[allow(clippy::float_cmp)] // expecting exact values

108

pub fn check_features_out_excess_unchanged<S: FeatureSpace>(space: &S, element: &S::Element) {

relearn 0.3.1/src/torch/initializers.rs

354	#[allow(clippy::float_cmp)] // Should be exact
355	if gain != 1.0 {

relearn 0.3.1/src/torch/tensors/exclusive.rs

370	#[test]
371	#[allow(clippy::float_cmp)]
372	fn slice_f64() {

relearn 0.3.1/src/utils/order.rs

48	#[cfg(test)]
49	#[allow(clippy::float_cmp)]
50	mod expect_ord {

resphys 0.1.0/src/collision/ray.rs

17	// ported https://github.com/RandyGaul/cute_headers/blob/master/cute_c2.h#L1427
18	#[allow(clippy::float_cmp)]
19	pub fn contact_ray_aabb(ray: &Ray, aabb_pos: Vec2, aabb_half_exts: Vec2) -> Option<Raycast> {

ring_api 0.1.0/src/requests/result.rs

636	#[allow(clippy::float_cmp)]
637	fn visit_f64<E: Error>(self, v: f64) -> Result<Self::Value, E> {

rmp-futures 0.3.2/src/decode.rs

1016	#[test]
1017	#[allow(clippy::float_cmp)] // Not doing math. Constant bytes are passed through unmodified.
1018	fn f32() {
1038	#[test]
1039	#[allow(clippy::float_cmp)] // Not doing math. Constant bytes are passed through unmodified.
1040	fn f64() {

ron 0.8.0/src/parse.rs

250	// Instead, this code checks if a f64 fits inside an f32.
251	#[allow(clippy::float_cmp)]
252	fn any_float(f: f64) -> Result<AnyNum> {

ron 0.8.0/tests/337_value_float_roundtrip.rs

14	#[test]
15	#[allow(clippy::float_cmp)]
16	fn roundtrip_value_float_into() {

ros-nalgebra 0.1.0/tests/test.rs

30	#[test]
31	#[allow(clippy::float_cmp)]
32	fn pose_to_iso() {
39	#[test]
40	#[allow(clippy::float_cmp)]
41	fn pose_into_iso2() {
48	#[test]
49	#[allow(clippy::float_cmp)]
50	fn odometry_into_iso2() {
57	#[test]
58	#[allow(clippy::float_cmp)]
59	fn imu_into_iso() {
69	#[test]
70	#[allow(clippy::float_cmp)]
71	fn test_from() {

ros-nalgebra 0.1.0/tests/test_pose_msg.rs

33	#[test]
34	#[allow(clippy::float_cmp)]
35	fn pose_to_iso() {
42	#[test]
43	#[allow(clippy::float_cmp)]
44	fn pose_into_iso2() {
51	#[test]
52	#[allow(clippy::float_cmp)]
53	fn test_from() {

ros-nalgebra 0.1.0/tests/test_transform_msg.rs

33	#[test]
34	#[allow(clippy::float_cmp)]
35	fn pose_to_iso() {
42	#[test]
43	#[allow(clippy::float_cmp)]
44	fn pose_into_iso2() {

rpt 0.2.1/src/kdtree.rs

149	/// Guarantee: we always find the closest intersection in the current kd-cell, if any.
150	#[allow(clippy::float_cmp)]
151	fn intersect_subtree(

rquickjs-core 0.1.7/src/value.rs

222	let int = value as i32;
223	#[allow(clippy::float_cmp)]
224	// This is safe and fast in that case

rrpack-prime 0.41.0/src/range.rs

73	#[cfg(test)]
74	#[allow(clippy::float_cmp)] // Consts are used only!
75	mod tests {

rsfbclient-diesel 0.23.0/src/tests/types.rs

9	#[test]
10	#[allow(clippy::float_cmp)]
11	fn types1() -> Result<(), String> {
203	#[test]
204	#[allow(clippy::float_cmp)]
205	fn types3() -> Result<(), String> {

rug 1.19.0/src/float/casts.rs

370	#[cfg(test)]
371	#[allow(clippy::float_cmp)]
372	mod tests {

rug 1.19.0/src/float/small.rs

502	#[cfg(test)]
503	#[allow(clippy::float_cmp)]
504	mod tests {

rug 1.19.0/src/float/traits.rs

345	#[cfg(test)]
346	#[allow(clippy::float_cmp)]
347	mod tests {

rug 1.19.0/src/integer/casts.rs

398	#[cfg(test)]
399	#[allow(clippy::float_cmp)]
400	mod tests {

rug 1.19.0/src/rational/casts.rs

147	#[cfg(test)]
148	#[allow(clippy::float_cmp)]
149	mod tests {

rug 1.19.0/src/rational/traits.rs

270	#[cfg(test)]
271	#[allow(clippy::float_cmp)]
272	mod tests {

rune 0.12.0/src/compile/ir/eval.rs

121	(IrValue::Float(a), IrValue::Float(b)) => {
122	#[allow(clippy::float_cmp)]
123	match ir.op {

rustpython-common 0.2.0/src/float_ops.rs

358	// nextafter algorithm based off of https://gitlab.com/bronsonbdevost/next_afterf
359	#[allow(clippy::float_cmp)]
360	pub fn nextafter(x: f64, y: f64) -> f64 {
438	let z = y.round();
439	#[allow(clippy::float_cmp)]
440	let z = if (y - z).abs() == 0.5 {

rustpython-vm 0.1.2/src/stdlib/math.rs

59	#[allow(clippy::float_cmp)]
60	fn math_isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {

rustpython-vm 0.1.2/src/stdlib/thread.rs

117	#[pymethod(name = "__enter__")]
118	#[allow(clippy::float_cmp, clippy::match_bool)]
119	fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {
178	#[pymethod(name = "__enter__")]
179	#[allow(clippy::float_cmp, clippy::match_bool)]
180	fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {

rusty_engine 5.2.1/src/game.rs

466	}
467	#[allow(clippy::float_cmp)]
468	if text.font_size != bevy_text_component.sections[0].style.font_size {

rusty_v8 0.32.1/tests/test_api.rs

59	#[test]
60	#[allow(clippy::float_cmp)]
61	fn handle_scope_numbers() {
237	#[test]
238	#[allow(clippy::float_cmp)]
239	fn escapable_handle_scope() {
4258	#[allow(clippy::float_cmp)]
4259	#[test]

rusty_v8_m 0.4.6/tests/test_api.rs

52	#[test]
53	#[allow(clippy::float_cmp)]
54	fn handle_scope_numbers() {
176	#[test]
177	#[allow(clippy::float_cmp)]
178	fn escapable_handle_scope() {

rusty_v8_protryon 3.10.4/tests/test_api.rs

53	#[test]
54	#[allow(clippy::float_cmp)]
55	fn handle_scope_numbers() {
185	#[test]
186	#[allow(clippy::float_cmp)]
187	fn escapable_handle_scope() {

s2n-quic-core 0.16.0/src/recovery/cubic/tests.rs

87	#[allow(clippy::float_cmp)]
88	#[test]

safe_wren 0.1.0/src/core.rs

236	// I don't know of a better way to check this.
237	#[allow(clippy::float_cmp)]
238	fn f64_is_integer(x: f64) -> bool {

safecoin-runtime 1.14.3/src/bank.rs

2126	/// Create a bank from explicit arguments and deserialized fields from snapshot
2127	#[allow(clippy::float_cmp)]
2128	pub(crate) fn new_from_fields(
8287	#[test]
8288	#[allow(clippy::float_cmp)]
8289	fn test_bank_new() {

safecoin-sdk 1.14.3/src/inflation.rs

114	#[test]
115	#[allow(clippy::float_cmp)]
116	fn test_inflation_basic() {
134	#[test]
135	#[allow(clippy::float_cmp)]
136	fn test_inflation_fixed() {

safecoin-sdk 1.14.3/src/timing.rs

129	#[test]
130	#[allow(clippy::float_cmp)]
131	fn test_years_as_slots() {

safina-select 0.1.4/src/lib.rs

326	#[cfg(test)]
327	#[allow(clippy::float_cmp)]
328	mod tests {

safina-select 0.1.4/src/option_abcde.rs

166	#[cfg(test)]
167	#[allow(clippy::float_cmp)]
168	mod tests {

sardonyx_utils 0.0.3/src/ortho_camera.rs

242	#[allow(clippy::float_cmp)] // cmp just used to recognize change
243	fn run(&mut self, (dimensions, mut cameras, mut ortho_cameras): Self::SystemData) {

scanf 1.2.1/src/lib.rs

135	#[test]
136	#[allow(clippy::float_cmp)]
137	fn string_and_float() {
146	#[test]
147	#[allow(clippy::float_cmp)]
148	fn generic() {

sentry-contrib-native 0.3.1/src/options.rs

985	options.set_sample_rate(sample_rate)?;
986	#[allow(clippy::float_cmp)]
987	{

serde_cbor 0.11.2/src/ser.rs

310	#[inline]
311	#[allow(clippy::float_cmp)]
312	fn serialize_f32(self, value: f32) -> Result<()> {
333	#[inline]
334	#[allow(clippy::float_cmp)]
335	fn serialize_f64(self, value: f64) -> Result<()> {

serde_cbor_2 0.12.0-dev/src/ser.rs

310	#[inline]
311	#[allow(clippy::float_cmp)]
312	fn serialize_f32(self, value: f32) -> Result<()> {
333	#[inline]
334	#[allow(clippy::float_cmp)]
335	fn serialize_f64(self, value: f64) -> Result<()> {

serde_postgres 0.2.0/src/de.rs

222	#[cfg(test)]
223	#[allow(clippy::float_cmp)]
224	mod tests {

serenity 0.11.5/src/http/ratelimiting.rs

437	#[test]
438	#[allow(clippy::float_cmp)]
439	fn test_parse_header_good() -> Result<()> {

simple_libc 0.5.0/src/grp.rs

417	#[test]
418	#[allow(clippy::float_cmp)]
419	fn test_parse_str_from_bytes() {

simple_libc 0.5.0/src/pwd.rs

468	#[test]
469	#[allow(clippy::float_cmp)]
470	fn test_parse_str_from_bytes() {

sixtyfps-corelib 0.1.6/graphics/brush.rs

160	#[test]
161	#[allow(clippy::float_cmp)] // We want bit-wise equality here
162	fn test_linear_gradient_encoding() {

sixtyfps-corelib 0.1.6/graphics/color.rs

234	#[allow(clippy::float_cmp)] // `max` is either `red`, `green` or `blue`
235	let hue = 60.

sixtyfps-corelib 0.1.6/layout.rs

204	#[test]
205	#[allow(clippy::float_cmp)] // We want bit-wise equality here
206	fn test_layout_items() {

skia-safe 0.58.0/src/core/color.rs

314	#[allow(clippy::float_cmp)]
315	pub fn is_opaque(&self) -> bool {
383	#[test]
384	#[allow(clippy::float_cmp)]
385	pub fn color4f_array_access() {

skia-safe 0.58.0/src/core/font_arguments.rs

167	#[test]
168	#[allow(clippy::float_cmp)]
169	fn access_coordinates() {

skia-safe 0.58.0/src/core/matrix.rs

836	#[test]
837	#[allow(clippy::float_cmp)]
838	fn test_tuple_to_vector() {

skia-safe 0.58.0/src/lib.rs

51	#[test]
52	#[allow(clippy::float_cmp)]
53	fn test_transmutation_of_fixed_size_arrays_to_slice() {

smartnoise_runtime 0.2.3/src/components/transforms.rs

71	impl Evaluable for proto::Equal {
72	#[allow(clippy::float_cmp)]
73	fn evaluate(&self, _privacy_definition: &Option<proto::PrivacyDefinition>, mut arguments: NodeArguments) -> Result<ReleaseNode> {

smartnoise_validator 0.2.3/src/components/transforms.rs

201	impl Component for proto::Divide {
202	#[allow(clippy::float_cmp)]
203	fn propagate_property(

smartnoise_validator 0.2.3/src/utilities/mod.rs

509	/// Utility function for building component expansions for dp mechanisms
510	#[allow(clippy::float_cmp)]
511	pub fn expand_mechanism(

smol-rgb 0.2.0/src/lib.rs

727	#[test]
728	#[allow(clippy::float_cmp)]
729	#[cfg(feature = "std")]

solana-genesis 1.14.13/src/unlocks.rs

132	/// the number of lamports unlocked at this event
133	#[allow(clippy::float_cmp)]
134	pub fn amount(&self, total: u64) -> u64 {
147	#[test]
148	#[allow(clippy::float_cmp)]
149	fn test_make_lockups() {

solana-gossip 1.14.13/src/crds_gossip_pull.rs

1549	#[test]
1550	#[allow(clippy::float_cmp)]
1551	fn test_crds_filter_mask() {

solana-runtime 1.14.13/src/bank.rs

1857	/// Create a bank from explicit arguments and deserialized fields from snapshot
1858	#[allow(clippy::float_cmp)]
1859	pub(crate) fn new_from_fields(
8059	#[test]
8060	#[allow(clippy::float_cmp)]
8061	fn test_bank_new() {

solana-sdk 1.14.13/src/inflation.rs

114	#[test]
115	#[allow(clippy::float_cmp)]
116	fn test_inflation_basic() {
134	#[test]
135	#[allow(clippy::float_cmp)]
136	fn test_inflation_fixed() {

solana-sdk 1.14.13/src/timing.rs

129	#[test]
130	#[allow(clippy::float_cmp)]
131	fn test_years_as_slots() {

soundboard 0.1.1/src/sound/sample.rs

82	#[cfg(test)]
83	#[allow(clippy::float_cmp)]
84	mod test {

sp-ipld 0.2.0/src/dag_cbor/encode.rs

157	impl Encode<DagCborCodec> for f32 {
158	#[allow(clippy::float_cmp)]
159	fn encode(&self, _: DagCborCodec, w: &mut ByteCursor) -> Result<(), String> {
179	impl Encode<DagCborCodec> for f64 {
180	#[allow(clippy::float_cmp)]
181	fn encode(&self, c: DagCborCodec, w: &mut ByteCursor) -> Result<(), String> {

spectrum-analyzer 1.2.6/src/frequency.rs

82	impl PartialOrd for OrderableF32 {
83	#[allow(clippy::float_cmp)]
84	#[inline(always)]

spectrusty-peripherals 0.4.0/src/ay/audio.rs

424	/// the result is `0`.
425	#[allow(clippy::float_cmp)]
426	pub fn freq_to_tone_period(clock_hz: f32, hz: f32) -> Option<NonZeroU16> {

sqldatetime 0.1.34/src/interval.rs

1217	#[allow(clippy::float_cmp)]
1218	fn test_extract_dt(negate: bool, day: u32, hour: u32, min: u32, sec: u32, usec: u32) {

sqldatetime 0.1.34/src/oracle.rs

1292	#[allow(clippy::float_cmp)]
1293	fn test_extract(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32) {

sqldatetime 0.1.34/src/time.rs

757	#[allow(clippy::float_cmp)]
758	fn test_extract(hour: u32, min: u32, sec: u32, usec: u32) {

sqldatetime 0.1.34/src/timestamp.rs

1689	#[allow(clippy::float_cmp)]
1690	fn test_extract(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32, usec: u32) {

ssb-crypto 0.2.3/src/b64.rs

24	// poor-man's ceil, because f64::ceil() isn't available on no_std
25	#[allow(clippy::float_cmp)]
26	fn ceil(x: f64) -> usize {

stick 0.12.4/src/ctlr.rs

356	#[allow(clippy::float_cmp)] // imprecision should be consistent
357	fn axis(
391	#[allow(clippy::float_cmp)] // imprecision should be consistent
392	fn pressure(

substrate-wasmtime-runtime 0.16.0-threadsafe.4/src/libcalls.rs

55	/// Implementation of f32.nearest
56	#[allow(clippy::float_arithmetic, clippy::float_cmp)]
57	pub extern "C" fn wasmtime_f32_nearest(x: f32) -> f32 {
96	/// Implementation of f64.nearest
97	#[allow(clippy::float_arithmetic, clippy::float_cmp)]
98	pub extern "C" fn wasmtime_f64_nearest(x: f64) -> f64 {

suzy 0.2.0/src/animation/easing.rs

337	inner: &EasingFn(\|t\| {
338	#[allow(clippy::float_cmp)]
339	if t == 1.0 {
356	inner: &EasingFn(\|t\| {
357	#[allow(clippy::float_cmp)]
358	if t == 0.0 {

suzy 0.2.0/src/platform/opengl/matrix.rs

321	assert!(result.1 + SOME_VEC.1 <= f32::EPSILON);
322	#[allow(clippy::float_cmp)]
323	{

syn-impersonated 0.1.18/tests/test_lit.rs

167	fn floats() {
168	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
169	fn test_float(s: &str, value: f64, suffix: &str) {

syn-next 1.0.0-rc4/tests/test_lit.rs

167	fn floats() {
168	#[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
169	fn test_float(s: &str, value: f64, suffix: &str) {

tacview 0.1.4/src/record/mod.rs

73	#[test]
74	#[allow(clippy::float_cmp)]
75	fn test_max_precision() {

tallystick 0.4.3/src/quota.rs

87	#[test]
88	#[allow(clippy::float_cmp)]
89	fn quota_test() {

termusic 0.7.8/src/player/rusty_backend/cpal/host/coreaudio/macos/mod.rs

464	#[allow(clippy::while_immutable_condition)]
465	#[allow(clippy::float_cmp)]
466	fn build_input_stream_raw<D, E>(

test-case-macros 2.2.2/src/complex_expr.rs

518	#[test]
519	#[allow(clippy::float_cmp)]
520	fn parses_ord_token_stream() {
570	#[test]
571	#[allow(clippy::float_cmp)]
572	fn parses_almost_equal_token_stream() {
699	#[test]
700	#[allow(clippy::float_cmp)]
701	fn parses_grouping() {

tetsy-primitive-types 0.9.1/tests/fp_conversion.rs

13	#[test]
14	#[allow(clippy::float_cmp)]
15	fn convert_u256_to_f64() {
21	#[test]
22	#[allow(clippy::excessive_precision, clippy::float_cmp, clippy::unreadable_literal)]
23	#[cfg(feature = "std")]

tflite 0.9.6/src/model/mod.rs

365	#[allow(clippy::float_cmp)]
366	{

tgbot 0.18.0/src/methods/location/send.rs

141	#[allow(clippy::float_cmp)]
142	#[test]
181	#[allow(clippy::float_cmp)]
182	#[test]

tgbot 0.18.0/src/methods/message/edit/live_location.rs

178	#[allow(clippy::float_cmp)]
179	#[test]

tgbot 0.18.0/src/types/inline_mode/message_content.rs

571	#[allow(clippy::float_cmp)]
572	#[test]
635	#[allow(clippy::float_cmp)]
636	#[test]

tgbot 0.18.0/src/types/inline_mode/mod.rs

71	#[allow(clippy::float_cmp)]
72	#[test]
98	#[allow(clippy::float_cmp)]
99	#[test]

tgbot 0.18.0/src/types/message/data.rs

608	#[allow(clippy::float_cmp)]
609	#[test]

tiny_http 0.12.0/src/util/mod.rs

51	#[test]
52	#[allow(clippy::float_cmp)]
53	fn test_parse_header() {

tique 0.7.0/src/dismax.rs

272	#[test]
273	#[allow(clippy::float_cmp)]
274	fn tiebreaker() {

tokkit 0.17.0/src/token_manager/internals/request_scheduler.rs

216	#[test]
217	#[allow(clippy::float_cmp)]
218	fn initial_state_is_correct() {

tokkit 0.17.0/src/token_manager/internals/token_updater.rs

328	#[test]
329	#[allow(clippy::float_cmp)]
330	fn initial_state_is_correct() {

tpntree 0.5.2/src/tpntree/mod.rs

218	#[cfg(test)]
219	#[allow(clippy::float_cmp)]
220	mod tests {

tpntree 0.5.2/src/tpntree_dynamic/mod.rs

208	#[cfg(test)]
209	#[allow(clippy::float_cmp)]
210	mod tests {

trackball 0.9.0/src/orbit.rs

125	self.vec = Some((Unit::new_unchecked(old.xyz()), old.w));
126	#[allow(clippy::float_cmp)]
127	(rot.w != 1.0).then(\|\| UnitQuaternion::new_unchecked(rot))
172	self.vec = Some((Unit::new_unchecked(old.xyz()), old.w));
173	#[allow(clippy::float_cmp)]
174	(rot.w != 1.0).then(\|\| UnitQuaternion::new_unchecked(rot))

transcode-pb 0.1.0/src/trans/jtop.rs

106	#[allow(clippy::float_cmp)]
107	fn trans_numeric(enc: &mut Encoder, ty: &Type, tag: u32, s: &[u8]) -> Result<()> {

transproto 0.1.0/src/trans/jtop.rs

106	#[allow(clippy::float_cmp)]
107	fn trans_numeric(enc: &mut Encoder, ty: &Type, tag: u32, s: &[u8]) -> Result<()> {

tremor-script 0.13.0-rc.11/src/lexer/test.rs

483	#[test]
484	#[allow(clippy::float_cmp)]
485	fn lexer_long_float() -> Result<()> {

uption 0.6.5/src/collectors/ping.rs

103	#[rstest]
104	#[allow(clippy::float_cmp)]
105	fn ping_output_parsing_successful(ping_output: &str) {

uu_od 0.0.17/src/inputdecoder.rs

163	#[test]
164	#[allow(clippy::float_cmp)]
165	fn smoke_test() {

v8 0.62.0/tests/test_api.rs

85	#[test]
86	#[allow(clippy::float_cmp)]
87	fn handle_scope_numbers() {
331	#[test]
332	#[allow(clippy::float_cmp)]
333	fn escapable_handle_scope() {
5978	#[allow(clippy::float_cmp)]
5979	#[test]

varisat 0.2.2/src/decision/vsids.rs

244	// Decay is a power of two so these values are exact
245	#[allow(clippy::float_cmp)]
246	{
273	// Decay is a power of two so these values are exact
274	#[allow(clippy::float_cmp)]
275	{

varlociraptor 5.7.0/src/calling/cnvs.rs

381	impl HMM {
382	#[allow(clippy::float_cmp)]
383	fn new(depth_norm_factor: f64, min_bayes_factor: f64, purity: f64) -> Self {

varlociraptor 5.7.0/src/variants/model/likelihood.rs

357	#[test]
358	#[allow(clippy::float_cmp)]
359	fn test_likelihood_pileup() {

varpro 0.5.0/src/solvers/levmar/builder.rs

386	#[test]
387	#[allow(clippy::float_cmp)] //clippy moans, but it's wrong (again!)
388	#[allow(non_snake_case)]

veebee 1.1.1/src/game.rs

319	}
320	#[allow(clippy::float_cmp)]
321	if text_actor.font_size != text.sections[0].style.font_size {

visioncortex 0.8.0/src/color.rs

108	clippy::many_single_char_names,
109	clippy::float_cmp
110	)]

waffles-solana-runtime 1.15.0/src/bank.rs

1922	/// Create a bank from explicit arguments and deserialized fields from snapshot
1923	#[allow(clippy::float_cmp)]
1924	pub(crate) fn new_from_fields(
8257	#[test]
8258	#[allow(clippy::float_cmp)]
8259	fn test_bank_new() {

waffles-solana-sdk 1.15.0/src/inflation.rs

114	#[test]
115	#[allow(clippy::float_cmp)]
116	fn test_inflation_basic() {
134	#[test]
135	#[allow(clippy::float_cmp)]
136	fn test_inflation_fixed() {

waffles-solana-sdk 1.15.0/src/timing.rs

129	#[test]
130	#[allow(clippy::float_cmp)]
131	fn test_years_as_slots() {

wain-exec 0.3.0/src/machine.rs

447	use ast::InsnKind::*;
448	#[allow(clippy::float_cmp)]
449	match &self.kind {

warpgrapher 0.11.2/tests/node_scalar_resolver_test.rs

34	/// Passes if the create mutation and the read query both succeed.
35	#[allow(clippy::float_cmp, dead_code)]
36	async fn scalar_lists_test<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {
106	/// fail, as it sets a scalar property value rather than a list and is returned as such.
107	#[allow(clippy::float_cmp, dead_code)]
108	async fn scalar_lists_no_array_test<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {
237	/// Passes if the create mutation and the read query both succeed.
238	#[allow(clippy::float_cmp, dead_code)]
239	async fn scalar_no_lists_no_array_test<RequestCtx: RequestContext>(mut client: Client<RequestCtx>) {

wasmdbg 0.1.0/src/vm.rs

652	#[allow(clippy::float_cmp, clippy::redundant_closure)]
653	fn execute_step_internal(&mut self) -> VMResult<()> {

wasmer-vm 3.2.0-alpha.1/src/libcalls.rs

69	/// Implementation of f32.nearest
70	#[allow(clippy::float_arithmetic, clippy::float_cmp)]
71	#[no_mangle]
114	/// Implementation of f64.nearest
115	#[allow(clippy::float_arithmetic, clippy::float_cmp)]
116	#[no_mangle]

wasmer-vm-near 2.4.0/src/libcalls.rs

70	/// Implementation of f32.nearest
71	#[allow(clippy::float_arithmetic, clippy::float_cmp)]
72	#[no_mangle]
115	/// Implementation of f64.nearest
116	#[allow(clippy::float_arithmetic, clippy::float_cmp)]
117	#[no_mangle]

web-audio-api 0.28.0/src/param.rs

1075	// no computation has been done on `time`
1076	#[allow(clippy::float_cmp)]
1077	if time != event.time {

webidl 0.9.0/src/parser/visitor/pretty_print.rs

106	#[allow(unknown_lints)]
107	#[allow(clippy::float_cmp)]
108	fn stringify_float_literal(&mut self, float_literal: f64) {

whitenoise_runtime 0.2.0/src/components/transforms.rs

71	impl Evaluable for proto::Equal {
72	#[allow(clippy::float_cmp)]
73	fn evaluate(&self, _privacy_definition: &Option<proto::PrivacyDefinition>, mut arguments: NodeArguments) -> Result<ReleaseNode> {

whitenoise_validator 0.2.0/src/components/transforms.rs

191	impl Component for proto::Divide {
192	#[allow(clippy::float_cmp)]
193	fn propagate_property(

whitenoise_validator 0.2.0/src/utilities/mod.rs

490	/// Utility function for building component expansions for dp mechanisms
491	#[allow(clippy::float_cmp)]
492	pub fn expand_mechanism(

wigners 0.2.1/src/primes.rs

474	#[test]
475	#[allow(clippy::float_cmp)]
476	fn as_f64() {

winit-gfx-hal 0.0.0/tests/sse.rs

838	#[test]
839	#[allow(clippy::float_cmp)]
840	fn m128_reciprocal0() {
859	#[test]
860	#[allow(clippy::float_cmp)]
861	fn m128_reciprocal_sqrt0() {
870	#[test]
871	#[allow(clippy::float_cmp)]
872	fn m128_set() {
887	#[test]
888	#[allow(clippy::float_cmp)]
889	fn m128_set0() {
896	#[test]
897	#[allow(clippy::float_cmp)]
898	fn m128_set_reverse() {

winit-gfx-hal 0.0.0/tests/sse2.rs

738	#[test]
739	#[allow(clippy::float_cmp)]
740	fn m128d_extract0() {
1061	#[test]
1062	#[allow(clippy::float_cmp)]
1063	fn m128d_store_low() {
1070	#[test]
1071	#[allow(clippy::float_cmp)]
1072	fn m128d_store_high() {

witchcraft-metrics 1.0.1/src/meter.rs

206	#[test]
207	#[allow(clippy::float_cmp)]
208	fn starts_out_with_no_rates_or_count() {

witchcraft-metrics 1.0.1/src/reservoir.rs

111	#[cfg(test)]
112	#[allow(clippy::float_cmp)]
113	mod test {

witchcraft-metrics 1.0.1/src/timer.rs

133	#[test]
134	#[allow(clippy::float_cmp)]
135	fn basic() {

wotw_seedgen 0.2.1/src/world/player.rs

201	// the game rounds to even
202	#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation, clippy::float_cmp)]
203	if value % 1. == 0.5 && value as u8 % 2 == 0 {

wownero 0.1.2/src/util/amount.rs

1137	#[test]
1138	#[allow(clippy::float_cmp)]
1139	fn floating_point() {

wrflib 0.0.3/src/fonts.rs

462	for (index, sg) in fonts_data_read_lock.fonts[font_id].atlas_pages.iter().enumerate() {
463	#[allow(clippy::float_cmp)]
464	if sg.dpi_factor == dpi_factor && sg.font_size == font_size {

wrflib_shader_compiler 0.0.3/src/const_eval.rs

57	#[allow(clippy::float_cmp)]
58	fn try_const_eval_bin_expr(&self, _span: Span, op: BinOp, left_expr: &Expr, right_expr: &Expr) -> Option<Val> {

wrflib_vector 0.0.3/src/trapezoidator/mod.rs

146	) {
147	#[allow(clippy::float_cmp)]
148	trapezoid_segments.extend(

wrflib_widget 0.0.3/src/floatslider.rs

190	}
191	#[allow(clippy::float_cmp)]
192	if scaled_value != self.scaled_value {

xaynet-core 0.2.0/src/mask/model.rs

444	#[test]
445	#[allow(clippy::float_cmp)]
446	fn test_ratio_to_float() {

xq 0.2.42/src/number.rs

70	// `.fract().is_zero()` also works but `.fract()` is implemented by `self - self.trunc()`.
71	#[allow(clippy::float_cmp)]
72	if self.0 .0.trunc() == self.0 .0 {

yata 0.6.1/src/core/ohlcv.rs

119	// we need to check division by zero, so we can really just check if `high` is equal to `low` without using any kind of round error checks
120	#[allow(clippy::float_cmp)]
121	if self.high() == self.low() {

yata 0.6.1/src/indicators/stochastic_oscillator.rs

85	// we need to check division by zero, so we can really just check if `high` is equal to `low` without using any kind of round error checks
86	#[allow(clippy::float_cmp)]
87	let k_rows = if candle.high() == candle.low() {
184	// we need to check division by zero, so we can really just check if `highest` is equal to `lowest` without using any kind of round error checks
185	#[allow(clippy::float_cmp)]
186	let k_rows = if highest == lowest {

ymc 0.1.0/src/list/list_index.rs

28	} else if let Some(value) = val.as_f64() {
29	#[allow(clippy::float_cmp)]
30	ListIndex::Single(if value != -1.0 {

zaplib 0.0.3/src/fonts.rs

460	for (index, sg) in fonts_data_read_lock.fonts[font_id].atlas_pages.iter().enumerate() {
461	#[allow(clippy::float_cmp)]
462	if sg.dpi_factor == dpi_factor && sg.font_size == font_size {

zaplib_components 0.0.3/src/floatslider.rs

189	}
190	#[allow(clippy::float_cmp)]
191	if scaled_value != self.scaled_value {

zaplib_shader_compiler 0.0.3/src/const_eval.rs

51	#[allow(clippy::float_cmp)]
52	fn try_const_eval_bin_expr(&self, _span: Span, op: BinOp, left_expr: &Expr, right_expr: &Expr) -> Option<Val> {

zaplib_vector 0.0.3/src/trapezoidator/mod.rs

140	) {
141	#[allow(clippy::float_cmp)]
142	trapezoid_segments.extend(

zaplib_widget 0.0.1/src/floatslider.rs

143	let mut changed = false;
144	#[allow(clippy::float_cmp)]
145	if scaled_value != self.scaled_value {

af-core 0.1.8/test/main.rs

7	#![allow(clippy::float_cmp)]

alt_serde_json 1.0.61/src/lib.rs

310	clippy::excessive_precision,
311	clippy::float_cmp,
312	clippy::manual_range_contains,

amadeus-streaming 0.4.3/src/lib.rs

52	clippy::suspicious_op_assign_impl,
53	clippy::float_cmp,
54	clippy::unsafe_derive_deserialize,

amethyst-inspector 0.3.0/src/lib.rs

1	#![allow(clippy::type_complexity, clippy::float_cmp)]

arcdps-imgui 0.8.0/src/utils.rs

1	#![allow(clippy::float_cmp)]
2	use bitflags::bitflags;

ash-tray 0.19.0/src/imgui/utils.rs

1	#![allow(clippy::float_cmp)]
2	use bitflags::bitflags;

ash-tray 0.19.0/src/imgui.rs

1	#![allow(clippy::float_cmp)]
2	pub use crate::imgui_sys as sys;

assemblage_db 0.1.0/tests/index_add.rs

1	#![allow(clippy::float_cmp)]

assemblage_db 0.1.0/tests/index_swap.rs

1	#![allow(clippy::float_cmp)]

assemblage_db 0.1.0/tests/overlap_add.rs

1	#![allow(clippy::float_cmp)]

assemblage_db 0.1.0/tests/overlap_swap.rs

1	#![allow(clippy::float_cmp)]

average 0.13.1/src/lib.rs

91	#![allow(
92	clippy::float_cmp,
93	clippy::suspicious_operation_groupings,

az 1.2.1/src/tests/mod.rs

16	#![allow(clippy::float_cmp)]

basic-toml 0.1.1/tests/float.rs

1	#![allow(clippy::float_cmp)]

binary-layout 3.1.3/src/fields/primitive/copy_access.rs

356	mod tests {
357	#![allow(clippy::float_cmp)]
358	use crate::prelude::*;

binary-layout 3.1.3/src/fields/primitive/slice_access.rs

241	mod tests {
242	#![allow(clippy::float_cmp)]
243	use crate::prelude::*;

binary-layout 3.1.3/src/fields/wrapped.rs

204	mod tests {
205	#![allow(clippy::float_cmp)]
206	use crate::prelude::*;

blasoxide 0.3.2/src/lib.rs

3	#![allow(clippy::too_many_arguments)]
4	#![allow(clippy::float_cmp)]

blush 0.1.0/src/lib.rs

1177	pub fn add_stop(&mut self, color: Color, position: Fraction) -> &mut Self {
1178	#![allow(clippy::float_cmp)]
1179	let same_position = self

blush 0.1.0/src/types.rs

17	pub fn value(self) -> Scalar {
18	#![allow(clippy::float_cmp)]
19	if self.unclipped == 360.0 {

Boa 0.13.1/src/builtins/math/tests.rs

1	#![allow(clippy::float_cmp)]

Boa 0.13.1/src/builtins/number/tests.rs

1	#![allow(clippy::float_cmp)]

boa_engine 0.16.0/src/builtins/math/tests.rs

1	#![allow(clippy::float_cmp)]

border-core 0.0.5/src/util.rs

1	#![allow(clippy::float_cmp)]
2	//! Utilities for interaction of agents and environments.

border-py-gym-env 0.0.5/src/base.rs

1	//! Wrapper of gym environments implemented in Python.
2	#![allow(clippy::float_cmp)]
3	use crate::{AtariWrapper, PyGymEnvConfig};

borrow_trait 0.1.1/src/lib.rs

11	clippy::unreadable_literal,
12	clippy::float_cmp
13	)]

borsh 0.10.0/tests/test_arrays.rs

1	#![allow(clippy::float_cmp)]

browserslist-rs 0.12.3/src/lib.rs

1	#![allow(clippy::float_cmp)]
2	#![deny(clippy::if_not_else)]

bson 2.5.0/src/raw/test/mod.rs

122	fn f64() {
123	#![allow(clippy::float_cmp)]

bson2 2.0.3/src/raw/test/mod.rs

130	fn f64() {
131	#![allow(clippy::float_cmp)]

cdx 0.1.21/src/comp.rs

24	//! ```
25	#![allow(clippy::float_cmp)]
26	use crate::column::{get_col, NamedCol};

cdx 0.1.21/src/expr.rs

1	//! Floating Point expressions
2	#![allow(clippy::float_cmp)]

compute 0.2.3/src/distributions/bernoulli.rs

1	#![allow(clippy::float_cmp)]
2	use crate::distributions::*;

concrete-core 1.0.2/src/commons/crypto/encoding/encoder.rs

296	mod test {
297	#![allow(clippy::float_cmp)]

cpython 0.7.1/src/objects/num.rs

19	#![allow(clippy::float_cmp)]

crystal_packing 0.6.0/src/basis/shared_value.rs

150	// The floating point values should be the same, so using standard equality is valid.
151	#![allow(clippy::float_cmp)]

cxx 1.0.88/tests/test.rs

5	clippy::cast_possible_wrap,
6	clippy::float_cmp,
7	clippy::needless_pass_by_value,

dicetest 0.3.1/src/dice/float.rs

1	#![allow(clippy::float_cmp)]

dimensioned 0.8.0/src/lib.rs

114	#![allow(
115	clippy::float_cmp,
116	clippy::useless_attribute,

directx_math 0.2.2/src/lib.rs

79	#![allow(clippy::approx_constant)]
80	#![allow(clippy::float_cmp)]
81	#![allow(clippy::needless_range_loop)]

dragonbox 0.1.4/tests/binary64_test.rs

23	clippy::excessive_precision,
24	clippy::float_cmp,
25	clippy::int_plus_one,

duckdb 0.6.1/src/types/mod.rs

404	fn test_numeric_conversions() -> Result<()> {
405	#![allow(clippy::float_cmp)]

egui 0.20.1/src/lib.rs

299	#![allow(clippy::float_cmp)]
300	#![allow(clippy::manual_range_contains)]

egui_demo_lib 0.20.0/src/lib.rs

11	#![allow(clippy::float_cmp)]
12	#![allow(clippy::manual_range_contains)]

egui_extras 0.20.0/src/lib.rs

9	#![allow(clippy::float_cmp)]
10	#![allow(clippy::manual_range_contains)]

egui_glium 0.20.1/src/lib.rs

11	#![allow(clippy::float_cmp)]
12	#![allow(clippy::manual_range_contains)]

egui_glow 0.20.1/src/lib.rs

11	#![allow(clippy::float_cmp)]
12	#![allow(clippy::manual_range_contains)]

egui_glow_tao 0.20.1/src/lib.rs

11	#![allow(clippy::float_cmp)]
12	#![allow(clippy::manual_range_contains)]

emath 0.20.0/src/lib.rs

22	#![allow(clippy::float_cmp)]

entity 0.3.2/src/ent/value/number.rs

546	mod tests {
547	#![allow(clippy::float_cmp)]
548	use super::*;

entity_macros 0.3.2/tests/derive/enum/ent.rs

68	fn supports_generic_fields() {
69	#![allow(clippy::float_cmp)]

entity_macros 0.3.2/tests/derive/struct/ent.rs

1259	fn supports_generic_fields() {
1260	#![allow(clippy::float_cmp)]

entity_macros 0.3.2/tests/derive/struct/field.rs

120	fn supports_generic_ent_fields() {
121	#![allow(clippy::float_cmp)]

epaint 0.20.0/src/lib.rs

12	#![allow(clippy::float_cmp)]
13	#![allow(clippy::manual_range_contains)]

epi 0.17.0/src/lib.rs

87	)]
88	#![allow(clippy::float_cmp)]
89	#![allow(clippy::manual_range_contains)]

esri_ascii_grid 0.1.2/src/lib.rs

76	clippy::cast_precision_loss,
77	clippy::float_cmp
78	)]

ewebsock 0.2.0/src/lib.rs

88	)]
89	#![allow(clippy::float_cmp)]
90	#![allow(clippy::manual_range_contains)]

farbraum 0.1.0/src/lib.rs

1	#![allow(clippy::float_cmp)]

float_eq 1.0.1/src/trait_impls/primitives.rs

1	#![allow(clippy::float_cmp)]

fundsp 0.12.0/src/lib.rs

9	clippy::type_complexity,
10	clippy::float_cmp,
11	clippy::len_zero,

fundsp 0.12.0/tests/basic.rs

4	clippy::type_complexity,
5	clippy::float_cmp,
6	clippy::len_zero,

fundsp 0.12.0/tests/filter.rs

4	clippy::type_complexity,
5	clippy::float_cmp,
6	clippy::len_zero,

fyrox-sound 0.30.0/src/renderer/mod.rs

8	#![allow(clippy::float_cmp)]

fyrox-sound 0.30.0/src/source.rs

30	#![allow(clippy::float_cmp)]

fyrox-ui 0.20.0/src/lib.rs

6	#![allow(irrefutable_let_patterns)]
7	#![allow(clippy::float_cmp)]
8	#![allow(clippy::upper_case_acronyms)]

geo-validator 0.1.3/src/lib.rs

1	#![allow(clippy::float_cmp)]

git_function_history 0.7.0/src/lib.rs

7	clippy::cognitive_complexity,
8	clippy::float_cmp,
9	// clippy::similar_names,

gkquad 0.0.4/src/lib.rs

19	deprecated,
20	clippy::float_cmp,
21	clippy::cognitive_complexity,

glerminal 0.3.0/src/lib.rs

68	#![warn(clippy::all)]
69	#![allow(clippy::float_cmp)]

gonk 0.1.2/src/main.rs

3	clippy::wildcard_imports,
4	clippy::float_cmp,
5	clippy::cast_lossless,

grafix-toolbox 0.8.7/crate.rs

4	non_camel_case_types,
5	clippy::float_cmp,
6	clippy::from_over_into,

grass 0.12.2/src/lib.rs

74	clippy::cast_precision_loss,
75	clippy::float_cmp,
76	clippy::wildcard_imports,

grass_compiler 0.12.2/src/lib.rs

74	clippy::cast_precision_loss,
75	clippy::float_cmp,
76	clippy::wildcard_imports,

hektor 0.2.2/tests/addition.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/component_getters.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/component_mutators.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/cross_product.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/determinant.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/from_into_array.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/indexing.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]
3	#![allow(clippy::unnecessary_operation)]

hektor 0.2.2/tests/length_length2.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hektor 0.2.2/tests/mat_inverse.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]
3	#![allow(clippy::unreadable_literal)]

hektor 0.2.2/tests/mat_mul_mat.rs

1	#![allow(bad_style)]
2	#![allow(clippy::float_cmp)]

hexf 0.2.1/tests/example.rs

1	#![allow(clippy::float_cmp)]

ijson 0.1.3/src/number.rs

1	//! Functionality relating to the JSON number type
2	#![allow(clippy::float_cmp)]

image2 1.8.2/src/color.rs

1	#![allow(clippy::float_cmp)]

imagecli 0.2.1/src/lib.rs

11	clippy::single_match,
12	clippy::float_cmp,
13	clippy::cast_lossless

imdl 0.1.12/src/lib.rs

5	clippy::float_arithmetic,
6	clippy::float_cmp,
7	clippy::implicit_return,

imgui 0.10.0/src/utils.rs

1	#![allow(clippy::float_cmp)]
2	use bitflags::bitflags;

inari 1.0.0/src/lib.rs

16	#![allow(clippy::float_cmp)]

interior_mutability_pointer 0.3.6/src/tests.rs

3	#![allow(clippy::bool_assert_comparison)]
4	#![allow(clippy::float_cmp)]

kalk 3.0.3/src/lib.rs

1	#![allow(clippy::unused_unit)]
2	#![allow(clippy::float_cmp)]
3	#![allow(clippy::clone_on_copy)] // the float type needs explicit cloning if the rug feature is enabled

kdb 0.3.0/src/list.rs

301	mod test {
302	#![allow(clippy::float_cmp)]

ketos 0.12.0/src/ketos/lib.rs

29	#![allow(clippy::new_without_default_derive)]
30	#![allow(clippy::float_cmp)]

koto 0.11.0/tests/one_plus_two.rs

1	#![allow(clippy::float_cmp)]

libm 0.2.6/src/lib.rs

10	#![allow(clippy::mixed_case_hex_literals)]
11	#![allow(clippy::float_cmp)]
12	#![allow(clippy::eq_op)]

lightbeam 0.30.0/src/backend.rs

1	#![allow(clippy::float_cmp)]

lokacore 0.3.0/tests/math.rs

1	#![allow(clippy::float_cmp)]
2	//! Most tests here are just the example code for each method in the stdlib,

lorawan 0.7.1/tests/maccommands.rs

103	fn test_duty_cycle_req_new() {
104	#![allow(clippy::float_cmp)]
105	let data = vec![0x02];

lorawan-encoding 0.6.2/tests/maccommands.rs

103	fn test_duty_cycle_req_new() {
104	#![allow(clippy::float_cmp)]
105	let data = vec![0x02];

lyon_algorithms 1.0.2/src/lib.rs

2	#![deny(bare_trait_objects)]
3	#![allow(clippy::float_cmp)]
4	#![no_std]

lyon_tessellation 1.0.8/src/lib.rs

3	#![deny(unconditional_recursion)]
4	#![allow(clippy::float_cmp)]
5	#![allow(clippy::too_many_arguments)]

macaw 0.18.0/src/color_rgba8.rs

184	fn test_srgba() {
185	#![allow(clippy::float_cmp)]

macaw 0.18.0/src/plane3.rs

112	fn test_plane3() {
113	#![allow(clippy::float_cmp)]
114	let point = Vec3::new(2.0, 3.0, 4.0);

malachite-base 0.3.2/src/lib.rs

95	clippy::cognitive_complexity,
96	clippy::float_cmp,
97	clippy::many_single_char_names,

malachite-base 0.3.2/tests/lib.rs

28	clippy::excessive_precision,
29	clippy::float_cmp,
30	clippy::too_many_arguments,

malachite-nz 0.3.2/tests/lib.rs

11	clippy::too_many_arguments,
12	clippy::float_cmp,
13	clippy::type_complexity

malachite-q 0.3.2/tests/lib.rs

11	clippy::too_many_arguments,
12	clippy::float_cmp,
13	clippy::type_complexity

matrixcompare 0.3.0/src/lib.rs

73	#![allow(clippy::float_cmp)]

miniball 0.1.1/tests/ball_enclosing_points.rs

7	#![allow(clippy::float_cmp)]

miniball 0.1.1/tests/ball_with_bounds.rs

7	#![allow(clippy::float_cmp)]

minidsp 0.1.4/src/formats/rew.rs

71	mod test {
72	#![allow(clippy::float_cmp)]
73	use super::*;

mlx9064x 0.2.1/src/lib.rs

68	#![no_std]
69	#![allow(clippy::float_cmp)]

mpi 0.6.0/examples/immediate.rs

1	#![deny(warnings)]
2	#![allow(clippy::float_cmp)]
3	extern crate mpi;

mpi 0.6.0/examples/wait_any.rs

1	#![deny(warnings)]
2	#![allow(clippy::float_cmp)]
3	extern crate mpi;

mpi-fork-fnsp 0.6.0/examples/immediate.rs

1	#![deny(warnings)]
2	#![allow(clippy::float_cmp)]
3	extern crate mpi_fork_fnsp as mpi;

mpi-fork-fnsp 0.6.0/examples/wait_any.rs

1	#![deny(warnings)]
2	#![allow(clippy::float_cmp)]
3	extern crate mpi_fork_fnsp as mpi;

nalgebra 0.32.1/examples/unit_wrapper.rs

1	#![allow(clippy::float_cmp)]
2	extern crate nalgebra as na;

ndarray 0.15.6/tests/array.rs

6	clippy::many_single_char_names,
7	clippy::float_cmp
8	)]

ndarray 0.15.6/tests/azip.rs

5	clippy::many_single_char_names,
6	clippy::float_cmp
7	)]

ndarray 0.15.6/tests/dimension.rs

1	#![allow(clippy::float_cmp)]

ndarray 0.15.6/tests/into-ixdyn.rs

5	clippy::many_single_char_names,
6	clippy::float_cmp
7	)]

ndarray 0.15.6/tests/iterator_chunks.rs

5	clippy::many_single_char_names,
6	clippy::float_cmp
7	)]

ndarray 0.15.6/tests/ix0.rs

5	clippy::many_single_char_names,
6	clippy::float_cmp
7	)]

ndarray 0.15.6/tests/ixdyn.rs

5	clippy::many_single_char_names,
6	clippy::float_cmp
7	)]

ndarray 0.15.6/tests/numeric.rs

5	clippy::many_single_char_names,
6	clippy::float_cmp
7	)]

open-vaf 0.4.2/src/analysis/constant_folding.rs

9	#![allow(clippy::float_cmp)]
10	#![allow(clippy::similar_names)]

ord_subset 3.1.1/tests/lib.rs

1	#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, match_wild_err_arm))]
2	extern crate ord_subset;

ordcode 0.2.2/tests/test_primitives.rs

1	#![allow(clippy::float_cmp)]

ordered-float 3.4.0/tests/test.rs

1	#![allow(clippy::float_cmp, clippy::eq_op, clippy::op_ref)]

oxidate 0.1.0/src/lex/literal/tests.rs

1	#![allow(clippy::float_cmp, clippy::non_ascii_literal, non_snake_case)]

pastel 0.9.0/src/lib.rs

1256	pub fn add_stop(&mut self, color: Color, position: Fraction) -> &mut Self {
1257	#![allow(clippy::float_cmp)]
1258	let same_position = self

pastel 0.9.0/src/types.rs

17	pub fn value(self) -> Scalar {
18	#![allow(clippy::float_cmp)]
19	if self.unclipped == 360.0 {

path-dsl 0.6.1/src/lib.rs

267	#![allow(clippy::cognitive_complexity)]
268	#![allow(clippy::float_cmp)]
269	#![deny(nonstandard_style)]

php_serde 0.6.0/src/lib.rs

1	#![forbid(missing_docs)]
2	#![allow(clippy::float_cmp)]
3	//! # PHP serialization format support for serde

pickledb 0.5.1/tests/pickledb_key_value_tests.rs

1	#![allow(clippy::float_cmp)]

pickledb 0.5.1/tests/pickledb_list_tests.rs

1	#![allow(clippy::float_cmp)]

portable-atomic 1.0.1/src/lib.rs

177	clippy::doc_markdown,
178	clippy::float_cmp,
179	clippy::inline_always,

portable-atomic-util 0.1.0/src/lib.rs

69	clippy::doc_markdown,
70	clippy::float_cmp,
71	clippy::inline_always,

profqu_neat 0.1.1/src/lib.rs

12	#![allow(clippy::must_use_candidate)]
13	#![allow(clippy::float_cmp)]
14	#![allow(clippy::cast_precision_loss)]

puffin_egui 0.19.2/src/lib.rs

90	// crate-specific exceptions:
91	#![allow(clippy::float_cmp, clippy::manual_range_contains)]

pyo3 0.18.0/src/types/floatob.rs

57	// PyFloat_AsDouble returns -1.0 upon failure
58	#![allow(clippy::float_cmp)]
59	fn extract(obj: &'source PyAny) -> PyResult<Self> {

pyxel-core 1.9.11/src/lib.rs

7	clippy::cast_sign_loss,
8	clippy::float_cmp,
9	clippy::fn_params_excessive_bools,

quickersort 3.0.1/tests/test-floats.rs

1	#![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]

rand 0.8.5/src/lib.rs

54	#![allow(
55	clippy::float_cmp,
56	clippy::neg_cmp_op_on_partial_ord,

rand_distr 0.4.3/src/lib.rs

17	clippy::excessive_precision,
18	clippy::float_cmp,
19	clippy::unreadable_literal

rawbson 0.2.1/src/lib.rs

1478	fn f64() {
1479	#![allow(clippy::float_cmp)]

rbson 2.0.5/src/raw/test/mod.rs

130	fn f64() {
131	#![allow(clippy::float_cmp)]

rg3d-sound 0.26.0/src/renderer/mod.rs

8	#![allow(clippy::float_cmp)]

rg3d-sound 0.26.0/src/source/generic.rs

31	#![allow(clippy::float_cmp)]

rg3d-ui 0.15.0/src/lib.rs

6	#![allow(irrefutable_let_patterns)]
7	#![allow(clippy::float_cmp)]
8	#![allow(clippy::upper_case_acronyms)]

rhai 1.12.0/src/func/builtin.rs

3	#![allow(clippy::float_cmp)]

rlbot 0.5.0/src/packeteer.rs

1	#![allow(clippy::float_cmp)]

rlr 0.2.0/src/lib.rs

16	clippy::must_use_candidate,
17	clippy::float_cmp,
18	clippy::similar_names,

rug 1.19.0/src/float/tests.rs

17	#![allow(clippy::float_cmp)]

rug 1.19.0/src/integer/tests.rs

17	#![allow(clippy::float_cmp)]

rusqlite 0.28.0/src/types/mod.rs

390	fn test_numeric_conversions() -> Result<()> {
391	#![allow(clippy::float_cmp)]

rusqlite-ic 0.28.1/src/types/mod.rs

390	fn test_numeric_conversions() -> Result<()> {
391	#![allow(clippy::float_cmp)]

rusqlite-le 0.24.2/src/types/mod.rs

401	fn test_numeric_conversions() -> Result<()> {
402	#![allow(clippy::float_cmp)]

ryu 1.0.12/tests/d2s_test.rs

23	clippy::cast_lossless,
24	clippy::float_cmp,
25	clippy::int_plus_one,

ryu 1.0.12/tests/f2s_test.rs

22	clippy::approx_constant,
23	clippy::float_cmp,
24	clippy::non_ascii_literal,

ryu 1.0.12/tests/s2d_test.rs

28	clippy::excessive_precision,
29	clippy::float_cmp,
30	clippy::manual_range_contains,

ryu 1.0.12/tests/s2f_test.rs

28	clippy::checked_conversions,
29	clippy::float_cmp,
30	clippy::manual_range_contains,

ryu-js 0.2.2/tests/d2s_test.rs

24	clippy::cast_lossless,
25	clippy::float_cmp,
26	clippy::int_plus_one,

ryu-js 0.2.2/tests/f2s_test.rs

22	clippy::approx_constant,
23	clippy::float_cmp,
24	clippy::non_ascii_literal,

ryu-js 0.2.2/tests/s2d_test.rs

21	#![allow(clippy::float_cmp)]
22	#![cfg(not(feature = "small"))]
29	clippy::excessive_precision,
30	clippy::float_cmp,
31	clippy::manual_range_contains,

ryu-js 0.2.2/tests/s2f_test.rs

28	clippy::checked_conversions,
29	clippy::float_cmp,
30	clippy::manual_range_contains,

serde_dynamo 4.0.12/src/de/tests.rs

1	#![allow(clippy::float_cmp, clippy::redundant_clone, clippy::unit_cmp)]

serde_dynamo 4.0.12/src/ser/tests.rs

1	#![allow(clippy::float_cmp, clippy::redundant_clone)]

serde_json 1.0.91/src/lib.rs

311	clippy::explicit_auto_deref,
312	clippy::float_cmp,
313	clippy::manual_range_contains,

serde_json 1.0.91/tests/lexical.rs

9	clippy::excessive_precision,
10	clippy::float_cmp,
11	clippy::if_not_else,

serde_json 1.0.91/tests/regression/issue520.rs

1	#![allow(clippy::float_cmp)]

serde_json 1.0.91/tests/test.rs

6	clippy::excessive_precision,
7	clippy::float_cmp,
8	clippy::items_after_statements,

serde_json_lenient 0.1.4/src/lib.rs

318	clippy::excessive_precision,
319	clippy::float_cmp,
320	clippy::manual_range_contains,

serde_partiql 1.1.65/src/lib.rs

310	clippy::excessive_precision,
311	clippy::float_cmp,
312	clippy::manual_range_contains,

serde_php 0.5.0/src/lib.rs

1	#![forbid(missing_docs)]
2	#![allow(clippy::float_cmp)]
3	//! # PHP serialization format support for serde

serde_test 1.0.152/src/lib.rs

145	// Ignored clippy lints
146	#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
147	// Ignored clippy_pedantic lints

shred 0.14.1/src/world/mod.rs

657	fn exec() {
658	#![allow(clippy::float_cmp)]

sleef 0.3.0/src/lib.rs

7	#![allow(clippy::cast_lossless)]
8	#![allow(clippy::float_cmp)]
9	#![allow(clippy::cognitive_complexity)]

slog-extlog 8.0.0/src/slog_test.rs

46	//! are generated as expected.
47	#![allow(clippy::float_cmp)]
48	pub use super::stats::*;

soa_derive 0.12.0/tests/extreme.rs

1	#![deny(warnings)]
2	#![allow(clippy::float_cmp)]

soa_derive 0.12.0/tests/index.rs

1	#![allow(clippy::float_cmp)]

soa_derive 0.12.0/tests/iter.rs

1	#![allow(clippy::float_cmp)]

soa_derive 0.12.0/tests/ptr.rs

1	#![allow(clippy::float_cmp)]

soa_derive 0.12.0/tests/slice.rs

1	#![allow(clippy::float_cmp)]

soa_derive 0.12.0/tests/vec.rs

1	#![allow(clippy::float_cmp)]

soa_derive 0.12.0/tests/zip.rs

1	#![allow(clippy::float_cmp)]

softposit 0.4.0/src/lib.rs

2	#![allow(clippy::cast_lossless)]
3	#![allow(clippy::float_cmp)]
4	#![allow(clippy::many_single_char_names)]

spectrum-analyzer 1.2.6/src/lib.rs

71	clippy::fallible_impl_from,
72	clippy::float_cmp
73	)]

starlark 0.8.0/src/lib.rs

389	#![allow(clippy::missing_safety_doc)]
390	#![allow(clippy::float_cmp)]
391	// FIXME: Temporary

streaming_algorithms 0.3.0/src/lib.rs

46	clippy::suspicious_op_assign_impl,
47	clippy::float_cmp,
48	clippy::unsafe_derive_deserialize,

substrace_utils 0.2.0/src/consts.rs

1	#![allow(clippy::float_cmp)]

swash 0.1.6/src/lib.rs

25	#![allow(clippy::float_cmp)]
26	#![allow(clippy::many_single_char_names)]

syn 1.0.107/tests/test_lit.rs

1	#![allow(clippy::float_cmp, clippy::non_ascii_literal)]

tensorgraph-math 0.1.11/src/lib.rs

176	clippy::module_name_repetitions,
177	clippy::float_cmp,
178	clippy::many_single_char_names,

tensorgraph-sys 0.1.11/src/lib.rs

17	clippy::module_name_repetitions,
18	clippy::float_cmp,
19	clippy::many_single_char_names,

tgbot 0.18.0/src/types/location.rs

46	mod tests {
47	#![allow(clippy::float_cmp)]
48	use super::*;

tgbot 0.18.0/src/types/stickers.rs

181	mod tests {
182	#![allow(clippy::float_cmp)]
183	use super::*;

themelio-stf 0.11.13/src/stake.rs

1	#![allow(clippy::float_cmp)]

tibrv 0.6.0/src/field.rs

7	#![allow(clippy::float_cmp)]

tremor-script 0.13.0-rc.11/src/std_lib/stats.rs

773	mod test {
774	#![allow(clippy::float_cmp)]
775	use super::*;

twofloat 0.6.1/src/lib.rs

63	#![allow(clippy::excessive_precision)]
64	#![allow(clippy::float_cmp)]
65	#![allow(clippy::suspicious_arithmetic_impl)]

twofloat 0.6.1/tests/arithmetic_tests.rs

1	#![allow(clippy::float_cmp)]

twofloat 0.6.1/tests/base_tests.rs

1	#![allow(clippy::float_cmp)]

twofloat 0.6.1/tests/convert_tests.rs

1	#![allow(clippy::float_cmp)]

twofloat 0.6.1/tests/fraction_tests.rs

1	#![allow(clippy::float_cmp)]

twofloat 0.6.1/tests/power_tests.rs

1	#![cfg(feature = "math_funcs")]
2	#![allow(clippy::float_cmp)]

umpl 1.1.0/src/lib.rs

10	clippy::cognitive_complexity,
11	clippy::float_cmp,
12	clippy::similar_names,

ux-animate 0.1.5/src/easing.rs

1	#![allow(dead_code)]
2	#![allow(clippy::float_cmp)]

ux-animate 0.1.5/src/tween/easing.rs

1	#![allow(clippy::float_cmp)]

ux-charts 0.1.3/src/bar.rs

2	#![allow(unused_variables)]
3	#![allow(clippy::explicit_counter_loop, clippy::float_cmp)]

ux-charts 0.1.3/src/basechart.rs

1	#![allow(unused_variables)]
2	#![allow(clippy::explicit_counter_loop, clippy::float_cmp)]

ux-charts 0.1.3/src/gauge.rs

1	#![allow(unused_variables)]
2	#![allow(clippy::explicit_counter_loop, clippy::float_cmp)]

ux-charts 0.1.3/src/line.rs

5	clippy::explicit_counter_loop,
6	clippy::float_cmp,
7	clippy::unnecessary_unwrap,

ux-charts 0.1.3/src/pie.rs

3	#![allow(dead_code)]
4	#![allow(clippy::explicit_counter_loop, clippy::float_cmp)]

ux-components 0.1.3/src/lib.rs

5	clippy::if_same_then_else,
6	clippy::float_cmp,
7	clippy::collapsible_if,

versionize 0.1.9/src/primitives.rs

3	//! Serialization support for primitive data types.
4	#![allow(clippy::float_cmp)]

watt 0.4.2/runtime/src/lib.rs

2	clippy::cognitive_complexity,
3	clippy::float_cmp,
4	clippy::let_unit_value,

watt-non-static-runtime 0.4.0/runtime/src/lib.rs

2	clippy::cognitive_complexity,
3	clippy::float_cmp,
4	clippy::let_unit_value,

wf2_core 0.31.0/src/lib.rs

87	clippy::trivially_copy_pass_by_ref,
88	clippy::float_cmp,
89	clippy::needless_doctest_main,

wrflib 0.0.3/src/lib.rs

11	// Not great but we do these comparisons all over the place..
12	#![allow(clippy::float_cmp)]
13	// We want to use links to private fields, since we use `--document-private-items`.

wrflib_widget 0.0.3/src/lib.rs

11	// Not great but we do these comparisons all over the place..
12	#![allow(clippy::float_cmp)]
13	// We want to use links to private fields, since we use `--document-private-items`.

zaplib 0.0.3/src/lib.rs

11	// Not great but we do these comparisons all over the place..
12	#![allow(clippy::float_cmp)]
13	// We want to use links to private fields, since we use `--document-private-items`.

zaplib_components 0.0.3/src/lib.rs

5	// Not great but we do these comparisons all over the place..
6	#![allow(clippy::float_cmp)]
7	// We want to use links to private fields, since we use `--document-private-items`.

zaplib_widget 0.0.1/src/lib.rs

5	// Not great but we do these comparisons all over the place..
6	#![allow(clippy::float_cmp)]

779	(_, &Value::Boolean(b)) => a.as_boolean() == b,
780	#[allow(clippy::float_cmp)]
781	(&Value::Float(a), &Value::Float(b)) => a == b,
782	#[allow(clippy::float_cmp)]
783	(&Value::Float(a), _) => a == b.as_float(),
784	#[allow(clippy::float_cmp)]
785	(_, &Value::Float(b)) => a.as_float() == b,