FST  openfst-1.7.5
OpenFst Library
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
fst Namespace Reference

Namespaces

 internal
 
 script
 

Classes

class  AcceptorCompactor
 
class  Adder
 
class  Adder< LogWeightTpl< T > >
 
class  Adder< SignedLogWeightTpl< T > >
 
class  AddOnPair
 
class  AlgoTester
 
class  AltSequenceComposeFilter
 
class  AnyArcFilter
 
class  ArcArena
 
class  ArcArenaStateStore
 
class  ArcIterator
 
class  ArcIterator< ArcMapFst< A, B, C > >
 
class  ArcIterator< ArcSortFst< Arc, Compare > >
 
class  ArcIterator< ClosureFst< Arc > >
 
class  ArcIterator< CompactFst< Arc, Compactor, CacheStore > >
 
class  ArcIterator< ComplementFst< Arc > >
 
class  ArcIterator< ComposeFst< Arc, CacheStore > >
 
class  ArcIterator< ConcatFst< Arc > >
 
class  ArcIterator< ConstFst< Arc, Unsigned > >
 
class  ArcIterator< DecodeFst< Arc > >
 
class  ArcIterator< DeterminizeFst< Arc > >
 
class  ArcIterator< DifferenceFst< Arc > >
 
class  ArcIterator< EncodeFst< Arc > >
 
class  ArcIterator< FactorWeightFst< Arc, FactorIterator > >
 
class  ArcIterator< IntersectFst< Arc > >
 
class  ArcIterator< InvertFst< Arc > >
 
class  ArcIterator< LinearClassifierFst< Arc > >
 
class  ArcIterator< LinearTaggerFst< Arc > >
 
class  ArcIterator< MapFst< A, B, C > >
 
class  ArcIterator< MatcherFst< FST, M, Name, Init > >
 
class  ArcIterator< MPdtExpandFst< Arc > >
 
class  ArcIterator< NGramFst< A > >
 
class  ArcIterator< PdtExpandFst< Arc > >
 
class  ArcIterator< ProjectFst< A > >
 
class  ArcIterator< RandGenFst< FromArc, ToArc, Sampler > >
 
class  ArcIterator< RationalFst< Arc > >
 
class  ArcIterator< RelabelFst< Arc > >
 
class  ArcIterator< ReplaceFst< Arc, StateTable, CacheStore > >
 
class  ArcIterator< RmEpsilonFst< Arc > >
 
class  ArcIterator< StateMapFst< A, B, C > >
 
class  ArcIterator< SynchronizeFst< Arc > >
 
class  ArcIterator< UnionFst< Arc > >
 
class  ArcIterator< VectorFst< Arc, State > >
 
class  ArcIteratorBase
 
struct  ArcIteratorData
 
class  ArcLookAheadMatcher
 
class  ArcMapFst
 
struct  ArcMapFstOptions
 
class  ArcSampler
 
class  ArcSampler< Arc, FastLogProbArcSelector< Arc > >
 
class  ArcSortFst
 
class  ArcSortMapper
 
class  ArcSumMapper
 
struct  ArcTpl
 
class  ArcUniqueMapper
 
class  AStarWeightCompare
 
class  AutoQueue
 
class  BitmapIndex
 
class  BlockAllocator
 
class  CacheArcIterator
 
struct  CacheImplOptions
 
class  CacheLogAccumulator
 
class  CacheLogAccumulatorData
 
class  CacheMutableArcIterator
 
struct  CacheOptions
 
class  CacheState
 
class  CacheStateIterator
 
class  CcVisitor
 
class  CheckSummer
 
class  ClosureFst
 
struct  ClosureFstOptions
 
class  Collection
 
class  CompactFst
 
struct  CompactFstOptions
 
class  CompactHashBiTable
 
class  CompactHashStateTable
 
class  CompactSet
 
class  ComplementFst
 
class  ComposeFingerprint
 
class  ComposeFst
 
struct  ComposeFstImplOptions
 
class  ComposeFstMatcher
 
struct  ComposeFstOptions
 
class  ComposeHash
 
struct  ComposeOptions
 
class  ComposeState1Fingerprint
 
class  ComposeState2Fingerprint
 
class  CompositeWeightReader
 
class  CompositeWeightWriter
 
class  Compressor
 
class  ConcatFst
 
class  ConstFst
 
class  CopyVisitor
 
class  DecodeFst
 
class  DefaultAccumulator
 
class  DefaultCacheStore
 
struct  DefaultCommonDivisor
 
class  DefaultCompactor
 
class  DefaultCompactState
 
class  DefaultCompactState< ArcCompactor, U, DefaultCompactStore< typename ArcCompactor::Element, U > >
 
class  DefaultCompactStore
 
class  DefaultComposeStateTuple
 
class  DefaultComposeStateTuple< S, TrivialFilterState >
 
class  DefaultDeterminizeFilter
 
class  DefaultDeterminizeStateTable
 
class  DefaultLookAhead
 
class  DefaultLookAhead< Arc, MATCH_INPUT >
 
class  DefaultLookAhead< Arc, MATCH_OUTPUT >
 
class  DefaultLookAhead< LogArc, MATCH_INPUT >
 
class  DefaultLookAhead< LogArc, MATCH_OUTPUT >
 
class  DefaultLookAhead< StdArc, MATCH_INPUT >
 
class  DefaultLookAhead< StdArc, MATCH_OUTPUT >
 
class  DefaultReplaceStateTable
 
class  DeterminizeFst
 
struct  DeterminizeFstOptions
 
struct  DeterminizeOptions
 
class  DetStringComposeStateTable
 
class  DifferenceFst
 
struct  DifferenceFstOptions
 
struct  DisambiguateOptions
 
class  EditFst
 
class  Elias
 
class  EncodeFst
 
class  EncodeMapper
 
class  EncodeTableHeader
 
class  EpsilonArcFilter
 
class  EpsMapper
 
class  ErasableBiTable
 
class  ErasableComposeStateTable
 
class  ErasableStateTable
 
class  ExpandedFst
 
class  ExpanderCacheStore
 
struct  ExpectationArc
 
class  ExpectationWeight
 
class  ExplicitMatcher
 
class  FactorWeightFst
 
struct  FactorWeightOptions
 
class  FarHeader
 
struct  FarInfoData
 
class  FarReader
 
class  FarWriter
 
class  FastLogAccumulator
 
class  FastLogAccumulatorData
 
class  FastLogProbArcSelector
 
class  FeatureGroup
 
class  FeatureGroupBuilder
 
class  FifoQueue
 
class  FilterQueue
 
class  FirstCacheStore
 
class  FlatTrieTopology
 
class  FloatLimits
 
class  FloatWeightGenerate
 
class  FloatWeightTpl
 
class  FromGallicMapper
 
class  FromPowerWeightMapper
 
class  Fst
 
class  FstCompiler
 
class  FstDrawer
 
class  FstFarReader
 
class  FstFarWriter
 
class  FstHeader
 
class  FstInfo
 
class  FstPrinter
 
class  FstReader
 
struct  FstReadOptions
 
class  FstRegister
 
struct  FstRegisterEntry
 
class  FstRegisterer
 
class  FstTester
 
struct  FstWriteOptions
 
class  FstWriter
 
struct  GallicArc
 
class  GallicCommonDivisor
 
class  GallicCommonDivisor< Label, W, GALLIC, CommonDivisor >
 
class  GallicFactor
 
class  GallicFactor< Label, W, GALLIC >
 
class  GallicToNewSymbolsMapper
 
struct  GallicUnionWeightOptions
 
struct  GallicWeight
 
struct  GallicWeight< Label, W, GALLIC >
 
class  GCCacheStore
 
class  GenericComposeStateTable
 
class  GenericRegister
 
class  GenericRegisterer
 
class  GzFile
 
class  HashBiTable
 
class  HashCacheStore
 
class  HashExpanderCache
 
class  HashMatcher
 
struct  HashSet
 
class  HashStateTable
 
class  Heap
 
class  IdentityArcMapper
 
class  IdentityFactor
 
struct  IdentityMapper
 
class  IdentityStateMapper
 
class  IGzFile
 
class  ILabelCompare
 
class  ImplToExpandedFst
 
class  ImplToFst
 
class  ImplToMutableFst
 
class  InputEpsilonArcFilter
 
class  InputEpsilonMapper
 
class  IntegerFilterState
 
class  IntersectFst
 
struct  IntersectFstOptions
 
class  IntervalReachVisitor
 
class  IntervalSet
 
struct  IntInterval
 
class  InvertFst
 
struct  InvertMapper
 
class  InvertWeightMapper
 
struct  KeyInfo
 
class  LabelArcFilter
 
struct  LabelCommonDivisor
 
class  LabelLookAheadMatcher
 
class  LabelLookAheadRelabeler
 
class  LabelReachable
 
class  LabelReachableData
 
class  LempelZiv
 
struct  LexicographicArc
 
class  LexicographicWeight
 
class  LifoQueue
 
class  LinearClassifierFst
 
class  LinearClassifierFstDataBuilder
 
class  LinearFstData
 
class  LinearFstDataBuilder
 
class  LinearFstMatcherTpl
 
class  LinearTaggerFst
 
class  ListFilterState
 
class  LogAccumulator
 
class  LogProbArcSelector
 
class  LogWeightTpl
 
class  LookAheadComposeFilter
 
class  LookAheadMatcher
 
class  LookAheadMatcher< MatcherFst< F, M, Name, Init > >
 
class  LookAheadMatcherBase
 
class  LookAheadSelector
 
class  LookAheadSelector< Matcher, Matcher, MT >
 
class  LookAheadSelector< Matcher1, Matcher2, MATCH_INPUT >
 
class  LookAheadSelector< Matcher1, Matcher2, MATCH_OUTPUT >
 
class  MapFst
 
class  MappedFile
 
class  MatchComposeFilter
 
class  Matcher
 
class  Matcher< MatcherFst< F, M, Name, Init > >
 
class  MatcherBase
 
class  MatcherFst
 
class  MemoryArenaBase
 
class  MemoryArenaCollection
 
class  MemoryPool
 
class  MemoryPoolBase
 
class  MemoryPoolCollection
 
struct  MemoryRegion
 
class  MinMaxWeightTpl
 
class  MPdtComposeFstOptions
 
class  MPdtComposeFstOptions< Arc, false >
 
struct  MPdtComposeOptions
 
class  MPdtExpandFst
 
struct  MPdtExpandFstOptions
 
struct  MPdtExpandOptions
 
class  MPdtInfo
 
class  MPdtParenFilter
 
class  MultiEpsFilter
 
class  MultiEpsMatcher
 
class  MultiLabelArcFilter
 
class  MutableArcIterator
 
class  MutableArcIterator< VectorFst< Arc, State > >
 
class  MutableArcIteratorBase
 
struct  MutableArcIteratorData
 
class  MutableFastLogAccumulatorData
 
class  MutableFst
 
class  MutableTrie
 
class  Mutex
 
class  MutexLock
 
class  NaturalAStarEstimate
 
class  NaturalAStarQueue
 
class  NaturalLess
 
class  NaturalLess< W, typename std::enable_if< IsIdempotent< W >::value >::type >
 
class  NaturalLess< W, typename std::enable_if<!IsIdempotent< W >::value >::type >
 
class  NaturalPruneQueue
 
class  NaturalShortestFirstQueue
 
class  NestedTrieTopology
 
class  NGramFst
 
struct  NGramFstInst
 
class  NGramFstMatcher
 
class  NoGcKeepOneExpanderCache
 
class  NoMatchComposeFilter
 
class  NullAddOn
 
class  NullComposeFilter
 
class  NullMatcherFstInit
 
class  OGzFile
 
class  OLabelCompare
 
class  OneFactor
 
class  OutputEpsilonArcFilter
 
class  OutputEpsilonMapper
 
class  PairFilterState
 
class  PairWeight
 
class  ParenFilter
 
class  ParenMatcher
 
struct  ParentLabel
 
struct  ParentLabelHash
 
class  PartialCopyVisitor
 
class  PartialVisitor
 
class  PdtComposeFstOptions
 
class  PdtComposeFstOptions< Arc, false >
 
struct  PdtComposeOptions
 
class  PdtExpandFst
 
struct  PdtExpandFstOptions
 
struct  PdtExpandOptions
 
class  PdtInfo
 
class  PdtLeftParser
 
class  PdtLeftSRParser
 
class  PdtParser
 
class  PdtPrunedExpand
 
struct  PdtReplaceOptions
 
class  PdtShortestPath
 
struct  PdtShortestPathOptions
 
class  PdtStack
 
class  PdtStateHash
 
class  PdtStateTable
 
struct  PdtStateTuple
 
class  PhiFstMatcher
 
class  PhiMatcher
 
class  PlusMapper
 
class  PoolAllocator
 
struct  PowerArc
 
class  PowerMapper
 
class  PowerWeight
 
struct  ProductArc
 
class  ProductComposeStateTable
 
class  ProductWeight
 
class  ProjectFst
 
class  ProjectMapper
 
class  ProjectPowerWeightMapper
 
class  PruneNaturalShortestFirstQueue
 
struct  PruneOptions
 
class  PruneQueue
 
class  PushLabelsComposeFilter
 
class  PushWeightsComposeFilter
 
class  QuantizeMapper
 
class  QueueBase
 
class  RandGenFst
 
struct  RandGenFstOptions
 
struct  RandGenOptions
 
struct  RandState
 
class  RationalFst
 
class  RelabelFst
 
class  ReplaceAccumulator
 
class  ReplaceAccumulatorData
 
class  ReplaceFingerprint
 
class  ReplaceFst
 
class  ReplaceFstMatcher
 
struct  ReplaceFstOptions
 
class  ReplaceFstStateFingerprint
 
class  ReplaceHash
 
class  ReplaceRootSelector
 
class  ReplaceStackPrefix
 
class  ReplaceStackPrefixHash
 
struct  ReplaceStateTuple
 
class  ReplaceUtil
 
struct  ReplaceUtilOptions
 
struct  ReverseArc
 
class  ReverseWeightMapper
 
class  RhoFstMatcher
 
class  RhoMatcher
 
class  RmEpsilonFst
 
struct  RmEpsilonFstOptions
 
struct  RmEpsilonOptions
 
class  RmWeightMapper
 
class  SafeReplaceAccumulator
 
class  SccQueue
 
class  SccVisitor
 
class  SequenceComposeFilter
 
class  SetWeight
 
class  SetWeightIterator
 
struct  ShortestDistanceOptions
 
class  ShortestFirstQueue
 
struct  ShortestPathOptions
 
class  SigmaFstMatcher
 
class  SigmaMatcher
 
class  SignedLogWeightTpl
 
class  SimpleVectorCacheState
 
class  SortedMatcher
 
struct  SparsePowerArc
 
class  SparsePowerWeight
 
class  SparseTupleWeight
 
class  SparseTupleWeightIterator
 
class  StateIterator
 
class  StateIterator< ArcMapFst< A, B, C > >
 
class  StateIterator< ArcSortFst< Arc, Compare > >
 
class  StateIterator< ClosureFst< Arc > >
 
class  StateIterator< CompactFst< Arc, Compactor, CacheStore > >
 
class  StateIterator< ComplementFst< Arc > >
 
class  StateIterator< ComposeFst< Arc, CacheStore > >
 
class  StateIterator< ConcatFst< Arc > >
 
class  StateIterator< ConstFst< Arc, Unsigned > >
 
class  StateIterator< DecodeFst< Arc > >
 
class  StateIterator< DeterminizeFst< Arc > >
 
class  StateIterator< DifferenceFst< Arc > >
 
class  StateIterator< EncodeFst< Arc > >
 
class  StateIterator< FactorWeightFst< Arc, FactorIterator > >
 
class  StateIterator< IntersectFst< Arc > >
 
class  StateIterator< InvertFst< Arc > >
 
class  StateIterator< LinearClassifierFst< Arc > >
 
class  StateIterator< LinearTaggerFst< Arc > >
 
class  StateIterator< MapFst< A, B, C > >
 
class  StateIterator< MatcherFst< FST, M, Name, Init > >
 
class  StateIterator< MPdtExpandFst< Arc > >
 
class  StateIterator< NGramFst< A > >
 
class  StateIterator< PdtExpandFst< Arc > >
 
class  StateIterator< ProjectFst< A > >
 
class  StateIterator< RandGenFst< FromArc, ToArc, Sampler > >
 
class  StateIterator< RationalFst< Arc > >
 
class  StateIterator< RelabelFst< Arc > >
 
class  StateIterator< ReplaceFst< Arc, StateTable, CacheStore > >
 
class  StateIterator< RmEpsilonFst< Arc > >
 
class  StateIterator< SynchronizeFst< Arc > >
 
class  StateIterator< UnionFst< Arc > >
 
class  StateIterator< VectorFst< Arc, State > >
 
class  StateIteratorBase
 
struct  StateIteratorData
 
class  StateMapFst
 
class  StateMapStateIteratorBase
 
class  StateOrderQueue
 
class  StateReachable
 
class  STListFarReader
 
class  STListFarWriter
 
class  STListReader
 
class  STListWriter
 
struct  StringArc
 
class  StringCompactor
 
class  StringCompiler
 
class  StringDetComposeStateTable
 
class  StringFactor
 
class  StringPrinter
 
class  StringReader
 
class  StringWeight
 
class  StringWeightIterator
 
class  StringWeightReverseIterator
 
class  STTableFarReader
 
class  STTableFarWriter
 
class  STTableReader
 
class  STTableWriter
 
class  SuperFinalMapper
 
class  SymbolTable
 
class  SymbolTableIterator
 
struct  SymbolTableReadOptions
 
struct  SymbolTableTextOptions
 
class  SynchronizeFst
 
class  TimesMapper
 
class  ToGallicMapper
 
class  TopOrderQueue
 
class  TopOrderVisitor
 
class  ToPowerWeightMapper
 
class  TransformPowerWeightMapper
 
class  TrivialArcCompactor
 
struct  TrivialAStarEstimate
 
