Term (termsuite-core 2.1.2 API)

java.lang.Object
- eu.project.ttc.models.Term

All Implemented Interfaces:: java.lang.Comparable<Term>, java.lang.Iterable<TermOccurrence>

public class Term
extends java.lang.Object
implements java.lang.Iterable<TermOccurrence>, java.lang.Comparable<Term>

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAll(java.util.Collection<TermOccurrence> c)`
`void`	`addExtension(Term t)`
`void`	`addOccurrence(TermOccurrence e)` Adds the parameter occurrence and stores it to the inner occurrence list.
`void`	`addOccurrence(TermOccurrence e, boolean keepOccurrence)` Increments the frequency, updates the inner list of source documents of this term and optionnaly updates the inner list of occurrences of this term if param `keepOccurrence` is set to true.
`void`	`addTermVariation(TermVariation termVariation)` Adds the `TermVariation` object to `variations` and variant`bases`.
`TermVariation`	`addTermVariation(Term variant, VariationType type, java.lang.Object info)` Builds a `TermVariation` object and add it to `variations` and variant`bases`.
`java.util.Iterator<LemmaStemHolder>`	`asComponentIterator()` Calls `asComponentIterator(boolean)` with param `true`.
`java.util.Iterator<LemmaStemHolder>`	`asComponentIterator(boolean compoundLevel)` Turns the term into a list `LemmaStemHolder` where each word of the term is given as itself if not compound, or as a list of its components if compound.
`void`	`clearContext()`
`int`	`compareTo(Term o)`
`ContextVector`	`computeContextVector(OccurrenceType coTermsType, int contextSize, int cooccFrequencyThreshhold, boolean useTermClasses)` Regenerate the single-word contextVector of this term and returns it.
`java.util.Iterator<java.util.Iterator<TermOccurrence>>`	`contextIterator(OccurrenceType coTermsType, int contextSize)`
`boolean`	`equals(java.lang.Object obj)`
`TermWord`	`firstWord()`
`java.util.Set<TermVariation>`	`getBases()`
`java.lang.Iterable<TermVariation>`	`getBases(VariationType... variantTypes)` Get all bases of given `VariationType`s
`ContextVector`	`getContextVector()` Returns the context vector of this term.
`int`	`getDocumentFrequency()`
`java.util.Set<Term>`	`getExtensionBases()`
`java.util.Set<Term>`	`getExtensions()`
`java.util.Set<java.lang.String>`	`getForms()` Deprecated.
`int`	`getFrequency()`
`double`	`getFrequencyNorm()` The average number of occurrences of this term in the corpus for each slice of 1000 words.
`double`	`getGeneralFrequencyNorm()` The average number of occurrences of this term in the general language corpus for each slice of 1000 words.
`java.lang.String`	`getGroupingKey()`
`int`	`getId()`
`java.lang.String`	`getLemma()` Returns the concatenation of inner words' lemmas.
`java.util.Collection<TermOccurrence>`	`getOccurrences()`
`java.lang.String`	`getPattern()`
`java.lang.String`	`getPilot()` Deprecated.
`int`	`getRank()`
`double`	`getSpecificity()`
`java.lang.String`	`getSpottingRule()`
`TermClass`	`getTermClass()`
`java.lang.Number`	`getValue()`
`java.util.List<VariationPath>`	`getVariationPaths(int depth)`
`java.util.Set<TermVariation>`	`getVariations()`
`java.lang.Iterable<TermVariation>`	`getVariations(VariationType... variantTypes)` Get all variations of given `VariationType`s
`java.util.List<TermWord>`	`getWords()`
`int`	`hashCode()`
`boolean`	`isCompound()`
`boolean`	`isContextVectorComputed()` True if the context vector of this term has been computed.
`boolean`	`isMultiWord()`
`boolean`	`isSingleWord()`
`boolean`	`isVariant()`
`java.util.Iterator<TermOccurrence>`	`iterator()`
`void`	`normalize(CrossTable crossTable)`
`void`	`removeTermVariation(TermVariation variation)` Removes the param variation from this`variations` and from variant's `bases`.
`void`	`setBases(java.util.SortedSet<TermVariation> bases)` Deprecated.
`void`	`setContextVector(ContextVector vector)`
`void`	`setFrequency(int frequency)`
`void`	`setFrequencyNorm(double normalizedTermFrequency)`
`void`	`setGeneralFrequencyNorm(double normalizedGeneralTermFrequency)`
`void`	`setPattern(java.lang.String pattern)`
`void`	`setRank(int rank)`
`void`	`setSpecificity(double specificity)`
`void`	`setTermClass(TermClass termClass)`
`void`	`setVariations(java.util.SortedSet<TermVariation> variations)` Deprecated.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - setFrequency
```
public void setFrequency(int frequency)
```
  - setPattern
```
public void setPattern(java.lang.String pattern)
```
  - getOccurrences
```
public java.util.Collection<TermOccurrence> getOccurrences()
```
  - iterator
```
public java.util.Iterator<TermOccurrence> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<TermOccurrence>
  - addOccurrence
