barrett/likewise
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

cargo format

Browse source
This commit is contained in:
Barrett Ruth 2025-09-11 15:20:00 -05:00
parent fdecdbc6c9
commit 332ca5582b
6 changed files with 67 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

31
examples/floating_point.rs → examples/floating-point.rs
View file

@ -9,10 +9,10 @@ fn main() {
// Strict comparison would show many differences due to measurement noise
// FP comparison with 0.05 tolerance treats small variations as equal
let ops = capture_diff_slices_fp(
Algorithm::Myers,
&baseline_readings,
&current_readings,
0.05
Algorithm::Myers,
&baseline_readings,
&current_readings,
0.05,
);
println!("Baseline: {:?}", baseline_readings);
@ -20,7 +20,9 @@ fn main() {
println!("With epsilon=0.05: {} diff operations", ops.len());
for op in &ops {
let changes: Vec<_> = op.iter_changes(&baseline_readings, &current_readings).collect();
let changes: Vec<_> = op
.iter_changes(&baseline_readings, &current_readings)
.collect();
for change in changes {
match change.tag() {
ChangeTag::Equal => println!(" ✓ Equal: {}", change.value()),
@ -41,8 +43,16 @@ fn main() {
for &epsilon in &[0.0001, 0.001, 0.01] {
let ops = capture_diff_slices_fp(Algorithm::Myers, &old, &new, epsilon);
let all_equal = ops.len() == 1 && matches!(ops[0], likewise::DiffOp::Equal { len: 3, .. });
println!(" epsilon={}: {} ({})", epsilon, ops.len(),
if all_equal { "all equal" } else { "differences found" });
println!(
" epsilon={}: {} ({})",
epsilon,
ops.len(),
if all_equal {
"all equal"
} else {
"differences found"
}
);
}
// Example 3: Edge cases with NaN and infinity
@ -61,5 +71,8 @@ fn main() {
let new_f64 = vec![1.0000000000002, 2.0, 3.141592653589794];
let ops_f64 = capture_diff_slices_fp_f64(Algorithm::Myers, &old_f64, &new_f64, 1e-12);
println!("f64 comparison with epsilon=1e-12: {} operations", ops_f64.len());
}
println!(
"f64 comparison with epsilon=1e-12: {} operations",
ops_f64.len()
);
}

4
src/algorithms/lcs.rs
View file

@ -320,5 +320,7 @@ pub fn diff_fp_f64_deadline<D>(
where
D: DiffHook,
{
crate::algorithms::myers::diff_fp_f64_deadline(d, old, old_range, new, new_range, epsilon, deadline)
crate::algorithms::myers::diff_fp_f64_deadline(
d, old, old_range, new, new_range, epsilon, deadline,
)
}

1
src/algorithms/mod.rs
View file

@ -132,4 +132,3 @@ where
{
diff_deadline(alg, d, old, 0..old.len(), new, 0..new.len(), deadline)
}

25
src/algorithms/myers.rs
View file

@ -21,7 +21,10 @@
use std::ops::{Index, IndexMut, Range};
use crate::algorithms::utils::{common_prefix_len, common_suffix_len, common_prefix_len_fp, common_suffix_len_fp, common_prefix_len_fp_f64, common_suffix_len_fp_f64, is_empty_range};
use crate::algorithms::utils::{
common_prefix_len, common_prefix_len_fp, common_prefix_len_fp_f64, common_suffix_len,
common_suffix_len_fp, common_suffix_len_fp_f64, is_empty_range,
};
use crate::algorithms::DiffHook;
use crate::deadline_support::{deadline_exceeded, Instant};
@ -457,7 +460,9 @@ where
let max_d = max_d(old_range.len(), new_range.len());
let mut vb = V::new(max_d);
let mut vf = V::new(max_d);
conquer_fp(d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline)?;
conquer_fp(
d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline,
)?;
d.finish()
}
@ -477,7 +482,9 @@ where
let max_d = max_d(old_range.len(), new_range.len());
let mut vb = V::new(max_d);
let mut vf = V::new(max_d);
conquer_fp_f64(d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline)?;
conquer_fp_f64(
d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline,
)?;
d.finish()
}
@ -681,7 +688,8 @@ where
D: DiffHook,
{
// Check for common prefix
let common_prefix_len = common_prefix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
let common_prefix_len =
common_prefix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
if common_prefix_len > 0 {
d.equal(old_range.start, new_range.start, common_prefix_len)?;
}
@ -689,7 +697,8 @@ where
new_range.start += common_prefix_len;
// Check for common suffix
let common_suffix_len = common_suffix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
let common_suffix_len =
common_suffix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
let common_suffix = (
old_range.end - common_suffix_len,
new_range.end - common_suffix_len,
@ -753,7 +762,8 @@ where
D: DiffHook,
{
// Check for common prefix
let common_prefix_len = common_prefix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
let common_prefix_len =
common_prefix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
if common_prefix_len > 0 {
d.equal(old_range.start, new_range.start, common_prefix_len)?;
}
@ -761,7 +771,8 @@ where
new_range.start += common_prefix_len;
// Check for common suffix
let common_suffix_len = common_suffix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
let common_suffix_len =
common_suffix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
let common_suffix = (
old_range.end - common_suffix_len,
new_range.end - common_suffix_len,

4
src/algorithms/patience.rs
View file

@ -224,5 +224,7 @@ pub fn diff_fp_f64_deadline<D>(
where
D: DiffHook,
{
crate::algorithms::myers::diff_fp_f64_deadline(d, old, old_range, new, new_range, epsilon, deadline)
crate::algorithms::myers::diff_fp_f64_deadline(
d, old, old_range, new, new_range, epsilon, deadline,
)
}

32
src/common.rs
View file

@ -124,9 +124,15 @@ fn capture_diff_fp_deadline(
) -> Vec<DiffOp> {
let mut d = Compact::new(Replace::new(Capture::new()), old, new);
let result = match alg {
Algorithm::Myers => crate::algorithms::myers::diff_fp_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
Algorithm::Patience => crate::algorithms::patience::diff_fp_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
Algorithm::Lcs => crate::algorithms::lcs::diff_fp_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
Algorithm::Myers => crate::algorithms::myers::diff_fp_deadline(
&mut d, old, old_range, new, new_range, epsilon, deadline,
),
Algorithm::Patience => crate::algorithms::patience::diff_fp_deadline(
&mut d, old, old_range, new, new_range, epsilon, deadline,
),
Algorithm::Lcs => crate::algorithms::lcs::diff_fp_deadline(
&mut d, old, old_range, new, new_range, epsilon, deadline,
),
};
result.unwrap();
d.into_inner().into_inner().into_ops()
@ -143,9 +149,15 @@ fn capture_diff_fp_f64_deadline(
) -> Vec<DiffOp> {
let mut d = Compact::new(Replace::new(Capture::new()), old, new);
let result = match alg {
Algorithm::Myers => crate::algorithms::myers::diff_fp_f64_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
Algorithm::Patience => crate::algorithms::patience::diff_fp_f64_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
Algorithm::Lcs => crate::algorithms::lcs::diff_fp_f64_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
Algorithm::Myers => crate::algorithms::myers::diff_fp_f64_deadline(
&mut d, old, old_range, new, new_range, epsilon, deadline,
),
Algorithm::Patience => crate::algorithms::patience::diff_fp_f64_deadline(
&mut d, old, old_range, new, new_range, epsilon, deadline,
),
Algorithm::Lcs => crate::algorithms::lcs::diff_fp_f64_deadline(
&mut d, old, old_range, new, new_range, epsilon, deadline,
),
};
result.unwrap();
d.into_inner().into_inner().into_ops()
@ -268,10 +280,10 @@ fn test_non_string_iter_change() {
fn test_fp_epsilon() {
let old = vec![1.0, 2.0, 3.0];
let new = vec![1.001, 2.0, 2.999];
let ops_tight = capture_diff_slices_fp(Algorithm::Myers, &old, &new, 0.0001);
assert!(ops_tight.len() > 1);
let ops_loose = capture_diff_slices_fp(Algorithm::Myers, &old, &new, 0.01);
assert_eq!(ops_loose.len(), 1);
}
@ -280,9 +292,7 @@ fn test_fp_epsilon() {
fn test_fp_nan() {
let old = vec![f32::NAN];
let new = vec![f32::NAN];
let ops = capture_diff_slices_fp(Algorithm::Myers, &old, &new, 0.001);
assert_eq!(ops.len(), 1);
}