class  TrivialCompactor
 
class  TrivialComposeFilter
 
class  TrivialFilterState
 
class  TrivialLookAheadMatcher
 
class  TrivialQueue
 
struct  TrivialStateEquivClass
 
class  TropicalWeightTpl
 
class  TupleWeight
 
class  UniformArcSelector
 
class  UnionFind
 
class  UnionFst
 
class  UnionWeight
 
class  UnionWeightIterator
 
class  UnionWeightReverseIterator
 
class  UnweightedAcceptorCompactor
 
class  UnweightedCompactor
 
class  UnweightedTester
 
class  UnweightedTester< StdArc >
 
class  VectorBiTable
 
class  VectorCacheStore
 
class  VectorExpanderCache
 
class  VectorFst
 
class  VectorHashBiTable
 
class  VectorHashReplaceStateTable
 
class  VectorHashStateTable
 
class  VectorIntervalStore
 
class  VectorState
 
class  VectorStateTable
 
class  WeightApproxEqual
 
struct  WeightConvert
 
struct  WeightConvert< Log64Weight, LogWeight >
 
struct  WeightConvert< Log64Weight, SignedLog64Weight >
 
struct  WeightConvert< Log64Weight, SignedLogWeight >
 
struct  WeightConvert< Log64Weight, TropicalWeight >
 
struct  WeightConvert< LogWeight, Log64Weight >
 
struct  WeightConvert< LogWeight, SignedLog64Weight >
 
struct  WeightConvert< LogWeight, SignedLogWeight >
 
struct  WeightConvert< LogWeight, TropicalWeight >
 
struct  WeightConvert< SetWeight< Label, S1 >, SetWeight< Label, S2 > >
 
struct  WeightConvert< SignedLog64Weight, Log64Weight >
 
struct  WeightConvert< SignedLog64Weight, LogWeight >
 
struct  WeightConvert< SignedLog64Weight, SignedLogWeight >
 
struct  WeightConvert< SignedLog64Weight, TropicalWeight >
 
struct  WeightConvert< SignedLogWeight, Log64Weight >
 
struct  WeightConvert< SignedLogWeight, LogWeight >
 
struct  WeightConvert< SignedLogWeight, SignedLog64Weight >
 
struct  WeightConvert< SignedLogWeight, TropicalWeight >
 
struct  WeightConvert< TropicalWeight, Log64Weight >
 
struct  WeightConvert< TropicalWeight, LogWeight >
 
struct  WeightConvert< TropicalWeight, SignedLog64Weight >
 
struct  WeightConvert< TropicalWeight, SignedLogWeight >
 
struct  WeightConvert< W, W >
 
class  WeightConvertMapper
 
class  WeightedStringCompactor
 
class  WeightedTester
 
class  WeightFilterState
 
struct  WeightGenerate
 
class  WeightGenerate< ExpectationWeight< X1, X2 > >
 
class  WeightGenerate< GallicWeight< Label, W, G > >
 
class  WeightGenerate< GallicWeight< Label, W, GALLIC > >
 
class  WeightGenerate< LexicographicWeight< W1, W2 > >
 
class  WeightGenerate< LogWeightTpl< T > >
 
class  WeightGenerate< MinMaxWeightTpl< T > >
 
class  WeightGenerate< PairWeight< W1, W2 > >
 
class  WeightGenerate< PowerWeight< W, n > >
 
class  WeightGenerate< ProductWeight< W1, W2 > >
 
class  WeightGenerate< SetWeight< Label, S > >
 
class  WeightGenerate< SignedLogWeightTpl< T > >
 
class  WeightGenerate< SparsePowerWeight< W, K > >
 
class  WeightGenerate< StringWeight< Label, S > >
 
class  WeightGenerate< TropicalWeightTpl< T > >
 
class  WeightGenerate< UnionWeight< W, O > >
 
class  WeightTester
 

Typedefs

using StdToLogMapper = WeightConvertMapper< StdArc, LogArc >
 
using LogToStdMapper = WeightConvertMapper< LogArc, StdArc >
 
using StdToLog64Mapper = WeightConvertMapper< StdArc, Log64Arc >
 
using LogToLog64Mapper = WeightConvertMapper< LogArc, Log64Arc >
 
using Log64ToStdMapper = WeightConvertMapper< Log64Arc, StdArc >
 
using Log64ToLogMapper = WeightConvertMapper< Log64Arc, LogArc >
 
using StdArc = ArcTpl< TropicalWeight >
 
using LogArc = ArcTpl< LogWeight >
 
using Log64Arc = ArcTpl< Log64Weight >
 
using SignedLogArc = ArcTpl< SignedLogWeight >
 
using SignedLog64Arc = ArcTpl< SignedLog64Weight >
 
using MinMaxArc = ArcTpl< MinMaxWeight >
 
using ArcSortFstOptions = CacheOptions
 
template<class Compare >
using StdArcSortFst = ArcSortFst< StdArc, Compare >
 
using StdILabelCompare = ILabelCompare< StdArc >
 
using StdOLabelCompare = OLabelCompare< StdArc >
 
using StdClosureFst = ClosureFst< StdArc >
 
template<class Arc , class Unsigned >
using CompactStringFst = CompactArcFst< Arc, StringCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactWeightedStringFst = CompactArcFst< Arc, WeightedStringCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactAcceptorFst = CompactArcFst< Arc, AcceptorCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactUnweightedFst = CompactArcFst< Arc, UnweightedCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactUnweightedAcceptorFst = CompactArcFst< Arc, UnweightedAcceptorCompactor< Arc >, Unsigned >
 
using StdCompactStringFst = CompactStringFst< StdArc, uint32 >
 
using StdCompactWeightedStringFst = CompactWeightedStringFst< StdArc, uint32 >
 
using StdCompactAcceptorFst = CompactAcceptorFst< StdArc, uint32 >
 
using StdCompactUnweightedFst = CompactUnweightedFst< StdArc, uint32 >
 
using StdCompactUnweightedAcceptorFst = CompactUnweightedAcceptorFst< StdArc, uint32 >
 
using StdComplementFst = ComplementFst< StdArc >
 
using StdComposeFst = ComposeFst< StdArc >
 
using ConcatFstOptions = RationalFstOptions
 
using StdConcatFst = ConcatFst< StdArc >
 
using StdConstFst = ConstFst< StdArc >
 
using StdDeterminizeFst = DeterminizeFst< StdArc >
 
using DifferenceOptions = ComposeOptions
 
using StdDifferenceFst = DifferenceFst< StdArc >
 
using StdEncodeFst = EncodeFst< StdArc >
 
using StdDecodeFst = DecodeFst< StdArc >
 
using StdExpandedFst = ExpandedFst< StdArc >
 
template<class Expander >
using DefaultExpanderCache = VectorExpanderCache< typename Expander::Arc >
 
template<class Arc >
using PhiFst = MatcherFst< ConstFst< Arc >, PhiFstMatcher< SortedMatcher< ConstFst< Arc >>>, phi_fst_type >
 
using StdPhiFst = PhiFst< StdArc >
 
template<class Arc >
using InputPhiFst = MatcherFst< ConstFst< Arc >, PhiFstMatcher< SortedMatcher< ConstFst< Arc >>, kPhiFstMatchInput >, input_phi_fst_type >
 
using StdInputPhiFst = InputPhiFst< StdArc >
 
template<class Arc >
using OutputPhiFst = MatcherFst< ConstFst< Arc >, PhiFstMatcher< SortedMatcher< ConstFst< Arc >>, kPhiFstMatchOutput >, output_phi_fst_type >
 
using StdOutputPhiFst = OutputPhiFst< StdArc >
 
template<class Arc >
using RhoFst = MatcherFst< ConstFst< Arc >, RhoFstMatcher< SortedMatcher< ConstFst< Arc >>>, rho_fst_type >
 
using StdRhoFst = RhoFst< StdArc >
 
template<class Arc >
using InputRhoFst = MatcherFst< ConstFst< Arc >, RhoFstMatcher< SortedMatcher< ConstFst< Arc >>, kRhoFstMatchInput >, input_rho_fst_type >
 
using StdInputRhoFst = InputRhoFst< StdArc >
 
template<class Arc >
using OutputRhoFst = MatcherFst< ConstFst< Arc >, RhoFstMatcher< SortedMatcher< ConstFst< Arc >>, kRhoFstMatchOutput >, output_rho_fst_type >
 
using StdOutputRhoFst = OutputRhoFst< StdArc >
 
template<class Arc >
using SigmaFst = MatcherFst< ConstFst< Arc >, SigmaFstMatcher< SortedMatcher< ConstFst< Arc >>>, sigma_fst_type >
 
using StdSigmaFst = SigmaFst< StdArc >
 
template<class Arc >
using InputSigmaFst = MatcherFst< ConstFst< Arc >, SigmaFstMatcher< SortedMatcher< ConstFst< Arc >>, kSigmaFstMatchInput >, input_sigma_fst_type >
 
using StdInputSigmaFst = InputSigmaFst< StdArc >
 
template<class Arc >
using OutputSigmaFst = MatcherFst< ConstFst< Arc >, SigmaFstMatcher< SortedMatcher< ConstFst< Arc >>, kSigmaFstMatchOutput >, output_sigma_fst_type >
 
using StdOutputSigmaFst = OutputSigmaFst< StdArc >
 
using CharFilterState = IntegerFilterState< signed char >
 
using ShortFilterState = IntegerFilterState< short >
 
using IntFilterState = IntegerFilterState< int >
 
using FloatWeight = FloatWeightTpl< float >
 
using TropicalWeight = TropicalWeightTpl< float >
 
using LogWeight = LogWeightTpl< float >
 
using Log64Weight = LogWeightTpl< double >
 
using MinMaxWeight = MinMaxWeightTpl< float >
 
template<class Arc , class ArcCompactor , class Unsigned = uint32, class CompactStore = DefaultCompactStore<typename ArcCompactor::Element, Unsigned>, class CacheStore = DefaultCacheStore<Arc>>
using CompactArcFst = CompactFst< Arc, DefaultCompactor< ArcCompactor, Unsigned, CompactStore >, CacheStore >
 
using StdFst = Fst< StdArc >
 
using StdMutableFst = MutableFst< StdArc >
 
using StdVectorFst = VectorFst< StdArc >
 
using StdIntersectFst = IntersectFst< StdArc >
 
using StdInvertFst = InvertFst< StdArc >
 
using StdProjectFst = ProjectFst< StdArc >
 
using StdRelabelFst = RelabelFst< StdArc >
 
using StdReplaceFst = ReplaceFst< StdArc >
 
using StdRmEpsilonFst = RmEpsilonFst< StdArc >
 
using StdUnionFst = UnionFst< StdArc >
 
using IntersectOptions = ComposeOptions
 
using ReaderMutexLock = MutexLock
 
using MapFstOptions = ArcMapFstOptions
 
using StdArcLookAheadFst = MatcherFst< ConstFst< StdArc >, ArcLookAheadMatcher< SortedMatcher< ConstFst< StdArc >>>, arc_lookahead_fst_type >
 
using StdILabelLookAheadFst = MatcherFst< ConstFst< StdArc >, LabelLookAheadMatcher< SortedMatcher< ConstFst< StdArc >>, ilabel_lookahead_flags, FastLogAccumulator< StdArc >>, ilabel_lookahead_fst_type, LabelLookAheadRelabeler< StdArc >>
 
using StdOLabelLookAheadFst = MatcherFst< ConstFst< StdArc >, LabelLookAheadMatcher< SortedMatcher< ConstFst< StdArc >>, olabel_lookahead_flags, FastLogAccumulator< StdArc >>, olabel_lookahead_fst_type, LabelLookAheadRelabeler< StdArc >>
 
template<typename T >
using MemoryArena = internal::MemoryArenaImpl< sizeof(T)>
 
using StdArcSelector = LogProbArcSelector< StdArc >
 
using RationalFstOptions = CacheOptions
 
using RelabelFstOptions = CacheOptions
 
template<class Arc >
using FstList = std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >>
 
using SignedLogWeight = SignedLogWeightTpl< float >
 
using SignedLog64Weight = SignedLogWeightTpl< double >
 
using StateMapFstOptions = CacheOptions
 
using StdArcSumMapper = ArcSumMapper< StdArc >
 
using StdArcUniqueMapper = ArcUniqueMapper< StdArc >
 
using SynchronizeFstOptions = CacheOptions
 
using UnionFstOptions = RationalFstOptions
 
template<class W >
using IsIdempotent = std::integral_constant< bool,(W::Properties()&kIdempotent)!=0 >
 
template<class W >
using IsPath = std::integral_constant< bool,(W::Properties()&kPath)!=0 >
 

Enumerations

enum  MapFinalAction { MAP_NO_SUPERFINAL, MAP_ALLOW_SUPERFINAL, MAP_REQUIRE_SUPERFINAL }
 
enum  MapSymbolsAction { MAP_CLEAR_SYMBOLS, MAP_COPY_SYMBOLS, MAP_NOOP_SYMBOLS }
 
enum  HSType { HS_STL = 0, HS_DENSE = 1, HS_SPARSE = 2, HS_FLAT = 3 }
 
enum  ComposeFilter {
  AUTO_FILTER, NULL_FILTER, TRIVIAL_FILTER, SEQUENCE_FILTER,
  ALT_SEQUENCE_FILTER, MATCH_FILTER, NO_MATCH_FILTER
}
 
enum  DeterminizeType { DETERMINIZE_FUNCTIONAL, DETERMINIZE_NONFUNCTIONAL, DETERMINIZE_DISAMBIGUATE }
 
enum  EncodeType { ENCODE = 1, DECODE = 2 }
 
enum  EpsNormalizeType { EPS_NORM_INPUT, EPS_NORM_OUTPUT }
 
enum  FarEntryType { FET_LINE, FET_FILE }
 
enum  FarTokenType { FTT_SYMBOL, FTT_BYTE, FTT_UTF8 }
 
enum  FarType { FAR_DEFAULT = 0, FAR_STTABLE = 1, FAR_STLIST = 2, FAR_FST = 3 }
 
enum  MPdtType { MPDT_READ_RESTRICT, MPDT_WRITE_RESTRICT, MPDT_NO_RESTRICT }
 
enum  PdtComposeFilter { PAREN_FILTER, EXPAND_FILTER, EXPAND_PAREN_FILTER }
 
enum  PdtParserType { PDT_LEFT_PARSER, PDT_LEFT_SR_PARSER }
 
enum  MatchType {
  MATCH_INPUT = 1, MATCH_OUTPUT = 2, MATCH_BOTH = 3, MATCH_NONE = 4,
  MATCH_UNKNOWN = 5
}
 
enum  MatcherRewriteMode { MATCHER_REWRITE_AUTO = 0, MATCHER_REWRITE_ALWAYS, MATCHER_REWRITE_NEVER }
 
enum  ProjectType { PROJECT_INPUT = 1, PROJECT_OUTPUT = 2 }
 
enum  QueueType {
  TRIVIAL_QUEUE = 0, FIFO_QUEUE = 1, LIFO_QUEUE = 2, SHORTEST_FIRST_QUEUE = 3,
  TOP_ORDER_QUEUE = 4, STATE_ORDER_QUEUE = 5, SCC_QUEUE = 6, AUTO_QUEUE = 7,
  OTHER_QUEUE = 8
}
 
enum  ClosureType { CLOSURE_STAR = 0, CLOSURE_PLUS = 1 }
 
enum  ReplaceLabelType { REPLACE_LABEL_NEITHER = 1, REPLACE_LABEL_INPUT = 2, REPLACE_LABEL_OUTPUT = 3, REPLACE_LABEL_BOTH = 4 }
 
enum  ReweightType { REWEIGHT_TO_INITIAL, REWEIGHT_TO_FINAL }
 
enum  SetType { SET_INTERSECT_UNION = 0, SET_UNION_INTERSECT = 1, SET_INTERSECT_UNION_RESTRICT = 2, SET_BOOLEAN = 3 }
 
enum  StringType { STRING_LEFT = 0, STRING_RIGHT = 1, STRING_RESTRICT = 2 }
 
enum  GallicType {
  GALLIC_LEFT = 0, GALLIC_RIGHT = 1, GALLIC_RESTRICT = 2, GALLIC_MIN = 3,
  GALLIC = 4
}
 
enum  StringTokenType { SYMBOL = 1, BYTE = 2, UTF8 = 3 }
 
enum  DivideType { DIVIDE_LEFT, DIVIDE_RIGHT, DIVIDE_ANY }
 

Functions

std::string GetFarTypeString (FarType type)
 
bool IsSTList (const std::string &source)
 
int KeySize (const char *source)
 
bool IsSTTable (const std::string &source)
 
 REGISTER_FST (PhiFst, StdArc)
 
 REGISTER_FST (PhiFst, LogArc)
 
 REGISTER_FST (PhiFst, Log64Arc)
 
 REGISTER_FST (InputPhiFst, StdArc)
 
 REGISTER_FST (InputPhiFst, LogArc)
 
 REGISTER_FST (InputPhiFst, Log64Arc)
 
 REGISTER_FST (OutputPhiFst, StdArc)
 
 REGISTER_FST (OutputPhiFst, LogArc)
 
 REGISTER_FST (OutputPhiFst, Log64Arc)
 
 REGISTER_FST (RhoFst, StdArc)
 
 REGISTER_FST (RhoFst, LogArc)
 
 REGISTER_FST (RhoFst, Log64Arc)
 
 REGISTER_FST (InputRhoFst, StdArc)
 
 REGISTER_FST (InputRhoFst, LogArc)
 
 REGISTER_FST (InputRhoFst, Log64Arc)
 
 REGISTER_FST (OutputRhoFst, StdArc)
 
 REGISTER_FST (OutputRhoFst, LogArc)
 
 REGISTER_FST (OutputRhoFst, Log64Arc)
 
 REGISTER_FST (SigmaFst, StdArc)
 
 REGISTER_FST (SigmaFst, LogArc)
 
 REGISTER_FST (SigmaFst, Log64Arc)
 
 REGISTER_FST (InputSigmaFst, StdArc)
 
 REGISTER_FST (InputSigmaFst, LogArc)
 
 REGISTER_FST (InputSigmaFst, Log64Arc)
 
 REGISTER_FST (OutputSigmaFst, StdArc)
 
 REGISTER_FST (OutputSigmaFst, LogArc)
 
 REGISTER_FST (OutputSigmaFst, Log64Arc)
 
