Lucas Soriano del Pino
3 years ago
5 changed files with 628 additions and 1 deletions
@ -0,0 +1,124 @@ |
|||||
|
use anyhow::{bail, Result}; |
||||
|
use bit_vec::BitVec; |
||||
|
use std::fmt::Display; |
||||
|
use std::ops::RangeInclusive; |
||||
|
|
||||
|
mod digit_decomposition; |
||||
|
|
||||
|
const BASE: usize = 2; |
||||
|
|
||||
|
/// Maximum number of binary digits for BTC price in whole USD.
|
||||
|
const MAX_DIGITS: usize = 20; |
||||
|
|
||||
|
const MAX_PRICE_DEC: u64 = (BASE as u64).pow(MAX_DIGITS as u32); |
||||
|
|
||||
|
#[derive(Debug)] |
||||
|
pub struct Interval(RangeInclusive<u64>); |
||||
|
|
||||
|
impl Interval { |
||||
|
pub fn new(start: u64, end: u64) -> Result<Self> { |
||||
|
if start > MAX_PRICE_DEC || end > MAX_PRICE_DEC { |
||||
|
bail!("price over maximum") |
||||
|
} |
||||
|
|
||||
|
if start > end { |
||||
|
bail!("invalid interval: start > end") |
||||
|
} |
||||
|
|
||||
|
Ok(Self(start..=end)) |
||||
|
} |
||||
|
|
||||
|
pub fn as_digits(&self) -> Vec<Digits> { |
||||
|
digit_decomposition::group_by_ignoring_digits( |
||||
|
*self.0.start() as usize, |
||||
|
*self.0.end() as usize, |
||||
|
BASE, |
||||
|
MAX_DIGITS, |
||||
|
) |
||||
|
.iter() |
||||
|
.map(|digits| { |
||||
|
let digits = digits.iter().map(|n| *n != 0).collect::<BitVec>(); |
||||
|
Digits(digits) |
||||
|
}) |
||||
|
.collect() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[derive(Clone, Debug)] |
||||
|
pub struct Digits(BitVec); |
||||
|
|
||||
|
impl Digits { |
||||
|
pub fn range(&self) -> RangeInclusive<u64> { |
||||
|
let missing_bits = MAX_DIGITS - self.0.len(); |
||||
|
|
||||
|
let mut bits = self.0.clone(); |
||||
|
bits.append(&mut BitVec::from_elem(missing_bits, false)); |
||||
|
let start = bits.as_u64(); |
||||
|
|
||||
|
let mut bits = self.0.clone(); |
||||
|
bits.append(&mut BitVec::from_elem(missing_bits, true)); |
||||
|
let end = bits.as_u64(); |
||||
|
|
||||
|
start..=end |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
impl std::iter::Iterator for Digits { |
||||
|
type Item = Vec<u8>; |
||||
|
|
||||
|
fn next(&mut self) -> Option<Self::Item> { |
||||
|
self.0.iter().map(|bit| vec![bit as u8]).next() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
trait BitVecExt { |
||||
|
fn as_u64(&self) -> u64; |
||||
|
} |
||||
|
|
||||
|
impl BitVecExt for BitVec { |
||||
|
fn as_u64(&self) -> u64 { |
||||
|
let len = self.len(); |
||||
|
|
||||
|
self.iter().enumerate().fold(0, |acc, (i, x)| { |
||||
|
acc + ((x as u64) * (BASE.pow((len - i - 1) as u32) as u64)) |
||||
|
}) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
impl Display for Digits { |
||||
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
||||
|
self.0 |
||||
|
.iter() |
||||
|
.try_for_each(|digit| write!(f, "{}", digit as u8))?; |
||||
|
|
||||
|
Ok(()) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[cfg(test)] |
||||
|
mod tests { |
||||
|
use super::*; |
||||
|
use proptest::prelude::*; |
||||
|
|
||||
|
impl PartialEq<Vec<Digits>> for Interval { |
||||
|
fn eq(&self, other: &Vec<Digits>) -> bool { |
||||
|
let sub_intervals = other.iter().flat_map(|i| i.range()); |
||||
|
sub_intervals.eq(self.0.clone()) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
prop_compose! { |
||||
|
fn interval()(x in 0u64..=MAX_PRICE_DEC, y in 0u64..=MAX_PRICE_DEC) -> Interval { |
||||
|
let (start, end) = if x < y { (x, y) } else { (y, x) }; |
||||
|
|
||||
|
Interval::new(start, end).unwrap() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
proptest! { |
||||
|
#[test] |
||||
|
fn interval_equal_to_sum_of_sub_intervals_described_by_digits(interval in interval()) { |
||||
|
prop_assert!(interval == interval.as_digits()) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,459 @@ |
|||||
|
//! Utility functions to decompose numeric outcome values
|
||||
|
//!
|
||||
|
//! This code has been lifted from:
|
||||
|
//! https://github.com/p2pderivatives/rust-dlc/blob/chore%2Ffactor-out-dlc-trie/dlc-trie/src/digit_decomposition.rs
|
||||
|
|
||||
|
/// Describes an interval that starts at `prefix || start` and terminates at `prefix || end`.
|
||||
|
struct PrefixInterval { |
||||
|
/// The prefix common to all numbers within the interval.
|
||||
|
prefix: Vec<usize>, |
||||
|
/// The suffix of the first number in the interval.
|
||||
|
start: Vec<usize>, |
||||
|
/// The suffix of the last number in the interval.
|
||||
|
end: Vec<usize>, |
||||
|
} |
||||
|
|
||||
|
/// Decompose a numeric value into digits in the specified base. If the decomposed
|
||||
|
/// value contains less than `nb_digits`, zeroes will be prepended to reach `nb_digits`
|
||||
|
/// size.
|
||||
|
fn decompose_value(mut value: usize, base: usize, nb_digits: usize) -> Vec<usize> { |
||||
|
let mut res = Vec::new(); |
||||
|
|
||||
|
while value > 0 { |
||||
|
res.push(value % base); |
||||
|
value = ((value as f64) / (base as f64)).floor() as usize; |
||||
|
} |
||||
|
|
||||
|
while res.len() < nb_digits { |
||||
|
res.push(0); |
||||
|
} |
||||
|
|
||||
|
assert_eq!(nb_digits, res.len()); |
||||
|
|
||||
|
res.into_iter().rev().collect() |
||||
|
} |
||||
|
|
||||
|
/// Returns the interval [start, end] as a `PrefixInterval`, which will contain
|
||||
|
/// the common prefix to all numbers in the interval as well as the start and end
|
||||
|
/// suffixes decomposed in the specified base, and zero padded to `nb_digits` if
|
||||
|
/// necessary.
|
||||
|
fn separate_prefix(start: usize, end: usize, base: usize, nb_digits: usize) -> PrefixInterval { |
||||
|
let start_digits = decompose_value(start, base, nb_digits); |
||||
|
let end_digits = decompose_value(end, base, nb_digits); |
||||
|
let mut prefix = Vec::new(); |
||||
|
|
||||
|
let mut i = 0; |
||||
|
while i < nb_digits && start_digits[i] == end_digits[i] { |
||||
|
prefix.push(start_digits[i]); |
||||
|
i += 1; |
||||
|
} |
||||
|
let start = start_digits.into_iter().skip(prefix.len()).collect(); |
||||
|
|
||||
|
let end = end_digits.into_iter().skip(prefix.len()).collect(); |
||||
|
|
||||
|
PrefixInterval { prefix, start, end } |
||||
|
} |
||||
|
|
||||
|
/// Removes the trailing digits from `digits` that are equal to `num`.
|
||||
|
fn remove_tail_if_equal(mut digits: Vec<usize>, num: usize) -> Vec<usize> { |
||||
|
let mut i = digits.len(); |
||||
|
while i > 1 && digits[i - 1] == num { |
||||
|
i -= 1; |
||||
|
} |
||||
|
digits.truncate(i); |
||||
|
digits |
||||
|
} |
||||
|
|
||||
|
/// Compute the groupings for the end of the interval.
|
||||
|
fn back_groupings(digits: Vec<usize>, base: usize) -> Vec<Vec<usize>> { |
||||
|
let digits = remove_tail_if_equal(digits, base - 1); |
||||
|
if digits.is_empty() { |
||||
|
return vec![vec![base - 1]]; |
||||
|
} |
||||
|
let mut prefix = vec![digits[0]]; |
||||
|
let mut res: Vec<Vec<usize>> = Vec::new(); |
||||
|
for digit in digits.iter().skip(1) { |
||||
|
let mut last = 0; |
||||
|
let digit = *digit; |
||||
|
while last < digit { |
||||
|
let mut new_res = prefix.clone(); |
||||
|
new_res.push(last); |
||||
|
res.push(new_res); |
||||
|
last += 1; |
||||
|
} |
||||
|
prefix.push(digit); |
||||
|
} |
||||
|
res.push(digits); |
||||
|
res |
||||
|
} |
||||
|
|
||||
|
/// Compute the groupings for the beginning of the interval.
|
||||
|
fn front_groupings(digits: Vec<usize>, base: usize) -> Vec<Vec<usize>> { |
||||
|
let digits = remove_tail_if_equal(digits, 0); |
||||
|
if digits.is_empty() { |
||||
|
return vec![vec![0]]; |
||||
|
} |
||||
|
let mut prefix = digits.clone(); |
||||
|
let mut res: Vec<Vec<usize>> = vec![digits.clone()]; |
||||
|
for digit in digits.into_iter().skip(1).rev() { |
||||
|
prefix.pop(); |
||||
|
let mut last = digit + 1; |
||||
|
while last < base { |
||||
|
let mut new_res = prefix.clone(); |
||||
|
new_res.push(last); |
||||
|
res.push(new_res); |
||||
|
last += 1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
res |
||||
|
} |
||||
|
|
||||
|
/// Compute the groupings for the middle of the interval.
|
||||
|
fn middle_grouping(first_digit_start: usize, first_digit_end: usize) -> Vec<Vec<usize>> { |
||||
|
let mut res: Vec<Vec<usize>> = Vec::new(); |
||||
|
let mut first_digit_start = first_digit_start + 1; |
||||
|
while first_digit_start < first_digit_end { |
||||
|
res.push(vec![first_digit_start]); |
||||
|
first_digit_start += 1; |
||||
|
} |
||||
|
|
||||
|
res |
||||
|
} |
||||
|
|
||||
|
/// Returns the set of decomposed prefixes that cover the range [start, end].
|
||||
|
pub(crate) fn group_by_ignoring_digits( |
||||
|
start: usize, |
||||
|
end: usize, |
||||
|
base: usize, |
||||
|
num_digits: usize, |
||||
|
) -> Vec<Vec<usize>> { |
||||
|
let prefix_range = separate_prefix(start, end, base, num_digits); |
||||
|
let start_is_all_zeros = prefix_range.start.iter().all(|x| *x == 0); |
||||
|
let end_is_all_max = prefix_range.end.iter().all(|x| *x == base - 1); |
||||
|
|
||||
|
if start == end || start_is_all_zeros && end_is_all_max && !prefix_range.prefix.is_empty() { |
||||
|
return vec![prefix_range.prefix]; |
||||
|
} |
||||
|
let mut res: Vec<Vec<usize>> = Vec::new(); |
||||
|
if prefix_range.prefix.len() == num_digits - 1 { |
||||
|
for i in prefix_range.start[prefix_range.start.len() - 1] |
||||
|
..prefix_range.end[prefix_range.end.len() - 1] + 1 |
||||
|
{ |
||||
|
let mut new_res = prefix_range.prefix.clone(); |
||||
|
new_res.push(i); |
||||
|
res.push(new_res) |
||||
|
} |
||||
|
} else { |
||||
|
let mut front = front_groupings(prefix_range.start.clone(), base); |
||||
|
let mut middle = middle_grouping(prefix_range.start[0], prefix_range.end[0]); |
||||
|
let mut back = back_groupings(prefix_range.end.clone(), base); |
||||
|
res.append(&mut front); |
||||
|
res.append(&mut middle); |
||||
|
res.append(&mut back); |
||||
|
res = res |
||||
|
.into_iter() |
||||
|
.map(|x| { |
||||
|
prefix_range |
||||
|
.prefix |
||||
|
.iter() |
||||
|
.cloned() |
||||
|
.chain(x.into_iter()) |
||||
|
.collect() |
||||
|
}) |
||||
|
.collect(); |
||||
|
} |
||||
|
|
||||
|
res |
||||
|
} |
||||
|
|
||||
|
#[cfg(test)] |
||||
|
mod tests { |
||||
|
struct DecompositionTestCase { |
||||
|
composed: usize, |
||||
|
decomposed: Vec<usize>, |
||||
|
base: usize, |
||||
|
nb_digits: usize, |
||||
|
} |
||||
|
|
||||
|
struct GroupingTestCase { |
||||
|
start_index: usize, |
||||
|
end_index: usize, |
||||
|
base: usize, |
||||
|
nb_digits: usize, |
||||
|
expected: Vec<Vec<usize>>, |
||||
|
} |
||||
|
fn decomposition_test_cases() -> Vec<DecompositionTestCase> { |
||||
|
vec![ |
||||
|
DecompositionTestCase { |
||||
|
composed: 123456789, |
||||
|
decomposed: vec![1, 2, 3, 4, 5, 6, 7, 8, 9], |
||||
|
base: 10, |
||||
|
nb_digits: 9, |
||||
|
}, |
||||
|
DecompositionTestCase { |
||||
|
composed: 4321, |
||||
|
decomposed: vec![1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1], |
||||
|
base: 2, |
||||
|
nb_digits: 13, |
||||
|
}, |
||||
|
DecompositionTestCase { |
||||
|
composed: 0, |
||||
|
decomposed: vec![0, 0, 0, 0], |
||||
|
base: 8, |
||||
|
nb_digits: 4, |
||||
|
}, |
||||
|
DecompositionTestCase { |
||||
|
composed: 2, |
||||
|
decomposed: vec![0, 2], |
||||
|
base: 10, |
||||
|
nb_digits: 2, |
||||
|
}, |
||||
|
DecompositionTestCase { |
||||
|
composed: 1, |
||||
|
decomposed: vec![1], |
||||
|
base: 2, |
||||
|
nb_digits: 1, |
||||
|
}, |
||||
|
] |
||||
|
} |
||||
|
|
||||
|
fn grouping_test_cases() -> Vec<GroupingTestCase> { |
||||
|
vec![ |
||||
|
GroupingTestCase { |
||||
|
start_index: 123, |
||||
|
end_index: 123, |
||||
|
base: 10, |
||||
|
nb_digits: 3, |
||||
|
expected: vec![vec![1, 2, 3]], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 171, |
||||
|
end_index: 210, |
||||
|
base: 16, |
||||
|
nb_digits: 2, |
||||
|
expected: vec![ |
||||
|
vec![10, 11], |
||||
|
vec![10, 12], |
||||
|
vec![10, 13], |
||||
|
vec![10, 14], |
||||
|
vec![10, 15], |
||||
|
vec![11], |
||||
|
vec![12], |
||||
|
vec![13, 0], |
||||
|
vec![13, 1], |
||||
|
vec![13, 2], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 73899, |
||||
|
end_index: 73938, |
||||
|
base: 16, |
||||
|
nb_digits: 6, |
||||
|
expected: vec![ |
||||
|
vec![0, 1, 2, 0, 10, 11], |
||||
|
vec![0, 1, 2, 0, 10, 12], |
||||
|
vec![0, 1, 2, 0, 10, 13], |
||||
|
vec![0, 1, 2, 0, 10, 14], |
||||
|
vec![0, 1, 2, 0, 10, 15], |
||||
|
vec![0, 1, 2, 0, 11], |
||||
|
vec![0, 1, 2, 0, 12], |
||||
|
vec![0, 1, 2, 0, 13, 0], |
||||
|
vec![0, 1, 2, 0, 13, 1], |
||||
|
vec![0, 1, 2, 0, 13, 2], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 1234, |
||||
|
end_index: 4321, |
||||
|
base: 10, |
||||
|
nb_digits: 4, |
||||
|
expected: vec![ |
||||
|
vec![1, 2, 3, 4], |
||||
|
vec![1, 2, 3, 5], |
||||
|
vec![1, 2, 3, 6], |
||||
|
vec![1, 2, 3, 7], |
||||
|
vec![1, 2, 3, 8], |
||||
|
vec![1, 2, 3, 9], |
||||
|
vec![1, 2, 4], |
||||
|
vec![1, 2, 5], |
||||
|
vec![1, 2, 6], |
||||
|
vec![1, 2, 7], |
||||
|
vec![1, 2, 8], |
||||
|
vec![1, 2, 9], |
||||
|
vec![1, 3], |
||||
|
vec![1, 4], |
||||
|
vec![1, 5], |
||||
|
vec![1, 6], |
||||
|
vec![1, 7], |
||||
|
vec![1, 8], |
||||
|
vec![1, 9], |
||||
|
vec![2], |
||||
|
vec![3], |
||||
|
vec![4, 0], |
||||
|
vec![4, 1], |
||||
|
vec![4, 2], |
||||
|
vec![4, 3, 0], |
||||
|
vec![4, 3, 1], |
||||
|
vec![4, 3, 2, 0], |
||||
|
vec![4, 3, 2, 1], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 1201234, |
||||
|
end_index: 1204321, |
||||
|
base: 10, |
||||
|
nb_digits: 8, |
||||
|
expected: vec![ |
||||
|
vec![0, 1, 2, 0, 1, 2, 3, 4], |
||||
|
vec![0, 1, 2, 0, 1, 2, 3, 5], |
||||
|
vec![0, 1, 2, 0, 1, 2, 3, 6], |
||||
|
vec![0, 1, 2, 0, 1, 2, 3, 7], |
||||
|
vec![0, 1, 2, 0, 1, 2, 3, 8], |
||||
|
vec![0, 1, 2, 0, 1, 2, 3, 9], |
||||
|
vec![0, 1, 2, 0, 1, 2, 4], |
||||
|
vec![0, 1, 2, 0, 1, 2, 5], |
||||
|
vec![0, 1, 2, 0, 1, 2, 6], |
||||
|
vec![0, 1, 2, 0, 1, 2, 7], |
||||
|
vec![0, 1, 2, 0, 1, 2, 8], |
||||
|
vec![0, 1, 2, 0, 1, 2, 9], |
||||
|
vec![0, 1, 2, 0, 1, 3], |
||||
|
vec![0, 1, 2, 0, 1, 4], |
||||
|
vec![0, 1, 2, 0, 1, 5], |
||||
|
vec![0, 1, 2, 0, 1, 6], |
||||
|
vec![0, 1, 2, 0, 1, 7], |
||||
|
vec![0, 1, 2, 0, 1, 8], |
||||
|
vec![0, 1, 2, 0, 1, 9], |
||||
|
vec![0, 1, 2, 0, 2], |
||||
|
vec![0, 1, 2, 0, 3], |
||||
|
vec![0, 1, 2, 0, 4, 0], |
||||
|
vec![0, 1, 2, 0, 4, 1], |
||||
|
vec![0, 1, 2, 0, 4, 2], |
||||
|
vec![0, 1, 2, 0, 4, 3, 0], |
||||
|
vec![0, 1, 2, 0, 4, 3, 1], |
||||
|
vec![0, 1, 2, 0, 4, 3, 2, 0], |
||||
|
vec![0, 1, 2, 0, 4, 3, 2, 1], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 2200, |
||||
|
end_index: 4999, |
||||
|
base: 10, |
||||
|
nb_digits: 4, |
||||
|
expected: vec![ |
||||
|
vec![2, 2], |
||||
|
vec![2, 3], |
||||
|
vec![2, 4], |
||||
|
vec![2, 5], |
||||
|
vec![2, 6], |
||||
|
vec![2, 7], |
||||
|
vec![2, 8], |
||||
|
vec![2, 9], |
||||
|
vec![3], |
||||
|
vec![4], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 0, |
||||
|
end_index: 99, |
||||
|
base: 10, |
||||
|
nb_digits: 2, |
||||
|
expected: vec![ |
||||
|
vec![0], |
||||
|
vec![1], |
||||
|
vec![2], |
||||
|
vec![3], |
||||
|
vec![4], |
||||
|
vec![5], |
||||
|
vec![6], |
||||
|
vec![7], |
||||
|
vec![8], |
||||
|
vec![9], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 100, |
||||
|
end_index: 199, |
||||
|
base: 10, |
||||
|
nb_digits: 3, |
||||
|
expected: vec![vec![1]], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 100, |
||||
|
end_index: 200, |
||||
|
base: 10, |
||||
|
nb_digits: 3, |
||||
|
expected: vec![vec![1], vec![2, 0, 0]], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 11, |
||||
|
end_index: 18, |
||||
|
base: 10, |
||||
|
nb_digits: 2, |
||||
|
expected: vec![ |
||||
|
vec![1, 1], |
||||
|
vec![1, 2], |
||||
|
vec![1, 3], |
||||
|
vec![1, 4], |
||||
|
vec![1, 5], |
||||
|
vec![1, 6], |
||||
|
vec![1, 7], |
||||
|
vec![1, 8], |
||||
|
], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 11, |
||||
|
end_index: 23, |
||||
|
base: 2, |
||||
|
nb_digits: 5, |
||||
|
expected: vec![vec![0, 1, 0, 1, 1], vec![0, 1, 1], vec![1, 0]], |
||||
|
}, |
||||
|
GroupingTestCase { |
||||
|
start_index: 5677, |
||||
|
end_index: 8621, |
||||
|
base: 2, |
||||
|
nb_digits: 14, |
||||
|
expected: vec![ |
||||
|
vec![0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1], |
||||
|
vec![0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1], |
||||
|
vec![0, 1, 0, 1, 1, 0, 0, 0, 1, 1], |
||||
|
vec![0, 1, 0, 1, 1, 0, 0, 1], |
||||
|
vec![0, 1, 0, 1, 1, 0, 1], |
||||
|
vec![0, 1, 0, 1, 1, 1], |
||||
|
vec![0, 1, 1], |
||||
|
vec![1, 0, 0, 0, 0, 0], |
||||
|
vec![1, 0, 0, 0, 0, 1, 0], |
||||
|
vec![1, 0, 0, 0, 0, 1, 1, 0, 0], |
||||
|
vec![1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0], |
||||
|
vec![1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0], |
||||
|
vec![1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0], |
||||
|
], |
||||
|
}, |
||||
|
] |
||||
|
} |
||||
|
|
||||
|
#[test] |
||||
|
fn decompose_value_test() { |
||||
|
for test_case in decomposition_test_cases() { |
||||
|
assert_eq!( |
||||
|
test_case.decomposed, |
||||
|
super::decompose_value(test_case.composed, test_case.base, test_case.nb_digits) |
||||
|
); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[test] |
||||
|
fn group_by_ignoring_digits_test() { |
||||
|
for test_case in grouping_test_cases() { |
||||
|
assert_eq!( |
||||
|
test_case.expected, |
||||
|
super::group_by_ignoring_digits( |
||||
|
test_case.start_index, |
||||
|
test_case.end_index, |
||||
|
test_case.base, |
||||
|
test_case.nb_digits |
||||
|
) |
||||
|
); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue