Crate Documentation

# Crate Documentation **Version:** 1.0.0 **Format Version:** 43 # Module `similarity_trait` # Similarity trait **[documentation](https://docs.rs/similarity-trait/)** • **[source](https://github.com/sixarm/similarity-trait-rust-crate/)** • **[llms.txt](https://raw.githubusercontent.com/sixarm/similarity-trait/refs/heads/main/llms.txt)** • **[crate](https://crates.io/crates/similarity-trait)** • **[email](mailto:joel@joelparkerhenderson.com)** The Similarity trait defines a function with one input and one output, so you can compare any kinds of input values and return any kind of output value. ```no_run pub trait SimilarityIO<Input, Output> { fn similarity(input: Input) -> Output; } ``` This trait is purposefully very generic so you can use it as you wish. We use this trait in our programs to create multiple kinds of similarity functionality, such as for trying various similarity algorithms that we want to use with the same input type and same output type. For examples, please see the directory [`examples`](examples). ## Similarity of a pair One way to use this trait is to calculate the similarity of a pair of values, such as two numbers, or two strings, or two images. This is sometimes known as pairwise similarity or pair matching. Example: given two numbers, then return the percent change. ```rust use similarity_trait::SimilarityIO; struct MyStruct; impl SimilarityIO<(i32, i32), f64> for MyStruct { /// Similarity of numbers via percent change. fn similarity(input: (i32, i32)) -> f64 { (100.0 * (input.1 - input.0) as f64) / i32::abs(input.0) as f64 } } let percent_change = MyStruct::similarity((100, 120)); assert_eq!(percent_change, 20.0); ``` ## Similarity of a collection One way to use this trait is to calculate the similarity of a collection of values, such as an array of numbers, or vector of strings, or set of images. This is sometimes called intra-group similarity or statistical correlation. Example: given numbers, then return the population standard deviation. ```rust use similarity_trait::SimilarityIO; struct MyStruct; impl SimilarityIO<&Vec<f64>, Option<f64>> for MyStruct { /// Similarity of numbers via population standard deviation fn similarity(numbers: &Vec<f64>) -> Option<f64> { if numbers.is_empty() { return None } let mean = numbers.iter().sum::<f64>() / numbers.len() as f64; let variance = numbers.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / numbers.len() as f64; Some(variance.sqrt()) } } let numbers = vec![2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]; let population_standard_deviation = MyStruct::similarity(&numbers).expect("similarity"); assert!(population_standard_deviation > 1.999 && population_standard_deviation < 2.001); ``` ## Similarity of a pair or a collection You may want to choose whether you prefer to calculate the similarity of a pair (such as two strings) or a collection (such as a vector of strings). Example: given a pair of strings, then return the Hamming distance. ```rust use similarity_trait::SimilarityIO; struct MyStruct; impl SimilarityIO<(&str, &str), usize> for MyStruct { /// Similarity of a pair of strings via Hamming distance. fn similarity(pair: (&str, &str)) -> usize { pair.0.chars().zip(pair.1.chars()).filter(|(c1, c2)| c1 != c2).count() } } let pair = ("information", "informatics"); let hamming_distance = MyStruct::similarity(pair); assert_eq!(hamming_distance, 2); ``` Example: given a collection of strings, then return the maximum Hamming distance. ```rust use similarity_trait::SimilarityIO; struct MyStruct; impl SimilarityIO<Vec<&str>, usize> for MyStruct { /// Similarity of a collection of strings via maximum Hamming distance. fn similarity(collection: Vec<&str>) -> usize { let mut max = 0; for i in 0..collection.len() { for j in (i + 1)..collection.len() { max = std::cmp::max(max, collection[i].chars().zip(collection[j].chars()).filter(|(c1, c2)| c1 != c2).count()) } } max } } let collection = vec!["information", "informatics", "affirmation"]; let maximum_hamming_distance = MyStruct::similarity(collection); assert_eq!(maximum_hamming_distance, 5); ``` ## Traits ### Trait `Similarity` ```rust pub trait SimilarityIO<Input, Output> { /* Associated items */ } ``` > This trait is not object-safe and cannot be used in dynamic trait objects. #### Required Items ##### Required Methods - `similarity`