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
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

use ::proptest::prelude::{any_with, Arbitrary, BoxedStrategy, Just, Strategy};
use ::proptest::prop_oneof;

use crate::algorithms::{concat::concat, union::union};
use crate::prelude::{TropicalWeight, VectorFst};
use crate::proptest_fst::simple_transducer::{ProptestSimpleTransducerConfig, SimpleTransducer};
use crate::proptest_fst::{MAX_ILABEL, MAX_NUM_OPERATIONS, MAX_OLABEL, MAX_WEIGHT_VALUE};
use crate::utils::epsilon_machine;
use crate::Label;

#[derive(Debug, Clone, Copy)]
pub struct ProptestFstConfig {
    pub n_operations: usize,
    pub max_ilabel: Label,
    pub max_olabel: Label,
    pub max_weight_value: usize,
}

#[derive(Debug, Clone)]
pub enum Operation {
    Union,
    Concat,
}

impl Arbitrary for Operation {
    type Parameters = ();

    fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
        prop_oneof![Just(Operation::Union), Just(Operation::Concat),].boxed()
    }

    type Strategy = BoxedStrategy<Operation>;
}

impl Default for ProptestFstConfig {
    fn default() -> Self {
        ProptestFstConfig {
            n_operations: MAX_NUM_OPERATIONS,
            max_ilabel: MAX_ILABEL,
            max_olabel: MAX_OLABEL,
            max_weight_value: MAX_WEIGHT_VALUE,
        }
    }
}

impl Arbitrary for ProptestFstConfig {
    type Parameters = ProptestFstConfig;
    fn arbitrary_with(maxes: ProptestFstConfig) -> Self::Strategy {
        (
            1..maxes.n_operations,
            1..maxes.max_ilabel,
            1..maxes.max_olabel,
            1..maxes.max_weight_value,
        )
            .prop_map(
                |(n_operations, max_ilabel, max_olabel, max_weight_value)| Self {
                    n_operations,
                    max_ilabel,
                    max_olabel,
                    max_weight_value,
                },
            )
            .boxed()
    }
    type Strategy = BoxedStrategy<ProptestFstConfig>;
}

impl Arbitrary for VectorFst<TropicalWeight> {
    type Parameters = ProptestFstConfig;
    fn arbitrary_with(maxes: Self::Parameters) -> Self::Strategy {
        any_with::<ProptestFstConfig>(maxes)
            .prop_flat_map(move |config: ProptestFstConfig| {
                (
                    // List of operations
                    proptest::collection::vec(any_with::<Operation>(()), config.n_operations),
                    // List of dummy transducers
                    proptest::collection::vec(
                        any_with::<SimpleTransducer>(ProptestSimpleTransducerConfig {
                            ilabel: config.max_ilabel,
                            olabel: config.max_olabel,
                            weight_value: config.max_weight_value,
                        }),
                        config.n_operations,
                    ),
                )
            })
            .prop_map(move |(operations, dummy_fsts)| {
                let mut fst: VectorFst<TropicalWeight> = epsilon_machine().unwrap();

                for i in 0..operations.len() {
                    match operations[i] {
                        Operation::Union => union(&mut fst, &dummy_fsts[i].0).unwrap(),
                        Operation::Concat => concat(&mut fst, &dummy_fsts[i].0).unwrap(),
                    };
                }

                fst
            })
            .boxed()
    }
    type Strategy = BoxedStrategy<VectorFst<TropicalWeight>>;
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::fst_traits::ExpandedFst;
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn test_proptest_vector_fst(fst in any::<VectorFst<TropicalWeight>>()) {
            prop_assert!(fst.num_states() > 0);
        }
    }
}