rustfst 0.1.3

Library for Weighted Finite States Transducers as decribed by Mohri and Allauzen
Documentation 
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use fst_traits::{ExpandedFst, MutableFst};
use Result;

/// This operation projects an FST onto its domain or range by either copying
/// each arc's input label to its output label or vice versa.
///
/// # Example : Project input
/// ```
/// use rustfst::utils::{acceptor, transducer};
/// use rustfst::semirings::{Semiring, IntegerWeight};
/// use rustfst::fst_impls::VectorFst;
/// use rustfst::algorithms::project;
///
/// let mut fst : VectorFst<IntegerWeight> = transducer(vec![2].into_iter(), vec![3].into_iter()).unwrap();
/// project(&mut fst, true).unwrap();
///
/// assert_eq!(fst, acceptor(vec![2].into_iter()).unwrap());
/// ```
///
/// # Example : Project output
/// ```
/// use rustfst::utils::{acceptor, transducer};
/// use rustfst::semirings::{Semiring, IntegerWeight};
/// use rustfst::fst_impls::VectorFst;
/// use rustfst::algorithms::project;
///
/// let mut fst : VectorFst<IntegerWeight> = transducer(vec![2].into_iter(), vec![3].into_iter()).unwrap();
/// project(&mut fst, false).unwrap();
///
/// assert_eq!(fst, acceptor(vec![3].into_iter()).unwrap());
/// ```
pub fn project<F: ExpandedFst + MutableFst>(fst: &mut F, project_input: bool) -> Result<()> {
    let states: Vec<_> = fst.states_iter().collect();
    for state_id in states {
        for arc in fst.arcs_iter_mut(&state_id)? {
            if project_input {
                arc.olabel = arc.ilabel;
            } else {
                arc.ilabel = arc.olabel;
            }
        }
    }

    Ok(())
}

/// This operation projects an FST onto its domain or range by copying
/// each arc's input label to its output label.
///
/// # Example
/// ```
/// use rustfst::utils::{acceptor, transducer};
/// use rustfst::semirings::{Semiring, IntegerWeight};
/// use rustfst::fst_impls::VectorFst;
/// use rustfst::algorithms::project;
///
/// let mut fst : VectorFst<IntegerWeight> = transducer(vec![2].into_iter(), vec![3].into_iter()).unwrap();
/// project(&mut fst, true).unwrap();
///
/// assert_eq!(fst, acceptor(vec![2].into_iter()).unwrap());
/// ```
pub fn project_input<F: ExpandedFst + MutableFst>(fst: &mut F) -> Result<()> {
    project(fst, true)
}

/// This operation projects an FST onto its domain or range by copying
/// each arc's output label to its input label.
///
/// # Example
/// ```
/// use rustfst::utils::{acceptor, transducer};
/// use rustfst::semirings::{Semiring, IntegerWeight};
/// use rustfst::fst_impls::VectorFst;
/// use rustfst::algorithms::project;
///
/// let mut fst : VectorFst<IntegerWeight> = transducer(vec![2].into_iter(), vec![3].into_iter()).unwrap();
/// project(&mut fst, false).unwrap();
///
/// assert_eq!(fst, acceptor(vec![3].into_iter()).unwrap());
/// ```
pub fn project_output<F: ExpandedFst + MutableFst>(fst: &mut F) -> Result<()> {
    project(fst, false)
}

#[cfg(test)]
mod tests {
    use super::*;
    use counter::Counter;
    use fst_traits::PathsIterator;
    use test_data::vector_fst::get_vector_fsts_for_tests;

    #[test]
    fn test_projection_input_generic() {
        for data in get_vector_fsts_for_tests() {
            let fst = &data.fst;

            let paths_ref: Counter<_> = fst
                .paths_iter()
                .map(|mut p| {
                    p.olabels = p.ilabels.clone();
                    p
                }).collect();

            let mut projected_fst = fst.clone();

            project_input(&mut projected_fst).unwrap();
            let paths: Counter<_> = projected_fst.paths_iter().collect();

            assert_eq!(
                paths, paths_ref,
                "Test failing for project_input on wFST {:?}",
                &data.name
            )
        }
    }

    #[test]
    fn test_projection_output_generic() {
        for data in get_vector_fsts_for_tests() {
            let fst = &data.fst;

            let paths_ref: Counter<_> = fst
                .paths_iter()
                .map(|mut p| {
                    p.ilabels = p.olabels.clone();
                    p
                }).collect();

            let mut projected_fst = fst.clone();

            project_output(&mut projected_fst).unwrap();
            let paths: Counter<_> = projected_fst.paths_iter().collect();

            assert_eq!(
                paths, paths_ref,
                "Test failing for project_output on wFST {:?}",
                &data.name
            )
        }
    }
}