Struct DenseFst 

pub struct DenseFst<'a, A: Arc> { /* private fields */ }

A T × V matrix of acoustic scores, read as an FST.

Row-major: the score of symbol c in frame t is scores[t * V + c].

Implementations

impl<'a, A: Arc> DenseFst<'a, A>

where A::Weight: FromScore,

pub fn new( scores: &'a [f32], num_frames: usize, num_symbols: usize, ) -> Result<Self, OpenFstError>

Reads scores as num_frames × num_symbols, with column c as label c + 1.

pub fn with_label_offset( scores: &'a [f32], num_frames: usize, num_symbols: usize, label_offset: i64, ) -> Result<Self, OpenFstError>

As new, with the columns placed at a chosen label.

An offset of 0 puts column 0 on epsilon; that is allowed, because a graph may genuinely want it, but the properties then say so.

pub fn num_frames(&self) -> usize

The number of frames, which is one less than the number of states.

pub fn num_symbols(&self) -> usize

The number of symbols the acoustic model scores.

pub fn label_offset(&self) -> i64

The label column 0 was placed on.

pub fn frame(&self, t: usize) -> &'a [f32]

The scores of one frame, indexed by column.

A decoder wants exactly this: it walks the graph’s arcs and looks up each one’s label here, rather than iterating this FST’s V arcs and discarding the ones the graph has no use for.

pub fn column_of(&self, label: A::Label) -> Option<usize>

The column a label falls in, or None if it names no column.

Trait Implementations

impl<'a, A: Clone + Arc> Clone for DenseFst<'a, A>

fn clone(&self) -> DenseFst<'a, A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, A: Debug + Arc> Debug for DenseFst<'a, A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: Arc> ExpandedFst<A> for DenseFst<'_, A>

where A::Weight: FromScore,

fn num_states(&self) -> usize

Returns the total number of states in the FST.

impl<A: Arc> Fst<A> for DenseFst<'_, A>

where A::Weight: FromScore,

type StateIter<'s> = DenseStateIter<A> where Self: 's

An iterator over the states of the FST.

type ArcIter<'s> = DenseArcIter<'s, A> where Self: 's

An iterator over the outgoing arcs of a state. Clone is required to allow multi-pass algorithms (e.g., matchers in Compose) to save and restore iteration positions effortlessly without C++ Seek or Reset.

fn start(&self) -> Option<A::StateId>

Returns the initial state ID, or None if the FST is empty.

fn final_weight(&self, state: A::StateId) -> A::Weight

Returns the final weight of the given state. If the state is not final, this must return Weight::zero().

fn num_arcs(&self, state: A::StateId) -> usize

Returns the number of arcs leaving the given state.

fn num_input_epsilons(&self, state: A::StateId) -> usize

Returns the number of input epsilon arcs leaving the given state.

fn num_output_epsilons(&self, state: A::StateId) -> usize

Returns the number of output epsilon arcs leaving the given state.

fn num_states_if_known(&self) -> Option<usize>

Returns the number of states if it is finite and can be computed in O(1) time. Otherwise returns None.

fn properties(&self, mask: u64, _test: bool) -> u64

Property bits. If test is false, returns stored properties bits (some possibly unknown). If test is true, computes the properties if they are unknown.

fn fst_type(&self) -> &str

Returns the name of the FST type (e.g., “vector”, “const”).

fn input_symbols(&self) -> Option<AtomicRc<SymbolTable>>

Returns the input label symbol table, if any. Using Arc allows cheap sharing across FST operations.

fn output_symbols(&self) -> Option<AtomicRc<SymbolTable>>

Returns the output label symbol table, if any.

fn states<'s>(&'s self) -> Self::StateIter<'s>

Returns an iterator over all state IDs in the FST.

fn arcs<'s>(&'s self, state: A::StateId) -> Self::ArcIter<'s>

Returns an iterator over the outgoing arcs of the given state.

fn count_states(&self) -> usize

Computes the exact number of states in the FST. If the state count is known in O(1) (i.e. num_states_if_known returns Some), it uses that. Otherwise, it iterates through all states in O(V) time.

fn count_arcs(&self) -> usize

Computes the exact number of arcs in the FST in O(V) time.