diff --git a/concrete-optimizer/src/computing_cost/fft.rs b/concrete-optimizer/src/computing_cost/fft.rs index 17cc4cfd4..a528d73f0 100644 --- a/concrete-optimizer/src/computing_cost/fft.rs +++ b/concrete-optimizer/src/computing_cost/fft.rs @@ -41,17 +41,17 @@ pub mod tests { /** Standard fft complexity with X factors*/ pub const COST_AWS: AsymptoticWithFactors = AsymptoticWithFactors { // https://github.com/zama-ai/concrete-optimizer/blob/prototype/python/optimizer/noise_formulas/bootstrap.py#L150 - factor_fft: 0.20292695115308917, - factor_ifft: 0.407795078512891, + factor_fft: 0.202_926_951_153_089_17, + factor_ifft: 0.407_795_078_512_891, }; #[test] fn golden_python_prototype() { - let golden_fft = 664.3856189774724; + let golden_fft = 664.385_618_977_472_4; let actual_fft = fft::DEFAULT.fft_complexity(100); approx::assert_relative_eq!(golden_fft, actual_fft, epsilon = f64::EPSILON); - let golden_ifft = 664.3856189774724; + let golden_ifft = 664.385_618_977_472_4; let actual_ifft = fft::DEFAULT.ifft_complexity(100); approx::assert_relative_eq!(golden_ifft, actual_ifft, epsilon = f64::EPSILON); } diff --git a/concrete-optimizer/src/computing_cost/operators/cmux.rs b/concrete-optimizer/src/computing_cost/operators/cmux.rs index 1e5dbaae3..682f8344c 100644 --- a/concrete-optimizer/src/computing_cost/operators/cmux.rs +++ b/concrete-optimizer/src/computing_cost/operators/cmux.rs @@ -76,10 +76,10 @@ pub mod tests { pub const COST_AWS: Default = SimpleWithFactors { /* https://github.com/zama-ai/concrete-optimizer/blob/prototype/python/optimizer/noise_formulas/bootstrap.py#L145 */ fft: fft::tests::COST_AWS, - linear_fft_factor: Some(0.011647955063264166), - linear_ifft_factor: Some(0.018836852582634938), - blind_rotate_factor: 0.8418306429189878, - constant_cost: 923.7542202718637, + linear_fft_factor: Some(0.011_647_955_063_264_166), + linear_ifft_factor: Some(0.018_836_852_582_634_938), + blind_rotate_factor: 0.841_830_642_918_987_8, + constant_cost: 923.754_220_271_863_7, }; #[test] @@ -123,19 +123,19 @@ pub mod tests { let actual = DEFAULT.complexity(cmux_param1, 0); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 138621.0; + let golden = 138_621.0; let actual = DEFAULT.complexity(cmux_param2, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 927.1215428435396; + let golden = 927.121_542_843_539_6; let actual = COST_AWS.complexity(cmux_param1, 0); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 117019.72048983313; + let golden = 117_019.720_489_833_13; let actual = COST_AWS.complexity(cmux_param2, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 7651844.24194206; + let golden = 7_651_844.241_942_06; let actual = COST_AWS.complexity(cmux_param3, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); } diff --git a/concrete-optimizer/src/computing_cost/operators/keyswitch_lwe.rs b/concrete-optimizer/src/computing_cost/operators/keyswitch_lwe.rs index a2f41a3ff..95291fbf7 100644 --- a/concrete-optimizer/src/computing_cost/operators/keyswitch_lwe.rs +++ b/concrete-optimizer/src/computing_cost/operators/keyswitch_lwe.rs @@ -46,13 +46,13 @@ mod tests { use super::*; pub const COST_AWS: SimpleProductWithFactor = SimpleProductWithFactor { - factor: 0.12547239853890443, + factor: 0.125_472_398_538_904_43, }; #[test] fn golden_python_prototype() { let ignored = 0; - let golden = 134313984.0; + let golden = 134_313_984.0; let ks_params = KeyswitchParameters { input_lwe_dimension: LweDimension(1024), @@ -66,7 +66,7 @@ mod tests { let actual = DEFAULT.complexity(ks_params, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 538899848.2752727; + let golden = 538_899_848.275_272_7; let actual = COST_AWS.complexity(ks_params, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); } diff --git a/concrete-optimizer/src/computing_cost/operators/pbs.rs b/concrete-optimizer/src/computing_cost/operators/pbs.rs index 9bc5c8a9e..94754e007 100644 --- a/concrete-optimizer/src/computing_cost/operators/pbs.rs +++ b/concrete-optimizer/src/computing_cost/operators/pbs.rs @@ -75,11 +75,11 @@ pub mod tests { let actual = DEFAULT.complexity(pbs_param1, 32); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 249957554585600.0; + let golden = 249_957_554_585_600.0; let actual = DEFAULT.complexity(pbs_param2, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); - let golden = 208532086206064.16; + let golden = 208_532_086_206_064.16; let actual = COST_AWS.complexity(pbs_param2, 64); approx::assert_relative_eq!(golden, actual, epsilon = f64::EPSILON); } diff --git a/concrete-optimizer/src/lib.rs b/concrete-optimizer/src/lib.rs index 4301873f1..cb9694412 100644 --- a/concrete-optimizer/src/lib.rs +++ b/concrete-optimizer/src/lib.rs @@ -10,7 +10,6 @@ #![allow(clippy::similar_names)] #![allow(clippy::suboptimal_flops)] #![allow(clippy::too_many_arguments)] -#![allow(clippy::unreadable_literal)] #![allow(clippy::match_wildcard_for_single_variants)] #![allow(clippy::cast_lossless)] #![warn(unused_results)] diff --git a/concrete-optimizer/src/optimisation/atomic_pattern.rs b/concrete-optimizer/src/optimisation/atomic_pattern.rs index 75e24cdc0..2566d6b43 100644 --- a/concrete-optimizer/src/optimisation/atomic_pattern.rs +++ b/concrete-optimizer/src/optimisation/atomic_pattern.rs @@ -10,8 +10,7 @@ use crate::parameters::{ KsDecompositionParameters, LweDimension, PbsParameters, }; use crate::security; -use complexity_atomic_pattern::AtomicPatternComplexity; -use complexity_atomic_pattern::DEFAULT as DEFAULT_COMPLEXITY; +use complexity_atomic_pattern::{AtomicPatternComplexity, DEFAULT as DEFAULT_COMPLEXITY}; use concrete_commons::dispersion::{DispersionParameter, Variance}; use concrete_commons::numeric::UnsignedInteger; @@ -452,7 +451,7 @@ fn assert_checks( security_level, ) .get_variance(); - assert!(f64::abs(noise_max - check_max_noise) / check_max_noise < 0.00000000001); + assert!(f64::abs(noise_max - check_max_noise) / check_max_noise < 0.000_000_000_01); let check_complexity = DEFAULT_COMPLEXITY.complexity( consts.sum_size, atomic_pattern_parameters, diff --git a/concrete-optimizer/src/security/glwe.rs b/concrete-optimizer/src/security/glwe.rs index ccb8dfa0f..65a680ad0 100644 --- a/concrete-optimizer/src/security/glwe.rs +++ b/concrete-optimizer/src/security/glwe.rs @@ -18,7 +18,7 @@ pub fn minimal_variance( let espsilon_log2_std_modular = 2.0; let espsilon_log2_std = espsilon_log2_std_modular - (ciphertext_modulus_log as f64); let equiv_lwe_dimension = (glwe_params.glwe_dimension * glwe_params.polynomial_size()) as f64; - let secure_log2_std = -0.026374888765705498 * equiv_lwe_dimension + 2.012143923330495; + let secure_log2_std = -0.026_374_888_765_705_498 * equiv_lwe_dimension + 2.012_143_923_330_495; // TODO: could be added instead let log2_std = f64::max(secure_log2_std, espsilon_log2_std); let log2_var = 2.0 * log2_std; @@ -34,7 +34,7 @@ mod tests { fn golden_python_prototype_security_security_glwe_variance_low() { // python securityFunc(10,14,64)= 0.3120089883926036 let integer_size = 64; - let golden_std_dev = 2.168404344971009e-19; + let golden_std_dev = 2.168_404_344_971_009e-19; let security_level = 128; let glwe_params = GlweParameters { log2_polynomial_size: 14, @@ -52,7 +52,7 @@ mod tests { fn golden_python_prototype_security_security_glwe_variance_high() { // python securityFunc(3,8,32)= 2.6011445832514504 let integer_size = 32; - let golden_std_dev = 3.2216458741669603e-6; + let golden_std_dev = 3.221_645_874_166_960_3e-6; let security_level = 128; let glwe_params = GlweParameters { log2_polynomial_size: 8, diff --git a/v0-parameters/src/main.rs b/v0-parameters/src/main.rs index 6f3da1acf..dc1e89028 100644 --- a/v0-parameters/src/main.rs +++ b/v0-parameters/src/main.rs @@ -1,8 +1,14 @@ -use clap::Parser; -use rayon_cond::CondIterator; +#![warn(clippy::nursery)] +#![warn(clippy::pedantic)] +#![warn(clippy::style)] +#![allow(clippy::cast_precision_loss)] // u64 to f64 +#![allow(clippy::cast_possible_truncation)] // u64 to usize +#![allow(clippy::cast_sign_loss)] +use clap::Parser; use concrete_optimizer::global_parameters::DEFAUT_DOMAINS; use concrete_optimizer::optimisation::atomic_pattern as optimize_atomic_pattern; +use rayon_cond::CondIterator; const _4_SIGMA: f64 = 1.0 - 0.999_936_657_516; const MIN_LOG_POLY_SIZE: u64 = DEFAUT_DOMAINS @@ -61,9 +67,10 @@ fn main() { let sum_size = args.sum_size; let p_error = args.p_error; let security_level = args.security_level; - if security_level != 128 { - panic!("Only 128bits of security is supported") - } + assert!( + security_level == 128, + "Only 128bits of security is supported" + ); let glwe_log_polynomial_sizes: Vec<_> = (args.min_log_poly_size..=args.max_log_poly_size).collect(); @@ -115,20 +122,23 @@ fn main() { println!("{{ /* precision {:2} */", precision); for (manp_i, manp) in manps.clone().enumerate() { let solution = all_results[precision_i][manp_i].best_solution; - if let Some(solution) = solution { - println!(" /* {:2} */ V0Parameter({:2}, {:2}, {:4}, {:2}, {:2}, {:2}, {:2}), \t\t // {:4} mops, {:1.1e} errors", - manp, solution.glwe_dimension, (solution.glwe_polynomial_size as f64).log2() as u64, - solution.internal_ks_output_lwe_dimension, - solution.br_decomposition_level_count, solution.br_decomposition_base_log, - solution.ks_decomposition_level_count, solution.ks_decomposition_base_log, - (solution.complexity / (1024.0 * 1024.0)) as u64, - solution.p_error - ) - } else { - println!( - " /* {:2} : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),", - manp - ); + match solution { + Some(solution) => { + println!(" /* {:2} */ V0Parameter({:2}, {:2}, {:4}, {:2}, {:2}, {:2}, {:2}), \t\t // {:4} mops, {:1.1e} errors", + manp, solution.glwe_dimension, (solution.glwe_polynomial_size as f64).log2() as u64, + solution.internal_ks_output_lwe_dimension, + solution.br_decomposition_level_count, solution.br_decomposition_base_log, + solution.ks_decomposition_level_count, solution.ks_decomposition_base_log, + (solution.complexity / (1024.0 * 1024.0)) as u64, + solution.p_error + ); + } + None => { + println!( + " /* {:2} : NO SOLUTION */ V0Parameter(0,0,0,0,0,0,0),", + manp + ); + } } } println!(" }},");