OpenFst Library

https://www.openfst.org/twiki/bin/view/FST/
Admin
OpenFst is a library for constructing, combining, optimizing, and searching weighted finite-state...
Tokens:134,355
Snippets:684
Trust Score:8.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get configure Script Help

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Displays a summary of available options for the 'configure' script. Use `--help` or `-h`.

```Shell
configure --help
```

```Shell
configure -h
```

--------------------------------

### Configuring OpenFst with Custom Options

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Example of how to pass compiler and linker flags to the `configure` script for custom builds.

```shell
./configure CC=c99 CFLAGS=-g LIBS=-lposix
```

--------------------------------

### Basic OpenFst Installation

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Standard shell commands to configure, build, and install the OpenFst package on a system.

```shell
./configure
make
make install
```

--------------------------------

### Create Example FST in C++

Source: https://www.openfst.org/twiki/bin/view/FST/FstQuickTour

This C++ code demonstrates how to create a sample finite state transducer (FST) using the OpenFst library's `StdVectorFst` class. It involves adding states, setting the start state, and adding arcs with specified input labels, output labels, weights, and destination states. The created FST can then be saved to a binary file.

```C++
// A vector FST is a general mutable FST 
StdVectorFst fst;

// Adds state 0 to the initially empty FST and make it the start state. 
fst.AddState();   // 1st state will be state 0 (returned by AddState) 
fst.SetStart(0);  // arg is state ID

// Adds two arcs exiting state 0.
// Arc constructor args: ilabel, olabel, weight, dest state ID. 
fst.AddArc(0, StdArc(1, 1, 0.5, 1));  // 1st arg is src state ID 
fst.AddArc(0, StdArc(2, 2, 1.5, 1)); 

// Adds state 1 and its arc. 
fst.AddState();
fst.AddArc(1, StdArc(3, 3, 2.5, 2));

// Adds state 2 and set its final weight. 
fst.AddState();
fst.SetFinal(2, 3.5);  // 1st arg is state ID, 2nd arg weight 

```

```Shell
fst.Write("binary.fst");

```

--------------------------------

### Get configure Script Version

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Prints the version of Autoconf used to generate the 'configure' script. Use `--version` or `-V`.

```Shell
configure --version
```

```Shell
configure -V
```

--------------------------------

### Installing OpenFst with Custom Executable Prefix

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

How to specify a custom installation directory for architecture-specific files using the `--exec-prefix` option with `configure`.

```shell
./configure --exec-prefix=/path/to/exec/install
```

--------------------------------

### Installing OpenFst with a Custom Prefix

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

How to specify a custom installation directory for OpenFst using the `--prefix` option with `configure`.

```shell
./configure --prefix=/path/to/install
```

--------------------------------

### Specify Installation Directories with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Allows users to specify custom directories for different types of files during the configuration process. Use `--bindir=DIR` to set the binary directory.

```Shell
./configure --bindir=DIR
```

--------------------------------

### C++ FST Composition Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstQuickTour

A complete C++ example demonstrating FST composition. It includes reading FSTs, sorting them for compatibility, performing the composition, projecting the result, and writing it to a file.

```C++
#include <fst/fstlib.h>

namespace fst {
  // Reads in an input FST. 
  StdVectorFst *input = StdVectorFst::Read("input.fst");

  // Reads in the transduction model. 
  StdVectorFst *model = StdVectorFst::Read("model.fst");

  // The FSTs must be sorted along the dimensions they will be joined.
  // In fact, only one needs to be so sorted.
  // This could have instead been done for "model.fst" when it was created. 
  ArcSort(input, StdOLabelCompare());
  ArcSort(model, StdILabelCompare());

  // Container for composition result. 
  StdVectorFst result;

  // Creates the composed FST. 
  Compose(*input, *model, &result);

  // Just keeps the output labels. 
  Project(&result, PROJECT_OUTPUT);

  // Writes the result FST to a file.
  result.Write("result.fst");
}
```

--------------------------------

### Install OpenFst using Conda

Source: https://www.openfst.org/twiki/bin/view/FST/WebHome_cover=print

This command installs the OpenFst library using the conda-forge channel. It is intended for Linux (x86) and Mac OS X users who have conda installed.

```bash
conda install -c conda-forge openfst
```

--------------------------------

### Install OpenFst using Conda

Source: https://www.openfst.org/twiki/bin/view/FST/WebHome_rev=124

This command installs the OpenFst library using the conda-forge channel. It is intended for Linux and Mac OS X users who have conda installed.

```bash
conda install -c conda-forge openfst
```

--------------------------------

### Example Usage of Compose

Source: https://www.openfst.org/twiki/bin/view/FST/ComposeDoc_rev=20

