/**
* Adds a new coordinate to this coordination. If the new coordinate is a
* <code>NLGElement</code> then it is added directly to the coordination. If
* the new coordinate is a <code>string</code> a <code>StringElement</code>
* is created and added to the coordination. <code>StringElement</code>s
* will have their complementisers suppressed by default. In the case of
* clauses, complementisers will be suppressed if the clause is not the
* first element in the coordination.
*
* @param newCoordinate
* the new coordinate to be added.
*/
public void addCoordinate(object newCoordinate)
{
List <INLGElement> coordinates = getFeatureAsElementList(InternalFeature.COORDINATES.ToString());
if (coordinates == null)
{
coordinates = new List <INLGElement>();
setFeature(InternalFeature.COORDINATES.ToString(), coordinates);
}
else if (coordinates.Count == 0)
{
setFeature(InternalFeature.COORDINATES.ToString(), coordinates);
}
if (newCoordinate is INLGElement)
{
if (((INLGElement)newCoordinate).isA(PhraseCategoryEnum.CLAUSE) &&
coordinates.Count > 0)
{
((INLGElement)newCoordinate).setFeature(
Feature.SUPRESSED_COMPLEMENTISER.ToString(), true);
}
coordinates.Add((INLGElement)newCoordinate);
}
else if (newCoordinate is string)
{
INLGElement coordElement = new StringElement((string)newCoordinate);
coordElement.setFeature(Feature.SUPRESSED_COMPLEMENTISER.ToString(), true);
coordinates.Add(coordElement);
}
setFeature(InternalFeature.COORDINATES.ToString(), coordinates);
}
/**
* This method performs the morphology for pronouns.
*
* @param element
* the <code>InflectedWordElement</code>.
* @return a <code>StringElement</code> representing the word after
* inflection.
*/
public static INLGElement doPronounMorphology(InflectedWordElement element)
{
string realised = null;
if (!element.getFeatureAsBoolean(InternalFeature.NON_MORPH.ToString()) && !isWHPronoun(element))
{
var genderValue = element.getFeature(LexicalFeature.GENDER);
var personValue = element.getFeature(Feature.PERSON.ToString());
var discourseValue = element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString());
var numberIndex = element.isPlural() ? 1 : 0;
var genderIndex = (genderValue is Gender) ? ((Gender)genderValue).ordinal() : 2;
var personIndex = (personValue is Person) ? ((Person)personValue).ordinal() : 2;
if (personIndex == 2)
{
personIndex += genderIndex;
}
var positionIndex = 0;
if (element.getFeatureAsBoolean(LexicalFeature.REFLEXIVE))
{
positionIndex = 2;
}
else if (element.getFeatureAsBoolean(Feature.POSSESSIVE.ToString()))
{
positionIndex = 3;
if (DiscourseFunction.SPECIFIER.Equals(discourseValue))
{
positionIndex++;
}
}
else
{
positionIndex = (DiscourseFunction.SUBJECT.Equals(discourseValue) && !element.getFeatureAsBoolean(
Feature.PASSIVE.ToString())) ||
(DiscourseFunction.OBJECT.Equals(discourseValue) &&
element.getFeatureAsBoolean(Feature.PASSIVE.ToString())) ||
DiscourseFunction.SPECIFIER.Equals(discourseValue) || (
DiscourseFunction.COMPLEMENT.Equals(discourseValue) &&
element.getFeatureAsBoolean(Feature.PASSIVE.ToString()))
? 0
: 1;
}
realised = PRONOUNS[numberIndex][positionIndex][personIndex];
}
else
{
realised = element.getBaseForm();
}
var realisedElement = new StringElement(realised);
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
return(realisedElement);
}
/**
* This method performs the morphology for adjectives.
*
* @param element
* the <code>InflectedWordElement</code>.
* @param baseWord
* the <code>WordElement</code> as created from the lexicon
* entry.
* @return a <code>StringElement</code> representing the word after
* inflection.
*/
public static INLGElement doAdjectiveMorphology(InflectedWordElement element, WordElement baseWord)
{
string realised = null;
var patternValue = element.getFeature(LexicalFeature.DEFAULT_INFL);
// base form from baseWord if it exists, otherwise from element
var baseForm = getBaseForm(element, baseWord);
if (element.getFeatureAsBoolean(Feature.IS_COMPARATIVE.ToString()))
{
realised = element.getFeatureAsString(LexicalFeature.COMPARATIVE);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.COMPARATIVE);
}
if (realised == null)
{
if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoubleCompAdjective(baseForm);
}
else
{
realised = buildRegularComparative(baseForm);
}
}
}
else if (element.getFeatureAsBoolean(Feature.IS_SUPERLATIVE.ToString()))
{
realised = element.getFeatureAsString(LexicalFeature.SUPERLATIVE);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.SUPERLATIVE);
}
if (realised == null)
{
if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoubleSuperAdjective(baseForm);
}
else
{
realised = buildRegularSuperlative(baseForm);
}
}
}
else
{
realised = baseForm;
}
var realisedElement = new StringElement(realised);
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
return(realisedElement);
}
public override INLGElement realise(INLGElement element)
{
INLGElement realisedElement = null;
if (element is InflectedWordElement)
{
realisedElement = doMorphology((InflectedWordElement)element);
}
else if (element is StringElement)
{
realisedElement = element;
}
else if (element is WordElement)
{
// AG: now retrieves the default spelling variant, not the baseform
// string baseForm = ((WordElement) element).getBaseForm();
var defaultSpell = ((WordElement)element).getDefaultSpellingVariant();
if (defaultSpell != null)
{
realisedElement = new StringElement(defaultSpell);
}
}
else if (element is DocumentElement)
{
List <INLGElement> children = element.getChildren();
((DocumentElement)element).setComponents(realise(children));
realisedElement = element;
}
else if (element is ListElement)
{
realisedElement = new ListElement();
((ListElement)realisedElement).addComponents(realise(element.getChildren()));
}
else if (element is CoordinatedPhraseElement)
{
List <INLGElement> children = element.getChildren();
((CoordinatedPhraseElement)element).clearCoordinates();
if (children != null && children.size() > 0)
{
((CoordinatedPhraseElement)element).addCoordinate(realise(children.get(0)));
for (var index = 1; index < children.size(); index++)
{
((CoordinatedPhraseElement)element).addCoordinate(realise(children.get(index)));
}
realisedElement = element;
}
}
else if (element != null)
{
realisedElement = element;
}
return(realisedElement);
}
/**
* This is the main method for performing the morphology. It effectively
* examines the lexical category of the element and calls the relevant set
* of rules from <code>MorphologyRules</em>.
*
* @param element
* the <code>InflectedWordElement</code>
* @return an <code>NLGElement</code> reflecting the correct inflection for
* the word.
*/
private INLGElement doMorphology(InflectedWordElement element)
{
INLGElement realisedElement = null;
if (element.getFeatureAsBoolean(InternalFeature.NON_MORPH.ToString()))
{
realisedElement = new StringElement(element.getBaseForm());
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
}
else
{
INLGElement baseWord = element.getFeatureAsElement(InternalFeature.BASE_WORD.ToString());
if (baseWord == null && this.lexicon != null)
{
baseWord = this.lexicon.lookupWord(element.getBaseForm());
}
var category = element.getCategory();
if (category is ILexicalCategory)
{
switch ((LexicalCategoryEnum)category.enumType)
{
case LexicalCategoryEnum.PRONOUN:
realisedElement = MorphologyRules.doPronounMorphology(element);
break;
case LexicalCategoryEnum.NOUN:
realisedElement = MorphologyRules.doNounMorphology(element, (WordElement)baseWord);
break;
case LexicalCategoryEnum.VERB:
realisedElement = MorphologyRules.doVerbMorphology(element, (WordElement)baseWord);
break;
case LexicalCategoryEnum.ADJECTIVE:
realisedElement = MorphologyRules.doAdjectiveMorphology(element, (WordElement)baseWord);
break;
case LexicalCategoryEnum.ADVERB:
realisedElement = MorphologyRules.doAdverbMorphology(element, (WordElement)baseWord);
break;
default:
realisedElement = new StringElement(element.getBaseForm());
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
break;
}
}
}
return(realisedElement);
}
/**
* <p>
* Adds a new complement to the phrase element. Complements will be realised
* in the syntax after the head element of the phrase. Complements differ
* from post-modifiers in that complements are crucial to the understanding
* of a phrase whereas post-modifiers are optional.
* </p>
*
* @param newComplement
* the new complement as a <code>string</code>. It is used to
* create a <code>StringElement</code>.
*/
public virtual void addComplement(string newComplement)
{
var newElement = new StringElement(newComplement);
var complements = getFeatureAsElementList(InternalFeature.COMPLEMENTS.ToString());
if (complements == null)
{
complements = new List <INLGElement>();
}
complements.add(newElement);
this.setFeature(InternalFeature.COMPLEMENTS.ToString(), complements);
}
/**
* Retrieves the value of the feature as a <code>NLGElement</code>. If the
* value is a string then it is wrapped in a <code>StringElement</code>. If
* the feature does not exist or is of any other type then <code>null</code>
* is returned.
*
* @param featureName
* the name of the feature.
* @return the <code>NLGElement</code>.
*/
public virtual INLGElement getFeatureAsElement(string featureName)
{
var value = getFeature(featureName);
INLGElement elementValue = null;
var element = value as INLGElement;
if (element != null)
{
elementValue = element;
}
else if (value is string)
{
elementValue = new StringElement((string)value);
}
return(elementValue);
}
/**
* This method performs the morphology for adverbs.
*
* @param element
* the <code>InflectedWordElement</code>.
* @param baseWord
* the <code>WordElement</code> as created from the lexicon
* entry.
* @return a <code>StringElement</code> representing the word after
* inflection.
*/
public static INLGElement doAdverbMorphology(InflectedWordElement element, WordElement baseWord)
{
string realised = null;
// base form from baseWord if it exists, otherwise from element
var baseForm = getBaseForm(element, baseWord);
if (element.getFeatureAsBoolean(Feature.IS_COMPARATIVE.ToString()))
{
realised = element.getFeatureAsString(LexicalFeature.COMPARATIVE);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.COMPARATIVE);
}
if (realised == null)
{
realised = buildRegularComparative(baseForm);
}
}
else if (element.getFeatureAsBoolean(Feature.IS_SUPERLATIVE.ToString()))
{
realised = element.getFeatureAsString(LexicalFeature.SUPERLATIVE);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.SUPERLATIVE);
}
if (realised == null)
{
realised = buildRegularSuperlative(baseForm);
}
}
else
{
realised = baseForm;
}
var realisedElement = new StringElement(realised);
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
return(realisedElement);
}
/**
* Sets the head, or main component, of this current phrase. For example,
* the head for a verb phrase should be a verb while the head of a noun
* phrase should be a noun. <code>string</code>s are converted to
* <code>StringElement</code>s. If <code>null</code> is passed in as the new
* head then the head feature is removed.
*
* @param newHead
* the new value for the head of this phrase.
*/
public virtual void setHead(object newHead)
{
if (newHead == null)
{
removeFeature(InternalFeature.HEAD.ToString());
return;
}
INLGElement headElement;
if (newHead is INLGElement)
{
headElement = (INLGElement)newHead;
}
else
{
headElement = new StringElement(newHead.ToString());
}
setFeature(InternalFeature.HEAD.ToString(), headElement);
}
/**
* This method performs the morphology for verbs.
*
* @param element
* the <code>InflectedWordElement</code>.
* @param baseWord
* the <code>WordElement</code> as created from the lexicon
* entry.
* @return a <code>StringElement</code> representing the word after
* inflection.
*/
public static INLGElement doVerbMorphology(InflectedWordElement element, WordElement baseWord)
{
string realised = null;
var numberValue = element.getFeature(Feature.NUMBER.ToString());
var personValue = element.getFeature(Feature.PERSON.ToString());
var tenseValue = element.getFeatureTense(Feature.TENSE.ToString());
var formValue = element.getFeature(Feature.FORM.ToString());
var patternValue = element.getFeature(LexicalFeature.DEFAULT_INFL);
// base form from baseWord if it exists, otherwise from element
var baseForm = getBaseForm(element, baseWord);
if (element.getFeatureAsBoolean(Feature.NEGATED.ToString()) || Form.BARE_INFINITIVE.Equals(formValue))
{
realised = baseForm;
}
else if (Form.PRESENT_PARTICIPLE.Equals(formValue))
{
realised = element.getFeatureAsString(LexicalFeature.PRESENT_PARTICIPLE);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.PRESENT_PARTICIPLE);
}
if (realised == null)
{
if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoublePresPartVerb(baseForm);
}
else
{
realised = buildRegularPresPartVerb(baseForm);
}
}
}
else if (Tense.PAST.Equals(tenseValue) || Form.PAST_PARTICIPLE.Equals(formValue))
{
if (Form.PAST_PARTICIPLE.Equals(formValue))
{
realised = element.getFeatureAsString(LexicalFeature.PAST_PARTICIPLE);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.PAST_PARTICIPLE);
}
if (realised == null)
{
if ("be".equalsIgnoreCase(baseForm))
{
realised = "been";
}
else if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoublePastVerb(baseForm);
}
else
{
realised = buildRegularPastVerb(baseForm, numberValue, personValue);
}
}
}
else
{
realised = element.getFeatureAsString(LexicalFeature.PAST);
if (realised == null && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.PAST);
}
if (realised == null)
{
if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoublePastVerb(baseForm);
}
else
{
realised = buildRegularPastVerb(baseForm, numberValue, personValue);
}
}
}
}
else if ((numberValue == null || NumberAgreement.SINGULAR.Equals(numberValue)) && (personValue == null ||
Person.THIRD.Equals(
personValue)) &&
(Tense.PRESENT.Equals(tenseValue)))
{
realised = element.getFeatureAsString(LexicalFeature.PRESENT3S);
if (realised == null && baseWord != null && !"be".equalsIgnoreCase(baseForm))
{
realised = baseWord.getFeatureAsString(LexicalFeature.PRESENT3S);
}
if (realised == null)
{
realised = buildPresent3SVerb(baseForm);
}
}
else
{
if ("be".equalsIgnoreCase(baseForm))
{
if (Person.FIRST.Equals(personValue) && (NumberAgreement.SINGULAR.Equals(numberValue) ||
numberValue == null))
{
realised = "am";
}
else
{
realised = "are";
}
}
else
{
realised = baseForm;
}
}
var realisedElement = new StringElement(realised);
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
return(realisedElement);
}
/**
* This method performs the morphology for nouns.
*
* @param element
* the <code>InflectedWordElement</code>.
* @param baseWord
* the <code>WordElement</code> as created from the lexicon
* entry.
* @return a <code>StringElement</code> representing the word after
* inflection.
*/
public static StringElement doNounMorphology(InflectedWordElement element, WordElement baseWord)
{
var realised = new StringBuilder();
// base form from baseWord if it exists, otherwise from element
var baseForm = getBaseForm(element, baseWord);
if (element.isPlural() && !element.getFeatureAsBoolean(LexicalFeature.PROPER))
{
string pluralForm = null;
// AG changed: now check if default infl is uncount
// if (element.getFeatureAsBoolean(LexicalFeature.NON_COUNT)
// ) {
// pluralForm = baseForm;
var elementDefaultInfl = element.getFeature(LexicalFeature.DEFAULT_INFL);
if (elementDefaultInfl != null && Inflection.UNCOUNT.Equals(elementDefaultInfl))
{
pluralForm = baseForm;
}
else
{
pluralForm = element.getFeatureAsString(LexicalFeature.PLURAL);
}
if (pluralForm == null && baseWord != null)
{
// AG changed: now check if default infl is uncount
// if (baseWord.getFeatureAsBoolean(LexicalFeature.NON_COUNT)
// ) {
// pluralForm = baseForm;
var baseDefaultInfl = baseWord.getFeatureAsString(LexicalFeature.DEFAULT_INFL);
if (baseDefaultInfl != null && baseDefaultInfl.Equals("uncount"))
{
pluralForm = baseForm;
}
else
{
pluralForm = baseWord.getFeatureAsString(LexicalFeature.PLURAL);
}
}
if (pluralForm == null)
{
var pattern = element.getFeature(LexicalFeature.DEFAULT_INFL);
if (Inflection.GRECO_LATIN_REGULAR.Equals(pattern))
{
pluralForm = buildGrecoLatinPluralNoun(baseForm);
}
else
{
pluralForm = buildRegularPluralNoun(baseForm);
}
}
realised.append(pluralForm);
}
else
{
realised.append(baseForm);
}
checkPossessive(element, realised);
var realisedElement = new StringElement(realised.ToString());
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION.ToString(),
element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString()));
return(realisedElement);
}
public override INLGElement realise(INLGElement element)
{
INLGElement realisedElement = null;
object function = null; //the element's discourse function
//get the element's function first
if (element is ListElement)
{
List <INLGElement> children = element.getChildren();
if (!children.isEmpty())
{
var firstChild = children.get(0);
function = firstChild.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString());
}
}
else
{
if (element != null)
{
function = element.getFeature(InternalFeature.DISCOURSE_FUNCTION.ToString());
}
}
if (element != null)
{
var category = element.getCategory();
if (category is IDocumentCategory && element is DocumentElement)
{
var components = ((DocumentElement)element).getComponents();
switch ((DocumentCategoryEnum)category.enumType)
{
case DocumentCategoryEnum.SENTENCE:
realisedElement = realiseSentence(components, element);
break;
case DocumentCategoryEnum.LIST_ITEM:
if (components != null && components.size() > 0)
{
// recursively realise whatever is in the list item
// NB: this will realise embedded lists within list
// items
realisedElement = new ListElement(realise(components));
realisedElement.setParent(element.getParent());
}
break;
default:
((DocumentElement)element).setComponents(realise(components));
realisedElement = element;
break;
}
}
else if (element is ListElement)
{
// AG: changes here: if we have a premodifier, then we ask the
// realiseList method to separate with a comma.
// if it's a postmod, we need commas at the start and end only
// if it's appositive
var buffer = new StringBuilder();
if (DiscourseFunction.PRE_MODIFIER.Equals(function))
{
var all_appositives = true;
foreach (NLGElement child in element.getChildren())
{
all_appositives = all_appositives && child.getFeatureAsBoolean(Feature.APPOSITIVE.ToString());
}
// TODO: unless this is the end of the sentence
if (all_appositives)
{
buffer.append(", ");
}
realiseList(buffer, element.getChildren(), this.commaSepPremodifiers ? "," : "");
if (all_appositives)
{
buffer.append(", ");
}
}
else if (DiscourseFunction.POST_MODIFIER.Equals(function))
{
// &&
// appositive)
// {
List <INLGElement> postmods = element.getChildren();
// bug fix due to Owen Bennett
var len = postmods.size();
for (var i = 0; i < len; i++)
{
// for(NLGElement postmod: element.getChildren()) {
var postmod = postmods.get(i);
// if the postmod is appositive, it's sandwiched in
// commas
if (postmod.getFeatureAsBoolean(Feature.APPOSITIVE.ToString()))
{
buffer.append(", ");
buffer.append(realise(postmod).ToString());
if (i < len - 1)
{
buffer.append(", ");
}
}
else
{
buffer.append(realise(postmod).ToString());
if (postmod is ListElement ||
(postmod.getRealisation() != null && !postmod.getRealisation().Equals("")))
{
buffer.append(" ");
}
}
}
}
else if ((DiscourseFunction.CUE_PHRASE.Equals(function) ||
DiscourseFunction.FRONT_MODIFIER.Equals(function)) &&
this.commaSepCuephrase)
{
realiseList(buffer, element.getChildren(), this.commaSepCuephrase ? "," : "");
}
else
{
realiseList(buffer, element.getChildren(), "");
}
// realiseList(buffer, element.getChildren(), "");
realisedElement = new StringElement(buffer.ToString());
}
else if (element is CoordinatedPhraseElement)
{
realisedElement = realiseCoordinatedPhrase(element.getChildren());
}
else
{
realisedElement = element;
}
// make the realised element inherit the original category
// essential if list items are to be properly formatted later
if (realisedElement != null)
{
realisedElement.setCategory(category);
}
//check if this is a cue phrase; if param is set, postfix a comma
if ((DiscourseFunction.CUE_PHRASE.Equals(function) || DiscourseFunction.FRONT_MODIFIER.Equals(function)) &&
this.commaSepCuephrase)
{
var realisation = realisedElement.getRealisation();
if (!realisation.endsWith(","))
{
realisation = realisation + ",";
}
realisedElement.setRealisation(realisation);
}
}
//remove preceding and trailing whitespace from internal punctuation
removePunctSpace(realisedElement);
return(realisedElement);
}