| accents | The class accents provides a wrapper to transparently create and access an accents_module to handle accentuation for the appropriate language |
| accents_default | Derived accents_module for null accentuation (eg english) |
| accents_es | Derived accents_module for Spanish accentuation |
| accents_gl | Derived accents_module for Galician accentuation |
| accents_module | The abstract class accents_module generalizes accentuation rules for different languages |
| adaboost | Class AdaBoost implement a generic AB learner/classifier, which may be based on any kind of weak rule |
| affixes | Class suffixes implements suffixation rules and dictionary search for suffixed word forms |
| aligner< T > | |
| aligner< T >::alin | |
| analysis | Class analysis stores a possible reading (lemma, PoS, probability, distance) for a word |
| automat | Abstract class to implement a Finite-State Automaton which is used by modules recognizing multiwords (dates, numbers, quantities, ...) |
| bioner | The class bioner implements an AdaBoost-Based NE recognizer |
| category | Class category is an auxiliar class to store information about the example belonging to a category |
| cell | Class cell stores all information in a chart cell |
| chart | Class chart contains an array of cells that constitute a chart |
| chart_parser | Class chart_parser implements a chart parser |
| check_and | The following classes are implementations of different constraints |
| check_asynon | Lemma or any ancestor has given synonym |
| check_category | Check category category |
| check_lemma | Find lemma in list of lemmas (separator character is |) |
| check_not | Negation |
| check_pos | Match pos against regexp |
| check_semfile | Lemma has given WN semantic file |
| check_side | Side of descendant respect to ancestor (or viceversa) |
| check_synon | Lemma has given synonym |
| check_tonto | Lemma has given top ontology class |
| check_wordclass | Lemma belongs to a class |
| classifier | The class classifier is an abstract class that implements a general ML classifier |
| completer | The class completer implements a parse tree completer, which given a partial parse tree (chunker output), completes the full parse according to some grammar rules |
| completerRule | The class completerRule stores rules used by the completer of parse trees |
| condition | Class condition implements a condition of a CG rule |
| dataset::const_iterator | |
| word::const_iterator | Const_iterator over word analysis (either all, only selected, only unselected) |
| const_iterator | |
| const_preorder_iterator< T > | |
| const_sibling_iterator< T > | |
| constraint | The class constraint implements a constraint for the relaxation labelling algorithm |
| constraint_grammar | Class constraint_grammar implements a pseudo CG, ready to be used from a relax PoS tagger |
| coref | The class coref implements a ML-based coreference classificator |
| coref_fex | Class for the feature extractor |
| corrector | |
| database | Class to wrap a berkeley DB database and unify access |
| dataset | Class dataset stores a set of examples uset to train adaboost models |
| dates | The class dates provides a wrapper to transparently create and access a dates_module, a temporal expression recognizer for the appropriate language |
| dates_ca | The derived class dates_ca implements a Catalan date/time recognizer |
| dates_default | The derived class dates_default implements a default date/time recognizer (only simple patterns are recognized) |
| dates_en | The derived class dates_en implements an English date/time recognizer |
| dates_es | The derived class dates_es implements a Spanish date/time recognizer |
| dates_gl | The derived class dates_gl implements a Galician date/time recognizer |
| dates_module | The abstract class dates_module generalizes temporal expression recognizer for different languages |
| dates_pt | The derived class dates_pt implements a Portuguese date/time recognizer |
| dates_ru | The derived class dates_ru implements Russian date/time recognizer |
| dep_tree | Class dep_tree stores a dependency tree |
| dep_txala | DependencyMaker is a class for obtaining a dependency tree from chunks |
| dependency_parser | The class dependency_parser is just an abstract class generalizing any dependency parser |
| depLabeler | DepLabeler is class to set labels into a dependency tree |
| depnode | Class denode stores nodes of a dependency tree and parse tree <-> deptree relations |
| dictionary | The class dictionary implements dictionary search and suffix analysis for word forms |
| document | Class document is a list of paragraphs |
| dt_node | Class dt_node stores the info in one node of the decision tree |
| edge | Class edge stores all information in a chart edge |
| trellis::element | Each trellis node contains an ordered set of paths |
| 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) |
| 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 |
| feature_function | Class feature_function is an abstrac class to enable calling module to define user-custom feature functions |
| fex | Class fex implements a feature extractor |
| fex_condition | Class fex_condition stores a condition to be checked on the target |
| fex_lexicon | Feature lexicon |
| fex_rule | Class fex_rule stores a feature extraction rule |
| fex_rulepack | Class fex_rulepack stores a batch of feature rules to be applied to the same kind of targets |
| generic_const_iterator< T > | |
| generic_iterator< T > | |
| grammar | Class grammar implements a CFG, ready to be used from a chart parser |
| hmm_tagger | The class hmm_tagger implements the syntactic analyzer and is the main class, which uses all the others |
| idioma | Class "idioma" implements a visible Markov's model that calculates the probability that a text is in a certain language |
| dataset::iterator | |
| iterator | |
| word::iterator | Iterator over word analysis (either all, only selected, only unselected) |
| label | The class label stores all information related to a variable label in the relaxation labelling algorithm |
| lang_ident | Class "lang_ident" checks a text against all known languages and sorts the results by probability |
| lex_entry | Content of one lexicon entry |
| lexer | Simple RegEx lexer to parse UTF8 grammar files without depending on flex (or the like) |
| list | |
| List | |
| List::ListRec | |
| List::ListRecBase | |
| List::ListRecData | |
| List::ListRecEnd | |
| locutions | Class locutions recognizes multiwords belonging to a list obtained from a configuration file |
| maco | Class maco implements the morphological analyzer, which uses all the specific analyzers: dates, numbers, dictionary, etc |
| maco_options | Class maco_options implements a set of specific options of the morphological analyzer |
| map | |
| mention | Class that contains one definite NP (candidate mention) |
| mlDTree | Class mlDTree implements a multilabel decision tree that can be used by adaboost as a weak rules |
| mlDTree_params | Class mlDTree_params stores the set of params for this kind of weak rules |
| multimap | |
| nec | The class nec implements a ML-based NE classificator |
| ner | Class ner implements a wrapper to transparently create and access a ner_module named entity recognizer |
| ner_module | The class ner is an abstract class that implements a general NE Recognizer |
| nerc_features | Available NERC-specific feature extraction functions |
| 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) |
| np | The class np implements a simple proper noun recognizer |
| numbers | Class numbers implements a wrapper to transparently create and access a numbers_module number recognizer for the appropriate language |
| numbers_ca | The derived class numbers_ca implements a Catalan number recognizer |
| numbers_default | The derived class numbers_default implements a default number recognizer (only numbers in digits are recognized) |
| numbers_en | The derived class numbers_en implements an English number recognizer |
| numbers_es | The derived class numbers_es implements a Spanish number recognizer |
| numbers_gl | The derived class numbers_gl implements a Galician number recognizer |
| numbers_it | The derived class numbers_it implements a Italian number recognizer |
| numbers_module | The abstract class numbers_module generalizes nummeric expression recognizer for different languages |
| numbers_pt | The derived class numbers_pt implements a Portuguese number recognizer |
| numbers_ru | The derived class numbers_ru implements an Russian number recognizer |
| paragraph | Class paragraph is just a list of sentences that someone has validated it as a paragraph |
| parse_tree | Class parse tree is used to store the results of parsing |
| ph_rule | Auxiliar class to store a phonetic change rule |
| phd< T > | |
| phonetics | This class is a will calculate the phonetic translation of a word |
| POS_tagger | The class POS_tagger is just an abstract class generalizing a PoS tagger |
| posmaprule | Auxiliary class to map FL postags to WN codes |
| PrefTree | |
| preorder_iterator< T > | Traverse the tree in preorder (parent first, then children) |
| probabilities | Class probabilities sets lexical probabilities for each PoS tag of each word in a sentence |
| 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 |
| processor | Abstract class to define the common API of any FreeLing processing module |
| punts | Class numbers implements a punctuation sign recognizer |
| quantities | Class quantities implements a wrapper to transparently create and access a quantities_module monetary expressions detector for the appropriate language |
| quantities_ca | The derived class quantities_ca implements a Catalan quantities recognizer |
| quantities_default | The derived class quantities_default implements a default quantities recognizer (only percentages are recognized) |
| quantities_en | The derived class quantities_en implements an English quantities recognizer |
| quantities_es | The derived class quantities_es implements a Spanish quantities recognizer |
| quantities_gl | The derived class quantities_gl implements a Galician quantities recognizer |
| quantities_module | The abstract class quantities_module generalizes a percentage, ratios, and currency expression recognizer for different languages |
| quantities_pt | The derived class quantities_pt implements a Portuguese quantities recognizer |
| quantities_ru | The derived class quantities_ru implements a Russian quantities recognizer |
| RE_map | Class tag_map implements a mapping from a regexps to an associated data string |
| RE_map_rule | Auxiliary class to store a single RE_map rule |
| relax | The class relax implements a generic solver for consistent labelling problems, using relaxation labelling algorithm |
| relax_tagger | The class relax_tagger implements a PoS tagger based on relaxation labelling algorithm |
| rule | Class rule implements a rule of a grammar |
| rule_expression | The class rule_expression is an abstract class (interface) for building dynamic restriction on a ruleLabeler which are used by class depLabeler |
| rule_set | |
| ruleCG | Class rule implements a rule of a CG |
| ruleLabeler | RuleLabeler is an auxiliary class for the depLabeler |
| semanticDB | Class semanticDB implements a semantic DB interface |
| sense_info | Class sense_info stores several semantic info about a sense |
| senses | Class senses implements a sense annotator |
| sentence | Class sentence is just a list of words that someone (the splitter) has validated it as a complete sentence |
| set | |
| setCG | Auxiliary class to store sets defined in the CG |
| sibling_iterator< T > | Sibling iterator: traverse all children of the same node |
| similarity | This class calculate the similarity between two words |
| 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 |
| sufrule | Class sufrule contains an affixation rule, and is used by class suffixes |
| svm | Class svm implements a bianry SVM classifier |
| svm_model | |
| svm_node | |
| svm_parameter | |
| svm_problem | |
| 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 |
| traces | MOD_TRACECODE and MOD_TRACENAME are empty |
| tree< T > | |
| tree_iterator< T, N > | Generic iterator, to derive all the others |
| trellis | The class viterbi stores the two maps for each observation: The delta map stores the maximum probability for each state in that observation, the phi map stores the backpath to maximize the probability |
| ukb_wrap | Disambiguator: Wrapper to UKB disambiguation module |
| util | Class util implements some utilities for NLP analyzers: "tolower" for latin alfabets, tags manipulation, wstring2number and viceversa conversions, etc |
| vector | |
| vis_viterbi | The class vis_viterbi implements the viterbi algorithm given the weights of different labels, without hidden information |
| weak_rule | Class weak_rule is an abstract class generalizing any kind of weak rule that adaboost can use |
| word | Class word stores all info related to a word: form, list of analysis, list of tokens (if multiword) |
| 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 |
| wr_params | Class wr_params is a dummy class used to derive the set of parameters of each WR type |