Demonstrates the different ways to call the Compose operation, including the C++ API functions and the command-line tool.

```C++
Compose(A, B, &C);
ComposeFst<Arc>(A, B);
fstcompose a.fst b.fst out.fst
```

--------------------------------

### Install OpenFst using Conda

Source: https://www.openfst.org/twiki/bin/view/FST/WebHome_rev=122

This command installs the OpenFst library using the conda-forge channel. It is intended for Linux (x86) and Mac OS X users who have conda installed.

```bash
conda install -c conda-forge openfst
```

--------------------------------

### Define Variables Directly in configure Command

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Enables setting configuration variables directly on the command line to ensure they are not lost during subsequent 'configure' runs. Example: `VAR=value`.

```Shell
./configure CC=/usr/local2/bin/gcc
```

--------------------------------

### Example Usage of Compose Functions

Source: https://www.openfst.org/twiki/bin/view/FST/ComposeDoc_rev=21

Demonstrates the usage of the Compose function, ComposeFst class constructor, and the fstcompose command-line tool for FST composition.

```Shell
Compose(A, B, &C);
ComposeFst<Arc>(A, B);
fstcompose a.fst b.fst out.fst
```

--------------------------------

### Prune Example Usage

Source: https://www.openfst.org/twiki/bin/view/FST/PruneDoc

Demonstrates the usage of the Prune function and the `fstprune` command-line tool with different FST objects and threshold values.

```Shell
Prune(&A, 3);
Prune(A, &B, 3);
fstprune --weight=3 a.fst out.fst
```

--------------------------------

### Subscribe to Email Notifications (Filtered by Topic Prefix)

Source: https://www.openfst.org/twiki/bin/view/FST/WebNotify

This example demonstrates subscribing to email notifications for topics that start with a specific prefix ('Web'). It includes the subscriber's email and the topic pattern.

```plaintext
* daisy.cutter@flowers.com : Web*
```

--------------------------------

### Install OpenFst using Conda

Source: https://www.openfst.org/twiki/bin/view/FST/WebHome

This command installs the OpenFst library using the conda-forge channel. It is intended for Linux (x86) and Mac OS X users who have conda installed.

```bash
conda install -c conda-forge openfst
```

--------------------------------

### Specify Source Directory with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Instructs the 'configure' script to look for the package's source code in a specified directory. Use `--srcdir=DIR`.

```Shell
configure --srcdir=DIR
```

--------------------------------

### FST Composition and Projection Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_rev=69

Demonstrates how to use the script library to read FSTs, sort them for compatibility, compose them, and project the result. This example works with FSTs of various arc types.

```C++
// Reads in an input FST. 
FstClass *input = FstClass::Read("input.fst");
// Reads in the transduction model. 
FstClass *model = FstClass::Read("model.fst");

// The FSTs must be sorted along the dimensions they will be joined.
// In fact, only one needs to be so sorted.
// This could have instead been done for "model.fst" when it was created. 
ArcSort(input, OLABEL_COMPARE);
ArcSort(model, ILABEL_COMPARE);
// Container for composition result. 
VectorFstClass result(input->ArcType());
// Create the composed FST. 
Compose(*input, *model, &result);
// Just keeps the output labels. 
Project(&result,  PROJECT_OUTPUT);

```

--------------------------------

### Acceptor Minimization Example (C++ and Shell)

Source: https://www.openfst.org/twiki/bin/view/FST/MinimizeDoc

Demonstrates the minimization of an FST acceptor using both the C++ Minimize function and the fstminimize command-line utility.

```C++
Minimize(A, &B);
```

```shell
fstminimize a.fst b.fst
```

--------------------------------

### FST Composition and Projection Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_cover=print

Demonstrates how to use the script library to read FSTs, sort them for compatibility, compose them, and project the result. This example works with FSTs of various arc types.

```C++
// Reads in an input FST. 
FstClass *input = FstClass::Read("input.fst");
// Reads in the transduction model. 
FstClass *model = FstClass::Read("model.fst");

// The FSTs must be sorted along the dimensions they will be joined.
// In fact, only one needs to be so sorted.
// This could have instead been done for "model.fst" when it was created. 
ArcSort(input, OLABEL_COMPARE);
ArcSort(model, ILABEL_COMPARE);
// Container for composition result. 
VectorFstClass result(input->ArcType());
// Create the composed FST. 
Compose(*input, *model, &result);
// Just keeps the output labels. 
Project(&result,  PROJECT_OUTPUT);

```

--------------------------------

### FST Composition and Projection Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_rev=71

Demonstrates how to use the script library to read FSTs, sort them for compatibility, compose them, and project the result. This example works with FSTs of various arc types.