template<class A , class C >
void ArcMap (MutableFst< A > *fst, C *mapper)
 
template<class A , class C >
void ArcMap (MutableFst< A > *fst, C mapper)
 
template<class A , class B , class C >
void ArcMap (const Fst< A > &ifst, MutableFst< B > *ofst, C *mapper)
 
template<class A , class B , class C >
void ArcMap (const Fst< A > &ifst, MutableFst< B > *ofst, C mapper)
 
template<class Arc , class Compare >
void ArcSort (MutableFst< Arc > *fst, Compare comp)
 
template<class Arc >
void Closure (MutableFst< Arc > *fst, ClosureType closure_type)
 
template<class Arc >
void Closure (RationalFst< Arc > *fst, ClosureType closure_type)
 
template<class F , class G >
void Cast (const F &, G *)
 
template<class CompactArcFST , class FST >
bool WriteCompactArcFst (const FST &fst, const typename CompactArcFST::Compactor::ArcCompactor &arc_compactor, std::ostream &strm, const FstWriteOptions &opts)
 
template<class Arc , class Unsigned = uint32, class LabelIterator >
CompactStringFst< Arc, Unsigned > MakeCompactStringFst (const LabelIterator begin, const LabelIterator end)
 
template<class LabelIterator >
StdCompactStringFst MakeStdCompactStringFst (const LabelIterator begin, const LabelIterator end)
 
template<typename To , typename From >
To down_cast (From *f)
 
template<class Dest , class Source >
Dest bit_cast (const Source &source)
 
template<typename T , typename... Args>
std::unique_ptr< T > make_unique (Args &&...args)
 
template<typename T >
std::unique_ptr< T[]> make_unique (size_t n)
 
template<typename T >
std::unique_ptr< T > make_unique_default_init ()
 
template<typename T >
std::unique_ptr< T[]> make_unique_default_init (size_t n)
 
template<typename T >
std::unique_ptr< T > WrapUnique (T *ptr)
 
std::string StringJoin (const std::vector< std::string > &elements, const std::string &delim)
 
std::string StringJoin (const std::vector< std::string > &elements, const char *delim)
 
std::string StringJoin (const std::vector< std::string > &elements, char delim)
 
std::vector< std::string > StringSplit (const std::string &full, const std::string &delim)
 
std::vector< std::string > StringSplit (const std::string &full, const char *delim)
 
std::vector< std::string > StringSplit (const std::string &full, char delim)
 
void StripTrailingAsciiWhitespace (std::string *full)
 
std::string StripTrailingAsciiWhitespace (const std::string &full)
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const ComposeOptions &opts=ComposeOptions())
 
template<class Arc >
void Concat (MutableFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
void Concat (RationalFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
void Concat (const Fst< Arc > &fst1, MutableFst< Arc > *fst2)
 
template<class Arc >
void Concat (const std::vector< const Fst< Arc > * > &fsts1, MutableFst< Arc > *fst2)
 
template<class Arc >
void Concat (const Fst< Arc > &fst1, RationalFst< Arc > *fst2)
 
template<class Arc >
void Connect (MutableFst< Arc > *fst)
 
template<class Arc >
void Condense (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, std::vector< typename Arc::StateId > *scc)
 
template<class Arc >
void Determinize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, const DeterminizeOptions< Arc > &opts=DeterminizeOptions< Arc >())
 
template<class FST , class Visitor , class ArcFilter >
void DfsVisit (const FST &fst, Visitor *visitor, ArcFilter filter, bool access_only=false)
 
template<class Arc , class Visitor >
void DfsVisit (const Fst< Arc > &fst, Visitor *visitor)
 
template<class Arc >
void Difference (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const DifferenceOptions &opts=DifferenceOptions())
 
template<class Arc >
void Disambiguate (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, const DisambiguateOptions< Arc > &opts=DisambiguateOptions< Arc >())
 
template<class Arc >
void Encode (MutableFst< Arc > *fst, EncodeMapper< Arc > *mapper)
 
template<class Arc >
void Decode (MutableFst< Arc > *fst, const EncodeMapper< Arc > &mapper)
 
template<class Arc >
void EpsNormalize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, EpsNormalizeType type=EPS_NORM_INPUT)
 
template<class Arc , GallicType G>
void EpsNormalize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, EpsNormalizeType type)
 
template<class Arc , class WeightEqual >
bool Equal (const Fst< Arc > &fst1, const Fst< Arc > &fst2, WeightEqual weight_equal, uint8 etype=kEqualFsts)
 
template<class Arc >
bool Equal (const Fst< Arc > &fst1, const Fst< Arc > &fst2, float delta=kDelta, uint8 etype=kEqualFsts)
 
template<class Arc >
bool Equal (const Fst< Arc > &fst1, const Fst< Arc > &fst2, double delta, uint8 etype=kEqualFsts)
 
template<class Arc >
bool Equivalent (const Fst< Arc > &fst1, const Fst< Arc > &fst2, float delta=kDelta, bool *error=nullptr)
 
template<class Arc >
Arc::StateId CountStates (const Fst< Arc > &fst)
 
template<class Arc >
Arc::StateId CountStates (const std::vector< const Fst< Arc > * > &fsts)
 
template<class F >
size_t CountArcs (const F &fst)
 
template<class X1 , class X2 >
ExpectationWeight< X1, X2 > Plus (const ExpectationWeight< X1, X2 > &w1, const ExpectationWeight< X1, X2 > &w2)
 
template<class X1 , class X2 >
ExpectationWeight< X1, X2 > Times (const ExpectationWeight< X1, X2 > &w1, const ExpectationWeight< X1, X2 > &w2)
 
template<class X1 , class X2 >
ExpectationWeight< X1, X2 > Divide (const ExpectationWeight< X1, X2 > &w1, const ExpectationWeight< X1, X2 > &w2, DivideType typ=DIVIDE_ANY)
 
template<class Arc >
void Compress (const Fst< Arc > &fst, std::ostream &strm)
 
template<class Arc >
bool Compress (const Fst< Arc > &fst, const std::string &source, const bool gzip=false)
 
template<class Arc >
bool Decompress (std::istream &strm, const std::string &source, MutableFst< Arc > *fst)
 
template<class Arc >
bool Decompress (const std::string &source, MutableFst< Arc > *fst, const bool gzip=false)
 
template<class Arc >
void FarCompileStrings (const std::vector< std::string > &in_sources, const std::string &out_source, const std::string &fst_type, const FarType &far_type, int32 generate_keys, FarEntryType fet, FarTokenType tt, const std::string &symbols_source, const std::string &unknown_symbol, bool keep_symbols, bool initial_symbols, bool allow_negative_labels, const std::string &key_prefix, const std::string &key_suffix)
 
template<class Arc >
void FarCreate (const std::vector< std::string > &in_sources, const std::string &out_source, const int32 generate_keys, const FarType &far_type, const std::string &key_prefix, const std::string &key_suffix)
 
template<class Arc >
bool FarEqual (const std::string &source1, const std::string &source2, float delta=kDelta, const std::string &begin_key=std::string(), const std::string &end_key=std::string())
 
template<class Arc >
void FarWriteFst (const Fst< Arc > *fst, std::string key, std::string *okey, int *nrep, int32 generate_sources, int i, const std::string &source_prefix, const std::string &source_suffix)
 
template<class Arc >
void FarExtract (const std::vector< std::string > &isources, int32 generate_sources, const std::string &keys, const std::string &key_separator, const std::string &range_delimiter, const std::string &source_prefix, const std::string &source_suffix)
 
bool IsFst (const std::string &source)
 
template<class Arc >
void AccumulateStatesAndArcs (const Fst< Arc > &fst, size_t *nstate, size_t *narc, size_t *nfinal)
 
template<class Arc >
void GetFarInfo (const std::vector< std::string > &sources, const std::string &begin_key, const std::string &end_key, const bool list_fsts, FarInfoData *far_info)
 
template<class Arc >
void FarInfo (const std::vector< std::string > &sources, const std::string &begin_key, const std::string &end_key, const bool list_fsts)
 
template<class Arc >
bool FarIsomorphic (const std::string &source1, const std::string &source2, float delta=kDelta, const std::string &begin_key=std::string(), const std::string &end_key=std::string())
 
template<class Arc >
void FarPrintStrings (const std::vector< std::string > &isources, FarEntryType entry_type, FarTokenType far_token_type, const std::string &begin_key, const std::string &end_key, bool print_key, bool print_weight, const std::string &symbols_source, bool initial_symbols, int32 generate_sources, const std::string &source_prefix, const std::string &source_suffix)
 
template<class Header >
bool ReadSTListHeader (const std::string &source, Header *header)
 
template<class Header >
bool ReadSTTableHeader (const std::string &source, Header *header)
 
std::string TranslateLabel (int64 label, const SymbolTable *syms)
 
template<class Iterator >
std::string JoinLabels (Iterator begin, Iterator end, const SymbolTable *syms)
 
template<class Label >
std::string JoinLabels (const std::vector< Label > &labels, const SymbolTable *syms)
 
template<class A >
A::Label GuessStartOrEnd (std::vector< typename A::Label > *sequence, typename A::Label boundary)
 
template<class A >
void LogLinearApply (const Fst< A > &ifst, const Fst< A > &lfst, MutableFst< A > *ofst, bool normalize=true)
 
template<class A , class B >
void LogLinearApply (const Fst< A > &ifst, const Fst< A > &lfst, MutableFst< A > *ofst, bool normalize=true)
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const MPdtComposeOptions &opts=MPdtComposeOptions())
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, MutableFst< Arc > *ofst, const MPdtComposeOptions &opts=MPdtComposeOptions())
 
uint64 MPdtExpandProperties (uint64 inprops)
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, MutableFst< Arc > *ofst, const MPdtExpandOptions &opts)
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, MutableFst< Arc > *ofst, bool connect=true, bool keep_parentheses=false)
 
template<typename Label >
bool ReadLabelTriples (const std::string &source, std::vector< std::pair< Label, Label >> *pairs, std::vector< Label > *assignments, bool allow_negative=false)
 
template<typename Label >
bool WriteLabelTriples (const std::string &source, const std::vector< std::pair< Label, Label >> &pairs, const std::vector< Label > &assignments)
 
template<class Arc , class RevArc >
void Reverse (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, std::vector< typename Arc::Label > *assignments, MutableFst< RevArc > *ofst)
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const PdtComposeOptions &opts=PdtComposeOptions())
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, const PdtComposeOptions &opts=PdtComposeOptions())
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, const PdtExpandOptions< Arc > &opts)
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, bool connect=true, bool keep_parentheses=false)
 
template<class Arc >
void PrintPdtInfo (const PdtInfo< Arc > &info)
 
template<typename S , typename K >
bool operator== (const PdtStateTuple< S, K > &x, const PdtStateTuple< S, K > &y)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, std::vector< std::pair< typename Arc::Label, typename Arc::Label >> *parens, const PdtReplaceOptions< Arc > &opts)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, std::vector< std::pair< typename Arc::Label, typename Arc::Label >> *parens, typename Arc::Label root)
 
template<class Arc , class RevArc >
void Reverse (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< RevArc > *ofst)
 
template<class Arc , class Queue >
void ShortestPath (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, const PdtShortestPathOptions< Arc, Queue > &opts)
 
template<class Arc >
void ShortestPath (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst)
 
template<class T >
constexpr bool operator== (const FloatWeightTpl< T > &w1, const FloatWeightTpl< T > &w2)
 
constexpr bool operator== (const FloatWeightTpl< float > &w1, const FloatWeightTpl< float > &w2)
 
constexpr bool operator== (const FloatWeightTpl< double > &w1, const FloatWeightTpl< double > &w2)
 
template<class T >
constexpr bool operator!= (const FloatWeightTpl< T > &w1, const FloatWeightTpl< T > &w2)
 
constexpr bool operator!= (const FloatWeightTpl< float > &w1, const FloatWeightTpl< float > &w2)
 
constexpr bool operator!= (const FloatWeightTpl< double > &w1, const FloatWeightTpl< double > &w2)
 
template<class T >
constexpr bool FloatApproxEqual (T w1, T w2, float delta=kDelta)
 
template<class T >
constexpr bool ApproxEqual (const FloatWeightTpl< T > &w1, const FloatWeightTpl< T > &w2, float delta=kDelta)
 
template<class T >
std::ostream & operator<< (std::ostream &strm, const FloatWeightTpl< T > &w)
 
template<class T >
std::istream & operator>> (std::istream &strm, FloatWeightTpl< T > &w)
 
template<class T >
constexpr TropicalWeightTpl< T > Plus (const TropicalWeightTpl< T > &w1, const TropicalWeightTpl< T > &w2)
 
constexpr TropicalWeightTpl< float > Plus (const TropicalWeightTpl< float > &w1, const TropicalWeightTpl< float > &w2)
 
constexpr TropicalWeightTpl< double > Plus (const TropicalWeightTpl< double > &w1, const TropicalWeightTpl< double > &w2)
 
template<class T >
constexpr TropicalWeightTpl< T > Times (const TropicalWeightTpl< T > &w1, const TropicalWeightTpl< T > &w2)
 
constexpr TropicalWeightTpl< float > Times (const TropicalWeightTpl< float > &w1, const TropicalWeightTpl< float > &w2)
 
constexpr TropicalWeightTpl< double > Times (const TropicalWeightTpl< double > &w1, const TropicalWeightTpl< double > &w2)
 