```
public void addOccurrence(TermOccurrence e,
                 boolean keepOccurrence)
```
    Increments the frequency, updates the inner list of source documents of this term and optionnaly updates the inner list of occurrences of this term if param keepOccurrence is set to true.
    
    Parameters:
    e - the occurrence object to add
    keepOccurrence - set this param to true if you need the occurrence to be stored within the object
    See Also:
    getOccurrences()
  - addOccurrence
```
public void addOccurrence(TermOccurrence e)
```
    Adds the parameter occurrence and stores it to the inner occurrence list.
    
    Parameters:
    e - the occurrence object
    See Also:
    addOccurrence(TermOccurrence, boolean)
  - addAll
```
public void addAll(java.util.Collection<TermOccurrence> c)
```
  - compareTo
```
public int compareTo(Term o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<Term>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - getGroupingKey
```
public java.lang.String getGroupingKey()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - isSingleWord
```
public boolean isSingleWord()
```
  - isMultiWord
```
public boolean isMultiWord()
```
  - addTermVariation
```
public TermVariation addTermVariation(Term variant,
                             VariationType type,
                             java.lang.Object info)
```
    Builds a TermVariation object and add it to variations and variantbases.
    
    Parameters:
    variant -
    type -
    info -
  - addTermVariation
```
public void addTermVariation(TermVariation termVariation)
```
    Adds the TermVariation object to variations and variantbases.
    
    Parameters:
    termVariation -
  - removeTermVariation
```
public void removeTermVariation(TermVariation variation)
```
    Removes the param variation from thisvariations and from variant's bases.
    
    Parameters:
    variation -
  - asComponentIterator
```
public java.util.Iterator<LemmaStemHolder> asComponentIterator()
```
    Calls asComponentIterator(boolean) with param true.
    
    Returns:
  - asComponentIterator
```
public java.util.Iterator<LemmaStemHolder> asComponentIterator(boolean compoundLevel)
```
    Turns the term into a list LemmaStemHolder where each word of the term is given as itself if not compound, or as a list of its components if compound.
    
    Parameters:
    compoundLevel - set to true if this method should iterate over components when words are compound, set it to false if this method should iterate over plain words even though they are compounds.
    
    Returns:
    The list of words and/or (depending on compoundLevel) compounds.
  - getPattern
```
public java.lang.String getPattern()
```
  - getWords
```
public java.util.List<TermWord> getWords()
```
  - getFrequency
```
public int getFrequency()
```
  - firstWord
```
public TermWord firstWord()
```
  - isCompound
```
public boolean isCompound()
```
  - getId
```
public int getId()
```
  - getSpottingRule
```
public java.lang.String getSpottingRule()
```
  - isVariant
```
public boolean isVariant()
```
  - getForms
```
@Deprecated
public java.util.Set<java.lang.String> getForms()
```
    Deprecated.
    
    Use TermUtils.formGetter(TermIndex, boolean) instead.
    
    Returns:
  - getPilot
```
@Deprecated
public java.lang.String getPilot()
```
    Deprecated.
    
    Use TermUtils.formGetter(TermIndex, boolean) instead.
    
    Returns:
  - getLemma
```
public java.lang.String getLemma()
```
    Returns the concatenation of inner words' lemmas.
  - getVariationPaths
```
public java.util.List<VariationPath> getVariationPaths(int depth)
```
  - getContextVector