```C++
// Reads in an input FST. 
FstClass *input = FstClass::Read("input.fst");
// Reads in the transduction model. 
FstClass *model = FstClass::Read("model.fst");

// The FSTs must be sorted along the dimensions they will be joined.
// In fact, only one needs to be so sorted.
// This could have instead been done for "model.fst" when it was created. 
ArcSort(input, OLABEL_COMPARE);
ArcSort(model, ILABEL_COMPARE);
// Container for composition result. 
VectorFstClass result(input->ArcType());
// Create the composed FST. 
Compose(*input, *model, &result);
// Just keeps the output labels. 
Project(&result,  PROJECT_OUTPUT);

```

--------------------------------

### FST Composition and Projection Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_rev=72

Demonstrates how to use the script library to read FSTs, sort them for compatibility, compose them, and project the result. This example works with FSTs of various arc types.

```C++
// Reads in an input FST. 
FstClass *input = FstClass::Read("input.fst");
// Reads in the transduction model. 
FstClass *model = FstClass::Read("model.fst");

// The FSTs must be sorted along the dimensions they will be joined.
// In fact, only one needs to be so sorted.
// This could have instead been done for "model.fst" when it was created. 
ArcSort(input, OLABEL_COMPARE);
ArcSort(model, ILABEL_COMPARE);
// Container for composition result. 
VectorFstClass result(input->ArcType());
// Create the composed FST. 
Compose(*input, *model, &result);
// Just keeps the output labels. 
Project(&result,  PROJECT_OUTPUT);

```

--------------------------------

### Determinize Example (C++ and Command Line)

Source: https://www.openfst.org/twiki/bin/view/FST/DeterminizeDoc_rev=15

Demonstrates how to use the Determinize function and its associated class in C++, along with the command-line equivalent for determinizing an FST.

```C++
Determinize(&A);
DeterminizeFst<Arc>(A);
```

```Shell
fstdeterminize a.fst out.fst
```

--------------------------------

### FST Composition and Projection Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage

Demonstrates how to use the script library to read FSTs, sort them for compatibility, compose them, and project the result. This example works with FSTs of various arc types.

```C++
// Reads in an input FST. 
FstClass *input = FstClass::Read("input.fst");
// Reads in the transduction model. 
FstClass *model = FstClass::Read("model.fst");

// The FSTs must be sorted along the dimensions they will be joined.
// In fact, only one needs to be so sorted.
// This could have instead been done for "model.fst" when it was created. 
ArcSort(input, OLABEL_COMPARE);
ArcSort(model, ILABEL_COMPARE);
// Container for composition result. 
VectorFstClass result(input->ArcType());
// Create the composed FST. 
Compose(*input, *model, &result);
// Just keeps the output labels. 
Project(&result,  PROJECT_OUTPUT);

```

--------------------------------

### Determinize Example (C++ and Shell)

Source: https://www.openfst.org/twiki/bin/view/FST/DeterminizeDoc_rev=14

Demonstrates the usage of the Determinize operation with both C++ code and the command-line utility. It shows how to apply determinization to an FST named 'A'.

```C++
Determinize(&A);
DeterminizeFst<Arc>(A);
```

```Shell
fstdeterminize a.fst out.fst
```

--------------------------------

### Compile FST from Text Format

Source: https://www.openfst.org/twiki/bin/view/FST/FstExamples

Compiles a finite-state transducer (FST) from a text description using the fstcompile command. It requires input and output symbol tables. The example shows how to create an FST for the word 'Mars'.

```shell
$ fstcompile --isymbols=ascii.syms --osymbols=wotw.syms >Mars.fst <<EOF
0 1 M Mars
1 2 a <epsilon>
2 3 r <epsilon>
3 4 s <epsilon>
4
EOF
```

--------------------------------

### Install OpenFst via Conda

Source: https://www.openfst.org/twiki/bin/view/FST/WebHome_rev=121

This command installs the OpenFst library on Linux and Mac OS X systems using the conda package manager. It ensures that users can easily access the latest version of OpenFst from the conda-forge channel.

```bash
conda install -c conda-forge openfst
```

--------------------------------

### Example: Command-line Relabel with Label Pairs (Shell)

Source: https://www.openfst.org/twiki/bin/view/FST/RelabelDoc

Example of using the 'fstrelabel' command-line tool to relabel 'a.fst' to 'b.fst' using label pair mappings 'p' for both input and output.

```shell
fstrelabel --relabel_ipairs=p --relabel_opairs=p a.fst b.fst
```

--------------------------------

### C++ Difference Examples

Source: https://www.openfst.org/twiki/bin/view/FST/DifferenceDoc