template<class T >
constexpr TropicalWeightTpl< T > Divide (const TropicalWeightTpl< T > &w1, const TropicalWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr TropicalWeightTpl< float > Divide (const TropicalWeightTpl< float > &w1, const TropicalWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr TropicalWeightTpl< double > Divide (const TropicalWeightTpl< double > &w1, const TropicalWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T , class V , bool Enable = !std::is_same<V, size_t>::value, typename std::enable_if< Enable >::type * = nullptr>
constexpr TropicalWeightTpl< T > Power (const TropicalWeightTpl< T > &w, V n)
 
template<>
constexpr TropicalWeightTpl< float > Power< TropicalWeightTpl< float > > (const TropicalWeightTpl< float > &weight, size_t n)
 
template<>
constexpr TropicalWeightTpl< double > Power< TropicalWeightTpl< double > > (const TropicalWeightTpl< double > &weight, size_t n)
 
template<class T >
LogWeightTpl< T > Plus (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
LogWeightTpl< float > Plus (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2)
 
LogWeightTpl< double > Plus (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2)
 
template<class T >
constexpr LogWeightTpl< T > Times (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
constexpr LogWeightTpl< float > Times (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2)
 
constexpr LogWeightTpl< double > Times (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2)
 
template<class T >
constexpr LogWeightTpl< T > Divide (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr LogWeightTpl< float > Divide (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr LogWeightTpl< double > Divide (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T , class V , bool Enable = !std::is_same<V, size_t>::value, typename std::enable_if< Enable >::type * = nullptr>
constexpr LogWeightTpl< T > Power (const LogWeightTpl< T > &w, V n)
 
template<>
constexpr LogWeightTpl< float > Power< LogWeightTpl< float > > (const LogWeightTpl< float > &weight, size_t n)
 
template<>
constexpr LogWeightTpl< double > Power< LogWeightTpl< double > > (const LogWeightTpl< double > &weight, size_t n)
 
template<class T >
constexpr MinMaxWeightTpl< T > Plus (const MinMaxWeightTpl< T > &w1, const MinMaxWeightTpl< T > &w2)
 
constexpr MinMaxWeightTpl< float > Plus (const MinMaxWeightTpl< float > &w1, const MinMaxWeightTpl< float > &w2)
 
constexpr MinMaxWeightTpl< double > Plus (const MinMaxWeightTpl< double > &w1, const MinMaxWeightTpl< double > &w2)
 
template<class T >
constexpr MinMaxWeightTpl< T > Times (const MinMaxWeightTpl< T > &w1, const MinMaxWeightTpl< T > &w2)
 
constexpr MinMaxWeightTpl< float > Times (const MinMaxWeightTpl< float > &w1, const MinMaxWeightTpl< float > &w2)
 
constexpr MinMaxWeightTpl< double > Times (const MinMaxWeightTpl< double > &w1, const MinMaxWeightTpl< double > &w2)
 
template<class T >
constexpr MinMaxWeightTpl< T > Divide (const MinMaxWeightTpl< T > &w1, const MinMaxWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr MinMaxWeightTpl< float > Divide (const MinMaxWeightTpl< float > &w1, const MinMaxWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr MinMaxWeightTpl< double > Divide (const MinMaxWeightTpl< double > &w1, const MinMaxWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
bool IsFstHeader (std::istream &, const std::string &)
 
template<class FST >
void Destroy (ArcIterator< FST > *aiter, MemoryPool< ArcIterator< FST >> *pool)
 
template<class Arc >
uint64 TestProperties (const Fst< Arc > &fst, uint64 mask, uint64 *known)
 
template<class IFST , class OFST >
void Cast (const IFST &ifst, OFST *ofst)
 
template<class Arc >
std::string FstToString (const Fst< Arc > &fst, const FstWriteOptions &options=FstWriteOptions("FstToString"))
 
template<class Arc >
void FstToString (const Fst< Arc > &fst, std::string *result)
 
template<class Arc >
void FstToString (const Fst< Arc > &fst, std::string *result, const FstWriteOptions &options)
 
template<class Arc >
Fst< Arc > * StringToFst (const std::string &s)
 
template<class Label >
bool ByteStringToLabels (const std::string &str, std::vector< Label > *labels)
 
template<class Label >
bool UTF8StringToLabels (const std::string &str, std::vector< Label > *labels)
 
template<class Label >
bool LabelsToByteString (const std::vector< Label > &labels, std::string *str)
 
template<class Label >
bool LabelsToUTF8String (const std::vector< Label > &labels, std::string *str)
 
template<class Arc >
void Intersect (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const IntersectOptions &opts=IntersectOptions())
 
template<typename T , class Store >
std::ostream & operator<< (std::ostream &strm, const IntervalSet< T, Store > &s)
 
template<class Arc >
void Invert (const Fst< Arc > &ifst, MutableFst< Arc > *ofst)
 
template<class Arc >
void Invert (MutableFst< Arc > *fst)
 
template<class Arc >
bool Isomorphic (const Fst< Arc > &fst1, const Fst< Arc > &fst2, float delta=kDelta)
 
template<typename Label , typename StateId >
bool StateSort (std::vector< IntervalSet< Label >> *interval_sets, const std::vector< StateId > &order)
 
template<typename Label , typename StateId >
bool StateSort (LabelReachableData< Label > *data, const std::vector< StateId > &order)
 
template<class W1 , class W2 >
LexicographicWeight< W1, W2 > Plus (const LexicographicWeight< W1, W2 > &w, const LexicographicWeight< W1, W2 > &v)
 
template<class W1 , class W2 >
LexicographicWeight< W1, W2 > Times (const LexicographicWeight< W1, W2 > &w, const LexicographicWeight< W1, W2 > &v)
 
template<class W1 , class W2 >
LexicographicWeight< W1, W2 > Divide (const LexicographicWeight< W1, W2 > &w, const LexicographicWeight< W1, W2 > &v, DivideType typ=DIVIDE_ANY)
 
template<class Matcher1 , class Matcher2 >
MatchType LookAheadMatchType (const Matcher1 &m1, const Matcher2 &m2)
 
template<class Arc >
MatchType LookAheadMatchType (const Fst< Arc > &fst1, const Fst< Arc > &fst2)
 
template<class A , class C >
void Map (MutableFst< A > *fst, C *mapper)
 
template<class A , class C >
void Map (MutableFst< A > *fst, C mapper)
 
template<class A , class B , class C >
void Map (const Fst< A > &ifst, MutableFst< B > *ofst, C *mapper)
 
template<class A , class B , class C >
void Map (const Fst< A > &ifst, MutableFst< B > *ofst, C mapper)
 
template<typename T , typename U >
bool operator== (const BlockAllocator< T > &alloc1, const BlockAllocator< U > &alloc2)
 
template<typename T , typename U >
bool operator!= (const BlockAllocator< T > &alloc1, const BlockAllocator< U > &alloc2)
 
template<typename T , typename U >
bool operator== (const PoolAllocator< T > &alloc1, const PoolAllocator< U > &alloc2)
 
template<typename T , typename U >
bool operator!= (const PoolAllocator< T > &alloc1, const PoolAllocator< U > &alloc2)
 
template<class Arc >
void Minimize (MutableFst< Arc > *fst, MutableFst< Arc > *sfst=nullptr, float delta=kShortestDelta, bool allow_nondet=false)
 
template<class W1 , class W2 >
bool operator== (const PairWeight< W1, W2 > &w1, const PairWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
bool operator!= (const PairWeight< W1, W2 > &w1, const PairWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
bool ApproxEqual (const PairWeight< W1, W2 > &w1, const PairWeight< W1, W2 > &w2, float delta=kDelta)
 
template<class W1 , class W2 >
std::ostream & operator<< (std::ostream &strm, const PairWeight< W1, W2 > &weight)
 
template<class W1 , class W2 >
std::istream & operator>> (std::istream &strm, PairWeight< W1, W2 > &weight)
 
template<class W , size_t n>
PowerWeight< W, n > Plus (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2)
 
template<class W , size_t n>
PowerWeight< W, n > Times (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2)
 
template<class W , size_t n>
PowerWeight< W, n > Divide (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2, DivideType type=DIVIDE_ANY)
 
template<class W , size_t n>
PowerWeight< W, n > Times (const W &scalar, const PowerWeight< W, n > &weight)
 
template<class W , size_t n>
PowerWeight< W, n > Times (const PowerWeight< W, n > &weight, const W &scalar)
 
template<class W , size_t n>
DotProduct (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2)
 
template<class W1 , class W2 >
ProductWeight< W1, W2 > Plus (const ProductWeight< W1, W2 > &w1, const ProductWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
ProductWeight< W1, W2 > Times (const ProductWeight< W1, W2 > &w1, const ProductWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
ProductWeight< W1, W2 > Divide (const ProductWeight< W1, W2 > &w1, const ProductWeight< W1, W2 > &w2, DivideType typ=DIVIDE_ANY)
 
template<class Arc >
void Project (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, ProjectType project_type)
 
template<class Arc >
void Project (MutableFst< Arc > *fst, ProjectType project_type)
 
uint64 SetStartProperties (uint64 inprops)
 
template<typename Weight >
uint64 SetFinalProperties (uint64 inprops, const Weight &old_weight, const Weight &new_weight)
 
uint64 AddStateProperties (uint64 inprops)
 
template<typename A >
uint64 AddArcProperties (uint64 inprops, typename A::StateId s, const A &arc, const A *prev_arc)
 
uint64 DeleteStatesProperties (uint64 inprops)
 
uint64 DeleteAllStatesProperties (uint64 inprops, uint64 staticProps)
 
uint64 DeleteArcsProperties (uint64 inprops)
 
uint64 ClosureProperties (uint64 inprops, bool star, bool delayed=false)
 
uint64 ComplementProperties (uint64 inprops)
 
uint64 ComposeProperties (uint64 inprops1, uint64 inprops2)
 
uint64 ConcatProperties (uint64 inprops1, uint64 inprops2, bool delayed=false)
 
uint64 DeterminizeProperties (uint64 inprops, bool has_subsequential_label, bool distinct_psubsequential_labels)
 
uint64 FactorWeightProperties (uint64 inprops)
 
uint64 InvertProperties (uint64 inprops)
 
uint64 ProjectProperties (uint64 inprops, bool project_input)
 
uint64 RandGenProperties (uint64 inprops, bool weighted)
 
uint64 RelabelProperties (uint64 inprops)
 
uint64 ReplaceProperties (const std::vector< uint64 > &inprops, size_t root, bool epsilon_on_call, bool epsilon_on_return, bool out_epsilon_on_call, bool out_epsilon_on_return, bool replace_transducer, bool no_empty_fst, bool all_ilabel_sorted, bool all_olabel_sorted, bool all_negative_or_dense)
 
uint64 ReverseProperties (uint64 inprops, bool has_superinitial)
 
uint64 ReweightProperties (uint64 inprops)
 
uint64 RmEpsilonProperties (uint64 inprops, bool delayed=false)
 
uint64 ShortestPathProperties (uint64 props, bool tree=false)
 
uint64 SynchronizeProperties (uint64 inprops)
 
uint64 UnionProperties (uint64 inprops1, uint64 inprops2, bool delayed=false)
 
template<typename Arc >
uint64 AddArcProperties (uint64 inprops, typename Arc::StateId s, const Arc &arc, const Arc *prev_arc)
 
template<class Arc , class ArcFilter , typename std::enable_if<(Arc::Weight::Properties()&kPath)==kPath >::type * = nullptr>
void Prune (MutableFst< Arc > *fst, const PruneOptions< Arc, ArcFilter > &opts=PruneOptions< Arc, ArcFilter >())
 
template<class Arc >
void Prune (MutableFst< Arc > *fst, typename Arc::Weight weight_threshold, typename Arc::StateId state_threshold=kNoStateId, float delta=kDelta)
 
template<class Arc , class ArcFilter , typename std::enable_if< IsPath< typename Arc::Weight >::value >::type * = nullptr>
void Prune (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, const PruneOptions< Arc, ArcFilter > &opts=PruneOptions< Arc, ArcFilter >())
 
template<class Arc >
void Prune (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, typename Arc::Weight weight_threshold, typename Arc::StateId state_threshold=kNoStateId, float delta=kDelta)
 
template<class Arc >
Arc::Weight ComputeTotalWeight (const Fst< Arc > &fst, const std::vector< typename Arc::Weight > &distance, bool reverse)
 
template<class Arc >
void RemoveWeight (MutableFst< Arc > *fst, const typename Arc::Weight &weight, bool at_final)
 
template<class Arc >
void Push (MutableFst< Arc > *fst, ReweightType type, float delta=kShortestDelta, bool remove_total_weight=false)
 
template<class Arc , ReweightType rtype>
void Push (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, uint8 ptype, float delta=kShortestDelta)
 
template<class Arc , class ArcSelector >
bool RandEquivalent (const Fst< Arc > &fst1, const Fst< Arc > &fst2, int32 num_paths, float delta, const RandGenOptions< ArcSelector > &opts, bool *error=nullptr)
 
template<class Arc >
bool RandEquivalent (const Fst< Arc > &fst1, const Fst< Arc > &fst2, int32 num_paths, float delta=kDelta, time_t seed=time(nullptr), int32 max_length=std::numeric_limits< int32 >::max(), bool *error=nullptr)
 
template<class Result , class RNG >
void OneMultinomialSample (const std::vector< double > &probs, size_t num_to_sample, Result *result, RNG *rng)
 
template<class FromArc , class ToArc , class Selector >
void RandGen (const Fst< FromArc > &ifst, MutableFst< ToArc > *ofst, const RandGenOptions< Selector > &opts)
 
template<class FromArc , class ToArc >
void RandGen (const Fst< FromArc > &ifst, MutableFst< ToArc > *ofst)
 
template<class Arc >
void Union (RationalFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
Fst< Arc > * Convert (const Fst< Arc > &fst, const std::string &fst_type)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &ipairs, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &opairs)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const SymbolTable *old_isymbols, const SymbolTable *new_isymbols, const std::string &unknown_isymbol, bool attach_new_isymbols, const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, const std::string &unknown_osymbol, bool attach_new_osymbols)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const SymbolTable *old_isymbols, const SymbolTable *new_isymbols, bool attach_new_isymbols, const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, bool attach_new_osymbols)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const SymbolTable *new_isymbols, const SymbolTable *new_osymbols)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &, MutableFst< Arc > *, const ReplaceUtilOptions &)
 
template<class StateId , class PrefixId >
bool operator== (const ReplaceStateTuple< StateId, PrefixId > &x, const ReplaceStateTuple< StateId, PrefixId > &y)
 
template<class Label , class StateId >
bool operator== (const ReplaceStackPrefix< Label, StateId > &x, const ReplaceStackPrefix< Label, StateId > &y)
 
bool EpsilonOnInput (ReplaceLabelType label_type)
 
bool EpsilonOnOutput (ReplaceLabelType label_type)
 
template<class Label >
bool ReplaceTransducer (ReplaceLabelType call_label_type, ReplaceLabelType return_label_type, Label call_output_label)
 
template<class Arc >
uint64 ReplaceFstProperties (typename Arc::Label root_label, const FstList< Arc > &fst_list, ReplaceLabelType call_label_type, ReplaceLabelType return_label_type, typename Arc::Label call_output_label, bool *sorted_and_non_empty)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, ReplaceFstOptions< Arc > opts=ReplaceFstOptions< Arc >())
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, typename Arc::Label root, bool epsilon_on_replace)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, typename Arc::Label root)
 
template<class FromArc , class ToArc >
void Reverse (const Fst< FromArc > &ifst, MutableFst< ToArc > *ofst, bool require_superinitial=true)
 
template<class Arc >
void Reweight (MutableFst< Arc > *fst, const std::vector< typename Arc::Weight > &potential, ReweightType type)
 
template<class Arc , class Queue >
void RmEpsilon (MutableFst< Arc > *fst, std::vector< typename Arc::Weight > *distance, const RmEpsilonOptions< Arc, Queue > &opts)
 
template<class Arc >
void RmEpsilon (MutableFst< Arc > *fst, bool connect=true, typename Arc::Weight weight_threshold=Arc::Weight::Zero(), typename Arc::StateId state_threshold=kNoStateId, float delta=kShortestDelta)
 
template<class Arc >
void RmFinalEpsilon (MutableFst< Arc > *fst)
 
template<typename Label , SetType S>
bool operator== (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label >
bool operator== (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2)
 
template<typename Label , SetType S>
bool operator!= (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
bool ApproxEqual (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2, float delta=kDelta)
 
template<typename Label , SetType S>
std::ostream & operator<< (std::ostream &strm, const SetWeight< Label, S > &weight)
 
template<typename Label , SetType S>
std::istream & operator>> (std::istream &strm, SetWeight< Label, S > &weight)
 
template<typename Label , SetType S>
SetWeight< Label, S > Union (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Intersect (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Difference (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Plus (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label >
SetWeight< Label, SET_UNION_INTERSECTPlus (const SetWeight< Label, SET_UNION_INTERSECT > &w1, const SetWeight< Label, SET_UNION_INTERSECT > &w2)
 
template<typename Label >
SetWeight< Label, SET_INTERSECT_UNION_RESTRICTPlus (const SetWeight< Label, SET_INTERSECT_UNION_RESTRICT > &w1, const SetWeight< Label, SET_INTERSECT_UNION_RESTRICT > &w2)
 
template<typename Label >
SetWeight< Label, SET_BOOLEANPlus (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Times (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label >
SetWeight< Label, SET_UNION_INTERSECTTimes (const SetWeight< Label, SET_UNION_INTERSECT > &w1, const SetWeight< Label, SET_UNION_INTERSECT > &w2)
 
template<typename Label >
SetWeight< Label, SET_BOOLEANTimes (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Divide (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<typename Label >
SetWeight< Label, SET_UNION_INTERSECTDivide (const SetWeight< Label, SET_UNION_INTERSECT > &w1, const SetWeight< Label, SET_UNION_INTERSECT > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<typename Label >
SetWeight< Label, SET_BOOLEANDivide (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<class Arc , class Queue , class ArcFilter >
void ShortestDistance (const Fst< Arc > &fst, std::vector< typename Arc::Weight > *distance, const ShortestDistanceOptions< Arc, Queue, ArcFilter > &opts)
 
template<class Arc >
void ShortestDistance (const Fst< Arc > &fst, std::vector< typename Arc::Weight > *distance, bool reverse=false, float delta=kShortestDelta)
 
template<class Arc >
Arc::Weight ShortestDistance (const Fst< Arc > &fst, float delta=kShortestDelta)
 
template<class Arc , class Queue , class ArcFilter , typename std::enable_if< IsPath< typename Arc::Weight >::value >::type * = nullptr>
void ShortestPath (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, std::vector< typename Arc::Weight > *distance, const ShortestPathOptions< Arc, Queue, ArcFilter > &opts)
 
template<class Arc >
void ShortestPath (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, int32 nshortest=1, bool unique=false, bool first_path=false, typename Arc::Weight weight_threshold=Arc::Weight::Zero(), typename Arc::StateId state_threshold=kNoStateId, float delta=kShortestDelta)
 
template<class T >
SignedLogWeightTpl< T > Plus (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Minus (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Times (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Divide (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T >
bool ApproxEqual (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2, float delta=kDelta)
 
template<class T >
bool operator== (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
bool operator!= (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class W1 , class W2 >
bool SignedLogConvertCheck (W1 weight)
 
template<class W , class K , class M >
SparsePowerWeight< W, K > SparsePowerWeightMap (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2, const M &operator_mapper)
 
template<class W , class K >
SparsePowerWeight< W, K > Plus (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Times (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Divide (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2, DivideType type=DIVIDE_ANY)
 
template<class W , class K >
const W & DotProduct (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
bool ApproxEqual (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2, float delta=kDelta)
 
template<class W , class K >
SparsePowerWeight< W, K > Times (const W &k, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Times (const SparsePowerWeight< W, K > &w1, const W &k)
 
template<class W , class K >
SparsePowerWeight< W, K > Divide (const SparsePowerWeight< W, K > &w1, const W &k, DivideType divide_type=DIVIDE_ANY)
 
template<class W , class K , class M >
void SparseTupleWeightMap (SparseTupleWeight< W, K > *result, const SparseTupleWeight< W, K > &w1, const SparseTupleWeight< W, K > &w2, const M &operator_mapper)
 
template<class W , class K >
bool operator== (const SparseTupleWeight< W, K > &w1, const SparseTupleWeight< W, K > &w2)
 
template<class W , class K >
bool operator!= (const SparseTupleWeight< W, K > &w1, const SparseTupleWeight< W, K > &w2)
 
template<class W , class K >
std::ostream & operator<< (std::ostream &strm, const SparseTupleWeight< W, K > &weight)
 
template<class W , class K >
std::istream & operator>> (std::istream &strm, SparseTupleWeight< W, K > &weight)
 
template<class A , class C >
void StateMap (MutableFst< A > *fst, C *mapper)
 
template<class A , class C >
void StateMap (MutableFst< A > *fst, C mapper)
 
template<class A , class B , class C >
void StateMap (const Fst< A > &ifst, MutableFst< B > *ofst, C *mapper)
 
template<class A , class B , class C >
void StateMap (const Fst< A > &ifst, MutableFst< B > *ofst, C mapper)
 
template<class Arc >
void StateSort (MutableFst< Arc > *fst, const std::vector< typename Arc::StateId > &order)
 
constexpr StringType ReverseStringType (StringType s)
 
template<typename Label , StringType S>
bool operator== (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
bool operator!= (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
bool ApproxEqual (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2, float delta=kDelta)
 
template<typename Label , StringType S>
std::ostream & operator<< (std::ostream &strm, const StringWeight< Label, S > &weight)
 
template<typename Label , StringType S>
std::istream & operator>> (std::istream &strm, StringWeight< Label, S > &weight)
 
template<typename Label , StringType S>
StringWeight< Label, S > Plus (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label >
StringWeight< Label, STRING_LEFTPlus (const StringWeight< Label, STRING_LEFT > &w1, const StringWeight< Label, STRING_LEFT > &w2)
 
template<typename Label >
StringWeight< Label, STRING_RIGHTPlus (const StringWeight< Label, STRING_RIGHT > &w1, const StringWeight< Label, STRING_RIGHT > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > Times (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > DivideLeft (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > DivideRight (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > Divide (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2, DivideType divide_type)
 
template<typename Label >
StringWeight< Label, STRING_LEFTDivide (const StringWeight< Label, STRING_LEFT > &w1, const StringWeight< Label, STRING_LEFT > &w2, DivideType divide_type)
 
template<typename Label >
StringWeight< Label, STRING_RIGHTDivide (const StringWeight< Label, STRING_RIGHT > &w1, const StringWeight< Label, STRING_RIGHT > &w2, DivideType divide_type)
 
constexpr StringType GallicStringType (GallicType g)
 
constexpr GallicType ReverseGallicType (GallicType g)
 
template<class Label , class W , GallicType G>
GallicWeight< Label, W, G > Plus (const GallicWeight< Label, W, G > &w, const GallicWeight< Label, W, G > &v)
 
template<class Label , class W >
GallicWeight< Label, W, GALLIC_MINPlus (const GallicWeight< Label, W, GALLIC_MIN > &w1, const GallicWeight< Label, W, GALLIC_MIN > &w2)
 
template<class Label , class W , GallicType G>
GallicWeight< Label, W, G > Times (const GallicWeight< Label, W, G > &w, const GallicWeight< Label, W, G > &v)
 
template<class Label , class W , GallicType G>
GallicWeight< Label, W, G > Divide (const GallicWeight< Label, W, G > &w, const GallicWeight< Label, W, G > &v, DivideType divide_type=DIVIDE_ANY)
 
template<class Label , class W >
GallicWeight< Label, W, GALLICPlus (const GallicWeight< Label, W, GALLIC > &w1, const GallicWeight< Label, W, GALLIC > &w2)
 
template<class Label , class W >
GallicWeight< Label, W, GALLICTimes (const GallicWeight< Label, W, GALLIC > &w1, const GallicWeight< Label, W, GALLIC > &w2)
 
template<class Label , class W >
GallicWeight< Label, W, GALLICDivide (const GallicWeight< Label, W, GALLIC > &w1, const GallicWeight< Label, W, GALLIC > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<class Arc >
bool StringFstToOutputLabels (const Fst< Arc > &fst, std::vector< typename Arc::Label > *labels)
 
template<class Label >
bool LabelsToString (const std::vector< Label > &labels, std::string *str, StringTokenType ttype=BYTE, const SymbolTable *syms=nullptr, const std::string &sep=FLAGS_fst_field_separator)
 
template<class Arc >
SymbolTablePruneSymbolTable (const Fst< Arc > &fst, const SymbolTable &syms, bool input)
 
SymbolTableCompactSymbolTable (const SymbolTable &syms)
 
SymbolTableMergeSymbolTable (const SymbolTable &left, const SymbolTable &right, bool *right_relabel_output=nullptr)
 
SymbolTableFstReadSymbols (const std::string &source, bool input)
 
bool AddAuxiliarySymbols (const std::string &prefix, int64 start_label, int64 nlabels, SymbolTable *syms)
 
template<class Label >
SymbolTableRelabelSymbolTable (const SymbolTable *table, const std::vector< std::pair< Label, Label >> &pairs)
 
bool CompatSymbols (const SymbolTable *syms1, const SymbolTable *syms2, bool warning=true)
 
void SymbolTableToString (const SymbolTable *table, std::string *result)
 
SymbolTableStringToSymbolTable (const std::string &str)
 
template<class Arc >
void Synchronize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst)
 
template<class Arc >
void LookAheadCompose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst)
 
void LookAheadCompose (const Fst< StdArc > &ifst1, const Fst< StdArc > &ifst2, MutableFst< StdArc > *ofst)
 
template<class Arc , class WeightGenerator >
void RandFst (const int num_random_states, const int num_random_arcs, const int num_random_labels, const float acyclic_prob, WeightGenerator *weight_generator, MutableFst< Arc > *fst)
 
uint64 KnownProperties (uint64 props)
 
bool CompatProperties (uint64 props1, uint64 props2)
 
template<class Arc >
uint64 ComputeProperties (const Fst< Arc > &fst, uint64 mask, uint64 *known, bool use_stored)
 
template<class Arc >
uint64 CheckProperties (const Fst< Arc > &fst, uint64 check_mask, uint64 test_mask)
 
template<class Arc >
bool TopSort (MutableFst< Arc > *fst)
 
template<class W , size_t n>
bool operator== (const TupleWeight< W, n > &w1, const TupleWeight< W, n > &w2)
 
template<class W , size_t n>
bool operator!= (const TupleWeight< W, n > &w1, const TupleWeight< W, n > &w2)
 
template<class W , size_t n>
bool ApproxEqual (const TupleWeight< W, n > &w1, const TupleWeight< W, n > &w2, float delta=kDelta)
 
template<class W , size_t n>
std::ostream & operator<< (std::ostream &strm, const TupleWeight< W, n > &w)
 
template<class W , size_t n>
std::istream & operator>> (std::istream &strm, TupleWeight< W, n > &w)
 
template<class W , class O >
bool operator== (const UnionWeight< W, O > &, const UnionWeight< W, O > &)
 
template<class W , class O >
bool operator!= (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2)
 
template<class W , class O >
bool ApproxEqual (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2, float delta=kDelta)
 
template<class W , class O >
std::ostream & operator<< (std::ostream &ostrm, const UnionWeight< W, O > &weight)
 
template<class W , class O >
std::istream & operator>> (std::istream &istrm, UnionWeight< W, O > &weight)
 
template<class W , class O >
UnionWeight< W, O > Plus (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2)
 
template<class W , class O >
UnionWeight< W, O > Times (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2)
 
template<class W , class O >
UnionWeight< W, O > Divide (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2, DivideType typ)
 
template<class Arc >
void Union (MutableFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
void Union (MutableFst< Arc > *fst1, const std::vector< const Fst< Arc > * > &fsts2)
 
template<class T , typename std::enable_if< std::is_class< T >::value, T >::type * = nullptr>
std::istream & ReadType (std::istream &strm, T *t)
 
std::istream & ReadType (std::istream &strm, std::string *s)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::vector< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::list< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::set< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::map< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::unordered_map< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::unordered_set< T... > *c)
 
template<typename S , typename T >
std::istream & ReadType (std::istream &strm, std::pair< S, T > *p)
 
template<typename S , typename T >
std::istream & ReadType (std::istream &strm, std::pair< const S, T > *p)
 
template<class T , size_t N>
std::istream & ReadType (std::istream &strm, std::array< T, N > *c)
 
template<class T , typename std::enable_if< std::is_class< T >::value, T >::type * = nullptr>
std::ostream & WriteType (std::ostream &strm, const T t)
 
std::ostream & WriteType (std::ostream &strm, const std::string &s)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::vector< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::list< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::set< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::map< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::unordered_map< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::unordered_set< T... > &c)
 
template<typename S , typename T >
std::ostream & WriteType (std::ostream &strm, const std::pair< S, T > &p)
 
template<class T , size_t N>
std::ostream & WriteType (std::ostream &strm, const std::array< T, N > &c)
 
int64 StrToInt64 (const std::string &s, const std::string &source, size_t nline, bool allow_negative, bool *error=nullptr)
 
template<typename Weight >
Weight StrToWeight (const std::string &s)
 
template<typename Weight >
void WeightToStr (Weight w, std::string *s)
 
void SplitString (char *line, const char *delim, std::vector< char * > *vec, bool omit_empty_strings)
 
template<typename I >
bool ReadIntPairs (const std::string &source, std::vector< std::pair< I, I >> *pairs, bool allow_negative=false)
 
template<typename I >
bool WriteIntPairs (const std::string &source, const std::vector< std::pair< I, I >> &pairs)
 
template<typename Label >
bool ReadLabelPairs (const std::string &source, std::vector< std::pair< Label, Label >> *pairs, bool allow_negative=false)
 
template<typename Label >
bool WriteLabelPairs (const std::string &source, const std::vector< std::pair< Label, Label >> &pairs)
 
void ConvertToLegalCSymbol (std::string *s)
 
bool AlignInput (std::istream &strm)
 
bool AlignOutput (std::ostream &strm)
 
template<class Arc >
bool Verify (const Fst< Arc > &fst, bool allow_negative_labels=false)
 
template<class FST , class Visitor , class Queue , class ArcFilter >
void Visit (const FST &fst, Visitor *visitor, Queue *queue, ArcFilter filter, bool access_only=false)
 
template<class Arc , class Visitor , class Queue >
void Visit (const Fst< Arc > &fst, Visitor *visitor, Queue *queue)
 
template<class Weight >
Weight Power (const Weight &weight, size_t n)
 
 REGISTER_FST (VectorFst, StdArc)
 
 REGISTER_FST (VectorFst, LogArc)
 
 REGISTER_FST (VectorFst, Log64Arc)
 
 REGISTER_FST (ConstFst, StdArc)
 
 REGISTER_FST (ConstFst, LogArc)
 
 REGISTER_FST (ConstFst, Log64Arc)
 
 REGISTER_FST (EditFst, StdArc)
 
 REGISTER_FST (EditFst, LogArc)
 
 REGISTER_FST (EditFst, Log64Arc)
 
 REGISTER_FST (CompactStringFst, StdArc)
 
 REGISTER_FST (CompactStringFst, LogArc)
 
 REGISTER_FST (CompactStringFst, Log64Arc)
 
 REGISTER_FST (CompactWeightedStringFst, StdArc)
 
 REGISTER_FST (CompactWeightedStringFst, LogArc)
 
 REGISTER_FST (CompactWeightedStringFst, Log64Arc)
 
 REGISTER_FST (CompactAcceptorFst, StdArc)
 
 REGISTER_FST (CompactAcceptorFst, LogArc)
 
 REGISTER_FST (CompactAcceptorFst, Log64Arc)
 
 REGISTER_FST (CompactUnweightedFst, StdArc)
 
 REGISTER_FST (CompactUnweightedFst, LogArc)
 
 REGISTER_FST (CompactUnweightedFst, Log64Arc)
 
 REGISTER_FST (CompactUnweightedAcceptorFst, StdArc)
 
 REGISTER_FST (CompactUnweightedAcceptorFst, LogArc)
 
 REGISTER_FST (CompactUnweightedAcceptorFst, Log64Arc)
 
int AlignBufferWithOutputStream (std::ostream &strm, std::ostringstream &buffer)
 

Variables

const char phi_fst_type [] = "phi"
 
const char input_phi_fst_type [] = "input_phi"
 
const char output_phi_fst_type [] = "output_phi"
 
const char rho_fst_type [] = "rho"
 
const char input_rho_fst_type [] = "input_rho"
 
const char output_rho_fst_type [] = "output_rho"
 
const char sigma_fst_type [] = "sigma"
 
const char input_sigma_fst_type [] = "input_sigma"
 
const char output_sigma_fst_type [] = "output_sigma"
 
constexpr uint8 kCacheFinal = 0x01
 
constexpr uint8 kCacheArcs = 0x02
 
constexpr uint8 kCacheInit = 0x04
 
constexpr uint8 kCacheRecent = 0x08
 
constexpr uint8 kCacheFlags
 
constexpr uint8 kEqualFsts = 0x01
 
constexpr uint8 kEqualFstTypes = 0x02
 
constexpr uint8 kEqualCompatProperties = 0x04
 
constexpr uint8 kEqualCompatSymbols = 0x08
 
constexpr uint8 kEqualAll
 
constexpr uint32 kGzipMask = 0xffffffff >> 16
 
const int kNoTrieNodeId = -1
 
constexpr uint32 kParenList = 0x00000001
 
constexpr uint32 kParenLoop = 0x00000002
 
constexpr uint8 kPhiFstMatchInput = 0x01
 
constexpr uint8 kPhiFstMatchOutput = 0x02
 
constexpr uint8 kRhoFstMatchInput = 0x01
 
constexpr uint8 kRhoFstMatchOutput = 0x02
 
constexpr uint8 kSigmaFstMatchInput = 0x01
 
constexpr uint8 kSigmaFstMatchOutput = 0x02
 
constexpr uint8 kFactorFinalWeights = 0x01
 
constexpr uint8 kFactorArcWeights = 0x02
 
constexpr int kNoLabel = -1
 
constexpr int kNoStateId = -1
 
constexpr uint32 kInputLookAheadMatcher = 0x00000010
 
constexpr uint32 kOutputLookAheadMatcher = 0x00000020
 
constexpr uint32 kLookAheadWeight = 0x00000040
 
constexpr uint32 kLookAheadPrefix = 0x00000080
 
constexpr uint32 kLookAheadNonEpsilons = 0x00000100
 
constexpr uint32 kLookAheadEpsilons = 0x00000200
 
constexpr uint32 kLookAheadNonEpsilonPrefix = 0x00000400
 
constexpr uint32 kLookAheadKeepRelabelData = 0x00000800
 
constexpr uint32 kLookAheadFlags = 0x00000ff0
 
const char arc_lookahead_fst_type [] = "arc_lookahead"
 
const char ilabel_lookahead_fst_type [] = "ilabel_lookahead"
 
const char olabel_lookahead_fst_type [] = "olabel_lookahead"
 
constexpr auto ilabel_lookahead_flags
 
constexpr auto olabel_lookahead_flags
 
constexpr uint32 kRequireMatch = 0x00000001
 
constexpr uint32 kMatcherFlags = kRequireMatch
 
constexpr ssize_t kRequirePriority = -1
 
const uint32 kMultiEpsList = 0x00000001
 
const uint32 kMultiEpsLoop = 0x00000002
 
constexpr int kAllocSize = 64
 
constexpr int kAllocFit = 4
 
constexpr uint64 kExpanded = 0x0000000000000001ULL
 
constexpr uint64 kMutable = 0x0000000000000002ULL
 
constexpr uint64 kError = 0x0000000000000004ULL
 
constexpr uint64 kAcceptor = 0x0000000000010000ULL
 
constexpr uint64 kNotAcceptor = 0x0000000000020000ULL
 
constexpr uint64 kIDeterministic = 0x0000000000040000ULL
 
constexpr uint64 kNonIDeterministic = 0x0000000000080000ULL
 
constexpr uint64 kODeterministic = 0x0000000000100000ULL
 
constexpr uint64 kNonODeterministic = 0x0000000000200000ULL
 
constexpr uint64 kEpsilons = 0x0000000000400000ULL
 
constexpr uint64 kNoEpsilons = 0x0000000000800000ULL
 
constexpr uint64 kIEpsilons = 0x0000000001000000ULL
 
constexpr uint64 kNoIEpsilons = 0x0000000002000000ULL
 
constexpr uint64 kOEpsilons = 0x0000000004000000ULL
 
constexpr uint64 kNoOEpsilons = 0x0000000008000000ULL
 
constexpr uint64 kILabelSorted = 0x0000000010000000ULL
 
constexpr uint64 kNotILabelSorted = 0x0000000020000000ULL
 
constexpr uint64 kOLabelSorted = 0x0000000040000000ULL
 
constexpr uint64 kNotOLabelSorted = 0x0000000080000000ULL
 
constexpr uint64 kWeighted = 0x0000000100000000ULL
 
constexpr uint64 kUnweighted = 0x0000000200000000ULL
 
constexpr uint64 kCyclic = 0x0000000400000000ULL
 
constexpr uint64 kAcyclic = 0x0000000800000000ULL
 
constexpr uint64 kInitialCyclic = 0x0000001000000000ULL
 
constexpr uint64 kInitialAcyclic = 0x0000002000000000ULL
 
constexpr uint64 kTopSorted = 0x0000004000000000ULL
 
constexpr uint64 kNotTopSorted = 0x0000008000000000ULL
 
constexpr uint64 kAccessible = 0x0000010000000000ULL
 
constexpr uint64 kNotAccessible = 0x0000020000000000ULL
 
constexpr uint64 kCoAccessible = 0x0000040000000000ULL
 
constexpr uint64 kNotCoAccessible = 0x0000080000000000ULL
 
constexpr uint64 kString = 0x0000100000000000ULL
 
constexpr uint64 kNotString = 0x0000200000000000ULL
 
constexpr uint64 kWeightedCycles = 0x0000400000000000ULL
 
constexpr uint64 kUnweightedCycles = 0x0000800000000000ULL
 
constexpr uint64 kNullProperties
 
constexpr uint64 kCompiledStringProperties
 
constexpr uint64 kCopyProperties
 
constexpr uint64 kIntrinsicProperties
 
constexpr uint64 kExtrinsicProperties = kError
 
constexpr uint64 kSetStartProperties
 
constexpr uint64 kSetFinalProperties
 
constexpr uint64 kAddStateProperties
 
constexpr uint64 kAddArcProperties
 
constexpr uint64 kSetArcProperties = kExpanded | kMutable | kError
 
constexpr uint64 kDeleteStatesProperties
 
constexpr uint64 kDeleteArcsProperties
 
constexpr uint64 kStateSortProperties
 
constexpr uint64 kArcSortProperties
 
constexpr uint64 kILabelInvariantProperties
 
constexpr uint64 kOLabelInvariantProperties
 
constexpr uint64 kWeightInvariantProperties
 
constexpr uint64 kAddSuperFinalProperties
 
constexpr uint64 kRmSuperFinalProperties
 
constexpr uint64 kBinaryProperties = 0x0000000000000007ULL
 
constexpr uint64 kTrinaryProperties = 0x0000ffffffff0000ULL
 
constexpr uint64 kPosTrinaryProperties
 
constexpr uint64 kNegTrinaryProperties
 
constexpr uint64 kFstProperties = kBinaryProperties | kTrinaryProperties
 
const char * PropertyNames []
 
constexpr uint8 kPushWeights = 0x01
 
constexpr uint8 kPushLabels = 0x02
 
constexpr uint8 kPushRemoveTotalWeight = 0x04
 
constexpr uint8 kPushRemoveCommonAffix = 0x08
 
constexpr uint8 kReplaceSCCLeftLinear = 0x01
 
constexpr uint8 kReplaceSCCRightLinear = 0x02
 
constexpr uint8 kReplaceSCCNonTrivial = 0x04
 
constexpr int kSetEmpty = 0
 
constexpr int kSetUniv = -1
 
constexpr int kSetBad = -2
 
constexpr char kSetSeparator = '_'
 
constexpr float kShortestDelta = 1e-6
 
constexpr int kStringInfinity = -1
 
constexpr int kStringBad = -2
 
constexpr char kStringSeparator = '_'
 
constexpr int64 kNoSymbol = -1
 
constexpr float kDelta = 1.0F / 1024.0F
 
constexpr uint64 kLeftSemiring = 0x0000000000000001ULL
 
constexpr uint64 kRightSemiring = 0x0000000000000002ULL
 
constexpr uint64 kSemiring = kLeftSemiring | kRightSemiring
 
constexpr uint64 kCommutative = 0x0000000000000004ULL
 
constexpr uint64 kIdempotent = 0x0000000000000008ULL
 
constexpr uint64 kPath = 0x0000000000000010ULL
 
constexpr size_t kNumRandomWeights = 5
 
constexpr int32 kFstMagicNumber = 2125659606
 

Typedef Documentation

Definition at line 94 of file arcsort.h.

typedef IntegerFilterState< signed char > fst::CharFilterState

Definition at line 74 of file filter-state.h.

template<class Arc , class Unsigned >
using fst::CompactAcceptorFst = typedef CompactArcFst<Arc, AcceptorCompactor<Arc>, U>

Definition at line 1577 of file compact-fst.h.

template<class Arc , class ArcCompactor , class Unsigned = uint32, class CompactStore = DefaultCompactStore<typename ArcCompactor::Element, Unsigned>, class CacheStore = DefaultCacheStore<Arc>>
using fst::CompactArcFst = typedef CompactFst<Arc, DefaultCompactor<ArcCompactor, Unsigned, CompactStore>, CacheStore>

Definition at line 80 of file fst-decl.h.

template<class Arc , class Unsigned >
using fst::CompactStringFst = typedef CompactArcFst<Arc, StringCompactor<Arc>, U>

Definition at line 1570 of file compact-fst.h.

template<class Arc , class Unsigned >
using fst::CompactUnweightedAcceptorFst = typedef CompactArcFst<Arc, UnweightedAcceptorCompactor<Arc>, U>

Definition at line 1585 of file compact-fst.h.

template<class Arc , class Unsigned >
using fst::CompactUnweightedFst = typedef CompactArcFst<Arc, UnweightedCompactor<Arc>, U>

Definition at line 1581 of file compact-fst.h.

template<class Arc , class Unsigned >
using fst::CompactWeightedStringFst = typedef CompactArcFst<Arc, WeightedStringCompactor<Arc>, U>

Definition at line 1574 of file compact-fst.h.

Definition at line 162 of file concat.h.

template<class Expander >
using fst::DefaultExpanderCache = typedef VectorExpanderCache<typename Expander::Arc>

Definition at line 223 of file expander-cache.h.

Definition at line 132 of file difference.h.

typedef FloatWeightTpl< float > fst::FloatWeight

Definition at line 91 of file float-weight.h.

template<class Arc >
using fst::FstList = typedef std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>

Definition at line 382 of file replace.h.

Definition at line 150 of file phi-fst.h.

Definition at line 139 of file rho-fst.h.

Definition at line 142 of file sigma-fst.h.

Definition at line 20 of file intersect.h.

Definition at line 76 of file filter-state.h.

template<class W >
using fst::IsIdempotent = typedef std::integral_constant<bool, (W::Properties() & kIdempotent) != 0>

Definition at line 137 of file weight.h.

template<class W >
using fst::IsPath = typedef std::integral_constant<bool, (W::Properties() & kPath) != 0>

Definition at line 140 of file weight.h.

using fst::Log64Arc = typedef ArcTpl<Log64Weight>

Definition at line 61 of file arc.h.

Definition at line 815 of file arc-map.h.

Definition at line 813 of file arc-map.h.

using fst::Log64Weight = typedef LogWeightTpl<double>

Definition at line 450 of file float-weight.h.

Definition at line 60 of file arc.h.

Definition at line 811 of file arc-map.h.

Definition at line 805 of file arc-map.h.

typedef LogWeightTpl< float > fst::LogWeight

Definition at line 447 of file float-weight.h.

Definition at line 36 of file map.h.

template<typename T >
using fst::MemoryArena = typedef internal::MemoryArenaImpl<sizeof(T)>

Definition at line 80 of file memory.h.

Definition at line 64 of file arc.h.

Definition at line 668 of file float-weight.h.

Definition at line 158 of file phi-fst.h.

Definition at line 147 of file rho-fst.h.

Definition at line 150 of file sigma-fst.h.

template<class Arc >
using fst::PhiFst = typedef MatcherFst<ConstFst<Arc>, PhiFstMatcher<SortedMatcher<ConstFst<Arc>>>, phi_fst_type>

Definition at line 142 of file phi-fst.h.

Definition at line 23 of file rational.h.

Definition at line 70 of file lock.h.

Definition at line 188 of file relabel.h.

template<class Arc >
using fst::RhoFst = typedef MatcherFst<ConstFst<Arc>, RhoFstMatcher<SortedMatcher<ConstFst<Arc>>>, rho_fst_type>

Definition at line 131 of file rho-fst.h.

Definition at line 75 of file filter-state.h.

template<class Arc >
using fst::SigmaFst = typedef MatcherFst<ConstFst<Arc>, SigmaFstMatcher<SortedMatcher<ConstFst<Arc>>>, sigma_fst_type>

Definition at line 134 of file sigma-fst.h.

Definition at line 63 of file arc.h.

using fst::SignedLog64Weight = typedef SignedLogWeightTpl<double>

Definition at line 213 of file signed-log-weight.h.

Definition at line 62 of file arc.h.

using fst::SignedLogWeight = typedef SignedLogWeightTpl<float>

Definition at line 210 of file signed-log-weight.h.

Definition at line 154 of file state-map.h.

Definition at line 59 of file arc.h.

Definition at line 315 of file matcher-fst.h.

Definition at line 125 of file randgen.h.

template<class Compare >
using fst::StdArcSortFst = typedef ArcSortFst<StdArc, Compare>

Definition at line 207 of file arcsort.h.

Definition at line 608 of file state-map.h.

Definition at line 610 of file state-map.h.

Definition at line 132 of file closure.h.

Definition at line 1591 of file compact-fst.h.

Definition at line 1587 of file compact-fst.h.

Definition at line 1596 of file compact-fst.h.

Definition at line 1593 of file compact-fst.h.

Definition at line 1589 of file compact-fst.h.

Definition at line 275 of file complement.h.

Definition at line 927 of file compose.h.

Definition at line 227 of file concat.h.

Definition at line 476 of file const-fst.h.

Definition at line 589 of file encode.h.

Definition at line 1012 of file determinize.h.

Definition at line 135 of file difference.h.

Definition at line 587 of file encode.h.

Definition at line 108 of file expanded-fst.h.

typedef Fst< StdArc > fst::StdFst

Definition at line 199 of file fst-decl.h.

Definition at line 209 of file arcsort.h.

Definition at line 332 of file matcher-fst.h.

Definition at line 152 of file phi-fst.h.

Definition at line 141 of file rho-fst.h.

Definition at line 144 of file sigma-fst.h.

Definition at line 218 of file fst-decl.h.

Definition at line 220 of file fst-decl.h.

Definition at line 200 of file fst-decl.h.

Definition at line 211 of file arcsort.h.

Definition at line 338 of file matcher-fst.h.

Definition at line 160 of file phi-fst.h.

Definition at line 149 of file rho-fst.h.

Definition at line 152 of file sigma-fst.h.

using fst::StdPhiFst = typedef PhiFst<StdArc>

Definition at line 144 of file phi-fst.h.

Definition at line 222 of file fst-decl.h.

Definition at line 224 of file fst-decl.h.

Definition at line 226 of file fst-decl.h.

using fst::StdRhoFst = typedef RhoFst<StdArc>

Definition at line 133 of file rho-fst.h.

Definition at line 228 of file fst-decl.h.

using fst::StdSigmaFst = typedef SigmaFst<StdArc>

Definition at line 136 of file sigma-fst.h.

Definition at line 809 of file arc-map.h.

Definition at line 803 of file arc-map.h.

Definition at line 230 of file fst-decl.h.

Definition at line 201 of file fst-decl.h.

Definition at line 23 of file synchronize.h.

Definition at line 245 of file float-weight.h.

Definition at line 101 of file union.h.

Enumeration Type Documentation

Enumerator
CLOSURE_STAR 
CLOSURE_PLUS 

Definition at line 26 of file rational.h.

Enumerator
AUTO_FILTER 
NULL_FILTER 
TRIVIAL_FILTER 
SEQUENCE_FILTER 
ALT_SEQUENCE_FILTER 
MATCH_FILTER 
NO_MATCH_FILTER 

Definition at line 929 of file compose.h.

Enumerator
DETERMINIZE_FUNCTIONAL 
DETERMINIZE_NONFUNCTIONAL 
DETERMINIZE_DISAMBIGUATE 

Definition at line 359 of file determinize.h.

Enumerator
DIVIDE_LEFT 
DIVIDE_RIGHT 
DIVIDE_ANY 

Definition at line 143 of file weight.h.

Enumerator
ENCODE 
DECODE 

Definition at line 24 of file encode.h.

Enumerator
EPS_NORM_INPUT 
EPS_NORM_OUTPUT 

Definition at line 18 of file epsnormalize.h.

Enumerator
FET_LINE 
FET_FILE 

Definition at line 21 of file far.h.

Enumerator
FTT_SYMBOL 
FTT_BYTE 
FTT_UTF8 

Definition at line 23 of file far.h.

Enumerator
FAR_DEFAULT 
FAR_STTABLE 
FAR_STLIST 
FAR_FST 

Definition at line 71 of file far.h.

Enumerator
GALLIC_LEFT 
GALLIC_RIGHT 
GALLIC_RESTRICT 
GALLIC_MIN 
GALLIC 

Definition at line 531 of file string-weight.h.

Enumerator
HS_STL 
HS_DENSE 
HS_SPARSE 
HS_FLAT 

Definition at line 99 of file bi-table.h.

Enumerator
MAP_NO_SUPERFINAL 
MAP_ALLOW_SUPERFINAL 
MAP_REQUIRE_SUPERFINAL 

Definition at line 25 of file arc-map.h.

Enumerator
MAP_CLEAR_SYMBOLS 
MAP_COPY_SYMBOLS 
MAP_NOOP_SYMBOLS 

Definition at line 40 of file arc-map.h.

Enumerator
MATCHER_REWRITE_AUTO 
MATCHER_REWRITE_ALWAYS 
MATCHER_REWRITE_NEVER 

Definition at line 570 of file matcher.h.

Enumerator
MATCH_INPUT 
MATCH_OUTPUT 
MATCH_BOTH 
MATCH_NONE 
MATCH_UNKNOWN 

Definition at line 171 of file fst.h.

Enumerator
MPDT_READ_RESTRICT 
MPDT_WRITE_RESTRICT 
MPDT_NO_RESTRICT 

Definition at line 19 of file mpdt.h.

Enumerator
PAREN_FILTER 
EXPAND_FILTER 
EXPAND_PAREN_FILTER 

Definition at line 436 of file compose.h.

Enumerator
PDT_LEFT_PARSER 
PDT_LEFT_SR_PARSER 

Definition at line 43 of file replace.h.

Enumerator
PROJECT_INPUT 
PROJECT_OUTPUT 

Definition at line 18 of file project.h.

Enumerator
TRIVIAL_QUEUE 
FIFO_QUEUE 
LIFO_QUEUE 
SHORTEST_FIRST_QUEUE 
TOP_ORDER_QUEUE 
STATE_ORDER_QUEUE 
SCC_QUEUE 
AUTO_QUEUE 
OTHER_QUEUE 

Definition at line 58 of file queue.h.

Enumerator
REPLACE_LABEL_NEITHER 
REPLACE_LABEL_INPUT 
REPLACE_LABEL_OUTPUT 
REPLACE_LABEL_BOTH 

Definition at line 29 of file replace-util.h.

Enumerator
REWEIGHT_TO_INITIAL 
REWEIGHT_TO_FINAL 

Definition at line 18 of file reweight.h.

Enumerator
SET_INTERSECT_UNION 
SET_UNION_INTERSECT 
SET_INTERSECT_UNION_RESTRICT 
SET_BOOLEAN 

Definition at line 38 of file set-weight.h.

Enumerator
SYMBOL 
BYTE 
UTF8 

Definition at line 30 of file string.h.

Enumerator
STRING_LEFT 
STRING_RIGHT 
STRING_RESTRICT 

Definition at line 32 of file string-weight.h.

Function Documentation

template<class Arc >
void fst::AccumulateStatesAndArcs ( const Fst< Arc > &  fst,
size_t *  nstate,
size_t *  narc,
size_t *  nfinal 
)

Definition at line 20 of file info.h.

template<typename A >
uint64 fst::AddArcProperties ( uint64  inprops,
typename A::StateId  s,
const A &  arc,
const A *  prev_arc 
)
template<typename Arc >
uint64 fst::AddArcProperties ( uint64  inprops,
typename Arc::StateId  s,
const Arc &  arc,
const Arc *  prev_arc 
)

Gets the properties for the MutableFst::AddArc method.

Parameters
inpropsthe current properties of the FST
sthe ID of the state to which an arc is being added.
arcthe arc being added to the state with the specified ID
prev_arcthe previously-added (or "last") arc of state s, or nullptr

Definition at line 425 of file properties.h.

bool fst::AddAuxiliarySymbols ( const std::string &  prefix,
int64  start_label,
int64  nlabels,
SymbolTable syms 
)

Definition at line 109 of file symbol-table-ops.cc.

uint64 fst::AddStateProperties ( uint64  inprops)
inline

Definition at line 383 of file properties.h.

int fst::AlignBufferWithOutputStream ( std::ostream &  strm,
std::ostringstream &  buffer 
)

Definition at line 92 of file util.cc.

bool fst::AlignInput ( std::istream &  strm)

Definition at line 63 of file util.cc.

bool fst::AlignOutput ( std::ostream &  strm)

Definition at line 79 of file util.cc.

template<class W1 , class W2 >
bool fst::ApproxEqual ( const PairWeight< W1, W2 > &  w1,
const PairWeight< W1, W2 > &  w2,
float  delta = kDelta 
)
inline

Definition at line 102 of file pair-weight.h.

template<class W , size_t n>
bool fst::ApproxEqual ( const TupleWeight< W, n > &  w1,
const TupleWeight< W, n > &  w2,
float  delta = kDelta 
)
inline

Definition at line 126 of file tuple-weight.h.

template<class T >
constexpr bool fst::ApproxEqual ( const FloatWeightTpl< T > &  w1,
const FloatWeightTpl< T > &  w2,
float  delta = kDelta 
)

Definition at line 142 of file float-weight.h.

template<class W , class K >
bool fst::ApproxEqual ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2,
float  delta = kDelta 
)
inline

Definition at line 150 of file sparse-power-weight.h.

template<class T >
bool fst::ApproxEqual ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2,
float  delta = kDelta 
)
inline

Definition at line 180 of file signed-log-weight.h.

template<typename Label , StringType S>
bool fst::ApproxEqual ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2,
float  delta = kDelta 
)
inline

Definition at line 287 of file string-weight.h.

template<typename Label , SetType S>
bool fst::ApproxEqual ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2,
float  delta = kDelta 
)
inline

Definition at line 315 of file set-weight.h.

template<class W , class O >
bool fst::ApproxEqual ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2,
float  delta = kDelta 
)
inline

Definition at line 348 of file union-weight.h.

template<class A , class C >
void fst::ArcMap ( MutableFst< A > *  fst,
C *  mapper 
)

Definition at line 95 of file arc-map.h.

template<class A , class C >
void fst::ArcMap ( MutableFst< A > *  fst,
mapper 
)

Definition at line 173 of file arc-map.h.

template<class A , class B , class C >
void fst::ArcMap ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
C *  mapper 
)

Definition at line 181 of file arc-map.h.

template<class A , class B , class C >
void fst::ArcMap ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
mapper 
)

Definition at line 269 of file arc-map.h.

template<class Arc , class Compare >
void fst::ArcSort ( MutableFst< Arc > *  fst,
Compare  comp 
)

Definition at line 89 of file arcsort.h.

template<class Dest , class Source >
Dest fst::bit_cast ( const Source &  source)
inline

Definition at line 56 of file compat.h.

template<class Label >
bool fst::ByteStringToLabels ( const std::string &  str,
std::vector< Label > *  labels 
)

Definition at line 25 of file icu.h.

template<class F , class G >
void fst::Cast ( const F &  ,
G *   
)
template<class IFST , class OFST >
void fst::Cast ( const IFST &  ifst,
OFST *  ofst 
)

Definition at line 978 of file fst.h.

template<class Arc >
uint64 fst::CheckProperties ( const Fst< Arc > &  fst,
uint64  check_mask,
uint64  test_mask 
)

Definition at line 233 of file test-properties.h.

template<class Arc >
void fst::Closure ( MutableFst< Arc > *  fst,
ClosureType  closure_type 
)

Definition at line 34 of file closure.h.

template<class Arc >
void fst::Closure ( RationalFst< Arc > *  fst,
ClosureType  closure_type 
)

Definition at line 58 of file closure.h.

uint64 fst::ClosureProperties ( uint64  inprops,
bool  star,
bool  delayed = false 
)

Definition at line 24 of file properties.cc.

SymbolTable * fst::CompactSymbolTable ( const SymbolTable syms)

Definition at line 63 of file symbol-table-ops.cc.

bool fst::CompatProperties ( uint64  props1,
uint64  props2 
)
inline

Definition at line 34 of file test-properties.h.

bool fst::CompatSymbols ( const SymbolTable syms1,
const SymbolTable syms2,
bool  warning = true 
)

Definition at line 411 of file symbol-table.cc.

uint64 fst::ComplementProperties ( uint64  inprops)

Definition at line 45 of file properties.cc.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const MPdtComposeOptions opts = MPdtComposeOptions() 
)

Definition at line 226 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
MutableFst< Arc > *  ofst,
const MPdtComposeOptions opts = MPdtComposeOptions() 
)

Definition at line 250 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const PdtComposeOptions opts = PdtComposeOptions() 
)

Definition at line 457 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
MutableFst< Arc > *  ofst,
const PdtComposeOptions opts = PdtComposeOptions() 
)

Definition at line 477 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const ComposeOptions opts = ComposeOptions() 
)

Definition at line 981 of file compose.h.

uint64 fst::ComposeProperties ( uint64  inprops1,
uint64  inprops2 
)

Definition at line 58 of file properties.cc.

template<class Arc >
void fst::Compress ( const Fst< Arc > &  fst,
std::ostream &  strm 
)

Definition at line 764 of file compress.h.

template<class Arc >
bool fst::Compress ( const Fst< Arc > &  fst,
const std::string &  source,
const bool  gzip = false 
)

Definition at line 770 of file compress.h.

template<class Arc >
uint64 fst::ComputeProperties ( const Fst< Arc > &  fst,
uint64  mask,
uint64 known,
bool  use_stored 
)

Definition at line 66 of file test-properties.h.

template<class Arc >
Arc::Weight fst::ComputeTotalWeight ( const Fst< Arc > &  fst,
const std::vector< typename Arc::Weight > &  distance,
bool  reverse 
)

Definition at line 28 of file push.h.

template<class Arc >
void fst::Concat ( MutableFst< Arc > *  fst1,
const Fst< Arc > &  fst2 
)

Definition at line 35 of file concat.h.

template<class Arc >
void fst::Concat ( RationalFst< Arc > *  fst1,
const Fst< Arc > &  fst2 
)

Definition at line 86 of file concat.h.

template<class Arc >
void fst::Concat ( const Fst< Arc > &  fst1,
MutableFst< Arc > *  fst2 
)

Definition at line 101 of file concat.h.

template<class Arc >
void fst::Concat ( const std::vector< const Fst< Arc > * > &  fsts1,
MutableFst< Arc > *  fst2 
)

Definition at line 150 of file concat.h.

template<class Arc >
void fst::Concat ( const Fst< Arc > &  fst1,
RationalFst< Arc > *  fst2 
)

Definition at line 158 of file concat.h.

uint64 fst::ConcatProperties ( uint64  inprops1,
uint64  inprops2,
bool  delayed = false 
)

Definition at line 80 of file properties.cc.

template<class Arc >
void fst::Condense ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
std::vector< typename Arc::StateId > *  scc 
)

Definition at line 290 of file connect.h.

template<class Arc >
void fst::Connect ( MutableFst< Arc > *  fst)

Definition at line 270 of file connect.h.

template<class Arc >
Fst<Arc>* fst::Convert ( const Fst< Arc > &  fst,
const std::string &  fst_type 
)

Definition at line 101 of file register.h.

void fst::ConvertToLegalCSymbol ( std::string *  s)

Definition at line 53 of file util.cc.

template<class F >
size_t fst::CountArcs ( const F &  fst)

Definition at line 179 of file expanded-fst.h.

template<class Arc >
Arc::StateId fst::CountStates ( const Fst< Arc > &  fst)

Definition at line 155 of file expanded-fst.h.

template<class Arc >
Arc::StateId fst::CountStates ( const std::vector< const Fst< Arc > * > &  fsts)

Definition at line 171 of file expanded-fst.h.

template<class Arc >
void fst::Decode ( MutableFst< Arc > *  fst,
const EncodeMapper< Arc > &  mapper 
)
inline

Definition at line 463 of file encode.h.

template<class Arc >
bool fst::Decompress ( std::istream &  strm,
const std::string &  source,
MutableFst< Arc > *  fst 
)

Definition at line 802 of file compress.h.

template<class Arc >
bool fst::Decompress ( const std::string &  source,
MutableFst< Arc > *  fst,
const bool  gzip = false 
)

Definition at line 811 of file compress.h.

uint64 fst::DeleteAllStatesProperties ( uint64  inprops,
uint64  staticProps 
)
inline

Definition at line 391 of file properties.h.

uint64 fst::DeleteArcsProperties ( uint64  inprops)
inline

Definition at line 396 of file properties.h.

uint64 fst::DeleteStatesProperties ( uint64  inprops)
inline

Definition at line 387 of file properties.h.

template<class FST >
void fst::Destroy ( ArcIterator< FST > *  aiter,
MemoryPool< ArcIterator< FST >> *  pool 
)

Definition at line 569 of file fst.h.

template<class Arc >
void fst::Determinize ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
const DeterminizeOptions< Arc > &  opts = DeterminizeOptions<Arc>() 
)

Definition at line 1059 of file determinize.h.

uint64 fst::DeterminizeProperties ( uint64  inprops,
bool  has_subsequential_label,
bool  distinct_psubsequential_labels 
)

Definition at line 115 of file properties.cc.

template<class FST , class Visitor , class ArcFilter >
void fst::DfsVisit ( const FST &  fst,
Visitor *  visitor,
ArcFilter  filter,
bool  access_only = false 
)

Definition at line 94 of file dfs-visit.h.

template<class Arc , class Visitor >
void fst::DfsVisit ( const Fst< Arc > &  fst,
Visitor *  visitor 
)

Definition at line 196 of file dfs-visit.h.

template<class Arc >
void fst::Difference ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const DifferenceOptions opts = DifferenceOptions() 
)

Definition at line 151 of file difference.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Difference ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 430 of file set-weight.h.

template<class Arc >
void fst::Disambiguate ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
const DisambiguateOptions< Arc > &  opts = DisambiguateOptions<Arc>() 
)

Definition at line 557 of file disambiguate.h.

template<class W1 , class W2 >
ProductWeight<W1, W2> fst::Divide ( const ProductWeight< W1, W2 > &  w1,
const ProductWeight< W1, W2 > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 85 of file product-weight.h.

template<class W , size_t n>
PowerWeight<W, n> fst::Divide ( const PowerWeight< W, n > &  w1,
const PowerWeight< W, n > &  w2,
DivideType  type = DIVIDE_ANY 
)
inline

Definition at line 106 of file power-weight.h.

template<class X1 , class X2 >
ExpectationWeight<X1, X2> fst::Divide ( const ExpectationWeight< X1, X2 > &  w1,
const ExpectationWeight< X1, X2 > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 111 of file expectation-weight.h.

template<class W , class K >
SparsePowerWeight<W, K> fst::Divide ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2,
DivideType  type = DIVIDE_ANY 
)
inline

Definition at line 128 of file sparse-power-weight.h.

template<class W1 , class W2 >
LexicographicWeight<W1, W2> fst::Divide ( const LexicographicWeight< W1, W2 > &  w,
const LexicographicWeight< W1, W2 > &  v,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 129 of file lexicographic-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Divide ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 157 of file signed-log-weight.h.

template<class W , class K >
SparsePowerWeight<W, K> fst::Divide ( const SparsePowerWeight< W, K > &  w1,
const W &  k,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 177 of file sparse-power-weight.h.

template<class T >
constexpr TropicalWeightTpl<T> fst::Divide ( const TropicalWeightTpl< T > &  w1,
const TropicalWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 302 of file float-weight.h.

constexpr TropicalWeightTpl<float> fst::Divide ( const TropicalWeightTpl< float > &  w1,
const TropicalWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 332 of file float-weight.h.

constexpr TropicalWeightTpl<double> fst::Divide ( const TropicalWeightTpl< double > &  w1,
const TropicalWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 338 of file float-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::Divide ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2,
DivideType  divide_type 
)
inline

Definition at line 449 of file string-weight.h.

template<class W , class O >
UnionWeight<W, O> fst::Divide ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2,
DivideType  typ 
)
inline

Definition at line 449 of file union-weight.h.

template<typename Label >
StringWeight<Label, STRING_LEFT> fst::Divide ( const StringWeight< Label, STRING_LEFT > &  w1,
const StringWeight< Label, STRING_LEFT > &  w2,
DivideType  divide_type 
)
inline

Definition at line 467 of file string-weight.h.

template<typename Label >
StringWeight<Label, STRING_RIGHT> fst::Divide ( const StringWeight< Label, STRING_RIGHT > &  w1,
const StringWeight< Label, STRING_RIGHT > &  w2,
DivideType  divide_type 
)
inline

Definition at line 480 of file string-weight.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Divide ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 536 of file set-weight.h.

template<class T >
constexpr LogWeightTpl<T> fst::Divide ( const LogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 537 of file float-weight.h.

template<typename Label >
SetWeight<Label, SET_UNION_INTERSECT> fst::Divide ( const SetWeight< Label, SET_UNION_INTERSECT > &  w1,
const SetWeight< Label, SET_UNION_INTERSECT > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 545 of file set-weight.h.

constexpr LogWeightTpl<float> fst::Divide ( const LogWeightTpl< float > &  w1,
const LogWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 545 of file float-weight.h.

constexpr LogWeightTpl<double> fst::Divide ( const LogWeightTpl< double > &  w1,
const LogWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 551 of file float-weight.h.

template<typename Label >
SetWeight<Label, SET_BOOLEAN> fst::Divide ( const SetWeight< Label, SET_BOOLEAN > &  w1,
const SetWeight< Label, SET_BOOLEAN > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 557 of file set-weight.h.

template<class Label , class W , GallicType G>
GallicWeight<Label, W, G> fst::Divide ( const GallicWeight< Label, W, G > &  w,
const GallicWeight< Label, W, G > &  v,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 636 of file string-weight.h.

template<class T >
constexpr MinMaxWeightTpl<T> fst::Divide ( const MinMaxWeightTpl< T > &  w1,
const MinMaxWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 708 of file float-weight.h.

constexpr MinMaxWeightTpl<float> fst::Divide ( const MinMaxWeightTpl< float > &  w1,
const MinMaxWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 714 of file float-weight.h.

constexpr MinMaxWeightTpl<double> fst::Divide ( const MinMaxWeightTpl< double > &  w1,
const MinMaxWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 720 of file float-weight.h.

template<class Label , class W >
GallicWeight<Label, W, GALLIC> fst::Divide ( const GallicWeight< Label, W, GALLIC > &  w1,
const GallicWeight< Label, W, GALLIC > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 777 of file string-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::DivideLeft ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 409 of file string-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::DivideRight ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 429 of file string-weight.h.

template<class W , class K >
const W& fst::DotProduct ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2 
)
inline

Definition at line 139 of file sparse-power-weight.h.

template<class W , size_t n>
W fst::DotProduct ( const PowerWeight< W, n > &  w1,
const PowerWeight< W, n > &  w2 
)
inline

Definition at line 140 of file power-weight.h.

template<typename To , typename From >
To fst::down_cast ( From *  f)
inline

Definition at line 50 of file compat.h.

template<class Arc >
void fst::Encode ( MutableFst< Arc > *  fst,
EncodeMapper< Arc > *  mapper 
)
inline

Definition at line 456 of file encode.h.

bool fst::EpsilonOnInput ( ReplaceLabelType  label_type)
inline

Definition at line 385 of file replace.h.

bool fst::EpsilonOnOutput ( ReplaceLabelType  label_type)
inline

Definition at line 391 of file replace.h.

template<class Arc >
void fst::EpsNormalize ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
EpsNormalizeType  type = EPS_NORM_INPUT 
)

Definition at line 32 of file epsnormalize.h.

template<class Arc , GallicType G>
void fst::EpsNormalize ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
EpsNormalizeType  type 
)

Definition at line 39 of file epsnormalize.h.

template<class Arc , class WeightEqual >
bool fst::Equal ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
WeightEqual  weight_equal,
uint8  etype = kEqualFsts 
)

Definition at line 43 of file equal.h.

template<class Arc >
bool fst::Equal ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
float  delta = kDelta,
uint8  etype = kEqualFsts 
)

Definition at line 151 of file equal.h.

template<class Arc >
bool fst::Equal ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
double  delta,
uint8  etype = kEqualFsts 
)

Definition at line 161 of file equal.h.

template<class Arc >
bool fst::Equivalent ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
float  delta = kDelta,
bool *  error = nullptr 
)

Definition at line 115 of file equivalent.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
MutableFst< Arc > *  ofst,
const MPdtExpandOptions opts 
)

Definition at line 303 of file expand.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
MutableFst< Arc > *  ofst,
bool  connect = true,
bool  keep_parentheses = false 
)

Definition at line 324 of file expand.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
MutableFst< Arc > *  ofst,
const PdtExpandOptions< Arc > &  opts 
)

Definition at line 899 of file expand.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
MutableFst< Arc > *  ofst,
bool  connect = true,
bool  keep_parentheses = false 
)

Definition at line 923 of file expand.h.

uint64 fst::FactorWeightProperties ( uint64  inprops)

Definition at line 140 of file properties.cc.

template<class Arc >
void fst::FarCompileStrings ( const std::vector< std::string > &  in_sources,
const std::string &  out_source,
const std::string &  fst_type,
const FarType far_type,
int32  generate_keys,
FarEntryType  fet,
FarTokenType  tt,
const std::string &  symbols_source,
const std::string &  unknown_symbol,
bool  keep_symbols,
bool  initial_symbols,
bool  allow_negative_labels,
const std::string &  key_prefix,
const std::string &  key_suffix 
)

Definition at line 126 of file compile-strings.h.

template<class Arc >
void fst::FarCreate ( const std::vector< std::string > &  in_sources,
const std::string &  out_source,
const int32  generate_keys,
const FarType far_type,
const std::string &  key_prefix,
const std::string &  key_suffix 
)

Definition at line 19 of file create.h.

template<class Arc >
bool fst::FarEqual ( const std::string &  source1,
const std::string &  source2,
float  delta = kDelta,
const std::string &  begin_key = std::string(),
const std::string &  end_key = std::string() 
)

Definition at line 16 of file equal.h.

template<class Arc >
void fst::FarExtract ( const std::vector< std::string > &  isources,
int32  generate_sources,
const std::string &  keys,
const std::string &  key_separator,
const std::string &  range_delimiter,
const std::string &  source_prefix,
const std::string &  source_suffix 
)

Definition at line 48 of file extract.h.

template<class Arc >
void fst::FarInfo ( const std::vector< std::string > &  sources,
const std::string &  begin_key,
const std::string &  end_key,
const bool  list_fsts 
)

Definition at line 87 of file info.h.

template<class Arc >
bool fst::FarIsomorphic ( const std::string &  source1,
const std::string &  source2,
float  delta = kDelta,
const std::string &  begin_key = std::string(),
const std::string &  end_key = std::string() 
)

Definition at line 16 of file isomorphic.h.

template<class Arc >
void fst::FarPrintStrings ( const std::vector< std::string > &  isources,
FarEntryType  entry_type,
FarTokenType  far_token_type,
const std::string &  begin_key,
const std::string &  end_key,
bool  print_key,
bool  print_weight,
const std::string &  symbols_source,
bool  initial_symbols,
int32  generate_sources,
const std::string &  source_prefix,
const std::string &  source_suffix 
)

Definition at line 24 of file print-strings.h.

template<class Arc >
void fst::FarWriteFst ( const Fst< Arc > *  fst,
std::string  key,
std::string *  okey,
int *  nrep,
int32  generate_sources,
int  i,
const std::string &  source_prefix,
const std::string &  source_suffix 
)
inline

Definition at line 19 of file extract.h.

template<class T >
constexpr bool fst::FloatApproxEqual ( w1,
w2,
float  delta = kDelta 
)

Definition at line 137 of file float-weight.h.

SymbolTable * fst::FstReadSymbols ( const std::string &  source,
bool  input 
)

Definition at line 75 of file symbol-table-ops.cc.

template<class Arc >
std::string fst::FstToString ( const Fst< Arc > &  fst,
const FstWriteOptions options = FstWriteOptions("FstToString") 
)

Definition at line 987 of file fst.h.

template<class Arc >
void fst::FstToString ( const Fst< Arc > &  fst,
std::string *  result 
)

Definition at line 996 of file fst.h.

template<class Arc >
void fst::FstToString ( const Fst< Arc > &  fst,
std::string *  result,
const FstWriteOptions options 
)

Definition at line 1001 of file fst.h.

constexpr StringType fst::GallicStringType ( GallicType  g)

Definition at line 539 of file string-weight.h.

template<class Arc >
void fst::GetFarInfo ( const std::vector< std::string > &  sources,
const std::string &  begin_key,
const std::string &  end_key,
const bool  list_fsts,
FarInfoData far_info 
)

Definition at line 51 of file info.h.

std::string fst::GetFarTypeString ( FarType  type)

Definition at line 60 of file getters.cc.

template<class A >
A::Label fst::GuessStartOrEnd ( std::vector< typename A::Label > *  sequence,
typename A::Label  boundary 
)

Definition at line 1037 of file linear-fst-data-builder.h.

template<class Arc >
void fst::Intersect ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const IntersectOptions opts = IntersectOptions() 
)

Definition at line 127 of file intersect.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Intersect ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 400 of file set-weight.h.

template<class Arc >
void fst::Invert ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst 
)
inline

Definition at line 56 of file invert.h.

template<class Arc >
void fst::Invert ( MutableFst< Arc > *  fst)
inline

Definition at line 68 of file invert.h.

uint64 fst::InvertProperties ( uint64  inprops)

Definition at line 154 of file properties.cc.

bool fst::IsFst ( const std::string &  source)
inline

Definition at line 25 of file far.h.

bool fst::IsFstHeader ( std::istream &  strm,
const std::string &   
)

Definition at line 45 of file fst.cc.

template<class Arc >
bool fst::Isomorphic ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
float  delta = kDelta 
)

Definition at line 229 of file isomorphic.h.

bool fst::IsSTList ( const std::string &  source)

Definition at line 11 of file stlist.cc.

bool fst::IsSTTable ( const std::string &  source)

Definition at line 9 of file sttable.cc.

template<class Iterator >
std::string fst::JoinLabels ( Iterator  begin,
Iterator  end,
const SymbolTable syms 
)

Definition at line 1016 of file linear-fst-data-builder.h.

template<class Label >
std::string fst::JoinLabels ( const std::vector< Label > &  labels,
const SymbolTable syms 
)

Definition at line 1031 of file linear-fst-data-builder.h.

int fst::KeySize ( const char *  source)

Definition at line 19 of file strings.cc.

uint64 fst::KnownProperties ( uint64  props)
inline

Definition at line 27 of file test-properties.h.

template<class Label >
bool fst::LabelsToByteString ( const std::vector< Label > &  labels,
std::string *  str 
)

Definition at line 77 of file icu.h.

template<class Label >
bool fst::LabelsToString ( const std::vector< Label > &  labels,
std::string *  str,
StringTokenType  ttype = BYTE,
const SymbolTable syms = nullptr,
const std::string &  sep = FLAGS_fst_field_separator 
)

Definition at line 267 of file string.h.

template<class Label >
bool fst::LabelsToUTF8String ( const std::vector< Label > &  labels,
std::string *  str 
)

Definition at line 87 of file icu.h.

template<class A >
void fst::LogLinearApply ( const Fst< A > &  ifst,
const Fst< A > &  lfst,
MutableFst< A > *  ofst,
bool  normalize = true 
)

Definition at line 36 of file loglinear-apply.h.

template<class A , class B >
void fst::LogLinearApply ( const Fst< A > &  ifst,
const Fst< A > &  lfst,
MutableFst< A > *  ofst,
bool  normalize = true 
)

Definition at line 45 of file loglinear-apply.h.

template<class Arc >
void fst::LookAheadCompose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst 
)

Definition at line 48 of file algo_test.h.

void fst::LookAheadCompose ( const Fst< StdArc > &  ifst1,
const Fst< StdArc > &  ifst2,
MutableFst< StdArc > *  ofst 
)
inline

Definition at line 54 of file algo_test.h.

template<class Matcher1 , class Matcher2 >
MatchType fst::LookAheadMatchType ( const Matcher1 &  m1,
const Matcher2 &  m2 
)

Definition at line 26 of file lookahead-filter.h.

template<class Arc >
MatchType fst::LookAheadMatchType ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2 
)

Definition at line 48 of file lookahead-filter.h.

template<typename T , typename... Args>
std::unique_ptr<T> fst::make_unique ( Args &&...  args)

Definition at line 92 of file compat.h.

template<typename T >
std::unique_ptr<T[]> fst::make_unique ( size_t  n)

Definition at line 97 of file compat.h.

template<typename T >
std::unique_ptr<T> fst::make_unique_default_init ( )

Definition at line 102 of file compat.h.

template<typename T >
std::unique_ptr<T[]> fst::make_unique_default_init ( size_t  n)

Definition at line 107 of file compat.h.

template<class Arc , class Unsigned = uint32, class LabelIterator >
CompactStringFst<Arc, Unsigned> fst::MakeCompactStringFst ( const LabelIterator  begin,
const LabelIterator  end 
)
inline

Definition at line 1601 of file compact-fst.h.

template<class LabelIterator >
StdCompactStringFst fst::MakeStdCompactStringFst ( const LabelIterator  begin,
const LabelIterator  end 
)
inline

Definition at line 1609 of file compact-fst.h.

template<class A , class C >
void fst::Map ( MutableFst< A > *  fst,
C *  mapper 
)

Definition at line 17 of file map.h.

template<class A , class C >
void fst::Map ( MutableFst< A > *  fst,
mapper 
)

Definition at line 22 of file map.h.

template<class A , class B , class C >
void fst::Map ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
C *  mapper 
)

Definition at line 27 of file map.h.

template<class A , class B , class C >
void fst::Map ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
mapper 
)

Definition at line 32 of file map.h.

SymbolTable * fst::MergeSymbolTable ( const SymbolTable left,
const SymbolTable right,
bool *  right_relabel_output = nullptr 
)

Definition at line 11 of file symbol-table-ops.cc.

template<class Arc >
void fst::Minimize ( MutableFst< Arc > *  fst,
MutableFst< Arc > *  sfst = nullptr,
float  delta = kShortestDelta,
bool  allow_nondet = false 
)

Definition at line 490 of file minimize.h.

template<class T >
SignedLogWeightTpl<T> fst::Minus ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 134 of file signed-log-weight.h.

uint64 fst::MPdtExpandProperties ( uint64  inprops)
inline

Definition at line 37 of file expand.h.

template<class Result , class RNG >
void fst::OneMultinomialSample ( const std::vector< double > &  probs,
size_t  num_to_sample,
Result *  result,
RNG *  rng 
)

Definition at line 262 of file randgen.h.

template<class W1 , class W2 >
bool fst::operator!= ( const PairWeight< W1, W2 > &  w1,
const PairWeight< W1, W2 > &  w2 
)
inline

Definition at line 96 of file pair-weight.h.

template<class W , size_t n>
bool fst::operator!= ( const TupleWeight< W, n > &  w1,
const TupleWeight< W, n > &  w2 
)
inline

Definition at line 117 of file tuple-weight.h.

template<class T >
constexpr bool fst::operator!= ( const FloatWeightTpl< T > &  w1,
const FloatWeightTpl< T > &  w2 
)

Definition at line 121 of file float-weight.h.

constexpr bool fst::operator!= ( const FloatWeightTpl< float > &  w1,
const FloatWeightTpl< float > &  w2 
)

Definition at line 126 of file float-weight.h.

constexpr bool fst::operator!= ( const FloatWeightTpl< double > &  w1,
const FloatWeightTpl< double > &  w2 
)

Definition at line 131 of file float-weight.h.

template<class T >
bool fst::operator!= ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 204 of file signed-log-weight.h.

template<typename Label , StringType S>
bool fst::operator!= ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 281 of file string-weight.h.

template<typename T , typename U >
bool fst::operator!= ( const BlockAllocator< T > &  alloc1,
const BlockAllocator< U > &  alloc2 
)

Definition at line 307 of file memory.h.

template<typename Label , SetType S>
bool fst::operator!= ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 309 of file set-weight.h.

template<class W , class O >
bool fst::operator!= ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2 
)
inline

Definition at line 341 of file union-weight.h.

template<class W , class K >
bool fst::operator!= ( const SparseTupleWeight< W, K > &  w1,
const SparseTupleWeight< W, K > &  w2 
)
inline

Definition at line 382 of file sparse-tuple-weight.h.

template<typename T , typename U >
bool fst::operator!= ( const PoolAllocator< T > &  alloc1,
const PoolAllocator< U > &  alloc2 
)

Definition at line 435 of file memory.h.

template<class W1 , class W2 >
std::ostream& fst::operator<< ( std::ostream &  strm,
const PairWeight< W1, W2 > &  weight 
)
inline

Definition at line 109 of file pair-weight.h.

template<class W , size_t n>
std::ostream& fst::operator<< ( std::ostream &  strm,
const TupleWeight< W, n > &  w 
)
inline

Definition at line 135 of file tuple-weight.h.

template<class T >
std::ostream& fst::operator<< ( std::ostream &  strm,
const FloatWeightTpl< T > &  w 
)
inline

Definition at line 148 of file float-weight.h.

template<typename Label , StringType S>
std::ostream& fst::operator<< ( std::ostream &  strm,
const StringWeight< Label, S > &  weight 
)
inline

Definition at line 294 of file string-weight.h.

template<typename Label , SetType S>
std::ostream& fst::operator<< ( std::ostream &  strm,
const SetWeight< Label, S > &  weight 
)
inline

Definition at line 322 of file set-weight.h.

template<class W , class O >
std::ostream& fst::operator<< ( std::ostream &  ostrm,
const UnionWeight< W, O > &  weight 
)
inline

Definition at line 360 of file union-weight.h.

template<class W , class K >
std::ostream& fst::operator<< ( std::ostream &  strm,
const SparseTupleWeight< W, K > &  weight 
)
inline

Definition at line 388 of file sparse-tuple-weight.h.

template<typename T , class Store >
std::ostream& fst::operator<< ( std::ostream &  strm,
const IntervalSet< T, Store > &  s 
)

Definition at line 389 of file interval-set.h.

template<class W , class O >
bool fst::operator== ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2 
)
inline

Definition at line 328 of file union-weight.h.

template<class StateId , class PrefixId >
bool fst::operator== ( const ReplaceStateTuple< StateId, PrefixId > &  x,
const ReplaceStateTuple< StateId, PrefixId > &  y 
)
inline

Definition at line 80 of file replace.h.

template<class W1 , class W2 >
bool fst::operator== ( const PairWeight< W1, W2 > &  w1,
const PairWeight< W1, W2 > &  w2 
)
inline

Definition at line 90 of file pair-weight.h.

template<class T >
constexpr bool fst::operator== ( const FloatWeightTpl< T > &  w1,
const FloatWeightTpl< T > &  w2 
)

Definition at line 94 of file float-weight.h.

template<class W , size_t n>
bool fst::operator== ( const TupleWeight< W, n > &  w1,
const TupleWeight< W, n > &  w2 
)
inline

Definition at line 108 of file tuple-weight.h.

constexpr bool fst::operator== ( const FloatWeightTpl< float > &  w1,
const FloatWeightTpl< float > &  w2 
)

Definition at line 110 of file float-weight.h.

constexpr bool fst::operator== ( const FloatWeightTpl< double > &  w1,
const FloatWeightTpl< double > &  w2 
)

Definition at line 115 of file float-weight.h.

template<typename S , typename K >
bool fst::operator== ( const PdtStateTuple< S, K > &  x,
const PdtStateTuple< S, K > &  y 
)
inline

Definition at line 133 of file pdt.h.

template<class Label , class StateId >
bool fst::operator== ( const ReplaceStackPrefix< Label, StateId > &  x,
const ReplaceStackPrefix< Label, StateId > &  y 
)
inline

Definition at line 164 of file replace.h.

template<class T >
bool fst::operator== ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 192 of file signed-log-weight.h.

template<typename Label , StringType S>
bool fst::operator== ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 268 of file string-weight.h.

template<typename Label , SetType S>
bool fst::operator== ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 280 of file set-weight.h.

template<typename Label >
bool fst::operator== ( const SetWeight< Label, SET_BOOLEAN > &  w1,
const SetWeight< Label, SET_BOOLEAN > &  w2 
)
inline

Definition at line 294 of file set-weight.h.

template<typename T , typename U >
bool fst::operator== ( const BlockAllocator< T > &  alloc1,
const BlockAllocator< U > &  alloc2 
)

Definition at line 301 of file memory.h.

template<class W , class K >
bool fst::operator== ( const SparseTupleWeight< W, K > &  w1,
const SparseTupleWeight< W, K > &  w2 
)
inline

Definition at line 354 of file sparse-tuple-weight.h.

template<typename T , typename U >
bool fst::operator== ( const PoolAllocator< T > &  alloc1,
const PoolAllocator< U > &  alloc2 
)

Definition at line 429 of file memory.h.

template<class W1 , class W2 >
std::istream& fst::operator>> ( std::istream &  strm,
PairWeight< W1, W2 > &  weight 
)
inline

Definition at line 120 of file pair-weight.h.

template<class W , size_t n>
std::istream& fst::operator>> ( std::istream &  strm,
TupleWeight< W, n > &  w 
)
inline

Definition at line 145 of file tuple-weight.h.

template<class T >
std::istream& fst::operator>> ( std::istream &  strm,
FloatWeightTpl< T > &  w 
)
inline

Definition at line 162 of file float-weight.h.

template<typename Label , StringType S>
std::istream& fst::operator>> ( std::istream &  strm,
StringWeight< Label, S > &  weight 
)
inline

Definition at line 313 of file string-weight.h.

template<typename Label , SetType S>
std::istream& fst::operator>> ( std::istream &  strm,
SetWeight< Label, S > &  weight 
)
inline

Definition at line 341 of file set-weight.h.

template<class W , class O >
std::istream& fst::operator>> ( std::istream &  istrm,
UnionWeight< W, O > &  weight 
)
inline

Definition at line 377 of file union-weight.h.

template<class W , class K >
std::istream& fst::operator>> ( std::istream &  strm,
SparseTupleWeight< W, K > &  weight 
)
inline

Definition at line 402 of file sparse-tuple-weight.h.

template<class W1 , class W2 >
ProductWeight<W1, W2> fst::Plus ( const ProductWeight< W1, W2 > &  w1,
const ProductWeight< W1, W2 > &  w2 
)
inline

Definition at line 71 of file product-weight.h.

template<class W , size_t n>
PowerWeight<W, n> fst::Plus ( const PowerWeight< W, n > &  w1,
const PowerWeight< W, n > &  w2 
)
inline

Definition at line 84 of file power-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Plus ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 94 of file signed-log-weight.h.

template<class X1 , class X2 >
ExpectationWeight<X1, X2> fst::Plus ( const ExpectationWeight< X1, X2 > &  w1,
const ExpectationWeight< X1, X2 > &  w2 
)
inline

Definition at line 96 of file expectation-weight.h.

template<class W1 , class W2 >
LexicographicWeight<W1, W2> fst::Plus ( const LexicographicWeight< W1, W2 > &  w,
const LexicographicWeight< W1, W2 > &  v 
)
inline

Definition at line 107 of file lexicographic-weight.h.

template<class W , class K >
SparsePowerWeight<W, K> fst::Plus ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2 
)
inline

Definition at line 110 of file sparse-power-weight.h.

template<class T >
constexpr TropicalWeightTpl<T> fst::Plus ( const TropicalWeightTpl< T > &  w1,
const TropicalWeightTpl< T > &  w2 
)

Definition at line 248 of file float-weight.h.

constexpr TropicalWeightTpl<float> fst::Plus ( const TropicalWeightTpl< float > &  w1,
const TropicalWeightTpl< float > &  w2 
)

Definition at line 256 of file float-weight.h.

constexpr TropicalWeightTpl<double> fst::Plus ( const TropicalWeightTpl< double > &  w1,
const TropicalWeightTpl< double > &  w2 
)

Definition at line 261 of file float-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::Plus ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 341 of file string-weight.h.

template<typename Label >
StringWeight<Label, STRING_LEFT> fst::Plus ( const StringWeight< Label, STRING_LEFT > &  w1,
const StringWeight< Label, STRING_LEFT > &  w2 
)
inline

Definition at line 358 of file string-weight.h.

template<typename Label >
StringWeight<Label, STRING_RIGHT> fst::Plus ( const StringWeight< Label, STRING_RIGHT > &  w1,
const StringWeight< Label, STRING_RIGHT > &  w2 
)
inline

Definition at line 377 of file string-weight.h.

template<class W , class O >
UnionWeight<W, O> fst::Plus ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2 
)
inline

Definition at line 402 of file union-weight.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Plus ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 461 of file set-weight.h.

template<typename Label >
SetWeight<Label, SET_UNION_INTERSECT> fst::Plus ( const SetWeight< Label, SET_UNION_INTERSECT > &  w1,
const SetWeight< Label, SET_UNION_INTERSECT > &  w2 
)
inline

Definition at line 469 of file set-weight.h.

template<typename Label >
SetWeight<Label, SET_INTERSECT_UNION_RESTRICT> fst::Plus ( const SetWeight< Label, SET_INTERSECT_UNION_RESTRICT > &  w1,
const SetWeight< Label, SET_INTERSECT_UNION_RESTRICT > &  w2 
)
inline

Definition at line 479 of file set-weight.h.

template<class T >
LogWeightTpl<T> fst::Plus ( const LogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2 
)
inline

Definition at line 493 of file float-weight.h.

template<typename Label >
SetWeight<Label, SET_BOOLEAN> fst::Plus ( const SetWeight< Label, SET_BOOLEAN > &  w1,
const SetWeight< Label, SET_BOOLEAN > &  w2 
)
inline

Definition at line 497 of file set-weight.h.

LogWeightTpl<float> fst::Plus ( const LogWeightTpl< float > &  w1,
const LogWeightTpl< float > &  w2 
)
inline

Definition at line 509 of file float-weight.h.

LogWeightTpl<double> fst::Plus ( const LogWeightTpl< double > &  w1,
const LogWeightTpl< double > &  w2 
)
inline

Definition at line 514 of file float-weight.h.

template<class Label , class W , GallicType G>
GallicWeight<Label, W, G> fst::Plus ( const GallicWeight< Label, W, G > &  w,
const GallicWeight< Label, W, G > &  v 
)
inline

Definition at line 613 of file string-weight.h.

template<class Label , class W >
GallicWeight<Label, W, GALLIC_MIN> fst::Plus ( const GallicWeight< Label, W, GALLIC_MIN > &  w1,
const GallicWeight< Label, W, GALLIC_MIN > &  w2 
)
inline

Definition at line 621 of file string-weight.h.

template<class T >
constexpr MinMaxWeightTpl<T> fst::Plus ( const MinMaxWeightTpl< T > &  w1,
const MinMaxWeightTpl< T > &  w2 
)

Definition at line 672 of file float-weight.h.

constexpr MinMaxWeightTpl<float> fst::Plus ( const MinMaxWeightTpl< float > &  w1,
const MinMaxWeightTpl< float > &  w2 
)

Definition at line 678 of file float-weight.h.

constexpr MinMaxWeightTpl<double> fst::Plus ( const MinMaxWeightTpl< double > &  w1,
const MinMaxWeightTpl< double > &  w2 
)

Definition at line 683 of file float-weight.h.

template<class Label , class W >
GallicWeight<Label, W, GALLIC> fst::Plus ( const GallicWeight< Label, W, GALLIC > &  w1,
const GallicWeight< Label, W, GALLIC > &  w2 
)