diff --git a/.github/workflows/mlsafir.yml b/.github/workflows/mlsafir.yml index 1d305e15..8b35e1b7 100644 --- a/.github/workflows/mlsafir.yml +++ b/.github/workflows/mlsafir.yml @@ -3,6 +3,7 @@ on: pull_request: paths: - src/vocoder/mlsa.rs + - src/mlpg_adjust/** jobs: collect: diff --git a/src/lib.rs b/src/lib.rs index 3ac00319..507f823e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -87,7 +87,7 @@ mod tests { assert_eq!(speech.len(), 74880); approx::assert_abs_diff_eq!(speech[2000], 2.3158134981607754e-5, epsilon = 1.0e-10); - approx::assert_abs_diff_eq!(speech[30000], 6459.375032316974, epsilon = 1.0e-10); + approx::assert_abs_diff_eq!(speech[30000], 6459.375032318177, epsilon = 1.0e-10); } // これ,名詞,代名詞,一般,*,*,*,これ,コレ,コレ,0/2,C3,-1 @@ -127,7 +127,7 @@ mod tests { assert_eq!(speech.len(), 100800); approx::assert_abs_diff_eq!(speech[2000], 17.15977345625943, epsilon = 1.0e-10); - approx::assert_abs_diff_eq!(speech[30000], 2566.2058730889985, epsilon = 1.0e-10); + approx::assert_abs_diff_eq!(speech[30000], 2566.205873089126, epsilon = 1.0e-10); approx::assert_abs_diff_eq!(speech[70000], -1898.2890228814217, epsilon = 1.0e-10); approx::assert_abs_diff_eq!(speech[100799], -13.514971382534956, epsilon = 1.0e-10); } diff --git a/src/mlpg_adjust/mask.rs b/src/mlpg_adjust/mask.rs index d6885bcb..5b4c296b 100644 --- a/src/mlpg_adjust/mask.rs +++ b/src/mlpg_adjust/mask.rs @@ -2,33 +2,55 @@ //! //! The unvoiced frames are determined using multi-space probability distribution (MSD) parameter in stream. -use crate::model::StreamParameter; +use std::ops::Range; -use super::IterExt; +use crate::model::StreamParameter; /// Mask for unvoiced frames -pub struct Mask(Vec); - -impl FromIterator for Mask { - fn from_iter>(iter: I) -> Self { - Self(iter.into_iter().collect()) - } +pub struct Mask { + // matches the length of `durations` + pub(super) ranged_durations: Vec>, + // contiguous ranges joined together + pub(super) voiced_ranges: Vec>, } impl Mask { /// Create mask from `msd` field in stream with lengths of `durations`. pub fn create(stream: &StreamParameter, threshold: f64, durations: &[usize]) -> Self { - Self( - stream - .iter() - .map(|(_, msd)| *msd > threshold) - .duration(durations) - .collect(), - ) + let mut i = 0; + let mut ranged_durations = Vec::with_capacity(durations.len()); + let mut voiced_ranges: Vec> = Vec::new(); + for ((_, msd), duration) in stream.iter().zip(durations) { + let range = i..(i + duration); + if *msd > threshold { + if let Some(last) = voiced_ranges.last_mut() + && last.end == range.start + { + last.end = range.end; + } else { + voiced_ranges.push(range.clone()); + } + } + ranged_durations.push(range); + i += duration; + } + Self { + ranged_durations, + voiced_ranges, + } + } + pub fn len(&self) -> usize { + self.ranged_durations.last().map_or(0, |r| r.end) } - /// Get the internal mask. - pub fn mask(&self) -> &[bool] { - &self.0 + pub fn voiced_len(&self) -> usize { + self.voiced_ranges.iter().map(|r| r.len()).sum() + } + fn mask(&self) -> Vec { + let mut out = vec![false; self.len()]; + for range in &self.voiced_ranges { + out[range.clone()].fill(true); + } + out } /// Fill back the masked region with `default` and returns an iterator of full-length sequence. pub fn fill<'a, T: 'a + Clone>( @@ -37,124 +59,87 @@ impl Mask { default: T, ) -> impl 'a + Iterator { let mut iter = masked.into_iter(); - self.0.iter().map(move |&mask| { - if mask { - iter.next().expect( - "Length of `masked` must be the same as the number of `true`'s in mask.", - ) + self.mask().into_iter().map(move |is_voiced| { + if is_voiced { + iter.next().unwrap() } else { default.clone() } }) } - /// Get distances from left- and right-boundaries. - pub fn boundary_distances(&self) -> Vec<(usize, usize)> { - if self.0.is_empty() { - return vec![]; - } +} - let mut result = vec![(0, 0); self.0.len()]; +#[derive(Debug)] +pub struct IntoIter<'a> { + ranged_durations: std::slice::Iter<'a, Range>, + voiced_ranges: std::slice::Iter<'a, Range>, + next_voiced_range: Option<&'a Range>, +} - let mut left = 0; - for (frame, mask) in self.0.iter().enumerate() { - if *mask { - result[frame].0 = frame - left; - } else { - // current position will be cut off - left = frame + 1; - } +impl<'a> IntoIter<'a> { + pub fn new(mask: &'a Mask) -> Self { + let ranged_durations = mask.ranged_durations.iter(); + let mut voiced_ranges = mask.voiced_ranges.iter(); + let next_voiced_range = voiced_ranges.next(); + Self { + ranged_durations, + voiced_ranges, + next_voiced_range, } + } +} - let mut right = self.0.len() - 1; - for (frame, mask) in self.0.iter().enumerate().rev() { - if *mask { - result[frame].1 = right - frame; - } else { - // current position will be cut off - if frame == 0 { - break; - } - right = frame - 1; - } +impl Iterator for IntoIter<'_> { + type Item = (Range, Option>); + + fn next(&mut self) -> Option { + let range = self.ranged_durations.next()?; + let voiced_range = self + .next_voiced_range + .filter(|r| r.start <= range.start && range.end <= r.end); + if voiced_range.is_some_and(|r| r.end == range.end) { + self.next_voiced_range = self.voiced_ranges.next(); } + Some((range.clone(), voiced_range.cloned())) + } +} + +impl<'a> IntoIterator for &'a Mask { + type Item = as Iterator>::Item; + type IntoIter = IntoIter<'a>; - result + fn into_iter(self) -> Self::IntoIter { + IntoIter::new(self) } } #[cfg(test)] +#[allow( + clippy::single_range_in_vec_init, + reason = "intended vec of single range" +)] mod tests { use super::Mask; #[test] fn fill() { assert_eq!( - Mask(vec![false, false, true, true, false, true]) - .fill([0, 1, 2], 5) - .collect::>(), + Mask { + ranged_durations: vec![0..2, 2..4, 4..5, 5..6], + voiced_ranges: vec![2..4, 5..6] + } + .fill([0, 1, 2], 5) + .collect::>(), vec![5, 5, 0, 1, 5, 2] ); assert_eq!( - Mask(vec![false, false]).fill([0, 1], 5).collect::>(), + Mask { + ranged_durations: vec![0..2], + voiced_ranges: vec![] + } + .fill([0, 1], 5) + .collect::>(), vec![5, 5] ); } - #[test] - fn boundary_distances() { - assert_eq!( - Mask(vec![ - true, true, true, true, true, true, true, true, true, true - ]) - .boundary_distances(), - vec![ - (0, 9), - (1, 8), - (2, 7), - (3, 6), - (4, 5), - (5, 4), - (6, 3), - (7, 2), - (8, 1), - (9, 0) - ], - ); - assert_eq!( - Mask(vec![ - true, true, true, false, false, true, true, true, true, true - ]) - .boundary_distances(), - vec![ - (0, 2), - (1, 1), - (2, 0), - (0, 0), - (0, 0), - (0, 4), - (1, 3), - (2, 2), - (3, 1), - (4, 0) - ] - ); - assert_eq!( - Mask(vec![ - true, true, true, false, true, false, false, false, false, false - ]) - .boundary_distances(), - vec![ - (0, 2), - (1, 1), - (2, 0), - (0, 0), - (0, 0), - (0, 0), - (0, 0), - (0, 0), - (0, 0), - (0, 0) - ] - ); - assert_eq!(Mask(vec![]).boundary_distances(), vec![]); - } } diff --git a/src/mlpg_adjust/mlpg.rs b/src/mlpg_adjust/mlpg.rs index 5b1d2fa6..2b50eee9 100644 --- a/src/mlpg_adjust/mlpg.rs +++ b/src/mlpg_adjust/mlpg.rs @@ -2,9 +2,12 @@ //! //! For details, please refer to . -use crate::model::{GvParameter, MeanVari, Windows}; +use std::ops::Range; -use super::{IterExt, mask::Mask}; +use crate::{ + mlpg_adjust::mask::Mask, + model::{GvParameter, MeanVari, Windows}, +}; const W1: f64 = 1.0; const W2: f64 = 1.0; @@ -15,7 +18,7 @@ pub struct MlpgMatrix { win_size: usize, length: usize, width: usize, - wuw: Vec>, + wuw: Vec, wum: Vec, } @@ -25,36 +28,30 @@ impl MlpgMatrix { pub fn calc_wuw_and_wum(windows: &Windows, parameters: Vec>) -> Self { let length = parameters[0].len(); let width = windows.max_width() * 2 + 1; - let mut wum = Vec::with_capacity(length); - let mut wuw = Vec::with_capacity(length); - - for t in 0..length { - wuw.push(vec![0.0; width]); - wum.push(0.0); - - for (i, window) in windows.iter().enumerate() { - for (index, coef) in window.iter_rev(0) { + let mut wum = vec![0.0; length]; + let mut wuw = vec![0.0; length * width]; + + use std::iter::zip; + for (window, parameter) in zip(windows, ¶meters) { + let parameter = ¶meter[..length]; + + for (index, coef) in window.iter(window.left_width()) { + for ((wuw, wum), MeanVari(mean, vari)) in zip( + wuw.chunks_exact_mut(width) + .zip(&mut wum) + .skip(index.max(0) as usize), + parameter.iter().skip((-index).max(0) as usize), + ) { if coef == 0.0 { continue; } + *wum += coef * vari * mean; - let idx = (t as isize) - index.position(); - if idx < 0 || idx >= length as isize { - continue; - } - let wu = coef * parameters[i][idx as usize].1; - wum[t] += wu * parameters[i][idx as usize].0; - - for (inner_index, coef) in window.iter_rev(index.index()) { - if coef == 0.0 { + for (wuw, (_, inner_coef)) in zip(wuw, window.iter(index)) { + if inner_coef == 0.0 { continue; } - let j = inner_index.index() - index.index(); - if t + j >= length { - break; - } - - wuw[t][j] += wu * coef; + *wuw += coef * inner_coef * vari; } } } @@ -77,62 +74,88 @@ impl MlpgMatrix { /// Perform Cholesky decomposition. fn ldl_factorization(&mut self) { - for t in 0..self.length { - for i in 1..self.width.min(t + 1) { - self.wuw[t][0] -= self.wuw[t - i][i] * self.wuw[t - i][i] * self.wuw[t - i][0]; + let Self { width, length, .. } = *self; + let wuw = &mut self.wuw[..length * width]; + for t in 0..length { + for i in 1..width.min(t + 1) { + wuw[width * t] -= + wuw[(t - i) * width + i] * wuw[(t - i) * width + i] * wuw[(t - i) * width]; } - for i in 1..self.width { - for j in 1..(self.width - i).min(t + 1) { - self.wuw[t][i] -= - self.wuw[t - j][j] * self.wuw[t - j][i + j] * self.wuw[t - j][0]; + for i in 1..width { + for j in 1..(width - i).min(t + 1) { + wuw[width * t + i] -= wuw[(t - j) * width + j] + * wuw[(t - j) * width + i + j] + * wuw[(t - j) * width]; } - self.wuw[t][i] /= self.wuw[t][0]; + wuw[width * t + i] /= wuw[width * t]; } } } /// Forward & backward substitution. fn substitutions(&self) -> Vec { + let Self { width, length, .. } = *self; + let wum = &self.wum[..length]; + let wuw = &self.wuw[..length * width]; let mut g = vec![0.0; self.length]; // forward - for t in 0..self.length { - g[t] = self.wum[t]; - for i in 1..self.width.min(t + 1) { - g[t] -= self.wuw[t - i][i] * g[t - i]; + for t in 0..length { + g[t] = wum[t]; + for i in 1..width.min(t + 1) { + g[t] -= wuw[(t - i) * width + i] * g[t - i]; } } let mut par = vec![0.0; self.length]; // backward for t in (0..self.length).rev() { - par[t] = g[t] / self.wuw[t][0]; - for i in 1..self.width.min(self.length - t) { - par[t] -= self.wuw[t][i] * par[t + i]; + par[t] = g[t] / wuw[t * width]; + for i in 1..width.min(length - t) { + par[t] -= wuw[t * width + i] * par[t + i]; } } par } + fn calculate_gv_by_ranges(gv_switch: &[bool], mask: &Mask) -> Vec<(Range, bool)> { + let mut gv_by_ranges: Vec<(Range, bool)> = Vec::new(); + + let mut cum_duration = 0; + for (sw, (range, voiced_range)) in std::iter::zip(gv_switch, mask) { + // not voiced + if voiced_range.is_none() { + continue; + } + + let range = cum_duration..cum_duration + range.len(); + cum_duration += range.len(); + if let Some((current_range, current_sw)) = gv_by_ranges.last_mut() + && *current_sw == *sw + && current_range.end == range.start + { + current_range.end = range.end; + } else { + gv_by_ranges.push((range, *sw)); + } + } + + gv_by_ranges + } + /// Solve the equasion, and if necessary, applies GV (global variance). pub fn par( &mut self, gv: &Option, vector_index: usize, gv_weight: f64, - durations: &[usize], - msd_flag: &Mask, + mask: &Mask, ) -> Vec { if let Some((gv_param, gv_switch)) = gv { let mtx_before = self.clone(); let par = self.solve(); - let gv_switch: Vec<_> = gv_switch - .iter() - .copied() - .duration(durations) - .filter_by(msd_flag.mask()) - .collect(); - let mgv = MlpgGlobalVariance::new(mtx_before, par, &gv_switch); + let gv_by_ranges = Self::calculate_gv_by_ranges(gv_switch, mask); + let mgv = MlpgGlobalVariance::new(mtx_before, par, gv_by_ranges); let MeanVari(gv_mean, gv_vari) = gv_param[vector_index]; mgv.apply_gv(gv_mean * gv_weight, gv_vari) @@ -144,22 +167,19 @@ impl MlpgMatrix { /// MLPG global variance (GV) calculator. #[derive(Debug, Clone)] -pub struct MlpgGlobalVariance<'a> { +pub struct MlpgGlobalVariance { par: Vec, - gv_switch: &'a [bool], - gv_length: usize, + gv_by_ranges: Vec<(Range, bool)>, mtx: MlpgMatrix, } -impl<'a> MlpgGlobalVariance<'a> { +impl MlpgGlobalVariance { /// Create a new GV structure. - pub fn new(mtx: MlpgMatrix, par: Vec, gv_switch: &'a [bool]) -> Self { - let gv_length = gv_switch.iter().filter(|b| **b).count(); + pub fn new(mtx: MlpgMatrix, par: Vec, gv_by_ranges: Vec<(Range, bool)>) -> Self { Self { par, - gv_switch, - gv_length, + gv_by_ranges, mtx, } } @@ -171,23 +191,28 @@ impl<'a> MlpgGlobalVariance<'a> { } fn calc_gv(&self) -> (f64, f64) { - let mean = self - .par - .iter() - .zip(self.gv_switch.iter()) - .filter(|(_, sw)| **sw) - .map(|(p, _)| *p) - .sum::() - / self.gv_length as f64; - let vari = self - .par - .iter() - .zip(self.gv_switch.iter()) - .filter(|(_, sw)| **sw) - .map(|(p, _)| (*p - mean) * (*p - mean)) - .sum::() - / self.gv_length as f64; + let gv_length = gv_ranges(&self.gv_by_ranges) + .map(|r| r.len()) + .sum::() as f64; + let mut sums = [0.0; 4]; + let mut square_sums = [0.0; 4]; + + for range in gv_ranges(&self.gv_by_ranges) { + let (par, par_rem) = self.par[range.clone()].as_chunks::<4>(); + for p in par { + for i in 0..4 { + sums[i] += p[i]; + square_sums[i] += p[i] * p[i]; + } + } + for p in par_rem { + sums[0] += p; + square_sums[0] += p * p; + } + } + let mean = sums.iter().sum::() / gv_length; + let vari = (square_sums.iter().sum::() / gv_length) - (mean * mean); (mean, vari) } @@ -195,65 +220,79 @@ impl<'a> MlpgGlobalVariance<'a> { fn conv_gv(&mut self, gv_mean: f64) { let (mean, vari) = self.calc_gv(); let ratio = (gv_mean / vari).sqrt(); - self.par - .iter_mut() - .zip(self.gv_switch.iter()) - .filter(|(_, sw)| **sw) - .for_each(|(p, _)| *p = ratio * (*p - mean) + mean); + + for range in gv_ranges(&self.gv_by_ranges) { + for p in &mut self.par[range] { + *p = ratio * *p + (1.0 - ratio) * mean; + } + } } fn calc_hmmobj_derivative(&self) -> (f64, Vec) { - let mut g = vec![0.0; self.mtx.length]; - - #[allow(clippy::needless_range_loop)] - for t in 0..self.mtx.length { - g[t] = self.mtx.wuw[t][0] * self.par[t]; - for i in 1..self.mtx.width { - if t + i < self.mtx.length { - g[t] += self.mtx.wuw[t][i] * self.par[t + i]; - } - if t + 1 > i { - g[t] += self.mtx.wuw[t - i][i] * self.par[t - i]; + let MlpgMatrix { + width, + length, + win_size, + .. + } = self.mtx; + assert!(width >= 1); // required for `wuw[0]` access + let wuw = self.mtx.wuw.chunks_exact(width); + let wum = &self.mtx.wum[..length]; + let par = &self.par[..length]; + + let mut g = vec![0.0; length]; + + // .zip(0..length) to help optimizer recognize t < length + for (wuw, t) in wuw.zip(0..length) { + g[t] += wuw[0] * par[t]; + for i in 1..width { + if t + i < length { + g[t] += wuw[i] * par[t + i]; + g[t + i] += wuw[i] * par[t]; } } } - let w = 1.0 / ((self.mtx.win_size * self.mtx.length) as f64); + let w = 1.0 / ((win_size * length) as f64); let mut hmmobj = 0.0; - #[allow(clippy::needless_range_loop)] - for t in 0..self.mtx.length { - hmmobj += W1 * w * self.par[t] * (self.mtx.wum[t] - 0.5 * g[t]); + for t in 0..length { + hmmobj += W1 * w * par[t] * (wum[t] - 0.5 * g[t]); } (hmmobj, g) } fn next_step( &mut self, - g: Vec, + g: &[f64], step: f64, mean: f64, vari: f64, gv_mean: f64, gv_vari: f64, ) { - let length = self.mtx.length; + let MlpgMatrix { width, length, .. } = self.mtx; let w = 1.0 / ((self.mtx.win_size * length) as f64); let dv = -2.0 * gv_vari * (vari - gv_mean) / self.mtx.length as f64; - #[allow(clippy::needless_range_loop)] - for t in 0..length { - let h = -W1 * w * self.mtx.wuw[t][0] - - W2 * 2.0 / (length * length) as f64 - * ((length - 1) as f64 * gv_vari * (vari - gv_mean) - + 2.0 * gv_vari * (self.par[t] - mean) * (self.par[t] - mean)); - let next_g = if self.gv_switch[t] { - 1.0 / h * (W1 * w * (-g[t] + self.mtx.wum[t]) + W2 * dv * (self.par[t] - mean)) - } else { - 1.0 / h * (W1 * w * (-g[t] + self.mtx.wum[t])) - }; - - self.par[t] += step * next_g; + assert!(width >= 1); // required for `wuw[0]` access + for (Range { start, end }, sw) in &self.gv_by_ranges { + let wuw = self.mtx.wuw[start * width..end * width].chunks_exact(width); + let wum = &self.mtx.wum[*start..*end]; + let par = &mut self.par[*start..*end]; + let g = &g[*start..*end]; + + for (wuw, t) in wuw.zip(0..end - start) { + let h = -W1 * w * wuw[0] + - W2 * 2.0 / (length * length) as f64 + * ((length - 1) as f64 * gv_vari * (vari - gv_mean) + + 2.0 * gv_vari * (par[t] - mean) * (par[t] - mean)); + let next_g = 1.0 / h + * (W1 * w * (-g[t] + wum[t]) + + (*sw as usize as f64) * W2 * dv * (par[t] - mean)); + + par[t] += step * next_g; + } } } @@ -263,7 +302,7 @@ impl<'a> MlpgGlobalVariance<'a> { const STEPDEC: f64 = 0.5; const STEPINC: f64 = 1.2; - if self.gv_length == 0 || GV_MAX_ITERATION == 0 { + if self.gv_by_ranges.is_empty() || GV_MAX_ITERATION == 0 { return; } @@ -285,9 +324,16 @@ impl<'a> MlpgGlobalVariance<'a> { } } - self.next_step(g, step, mean, vari, gv_mean, gv_vari); + self.next_step(&g, step, mean, vari, gv_mean, gv_vari); prev = obj; } } } + +fn gv_ranges(gv_by_ranges: &[(Range, bool)]) -> impl Iterator> + '_ { + gv_by_ranges + .iter() + .filter(|(_, sw)| *sw) + .map(|(r, _)| r.clone()) +} diff --git a/src/mlpg_adjust/mod.rs b/src/mlpg_adjust/mod.rs index 017fe66c..b6454361 100644 --- a/src/mlpg_adjust/mod.rs +++ b/src/mlpg_adjust/mod.rs @@ -2,8 +2,6 @@ //! //! For details on MLPG, please refer to . -use std::iter; - use crate::{ constants::NODATA, model::{GvParameter, MeanVari, ModelStream, StreamParameter, Windows}, @@ -49,78 +47,47 @@ impl<'a> MlpgAdjust<'a> { } /// Parameter generation using GV weight pub fn create(&self, durations: &[usize]) -> Vec> { - let msd_flag = Mask::create(&self.stream, self.msd_threshold, durations); - let msd_boundaries = msd_flag.boundary_distances(); - let mut pars = vec![vec![0.0; self.vector_length]; msd_flag.mask().len()]; + let mask = Mask::create(&self.stream, self.msd_threshold, durations); + let mut pars = vec![vec![0.0; self.vector_length]; mask.len()]; for vector_index in 0..self.vector_length { - let parameters: Vec> = self - .windows - .iter() - .enumerate() - .map(|(window_index, window)| { - let m = self.vector_length * window_index + vector_index; - - self.stream - .iter() - .map(|(curr_stream, _)| curr_stream[m].with_ivar()) - .duration(durations) - .zip(&msd_boundaries) - .map(|(mean_ivar, (left, right))| { - let is_left_msd_boundary = *left < window.left_width(); - let is_right_msd_boundary = *right < window.right_width(); - - // If the window includes non-msd frames, set the ivar to 0.0 - if (is_left_msd_boundary || is_right_msd_boundary) && window_index != 0 - { - mean_ivar.with_0() - } else { - mean_ivar - } - }) - .filter_by(msd_flag.mask()) - .collect() - }) - .collect(); - + let parameters = self.create_parameters(vector_index, &mask); let mut mtx = MlpgMatrix::calc_wuw_and_wum(self.windows, parameters); - let par = mtx.par(&self.gv, vector_index, self.gv_weight, durations, &msd_flag); + let par = mtx.par(&self.gv, vector_index, self.gv_weight, &mask); - for (par, value) in pars.iter_mut().zip(msd_flag.fill(par, NODATA)) { + for (par, value) in pars.iter_mut().zip(mask.fill(par, NODATA)) { par[vector_index] = value; } } pars } -} - -trait IterExt: Iterator { - fn duration<'a>( - self, - durations: impl IntoIterator + 'a, - ) -> impl Iterator; - - fn filter_by<'a>( - self, - mask: impl IntoIterator + 'a, - ) -> impl Iterator; -} - -impl> IterExt for I { - fn duration<'a>( - self, - durations: impl IntoIterator + 'a, - ) -> impl Iterator { - self.zip(durations) - .flat_map(move |(item, duration)| iter::repeat_n(item, *duration)) - } - fn filter_by<'a>( - self, - mask: impl IntoIterator + 'a, - ) -> impl Iterator { - self.zip(mask) - .filter_map(|(item, mask)| if *mask { Some(item) } else { None }) + fn create_parameters(&self, vector_index: usize, mask: &Mask) -> Vec> { + self.windows + .iter() + .enumerate() + .map(|(window_index, window)| { + let m = self.vector_length * window_index + vector_index; + + let mut out = Vec::with_capacity(mask.voiced_len()); + for ((curr_stream, _), (range, voiced_range)) in self.stream.iter().zip(mask) { + let Some(voiced_range) = voiced_range else { + continue; + }; + + let mean_ivar = curr_stream[m].with_ivar(); + for i in range { + if !window.contained_in(&voiced_range, i) && window_index != 0 { + out.push(mean_ivar.with_0()); + } else { + out.push(mean_ivar); + } + } + } + + out + }) + .collect() } } diff --git a/src/model/voice/window.rs b/src/model/voice/window.rs index 78af8d08..96fc7bb8 100644 --- a/src/model/voice/window.rs +++ b/src/model/voice/window.rs @@ -1,3 +1,5 @@ +use std::ops::Range; + use serde::{Deserialize, Serialize}; #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] @@ -11,7 +13,7 @@ impl Windows { } pub fn iter(&self) -> impl '_ + Iterator { - self.windows.iter() + self.into_iter() } pub fn size(&self) -> usize { self.windows.len() @@ -21,6 +23,15 @@ impl Windows { } } +impl<'a> IntoIterator for &'a Windows { + type Item = &'a Window; + type IntoIter = std::slice::Iter<'a, Window>; + + fn into_iter(self) -> Self::IntoIter { + self.windows.iter() + } +} + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct Window { coefficients: Vec, @@ -31,27 +42,26 @@ impl Window { Self { coefficients } } - pub fn iter_rev(&self, start: usize) -> impl '_ + Iterator { - let width = self.width(); - self.coefficients[start..] + #[inline(always)] + pub fn iter(&self, start: isize) -> impl '_ + Iterator { + self.coefficients[(start - self.left_width()) as usize..] .iter() .enumerate() - .rev() - .zip(std::iter::repeat((start, width))) - .map(|((idx, coef), (start, width))| (WindowIndex::new(start + idx, width), *coef)) + .map(move |(idx, coef)| (idx as isize + start, *coef)) } #[inline] - pub fn width(&self) -> usize { + pub(super) fn width(&self) -> usize { self.coefficients.len() } #[inline] - pub fn left_width(&self) -> usize { - self.width() / 2 + pub fn left_width(&self) -> isize { + -(self.width() as isize / 2) } #[inline] - pub fn right_width(&self) -> usize { - self.width() - self.left_width() - 1 + pub fn contained_in(&self, range: &Range, self_index: usize) -> bool { + self_index >= range.start + (self.width() / 2) + && range.end > self_index + (self.width() / 2) } } @@ -85,32 +95,34 @@ mod tests { let window = Window::new(vec![0.0]); assert_eq!(window.width(), 1); assert_eq!(window.left_width(), 0); - assert_eq!(window.right_width(), 0); + assert!(!window.contained_in(&(3..5), 2)); + assert!(window.contained_in(&(3..5), 3)); + assert!(window.contained_in(&(3..5), 4)); + assert!(!window.contained_in(&(3..5), 5)); } #[test] fn width_3() { let window = Window::new(vec![-1.0, 0.0, 1.0]); assert_eq!(window.width(), 3); - assert_eq!(window.left_width(), 1); - assert_eq!(window.right_width(), 1); + assert_eq!(window.left_width(), -1); + assert!(!window.contained_in(&(3..6), 2)); + assert!(!window.contained_in(&(3..6), 3)); + assert!(window.contained_in(&(3..6), 4)); + assert!(!window.contained_in(&(3..6), 5)); } #[test] fn iterator() { let window = Window::new(vec![-1.0, 0.0, 1.0]); - let iterated = window.iter_rev(0).collect::>(); + let iterated = window.iter(window.left_width()).collect::>(); - assert_eq!(iterated[2].1, -1.0); + assert_eq!(iterated[0].1, -1.0); assert_eq!(iterated[1].1, 0.0); - assert_eq!(iterated[0].1, 1.0); - - assert_eq!(iterated[2].0.index(), 0); - assert_eq!(iterated[1].0.index(), 1); - assert_eq!(iterated[0].0.index(), 2); + assert_eq!(iterated[2].1, 1.0); - assert_eq!(iterated[2].0.position(), -1); - assert_eq!(iterated[1].0.position(), 0); - assert_eq!(iterated[0].0.position(), 1); + assert_eq!(iterated[0].0, -1); + assert_eq!(iterated[1].0, 0); + assert_eq!(iterated[2].0, 1); } }