1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
use crate::algorithms::factor_weight::factor_iterators::{
StringFactorLeft, StringFactorRestrict, StringFactorRight,
};
use crate::algorithms::factor_weight::FactorIterator;
use crate::semirings::{
GallicWeight, GallicWeightLeft, GallicWeightMin, GallicWeightRestrict, GallicWeightRight,
Semiring, StringWeightVariant,
};
#[derive(Debug, PartialEq, Clone)]
pub struct GallicFactorLeft<W: Semiring> {
weight: GallicWeightLeft<W>,
done: bool,
}
#[derive(Debug, PartialEq, Clone)]
pub struct GallicFactorRight<W: Semiring> {
weight: GallicWeightRight<W>,
done: bool,
}
#[derive(Debug, PartialEq, Clone)]
pub struct GallicFactorMin<W: Semiring> {
weight: GallicWeightMin<W>,
done: bool,
}
#[derive(Debug, PartialEq, Clone)]
pub struct GallicFactorRestrict<W: Semiring> {
weight: GallicWeightRestrict<W>,
done: bool,
}
macro_rules! impl_gallic_factor {
($gallic: ident, $g_factor: ident, $s_factor: ident) => {
impl<W: Semiring> Iterator for $g_factor<W> {
type Item = ($gallic<W>, $gallic<W>);
fn next(&mut self) -> Option<Self::Item> {
if self.done() {
return None;
}
let mut it = $s_factor::new(self.weight.value1().clone());
let lol = it.next();
let (p_f, p_s) = lol.unwrap();
let g1 = (p_f, self.weight.value2().clone()).into();
let g2 = (p_s, W::one()).into();
self.done = true;
Some((g1, g2))
}
}
impl<W: Semiring> FactorIterator<$gallic<W>> for $g_factor<W> {
fn new(weight: $gallic<W>) -> Self {
let done = match &weight.value1().value {
StringWeightVariant::Infinity => true,
StringWeightVariant::Labels(l) => (l.len() <= 1),
};
Self { weight, done }
}
fn done(&self) -> bool {
self.done
}
}
};
}
impl_gallic_factor!(GallicWeightLeft, GallicFactorLeft, StringFactorLeft);
impl_gallic_factor!(GallicWeightRight, GallicFactorRight, StringFactorRight);
impl_gallic_factor!(
GallicWeightRestrict,
GallicFactorRestrict,
StringFactorRestrict
);
impl_gallic_factor!(GallicWeightMin, GallicFactorMin, StringFactorRestrict);
#[derive(Debug, PartialEq, Clone)]
pub struct GallicFactor<W: Semiring> {
weight: GallicWeight<W>,
done: bool,
idx: usize,
}
impl<W: Semiring> Iterator for GallicFactor<W> {
type Item = (GallicWeight<W>, GallicWeight<W>);
fn next(&mut self) -> Option<Self::Item> {
if self.done() {
return None;
}
let w = &self.weight.0.list[self.idx];
let mut s_it = StringFactorRestrict::new(w.value1().clone());
let (p_f, p_s) = s_it.next().unwrap_or_else(|| {
(
StringWeightVariant::Labels(vec![]).into(),
StringWeightVariant::Labels(vec![]).into(),
)
});
let grw1: GallicWeightRestrict<W> = (p_f, w.value2().clone()).into();
let grw2: GallicWeightRestrict<W> = (p_s, W::one()).into();
self.idx += 1;
Some((grw1.into(), grw2.into()))
}
}
impl<W: Semiring> FactorIterator<GallicWeight<W>> for GallicFactor<W> {
fn new(weight: GallicWeight<W>) -> Self {
let done = weight.0.list.is_empty()
|| (weight.0.list.len() == 1 && weight.0.list[0].value1().len_labels() <= 1);
Self {
weight,
done,
idx: 0,
}
}
fn done(&self) -> bool {
self.done || (self.idx >= self.weight.0.list.len())
}
}