pub fn hoeffding_integer_maximum(number_pairs: usize) -> i128 {
let n = number_pairs as i128;
let hoeffding_integer_maximum = (128 * n * (n - 1) * (n - 2) * (n - 3) * (n - 4)) / 15;
hoeffding_integer_maximum
}
pub fn hoeffding_integer_minimum(number_pairs: usize) -> i128 {
let n = number_pairs as i128;
let hoeffding_integer_minimum = -16 * n * (n - 3) * (n - 1) * (n - 1);
hoeffding_integer_minimum
}
pub fn order_sort_by<T: Clone + Copy + PartialOrd>(list: &Vec<T>) -> Vec<usize> {
let mut orders: Vec<usize> = (0..(list.len())).collect();
orders.sort_by(|a, b| (list[*a]).partial_cmp(&list[*b]).unwrap());
return orders;
}
pub fn count_sorted_duplicates_or_uniques<T: PartialOrd + Clone>(splice: &Vec<T>) -> Vec<usize> {
let length = splice.len();
let mut count: usize = 1;
let mut output: Vec<usize> = vec![];
for i in 0..(length - 1) {
if splice[i] == splice[i + 1] {
count += 1;
} else {
output.push(count);
count = 1;
}
}
output.push(count);
output
}
pub fn hoeffding_integer_d<T: PartialOrd + Clone + Copy, P: PartialOrd + Clone + Copy>(
datax: &Vec<T>,
datay: &Vec<P>,
) -> i128 {
let n_element = datax.len();
match datax.len() == datay.len() {
false => {
eprint!("Hoeffding can't make paired compaisons in unequal length lists");
return i128::MIN;
}
true => {
if datax.len() < 5 {
eprint!("Hoeffding Dependence Coefficient requires 5+ paired values least the calculation touch infinity");
return i128::MIN;
}
}
};
let arrangementx: Vec<usize> = order_sort_by(&datax);
let repatterx: Vec<T> = arrangementx.iter().map(|v| datax[*v]).collect();
let countedx: Vec<usize> = count_sorted_duplicates_or_uniques(&repatterx);
let uniques_lengthx = countedx.len();
let mut runningtotalx = 1;
let mut outgoingx: Vec<usize> = vec![];
for each in 0usize..uniques_lengthx {
runningtotalx += countedx[each];
let wholesx: usize = runningtotalx.saturating_sub(countedx[each]);
let halvesx: usize = countedx[each].saturating_sub(1);
let quadrankx = 4 * wholesx + 2 * halvesx;
for _every in 0..countedx[each] {
outgoingx.push(quadrankx.clone());
}
}
let mut originx: Vec<usize> = vec![0usize; datax.len()];
for each in 0..(outgoingx.len()) {
originx[arrangementx[each]] = outgoingx[each]
}
let arrangementy: Vec<usize> = order_sort_by(&datay);
let repattery: Vec<P> = arrangementy.iter().map(|v| datay[*v]).collect();
let countedy: Vec<usize> = count_sorted_duplicates_or_uniques(&repattery);
let uniques_lengthy = countedy.len();
let mut runningtotaly = 1;
let mut outgoingy: Vec<usize> = vec![];
for each in 0usize..uniques_lengthy {
runningtotaly += countedy[each];
let wholesy: usize = runningtotaly.saturating_sub(countedy[each]);
let halvesy: usize = countedy[each].saturating_sub(1);
let quadranky = 4 * wholesy + 2 * halvesy;
for _every in 0..countedy[each] {
outgoingy.push(quadranky.clone());
}
}
let mut originy: Vec<usize> = vec![0usize; datay.len()];
for each in 0..(outgoingy.len()) {
originy[arrangementy[each]] = outgoingy[each]
}
let mut originxy: Vec<usize> = vec![];
for j in 0..n_element {
let v: usize = (0..n_element)
.map(|i| {
2 * ((originx[i] < originx[j] && originy[i] < originy[j]) as usize)
+ 2 * ((originx[i] <= originx[j] && originy[i] <= originy[j]) as usize)
- ((originx[i] == originx[j] && originy[i] == originy[j]) as usize)
})
.collect::<Vec<usize>>()
.iter()
.sum();
let v = v + 3;
originxy.push(v); }
let d_subone_times_sixteen_list: Vec<i128> = (0..n_element)
.map(|i| ((originxy[i] as i128) - 4) * ((originxy[i] as i128) - 8))
.collect(); let d_subone_times_sixteen: i128 = d_subone_times_sixteen_list.iter().sum();
println!("d1={}", &d_subone_times_sixteen);
let d_subtwo_times_twofiftysix_list: Vec<i128> = (0..n_element)
.map(|i| {
((originx[i] as i128) - 4)
* ((originx[i] as i128) - 8)
* ((originy[i] as i128) - 4)
* ((originy[i] as i128) - 8)
})
.collect();
let d_subtwo_times_twofiftysix: i128 = d_subtwo_times_twofiftysix_list.iter().sum();
println!("d2={}", &d_subtwo_times_twofiftysix);
let d_subthree_times_sixtyfour_list: Vec<i128> = (0..n_element)
.map(|i| {
((originx[i] as i128) - 8i128)
* ((originy[i] as i128) - 8i128)
* ((originxy[i] as i128) - 4i128)
})
.collect();
let d_subthree_times_sixtyfour: i128 = d_subthree_times_sixtyfour_list.iter().sum();
let n = n_element as i128;
println!("d3={}", &d_subthree_times_sixtyfour);
let h_first_times256: i128 = 16 * (((n - 2) * (n - 3)) * d_subone_times_sixteen);
println!("head1{:?}", &h_first_times256);
let h_second_times256: i128 = d_subtwo_times_twofiftysix;
println!("head2{:?}", &h_second_times256);
let h_third_times256: i128 = 4 * (2 * n - 4) * d_subthree_times_sixtyfour; println!("head2{:?}", &h_third_times256);
let hoeffding_integer_numerator: i128 = h_first_times256 + h_second_times256 - h_third_times256;
hoeffding_integer_numerator }
fn main() {
let data: Vec<&str> = vec!["a", "a", "a", "b", "b", "b", "c", "c", "c", "d"];
let data2: Vec<u8> = vec![2, 3, 4, 5, 6, 7, 8, 9, 10, 12];
let d = hoeffding_integer_d(&data, &data); println!("Compared {:?} with {:?}", data, data2);
println!("Hoeffding Integer D dependence coefficident: {}", d);
let minimum = hoeffding_integer_minimum(data.len());
let maximum = hoeffding_integer_maximum(data.len());
println!(
"Hoeffding Integer D dependence coefficient minmum and maximum possible values: {} <--> {}",
minimum, maximum
);
println!(" (min = no observed dependence, max = strong association connection relationship or correlation)");
}