| freeling::accents | The class accents provides a wrapper to transparently create and access an accents_module to handle accentuation for the appropriate language |
| freeling::accents_default | Derived accents_module for null accentuation (eg english) |
| freeling::accents_es | Derived accents_module for Spanish accentuation |
| freeling::accents_gl | Derived accents_module for Galician accentuation |
| freeling::accents_module | The abstract class accents_module generalizes accentuation rules for different languages |
| freeling::adaboost | Class AdaBoost implement a generic AB learner/classifier, which may be based on any kind of weak rule |
| freeling::affixes | Class suffixes implements suffixation rules and dictionary search for suffixed word forms |
| freeling::aligner< T > | |
| freeling::aligner< T >::alin | |
| freeling::alternatives | Class alternatives suggests words that are orthogrphically/phonetically similar to input word |
| freeling::analysis | Class analysis stores a possible reading (lemma, PoS, probability, distance) for a word |
| freeling::analyzer | Class analyzer is a meta class that just calls all modules in FreeLing in the right order |
| freeling::analyzer::analyzer_config_options | Class analyzer::config_options contains the configuration options that define which modules are active and which configuration files are loaded for each of them at construction time |
| freeling::analyzer::analyzer_invoke_options | Class analyzer::invoke_options contains the options that define the behaviour of each module in the analyze on the next analysis |
| freeling::argument | Class argument stores information about a predicate argument |
| freeling::automat< T > | Abstract class to implement a Finite-State Automaton which is used by modules recognizing multiwords (dates, numbers, quantities, ...) |
| freeling::automat_status | Class to store status information |
| freeling::basic_const_tree_iterator< T > | Const iterator |
| freeling::basic_nonconst_tree_iterator< T > | Nonconst iterator |
| freeling::basic_preorder_iterator< T, X > | Basic preorder iterator |
| freeling::basic_sibling_iterator< T, X > | Basic sibling iterator |
| freeling::basic_tree_iterator< T, N > | ############################################################# /// |
| freeling::bioner | The class bioner implements an AdaBoost-Based NE recognizer |
| freeling::category | Class category is an auxiliar class to store information about the example belonging to a category |
| freeling::chart | Class chart contains an array of cells that constitute a chart |
| freeling::chart_parser | Class chart_parser implements a chart parser |
| freeling::classifier | The class classifier is an abstract class that implements a general ML classifier |
| freeling::completer_rule | The class completer_rule stores rules used by the completer of parse trees |
| freeling::compounds | Class compounds implements a compound checker |
| freeling::condition | Class condition implements a condition of a CG rule |
| freeling::config_file | Class to handle loading a config file for freeling module, with XML-like sections |
| freeling::io::conll_handler | |
| freeling::io::conll_sentence | |
| freeling::word::const_iterator | Const_iterator over word analysis (either all, only selected, only unselected) |
| freeling::dataset::const_iterator | |
| const_iterator | |
| freeling::const_tree_preorder_iterator< T > | Const tree_preorder iterator |
| freeling::const_tree_sibling_iterator< T > | Const sibling iterator |
| freeling::constraint | The class constraint implements a constraint for the relaxation labelling algorithm |
| freeling::relaxcor_modelDT::constraint | |
| freeling::constraint_grammar | Class constraint_grammar implements a pseudo CG, ready to be used from a relax PoS tagger |
| freeling::coref | The class coref implements a ML-based coreference classificator |
| freeling::coref_fex | Class for the feature extractor |
| freeling::csr_kb | Class kb: Store information associated to a knowledge base |
| freeling::database | Class to wrap a berkeley DB database and unify access |
| freeling::dataset | Class dataset stores a set of examples uset to train adaboost models |
| freeling::dates | The class dates provides a wrapper to transparently create and access a dates_module, a temporal expression recognizer for the appropriate language |
| freeling::dates_ca | The derived class dates_ca implements a Catalan date/time recognizer |
| freeling::dates_cy | |
| freeling::dates_de | |
| freeling::dates_default | The derived class dates_default implements a default date/time recognizer (only simple patterns are recognized) |
| freeling::dates_en | The derived class dates_en implements an English date/time recognizer |
| freeling::dates_es | The derived class dates_es implements a Spanish date/time recognizer |
| freeling::dates_fr | |
| freeling::dates_gl | The derived class dates_gl implements a Galician date/time recognizer |
| freeling::dates_module | The abstract class dates_module generalizes temporal expression recognizer for different languages |
| freeling::dates_pt | The derived class dates_pt implements a Portuguese date/time recognizer |
| freeling::dates_ru | The derived class dates_ru implements Russian date/time recognizer |
| freeling::dates_status | Class to store status information |
| freeling::dep_tree | Class dep_tree stores a dependency tree |
| freeling::dep_treeler | Class dep_treeler is a wrapper for a Treeler dependency parser |
| freeling::dep_txala | Dep_txala is a class for obtaining a dependency tree from chunks |
| freeling::dep_txala_status | Store parsing status information |
| freeling::dependency_parser | The class dependency_parser is just an abstract class generalizing any dependency parser |
| freeling::depnode | Class denode stores nodes of a dependency tree and parse tree <-> deptree relations |
| freeling::dictionary | The class dictionary implements dictionary search and suffix analysis for word forms |
| freeling::document | Class document is a list of paragraphs |
| freeling::dt_node | Class dt_node stores the info in one node of the decision tree |
| freeling::edge | Class edge stores all information in a chart edge |
| freeling::trellis::element | Each trellis node contains an ordered set of paths |
| freeling::emission_states | The class emission_states stores the list of states in the HMM that *may* be generating a given word given the two previous words (and their valid tags) |
| freeling::ent_extract | |
| freeling::example | Class example is a vector of real-valued features, each identified by an integer label, plus info about to which classes the example belongs to, and with prediction storage functionalities |
| freeling::factory< T > | This template is used by numbers, quantities, dates, and ner classes to dinamycally create the appropriate subclass of numbers_module, quantities_module, dates_module, or ner_module (according to received options) |
| freeling::feature_function | Class feature_function is an abstrac class to enable calling module to define user-custom feature functions |
| freeling::fex | Class fex implements a feature extractor |
| freeling::fex_condition | Class fex_condition stores a condition to be checked on the target |
| freeling::fex_lexicon | Feature lexicon |
| freeling::fex_rule | Class fex_rule stores a feature extraction rule |
| freeling::fex_rulepack | Class fex_rulepack stores a batch of feature rules to be applied to the same kind of targets |
| freeling::fex_status | Store status about extracted features |
| freeling::foma_FSM | Class foma_FSM is a wrapper for the FOMA library, for the specific use of getting entries from a dictionary with minimum edit distance to given key |
| freeling::grammar | Class grammar implements a CFG, ready to be used from a chart parser |
| freeling::hmm_tagger | The class hmm_tagger implements the syntactic analyzer and is the main class, which uses all the others |
| freeling::hypernymy | Class hypernymy represents the hypernymy relation: two words are related if one is an hypernymy of the other and the hypernymy depth is smaller or equal than a given maximum |
| freeling::idioma | Class "idioma" implements a visible Markov's model that calculates the probability that a text is in a certain language |
| freeling::io::input_conll | |
| freeling::io::input_freeling | |
| freeling::io::input_handler | |
| freeling::io::io_handler | |
| freeling::word::iterator | Iterator over word analysis (either all, only selected, only unselected) |
| freeling::dataset::iterator | |
| iterator | |
| freeling::label | The class label stores all information related to a variable label in the relaxation labelling algorithm |
| freeling::labeler_rule | Labeler_rule is an auxiliary class for the depLabeler |
| freeling::lang_ident | Class "lang_ident" checks a text against all known languages and sorts the results by probability |
| freeling::lex_entry | Content of one lexicon entry |
| freeling::lexer | Simple RegEx lexer to parse UTF8 grammar files without depending on flex (or the like) |
| freeling::lexical_chain | Class lexical_chain represents a lexical chain and computes words and stores (or not) them into the structures |
| freeling::List | |
| list | |
| freeling::List::ListRec | |
| freeling::List::ListRecBase | |
| freeling::List::ListRecData | |
| freeling::List::ListRecEnd | |
| freeling::locutions | Class locutions recognizes multiwords belonging to a list obtained from a configuration file |
| freeling::locutions_status | Class to store status information |
| freeling::maco | Class maco implements the morphological analyzer, which uses all the specific analyzers: dates, numbers, dictionary, etc |
| freeling::maco_options | Class maco_options implements a set of specific options of the morphological analyzer |
| map | |
| freeling::matching_attrib | The class matching attrib stores attributes for maching condition |
| freeling::matching_condition | The class matching condition stores a condition used in a MATCHING operation of a completer rule |
| freeling::mention | Class mention is a node in the parse tree, as well as the sequence of tokens subsumed by the node |
| freeling::mention_ab | |
| freeling::mention_detector | The class mention_detector implements a rule-based entity mention detector |
| freeling::mlDTree | Class mlDTree implements a multilabel decision tree that can be used by adaboost as a weak rules |
| freeling::mlDTree_params | Class mlDTree_params stores the set of params for this kind of weak rules |
| multimap | |
| freeling::nec | The class nec implements a ML-based NE classificator |
| freeling::ner | Class ner implements a wrapper to transparently create and access a ner_module named entity recognizer |
| freeling::ner_module | The class ner is an abstract class that implements a general NE Recognizer |
| freeling::ner_status | Class to store status information |
| freeling::nerc_features | Available NERC-specific feature extraction functions |
| freeling::node | Class node stores nodes of a parse_tree Each node in the tree is either a label (intermediate node) or a word (leaf node) |
| freeling::node_pattern | Auxiliary class to store relation extraction rules |
| freeling::np | The class np implements a simple proper noun recognizer |
| freeling::numbers | Class numbers implements a wrapper to transparently create and access a numbers_module number recognizer for the appropriate language |
| freeling::numbers_ca | The derived class numbers_ca implements a Catalan number recognizer |
| freeling::numbers_cs | The derived class numbers_cs implements a Czeck number recognizer |
| freeling::numbers_de | |
| freeling::numbers_default | The derived class numbers_default implements a default number recognizer (only numbers in digits are recognized) |
| freeling::numbers_en | The derived class numbers_en implements an English number recognizer |
| freeling::numbers_es | The derived class numbers_es implements a Spanish number recognizer |
| freeling::numbers_gl | The derived class numbers_gl implements a Galician number recognizer |
| freeling::numbers_it | The derived class numbers_it implements a Italian number recognizer |
| freeling::numbers_module | The abstract class numbers_module generalizes nummeric expression recognizer for different languages |
| freeling::numbers_pt | The derived class numbers_pt implements a Portuguese number recognizer |
| freeling::numbers_ru | The derived class numbers_ru implements an Russian number recognizer |
| freeling::numbers_status | Class to store status information |
| freeling::io::output | Class output implements a wrapper to transparently create and access an output_handler |
| freeling::io::output_conll | |
| freeling::io::output_freeling | |
| freeling::io::output_handler | |
| freeling::io::output_json | |
| freeling::io::output_naf | |
| freeling::io::output_train | |
| freeling::io::output_xml | |
| freeling::paragraph | Class paragraph is just a list of sentences that someone has validated it as a paragraph |
| freeling::parse_tree | Class parse tree is used to store the results of parsing |
| freeling::compounds::pattern | Auxiliary class to store a pattern |
| freeling::ph_rule | Auxiliar class to store a phonetic change rule |
| freeling::phd< T > | |
| freeling::phonetics | This class is a will calculate the phonetic translation of a word |
| freeling::POS_tagger | The class POS_tagger is just an abstract class generalizing a PoS tagger |
| freeling::posmaprule | Auxiliary class to map FL postags to WN codes |
| freeling::predicate | Class predicate stores a predicate and its arguments |
| freeling::PrefTree | |
| freeling::probabilities | Class probabilities sets lexical probabilities for each PoS tag of each word in a sentence |
| freeling::problem | The class problem stores the structure of a problem, namely, a vector with a position for each variable to consider, and for each variable, a list of initial weights for each possible label |
| freeling::processor | Abstract class to define the common API of any FreeLing processing module |
| freeling::processor_status | Virtual class to store the processing state of a sentence |
| freeling::punts | Class numbers implements a punctuation sign recognizer |
| freeling::quantities | Class quantities implements a wrapper to transparently create and access a quantities_module monetary expressions detector for the appropriate language |
| freeling::quantities_ca | The derived class quantities_ca implements a Catalan quantities recognizer |
| freeling::quantities_default | The derived class quantities_default implements a default quantities recognizer (only percentages are recognized) |
| freeling::quantities_en | The derived class quantities_en implements an English quantities recognizer |
| freeling::quantities_es | The derived class quantities_es implements a Spanish quantities recognizer |
| freeling::quantities_gl | The derived class quantities_gl implements a Galician quantities recognizer |
| freeling::quantities_module | The abstract class quantities_module generalizes a percentage, ratios, and currency expression recognizer for different languages |
| freeling::quantities_pt | The derived class quantities_pt implements a Portuguese quantities recognizer |
| freeling::quantities_ru | The derived class quantities_ru implements a Russian quantities recognizer |
| freeling::quantities_status | Class to store status information |
| freeling::RE_map | Class tag_map implements a mapping from a regexps to an associated data string |
| freeling::RE_map_rule | Auxiliary class to store a single RE_map rule |
| freeling::regexp | |
| freeling::rel_extract | |
| freeling::rel_extract_SPR | |
| freeling::rel_extract_SRL | |
| freeling::related_words | Struct that represents a relationship between two words |
| freeling::relation | Class relation is a non-instantiable class which defines many virtual methods to check if a word is compatible with the relation or if a word can be stored in the structures of a lexical chain |
| freeling::relax | The class relax implements a generic solver for consistent labelling problems, using relaxation labelling algorithm |
| freeling::relax_tagger | The class relax_tagger implements a PoS tagger based on relaxation labelling algorithm |
| freeling::relaxcor | The class mention_detector implements a rule-based entity mention detector |
| freeling::relaxcor_fex | Class for the feature extractor |
| freeling::relaxcor_model | The basic class relaxcor_model implements the mention-pair model |
| freeling::relaxcor_modelDT | The basic class relaxcor_modelDT implements the mention-pair model based on constraints derived from DTs |
| freeling::rule | Class rule implements a rule of a grammar |
| freeling::rule_expression | The class rule_expression stores the conditions for a labeler_rule |
| freeling::rule_set | |
| freeling::ruleCG | Class rule implements a rule of a CG |
| freeling::rx_rule | Auxiliary class to store relation extraction rules |
| safe_map< T1, T2 > | This class provides a map with thread_safe writing acces |
| freeling::same_coref_group | Class same_coref_group represents the same coreference group relation: two words are related if they are in the same coreference group |
| freeling::same_word | Class same_word represents the same word relation: two words are related if they are the same word |
| freeling::semgraph::semantic_graph | Auxiliary class to store a semantic graph |
| freeling::semanticDB | Class semanticDB implements a semantic DB interface |
| freeling::semgraph_extract | |
| freeling::sense_info | Class sense_info stores several semantic info about a sense |
| freeling::senses | Class senses implements a sense annotator |
| freeling::sentence | Class sentence is just a list of words that someone (the splitter) has validated it as a complete sentence |
| set | |
| freeling::setCG | Auxiliary class to store sets defined in the CG |
| freeling::semgraph::SG_argument | Auxiliary class to store frame arguments |
| freeling::semgraph::SG_entity | |
| freeling::semgraph::SG_frame | Auxiliary class to store frames (relations between n entities) |
| freeling::semgraph::SG_mention | Auxiliary class to store mentions to entities found in text |
| freeling::similarity | This class calculates the similarity between two words |
| freeling::smoothingLD< G, E > | Class smoothingLD computes linear-discount smoothed conditional probabilities P(z|w1...wn) for n-gram transitions |
| freeling::splitter | Class splitter implements a sentence splitter, which accumulates lists of words until a sentence is completed, and then returns a list of sentence objects |
| freeling::splitter::splitter_status | |
| freeling::sufrule | Class sufrule contains an affixation rule, and is used by class suffixes |
| freeling::summarizer | Summarizer class summarizes a document using the lexical chains method |
| freeling::svm | Class svm implements a bianry SVM classifier |
| svm_model | |
| svm_node | |
| svm_parameter | |
| svm_problem | |
| freeling::tagset | The class tagset handles PoS tags long to short conversion and morphosintactic feature decomposition |
| freeling::tokenizer | Class tokenizer implements a token splitter, which converts a string into a sequence of word objects, according to a set of tokenization rules read from aconfiguration file |
| freeling::traces | Class traces implements trace and error handling utilities |
| freeling::tree< T > | STL-like container implementing a n-ary tree |
| freeling::tree_preorder_iterator< T > | Preorder iterator |
| freeling::tree_sibling_iterator< T > | Sibling iterator |
| freeling::trellis | |
| freeling::ukb | |
| freeling::util | Class util implements some utilities for NLP analyzers: "tolower" for latin alfabets, tags manipulation, wstring2number and viceversa conversions, etc |
| vector | |
| freeling::vis_viterbi | The class vis_viterbi implements the viterbi algorithm given the weights of different labels, without hidden information |
| freeling::weak_rule | Class weak_rule is an abstract class generalizing any kind of weak rule that adaboost can use |
| freeling::word | Class word stores all info related to a word: form, list of analysis, list of tokens (if multiword) |
| freeling::word_pos | Struct that allow us to compare words easily |
| freeling::wr_factory | Class wr_factory is a factory enabling to register new types of weak_rules (provided they are derived from weak_rule class below |
| freeling::wr_params | Class wr_params is a dummy class used to derive the set of parameters of each WR type |