Illustrates how to use the Difference operation in C++ with different function signatures and the command-line tool.

```C++
Difference(A, B, &C);
DifferenceFst<Arc>(A, B);
```

```Shell
fstdifference a.fsa b.fsa out.fsa
```

--------------------------------

### Enable Caching with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Enables the cache mechanism to store and reuse test results, improving configuration speed. Use `--cache-file=FILE` or `--config-cache`.

```Shell
configure --cache-file=FILE
```

```Shell
configure --config-cache
```

```Shell
configure -C
```

--------------------------------

### Configure FST Composition with Options

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_cover=print

Demonstrates how to set up composition options for FSTs, including specifying caching behavior and matchers. This example uses `RhoMatcher` and `StdComposeFst`.

```C++
typedef RhoMatcher< SortedMatcher<StdFst> > RM;

ComposeFstOptions<StdArc, RM> opts;
opts.gc_limit = 0;
opts.matcher1 = new RM(fst1, MATCH_NONE, kNoLabel);
opts.matcher2 = new RM(fst2, MATCH_INPUT, SomeRhoLabel);

StdComposeFst cfst(fst1, fst2, opts);
```

--------------------------------

### Configure FST Composition with Options

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_rev=72

Demonstrates how to set up composition options for FSTs, including specifying caching behavior and matchers. This example uses `RhoMatcher` and `StdComposeFst`.

```C++
typedef RhoMatcher< SortedMatcher<StdFst> > RM;

ComposeFstOptions<StdArc, RM> opts;
opts.gc_limit = 0;
opts.matcher1 = new RM(fst1, MATCH_NONE, kNoLabel);
opts.matcher2 = new RM(fst2, MATCH_INPUT, SomeRhoLabel);

StdComposeFst cfst(fst1, fst2, opts);
```

--------------------------------

### FST Composition Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_raw=on

Demonstrates a practical C++ example using the fst::script library to compose two FSTs. It covers reading FSTs, sorting them, performing the composition, and projecting the result.

```C++
// Reads in an input FST.
FstClass *input = FstClass::Read("input.fst");
// Reads in the transduction model.
FstClass *model = FstClass::Read("model.fst");

// The FSTs must be sorted along the dimensions they will be joined.
// In fact, only one needs to be so sorted.
// This could have instead been done for "model.fst" when it was created.
ArcSort(input, OLABEL_COMPARE);
ArcSort(model, ILABEL_COMPARE);

// Container for composition result.
VectorFstClass result(input->ArcType());

// Create the composed FST.
Compose(*input, *model, &result);

// Just keeps the output labels.
Project(&result, PROJECT_OUTPUT);
```

--------------------------------

### Compose Transducers Example (C++)

Source: https://www.openfst.org/twiki/bin/view/FST/ComposeDoc

Demonstrates the usage of the Compose function and ComposeFst constructor in C++ for composing transducers A and B, storing the result in C.

```C++
Compose(A, B, &C);
ComposeFst<Arc>(A, B);
```

--------------------------------

### Configure FST Composition with Options

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage

Demonstrates how to set up composition options for FSTs, including specifying caching behavior and matchers. This example uses `RhoMatcher` and `StdComposeFst`.

```C++
typedef RhoMatcher< SortedMatcher<StdFst> > RM;

ComposeFstOptions<StdArc, RM> opts;
opts.gc_limit = 0;
opts.matcher1 = new RM(fst1, MATCH_NONE, kNoLabel);
opts.matcher2 = new RM(fst2, MATCH_INPUT, SomeRhoLabel);

StdComposeFst cfst(fst1, fst2, opts);
```

--------------------------------

### Cleaning OpenFst Build Files

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Shell commands to clean compiled object files and configuration-generated files from the OpenFst source directory.

```shell
make clean
make distclean
```

--------------------------------

### Access FST Initial State

Source: https://www.openfst.org/twiki/bin/view/FST/FstQuickTour

Retrieves the starting state of an FST. If the returned state ID is kNoState, it indicates that the FST is empty.

```c++
typedef StdArc::StateId StateId;

// Gets the initial state; if == kNoState => empty FST. 
StateId initial_state = fst.Start();

```

--------------------------------

### Compose Transducers Example (Command Line)

Source: https://www.openfst.org/twiki/bin/view/FST/ComposeDoc

Illustrates the command-line usage for composing two FST files, 'a.fst' and 'b.fst', to create an output file 'out.fst'.

```Shell
fstcompose a.fst b.fst out.fst
```

--------------------------------

### Set Program Name Prefix/Suffix with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Enables customization of program names by adding a prefix or suffix. Use `--program-prefix=PREFIX` or `--program-suffix=SUFFIX` to modify program names.

