uuuuhhhhhh all for nothing!!!!!!
This commit is contained in:
lda committed
1 parent
79c67497fa
commit
cc939b19f5
3 files changed
+378
-481
No files matched your search
@@ -79,8 +79,8 @@ impl DB {
|
||||
|
||||
/// Removes the last value from the sequence.
|
||||
pub fn pop(&mut self) -> Option<u32> {
|
||||
let return_value = self.last();
|
||||
if return_value.is_some() {
|
||||
let return_value = self.last()?;
|
||||
// if return_value.is_some() {
|
||||
if let Some(&last_inner) = self.inner.last() {
|
||||
if self.len - last_inner == 1 {
|
||||
self.inner.pop();
|
||||
@@ -88,9 +88,8 @@ impl DB {
|
||||
panic!("run DB::validate(&self)");
|
||||
}
|
||||
}
|
||||
self.len -= 1;
|
||||
}
|
||||
return_value
|
||||
self.len -= 1; // }
|
||||
Some(return_value)
|
||||
}
|
||||
/// Retrieves the value at a given index.
|
||||
/**
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
use db::DB;
|
||||
use monotonic_sequence::{MonotonicSequence, SequenceError};
|
||||
// use db2::{DBError, DB as DB2};
|
||||
|
||||
pub mod db;
|
||||
#[allow(dead_code)]
|
||||
mod db2;
|
||||
#[allow(dead_code)]
|
||||
mod db3;
|
||||
// #[allow(dead_code)]
|
||||
// mod db2;
|
||||
// #[allow(dead_code)]
|
||||
// mod db3;
|
||||
pub mod monotonic_sequence;
|
||||
|
||||
pub fn lcs_gen(str1: &str, str2: &str) -> Vec<Vec<u32>> {
|
||||
@@ -68,6 +69,45 @@ pub fn lcs_gen_db(str1: &str, str2: &str) -> Vec<DB> {
|
||||
db
|
||||
}
|
||||
|
||||
#[allow(non_camel_case_types)]
|
||||
#[derive(Debug)]
|
||||
pub enum belper {
|
||||
MSE(SequenceError),
|
||||
None,
|
||||
}
|
||||
|
||||
pub fn lcs_gen_ms(str1: &str, str2: &str) -> Result<Vec<MonotonicSequence>, belper> {
|
||||
let c1: Vec<char> = str1.chars().collect();
|
||||
let c1len = c1.len();
|
||||
let c2: Vec<char> = str2.chars().collect();
|
||||
let c2len = c2.len();
|
||||
let mut db: Vec<MonotonicSequence> = vec![MonotonicSequence::zeros(c2len + 1); c1len + 1];
|
||||
if c1len * c2len == 0 {
|
||||
// for i in &db {
|
||||
// println!("{i:?}")
|
||||
// }
|
||||
return Ok(db);
|
||||
}
|
||||
for i in 1..=c1len {
|
||||
for j in 1..=c2len {
|
||||
if c1[i - 1] == c2[j - 1] {
|
||||
let val = db[i - 1].get(j - 1).ok_or(belper::None)? + 1;
|
||||
db[i].propagate_to_end(j, val).map_err(belper::MSE)?;
|
||||
} else {
|
||||
let val = db[i]
|
||||
.get(j - 1)
|
||||
.ok_or(belper::None)?
|
||||
.max(db[i - 1].get(j).ok_or(belper::None)?);
|
||||
db[i].propagate_to_end(j, val).map_err(belper::MSE)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
// for i in &db {
|
||||
// println!("{i:?}")
|
||||
// }
|
||||
Ok(db)
|
||||
}
|
||||
|
||||
// #[allow(non_camel_case_types)]
|
||||
// #[derive(Debug)]
|
||||
// pub enum belper {
|
||||
@@ -112,6 +152,8 @@ mod test {
|
||||
|
||||
// use crate::common_subsequence::{db2::DB as DB2, lcs_gen_dbai};
|
||||
|
||||
use super::{lcs_gen_ms, monotonic_sequence::MonotonicSequence};
|
||||
|
||||
use super::{lcs_gen, lcs_gen_db, DB};
|
||||
#[test]
|
||||
fn test_normal_case() {
|
||||
@@ -129,7 +171,7 @@ mod test {
|
||||
|
||||
println!("for test_wiki is: {:?}", duration);
|
||||
}
|
||||
// 30/45 micro
|
||||
// 30/45 micro how dropped to 8/15 im cooked
|
||||
|
||||
{
|
||||
let start = Instant::now();
|
||||
@@ -138,7 +180,15 @@ mod test {
|
||||
|
||||
println!("for test_db is: {:?}", duration);
|
||||
}
|
||||
// 22 micro
|
||||
// 22/30 micro
|
||||
{
|
||||
let start = Instant::now();
|
||||
test_dbai();
|
||||
let duration = start.elapsed();
|
||||
|
||||
println!("for test_dbai is: {:?}", duration);
|
||||
}
|
||||
// 13/28 micro
|
||||
|
||||
// success to me
|
||||
}
|
||||
@@ -186,26 +236,26 @@ mod test {
|
||||
.collect();
|
||||
assert_eq!(c, s)
|
||||
}
|
||||
// #[test]
|
||||
// fn test_dbai() {
|
||||
// // CURRENTLY BREAKING IDFK idk IDKF
|
||||
// let s: Vec<Vec<u32>> = vec![
|
||||
// vec![0, 0, 0, 0, 0, 0, 0, 0],
|
||||
// vec![0, 0, 0, 0, 0, 0, 1, 1],
|
||||
// vec![0, 1, 1, 1, 1, 1, 1, 1],
|
||||
// vec![0, 1, 1, 2, 2, 2, 2, 2],
|
||||
// vec![0, 1, 1, 2, 2, 2, 2, 2],
|
||||
// vec![0, 1, 1, 2, 3, 3, 3, 3],
|
||||
// vec![0, 1, 1, 2, 3, 3, 3, 4],
|
||||
// vec![0, 1, 2, 2, 3, 3, 3, 4],
|
||||
// ];
|
||||
// let c: Vec<Vec<u32>> = lcs_gen_dbai("XMJYAUZ", "MZJAWXU")
|
||||
// .expect("oops")
|
||||
// .iter()
|
||||
// .map(DB2::to_vec)
|
||||
// .collect();
|
||||
// assert_eq!(c, s)
|
||||
// }
|
||||
#[test]
|
||||
fn test_dbai() {
|
||||
// CURRENTLY BREAKING IDFK idk IDKF
|
||||
let s: Vec<Vec<u32>> = vec![
|
||||
vec![0, 0, 0, 0, 0, 0, 0, 0],
|
||||
vec![0, 0, 0, 0, 0, 0, 1, 1],
|
||||
vec![0, 1, 1, 1, 1, 1, 1, 1],
|
||||
vec![0, 1, 1, 2, 2, 2, 2, 2],
|
||||
vec![0, 1, 1, 2, 2, 2, 2, 2],
|
||||
vec![0, 1, 1, 2, 3, 3, 3, 3],
|
||||
vec![0, 1, 1, 2, 3, 3, 3, 4],
|
||||
vec![0, 1, 2, 2, 3, 3, 3, 4],
|
||||
];
|
||||
let c: Vec<Vec<u32>> = lcs_gen_ms("XMJYAUZ", "MZJAWXU")
|
||||
.expect("oops")
|
||||
.iter()
|
||||
.map(MonotonicSequence::to_vec)
|
||||
.collect();
|
||||
assert_eq!(c, s)
|
||||
}
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
lcs_gen("", "");
|
||||
|
||||
@@ -43,7 +43,16 @@ impl MonotonicSequence {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new() -> Self{Default::default()}
|
||||
pub fn zeros(count: usize) -> Self {
|
||||
match count {
|
||||
0 => Self::new(),
|
||||
_ => Self::with(0, count),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
// jumps function
|
||||
/// `self.jumps[result of this function]` to get info
|
||||
fn get_jump_index(&self, pos: usize) -> usize {
|
||||
@@ -64,7 +73,7 @@ impl MonotonicSequence {
|
||||
}
|
||||
/// Get value at position
|
||||
///
|
||||
/// this would return none if pos == self.len()
|
||||
/// this would return none if pos >= self.len()
|
||||
pub fn get(&self, pos: usize) -> Option<u32> {
|
||||
// check for bounds
|
||||
if pos >= self.length {
|
||||
@@ -73,9 +82,14 @@ impl MonotonicSequence {
|
||||
// find the place to put
|
||||
Some(self.jumps[self.get_jump_index(pos)].1)
|
||||
}
|
||||
|
||||
/// a superset of can_set, giving no fucks about self.length.
|
||||
// code in can_set moved to here
|
||||
fn can_be(&self, pos: usize) -> (u32, u32) {
|
||||
// if pos > self.len() {
|
||||
// return None
|
||||
// } what couldve been if i cared
|
||||
|
||||
// let _current_value = self.get(pos).unwrap(); // in bound,
|
||||
|
||||
// this new value must be:
|
||||
@@ -142,25 +156,35 @@ impl MonotonicSequence {
|
||||
Ok(min <= new_value && new_value <= max)
|
||||
// if 2, 4 which NEVER happens btw then can you not be 4? well but it never happens
|
||||
}
|
||||
|
||||
/// Change value at position
|
||||
pub fn set(&mut self, pos: usize, value: u32) -> Result<(), SequenceError> {
|
||||
let (min, max) = dbg!(self.can_set(pos, value)?); // already checked for bounds here
|
||||
if value < min {
|
||||
// if bigger to big if smaller too small
|
||||
pub fn can_set_mini(
|
||||
pos: usize,
|
||||
new_value: u32,
|
||||
(current_min, current_max): (u32, u32),
|
||||
) -> Result<(), SequenceError> {
|
||||
debug_assert!(current_max >= current_min && current_max - current_min <= 1);
|
||||
if new_value < current_min {
|
||||
return Err(SequenceError::ValueTooLow {
|
||||
pos,
|
||||
attempted: value,
|
||||
min_allowed: min,
|
||||
attempted: new_value,
|
||||
min_allowed: current_min,
|
||||
});
|
||||
} else if value > max {
|
||||
} else if new_value > current_max {
|
||||
return Err(SequenceError::ValueTooHigh {
|
||||
pos,
|
||||
attempted: value,
|
||||
max_allowed: max,
|
||||
attempted: new_value,
|
||||
max_allowed: current_max,
|
||||
});
|
||||
} else if min == value && max == value {
|
||||
};
|
||||
Ok(())
|
||||
}
|
||||
/// Change value at position
|
||||
pub fn set(&mut self, pos: usize, value: u32) -> Result<(), SequenceError> {
|
||||
let (min, max) = /*dbg!*/self.can_set(pos, value)?; // already checked for bounds here
|
||||
if min == value && max == value {
|
||||
return Ok(());
|
||||
}
|
||||
Self::can_set_mini(pos, value, (min, max))?;
|
||||
// every single singular instance of in between is solved
|
||||
// [2, (3), 4] min == max == 3
|
||||
|
||||
@@ -172,17 +196,20 @@ impl MonotonicSequence {
|
||||
// now current_value needs to change to value.
|
||||
// case 1.
|
||||
// value == min, so current value MUST be max. like how else
|
||||
// THE jump index from get_jump_index
|
||||
if value == min {
|
||||
assert_eq!(current_value, max); // solid logic
|
||||
let at = self.get_jump_index(pos);
|
||||
debug_assert_eq!(current_value, max);
|
||||
debug_assert_eq!(self.jumps[at].0, pos);
|
||||
let (ind, val) = self.jumps.get_mut(pos).unwrap(); // pos here is valid. already checked bounds
|
||||
// TODO: pos misuse?
|
||||
let (ind, _ /*val*/) = self.jumps.get_mut(at).unwrap(); // pos here is valid. already checked bounds
|
||||
|
||||
debug_assert_eq!(current_value, *val);
|
||||
// debug_assert_eq!(current_value, *val); // current value is upper
|
||||
*ind += 1;
|
||||
// if ind is self.length now then we need to pop
|
||||
if *ind >= self.length {
|
||||
let re_moved = self.jumps.pop(); // its just moved (+ 1) also its removed
|
||||
// get it
|
||||
#[cfg(debug_assertions)]
|
||||
{
|
||||
if let Some(ind_and_val) = re_moved {
|
||||
@@ -192,18 +219,26 @@ impl MonotonicSequence {
|
||||
}
|
||||
}
|
||||
// case 2: value == max, current must be min
|
||||
// very last number before a jump
|
||||
else if value == max {
|
||||
debug_assert_eq!(current_value, min);
|
||||
// let at = self.get_jump_index(pos + 1);
|
||||
let Some((index, _val)) = dbg!(self.jumps.get_mut(pos + 1)) else {
|
||||
assert_eq!(current_value, min);
|
||||
if pos + 1 >= self.len() {
|
||||
// pos + 1 is len
|
||||
// pos is the end. Not a jump point, as current_value == min
|
||||
debug_assert_eq!(self.length, pos + 1);
|
||||
|
||||
self.jumps.push((pos, value));
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
// TODO: pos misuse?
|
||||
let at = self.get_jump_index(pos + 1); // should land at
|
||||
debug_assert_eq!(self.jumps[at].0, pos + 1);
|
||||
let (index, _val) = /*dbg!*/self.jumps.get_mut(at).unwrap();
|
||||
|
||||
// how does this work?
|
||||
assert_ne!(*index, 0);
|
||||
|
||||
// we want to decrease my guy
|
||||
// but what if index == 1?
|
||||
// at that place current value == min, value == max ([(0),1,1,1])
|
||||
@@ -221,12 +256,12 @@ impl MonotonicSequence {
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// readonly of self.length
|
||||
pub fn len(&self) -> usize {
|
||||
self.length
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.length == 0
|
||||
self.len() == 0
|
||||
}
|
||||
|
||||
/// Convert to regular vector
|
||||
@@ -246,8 +281,167 @@ impl MonotonicSequence {
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
pub fn validate(&self) -> bool {
|
||||
self.jumps.windows(2).all(|c| {
|
||||
let [(lind, lv), (tind, tv)] = *c else {
|
||||
unreachable!("windows is 2")
|
||||
};
|
||||
lind < tind && lv < tv
|
||||
}) && self.jumps.iter().all(|&(ind, _)| ind < self.length)
|
||||
}
|
||||
|
||||
pub fn push(&mut self, value: u32) -> Result<(), SequenceError> {
|
||||
// let len = self.jumps.len();
|
||||
let Some(&(_curind, current_value)) = self.jumps.last() else {
|
||||
debug_assert_eq!(self.length, 0);
|
||||
self.jumps.push((self.length, value));
|
||||
self.length += 1;
|
||||
return Ok(());
|
||||
};
|
||||
Self::can_set_mini(self.length, value, (current_value, current_value + 1))?;
|
||||
// if current_value == value { } else
|
||||
if current_value + 1 == value {
|
||||
self.jumps.push((self.length, value));
|
||||
}
|
||||
self.length += 1;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn last(&self) -> Option<u32> {
|
||||
if self.is_empty() {
|
||||
None // huh
|
||||
} else {
|
||||
self.jumps.last().map(|&(_, val)| val)
|
||||
}
|
||||
}
|
||||
pub fn first(&self) -> Option<u32> {
|
||||
if self.is_empty() {
|
||||
None // huh
|
||||
} else {
|
||||
self.jumps.first().map(|&(_, val)| val)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn pop(&mut self) -> Option<u32> {
|
||||
let return_value = self.last()?;
|
||||
|
||||
if let Some(&(index_last, _)) = self.jumps.last() {
|
||||
if self.length - index_last == 1 {
|
||||
let _rem = self.jumps.pop();
|
||||
#[cfg(debug_assertions)]
|
||||
{
|
||||
if let Some(ind_and_val) = _rem {
|
||||
debug_assert_eq!(ind_and_val, (self.length - 1, return_value))
|
||||
}
|
||||
}
|
||||
} else if self.length < index_last {
|
||||
// things that never run:
|
||||
panic!("run self.validate()");
|
||||
}
|
||||
}
|
||||
self.length -= 1; // not zero already
|
||||
Some(return_value)
|
||||
}
|
||||
|
||||
pub fn try_from_vec(vec: &[u32]) -> Result<Self, SequenceError> {
|
||||
let Some(mut lagging_value) = vec.first().cloned() else {
|
||||
return Ok(Default::default());
|
||||
}; // always 1 behind => lagging
|
||||
let mut jumps = vec![(0, lagging_value)];
|
||||
vec.iter().enumerate().skip(1).try_for_each(|(ind, &val)| {
|
||||
// if val > lagging_value + 1 {
|
||||
// return Err(SequenceError::ValueTooHigh {
|
||||
// pos: ind,
|
||||
// attempted: val,
|
||||
// max_allowed: lagging_value + 1,
|
||||
// });
|
||||
// } else if val < lagging_value {
|
||||
// return Err(SequenceError::ValueTooLow {
|
||||
// pos: ind,
|
||||
// attempted: val,
|
||||
// min_allowed: lagging_value,
|
||||
// });
|
||||
// } else
|
||||
|
||||
Self::can_set_mini(ind, val, (lagging_value, lagging_value + 1))?;
|
||||
if val == lagging_value + 1 {
|
||||
jumps.push((ind, val));
|
||||
}
|
||||
lagging_value = val;
|
||||
Ok(())
|
||||
})?;
|
||||
Ok(Self {
|
||||
jumps,
|
||||
length: vec.len(),
|
||||
})
|
||||
}
|
||||
|
||||
// working my ass out to make this struct look like a vec D:
|
||||
|
||||
pub fn flatten_after(&mut self, pos: usize) {
|
||||
let len = self.get_jump_index(pos) + 1;
|
||||
self.jumps.truncate(len);
|
||||
}
|
||||
pub fn flatten_before(&mut self, pos: usize) {
|
||||
let len = self.get_jump_index(pos);
|
||||
// let r = self.jumps[len..].to_vec();
|
||||
|
||||
self.jumps.rotate_left(len); // damn they figured it
|
||||
// self.jumps.copy_within(len.., 0);
|
||||
|
||||
self.jumps.truncate(self.jumps.len() - len);
|
||||
// assert_eq!(r, self.jumps, "rotate tricks failed");
|
||||
if let Some((ind, _)) = self.jumps.first_mut() {
|
||||
*ind = 0;
|
||||
}
|
||||
}
|
||||
/// truncate does not need work when big
|
||||
pub fn truncate(&mut self, new_len: usize) {
|
||||
if new_len >= self.len() {
|
||||
return;
|
||||
};
|
||||
self.flatten_after(new_len);
|
||||
self.length = new_len;
|
||||
}
|
||||
// does not extend if number smaller than len
|
||||
pub fn extend(&mut self, large_len: usize) {
|
||||
if large_len < self.length {
|
||||
// eprintln!(
|
||||
// "{large_len} smaller than length {l} could cause data loss",
|
||||
// l = self.length
|
||||
// );
|
||||
return;
|
||||
}
|
||||
self.length = large_len;
|
||||
}
|
||||
pub fn resize(&mut self, new_size: usize) {
|
||||
if new_size >= self.len() {
|
||||
self.extend(new_size);
|
||||
} else {
|
||||
self.truncate(new_size);
|
||||
}
|
||||
}
|
||||
pub fn jumps(&self) -> Vec<(usize, u32)> {
|
||||
self.jumps.to_vec()
|
||||
}
|
||||
pub fn propagate_to_end(&mut self, pos: usize, val: u32) -> Result<(), SequenceError> {
|
||||
let len = self.len();
|
||||
let Some(cur) = self.get(pos) else {
|
||||
return Ok(());
|
||||
};
|
||||
Self::can_set_mini(pos, val, (cur, cur + 1))?;
|
||||
self.flatten_after(pos);
|
||||
if val == cur + 1 {
|
||||
self.jumps.push((pos, val));
|
||||
}
|
||||
self.length = len;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
// ai gen testcases: not quite sure because short + not updated with new methods
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -256,8 +450,11 @@ mod tests {
|
||||
fn test_basic_operations() {
|
||||
// Create [0,0,1,1,2,2]
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.length = 3; // temp
|
||||
seq.set(2, 1).unwrap();
|
||||
seq.length = 5; // temp
|
||||
seq.set(4, 2).unwrap();
|
||||
seq.length = 6; // temp
|
||||
|
||||
assert_eq!(seq.get(0), Some(0));
|
||||
assert_eq!(seq.get(1), Some(0));
|
||||
@@ -274,7 +471,7 @@ mod tests {
|
||||
fn test_invalid_changes() {
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.length = 3; // temp
|
||||
dbg!(&seq);
|
||||
// dbg!(&seq, /*seq.to_vec()*/);
|
||||
seq.set(2, 1).unwrap();
|
||||
seq.length = 5; // temp
|
||||
seq.set(4, 2).unwrap();
|
||||
@@ -298,438 +495,89 @@ mod tests {
|
||||
seq.length = 5; // temp
|
||||
seq.set(4, 2).unwrap();
|
||||
seq.length = 6; // temp
|
||||
|
||||
seq.set(2, 0).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 0, 1, 2, 2]);
|
||||
let mut sec = seq.clone();
|
||||
sec.set(2, 0).unwrap();
|
||||
assert_eq!(sec.to_vec(), vec![0, 0, 0, 1, 2, 2]);
|
||||
|
||||
seq.set(1, 1).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 1, 1, 1, 2, 2]);
|
||||
}
|
||||
#[test]
|
||||
fn test_basic_sequence() {
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 0, 0, 0, 0]);
|
||||
|
||||
seq.truncate(3);
|
||||
seq.set(2, 1).unwrap();
|
||||
seq.extend(6);
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 1, 1]);
|
||||
seq.truncate(5);
|
||||
|
||||
seq.set(4, 2).unwrap();
|
||||
seq.extend(6);
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
|
||||
}
|
||||
#[test]
|
||||
fn test_edge_cases() {
|
||||
let mut seq = MonotonicSequence::with(3, 3);
|
||||
|
||||
// Can't decrease
|
||||
assert!(seq.set(1, 3).is_ok()); // same value ok
|
||||
assert!(matches!(
|
||||
seq.set(2, 2),
|
||||
Err(SequenceError::ValueTooLow { .. })
|
||||
));
|
||||
|
||||
// Can't jump by 2
|
||||
assert!(matches!(
|
||||
seq.set(1, 5),
|
||||
Err(SequenceError::ValueTooHigh { .. })
|
||||
));
|
||||
}
|
||||
#[test]
|
||||
fn test_push_pop() {
|
||||
let mut seq = MonotonicSequence::with(0, 1);
|
||||
seq.push(1).unwrap();
|
||||
seq.push(1).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 1, 1]);
|
||||
|
||||
assert_eq!(seq.pop(), Some(1));
|
||||
assert_eq!(seq.pop(), Some(1));
|
||||
assert_eq!(seq.to_vec(), vec![0]);
|
||||
}
|
||||
#[test]
|
||||
fn test_flatten_after() {
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.propagate_to_end(2, 1).unwrap();
|
||||
seq.propagate_to_end(4, 2).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
|
||||
|
||||
seq.flatten_after(3);
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 1, 1]);
|
||||
}
|
||||
#[test]
|
||||
fn test_flatten_before() {
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.propagate_to_end(2, 1).unwrap();
|
||||
seq.propagate_to_end(4, 2).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
|
||||
|
||||
seq.flatten_before(3);
|
||||
assert_eq!(seq.to_vec(), vec![1, 1, 1, 1, 2, 2]);
|
||||
}
|
||||
|
||||
// /// working as intended: i am happy
|
||||
// #[cfg(test)]
|
||||
// mod lda_test {
|
||||
// use super::MonotonicSequence;
|
||||
// #[test]
|
||||
// fn db_to_vec() {
|
||||
// let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![(0, 0), (4, 1), (8, 2), (12, 3), (14, 4)];
|
||||
// let clen = 16;
|
||||
// assert_eq!(clen as usize, c.len());
|
||||
// let ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: clen,
|
||||
// };
|
||||
// assert!(ctodb.validate().is_ok());
|
||||
// assert_eq!(ctodb.to_vec(), c);
|
||||
// }
|
||||
// #[test]
|
||||
// fn pop_and_get() {
|
||||
// let ctodb = vec![(0, 0), (4, 1), (8, 2), (12, 3), (14, 4)];
|
||||
// let clen = 17;
|
||||
// let mut db = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: clen,
|
||||
// };
|
||||
// assert_eq!(db.get(4), Some(1));
|
||||
// assert_eq!(db.get(12), Some(3));
|
||||
// assert_eq!(db.get(18), None);
|
||||
// assert_eq!(db.get(0), Some(0));
|
||||
// assert_eq!(db.get(17), None);
|
||||
// assert_eq!(db.get(16), Some(4));
|
||||
// // assert_eq!(db.pop(), Some(4));
|
||||
#[test]
|
||||
fn test_try_from_vec() {
|
||||
// Valid sequence
|
||||
let v = vec![0, 0, 1, 1, 2, 2];
|
||||
let seq = MonotonicSequence::try_from_vec(&v).unwrap();
|
||||
assert_eq!(seq.to_vec(), v);
|
||||
|
||||
// // println!("length:{} jumps: {:?} vec: {:?}",db.len(), db.jumps, db.vec());
|
||||
// // while let Some(_) = db.pop() {
|
||||
// // println!("length:{} jumps: {:?} vec: {:?}",db.len(), db.jumps, db.vec());
|
||||
|
||||
// // };
|
||||
// let mut vec = db.to_vec();
|
||||
// while db.len() > 0 {
|
||||
// assert_eq!(db.pop(), vec.pop())
|
||||
// }
|
||||
// assert_eq!(db.pop(), vec.pop());
|
||||
// assert_eq!(db.len(), 0);
|
||||
// }
|
||||
// #[test]
|
||||
// fn last() {
|
||||
// let db = MonotonicSequence::new();
|
||||
// assert_eq!(db.len(), 0);
|
||||
// assert!(db.last_item().is_none());
|
||||
|
||||
// let db = MonotonicSequence::with(0, 1);
|
||||
// assert!(matches!(db.last_item(), Some(0)));
|
||||
|
||||
// // assert!(db.pop() == 0);
|
||||
// // assert_eq!(db.len(), 0);
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn range_of() {
|
||||
// let ctodb = vec![4, 7, 9, 12, 15, 23, 27, 31, 38, 41];
|
||||
// let clen = 49;
|
||||
// let mut db = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: clen,
|
||||
// };
|
||||
// assert_eq!(db.range_of(0), Some(0..4));
|
||||
// assert_eq!(db.range_of(1), Some(4..7));
|
||||
// assert_eq!(db.range_of(11), None);
|
||||
// assert_eq!(db.range_of(10), Some(41..clen));
|
||||
// assert_eq!(db.pop(), Some(10));
|
||||
// assert_eq!(db.range_of(10), Some(41..clen - 1));
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn push() {
|
||||
// let mut db = MonotonicSequence::new();
|
||||
// let mut c = vec![];
|
||||
// let mut push = |i| {
|
||||
// db.push(i).unwrap();
|
||||
// c.push(i);
|
||||
// };
|
||||
// for _ in 0..6 {
|
||||
// push(0);
|
||||
// }
|
||||
// for _ in 0..3 {
|
||||
// push(1);
|
||||
// }
|
||||
// for _ in 0..5 {
|
||||
// push(2);
|
||||
// }
|
||||
// for _ in 0..2 {
|
||||
// push(3);
|
||||
// }
|
||||
// for _ in 0..1 {
|
||||
// push(4);
|
||||
// }
|
||||
// assert_eq!(db.to_vec(), c)
|
||||
// }
|
||||
// #[test]
|
||||
// // #[should_panic]
|
||||
// fn invalid_push() {
|
||||
// let mut db = MonotonicSequence::new();
|
||||
// // dbg!(&db.jumps);
|
||||
// db.push(1).unwrap();
|
||||
// // dbg!(&db.jumps);
|
||||
// for _ in 3..=11 {
|
||||
// db.push(1).unwrap();
|
||||
// }
|
||||
|
||||
// // dbg!(&db.jumps);
|
||||
// // dbg!(db.vec());
|
||||
// db.push(2).unwrap();
|
||||
// dbg!(db.len() != 0);
|
||||
// assert!(db.push(4).is_err());
|
||||
// }
|
||||
// #[test]
|
||||
// // #[should_panic]
|
||||
// fn invalid_push_2() {
|
||||
// let mut db = MonotonicSequence::new();
|
||||
// // dbg!(&db.jumps);
|
||||
|
||||
// db.push(0).unwrap();
|
||||
// db.push(1).unwrap();
|
||||
// // dbg!(&db.jumps);
|
||||
// // dbg!(db.to_vec());
|
||||
// db.push(2).unwrap();
|
||||
// dbg!(db.len() != 0);
|
||||
// assert!(db.push(1).is_err());
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn change() {
|
||||
// let mut c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let mut ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: c.len() as _,
|
||||
// };
|
||||
// let mut change = |i, v| {
|
||||
// ctodb.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
// change(13, 3);
|
||||
// change(3, 1);
|
||||
// change(7, 2);
|
||||
|
||||
// assert_eq!(
|
||||
// ctodb.jumps,
|
||||
// MonotonicSequence::try_from_vec(c).unwrap().jumps
|
||||
// )
|
||||
// }
|
||||
// #[test]
|
||||
// fn from_vec() {
|
||||
// let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: c.len() as _,
|
||||
// };
|
||||
// let c2 = MonotonicSequence::try_from_vec(c).unwrap();
|
||||
// assert_eq!(ctodb.jumps, c2.jumps);
|
||||
// assert_eq!(ctodb.len, c2.len);
|
||||
// }
|
||||
// #[test]
|
||||
// fn avail() {
|
||||
// let c = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: c.len() as _,
|
||||
// };
|
||||
// assert_eq!(ctodb.available_values(3), (Some([0, 1]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(7), (Some([1, 2]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(13), (Some([3, 4]), Some(false)));
|
||||
|
||||
// assert_eq!(ctodb.available_values(0), (Some([0, 0]), None));
|
||||
// assert_eq!(ctodb.available_values(4), (Some([0, 1]), Some(true)));
|
||||
// assert_eq!(ctodb.available_values(11), (Some([2, 3]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(12), (Some([2, 3]), Some(true)));
|
||||
// assert_eq!(ctodb.available_values(15), (Some([4, 5]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(16), (Some([4, 5]), Some(true)));
|
||||
// assert_eq!(ctodb.available_values(17), (None, None));
|
||||
// }
|
||||
// #[test]
|
||||
// fn avail_hard() {
|
||||
// let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let db = MonotonicSequence::try_from_vec(c).unwrap();
|
||||
// assert_eq!(db.available_values(0), (Some([0, 1]), None));
|
||||
// assert_eq!(db.available_values(1), (Some([1, 2]), None));
|
||||
// assert_eq!(db.available_values(11), (Some([11, 12]), None));
|
||||
// assert_eq!(db.available_values(12), (Some([12, 13]), Some(true)));
|
||||
// assert_eq!(db.available_values(13), (Some([13, 13]), None));
|
||||
// assert_eq!(db.available_values(15), (Some([13, 13]), None));
|
||||
// assert_eq!(db.available_values(16), (Some([13, 14]), Some(false)));
|
||||
// assert_eq!(db.available_values(17), (Some([13, 14]), Some(true)));
|
||||
// }
|
||||
// #[test]
|
||||
// fn change_hard() {
|
||||
// let mut c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// let change = |d: &mut MonotonicSequence, c: &mut Vec<u32>, i, v| {
|
||||
// d.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
|
||||
// change(&mut db, &mut c, 12, 12);
|
||||
// change(&mut db, &mut c, 16, 14);
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 13, 12);
|
||||
// change(&mut db, &mut c, 14, 12);
|
||||
// change(&mut db, &mut c, 11, 11);
|
||||
// change(&mut db, &mut c, 12, 11);
|
||||
// change(&mut db, &mut c, 13, 11);
|
||||
// change(&mut db, &mut c, 10, 10);
|
||||
// change(&mut db, &mut c, 11, 10);
|
||||
// change(&mut db, &mut c, 12, 10);
|
||||
// change(&mut db, &mut c, 9, 9);
|
||||
// change(&mut db, &mut c, 10, 9);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 11, 9);
|
||||
// change(&mut db, &mut c, 8, 8);
|
||||
// change(&mut db, &mut c, 9, 8);
|
||||
// change(&mut db, &mut c, 10, 8);
|
||||
// change(&mut db, &mut c, 7, 7);
|
||||
// change(&mut db, &mut c, 8, 7);
|
||||
// // change(&mut db, &mut c, 9, 7);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 6, 6);
|
||||
// change(&mut db, &mut c, 7, 6);
|
||||
// // change(&mut db, &mut c, 8, 6);
|
||||
// change(&mut db, &mut c, 5, 5);
|
||||
// change(&mut db, &mut c, 6, 5);
|
||||
// // change(&mut db, &mut c, 7, 5);
|
||||
// change(&mut db, &mut c, 4, 4);
|
||||
// change(&mut db, &mut c, 5, 4);
|
||||
// // change(&mut db, &mut c, 6, 4);
|
||||
// change(&mut db, &mut c, 3, 3);
|
||||
// change(&mut db, &mut c, 4, 3);
|
||||
// // change(&mut db, &mut c, 5, 3);
|
||||
// change(&mut db, &mut c, 2, 2);
|
||||
// change(&mut db, &mut c, 3, 2);
|
||||
// // change(&mut db, &mut c, 4, 2);
|
||||
// change(&mut db, &mut c, 1, 1);
|
||||
// // change(&mut db, &mut c, 2, 1);
|
||||
// // change(&mut db, &mut c, 3, 1);
|
||||
// change(&mut db, &mut c, 0, 0);
|
||||
// // change(&mut db, &mut c, 1, 0);
|
||||
// // change(&mut db, &mut c, 2, 0);
|
||||
// {
|
||||
// let db2 = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// println!("e: {c:?}, {:?}", db2.to_vec());
|
||||
// println!("{:?}", db);
|
||||
// assert_eq!(db, db2);
|
||||
// }
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn change_harder() {
|
||||
// let mut c = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13];
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// let change = |d: &mut MonotonicSequence, c: &mut Vec<u32>, i, v| {
|
||||
// d.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 12, 12);
|
||||
// println!("m: {:?}", db);
|
||||
// change(&mut db, &mut c, 16, 14);
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 13, 12);
|
||||
// change(&mut db, &mut c, 14, 12);
|
||||
// change(&mut db, &mut c, 11, 11);
|
||||
// change(&mut db, &mut c, 12, 11);
|
||||
// change(&mut db, &mut c, 13, 11);
|
||||
// change(&mut db, &mut c, 10, 10);
|
||||
// change(&mut db, &mut c, 11, 10);
|
||||
// change(&mut db, &mut c, 12, 10);
|
||||
// change(&mut db, &mut c, 9, 9);
|
||||
// change(&mut db, &mut c, 10, 9);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 11, 9);
|
||||
// change(&mut db, &mut c, 8, 8);
|
||||
// change(&mut db, &mut c, 9, 8);
|
||||
// change(&mut db, &mut c, 10, 8);
|
||||
// change(&mut db, &mut c, 7, 7);
|
||||
// change(&mut db, &mut c, 8, 7);
|
||||
// // change(&mut db, &mut c, 9, 7);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 6, 6);
|
||||
// change(&mut db, &mut c, 7, 6);
|
||||
// // change(&mut db, &mut c, 8, 6);
|
||||
// change(&mut db, &mut c, 5, 5);
|
||||
// change(&mut db, &mut c, 6, 5);
|
||||
// // change(&mut db, &mut c, 7, 5);
|
||||
// change(&mut db, &mut c, 4, 4);
|
||||
// change(&mut db, &mut c, 5, 4);
|
||||
// // change(&mut db, &mut c, 6, 4);
|
||||
// change(&mut db, &mut c, 3, 3);
|
||||
// change(&mut db, &mut c, 4, 3);
|
||||
// // change(&mut db, &mut c, 5, 3);
|
||||
// change(&mut db, &mut c, 2, 2);
|
||||
// change(&mut db, &mut c, 3, 2);
|
||||
// // change(&mut db, &mut c, 4, 2);
|
||||
// change(&mut db, &mut c, 1, 1);
|
||||
// // change(&mut db, &mut c, 2, 1);
|
||||
// // change(&mut db, &mut c, 3, 1);
|
||||
// change(&mut db, &mut c, 0, 0);
|
||||
// // change(&mut db, &mut c, 1, 0);
|
||||
// // change(&mut db, &mut c, 2, 0);
|
||||
// {
|
||||
// let db2 = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// println!("e: {c:?}, {:?}", db2.to_vec());
|
||||
// println!("{:?}", db);
|
||||
// assert_eq!(db, db2);
|
||||
// }
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn prop_idk() {
|
||||
// let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// dbg!(&mut db).propagate_to_end(2, 2);
|
||||
// dbg!(&db);
|
||||
// println!("{:?}", db.to_vec());
|
||||
// assert_eq!(db.jumps, vec![0, 1]);
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// db.propagate_to_end(2, 3);
|
||||
// println!("{:?}", db.to_vec());
|
||||
// assert_eq!(db.jumps, vec![0, 1, 2]);
|
||||
// }
|
||||
// #[test]
|
||||
// fn prop() {
|
||||
// let base = [
|
||||
// 0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
|
||||
// 14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
|
||||
// 26, 26,
|
||||
// ];
|
||||
|
||||
// let prop = |bd: &mut MonotonicSequence, cc: &mut Vec<u32>, i, v: u32| {
|
||||
// cc.get_mut(i as usize..).unwrap().fill(v);
|
||||
// bd.propagate_to_end(i, v);
|
||||
// };
|
||||
// {
|
||||
// let mut c = base.to_vec();
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.to_vec()).unwrap();
|
||||
|
||||
// prop(&mut db, &mut c, 15, 7);
|
||||
// prop(&mut db, &mut c, 28, 8);
|
||||
|
||||
// println!("{db:?}, {c:?}");
|
||||
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// assert_eq!(db.to_vec(), c);
|
||||
// }
|
||||
// }
|
||||
// #[test]
|
||||
// #[should_panic]
|
||||
// fn prop_failcase() {
|
||||
// let base = [
|
||||
// 0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
|
||||
// 14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
|
||||
// 26, 26,
|
||||
// ];
|
||||
|
||||
// let prop = |bd: &mut MonotonicSequence, cc: &mut Vec<u32>, i, v: u32| {
|
||||
// cc.get_mut(i as usize..).unwrap().fill(v);
|
||||
// bd.propagate_to_end(i, v);
|
||||
// };
|
||||
// {
|
||||
// let mut c = base.to_vec();
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.to_vec()).unwrap();
|
||||
|
||||
// // prop(&mut db, &mut c, 12, 6);
|
||||
// prop(&mut db, &mut c, 28, 14);
|
||||
|
||||
// println!("{db:?}, {c:?}");
|
||||
|
||||
// assert_eq!(db.to_vec(), c);
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// Invalid jumps
|
||||
let v = vec![0, 0, 2, 1, 1, 1];
|
||||
assert!(matches!(
|
||||
MonotonicSequence::try_from_vec(&v),
|
||||
Err(SequenceError::ValueTooHigh { .. })
|
||||
));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user