github/concrete
1
1
Fork 0
mirror of https://github.com/zama-ai/concrete.git synced 2026-02-09 12:15:09 -05:00
Code Issues Packages Projects Releases Wiki Activity

fix clippy lints

Browse Source 
fix clippy::unreadable_literal
This commit is contained in:
Mayeul@Zama
2022-04-15 17:04:39 +02:00
committed by rudy
parent b48c21db93
commit 129e4ed968
8 changed files with 51 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
concrete-optimizer/src/computing_cost/fft.rs
View File

@@ -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);
}

16
concrete-optimizer/src/computing_cost/operators/cmux.rs
View File

@@ -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);
}

6
concrete-optimizer/src/computing_cost/operators/keyswitch_lwe.rs
View File

@@ -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);
}

4
concrete-optimizer/src/computing_cost/operators/pbs.rs
View File

@@ -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);
}

1
concrete-optimizer/src/lib.rs
View File

@@ -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)]

5
concrete-optimizer/src/optimisation/atomic_pattern.rs
View File

@@ -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<W: UnsignedInteger>(
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,

6
concrete-optimizer/src/security/glwe.rs
View File

@@ -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,

48
v0-parameters/src/main.rs
View File

@@ -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!(" }},");