From c99e3675124966ea831a5b0d616c93dba3699e17 Mon Sep 17 00:00:00 2001 From: Simon Gardling Date: Thu, 19 May 2022 11:20:37 -0400 Subject: [PATCH] logic improvements --- src/function_entry.rs | 37 ++++++++++++++++++++++++++----------- src/math_app.rs | 4 ++-- src/misc.rs | 6 +++--- tests/misc.rs | 4 ++-- 4 files changed, 33 insertions(+), 18 deletions(-) diff --git a/src/function_entry.rs b/src/function_entry.rs index 9996b14..1a43ef7 100644 --- a/src/function_entry.rs +++ b/src/function_entry.rs @@ -218,14 +218,15 @@ impl FunctionEntry { let sum_func = self.get_sum_func(*sum); - let data2: Vec<(f64, f64)> = dyn_iter(&step_helper(*integral_num, integral_min_x, &step)) + let data2: Vec<(f64, f64)> = step_helper(*integral_num, integral_min_x, &step) + .into_iter() .map(|x| { let step_offset = step * x.signum(); // store the offset here so it doesn't have to be calculated multiple times let x2: f64 = x + step_offset; let (left_x, right_x) = match x.is_sign_positive() { - true => (*x, x2), - false => (x2, *x), + true => (x, x2), + false => (x2, x), }; let y = sum_func.get(left_x, right_x); @@ -263,8 +264,8 @@ impl FunctionEntry { }; newtons_method_output - .iter() - .map(|x| Value::new(*x, self.function.get(*x))) + .into_iter() + .map(|x| Value::new(x, self.function.get(x))) .collect() } @@ -338,9 +339,14 @@ impl FunctionEntry { self.back_data = back_data; if derivative_required { - debug_assert!(derivative_data_1[0].is_some()); + /* + debug_assert!(derivative_data_1.iter().any(|x| x.is_none())); + self.derivative_data = unsafe { + std::mem::transmute::>, Vec>(derivative_data_1) + }; + */ self.derivative_data = derivative_data_1 - .iter() + .into_iter() .map(|ele| unsafe { ele.unwrap_unchecked() }) .collect::>(); } else { @@ -348,10 +354,16 @@ impl FunctionEntry { } if do_nth_derivative { + /* + debug_assert!(new_nth_derivative_data.iter().any(|x| x.is_none())); + self.nth_derivative_data = Some(unsafe { + std::mem::transmute::>, Vec>(new_nth_derivative_data) + }); + */ self.nth_derivative_data = Some( new_nth_derivative_data - .iter() - .map(|c| unsafe { c.unwrap_unchecked() }) + .into_iter() + .map(|ele| unsafe { ele.unwrap_unchecked() }) .collect(), ); } else { @@ -397,8 +409,11 @@ impl FunctionEntry { &settings.riemann_sum, &settings.integral_num, ); - self.integral_data = - Some((data.iter().map(|(x, y)| Bar::new(*x, *y)).collect(), area)); + + self.integral_data = Some(( + data.into_iter().map(|(x, y)| Bar::new(x, y)).collect(), + area, + )); } } else { self.invalidate_integral(); diff --git a/src/math_app.rs b/src/math_app.rs index f5705ef..113387d 100644 --- a/src/math_app.rs +++ b/src/math_app.rs @@ -145,7 +145,7 @@ impl MathApp { fn get_storage_decompressed() -> Option> { let data = get_localstorage().get_item(DATA_NAME).ok()??; - let (commit, cached_data) = crate::misc::hashed_storage_read(&data)?; + let (commit, cached_data) = crate::misc::hashed_storage_read(data)?; debug_assert!(!commit.is_empty()); debug_assert!(!cached_data.is_empty()); @@ -183,7 +183,7 @@ impl MathApp { return None; } - let (commit, func_data) = crate::misc::hashed_storage_read(&data)?; + let (commit, func_data) = crate::misc::hashed_storage_read(data)?; debug_assert!(!commit.is_empty()); debug_assert!(!func_data.is_empty()); diff --git a/src/misc.rs b/src/misc.rs index 1967f0d..f58dbcf 100644 --- a/src/misc.rs +++ b/src/misc.rs @@ -233,7 +233,7 @@ pub fn newtons_method_helper( threshold: &f64, range: &std::ops::Range, data: &[Value], f: &dyn Fn(f64) -> f64, f_1: &dyn Fn(f64) -> f64, ) -> Vec { - data.iter() + data.into_iter() .tuple_windows() .filter(|(prev, curr)| prev.y.is_finite() && curr.y.is_finite()) .filter(|(prev, curr)| prev.y.signum() != curr.y.signum()) @@ -337,7 +337,7 @@ pub fn hashed_storage_create(hash: HashBytes, data: &[u8]) -> String { } #[allow(dead_code)] -pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, Vec)> { +pub fn hashed_storage_read(data: String) -> Option<(HashBytes, Vec)> { if HASH_LENGTH >= data.len() { return None; } @@ -347,7 +347,7 @@ pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, Vec)> { assume(data.len() > HASH_LENGTH); } - let decoded_1: Vec = unsafe { std::mem::transmute::<&str, &[u8]>(data) }.to_vec(); + let decoded_1: Vec = unsafe { std::mem::transmute::>(data) }; let hash: HashBytes = unsafe { *(decoded_1[..HASH_LENGTH].as_ptr() as *const HashBytes) }; let cached_data = decoded_1[HASH_LENGTH..].to_vec(); diff --git a/tests/misc.rs b/tests/misc.rs index 7275117..250c87e 100644 --- a/tests/misc.rs +++ b/tests/misc.rs @@ -105,14 +105,14 @@ fn hashed_storage() { data.as_slice(), ); - let read = hashed_storage_read(&storage); + let read = hashed_storage_read(storage); assert_eq!(read.map(|(a, b)| (a.to_vec(), b)), Some((commit, data))); } #[test] fn invalid_hashed_storage() { use ytbn_graphing_software::hashed_storage_read; - assert_eq!(hashed_storage_read("aaaa"), None); + assert_eq!(hashed_storage_read("aaaa".to_owned()), None); } #[test]