| Cfst::AE< T, Collection > | |
| Cfst::AE< T, std::map< unsigned int, T > > | |
| Cfst::AE< T, std::vector< T > > | |
| Cfst::AE< T, TropicalSparseTupleWeight< T > > | |
| Cucam::hifst::AlilatsToSparseWeightLatsData< ArcT > | Data class containing relevant variables. To be used as template for task classes using it |
| Cfst::ApplyLanguageModelOnTheFlyInterface< ArcT > | Interface for language model application Provides different run methods to do composition with a (bilingual) model |
| ►Cfst::ApplyLanguageModelOnTheFlyInterface< Arc > | |
| Cfst::ApplyLanguageModelOnTheFly< Arc, MakeWeightT, KenLMModelT, IdBridgeT, HackScoreT > | Class that applies language model on the fly using kenlm |
| Cucam::fsttools::ApplyLMData< ArcT > | Data structure for applylm tool |
| Cucam::lmbr::ApplyPosteriors | Functor that applies posteriors to any hypothesis space. Initializes with previously calculated posteriors |
| Cucam::fsttools::Bleu | |
| CBleu | |
| Cucam::fsttools::BleuScorer | |
| Cucam::fsttools::BleuStats | |
| CBleuStats | |
| Cuk.ac.cam.eng.util.CLI | |
| Cfst::CompareHyp | Class used by priority queue to compare two hypotheses and decide which one wins |
| ►Cucam::hifst::CompareTool | Class that provides basic string comparison between two const char * |
| Cucam::hifst::PatternCompareTool | Class that provides "pattern" comparison between two const char *. The "patterns" are an abstraction of any non-terminal A-Z. So for instance, consider non_terminals A and Z. A rule with source 3_A_5 and another one with source 3_Z_5 are equivalent and need to be listed together (with any other equivalent sources). This class can be used with PosIndexCompare as it inherits from CompareTool |
| CCompositeList | |
| Cucam::lmbr::ComputePosteriors | |
| Cucam::hifst::conditions | Struct containing the elements that trigger local pruning |
| Cuk.ac.cam.eng.extraction.hadoop.util.CopyRecordsForTesting | |
| Cucam::hifst::CYKbackpointers | Functor that provides cyk backpointers |
| Cucam::hifst::CYKdata | Data structure containing all cyk-related information |
| Cucam::hifst::CYKgrid | Functor that provides cykgrid access methods |
| CDataForCyK | Public Data class with variables required by CyKParser |
| CDataForPatternsToInstancesTask | Public Data class with variables required by PatternsToInstancestask to compile and run |
| Cgoogletesting::DataForReferenceFilter | Public class with variables required by TextTask to compile and run |
| CDataForSentenceSpecificGrammarTask | Public Data class with variables required by SentenceSpecificGrammarTask |
| Cgoogletesting::DataForStats | Public class with variables required by TextTask to compile and run |
| Cgoogletesting::DataTest1 | Trivial data class with three bool variables |
| Cgoogletesting::DataTest2 | Trivial data class, now contains unsigned and vector<unsigned> |
| CDebugMertAlgorithm | |
| CDirections | |
| Cucam::fsttools::DisambigData | Data structure for disambig tool. It needs at least a mixed case language model, mixed-case vocabulary and a transduction unigram model |
| CDisambigFunctor< ArcT > | |
| Cfst::DotProductMap< T > | Map functor used with generic weight mapper |
| ►CEnumerateVocab | |
| Clm::HifstEnumerateVocab< WordMapperT > | This class extends EnumerateVocab in kenlm code. This class creates a grammar-integer to lm-integer hash which will be used during composition. If there is an lm wordmap available, then it uses the wordmap to synchronize. Note: The nplm wrapper does not support this functionality |
| Cuk.ac.cam.eng.rule.retrieval.EnumRuleType | |
| CErrorSurface< RD > | |
| Cfst::Expand | |
| Cucam::hifst::ExpandedNumStatesRTN< Arc > | Utility class that, given an RTN with root at (cc,x,y), estimates the number of states of an expanded FSA The RTN is not explicitly passed to this class. Instead, it is updated sequentially as individual FSAs are created |
| Cucam::fsttools::ExpandPathsWithTopologicalWeights< MapCursorT, FeatureTrackerT > | |
| Cuk.ac.cam.eng.extraction.hadoop.util.ExtractorDataLoader | |
| Cucam::util::FastForwardRead< StreamT > | Convenience class that reads "quickly" until a queried line |
| Cucam::util::FastForwardRead< ucam::util::iszfstream > | |
| Cuk.ac.cam.eng.rule.features.Feature | |
| Cuk.ac.cam.eng.rule.features.FeatureFunctionRegistry | |
| Cuk.ac.cam.eng.rule.features.FeatureFunctions | |
| Cuk.ac.cam.eng.rule.features.FeatureRegistry | |
| Cucam::fsttools::FeatureTracker | |
| Cucam::fsttools::FeatureTrackerRev | |
| CFunctionArc | |
| CFunctionToStdMapper | |
| CFunctionWeight | |
| Cgoogletesting::functor_test | |
| Cgoogletesting::functor_test2 | |
| Cfst::GeneralMapper< FromArc, ToArc, M > | |
| Cucam::hifst::GenerateTrivialFst< Arc > | |
| Cfst::GenericArcAutoMapper< Arc, ArcMakerFunctorT > | |
| Cfst::GenericArcMapper< FromArc, ToArc, ArcMakerFunctorT > | |
| Cfst::GenericWeightAutoMapper< Arc, WeightMakerFunctorT > | Templated Mapper that modifies weights over an FST, passing through the other values of the arc. This mapper is to be combined with any functor that accepts Arc::Weight as a unique parameter for operator () and returns Arc::Weight. The functor itself implements the mapping details, e.g. see lexicographic unit tests |
| Cfst::GenericWeightMapper< FromArc, ToArc, WeightMakerFunctorT > | Templated Mapper that modifies weights when copying from one FST to another, passing through the other values of the arc. This mapper is to be combined with any functor that accepts FromArc::Weight as a unique parameter for operator () and returns ToArc::Weight. The functor itself implements the mapping details |
| Cfst::GetNGrams< Arc > | Functor with recursive procedure that extracts into a vector all the possible ngrams of a lattice, up to a given order, and starting from a given state |
| Cfst::GetWeight< Arc > | |
| Cfst::GetWeight< LexStdArc > | |
| Cucam::hifst::GrammarData | Struct containing grammar rules |
| Cfst::HackScore< StateT > | |
| Cfst::HackScore< lm::np::State > | |
| Cfst::HackScoreBilingual< StateT > | |
| Cfst::HackScoreBilingual< lm::np::State > | |
| Cucam::util::HashEqVec< VecT > | |
| Chasheqvecint64 | |
| Cuk.ac.cam.eng.extraction.hadoop.util.HFilePrint | |
| Cucam::hifst::HifstClientTaskData | Data class containing relevant variables. To be used as template for task classes using it |
| Cucam::hifst::HifstTaskData< ArcT > | Data class containing relevant variables. To be used as template for task classes using it |
| Cucam::hifst::HifstTaskData<> | |
| ►Cfst::Hyp< Arc > | Struct template that represents a hypothesis in a lattice |
| CHypW< Arc > | Same as Hyp but the printing will convert integer ids to words |
| CHypW< Arc > | Same as Hyp but the printing will convert integer ids to words |
| Cfst::hypcost | Struct for priority queue comparison |
| Cucam::fsttools::IdBridge | |
| CIntegerEncRefs | |
| Cucam::lmert::IntervalBoundary | |
| CIntervalData< ErrorStats > | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.IntWritableCache | |
| Cucam::util::iszfstream | Wrapper stream class that reads pipes, text files or gzipped files |
| ►CIterable | |
| Cuk.ac.cam.eng.rule.retrieval.HFileRuleReader | |
| ►Citerator | |
| CCompositeList::cl_iterator | |
| Cucam::fsttools::KenLMData | Language Model data structure |
| Cucam::fsttools::KenLMModelHelper< KenLMModelT > | |
| CLabeledFeature< Value, Weight > | |
| Cfst::LexStdToStdMapper | LexStdArc to StdArc Mapper |
| Cfst::LexToStd | |
| Cucam::lmert::LineOptimize< Arc > | |
| Cucam::lmbr::LmbrTaskData | |
| Cucam::lmbr::lmbrtunedata | |
| CLMertAlgorithm | |
| Cucam::hifst::LocalPruningConditions | Convenience class that takes care of local pruning conditions. Conditions are indexed by 1000*cc+y, so you can search through all conditions and get to the closest set of conditions that apply |
| Cucam::fsttools::LRUCache | |
| Cucam::util::MainClass | |
| Cfst::MakeSparseVectorWeight< Arc > | Templated Functor to generate a sparse vector weight from any other representation |
| Cfst::MakeSparseVectorWeight< LexStdArc > | Template specialization of MakeSparseVectorWeight functor for LexStdArc |
| Cfst::MakeWeight< Arc > | Templated functor that creates a weight given a float |
| Cfst::MakeWeight2< Arc > | Templated functor that creates a weight given a float |
| Cfst::MakeWeight2< LexStdArc > | Specialized implementation of MakeWeight2 for lexicographic semiring over two tropical weights. Second weight is set to the same input weight |
| Cfst::MakeWeight< LexStdArc > | Specialized implementation of MakeWeight for lexicographic semiring over two tropical weights. Second weight is set to One() |
| Cfst::MakeWeight< TupleArc32 > | Template specialization of functor MakeWeight for TupleArc32. See lexicographic-tropical-tropical-funcs.h |
| Cucam::hifst::MakeWeightHifst< Arc > | |
| Cucam::hifst::MakeWeightHifst< fst::LexStdArc > | |
| Cucam::hifst::MakeWeightHifst< TupleArc32 > | |
| Cucam::hifst::MakeWeightHifstLocalLm< Arc > | |
| Cucam::hifst::MakeWeightHifstLocalLm< fst::LexStdArc > | |
| Cucam::hifst::MakeWeightHifstLocalLm< TupleArc32 > | |
| Cucam::hifst::ManualReplaceFstByArc< Arc > | Creates FST replacement or not depending on conditions including program options |
| Cucam::fsttools::MapCursor | |
| Cucam::fsttools::MapCursorRev | |
| Cucam::fsttools::MergeFeatures | |
| CMERT | Hifst-specific classes and methods included in this namespace |
| CMertEnvelope | |
| Cucam::lmert::MertEnvelope< Arc > | |
| CMertLattice | |
| Cucam::lmert::MertLattice< Arc > | |
| Cucam::lmert::MertLatticeWrap< Arc > | |
| CMertLine | |
| Cucam::lmert::MertLine< Arc > | |
| CMertOpt | |
| Cfst::MultiUnionRational< Arc > | This class creates the Union of an arbitrarily large number of fsts. This implementation was suggested by Cyril (13-08-2009), as a more efficient alternative to using consecutive Union() over two VectorFsts. The reason being that this generates internally a list of ReplaceFsts |
| Cfst::MultiUnionReplace< Arc > | This class creates the Union of an arbitrarily large number of fsts. This implementation uses one RTN to generate the union |
| Cucam::hifst::NonTerminalHierarchy | This is a functor with additional methods to include relevant rules (i.e. identify SCFG rules, S -> X X, X -> V V ) and determine the hierarchy of non-terminals within the grammar |
| Cucam::util::NoThreadPool | Trivial struct that can replace seamlessly the threadpool for single threaded executions |
| Cucam::fsttools::NullAction | |
| ►Cucam::util::NumberRangeInterface< NumberType > | Interface for an arbitrary range of numbers |
| Cucam::util::InfiniteRange< NumberType > | Implements a Range iterator that will never finish |
| Cucam::util::NumberRange< NumberType > | |
| Cucam::util::OneRange< NumberType > | Implements a Range iterator that only runs once. This is useful e.g. for fsttools that process a batch of files if range is specificied, and only one if not |
| ►Cucam::util::NumberRangeInterface< float > | |
| Cucam::util::NumberRange< float > | |
| Cucam::fsttools::OLabelToFeature | |
| Cucam::hifst::OptimizeMachine< Arc > | |
| Cucam::hifst::OptimizeMachineNoDetMin< Arc > | |
| ►COptimizer | |
| ►COptimizerImpl< Algo, ErrorSurface > | |
| CPowellOptimizer< Algo, ErrorSurface > | |
| CRandomOptimizer< Algo, ErrorSurface > | |
| COptimizeTask< Algo, ErrorSurface > | |
| Cucam::util::oszfstream | Wrapper stream class that writes to pipes, text files or gzipped files |
| Cuk.ac.cam.eng.util.Pair< T, U > | |
| CParamsConfig | |
| Cucam::util::ParamsInit< T > | Initializes a set of parameters from environment variables PARAMS_FILE or PARAMS |
| Cfst::ParamsInit< T > | |
| Cucam::util::PatternAddress< T > | Class that expands a wildcard into its actual value. This is useful e.g. for filenames ranging several sentences |
| Cucam::hifst::posindex | Struct containing rule positions and offsets |
| Cucam::hifst::PosIndexCompare | Functor Class that provides comparison accross the posindex structure. This is typically used e.g. with a priority queue. It can use CompareTool or any inherited class |
| Cgoogletesting::PostProTaskData | |
| Cucam::util::PQwmapcompare | Comparison functor for queue sorting |
| Cgoogletesting::PreProTaskData | |
| Cucam::fsttools::ProjectDeterminizeAction | |
| Cucam::fsttools::ProjectDeterminizeMinimizePushAction | |
| Cucam::fsttools::ProjectDeterminizePushAction | |
| CPruneStats | |
| CRandDirGenerator | |
| Cucam::lmert::RandomLineSearch< Arc > | |
| CRefsData | |
| Cucam::util::RegistryPO | |
| Cfst::RelabelUtil< Arc > | Utility functor for relabeling one or more lattices. Note that you can chain commands. See Unit test in fstutils.gtest.cpp for an example |
| Cfst::RelabelUtil< TupleArc32 > | |
| Cgoogletesting::RemoveWeight | |
| Cucam::hifst::ReplaceFstByArc< Arc > | Creates FST replacement or not depending on conditions |
| Cucam::hifst::RTN< Arc > | Convenience class that stores pointers to cell FSAs. These pointers are organized through a hash using a label built from (cc,x,y) as key |
| Cuk.ac.cam.eng.extraction.RuleExtractorTest | |
| Cuk.ac.cam.eng.rule.filtering.RuleFilter | |
| Cucam::hifst::RuleIdsToSparseWeightLatsData< KenLMModelT > | Data class containing relevant variables. To be used as template for task classes using it |
| Cuk.ac.cam.eng.rule.retrieval.RulePattern | |
| Cuk.ac.cam.eng.rule.retrieval.RuleRetriever | |
| Cucam::hifst::RulesToWeightsMapperObject | |
| CRunAlilatsToSplats< DataT, ArcT > | Include all necessary headers here |
| CRunApplyLm< DataT, ArcT > | Concrete RunTaskT implementation for applylm tool |
| CRunHifst< DataT, ArcT > | Include all necessary headers here |
| Cucam::util::Runner< SingleThreadedFunctorT, MultiThreadedFunctorT > | Convenience wrapper class that can kick off two type of executions: singlethreaded or multithreaded, triggered by program options. Possibly multithreading with 1 thread would do, but I keep both implementations as any plain bug that might arise will be easier to trace down with a normal execution (threadpool uses two, actually). The class is templated with two classes, one for single threading and another for multithreading. Note that the multithreading details are up to the second templated class. e.g. Runner<SingleThreadedFunctor,SingleThreadedFunctor> would not multithread at all ;-) |
| Cucam::util::Runner2< SingleThreadedFunctorT, MultiThreadedFunctorT > | Convenience wrapper class that can kick off two type of executions: single or multithreaded, triggered by program options. Possibly multithreading with 1 thread would do, but I keep both implementations as any plain bug that might arise will be easier to trace down with a serialized execution (threadpool uses two, actually). The class is templated with two classes, one for single threading and another for multithreading. Note that the multithreading details are up to the second templated class |
| Cucam::util::Runner3< SingleThreadedFunctorT, MultiThreadedFunctorT, ServerFunctorT > | Convenience wrapper class that can kick off three type of executions: singlethreaded, multithreaded, or server, triggered by program options. Possibly multithreading with 1 thread would do, but I keep both implementations as any plain bug that might arise will be easier to trace down with a single thread execution. The class is templated three functors, one for each type of execution Note that the details are up to the each of these functors |
| Cucam::fsttools::RunTask2< TaskOneT, TaskTwoT, DataT, ArcT > | Generic Runner2 class wrapper with the usual template structure required by the tasks in fsttools and hifst. This one is meant to be used by most of the tools |
| Cucam::fsttools::RunTask3< TaskOneT, TaskTwoT, TaskThreeT, DataT, ArcT > | Generic Runner3 class wrapper with the usual template structure required by hifst. It can be used by other tools that should support a server mode (see Runner2/Runner3 details) |
| CSample | |
| Cfst::Scale< StateT > | |
| Cfst::Scale< lm::np::State > | |
| Cfst::Scale< typename KenLMModelT::State > | |
| Cfst::ScaleWeight< Arc > | Function object that applies to every single weight a scaling factor |
| Cfst::ScaleWeight< LexStdArc > | Template specialization for LexStdArc of ScaleWeight |
| Cfst::Scorer< StateT, KenLMModelT, IdBridgeT, HackScoreT > | |
| ►CScorer | |
| CScorerImpl< RefData > | |
| Cfst::Scorer< lm::np::State, lm::np::Model, IdBridgeT, HackScoreT > | |
| Cucam::hifst::SentenceSpecificGrammarData | Structure for sentence-specific grammar Rules will be queried by cyk per position and number of elements in the right-hand-side (source) of the rule Therefore indices are stored in this fashion so queries can be done directly. Note: a more efficient implementation could be to store these rule indices in a structure much closer even to the cyk grid. For instance, if an instanced pattern has never been seen below span 5, there is no need for the cyk to query and reject it |
| Cuk.ac.cam.eng.extraction.hadoop.util.SequenceFilePrint | |
| Cmertfst::ShortestDistanceOptions< Arc, Queue, ArcFilter > | |
| Cmertfst::ShortestDistanceState< Arc, Queue, ArcFilter > | |
| Cuk.ac.cam.eng.rule.retrieval.SidePattern | |
| Cucam::util::silent | Provides methods to set and get silent logging mode |
| ►CSparsePowerWeight | |
| Cfst::TropicalSparseTupleWeight< T > | Implements Tropical Sparse tuple weight semiring, extending from openfst SparsePowerWeight class |
| Cfst::TropicalSparseTupleWeight< T > | Implements Tropical Sparse tuple weight semiring, extending from openfst SparsePowerWeight class |
| Cucam::fsttools::SpeedStatsData | |
| Cfst::StateHandler< StateT > | |
| Cucam::fsttools::StateHandler | |
| Cfst::StateHandler< lm::np::State > | |
| Cfst::StateHandler< typename KenLMModelT::State > | |
| Cucam::fsttools::StatsData | Contains data for statistics, i.e. allows timing actions and methods called during execution |
| Cfst::StdToLexStdMapper | StdArc to LexStdArc mapper |
| Cfst::StdToTropicalSparseMapper< W > | |
| Cfst::StdToVector< T > | Functor that converts tropical to sparse tuple weight |
| CTaskData | Trivial Data class with necessary variables for correct compilation |
| Cucam::util::TaskFunctor< Data > | Simple functor that accepts an interface and pointer to the data object in which it will have to run The actual task running is delayed to the call of the (). This is useful e.g. for task dispatching in the threadpool pattern. This functor deletes data and task as soon as it is guaranteed to have been completely executed |
| ►Cucam::util::TaskInterface< Data > | Templated (hybrid) Interface for Task classes |
| Cgoogletesting::PostEditTask< Data > | This is a test to show how an imaginary postedit class could work. The class would contain a pointer to the whole hifst system A single run of PostEditTask may kickoff several times the decoder |
| Cgoogletesting::Task1< Data > | Trivial task class implementing run method to modify first bool variable |
| Cgoogletesting::Task2< Data > | Trivial task class implementing run method to modify second bool variable |
| Cgoogletesting::Task2b< Data > | Trivial task class implementing run method to modify second bool variable. Additionally, signals that execution is to stop after finishing with Task2b |
| Cgoogletesting::Task3< Data > | Trivial task class implementing run method to modify third bool variable |
| Cgoogletesting::Task4< Data > | Trivial task class, implements run to modify DataTest2 |
| Cucam::fsttools::ApplyBiLMTask< Data, Arc > | |
| Cucam::fsttools::ApplyLanguageModelTask< Data, Arc > | Language model loader task, loads a language model wrapping it in a class to provide |
| Cucam::fsttools::DisambigTask< Data, Arc > | Disambig Task tool. Given a search space, applies a unigram transduction model (generating alternatives) and an ngram model over alternatives |
| Cucam::fsttools::LoadLanguageModelTask< Data > | Language model loader task, loads a language model wrapping it in a class to provide |
| Cucam::fsttools::LoadUnimapTask< Data, Arc > | Loads a unigram transduction model (aka unimap file) from a file with the format accepted by srilm disambig tool |
| Cucam::fsttools::LoadWordMapTask< Data > | Loads wordmap in constructor and delivers pointer to data object during run time |
| Cucam::fsttools::OptimizeFstTask< Data, Arc > | Convenience class that inherits Taskinterface behaviour and optimizes an fst |
| Cucam::fsttools::ReadFstTask< Data, Arc > | Convenience class that loads an fst using a key defined in the constructor and delivers it to the data object |
| Cucam::fsttools::SpeedStatsTask< Data > | Task that reads stats from data object and writes them to a [file] |
| Cucam::fsttools::TuneWpWriteFstTask< Data, Arc > | Convenience class that inherits Taskinterface behaviour and writes an fst to [file] using a key defined in the constructor. The key is used to access the registry object (i.e. actual program option telling where to write the fst) and a pointer in the data object, telling where to read the fst from |
| Cucam::fsttools::WriteFstTask< Data, Arc > | Convenience class that inherits Taskinterface behaviour and writes an fst to [file] using a key defined in the constructor. The key is used to access the registry object (i.e. actual program option telling where to write the fst) and a pointer in the data object, telling where to read the fst from |
| Cucam::hifst::CYKParserTask< Data > | Implements cyk+ parser |
| Cucam::hifst::DumpNbestFeaturesTask< Data, Arc > | Task that dumps nbest and feature file. Templated on specific Data object and Fst Arc |
| Cucam::hifst::GrammarTask< Data > | Task class that loads a grammar into memory |
| Cucam::hifst::HifstStatsTask< Data > | Reads StatsData and dumps all stats to (sentence-specific) file. Provides a special method for cyk data: dumps a grid in text format with relevant information per cell |
| Cucam::hifst::HiFSTTask< Data, Arc, OptimizeT, CYKdataT, MultiUnionT, ExpandedNumStatesRTNT, ReplaceFstByArcT, RTNT > | Core of Hifst. Implements the lattice-building procedure for a cyk-parsed sentence |
| Cucam::hifst::MultiThreadedCreateSentenceSpecificGrammarTask< Data > | Full multi-threaded Translation system |
| Cucam::hifst::PatternsToInstancesTask< Data > | Converts patterns to instanced patterns |
| Cucam::hifst::PostProTask< Data, Arc > | Task that writes translation to a text file. This translation might be recased, wordmapped and tokenized |
| Cucam::hifst::PreProTask< Data > | Reads text file, performs tokenization and integer-mapping |
| Cucam::hifst::ReferenceFilterTask< Data, Arc > | Generates a substring version of a reference translation lattice and associated vocabulary. This substring fst is typically used to guide translation towards a particular search space. The associated vocabulary can be used e.g. to restrict parsing algorithms |
| Cucam::hifst::SentenceSpecificGrammarTask< Data > | This class uses instantiated patterns to analyze the grammar and deliver two hashes providing candidate rules for a (cyk) parser to validate them. The first hash is for rules with only one element (e.g. A->word, A->B). The second hash is for rules with two or more elements. Both hashes require two keys: the word position in the sentence (x) and the first element of the rule (which can be either a word or non-terminal) |
| Cucam::hifst::SingleThreadedCreateSentenceSpecificGrammarTask< Data > | Full single-threaded Translation system |
| Cucam::hifst::SingleThreadedHifstClientTask< Data > | Full single-threaded Translation system |
| Cucam::hifst::SparseWeightVectorLatticesTask< Data, Arc > | Creates lattices using tropical tuple weight semiring – each arc containing separate feature weight contributions. Note that the semiring is tropical under dot product of all these features with its scales |
| Cucam::lmbr::LmbrTask< Data > | Lattice MBR task |
| Cucam::lmbr::MultiThreadedLmbrTask< Data > | Not implemented yet! |
| Cucam::lmbr::SingleThreadedLmbrTask< Data > | Full single-threaded Alignment lattices to Sparse lattices |
| ►Cucam::util::TaskInterface< DataT > | |
| ►Cucam::hifst::LoadSparseWeightFlowerLatticeTask< DataT > | Implements a class that loads the grammar sparseweight flower lattice and stores a pointer on the data object |
| Cucam::hifst::LoadSparseWeightsTask< DataT > | |
| ►Cucam::util::TaskInterface< DataT< ArcT > > | |
| Cucam::fsttools::MultiThreadedApplyLanguageModelTask< DataT, ArcT > | Class for multithreaded application of language model. Inherits taskinterface and provides standalone function object behaviour |
| Cucam::fsttools::SingleThreadedApplyLanguageModelTask< DataT, ArcT > | Class for single threaded application of language model. It inherits taskinterface behaviour and also provides standalone function object behaviour |
| Cucam::hifst::HifstServerTask< DataT, ArcT > | Translation Server |
| Cucam::hifst::MultiThreadedHifstTask< DataT, ArcT > | Full multi-threaded Translation system |
| Cucam::hifst::SingleThreadedHifstTask< DataT, ArcT > | Full single-threaded Translation system |
| ►Cucam::util::TaskInterface< DataT< TupleArc32 > > | |
| Cucam::hifst::MultiThreadedAliLatsToSparseVecLatsTask< DataT, ArcT > | Multithreaded implementation of alilats2splats pipeline |
| Cucam::hifst::SingleThreadedAliLatsToSparseVecLatsTask< DataT, ArcT > | Full single-threaded Alignment lattices to Sparse lattices |
| ►Cucam::util::TaskInterface< RuleIdsToSparseWeightLatsData<> > | |
| Cucam::hifst::SingleThreadededRulesToWeightsSparseLatsTask | Full single-threaded Alignment lattices to Sparse lattices |
| ►Cucam::util::TaskInterface< uh::HifstTaskData<> > | |
| Cucam::hifst::CYKParserTask< uh::HifstTaskData<> > | |
| Cucam::hifst::GrammarTask< uh::HifstTaskData<> > | |
| Cucam::hifst::SentenceSpecificGrammarTask< uh::HifstTaskData<> > | |
| ►CTest | |
| CHifstTest | Hifst test class for google test fixtures |
| Cuk.ac.cam.eng.util.TestCommandLineInterface | |
| Cuk.ac.cam.eng.rule.features.TestFeatureRegistry | |
| CTGMertAlgorithm< Arc, T > | |
| Cucam::lmbr::Theta | Functor handling LMBR theta parameters |
| Cucam::fsttools::TopoFeaturesHelper< ActionT > | A wrapper that runs maps labels to topological features, runs an "action" (sequence of standard fst operations defined as a policy per ActionT), and then expands the resulting lattice and moves topological features to allow for a 1-1 reverse mapping from features to output labels on the same arcs |
| Cucam::util::TrivialThreadPool | Trivial implementation of a threadpool based on boost::asio methods When initiated, creates a threadpool of n threads (n <= number of cpus). Jobs should be submitted with the templated operator(). When the object is deleted it will wait for all threads to finish |
| Cuk.ac.cam.eng.extraction.hadoop.features.lexical.TTableClient | |
| CTuneSet | |
| Cucam::fsttools::TuneSet< Arc > | |
| CTuneWpMain< Arc > | |
| ►Cunary_function | |
| Chashfvecint64 | |
| Cucam::util::HashFVec< VecT > | |
| Cuk.ac.cam.eng.extraction.hadoop.util.Util | |
| CVectorToFunctionMapper< FromArc, T > | |
| Cfst::VectorToStd< T > | Functor to convert sparse tuple weight to tropical (single weight) |
| Cucam::util::WordMapper | Loads efficiently a wordmap file and provides methods to map word-to-integer or integer-to-word. To avoid memory footprint issues, hashing the wordmap entries is avoided |
| Cfst::WordPenaltyMapper< Arc > | Templated Mapper that inserts a word penalty over an FST, skipping user defined epsilon arcs |
| ►CArrayList | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.TargetFeatureList | |
| ►CArrayWritable | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.TextArrayWritable | |
| ►CCloseable | |
| Cuk.ac.cam.eng.extraction.hadoop.features.lexical.TTableServer | |
| ►CConfigured | |
| Cuk.ac.cam.eng.extraction.hadoop.extraction.ExtractorJob | |
| ►Cuk.ac.cam.eng.extraction.hadoop.features.phrase.PhraseJob | |
| Cuk.ac.cam.eng.extraction.hadoop.features.phrase.Source2TargetJob | |
| Cuk.ac.cam.eng.extraction.hadoop.features.phrase.Target2SourceJob | |
| Cuk.ac.cam.eng.extraction.hadoop.merge.MergeJob | |
| ►CEnumMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.FeatureMap | |
| ►CFileOutputFormat | |
| Cuk.ac.cam.eng.extraction.hadoop.util.SimpleHFileOutputFormat | |
| ►CHashMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.AlignmentCountMapWritable | |
| ►CMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.ProvenanceCountMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.ProvenanceProbMap | |
| ►CTool | |
| Cuk.ac.cam.eng.extraction.hadoop.extraction.ExtractorJob | |
| Cuk.ac.cam.eng.extraction.hadoop.features.phrase.PhraseJob | |
| Cuk.ac.cam.eng.extraction.hadoop.merge.MergeJob | |
| ►CWritable | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.AlignmentCountMapWritable | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.ExtractedData | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.FeatureMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.ProvenanceCountMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.ProvenanceProbMap | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.RuleData | |
| Cuk.ac.cam.eng.extraction.hadoop.datatypes.TargetFeatureList | |
| ►CWritableComparator | |
| Cuk.ac.cam.eng.extraction.hadoop.merge.MergeComparator | |
1.8.11