rustfst 1.3.0

Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs).
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

use anyhow::Result;
use itertools::Itertools;

use crate::fst_impls::{ConstFst, VectorFst};
use crate::fst_traits::ExpandedFst;
use crate::semirings::{SerializableSemiring, WeightQuantize};
use crate::tests_openfst::FstTestData;
use crate::{Semiring, Trs};

fn do_test_fst_into_iterator<W: Semiring, F: ExpandedFst<W>>(fst: F) -> Result<()> {
    let mut fst_data_ref = vec![];

    for state in fst.states_range() {
        fst_data_ref.push((
            state,
            fst.get_trs(state)?.trs().iter().cloned().collect_vec(),
            fst.final_weight(state)?,
            fst.num_trs(state)?,
        ));
    }

    let mut fst_data = vec![];
    for fst_iter_data in fst.fst_into_iter() {
        fst_data.push((
            fst_iter_data.state_id,
            fst_iter_data.trs.collect_vec(),
            fst_iter_data.final_weight,
            fst_iter_data.num_trs,
        ));
    }
    assert_eq!(fst_data, fst_data_ref);

    Ok(())
}

fn do_test_fst_iterator<W: Semiring, F: ExpandedFst<W>>(fst: &F) -> Result<()> {
    let mut fst_data_ref = vec![];

    for state in fst.states_range() {
        fst_data_ref.push((
            state,
            fst.get_trs(state)?.trs().iter().cloned().collect_vec(),
            fst.final_weight(state)?,
            fst.num_trs(state)?,
        ));
    }

    let mut fst_data = vec![];
    for data in fst.fst_iter() {
        fst_data.push((
            data.state_id,
            data.trs.trs().iter().cloned().collect_vec(),
            data.final_weight,
            data.num_trs,
        ));
    }
    assert_eq!(fst_data, fst_data_ref);

    Ok(())
}

pub fn test_fst_into_iterator_const<W>(test_data: &FstTestData<W, VectorFst<W>>) -> Result<()>
where
    W: SerializableSemiring + WeightQuantize,
{
    let raw_fst: ConstFst<_> = test_data.raw.clone().into();

    do_test_fst_iterator(&raw_fst)?;
    do_test_fst_into_iterator(raw_fst)?;

    Ok(())
}

pub fn test_fst_into_iterator_vector<W>(test_data: &FstTestData<W, VectorFst<W>>) -> Result<()>
where
    W: SerializableSemiring + WeightQuantize,
{
    let raw_fst = test_data.raw.clone();

    do_test_fst_iterator(&raw_fst)?;
    do_test_fst_into_iterator(raw_fst.clone())?;

    Ok(())
}