From 53fff5d2f7fc007476e4c4850bd4f974f488b13e Mon Sep 17 00:00:00 2001 From: Andreas Grois Date: Sun, 23 Oct 2022 15:22:20 +0200 Subject: Rename "potency" to "power", the English term. It seems English doesn't use the word potency in this context, but rather uses power. --- .../iterative_conversion_impl/mod.rs | 4 +- .../precomputed_constants.rs | 62 +++++++++++----------- 2 files changed, 33 insertions(+), 33 deletions(-) (limited to 'src/passwordmaker/base_conversion/iterative_conversion_impl') diff --git a/src/passwordmaker/base_conversion/iterative_conversion_impl/mod.rs b/src/passwordmaker/base_conversion/iterative_conversion_impl/mod.rs index 7ab9171..ae4aeca 100644 --- a/src/passwordmaker/base_conversion/iterative_conversion_impl/mod.rs +++ b/src/passwordmaker/base_conversion/iterative_conversion_impl/mod.rs @@ -13,7 +13,7 @@ use std::fmt::Display; use std::error::Error; use std::iter::once; -use super::iterative_conversion::{RemAssignWithQuotient, ConstantMaxPotencyCache}; +use super::iterative_conversion::{RemAssignWithQuotient, ConstantMaxPowerCache}; //Type to be used as V, with usize as B. pub(crate) struct SixteenBytes(u128); @@ -68,7 +68,7 @@ impl Mul<&SixteenBytes> for &SixteenBytes{ } } -impl ConstantMaxPotencyCache for SixteenBytes{} +impl ConstantMaxPowerCache for SixteenBytes{} //-------------------------------------------------------------------------------------------------------------------------------------- //and now the hard part: The same for [u32;N]. diff --git a/src/passwordmaker/base_conversion/iterative_conversion_impl/precomputed_constants.rs b/src/passwordmaker/base_conversion/iterative_conversion_impl/precomputed_constants.rs index c5a1809..86b8c56 100644 --- a/src/passwordmaker/base_conversion/iterative_conversion_impl/precomputed_constants.rs +++ b/src/passwordmaker/base_conversion/iterative_conversion_impl/precomputed_constants.rs @@ -1,15 +1,15 @@ use super::const_mul_usize; use super::ArbitraryBytes; -use super::super::iterative_conversion::ConstantMaxPotencyCache; +use super::super::iterative_conversion::ConstantMaxPowerCache; -impl ConstantMaxPotencyCache for ArbitraryBytes<5>{ +impl ConstantMaxPowerCache for ArbitraryBytes<5>{ fn lookup(base : &usize) -> Option<(Self, usize)> { - get_from_cache(base, &CONSTANT_MAX_POTENCY_CACHE_5) + get_from_cache(base, &CONSTANT_MAX_POWER_CACHE_5) } } -impl ConstantMaxPotencyCache for ArbitraryBytes<8>{ +impl ConstantMaxPowerCache for ArbitraryBytes<8>{ fn lookup(base : &usize) -> Option<(Self, usize)> { - get_from_cache(base, &CONSTANT_MAX_POTENCY_CACHE_8) + get_from_cache(base, &CONSTANT_MAX_POWER_CACHE_8) } } @@ -18,12 +18,12 @@ fn get_from_cache(base : &usize, cache : &[([u32;N], usize)]) - .map(|c| (ArbitraryBytes(c.0), c.1)) } -const CONSTANT_MAX_POTENCY_CACHE_5 : [([u32;5],usize);128] = gen_const_max_potency_cache(); -const CONSTANT_MAX_POTENCY_CACHE_8 : [([u32;8],usize);128] = gen_const_max_potency_cache(); +const CONSTANT_MAX_POWER_CACHE_5 : [([u32;5],usize);128] = gen_const_max_power_cache(); +const CONSTANT_MAX_POWER_CACHE_8 : [([u32;8],usize);128] = gen_const_max_power_cache(); //----------------------------------------------------------------------------------------- -/// This version of find_highest_fitting_potency is not optimized. But it can run in const contexts. Only use it there, use the normal one everywhere else. +/// This version of find_highest_fitting_power is not optimized. But it can run in const contexts. Only use it there, use the normal one everywhere else. const fn const_find_highest_fitting_power(base : usize) -> ([u32;N],usize){ let start = super::from_usize(&base); @@ -38,7 +38,7 @@ const fn const_find_highest_fitting_power(base : usize) -> ([u3 //If anyone could tell me how to implement "~const Clone" in stable Rust, I'd be very happy. const fn const_clone(x : &ArbitraryBytes) -> ArbitraryBytes{ArbitraryBytes(x.0)} -pub(crate) const fn gen_const_max_potency_cache() -> [([u32;N],usize);CNT]{ +pub(crate) const fn gen_const_max_power_cache() -> [([u32;N],usize);CNT]{ let mut result = [([0u32;N],0usize);CNT]; let mut i = 0usize; loop { @@ -57,69 +57,69 @@ mod iterative_conversion_constants_tests{ #[test] fn test_overlows_8() { - let entries = super::CONSTANT_MAX_POTENCY_CACHE_8.iter().enumerate() + let entries = super::CONSTANT_MAX_POWER_CACHE_8.iter().enumerate() .map(|(i,(p,e))| (i+2, ArbitraryBytes(*p), *e)); - for (base, potency, _exponent) in entries { - assert!((potency * base).is_none()) + for (base, power, _exponent) in entries { + assert!((power * base).is_none()) } } #[test] fn test_overlows_5() { - let entries = super::CONSTANT_MAX_POTENCY_CACHE_5.iter().enumerate() + let entries = super::CONSTANT_MAX_POWER_CACHE_5.iter().enumerate() .map(|(i,(p,e))| (i+2, ArbitraryBytes(*p), *e)); - for (base, potency, _exponent) in entries { - assert!((potency * base).is_none()) + for (base, power, _exponent) in entries { + assert!((power * base).is_none()) } } #[test] fn test_exponent_8() { - let entries = super::CONSTANT_MAX_POTENCY_CACHE_8.iter().enumerate() + let entries = super::CONSTANT_MAX_POWER_CACHE_8.iter().enumerate() .map(|(i,(p,e))| (i+2, ArbitraryBytes(*p), *e)); - for (base, mut potency, exponent) in entries { + for (base, mut power, exponent) in entries { //exponent is the largest fitting exponent. Soo, if we divide exponent times, we should end up with 1. for _i in 0..exponent { - let remainder = potency.div_assign_with_remainder_usize(&base); + let remainder = power.div_assign_with_remainder_usize(&base); assert_eq!(remainder, 0); } - assert_eq!(potency, (&1usize).into()); + assert_eq!(power, (&1usize).into()); } } #[test] fn test_exponent_5() { - let entries = super::CONSTANT_MAX_POTENCY_CACHE_5.iter().enumerate() + let entries = super::CONSTANT_MAX_POWER_CACHE_5.iter().enumerate() .map(|(i,(p,e))| (i+2, ArbitraryBytes(*p), *e)); - for (base, mut potency, exponent) in entries { + for (base, mut power, exponent) in entries { //exponent is the largest fitting exponent. Soo, if we divide exponent times, we should end up with 1. for _i in 0..exponent { - let remainder = potency.div_assign_with_remainder_usize(&base); + let remainder = power.div_assign_with_remainder_usize(&base); assert_eq!(remainder, 0); } - assert_eq!(potency, (&1usize).into()); + assert_eq!(power, (&1usize).into()); } } #[test] - fn highest_fitting_potency_consistency_5(){ + fn highest_fitting_power_consistency_5(){ use super::super::super::iterative_conversion::IterativeBaseConversion; - let entries = super::CONSTANT_MAX_POTENCY_CACHE_5.iter().enumerate() + let entries = super::CONSTANT_MAX_POWER_CACHE_5.iter().enumerate() .map(|(i,(p,e))| (i+2, ArbitraryBytes(*p), *e)); - for (base, potency, exponent) in entries { + for (base, power, exponent) in entries { let non_cached_result = IterativeBaseConversion::,usize>::find_highest_fitting_power_non_cached(&base); assert_eq!(non_cached_result.exponent,exponent); - assert_eq!(non_cached_result.power, potency); + assert_eq!(non_cached_result.power, power); } } #[test] - fn highest_fitting_potency_consistency_8(){ + fn highest_fitting_power_consistency_8(){ use super::super::super::iterative_conversion::IterativeBaseConversion; - let entries = super::CONSTANT_MAX_POTENCY_CACHE_8.iter().enumerate() + let entries = super::CONSTANT_MAX_POWER_CACHE_8.iter().enumerate() .map(|(i,(p,e))| (i+2, ArbitraryBytes(*p), *e)); - for (base, potency, exponent) in entries { + for (base, power, exponent) in entries { let non_cached_result = IterativeBaseConversion::,usize>::find_highest_fitting_power_non_cached(&base); assert_eq!(non_cached_result.exponent,exponent); - assert_eq!(non_cached_result.power, potency); + assert_eq!(non_cached_result.power, power); } } } \ No newline at end of file -- cgit v1.2.3