```Shell
configure --program-prefix=PREFIX
```

```Shell
configure --program-suffix=SUFFIX
```

--------------------------------

### Subscribe with Topic Exclusion Filters

Source: https://www.openfst.org/twiki/bin/view/FST/WebNotify

This example illustrates subscribing to topics starting with 'Star' while excluding specific topics that end with 'Wars', 'sInTheirEyes', or 'shipTroopers'.

```plaintext
* StarTrekFan: Star* - *Wars - *sInTheirEyes - *shipTroopers
```

--------------------------------

### Subscribe with Multiple Topic Filters and Depth

Source: https://www.openfst.org/twiki/bin/view/FST/WebNotify

This example shows a more complex subscription involving multiple topic patterns with depth specifications. It includes subscribing to topics starting with 'Petal' (and immediate children), 'WeedKillers' (and children to depth 3), and topics matching 'Pretty*Flowers'.

```plaintext
* DaisyCutter: Petal* (1) WeedKillers (3) Pretty*Flowers
```

--------------------------------

### Shell FST Composition Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstQuickTour

Demonstrates FST composition using shell commands. It shows sorting FSTs by label type, composing them, projecting the output, and chaining these operations in a single command line.

```shell
# The FSTs must be sorted along the dimensions they will be joined.
# In fact, only one needs to be so sorted.
# This could have instead been done for "model.fst" when it was created. 
$ fstarcsort --sort_type=olabel input.fst input_sorted.fst
$ fstarcsort --sort_type=ilabel model.fst model_sorted.fst

# Creates the composed FST. 
$ fstcompose input_sorted.fst model_sorted.fst comp.fst

# Just keeps the output label 
$ fstproject --project_output comp.fst result.fst

# Do it all in a single command line. 
$ fstarcsort --sort_type=ilabel model.fst | fstcompose input.fst - | fstproject --project_output result.fst
```

--------------------------------

### FST Alignment Output Format

Source: https://www.openfst.org/twiki/bin/view/FST/FstExamples

This represents the output of the `fstprint` command, showing the alignment between the reference and hypothesis FSTs. Each line typically represents an arc, with columns indicating the start state, end state, input symbol, output symbol, and optionally a weight. The presence of a weight (e.g., '1') often signifies a substitution, insertion, or deletion.

```fst
0	1	T	T
1	2	h	h
2	3	e	e
3	4	<space>	<space>
4	5	n	N	1
5	6	i	i
6	7	c	c
7	8	e	e
8	9	<space>	<space>
9	10	c	c
10	11	h	h
11	12	i	i
12	13	e	e
13	14	f	f
14	15	<space>	<space>
15	16	a	A	1
16	17	s	s
17	18	t	t
18	19	r	r
19	20	o	o
20	21	n	n
21	22	o	o
22	23	m	m
23	24	e	e
24	25	r	r
25	26	<space>	<space>
26	27	s	s
27	28	a	a
28	29	y	y
29	30	s	s
30	31	<space>	<space>
31	32	t	t
32	33	h	h
33	34	a	a
34	35	t	t
35	36	<space>	<space>
36	37	b	b
37	38	o	o
38	39	t	t
39	40	h	h
40	41	<space>	<space>
41	42	t	t
42	43	h	h
43	44	e	e
44	45	<space>	<space>
45	46	t	t
46	47	e	e
47	48	r	r
48	49	r	r
49	50	a	a
50	51	c	c
51	52	e	e
52	53	s	s
53	54	<space>	<space>
54	55	o	o
55	56	f	f
56	57	<space>	<space>
57	58	t	t
58	59	h	h
59	60	e	e
60	61	<space>	<space>
61	62	s	s
62	63	o	o
63	64	u	u
64	65	t	t
65	66	h	h
66	67	<space>	<space>
67	68	t	T	1
68	69	o	o
69	70	w	w
70	71	e	e
71	72	r	r
72	73	<space>	<space>
73	74	a	a
74	75	n	n
75	76	d	d
76	77	<space>	<space>
77	78	t	t
78	79	h	h
79	80	e	e
80	81	<space>	<space>
81	82	w	w
82	83	e	e
83	84	s	s
84	85	t	t
85	86	e	e
86	87	r	r
87	88	n	n
88	89	<space>	<space>
89	90	m	M	1
90	91	i	i
91	92	l	l
92	93	l	l
93	94	s	s
94	95	<space>	<space>
95	96	i	i
96	97	n	n
97	98	<space>	<space>
98	99	t	t
99	100	h	h
100	101	e	e
101	102	<space>	<space>
102	103	e	E	1
103	104	a	a
104	105	s	s
105	106	t	t
106	107	<space>	<space>
107	108	u	u
108	109	s	s
109	110	e	e
110	111	<space>	<space>
111	112	t	t
112	113	h	h
113	114	e	e
114	115	<space>	<space>
115	116	e	E
116	117	n	n
117	118	g	g
118	119	l	l
119	120	i	i
120	121	s	s
121	122	h	h
122	123	<space>	<space>
123	124	c	C	1
124	125	h	h
125	126	a	a
126	127	n	n
127	128	n	n
128	129	e	e
129	130	l	l
130	131	<space>	<space>
131	132	a	a
132	133	s	s
133	134	<space>	<space>
134	135	a	a
135	136	<space>	<space>
136	137	s	S	1
137	138	u	u
138	139	p	p
139	140	p	p
140	141	l	l
141	142	y	y
142	143	<space>	<space>
143	144	p	P	1
144	145	o	o
145	146	o	o
146	147	l	l
147	148	<space>	<space>
```

