| ►Cmeta::analyzers::analyzer | An class that provides a framework to produce token counts from documents |
| Cmeta::analyzers::ngram_analyzer | Analyzes documents based on an ngram word model, where the value for n is supplied by the user |
| Cmeta::util::basic_range< T > | Implements a range that spans a loop's extension and termination conditions, most useful for iterating over a range of numbers with a range-based for loop |
| Cmeta::index::chunk< PrimaryKey, SecondaryKey > | Represents a portion of a disk_index's postings file |
| Cmeta::index::chunk_handler< Index > | An interface for writing and merging inverted chunks of postings_data for a disk_index |
| ►Cmeta::classify::classifier | A classifier uses a document's feature space to identify which group it belongs to |
| ►Cmeta::classify::binary_classifier | A classifier which classifies documents as "positive" or "negative" |
| Cmeta::classify::sgd | Implements stochastic gradient descent for learning binary linear classifiers |
| Cmeta::classify::dual_perceptron | Implements a perceptron classifier, but using the dual formulation of the problem |
| Cmeta::classify::knn | Implements the k-Nearest Neighbor lazy learning classification algorithm |
| Cmeta::classify::logistic_regression | Multinomial logistic regression |
| Cmeta::classify::naive_bayes | Implements the Naive Bayes classifier, a simplistic probabilistic classifier that uses Bayes' theorem with strong feature independence assumptions |
| Cmeta::classify::nearest_centroid | Implements the nearest centroid classification algorithm |
| Cmeta::classify::one_vs_all | Generalizes binary classifiers to operate over multiclass types using the one vs all method |
| Cmeta::classify::one_vs_one | Ensemble method adaptor for extending binary_classifiers to the multi-class classification case by using a one-vs-one strategy |
| Cmeta::classify::svm_wrapper | Wrapper class for liblinear (http://www.csie.ntu.edu.tw/~cjlin/liblinear/) and libsvm (http://www.csie.ntu.edu.tw/~cjlin/libsvm/) implementation of support vector machine classification |
| Cmeta::classify::winnow | Implements the Winnow classifier, a simplistic linear classifier for linearly-separable data |
| ►Cmeta::sequence::sequence_analyzer::collector | Interface class used for analyzing observations inside user-provided feature functions |
| ►Cmeta::sequence::sequence_analyzer::basic_collector< const sequence_analyzer > | |
| Cmeta::sequence::sequence_analyzer::const_collector | Const version of the collector |
| ►Cmeta::sequence::sequence_analyzer::basic_collector< sequence_analyzer > | |
| Cmeta::sequence::sequence_analyzer::default_collector | Non-const version of the collector |
| Cmeta::sequence::sequence_analyzer::basic_collector< Analyzer > | Implementation-detail collector |
| Cmeta::util::comparable< Derived > | A CRTP base class that allows for inheritance of all comparator operators given that the derived class defines an operator<() |
| ►Cmeta::util::comparable< identifier< Derived, T > > | |
| ►Cmeta::util::identifier< Derived, T > | CRTP base template that denotes an identifier |
| Cmeta::util::numerical_identifier< Derived, T > | A CRTP template base that adds numeric functionality to the identifier type |
| ►Cmeta::util::comparable< optional< class_label > > | |
| Cmeta::util::optional< class_label > | |
| ►Cmeta::util::comparable< optional< dense_matrix< double > > > | |
| Cmeta::util::optional< dense_matrix< double > > | |
| ►Cmeta::util::comparable< optional< io::mmap_file > > | |
| Cmeta::util::optional< io::mmap_file > | |
| ►Cmeta::util::comparable< optional< label_id > > | |
| Cmeta::util::optional< label_id > | |
| ►Cmeta::util::comparable< optional< meta::index::string_list > > | |
| Cmeta::util::optional< meta::index::string_list > | |
| ►Cmeta::util::comparable< optional< meta::index::vocabulary_map > > | |
| Cmeta::util::optional< meta::index::vocabulary_map > | |
| ►Cmeta::util::comparable< optional< meta::sequence::forward_trellis > > | |
| Cmeta::util::optional< meta::sequence::forward_trellis > | |
| ►Cmeta::util::comparable< optional< meta::sequence::trellis > > | |
| Cmeta::util::optional< meta::sequence::trellis > | |
| ►Cmeta::util::comparable< optional< std::string > > | |
| Cmeta::util::optional< std::string > | |
| ►Cmeta::util::comparable< optional< T > > | |
| Cmeta::util::optional< T > | A class for representing optional values |
| ►Cmeta::util::comparable< optional< tag_t > > | |
| Cmeta::util::optional< tag_t > | |
| ►Cmeta::util::comparable< optional< uint64_t > > | |
| Cmeta::util::optional< uint64_t > | |
| ►Cmeta::util::comparable< optional< util::disk_vector< crf_feature_id > > > | |
| Cmeta::util::optional< util::disk_vector< crf_feature_id > > | |
| ►Cmeta::util::comparable< optional< util::disk_vector< double > > > | |
| Cmeta::util::optional< util::disk_vector< double > > | |
| ►Cmeta::util::comparable< optional< util::disk_vector< label_id > > > | |
| Cmeta::util::optional< util::disk_vector< label_id > > | |
| ►Cmeta::util::comparable< optional< util::disk_vector< uint64_t > > > | |
| Cmeta::util::optional< util::disk_vector< uint64_t > > | |
| ►Cmeta::util::comparable< optional< Value > > | |
| Cmeta::util::optional< Value > | |
| ►Cmeta::util::comparable< transition > | |
| Cmeta::parser::transition | Represents a transition taken by the parser |
| Cmeta::io::compressed_file_reader | Represents a file of unsigned integers compressed using gamma compression |
| Cmeta::io::compressed_file_writer | Writes to a file of unsigned integers using gamma compression |
| Cmeta::classify::confusion_matrix | Allows interpretation of classification errors |
| Cmeta::parser::const_visitor< T > | Abstract base class for visitors over parse trees that do not modify the underlying tree |
| ►Cmeta::parser::const_visitor< bool > | |
| Cannotation_checker | |
| Cbinary_checker | |
| Cmeta::testing::annotation_checker | |
| Cmeta::testing::binary_checker | |
| ►Cmeta::parser::const_visitor< std::unique_ptr< node > > | |
| ►Cmeta::parser::tree_transformer | Abstract base class for tree transformers |
| Cmeta::parser::annotation_remover | A tree transformer that removes annotations (currently only Penn Treebank style) from trees |
| Cmeta::parser::binarizer | A tree transformer that converts any n-ary productions to binary productions using provided head annotations |
| Cmeta::parser::debinarizer | A tree transformer that converts binarized trees back into n-ary trees |
| Cmeta::parser::empty_remover | A tree transformer that removes trace elements (like "-NONE-" in the Penn Treebank) as well as nodes with empty yields |
| Cmeta::parser::multi_transformer< Transformers > | A template class for composing tree transformers |
| Cmeta::parser::unary_chain_remover | Transforms trees by removing any unary X -> X rules |
| ►Cmeta::parser::const_visitor< void > | |
| Cmeta::parser::leaf_node_finder | This is a visitor that finds all of the leaf nodes in a parse tree |
| Cmeta::parser::sequence_extractor | This is a visitor that converts a parse tree into a POS-tagged sequence |
| Cmeta::parser::transition_finder | This is a visitor that converts a parse tree into a list of transitions that a shift-reduce parser would have to take in order to generate it |
| ►Cmeta::corpus::corpus | Provides interface to with multiple corpus input formats |
| Cmeta::corpus::file_corpus | Creates document objects from individual files, each representing a single document |
| Cmeta::corpus::gz_corpus | Fills document objects with content line-by-line from gzip-compressed input files |
| Cmeta::corpus::line_corpus | Fills document objects with content line-by-line from an input file |
| Cmeta::sequence::crf | Linear-chain conditional random field for POS tagging and chunking applications |
| Cmeta::caching::dblru_cache< Key, Value, Map > | A double-barrel approach at a LRU cache |
| Cmeta::graph::default_edge | |
| Cmeta::graph::default_node | |
| Cmeta::util::dense_matrix< T > | Simple wrapper class for representing a dense matrix laid out in row-major order (that is, its internal representation is a linear array of the rows) |
| Cmeta::util::dense_matrix< double > | |
| Cmeta::util::dense_matrix< label_id > | |
| Cdirected_graph< A, B > | |
| Cmeta::graph::undirected_graph< Node, Edge >::directed_graph< A, B > | |
| Cmeta::stats::dirichlet< T > | Represents a Dirichlet distribution |
| Cmeta::stats::dirichlet< class_label > | |
| Cmeta::stats::dirichlet< term_id > | |
| Cmeta::stats::dirichlet< topic_id > | |
| ►Cmeta::index::disk_index | Holds generic data structures and functions that inverted_index and forward_index both use |
| Cmeta::index::forward_index | The forward_index stores information on a corpus by doc_ids |
| Cmeta::index::inverted_index | Stores information on a corpus indexed by term_ids |
| Cmeta::index::disk_index::disk_index_impl | The implementation of a disk_index |
| Cmeta::util::disk_vector< T > | Disk_vector represents a large constant-size vector that does not necessarily fit in memory |
| Cmeta::util::disk_vector< crf_feature_id > | |
| Cmeta::util::disk_vector< double > | |
| Cmeta::util::disk_vector< label_id > | |
| Cmeta::util::disk_vector< uint64_t > | |
| Cmeta::corpus::document | Represents an indexable document |
| Cmeta::parser::evalb | A re-implementation of (some of) the evalb metrics |
| ►Cstd::exception | STL class |
| ►Cstd::runtime_error | STL class |
| Cmeta::analyzers::analyzer::analyzer_exception | Basic exception for analyzer interactions |
| Cmeta::analyzers::token_stream::token_stream_exception | Basic exception class for token stream interactions |
| Cmeta::caching::splay_cache< Key, Value >::splay_cache_exception | Basic exception for splay_cache interactions |
| Cmeta::classify::knn::knn_exception | Basic exception for knn interactions |
| Cmeta::classify::linear_model_exception | Exception thrown during interactions with linear_models |
| Cmeta::classify::nearest_centroid::nearest_centroid_exception | Basic exception for nearest_centroid interactions |
| Cmeta::corpus::corpus::corpus_exception | Basic exception for corpus interactions |
| Cmeta::graph::algorithms::graph_algorithm_exception | Exception for errors in graph algorithms |
| Cmeta::graph::directed_graph_exception | Basic exception for directed_graph interactions |
| Cmeta::graph::graph_exception | Basic exception for graph interactions |
| Cmeta::graph::undirected_graph_exception | Basic exception for undirected_graph interactions |
| Cmeta::index::chunk_handler< Index >::chunk_handler_exception | Simple exception class for chunk_handler interactions |
| Cmeta::index::forward_index::forward_index_exception | Basic exception for forward_index interactions |
| Cmeta::index::inverted_index::inverted_index_exception | Basic exception for inverted_index interactions |
| Cmeta::index::ir_eval::ir_eval_exception | Basic exception for ir_eval interactions |
| Cmeta::index::vocabulary_map_writer::vocabulary_map_writer_exception | An exception that can be thrown during the building of the tree |
| Cmeta::io::compressed_file_reader::compressed_file_reader_exception | Basic exception for compressed_file_reader interactions |
| Cmeta::io::compressed_file_writer::compressed_file_writer_exception | Basic exception for compressed_file_writer interactions |
| Cmeta::io::libsvm_parser::libsvm_parser_exception | Exception class for this parser |
| Cmeta::io::mmap_file::mmap_file_exception | Basic exception for mmap_file interactions |
| Cmeta::parser::binarizer::exception | |
| Cmeta::parser::sr_parser::exception | Exception thrown during parser actions |
| Cmeta::parser::transition::exception | Exception thrown during interactions with transitions |
| Cmeta::parser::transition_finder::exception | |
| Cmeta::parser::transition_map::exception | Exception thrown from interactions with the transition_map |
| Cmeta::sequence::observation::exception | Basic exception class for observation interactions |
| Cmeta::sequence::sequence_analyzer::exception | |
| Cmeta::testing::unit_test_exception | Exception class used to report errors in the unit test |
| Cmeta::util::bad_optional_access | Exception thrown when trying to obtain the value of a non-engaged optional |
| Cmeta::util::disk_vector< T >::disk_vector_exception | Basic exception for disk_vector |
| Cmeta::util::factory< DerivedFactory, Type, Arguments >::exception | Simple exception for factories |
| Cmeta::util::invertible_map< Key, Value >::invertible_map_exception | Basic exception for invertible_map interactions |
| Cmeta::util::persistent_stack< T >::exception | |
| Cmeta::util::factory< DerivedFactory, Type, Arguments > | Generic factory that can be subclassed to create factories for specific types |
| ►Cmeta::util::factory< analyzer_factory, analyzer, const cpptoml::table &, const cpptoml::table & > | |
| Cmeta::analyzers::analyzer_factory | Factory that is responsible for creating analyzers from configuration files |
| ►Cmeta::util::factory< binary_classifier_factory, binary_classifier, const cpptoml::table &, std::shared_ptr< index::forward_index >, class_label, class_label > | |
| Cmeta::classify::binary_classifier_factory | Factory that is responsible for creating binary classifiers from configuration files |
| ►Cmeta::util::factory< classifier_factory, classifier, const cpptoml::table &, std::shared_ptr< index::forward_index >, std::shared_ptr< index::inverted_index > > | |
| Cmeta::classify::classifier_factory | Factory that is responsible for creating classifiers from configuration files |
| ►Cmeta::util::factory< featurizer_factory, tree_featurizer > | |
| Cmeta::analyzers::featurizer_factory | Factory that is responsible for creating tree featurizers from configuration files |
| ►Cmeta::util::factory< filter_factory, token_stream, std::unique_ptr< token_stream >, const cpptoml::table & > | |
| Cmeta::analyzers::filter_factory | Factory that is responsible for creating filters during analyzer construction |
| ►Cmeta::util::factory< loss_function_factory, loss_function > | |
| Cmeta::classify::loss::loss_function_factory | Factory that is responsible for creating loss functions from strings |
| ►Cmeta::util::factory< ranker_factory, ranker, const cpptoml::table & > | |
| Cmeta::index::ranker_factory | Factory that is responsible for creating rankers from configuration files |
| Cmeta::testing::file_guard | Always makes sure a new file is created |
| Cmeta::caching::generic_shard_cache< Key, Value, Map > | A simple sharding-based approach for increasing concurrency within a cache |
| ►Cmeta::graph::graph< Node, Edge > | |
| Cmeta::graph::directed_graph< Node, Edge > | A (currently) simple class to represent a directed graph in memory |
| Cmeta::graph::undirected_graph< Node, Edge > | A simple class to represent a directed graph in memory |
| Cstd::hash< meta::index::postings_data< PrimaryKey, SecondaryKey > > | Hash specialization for postings_data<PrimaryKey, SecondaryKey> |
| Cstd::hash< meta::util::hash_wrapper< Wrapped > > | A partial specialization that allows for hashing of hash_wrapper types based on their base type |
| Cmeta::parser::head_rule | |
| Cmeta::utf::icu_handle | Internal class that ensures that ICU cleans up all of its "still-reachable" memory before program termination |
| Cmeta::analyzers::tokenizers::icu_tokenizer::impl | Implementation class for the icu_tokenizer |
| Cmeta::index::forward_index::impl | Implementation of a forward_index |
| Cmeta::index::inverted_index::impl | Implementation of an inverted_index |
| Cmeta::utf::segmenter::impl | Implementation class for the segmenter |
| Cmeta::utf::transformer::impl | Implementation class for the transformer |
| ►CIndex | |
| Cmeta::index::cached_index< Index, Cache > | Decorator class for wrapping indexes with a cache |
| Cmeta::util::nullopt_t::init | An empty object |
| Cmeta::util::invertible_map< Key, Value > | This data structure indexes by keys as well as values, allowing constant amortized lookup time by key or value |
| Cmeta::util::invertible_map< class_label, label_id > | |
| Cmeta::util::invertible_map< tag_t, label_id > | |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_istream< Char > | STL class |
| ►Cstd::istream | STL class |
| Cmeta::io::gzifstream | |
| ►Cstd::basic_ostream< Char > | STL class |
| ►Cstd::ostream | STL class |
| Cmeta::io::gzofstream | |
| Cmeta::index::ir_eval | Evaluates lists of ranked documents returned from a search engine; can give stats per-query (e.g |
| ►Citerator | |
| Cedge_iterator< Iter > | |
| Cmeta::graph::directed_graph< Node, Edge >::edge_iterator< Iter > | |
| Cmeta::graph::directed_graph< Node, Edge >::node_iterator< Iter > | |
| Cmeta::graph::undirected_graph< Node, Edge >::edge_iterator< Iter > | |
| Cmeta::graph::undirected_graph< Node, Edge >::node_iterator< Iter > | |
| Cmeta::util::disk_vector< T >::iterator | Provides iterator functionality for the disk_vector class |
| Cmeta::util::invertible_map< Key, Value >::Iterator | The invertible_map iterator is really just a wrapper for the forward (key -> value) unordered_map iterator |
| Cnode_iterator< Iter > | |
| Cmeta::util::basic_range< T >::iterator_t< Plus > | Iterator to traverse the generic range |
| Cmeta::lm::language_model | |
| ►Cmeta::topics::lda_model | An LDA topic model base class |
| Cmeta::topics::lda_cvb | Lda_cvb: An implementation of LDA that uses collapsed variational bayes for inference |
| ►Cmeta::topics::lda_gibbs | A LDA topic model implemented using a collapsed gibbs sampler |
| Cmeta::topics::parallel_lda_gibbs | An LDA topic model implemented using the Approximate Distributed LDA algorithm |
| Cmeta::topics::lda_scvb | Lda_scvb: An implementation of LDA that uses stochastic collapsed variational Bayes for inference |
| Cmeta::classify::linear_model< FeatureId, FeatureValue, ClassId > | A storage class for multiclass linear classifier models |
| Cmeta::classify::linear_model< feature_id, double, label_id > | |
| Cmeta::classify::linear_model< std::string, float, trans_id > | |
| Cmeta::caching::locking_map< Key, Value > | A simple wrapper around a std::unordered_map that uses an internal mutex for synchronization safety |
| Cmeta::logging::logger::log_line | Log_line: Represents a single message to be written to all sinks |
| Cmeta::logging::logger | Logger: Main logging class |
| ►Cmeta::classify::loss::loss_function | Base class for all loss functions that can be passed to the sgd classifier |
| Cmeta::classify::loss::hinge | The hinge loss for SGD algorithms |
| Cmeta::classify::loss::huber | The huber loss for SGD algorithms |
| Cmeta::classify::loss::least_squares | The least-squares loss function for SGD algorithms |
| Cmeta::classify::loss::logistic | The logistic loss for SGD algorithms |
| Cmeta::classify::loss::modified_huber | The modified huber loss function for SGD algorithms |
| Cmeta::classify::loss::perceptron | The perceptron loss function for SGD algorithms |
| Cmeta::classify::loss::smooth_hinge | The smooth hinge loss function for SGD algorithms |
| Cmeta::classify::loss::squared_hinge | The squared hinge loss function for SGD algorithms |
| Cmeta::io::mmap_file | Memory maps a text file readonly |
| Cmeta::stats::multinomial< T > | Represents a multinomial/categorical distribution |
| Cmeta::stats::multinomial< class_label > | |
| Cmeta::stats::multinomial< term_id > | |
| Cmeta::stats::multinomial< topic_id > | |
| ►Cngram_analyzer | |
| ►Cmeta::util::multilevel_clonable< analyzer, ngram_analyzer, ngram_pos_analyzer > | |
| Cmeta::analyzers::ngram_pos_analyzer | Analyzes documents based on part-of-speech tags instead of words |
| ►Cmeta::util::multilevel_clonable< analyzer, ngram_analyzer, ngram_word_analyzer > | |
| Cmeta::analyzers::ngram_word_analyzer | Analyzes documents using their tokenized words |
| Cmeta::caching::no_evict_cache< Key, Value > | An incredibly simple "cache" that simply keeps everything in memory |
| Cmeta::caching::splay_cache< Key, Value >::node | One node in the splay tree contains pointers to children and the templated (key, value) pair |
| Cmeta::util::persistent_stack< T >::node | |
| Cmeta::parser::node | A single node in a parse tree for a sentence |
| Cmeta::util::nullopt_t | A dummy type for representing a disengaged option<T> |
| ►Cmeta::util::numeric | Empty helper class to denote that something is numeric |
| Cmeta::util::numerical_identifier< Derived, T > | A CRTP template base that adds numeric functionality to the identifier type |
| Cmeta::sequence::observation | Represents an observation in a tagged sequence |
| Cmeta::util::optional_dummy_t | A dummy type for optional storage |
| Cmeta::util::optional_storage< T > | A storage class for the optional<T> class |
| Cmeta::util::optional_storage< class_label > | |
| Cmeta::util::optional_storage< dense_matrix< double > > | |
| Cmeta::util::optional_storage< io::mmap_file > | |
| Cmeta::util::optional_storage< label_id > | |
| Cmeta::util::optional_storage< meta::index::string_list > | |
| Cmeta::util::optional_storage< meta::index::vocabulary_map > | |
| Cmeta::util::optional_storage< meta::sequence::forward_trellis > | |
| Cmeta::util::optional_storage< meta::sequence::trellis > | |
| Cmeta::util::optional_storage< std::string > | |
| Cmeta::util::optional_storage< tag_t > | |
| Cmeta::util::optional_storage< uint64_t > | |
| Cmeta::util::optional_storage< util::disk_vector< crf_feature_id > > | |
| Cmeta::util::optional_storage< util::disk_vector< double > > | |
| Cmeta::util::optional_storage< util::disk_vector< label_id > > | |
| Cmeta::util::optional_storage< util::disk_vector< uint64_t > > | |
| Cmeta::util::optional_storage< Value > | |
| Cmeta::sequence::crf::parameters | Wrapper to represent the parameters used during learning |
| Cmeta::stats::dirichlet< T >::parameters | |
| Cmeta::parser::parse_tree | Represents the parse tree for a sentence |
| Cmeta::io::parser | Parses a text file by reading it completely into memory, delimiting tokens by user request |
| Cmeta::sequence::perceptron | A greedy averaged perceptron tagger |
| Cmeta::util::persistent_stack< T > | |
| Cmeta::util::pimpl< Impl > | Class to assist in simple pointer-to-implementation classes |
| Cmeta::util::pimpl< meta::analyzers::tokenizers::icu_tokenizer::impl > | |
| Cmeta::util::pimpl< meta::index::disk_index::disk_index_impl > | |
| Cmeta::util::pimpl< meta::index::forward_index::impl > | |
| Cmeta::util::pimpl< meta::index::inverted_index::impl > | |
| Cmeta::util::pimpl< meta::utf::segmenter::impl > | |
| Cmeta::util::pimpl< meta::utf::transformer::impl > | |
| Cmeta::classify::kernel::polynomial | A polynomial kernel function for a linear classifier to adapt it to data that is not linearly separable |
| Cmeta::index::postings_data< PrimaryKey, SecondaryKey > | A class to represent the per-PrimaryKey data in an index's postings file |
| Cmeta::index::chunk_handler< Index >::producer | The object that is fed postings_data by the index |
| Cmeta::printing::progress | Simple class for reporting progress of lengthy operations |
| Cmeta::classify::kernel::radial_basis | A radial basis function kernel for linear classifiers to adapt them to data that is not linearly separable |
| ►Cmeta::index::ranker | A ranker scores a query against all the documents in an inverted index, returning a list of documents sorted by relevance |
| ►Cmeta::index::language_model_ranker | Scores documents according to one of three different smoothed language model scoring methods described in "A Study of Smoothing Methods for Language
Models Applied to Ad Hoc Information Retrieval" by Zhai and Lafferty, 2001 |
| Cmeta::index::absolute_discount | Implements the absolute discounting smoothing method |
| Cmeta::index::dirichlet_prior | Implements Bayesian smoothing with a Dirichlet prior |
| Cmeta::index::jelinek_mercer | Implements the Jelinek-Mercer smoothed ranking model |
| Cmeta::index::okapi_bm25 | The Okapi BM25 scoring function |
| Cmeta::index::pivoted_length | The pivoted document length normalization ranking function |
| Cmeta::index::score_data | A score_data object contains information needed to evaluate a ranking function |
| Cmeta::sequence::crf::scorer | Internal class that holds scoring information for sequences under the current model |
| Cmeta::utf::segmenter::segment | Represents a segment within a unicode string |
| Cmeta::utf::segmenter | Class that encapsulates segmenting unicode strings |
| Cmeta::sequence::sequence | Represents a tagged sequence of observations |
| Cmeta::sequence::sequence_analyzer | Analyzer that operates over sequences, generating features based on a set of "observation functions" |
| Cmeta::classify::kernel::sigmoid | A sigmoid kernel function for a linear classifier to adapt it to data that is not linearly separable |
| Cmeta::logging::logger::sink | Sink: A wrapper for a stream that a logger should write to |
| Cmeta::util::sparse_vector< Index, Value > | Represents a sparse vector, indexed by type Index and storing values of type Value |
| Cmeta::util::sparse_vector< class_label, double > | |
| Cmeta::util::sparse_vector< class_label, stats::multinomial< term_id > > | |
| Cmeta::util::sparse_vector< meta::parser::transition, trans_id > | |
| Cmeta::util::sparse_vector< SecondaryKey, double > | |
| Cmeta::util::sparse_vector< T, double > | |
| Cmeta::util::sparse_vector< term_id, double > | |
| Cmeta::util::sparse_vector< topic_id, double > | |
| Cmeta::caching::splay_cache< Key, Value > | A splay_cache is a fixed-size splay tree for cache operations |
| Cmeta::parser::sr_parser | A shift-reduce constituency parser |
| Cmeta::parser::state | Represents the current parser state of a shift-reduce parser |
| Cmeta::parser::sr_parser::state_analyzer | Analyzer responsible for converting a parser state to a feature_vector |
| ►Cstreambuf | |
| Cmeta::io::gzstreambuf | |
| Cmeta::index::string_list | A class designed for reading large lists of strings that have been persisted to disk |
| Cmeta::index::string_list_writer | A class for writing large lists of strings to disk with an associated index file for fast random access |
| Cmeta::sequence::crf::tagger | |
| ►Cmeta::parallel::thread_pool::task | A generic task object |
| Cmeta::parallel::thread_pool::concrete_task< R > | A concrete task is templated with a result type |
| Cmeta::parallel::thread_pool | Represents a collection of a fixed number of threads, which tasks can be added to |
| Cmeta::analyzers::token_stream | Base class that represents a stream of tokens that have been extracted from a document |
| Cmeta::parser::sr_parser::training_batch | A training batch |
| Cmeta::parser::sr_parser::training_data | Training data for the parser |
| Cmeta::sequence::perceptron::training_options | Training options required for learning a tagger |
| Cmeta::parser::sr_parser::training_options | Training options required for learning a parser model |
| Cmeta::utf::transformer | Class that encapsulates transliteration of unicode strings |
| Cmeta::parser::transition_map | An invertible map that maps transitions to ids |
| Cmeta::analyzers::tree_featurizer | Base class for featurizers that convert trees into features in a document |
| ►Cmeta::sequence::trellis | Basic trellis for holding score data for the forward/backward algorithm |
| Cmeta::sequence::forward_trellis | Special trellis for the normalized forward algorithm |
| Cmeta::sequence::viterbi_trellis | Special trellis for the Viterbi algorithm |
| Cmeta::util::trivial_init_t | A tag for trivial initialization of optional storage |
| Cundirected_graph< A, B > | |
| Cmeta::graph::directed_graph< Node, Edge >::undirected_graph< A, B > | |
| Cmeta::parser::visitor< T > | Abstract base class for visitors over parse trees that are allowed to modify the underlying tree |
| ►Cmeta::parser::visitor< void > | |
| Cmeta::parser::head_finder | A visitor that annotates the internal nodes of parse trees with their head constituents/lexicons |
| Cmeta::sequence::crf::viterbi_scorer | Scorer for performing viterbi-based tagging |
| Cmeta::index::vocabulary_map | A read-only view of a B+-tree-like structure that stores the vocabulary for an index |
| Cmeta::index::vocabulary_map_writer | A class that writes the B+-tree-like data structure used for storing the term id mapping in an index |
| ►CWrapped | |
| Cmeta::util::hash_wrapper< Wrapped > | Helper class that allows the wrapped type to be hashed into standard library containers such as unordered_map or unordered_set |
| ►CBase | |
| ►Cmeta::util::multilevel_clonable< Root, Base, Derived > | Template class to facilitate polymorphic cloning |
| Cmeta::analyzers::branch_featurizer | Tokenizes parse trees by extracting branching factor features |
| Cmeta::analyzers::depth_featurizer | Tokenizes parse trees by extracting depth features |
| Cmeta::analyzers::filters::alpha_filter | Filter that removes "non-letter" characters from tokens |
| Cmeta::analyzers::filters::empty_sentence_filter | Filter that removes any empty sentences from the token stream |
| Cmeta::analyzers::filters::english_normalizer | Filter that normalizes english language tokens |
| Cmeta::analyzers::filters::icu_filter | Filter that applies an ICU transliteration to each token in the sequence |
| Cmeta::analyzers::filters::length_filter | Filter that only retains tokens that are within a certain length range, inclusive |
| Cmeta::analyzers::filters::list_filter | Filter that either removes or keeps tokens from a given list |
| Cmeta::analyzers::filters::lowercase_filter | Filter that converts all tokens to lowercase |
| Cmeta::analyzers::filters::porter2_stemmer | Filter that stems words according to the porter2 stemmer algorithm |
| Cmeta::analyzers::filters::ptb_normalizer | A filter that normalizes text to match Penn Treebank conventions |
| Cmeta::analyzers::filters::sentence_boundary | Filter that adds sentence boundary tokens ("<s>" and "</s>") to streams of tokens |
| Cmeta::analyzers::libsvm_analyzer | Libsvm_analyzer tokenizes documents that have been created from a line_corpus, where each line is in libsvm input format and stored in the document's content field |
| Cmeta::analyzers::multi_analyzer | More than one analyzer |
| Cmeta::analyzers::semi_skeleton_featurizer | Tokenizes parse trees by keeping track of only a single node label and the underlying tree structure |
| Cmeta::analyzers::skeleton_featurizer | Tokenizes parse trees by only tokenizing the tree structure itself |
| Cmeta::analyzers::subtree_featurizer | Tokenizes parse trees by counting occurrences of subtrees in a document's parse tree |
| Cmeta::analyzers::tag_featurizer | Tokenizes parse trees by looking at labels of leaf and interior nodes |
| Cmeta::analyzers::tokenizers::character_tokenizer | Converts documents into streams of characters |
| Cmeta::analyzers::tokenizers::icu_tokenizer | Converts documents into streams of tokens by following the unicode standards for sentence and word segmentation |
| Cmeta::analyzers::tokenizers::whitespace_tokenizer | Converts documents into streams of whitespace delimited tokens |
| Cmeta::analyzers::tree_analyzer | Base class tokenizing using parse tree features |
| Cmeta::parser::internal_node | An internal node in a parse tree |
| Cmeta::parser::leaf_node | A leaf node (pre-terminal) in a parse tree |
1.8.9.1
