FreeLing  3.1
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
freeling::accentsThe class accents provides a wrapper to transparently create and access an accents_module to handle accentuation for the appropriate language
freeling::accents_defaultDerived accents_module for null accentuation (eg english)
freeling::accents_esDerived accents_module for Spanish accentuation
freeling::accents_glDerived accents_module for Galician accentuation
freeling::accents_moduleThe abstract class accents_module generalizes accentuation rules for different languages
freeling::adaboostClass AdaBoost implement a generic AB learner/classifier, which may be based on any kind of weak rule
freeling::affixesClass suffixes implements suffixation rules and dictionary search for suffixed word forms
freeling::aligner< T >
freeling::aligner< T >::alin
freeling::alternativesClass alternatives suggests words that are orthogrphically/phonetically similar to input word
freeling::analysisClass analysis stores a possible reading (lemma, PoS, probability, distance) for a word
freeling::automat< T >Abstract class to implement a Finite-State Automaton which is used by modules recognizing multiwords (dates, numbers, quantities, ...)
freeling::automat_statusClass to store status information
freeling::bionerThe class bioner implements an AdaBoost-Based NE recognizer
freeling::categoryClass category is an auxiliar class to store information about the example belonging to a category
freeling::cellClass cell stores all information in a chart cell
freeling::chartClass chart contains an array of cells that constitute a chart
freeling::chart_parserClass chart_parser implements a chart parser
freeling::check_andThe following classes are implementations of different constraints
freeling::check_asynonLemma or any ancestor has given synonym
freeling::check_categoryCheck category category
freeling::check_lemmaFind lemma in list of lemmas (separator character is |)
freeling::check_notNegation
freeling::check_posMatch pos against regexp
freeling::check_semfileLemma has given WN semantic file
freeling::check_sideSide of descendant respect to ancestor (or viceversa)
freeling::check_synonLemma has given synonym
freeling::check_tontoLemma has given top ontology class
freeling::check_wordclassLemma belongs to a class
freeling::classifierThe class classifier is an abstract class that implements a general ML classifier
freeling::completerThe class completer implements a parse tree completer, which given a partial parse tree (chunker output), completes the full parse according to some grammar rules
freeling::completerRuleThe class completerRule stores rules used by the completer of parse trees
freeling::conditionClass condition implements a condition of a CG rule
freeling::config_fileClass to handle loading a config file for freeling module, with XML-like sections
freeling::dataset::const_iterator
freeling::word::const_iteratorConst_iterator over word analysis (either all, only selected, only unselected)
const_iterator
freeling::const_preorder_iterator< T >
freeling::const_sibling_iterator< T >
freeling::constraintThe class constraint implements a constraint for the relaxation labelling algorithm
freeling::constraint_grammarClass constraint_grammar implements a pseudo CG, ready to be used from a relax PoS tagger
freeling::corefThe class coref implements a ML-based coreference classificator
freeling::coref_fexClass for the feature extractor
freeling::csr_kbClass kb: Store information associated to a knowledge base
freeling::databaseClass to wrap a berkeley DB database and unify access
freeling::datasetClass dataset stores a set of examples uset to train adaboost models
freeling::datesThe class dates provides a wrapper to transparently create and access a dates_module, a temporal expression recognizer for the appropriate language
freeling::dates_caThe derived class dates_ca implements a Catalan date/time recognizer
freeling::dates_defaultThe derived class dates_default implements a default date/time recognizer (only simple patterns are recognized)
freeling::dates_enThe derived class dates_en implements an English date/time recognizer
freeling::dates_esThe derived class dates_es implements a Spanish date/time recognizer
freeling::dates_glThe derived class dates_gl implements a Galician date/time recognizer
freeling::dates_moduleThe abstract class dates_module generalizes temporal expression recognizer for different languages
freeling::dates_ptThe derived class dates_pt implements a Portuguese date/time recognizer
freeling::dates_ruThe derived class dates_ru implements Russian date/time recognizer
freeling::dates_statusClass to store status information
freeling::dep_treeClass dep_tree stores a dependency tree
freeling::dep_txalaDependencyMaker is a class for obtaining a dependency tree from chunks
freeling::dep_txala_statusStore parsing status information
freeling::dependency_parserThe class dependency_parser is just an abstract class generalizing any dependency parser
freeling::depLabelerDepLabeler is class to set labels into a dependency tree
freeling::depnodeClass denode stores nodes of a dependency tree and parse tree <-> deptree relations
freeling::dictionaryThe class dictionary implements dictionary search and suffix analysis for word forms
freeling::documentClass document is a list of paragraphs
freeling::dt_nodeClass dt_node stores the info in one node of the decision tree
freeling::edgeClass edge stores all information in a chart edge
freeling::trellis::elementEach trellis node contains an ordered set of paths
freeling::emission_statesThe 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::exampleClass 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_functionClass feature_function is an abstrac class to enable calling module to define user-custom feature functions
freeling::fexClass fex implements a feature extractor
freeling::fex_conditionClass fex_condition stores a condition to be checked on the target
freeling::fex_lexiconFeature lexicon
freeling::fex_ruleClass fex_rule stores a feature extraction rule
freeling::fex_rulepackClass fex_rulepack stores a batch of feature rules to be applied to the same kind of targets
freeling::fex_statusStore status about extracted features
freeling::foma_FSM
freeling::generic_const_iterator< T >
freeling::generic_iterator< T >
freeling::grammarClass grammar implements a CFG, ready to be used from a chart parser
freeling::hmm_taggerThe class hmm_tagger implements the syntactic analyzer and is the main class, which uses all the others
freeling::idiomaClass "idioma" implements a visible Markov's model that calculates the probability that a text is in a certain language
freeling::dataset::iterator
freeling::word::iteratorIterator over word analysis (either all, only selected, only unselected)
iterator
freeling::labelThe class label stores all information related to a variable label in the relaxation labelling algorithm
freeling::lang_identClass "lang_ident" checks a text against all known languages and sorts the results by probability
freeling::lex_entryContent of one lexicon entry
freeling::lexerSimple RegEx lexer to parse UTF8 grammar files without depending on flex (or the like)
list
freeling::List
freeling::List::ListRec
freeling::List::ListRecBase
freeling::List::ListRecData
freeling::List::ListRecEnd
freeling::locutionsClass locutions recognizes multiwords belonging to a list obtained from a configuration file
freeling::locutions_statusClass to store status information
freeling::macoClass maco implements the morphological analyzer, which uses all the specific analyzers: dates, numbers, dictionary, etc
freeling::maco_optionsClass maco_options implements a set of specific options of the morphological analyzer
map
freeling::matching_attribThe class matching attrib stores attributes for maching condition
freeling::matching_conditionThe class matching condition stores a condition used in a MATCHING operation of a completer rule
freeling::mentionClass that contains one definite NP (candidate mention)
freeling::mlDTreeClass mlDTree implements a multilabel decision tree that can be used by adaboost as a weak rules
freeling::mlDTree_paramsClass mlDTree_params stores the set of params for this kind of weak rules
multimap
freeling::necThe class nec implements a ML-based NE classificator
freeling::nerClass ner implements a wrapper to transparently create and access a ner_module named entity recognizer
freeling::ner_moduleThe class ner is an abstract class that implements a general NE Recognizer
freeling::ner_statusClass to store status information
freeling::nerc_featuresAvailable NERC-specific feature extraction functions
freeling::nodeClass node stores nodes of a parse_tree Each node in the tree is either a label (intermediate node) or a word (leaf node)
freeling::npThe class np implements a simple proper noun recognizer
freeling::numbersClass numbers implements a wrapper to transparently create and access a numbers_module number recognizer for the appropriate language
freeling::numbers_caThe derived class numbers_ca implements a Catalan number recognizer
freeling::numbers_csThe derived class numbers_cs implements a Czeck number recognizer
freeling::numbers_defaultThe derived class numbers_default implements a default number recognizer (only numbers in digits are recognized)
freeling::numbers_enThe derived class numbers_en implements an English number recognizer
freeling::numbers_esThe derived class numbers_es implements a Spanish number recognizer
freeling::numbers_glThe derived class numbers_gl implements a Galician number recognizer
freeling::numbers_itThe derived class numbers_it implements a Italian number recognizer
freeling::numbers_moduleThe abstract class numbers_module generalizes nummeric expression recognizer for different languages
freeling::numbers_ptThe derived class numbers_pt implements a Portuguese number recognizer
freeling::numbers_ruThe derived class numbers_ru implements an Russian number recognizer
freeling::numbers_statusClass to store status information
freeling::paragraphClass paragraph is just a list of sentences that someone has validated it as a paragraph
freeling::parse_treeClass parse tree is used to store the results of parsing
freeling::ph_ruleAuxiliar class to store a phonetic change rule
freeling::phd< T >
freeling::phoneticsThis class is a will calculate the phonetic translation of a word
freeling::POS_taggerThe class POS_tagger is just an abstract class generalizing a PoS tagger
freeling::posmapruleAuxiliary class to map FL postags to WN codes
freeling::PrefTree
freeling::preorder_iterator< T >Traverse the tree in preorder (parent first, then children)
freeling::probabilitiesClass probabilities sets lexical probabilities for each PoS tag of each word in a sentence
freeling::problemThe 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::processorAbstract class to define the common API of any FreeLing processing module
freeling::processor_statusVirtual class to store the processing state of a sentence
freeling::puntsClass numbers implements a punctuation sign recognizer
freeling::quantitiesClass quantities implements a wrapper to transparently create and access a quantities_module monetary expressions detector for the appropriate language
freeling::quantities_caThe derived class quantities_ca implements a Catalan quantities recognizer
freeling::quantities_defaultThe derived class quantities_default implements a default quantities recognizer (only percentages are recognized)
freeling::quantities_enThe derived class quantities_en implements an English quantities recognizer
freeling::quantities_esThe derived class quantities_es implements a Spanish quantities recognizer
freeling::quantities_glThe derived class quantities_gl implements a Galician quantities recognizer
freeling::quantities_moduleThe abstract class quantities_module generalizes a percentage, ratios, and currency expression recognizer for different languages
freeling::quantities_ptThe derived class quantities_pt implements a Portuguese quantities recognizer
freeling::quantities_ruThe derived class quantities_ru implements a Russian quantities recognizer
freeling::quantities_statusClass to store status information
freeling::RE_mapClass tag_map implements a mapping from a regexps to an associated data string
freeling::RE_map_ruleAuxiliary class to store a single RE_map rule
freeling::regexp
freeling::relaxThe class relax implements a generic solver for consistent labelling problems, using relaxation labelling algorithm
freeling::relax_taggerThe class relax_tagger implements a PoS tagger based on relaxation labelling algorithm
freeling::ruleClass rule implements a rule of a grammar
freeling::rule_expressionThe class rule_expression is an abstract class (interface) for building dynamic restriction on a ruleLabeler which are used by class depLabeler
freeling::rule_set
freeling::ruleCGClass rule implements a rule of a CG
freeling::ruleLabelerRuleLabeler is an auxiliary class for the depLabeler
safe_map< T1, T2 >This class provides a map with thread_safe writing acces
freeling::semanticDBClass semanticDB implements a semantic DB interface
freeling::sense_infoClass sense_info stores several semantic info about a sense
freeling::sensesClass senses implements a sense annotator
freeling::sentenceClass sentence is just a list of words that someone (the splitter) has validated it as a complete sentence
set
freeling::setCG
freeling::sibling_iterator< T >Sibling iterator: traverse all children of the same node
freeling::similarityThis class calculates the similarity between two words
freeling::splitterClass splitter implements a sentence splitter, which accumulates lists of words until a sentence is completed, and then returns a list of sentence objects
freeling::sufruleClass sufrule contains an affixation rule, and is used by class suffixes
freeling::svmClass svm implements a bianry SVM classifier
svm_model
svm_node
svm_parameter
svm_problem
freeling::tagsetThe class tagset handles PoS tags long to short conversion and morphosintactic feature decomposition
freeling::tokenizerClass 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::tracesClass traces implements trace and error handling utilities
freeling::tree< T >
freeling::tree_iterator< T, N >Generic iterator, to derive all the others
freeling::trellis
freeling::ukb
freeling::utilClass util implements some utilities for NLP analyzers: "tolower" for latin alfabets, tags manipulation, wstring2number and viceversa conversions, etc
vector
freeling::vis_viterbiThe class vis_viterbi implements the viterbi algorithm given the weights of different labels, without hidden information
freeling::weak_ruleClass weak_rule is an abstract class generalizing any kind of weak rule that adaboost can use
freeling::wordClass word stores all info related to a word: form, list of analysis, list of tokens (if multiword)
freeling::wr_factoryClass wr_factory is a factory enabling to register new types of weak_rules (provided they are derived from weak_rule class below
freeling::wr_paramsClass wr_params is a dummy class used to derive the set of parameters of each WR type