--------------------------------

### Configure OpenFst with Optional Features

Source: https://www.openfst.org/twiki/bin/view/FST/ReadMe

This snippet shows common configuration options for building OpenFst using the GNU build system. These options enable or disable specific features like command-line binaries, various FST extensions, and Python bindings.

```bash
configure --enable-static=no
configure --enable-bin=yes
configure --enable-compact-fsts=yes
configure --enable-compress=yes
configure --enable-const-fsts=yes
configure --enable-far=yes
configure --enable-linear-fsts=yes
configure --enable-lookahead-fsts=yes
configure --enable-mpdt=yes
configure --enable-ngram-fsts=yes
configure --enable-pdt=yes
configure --enable-python=yes
```

--------------------------------

### OpenFst Quick Tour Statistics

Source: https://www.openfst.org/twiki/bin/view/FST/WebStatistics

Provides statistics on the usage of the OpenFst Quick Tour, which is likely an introductory guide for new users. This metric indicates the onboarding success and initial engagement with OpenFst.

```text
FstQuickTour
```

--------------------------------

### ArcMap Example Usage

Source: https://www.openfst.org/twiki/bin/view/FST/ArcMapDoc

Illustrates practical examples of using ArcMap with `RmWeightMapper` in C++ and the `fstmap` command-line tool. These examples show how to apply weight removal to FSTs.

```C++
ArcMap(&A, RmWeightMapper<StdArc>());
ArcMap(A, &B, RmWeightMapper<StdArc>());
ArcMapFst B(A, RmWeightMapper<StdArc>());
```

```Shell
fstmap --map_type=rmweight a.fst b.fst
```

--------------------------------

### Specify X Window System Paths with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Provides options to manually specify include and library paths for the X Window System if automatic detection fails. Use `--x-includes=DIR` and `--x-libraries=DIR`.

```Shell
configure --x-includes=DIR
```

```Shell
configure --x-libraries=DIR
```

--------------------------------

### OpenFst Examples Usage Statistics

Source: https://www.openfst.org/twiki/bin/view/FST/WebStatistics

Monitors the usage of OpenFst examples, which are crucial for users learning and implementing FST algorithms. High usage indicates that users are actively exploring and utilizing the provided examples.

```text
FstExamples
```

--------------------------------

### Determinize Example (C++)

Source: https://www.openfst.org/twiki/bin/view/FST/DeterminizeDoc_rev=12

Demonstrates the usage of the Determinize function and DeterminizeFst class with a TropicalWeight FST. This example shows how to apply determinization to an existing FST.

```C++
Determinize(&A);
DeterminizeFst<Arc>(A);
```

--------------------------------

### Compile C++ Program with OpenFst

Source: https://www.openfst.org/twiki/bin/view/FST/ReadMe

This command illustrates how to compile a C++ program that uses OpenFst. It specifies the C++11 standard, includes the necessary header path, and links against the OpenFst library and the dynamic linking library.

```bash
g++ your_program.cc -std=c++11 -I /usr/local/include -L /usr/local/lib -lfst -ldl
```

--------------------------------

### OpenFst Compilation on Windows

Source: https://www.openfst.org/twiki/bin/view/FST/FstDownload_raw=on

Offers contributed instructions and code for compiling the OpenFst library on Windows using Visual Studio. This section is for users who need to build OpenFst on a Windows platform.

```shell
Contributed Instructions and code for compiling on Windows with Visual Studio
```

--------------------------------

### Shell Example: Epsilon Normalize

Source: https://www.openfst.org/twiki/bin/view/FST/EpsNormalizeDoc

Shows a shell command example for using `fstepsnormalize` to process an FST file named 'a.fst' and output the normalized result to 'out.fst'.

```Shell
fstepsnormalize a.fst out.fst
```

--------------------------------

