2020-01-12 07:19:06 +00:00
|
|
|
use crate::matrix::DenseBinaryMatrix;
|
2020-01-04 23:52:10 +00:00
|
|
|
use crate::octet::Octet;
|
2020-01-16 07:07:26 +00:00
|
|
|
use crate::sparse_vec::SparseBinaryVec;
|
2020-01-04 23:52:10 +00:00
|
|
|
|
2020-08-30 05:35:08 +00:00
|
|
|
#[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
|
2020-01-04 23:52:10 +00:00
|
|
|
pub struct ClonedOctetIter {
|
|
|
|
sparse: bool,
|
|
|
|
end_col: usize,
|
2020-01-12 07:19:06 +00:00
|
|
|
dense_elements: Option<Vec<u64>>,
|
2020-01-04 23:52:10 +00:00
|
|
|
dense_index: usize,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_word_index: usize,
|
|
|
|
dense_bit_index: usize,
|
2020-01-04 23:52:10 +00:00
|
|
|
sparse_elements: Option<Vec<(usize, Octet)>>,
|
|
|
|
sparse_index: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Iterator for ClonedOctetIter {
|
|
|
|
type Item = (usize, Octet);
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
if self.sparse {
|
|
|
|
let elements = self.sparse_elements.as_ref().unwrap();
|
|
|
|
if self.sparse_index == elements.len() {
|
|
|
|
return None;
|
|
|
|
} else {
|
|
|
|
let old_index = self.sparse_index;
|
|
|
|
self.sparse_index += 1;
|
|
|
|
return Some(elements[old_index].clone());
|
|
|
|
}
|
|
|
|
} else if self.dense_index == self.end_col {
|
|
|
|
return None;
|
|
|
|
} else {
|
|
|
|
let old_index = self.dense_index;
|
2020-12-07 05:22:30 +00:00
|
|
|
let value = if self.dense_elements.as_ref().unwrap()[self.dense_word_index]
|
|
|
|
& DenseBinaryMatrix::select_mask(self.dense_bit_index)
|
2020-01-12 07:19:06 +00:00
|
|
|
== 0
|
|
|
|
{
|
|
|
|
Octet::zero()
|
|
|
|
} else {
|
|
|
|
Octet::one()
|
|
|
|
};
|
2020-12-07 05:22:30 +00:00
|
|
|
self.dense_index += 1;
|
|
|
|
self.dense_bit_index += 1;
|
|
|
|
if self.dense_bit_index == 64 {
|
|
|
|
self.dense_bit_index = 0;
|
|
|
|
self.dense_word_index += 1;
|
|
|
|
}
|
2020-01-12 07:19:06 +00:00
|
|
|
return Some((old_index, value));
|
2020-01-04 23:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-04 17:29:36 +00:00
|
|
|
#[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
|
2020-01-04 23:52:10 +00:00
|
|
|
pub struct OctetIter<'a> {
|
|
|
|
sparse: bool,
|
|
|
|
start_col: usize,
|
|
|
|
end_col: usize,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_elements: Option<&'a [u64]>,
|
2020-01-04 23:52:10 +00:00
|
|
|
dense_index: usize,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_word_index: usize,
|
|
|
|
dense_bit_index: usize,
|
2020-01-11 23:06:57 +00:00
|
|
|
sparse_elements: Option<&'a SparseBinaryVec>,
|
2020-01-04 23:52:10 +00:00
|
|
|
sparse_index: usize,
|
2020-01-13 04:49:13 +00:00
|
|
|
sparse_physical_col_to_logical: Option<&'a [u16]>,
|
2020-01-04 23:52:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> OctetIter<'a> {
|
|
|
|
pub fn new_sparse(
|
|
|
|
start_col: usize,
|
|
|
|
end_col: usize,
|
2020-01-11 23:06:57 +00:00
|
|
|
sparse_elements: &'a SparseBinaryVec,
|
2020-01-13 04:49:13 +00:00
|
|
|
sparse_physical_col_to_logical: &'a [u16],
|
2020-01-04 23:52:10 +00:00
|
|
|
) -> OctetIter<'a> {
|
|
|
|
OctetIter {
|
|
|
|
sparse: true,
|
|
|
|
start_col,
|
|
|
|
end_col,
|
|
|
|
dense_elements: None,
|
|
|
|
dense_index: 0,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_word_index: 0,
|
|
|
|
dense_bit_index: 0,
|
2020-01-04 23:52:10 +00:00
|
|
|
sparse_elements: Some(sparse_elements),
|
|
|
|
sparse_index: 0,
|
|
|
|
sparse_physical_col_to_logical: Some(sparse_physical_col_to_logical),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(clippy::ptr_arg)]
|
2020-01-12 07:19:06 +00:00
|
|
|
pub fn new_dense_binary(
|
2020-01-04 23:52:10 +00:00
|
|
|
start_col: usize,
|
|
|
|
end_col: usize,
|
2020-12-07 05:22:30 +00:00
|
|
|
start_bit: usize,
|
|
|
|
dense_elements: &'a [u64],
|
2020-01-04 23:52:10 +00:00
|
|
|
) -> OctetIter<'a> {
|
|
|
|
OctetIter {
|
|
|
|
sparse: false,
|
2020-01-12 07:19:06 +00:00
|
|
|
start_col: 0,
|
2020-01-04 23:52:10 +00:00
|
|
|
end_col,
|
|
|
|
dense_elements: Some(dense_elements),
|
2020-01-12 07:19:06 +00:00
|
|
|
dense_index: start_col,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_word_index: 0,
|
|
|
|
dense_bit_index: start_bit,
|
2020-01-04 23:52:10 +00:00
|
|
|
sparse_elements: None,
|
|
|
|
sparse_index: 0,
|
|
|
|
sparse_physical_col_to_logical: None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn clone(&self) -> ClonedOctetIter {
|
|
|
|
// Convert to logical indices, since ClonedOctetIter doesn't handle physical
|
|
|
|
let sparse_elements = self.sparse_elements.map(|x| {
|
|
|
|
x.keys_values()
|
|
|
|
.map(|(physical_col, value)| {
|
|
|
|
(
|
2020-01-13 03:42:48 +00:00
|
|
|
self.sparse_physical_col_to_logical.unwrap()[physical_col] as usize,
|
2020-01-13 03:22:02 +00:00
|
|
|
value,
|
2020-01-04 23:52:10 +00:00
|
|
|
)
|
|
|
|
})
|
|
|
|
.filter(|(logical_col, _)| {
|
|
|
|
*logical_col >= self.start_col && *logical_col < self.end_col
|
|
|
|
})
|
|
|
|
.collect()
|
|
|
|
});
|
|
|
|
ClonedOctetIter {
|
|
|
|
sparse: self.sparse,
|
|
|
|
end_col: self.end_col,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_elements: self.dense_elements.map(|x| x.to_vec()),
|
2020-01-04 23:52:10 +00:00
|
|
|
dense_index: self.dense_index,
|
2020-12-07 05:22:30 +00:00
|
|
|
dense_word_index: self.dense_word_index,
|
|
|
|
dense_bit_index: self.dense_bit_index,
|
2020-01-04 23:52:10 +00:00
|
|
|
sparse_elements,
|
|
|
|
sparse_index: self.sparse_index,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> Iterator for OctetIter<'a> {
|
|
|
|
type Item = (usize, Octet);
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
if self.sparse {
|
|
|
|
let elements = self.sparse_elements.unwrap();
|
|
|
|
// Need to iterate over the whole array, since they're not sorted by logical col
|
2021-07-28 05:07:12 +00:00
|
|
|
if self.sparse_index < elements.len() {
|
2020-01-04 23:52:10 +00:00
|
|
|
while self.sparse_index < elements.len() {
|
|
|
|
let entry = elements.get_by_raw_index(self.sparse_index);
|
|
|
|
self.sparse_index += 1;
|
|
|
|
let logical_col = self.sparse_physical_col_to_logical.unwrap()[entry.0];
|
2020-01-13 04:49:13 +00:00
|
|
|
if logical_col >= self.start_col as u16 && logical_col < self.end_col as u16 {
|
2020-01-13 03:42:48 +00:00
|
|
|
return Some((logical_col as usize, entry.1));
|
2020-01-04 23:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-07-28 05:07:12 +00:00
|
|
|
return None;
|
2020-01-04 23:52:10 +00:00
|
|
|
} else if self.dense_index == self.end_col {
|
|
|
|
return None;
|
|
|
|
} else {
|
|
|
|
let old_index = self.dense_index;
|
|
|
|
self.dense_index += 1;
|
2020-12-07 05:22:30 +00:00
|
|
|
let value = if self.dense_elements.unwrap()[self.dense_word_index]
|
|
|
|
& DenseBinaryMatrix::select_mask(self.dense_bit_index)
|
|
|
|
== 0
|
|
|
|
{
|
|
|
|
Octet::zero()
|
|
|
|
} else {
|
|
|
|
Octet::one()
|
|
|
|
};
|
|
|
|
self.dense_bit_index += 1;
|
|
|
|
if self.dense_bit_index == 64 {
|
|
|
|
self.dense_bit_index = 0;
|
|
|
|
self.dense_word_index += 1;
|
|
|
|
}
|
2020-01-12 07:19:06 +00:00
|
|
|
return Some((old_index, value));
|
2020-01-04 23:52:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|