```
public ContextVector getContextVector()
```
    Returns the context vector of this term. The context vector must have been explicitly invoked by user using the #computeContextVector(contextSize) method.
    
    Returns:
    the ContextVector of this term
    
    Throws:
    
    java.lang.IllegalStateException - if the inner context vector does not exist (invoke #computeContextVector(contextSize)) to generate this vector if missing.
    See Also:
    isContextVectorComputed()
  - isContextVectorComputed
```
public boolean isContextVectorComputed()
```
    True if the context vector of this term has been computed. float
    
    Returns:
    See Also:
    getContextVector()
  - computeContextVector
```
public ContextVector computeContextVector(OccurrenceType coTermsType,
                                 int contextSize,
                                 int cooccFrequencyThreshhold,
                                 boolean useTermClasses)
```
    Regenerate the single-word contextVector of this term and returns it.
    
    Parameters:
    coTermsType -
    contextSize -
    cooccFrequencyThreshhold -
    useTermClasses -
    
    Returns:
    The computed ContextVector object
  - contextIterator
```
public java.util.Iterator<java.util.Iterator<TermOccurrence>> contextIterator(OccurrenceType coTermsType,
                                                                     int contextSize)
```
  - getDocumentFrequency
```
public int getDocumentFrequency()
```
  - normalize
```
public void normalize(CrossTable crossTable)
```
  - getValue
```
public java.lang.Number getValue()
```
  - setContextVector
```
public void setContextVector(ContextVector vector)
```
  - clearContext
```
public void clearContext()
```
  - setTermClass
```
public void setTermClass(TermClass termClass)
```
  - getTermClass
```
public TermClass getTermClass()
```
  - getVariations
```
public java.util.Set<TermVariation> getVariations()
```
  - getBases
```
public java.util.Set<TermVariation> getBases()
```
  - getVariations
```
public java.lang.Iterable<TermVariation> getVariations(VariationType... variantTypes)
```
    Get all variations of given VariationTypes
    
    Parameters:
    variantTypes -
    
    Returns:
  - getBases
```
public java.lang.Iterable<TermVariation> getBases(VariationType... variantTypes)
```
    Get all bases of given VariationTypes
    
    Parameters:
    variantTypes -
    
    Returns:
  - setFrequencyNorm
```
public void setFrequencyNorm(double normalizedTermFrequency)
```
  - setGeneralFrequencyNorm
```
public void setGeneralFrequencyNorm(double normalizedGeneralTermFrequency)
```
  - getGeneralFrequencyNorm
```
public double getGeneralFrequencyNorm()
```
    The average number of occurrences of this term in the general language corpus for each slice of 1000 words.
    
    Returns:
  - getFrequencyNorm
```
public double getFrequencyNorm()
```
    The average number of occurrences of this term in the corpus for each slice of 1000 words.
    
    Returns:
  - addExtension
```
public void addExtension(Term t)
```
  - getExtensions
```
public java.util.Set<Term> getExtensions()
```
  - getExtensionBases
```
public java.util.Set<Term> getExtensionBases()
```
  - setVariations
```
@Deprecated
public void setVariations(java.util.SortedSet<TermVariation> variations)
```
    Deprecated.
    
    Do not use this, this will disappear on version 3.0.
    
    Parameters:
    variations -
  - setBases
```
@Deprecated
public void setBases(java.util.SortedSet<TermVariation> bases)
```
    Deprecated.
    
    Do not use this, this will disappear on version 3.0.
    
    Parameters:
    variations -
  - getRank
```
public int getRank()
```
  - setRank
```
public void setRank(int rank)
```
  - getSpecificity
```
public double getSpecificity()
```
  - setSpecificity
```
public void setSpecificity(double specificity)
```

Class Term

Method Summary

Methods inherited from class java.lang.Object

Method Detail

setFrequency

setPattern

getOccurrences

iterator

addOccurrence

addOccurrence

addAll

compareTo

hashCode

equals

getGroupingKey

toString

isSingleWord

isMultiWord

addTermVariation

addTermVariation

removeTermVariation

asComponentIterator

asComponentIterator

getPattern

getWords

getFrequency

firstWord

isCompound

getId

getSpottingRule

isVariant

getForms

getPilot

getLemma

getVariationPaths

getContextVector

isContextVectorComputed

computeContextVector

contextIterator

getDocumentFrequency

normalize

getValue

setContextVector

clearContext

setTermClass

getTermClass

getVariations

getBases

getVariations

getBases

setFrequencyNorm

setGeneralFrequencyNorm

getGeneralFrequencyNorm

getFrequencyNorm

addExtension

getExtensions

getExtensionBases

setVariations

setBases

getRank

setRank

getSpecificity

setSpecificity