### OpenFst Tutorials and Documentation

Source: https://www.openfst.org/twiki/bin/view/FST/WebStatistics

This section lists various documentation pages and tutorials for the OpenFst library. It covers fundamental concepts, advanced usage, and specific algorithms like composition, determinization, and shortest path. The content is organized by topic and includes links to detailed guides.

```English
FstHltTutorial
ComposeDoc
DeterminizeDoc
ShortestPathDoc
WebSearch
FstQuickTour
WebTopicCreator
FstBackground
FstAdvancedUsage
FstDownload
WebStatistics
DistInstall
MinimizeDoc
FstGlossary
FstForum
FstConventions
WebRss
FstWeightRequirements
CompilingOnMacOSX
EncodeDecodeDoc
```

--------------------------------

### C++ Topsort Example Usage

Source: https://www.openfst.org/twiki/bin/view/FST/TopSortDoc

An example demonstrating how to use the Topsort function in C++ with an FST object named 'A'. This is typically followed by the command-line equivalent for verification or batch processing.

```C++
Topsort(&A);
fsttopsort a.fst out.fst
```

--------------------------------

### Determinize Example (C++)

Source: https://www.openfst.org/twiki/bin/view/FST/DeterminizeDoc_raw=on

Example demonstrating the use of the Determinize function and DeterminizeFst class. It shows how to apply determinization to an FST, likely using TropicalWeight as indicated by the accompanying image.

```C++
Determinize(&A);
DeterminizeFst<Arc>(A);
```

--------------------------------

### Compose Function Calls

Source: https://www.openfst.org/twiki/bin/view/FST/ComposeDoc_cover=print

Demonstrates various ways to call the Compose operation, including the C++ function, the ComposeFst constructor, and the command-line utility.

```C++
Compose(A, B, &C);
ComposeFst<Arc>(A, B);
fstcompose a.fst b.fst out.fst
```

--------------------------------

### C++ FST Input/Output Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_cover=print

Demonstrates writing a VectorFst to a file and then reading it back using OpenFST library functions. This involves specifying the FST and arc types.

```C++
VectorFst<Arc> ifst;
...
ifst.Write("a.fst");
VectorFst<Arc> *ofst = VectorFst<Arc>::Read("a.fst");

```

--------------------------------

### Example: Command-line Relabel with Symbol Tables (Shell)

Source: https://www.openfst.org/twiki/bin/view/FST/RelabelDoc

Example of using the 'fstrelabel' command-line tool to relabel 'a.fst' to 'b.fst' using symbol tables 's2' for both input and output.

```shell
fstrelabel  --relabel_isymbols=s2 --relabel_osymbols=s2 a.fst b.fst
```

--------------------------------

### C++ Example: Epsilon Normalize

Source: https://www.openfst.org/twiki/bin/view/FST/EpsNormalizeDoc

Provides a C++ code example demonstrating how to use the EpsNormalize function to perform input epsilon normalization on an FST named 'A', storing the result in 'B'.

```C++
Epsnormalize(A, &B, EPS_NORM_INPUT);
```

--------------------------------

### Install GCC 4.2 via Fink

Source: https://www.openfst.org/twiki/bin/view/FST/CompilingOnMacOSX

Installs the gcc42 package using the Fink package manager. This is a prerequisite for compiling OpenFst on older MacOS X versions with a compatible GCC.

```bash
sudo apt-get install gcc42
```

--------------------------------

### Specify System Type for Cross-Compilation with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Used to specify the system type when 'configure' cannot automatically determine it, especially for cross-compiling. Use `--build=TYPE`, `--target=TYPE`, or `--host=TYPE`.

```Shell
configure --build=TYPE
```

```Shell
configure --target=TYPE
```

```Shell
configure --host=TYPE
```

--------------------------------

### C++ FST Input/Output Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_rev=72

Demonstrates writing a VectorFst to a file and then reading it back using OpenFST library functions. This involves specifying the FST and arc types.

```C++
VectorFst<Arc> ifst;
...
ifst.Write("a.fst");
VectorFst<Arc> *ofst = VectorFst<Arc>::Read("a.fst");

```

--------------------------------

### C++ ArcMap Example Usage

Source: https://www.openfst.org/twiki/bin/view/FST/ArcMapDoc_rev=9

Provides C++ code examples demonstrating how to use the `ArcMap` and `ArcMapFst` classes with the `RmWeightMapper` to remove weights from arcs and final states. It also shows the equivalent `fstmap` command.

```C++
ArcMap(&A, RmWeightMapper<StdArc>());
```

```C++
ArcMap(A, &B, RmWeightMapper<StdArc>());
```

```C++
ArcMapFst B(A, RmWeightMapper<StdArc>());
```

--------------------------------

### Shell fstmap Example Usage

Source: https://www.openfst.org/twiki/bin/view/FST/ArcMapDoc_rev=9

Demonstrates the command-line usage of `fstmap` to remove weights from an FST file.

```shell
fstmap --map_type=rmweight a.fst b.fst
```

--------------------------------

### Determinize Example (C++ and Shell)

Source: https://www.openfst.org/twiki/bin/view/FST/DeterminizeDoc_cover=print

Demonstrates the usage of the Determinize operation for FSTs, including C++ function calls and the command-line utility. It shows how to apply determinization to an FST named 'A'.

```C++
Determinize(&A);
DeterminizeFst<Arc>(A);
```

```Shell
fstdeterminize a.fst out.fst
```

--------------------------------

### Suppress Output with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Reduces the amount of output from the 'configure' script during its execution. Use `--quiet` or `--silent` or `-q`.

```Shell
configure --quiet
```

```Shell
configure --silent
```

```Shell
configure -q
```

--------------------------------

### Enable/Disable Optional Features with configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Allows enabling or disabling optional features of a package during configuration. Use `--enable-FEATURE` for features and `--with-PACKAGE` for dependencies like X Window System.

```Shell
configure --enable-FEATURE
```

```Shell
configure --with-PACKAGE
```

--------------------------------

### C++ FST Input/Output Example

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage

Demonstrates writing a VectorFst to a file and then reading it back using OpenFST library functions. This involves specifying the FST and arc types.

```C++
VectorFst<Arc> ifst;
...
ifst.Write("a.fst");
VectorFst<Arc> *ofst = VectorFst<Arc>::Read("a.fst");

```

--------------------------------

### Connect FST Operation

Source: https://www.openfst.org/twiki/bin/view/FST/FstQuickTour

Removes states and arcs that are not on a path from the start to a final state. Available via C++ and command-line.

```C++
Connect(&A);
```

```Shell
fstconnect in.fst out.fst
```

--------------------------------

### Compile OpenFst with Warnings

Source: https://www.openfst.org/twiki/bin/view/FST/ReadMe

This command demonstrates how to compile OpenFst using g++ with specific warning flags enabled to catch potential issues during development. It includes flags to enable all warnings and disable a specific comparison warning.

```bash
g++ -Wall -Wno-sign-compare
```

--------------------------------

### Invert and Downcase Lexicon

Source: https://www.openfst.org/twiki/bin/view/FST/FstExamples

Inverts a lexicon FST and then composes it with a full downcasing transducer. The result is then inverted again, saving the transformed lexicon to 'lexicon_opt_downcase.fst'.

```bash
$ fstinvert lexicon_opt.fst | fstcompose - full_downcase.fst | fstinvert >lexicon_opt_downcase.fst
```

--------------------------------

### OpenFst Decode Example

Source: https://www.openfst.org/twiki/bin/view/FST/EncodeDecodeDoc

Shows the C++ usage for decoding an FST using EncodeMapper and the `fstencode` command-line tool.

```C++
Decode(&A, encoder);
DecodeFst<Arc>(A, encoder);
fstencode --decode a.fst encoder b.fst
```

--------------------------------

### ComposeFst with Options

Source: https://www.openfst.org/twiki/bin/view/FST/FstAdvancedUsage_raw=on

Demonstrates using options with OpenFst's `ComposeFst` for composition of FSTs. This example shows how to configure caching behavior and specify matchers for the input FSTs using `ComposeFstOptions`.

```C++
typedef RhoMatcher< SortedMatcher<StdFst> > RM;
ComposeFstOptions<StdArc, RM> opts;
opts.gc_limit = 0;
opts.matcher1 = new RM(fst1, MATCH_NONE, kNoLabel);
opts.matcher2 = new RM(fst2, MATCH_INPUT, SomeRhoLabel);
StdComposeFst cfst(fst1, fst2, opts);
```

--------------------------------

### Workaround for CONFIG_SHELL Bug in configure

Source: https://www.openfst.org/twiki/bin/view/FST/DistInstall

Provides a workaround for an Autoconf bug related to the `CONFIG_SHELL` variable. This involves setting `CONFIG_SHELL` both in the environment and on the command line.

```Shell
CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
```

--------------------------------

### Optimize Lexicon FST

Source: https://www.openfst.org/twiki/bin/view/FST/FstExamples

Optimizes a lexicon FST by removing epsilon transitions, determinizing, and minimizing the transducer. This results in an equivalent, deterministic, and minimal FST.

```shell
$ fstrmepsilon lexicon.fst | fstdeterminize | fstminimize >lexicon_opt.fst
```
Tokens:
Raw