/**
* Determines the maximim position at which this modifier can occur.
*
* @param modifier
* the modifier to be checked.
* @return the maximum position for this modifier.
*/
private static int getMaxPos(NLGElement modifier)
{
int position = NOUN_POSITION;
if (modifier.isA(new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ADJECTIVE)) || modifier.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.ADJECTIVE_PHRASE)))
{
WordElement adjective = getHeadWordElement(modifier);
if (adjective.getFeatureAsBoolean(LexicalFeature.CLASSIFYING))
{
position = CLASSIFYING_POSITION;
}
else if (adjective.getFeatureAsBoolean(LexicalFeature.COLOUR))
{
position = COLOUR_POSITION;
}
else if (adjective.getFeatureAsBoolean(LexicalFeature.QUALITATIVE))
{
position = QUALITATIVE_POSITION;
}
else
{
position = CLASSIFYING_POSITION;
}
}
return(position);
}
/// <summary>
/// 合并多行注释
/// </summary>
/// <param name="codeElement"></param>
private void MergeMulitRem(AnalyzeElement codeElement)
{
var last = codeElement.Elements[codeElement.Elements.Count - 1];
codeElement.Elements.RemoveAt(codeElement.Elements.Count - 1);
var element = codeElement.Elements[codeElement.Elements.Count - 1];
element.ItemRace = CodeItemRace.Assist;
element.ItemFamily = CodeItemFamily.Rem;
element.Word += last.Word;
codeElement.CurrentElement = element;
bool isShift = false;
for (CurWordIndex++; CurWordIndex < WordElements.Count; CurWordIndex++)
{
WordElement curElement = WordElements[CurWordIndex];
element.Word += curElement.RealWord;
if (isShift && curElement.Char == '/')//注释结束
{
return;
}
isShift = curElement.Char == '*';
}
}
/**
* extract adj information from NIH AdjEntry record, and add to a simplenlg
* WordElement For now just extract position info
*
* @param wordElement
* @param AdjEntry
*/
private void addAdjectiveInfo(WordElement wordElement, AdjEntry adjEntry)
{
bool qualitativeAdj = false;
bool colourAdj = false;
bool classifyingAdj = false;
bool predicativeAdj = false;
List <string> positions = adjEntry.GetPosition();
foreach (string position in positions)
{
if (position.StartsWith("attrib(1)", StringComparison.Ordinal))
{
qualitativeAdj = true;
}
else if (position.StartsWith("attrib(2)", StringComparison.Ordinal))
{
colourAdj = true;
}
else if (position.StartsWith("attrib(3)", StringComparison.Ordinal))
{
classifyingAdj = true;
}
else if (position.StartsWith("pred", StringComparison.Ordinal))
{
predicativeAdj = true;
}
// ignore other positions
}
// ignore (for now) other info in record
wordElement.setFeature(LexicalFeature.QUALITATIVE, qualitativeAdj);
wordElement.setFeature(LexicalFeature.COLOUR, colourAdj);
wordElement.setFeature(LexicalFeature.CLASSIFYING, classifyingAdj);
wordElement.setFeature(LexicalFeature.PREDICATIVE, predicativeAdj);
}
private IList <string> breakWord(string word, HashSet <string> wordDict)
{
Queue <WordElement> q = new Queue <WordElement>();
q.Enqueue(new WordElement(0));
IList <string> result = new List <string>();
while (q.Count > 0)
{
WordElement ele = q.Dequeue();
if (ele.nextindex >= word.Length)
{
result.Add(ele.result);
}
for (int i = ele.nextindex; i <= word.Length; i++)
{
string possibleWord = word.Substring(ele.nextindex, i - ele.nextindex);
if (wordDict.Contains(possibleWord))
{
WordElement newEle = new WordElement(i, ele.result);
string temp = newEle.result != null ? newEle.result : null;
newEle.result = temp != null ? temp + " " + possibleWord : possibleWord;
q.Enqueue(newEle);
}
}
}
return(result);
}
public virtual void verbInflectionalVariantsTest()
{
WordElement word = lexicon.getWord("lie", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB));
Assert.AreEqual(Inflection.REGULAR, word.getDefaultInflectionalVariant());
// default past is "lied"
InflectedWordElement infl = new InflectedWordElement(word);
infl.setFeature(Feature.TENSE, Tense.PAST);
string past = realiser.realise(infl).Realisation;
Assert.AreEqual("lied", past);
// switch to irregular
word.setDefaultInflectionalVariant(Inflection.IRREGULAR);
infl = new InflectedWordElement(word);
infl.setFeature(Feature.TENSE, Tense.PAST);
past = realiser.realise(infl).Realisation;
Assert.AreEqual("lay", past);
// switch back to regular
word.setDefaultInflectionalVariant(Inflection.REGULAR);
Assert.AreEqual(null, word.getFeature(LexicalFeature.PAST));
infl = new InflectedWordElement(word);
infl.setFeature(Feature.TENSE, Tense.PAST);
past = realiser.realise(infl).Realisation;
Assert.AreEqual("lied", past);
}
/**
* extract verb information from NIH VerbEntry record, and add to a
* simplenlg WordElement For now just extract transitive, instransitive,
* and/or ditransitive
*
* @param wordElement
* @param verbEntry
*/
private void addVerbInfo(WordElement wordElement, VerbEntry verbEntry)
{
if (verbEntry == null)
{ // should only happen for aux verbs, which have
// auxEntry instead of verbEntry in NIH Lex
// just flag as transitive and return
wordElement.setFeature(LexicalFeature.INTRANSITIVE, false);
wordElement.setFeature(LexicalFeature.TRANSITIVE, true);
wordElement.setFeature(LexicalFeature.DITRANSITIVE, false);
return;
}
bool intransitiveVerb = verbEntry.GetIntran().Any();
bool transitiveVerb = verbEntry.GetTran().Any() || verbEntry.GetCplxtran().Any();
bool ditransitiveVerb = verbEntry.GetDitran().Any();
wordElement.setFeature(LexicalFeature.INTRANSITIVE, intransitiveVerb);
wordElement.setFeature(LexicalFeature.TRANSITIVE, transitiveVerb);
wordElement.setFeature(LexicalFeature.DITRANSITIVE, ditransitiveVerb);
// add the inflectional variants
List <string> variants = verbEntry.GetVariants();
if (variants.Count > 0)
{
IList <Inflection> wordVariants = new List <Inflection>();
foreach (string v in variants)
{
int index = v.IndexOf("|", StringComparison.Ordinal);
string code;
Inflection?infl;
if (index > -1)
{
code = v.Substring(0, index).ToLower().Trim();
infl = Inflection.REGULAR.getInflCode(code);
}
else
{
infl = Inflection.REGULAR.getInflCode(v.ToLower().Trim());
}
if (infl != null)
{
wordElement.addInflectionalVariant((Inflection)infl);
wordVariants.Add((Inflection)infl);
}
}
// if the variants include "reg", this is the default, otherwise
// just a random pick
Inflection defaultVariant = wordVariants.Contains(Inflection.REGULAR) || wordVariants.Count == 0 ? Inflection.REGULAR : wordVariants[0];
// wordElement.setFeature(LexicalFeature.INFLECTIONS, wordVariants);
// wordElement.setFeature(LexicalFeature.DEFAULT_INFL, defaultVariant);
wordElement.setDefaultInflectionalVariant(defaultVariant);
}
// ignore (for now) other info in record
}
public virtual void nounInflectionalVariantsTest()
{
WordElement word =
lexicon.getWord("sanctum", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.NOUN));
Assert.AreEqual(Inflection.REGULAR, word.getDefaultInflectionalVariant());
// reg plural shouldn't be stored
Assert.AreEqual(null, word.getFeature(LexicalFeature.PLURAL));
InflectedWordElement infl = new InflectedWordElement(word);
infl.setFeature(Feature.NUMBER, NumberAgreement.PLURAL);
string plur = realiser.realise(infl).Realisation;
Assert.AreEqual("sanctums", plur);
// switch to glreg
word.setDefaultInflectionalVariant(Inflection.GRECO_LATIN_REGULAR);
infl = new InflectedWordElement(word);
infl.setFeature(Feature.NUMBER, NumberAgreement.PLURAL);
plur = realiser.realise(infl).Realisation;
Assert.AreEqual("sancta", plur);
// and back to reg
word.setDefaultInflectionalVariant(Inflection.REGULAR);
infl = new InflectedWordElement(word);
infl.setFeature(Feature.NUMBER, NumberAgreement.PLURAL);
plur = realiser.realise(infl).Realisation;
Assert.AreEqual("sanctums", plur);
}
/**
* quick-and-dirty routine for getting morph variants should be replaced by
* something better!
*
* @param word
* @return
*/
private ISet <string> getVariants(WordElement word)
{
ISet <string> variants = new HashSet <string>();
variants.Add(word.BaseForm);
ElementCategory category = word.Category;
if (category is LexicalCategory)
{
switch (((LexicalCategory)category).GetLexicalCategory())
{
case LexicalCategory.LexicalCategoryEnum.NOUN:
variants.Add(getVariant(word, LexicalFeature.PLURAL, "s"));
break;
case LexicalCategory.LexicalCategoryEnum.ADJECTIVE:
variants.Add(getVariant(word, LexicalFeature.COMPARATIVE, "er"));
variants.Add(getVariant(word, LexicalFeature.SUPERLATIVE, "est"));
break;
case LexicalCategory.LexicalCategoryEnum.VERB:
variants.Add(getVariant(word, LexicalFeature.PRESENT3S, "s"));
variants.Add(getVariant(word, LexicalFeature.PAST, "ed"));
variants.Add(getVariant(word, LexicalFeature.PAST_PARTICIPLE, "ed"));
variants.Add(getVariant(word, LexicalFeature.PRESENT_PARTICIPLE, "ing"));
break;
default:
// only base needed for other forms
break;
}
}
return(variants);
}
/**
* add word to internal indices
*
* @param word
*/
private void IndexWord(WordElement word)
{
// first index by base form
string @base = word.BaseForm;
// shouldn't really need is, as all words have base forms
if (!ReferenceEquals(@base, null))
{
updateIndex(word, @base, indexByBase);
}
// now index by ID, which should be unique (if present)
string id = word.Id;
if (!ReferenceEquals(id, null))
{
if (indexByID.ContainsKey(id))
{
Console.WriteLine("Lexicon error: ID " + id + " occurs more than once");
}
indexByID[id] = word;
}
// now index by variant
foreach (string variant in getVariants(word))
{
updateIndex(word, variant, indexByVariant);
}
// done
}
public virtual void spellingVariantsInNPTest()
{
WordElement asd = lexicon.getWord("Adams-Stokes disease");
Assert.AreEqual("Adams-Stokes disease", asd.DefaultSpellingVariant);
NPPhraseSpec np = factory.createNounPhrase(asd);
np.setSpecifier(lexicon.getWord("the"));
Assert.AreEqual("the Adams-Stokes disease", realiser.realise(np).Realisation);
// change spelling var
asd.DefaultSpellingVariant = "Adams Stokes disease";
Assert.AreEqual("Adams Stokes disease", asd.DefaultSpellingVariant);
Assert.AreEqual("the Adams Stokes disease", realiser.realise(np).Realisation);
//default infl for this word is uncount
np.setFeature(Feature.NUMBER, NumberAgreement.PLURAL);
Assert.AreEqual("the Adams Stokes disease", realiser.realise(np).Realisation);
//change default infl for this word
asd.setDefaultInflectionalVariant(Inflection.REGULAR);
Assert.AreEqual("the Adams Stokes diseases", realiser.realise(np).Realisation);
}
///// <summary>
///// 组合代码
///// </summary>
///// <param name="isCodeBlock"></param>
///// <param name="codeElement"></param>
//void JoinCode(bool isCodeBlock, WordElement codeElement)
//{
// if (contentElement != null)
// {
// if (isCodeBlock)
// {
// AppendContentCode(contentElement);
// contentElement = null;
// }
// else
// {
// contentElement.Append(codeElement.Element.End, $"{{{codeElement.RealWord.Trim()}}}");
// }
// }
// else if (!isCodeBlock)
// {
// Codes.Add($"strResult.Append({codeElement.RealWord.Trim()});");
// }
// if (isCodeBlock && codeElement != null)
// {
// Codes.Add(codeElement.RealWord);
// }
// if (CurWordIndex < this.WordElements.Count && this.WordElements[CurWordIndex].Element.IsSpace)
// {
// CurWordIndex--; //空白还回去
// }
//}
#endregion
#region 特殊单元的组合
/// <summary>
/// 处理当前语言内容
/// </summary>
/// <param name="codeElement">语言节点</param>
/// <param name="preChar"></param>
public override void MergeLanWord(AnalyzeElement codeElement, ref char preChar)
{
WordElement cur = WordElements[CurWordIndex];
codeElement.Append(cur);
if (!cur.IsPunctuate)
{
preChar = '\0';
return;
}
switch (cur.Char)
{
#region 注释
case '/':
if (preChar != '/')
{
preChar = '/';
return;
}
MergeSinleRem(codeElement);
break;
case '*':
if (preChar == '/')
{
MergeMulitRem(codeElement);
}
break;
#endregion
#region 字符串
case '@':
preChar = '@';
return;
case '\"':
if (preChar == '@')
{
var block = codeElement.Elements[codeElement.Elements.Count - 2];
block.Append(cur);
codeElement.Elements.RemoveAt(codeElement.Elements.Count - 1);
MergeMulitString(block);
}
else
{
MergeString(cur, '\"');
}
break;
case '\'':
MergeString(cur, '\'');
break;
#endregion
}
preChar = '\0';
}
public override bool Load(SecurityElement element)
{
if (element.Tag != "Items")
{
return(false);
}
if (element.Children != null)
{
foreach (SecurityElement childrenElement in element.Children)
{
if (childrenElement.Tag == "Item")
{
WordElement wordElement = null;
if (!LoadWordElement(childrenElement, out wordElement))
{
continue;
}
_mWordElementList[wordElement.WordID] = wordElement;
}
}
return(true);
}
return(false);
}
/**
* extract adv information from NIH AdvEntry record, and add to a simplenlg
* WordElement For now just extract modifier type
*
* @param wordElement
* @param AdvEntry
*/
private void addAdverbInfo(WordElement wordElement, AdvEntry advEntry)
{
bool verbModifier = false;
bool sentenceModifier = false;
bool intensifier = false;
List <string> modifications = advEntry.GetModification();
foreach (string modification in modifications)
{
if (modification.StartsWith("verb_modifier", StringComparison.Ordinal))
{
verbModifier = true;
}
else if (modification.StartsWith("sentence_modifier", StringComparison.Ordinal))
{
sentenceModifier = true;
}
else if (modification.StartsWith("intensifier", StringComparison.Ordinal))
{
intensifier = true;
}
// ignore other modification types
}
// ignore (for now) other info in record
wordElement.setFeature(LexicalFeature.VERB_MODIFIER, verbModifier);
wordElement.setFeature(LexicalFeature.SENTENCE_MODIFIER, sentenceModifier);
wordElement.setFeature(LexicalFeature.INTENSIFIER, intensifier);
}
/**
* extract noun information from NIH NounEntry record, and add to a
* simplenlg WordElement For now just extract whether count/non-count and
* whether proper or not
*
* @param wordElement
* @param nounEntry
*/
private void addNounInfo(WordElement wordElement, NounEntry nounEntry)
{
bool proper = nounEntry.IsProper();
// bool nonCountVariant = false;
// bool regVariant = false;
// add the inflectional variants
List <string> variants = nounEntry.GetVariants();
if (variants.Count > 0)
{
IList <Inflection> wordVariants = new List <Inflection>();
foreach (string v in variants)
{
int index = v.IndexOf("|", StringComparison.Ordinal);
string code;
if (index > -1)
{
code = v.Substring(0, index).ToLower().Trim();
}
else
{
code = v.ToLower().Trim();
}
Inflection?infl = Inflection.REGULAR.getInflCode(code);
if (infl != null)
{
wordVariants.Add((Inflection)infl);
wordElement.addInflectionalVariant((Inflection)infl);
}
}
// if the variants include "reg", this is the default, otherwise just a random pick
Inflection defaultVariant = wordVariants.Contains(Inflection.REGULAR) || wordVariants.Count == 0 ? Inflection.REGULAR : wordVariants[0];
wordElement.setFeature(LexicalFeature.DEFAULT_INFL, defaultVariant);
wordElement.setDefaultInflectionalVariant(defaultVariant);
}
// for (String variant : variants) {
// if (variant.startsWith("uncount")
// || variant.startsWith("groupuncount"))
// nonCountVariant = true;
//
// if (variant.startsWith("reg"))
// regVariant = true;
// // ignore other variant info
// }
// lots of words have both "reg" and "unCount", indicating they
// can be used in either way. Regard such words as normal,
// only flag as nonCount if unambiguous
// wordElement.setFeature(LexicalFeature.NON_COUNT, nonCountVariant && !regVariant);
wordElement.setFeature(LexicalFeature.PROPER, proper);
// ignore (for now) other info in record
}
/**
* convenience method to update an index
*
* @param word
* @param base
* @param index
*/
private void updateIndex(WordElement word, string @base, IDictionary <string, IList <WordElement> > index)
{
if (!index.ContainsKey(@base))
{
index[@base] = new List <WordElement>();
}
index[@base].Add(word);
}
public Phrase GetRandomSentence(WordElement word = null)
{
if (word == null)
{
word = GetRandomWord();
}
return(new Phrase(this, word));
}
/// <summary>
/// 处理当前语言内容
/// </summary>
/// <param name="codeElement">语言节点</param>
/// <param name="preChar"></param>
public override void MergeLanWord(AnalyzeElement codeElement, ref char preChar)
{
WordElement cur = WordElements[CurWordIndex];
codeElement.Append(cur);
if (!cur.IsPunctuate)
{
preChar = '\0';
return;
}
switch (cur.Char)
{
#region 注释
case '-':
if (preChar != '-')
{
preChar = '-';
return;
}
{
var block = codeElement.Elements[codeElement.Elements.Count - 2];
block.Append(cur);
codeElement.Elements.RemoveAt(codeElement.Elements.Count - 1);
MergeLuaRem(block);
block.SetRace(CodeItemRace.Assist, CodeItemFamily.Rem);
}
break;
#endregion
#region 字符串
case '\"':
case '\'':
MergeString(cur, cur.Char);
break;
case '[':
if (preChar != '[')
{
preChar = '[';
return;
}
{
var block = codeElement.Elements[codeElement.Elements.Count - 2];
block.Append(cur);
codeElement.Elements.RemoveAt(codeElement.Elements.Count - 1);
MergeMulitString(block);
block.SetRace(CodeItemRace.Value, CodeItemFamily.Constant, CodeItemType.String);
}
break;
#endregion
}
preChar = '\0';
}
/**
* 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 NLGElement doAdjectiveMorphology(InflectedWordElement element, WordElement baseWord)
{
string realised = null;
object patternValue = element.getFeature(LexicalFeature.DEFAULT_INFL);
// base form from baseWord if it exists, otherwise from element
string baseForm = getBaseForm(element, baseWord);
if (element.getFeatureAsBoolean(Feature.IS_COMPARATIVE))
{
realised = element.getFeatureAsString(LexicalFeature.COMPARATIVE);
if (ReferenceEquals(realised, null) && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.COMPARATIVE);
}
if (ReferenceEquals(realised, null))
{
if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoubleCompAdjective(baseForm);
}
else
{
realised = buildRegularComparative(baseForm);
}
}
}
else if (element.getFeatureAsBoolean(Feature.IS_SUPERLATIVE))
{
realised = element.getFeatureAsString(LexicalFeature.SUPERLATIVE);
if (ReferenceEquals(realised, null) && baseWord != null)
{
realised = baseWord.getFeatureAsString(LexicalFeature.SUPERLATIVE);
}
if (ReferenceEquals(realised, null))
{
if (Inflection.REGULAR_DOUBLE.Equals(patternValue))
{
realised = buildDoubleSuperAdjective(baseForm);
}
else
{
realised = buildRegularSuperlative(baseForm);
}
}
}
else
{
realised = baseForm;
}
StringElement realisedElement = new StringElement(realised);
realisedElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, element.getFeature(InternalFeature.DISCOURSE_FUNCTION));
return(realisedElement);
}
// note that addFrontModifier, addPostModifier, addPreModifier are inherited from PhraseElement
// likewise getFrontModifiers, getPostModifiers, getPreModifiers
/** Add a modifier to a verb phrase
* Use heuristics to decide where it goes
* @param modifier
*/
public override void addModifier(object modifier)
{
// adverb is preModifier
// string which is one lexicographic word is looked up in lexicon,
// if it is an adverb than it becomes a preModifier
// Everything else is postModifier
if (modifier == null)
{
return;
}
// get modifier as NLGElement if possible
NLGElement modifierElement = null;
if (modifier is NLGElement)
{
modifierElement = (NLGElement)modifier;
}
else if (modifier is string)
{
string modifierString = (string)modifier;
if (modifierString.Length > 0 && !modifierString.Contains(" "))
{
modifierElement = Factory.createWord(modifier, new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ANY));
}
}
// if no modifier element, must be a complex string
if (modifierElement == null)
{
addPostModifier((string)modifier);
return;
}
// extract WordElement if modifier is a single word
WordElement modifierWord = null;
if (modifierElement != null && modifierElement is WordElement)
{
modifierWord = (WordElement)modifierElement;
}
else if (modifierElement != null && modifierElement is InflectedWordElement)
{
modifierWord = ((InflectedWordElement)modifierElement).BaseWord;
}
if (modifierWord != null && modifierWord.Category == LexicalCategory.LexicalCategoryEnum.ADVERB)
{
addPreModifier(modifierWord);
return;
}
// default case
addPostModifier(modifierElement);
}
public virtual void acronymsTests()
{
WordElement uk = lexicon.getWord("UK");
WordElement unitedKingdom = lexicon.getWord("United Kingdom");
IList <NLGElement> fullForms = uk.getFeatureAsElementList(LexicalFeature.ACRONYM_OF);
Assert.AreEqual(3, fullForms.Count);
Assert.IsTrue(fullForms.Contains(unitedKingdom));
}
/**
* Unwrap word element.
*
* @param wordElement
* the word element
* @return the nLG element
*/
private NLGElement UnwrapWordElement(XmlWordElement wordElement)
{
NLGElement word = null;
if (wordElement != null)
{
if (true.Equals(wordElement.Canned))
{
word = factory.createStringElement(wordElement.Base);
}
else
{
LexicalCategory lexCat = new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ANY);
ElementCategory cat = UnwrapCategory(wordElement.Cat);
if (cat != null && cat is LexicalCategory)
{
lexCat = (LexicalCategory)cat;
}
// String baseForm = getBaseWord(wordElement);
string baseForm = wordElement.Base;
if (!ReferenceEquals(baseForm, null))
{
word = factory.createWord(baseForm, lexCat);
if (word is InflectedWordElement && ((InflectedWordElement)word).BaseWord.BaseForm.Length == 0)
{
word = null; // cch TESTING
}
else if (word is WordElement)
{
WordElement we = (WordElement)word;
// Inflection
if (wordElement.Var != null)
{
Enum.TryParse(wordElement.Var.ToString(), out Inflection defaultInflection);
we.setDefaultInflectionalVariant(defaultInflection);
}
// Spelling variant may have been given as base form in xml.
// If so, use that variant.
if (!Regex.IsMatch(baseForm, "^" + we.BaseForm + "$"))
{
we.DefaultSpellingVariant = baseForm;
}
}
}
}
}
return(word);
}
/**
* quick-and-dirty routine for computing morph forms Should be replaced by
* something better!
*
* @param word
* @param feature
* @param string
* @return
*/
private string getVariant(WordElement word, string feature, string suffix)
{
if (word.hasFeature(feature))
{
return(word.getFeatureAsString(feature));
}
else
{
return(getForm(word.BaseForm, suffix));
}
}
///**
// * Extract info about the spelling variants of a word from an NIH record,
// * and add to the simplenlg Woordelement.
// *
// * <P>
// * Spelling variants are represented as lists of strings, retrievable via
// * {@link LexicalFeature#SPELL_VARS}
// *
// * @param wordElement
// * @param record
// */
private void addSpellingVariants(WordElement wordElement, LexRecord record)
{
List <string> vars = record.GetSpellingVars();
if (vars != null && vars.Count > 0)
{
wordElement.setFeature(LexicalFeature.SPELL_VARS, vars);
}
// we set the default spelling var as the baseForm
wordElement.setFeature(LexicalFeature.DEFAULT_SPELL, wordElement.BaseForm);
}
/**
* return the base form of a word
*
* @param element
* @param baseWord
* @return
*/
private static string getBaseForm(InflectedWordElement element, WordElement baseWord)
{
// unclear what the right behaviour should be
// for now, prefer baseWord.getBaseForm() to element.getBaseForm() for
// verbs (ie, "is" mapped to "be")
// but prefer element.getBaseForm() to baseWord.getBaseForm() for other
// words (ie, "children" not mapped to "child")
// AG: changed this to get the default spelling variant
// needed to preserve spelling changes in the VP
if (element.Category == LexicalCategory.LexicalCategoryEnum.VERB)
{
if (baseWord != null && baseWord.DefaultSpellingVariant != null)
{
return(baseWord.DefaultSpellingVariant);
}
else
{
return(element.BaseForm);
}
}
else
{
if (element.BaseForm != null)
{
return(element.BaseForm);
}
else if (baseWord == null)
{
return(null);
}
else
{
return(baseWord.DefaultSpellingVariant);
}
}
// if (LexicalCategory.VERB == element.getCategory()) {
// if (baseWord != null && baseWord.getBaseForm() != null)
// return baseWord.getBaseForm();
// else
// return element.getBaseForm();
// } else {
// if (element.getBaseForm() != null)
// return element.getBaseForm();
// else if (baseWord == null)
// return null;
// else
// return baseWord.getBaseForm();
// }
}
public virtual void spellingVariantsInVPTest()
{
WordElement eth = (WordElement)factory.createWord("etherise",
new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB));
Assert.AreEqual("etherize", eth.DefaultSpellingVariant);
eth.DefaultSpellingVariant = "etherise";
Assert.AreEqual("etherise", eth.DefaultSpellingVariant);
SPhraseSpec s = factory.createClause(factory.createNounPhrase("the", "doctor"), eth,
factory.createNounPhrase("the patient"));
Assert.AreEqual("the doctor etherises the patient", realiser.realise(s).Realisation);
}
public static bool equals(this WordElement o, WordElement d)
{
if (o != null)
{
var we = o;
return((o.baseForm == d.baseForm || o.baseForm
.Equals(d.baseForm)) &&
(o.id == d.id || o.id.Equals(d.id)) &&
d.features.equals(o.features));
}
return(false);
}
/**
* add special cases to lexicon
*
*/
private void addSpecialCases()
{
// add variants of "be"
WordElement be = getWord("be", new LexicalCategory(LexicalCategory.LexicalCategoryEnum.VERB));
if (be != null)
{
updateIndex(be, "is", indexByVariant);
updateIndex(be, "am", indexByVariant);
updateIndex(be, "are", indexByVariant);
updateIndex(be, "was", indexByVariant);
updateIndex(be, "were", indexByVariant);
}
}
/// <summary>
/// 合并注释
/// </summary>
/// <param name="element"></param>
private void MergeLuaRem(WordElement element)
{
if (IsWithLineEnd())
{
return;
}
element.Append(WordElements[++CurWordIndex]);
var a = WordElements[CurWordIndex].Char;
if (IsWithLineEnd())
{
return;
}
element.Append(WordElements[++CurWordIndex]);
var b = WordElements[CurWordIndex].Char;
if (a == '[' && b == '[') //多行注释
{
bool isShift = false;
for (CurWordIndex++; CurWordIndex < WordElements.Count; CurWordIndex++)
{
element.Append(WordElements[++CurWordIndex]);
if (WordElements[CurWordIndex].Char == ']') //多行注释结束
{
if (isShift)
{
return;
}
isShift = true;
}
else if (isShift)
{
isShift = false;
}
}
}
else
{
for (CurWordIndex++; CurWordIndex < WordElements.Count; CurWordIndex++)
{
if (WordElements[CurWordIndex].IsLine) //行已结束
{
--CurWordIndex; //回退
return;
}
element.Append(WordElements[++CurWordIndex]);
}
}
}
///**
// * convenience method to test that a list is not null and not empty
// *
// * @param list
// * @return
// */
//private bool notEmpty<T1>(IList<T1> list)
//{
// return list != null && list.Count > 0;
//}
/**
* extract information about acronyms from NIH record, and add to a
* simplenlg WordElement.
*
* <P>
* Acronyms are represented as lists of word elements. Any acronym will have
* a list of full form word elements, retrievable via
* {@link LexicalFeature#ACRONYM_OF}
*
* @param wordElement
* @param record
*/
private void addAcronymInfo(WordElement wordElement, LexRecord record)
{
// NB: the acronyms are actually the full forms of which the word is an
// acronym
List <string> acronyms = record.GetAcronyms();
if (acronyms.Count > 0)
{
// the list of full forms of which this word is an acronym
List <NLGElement> acronymOf = wordElement.getFeatureAsElementList(LexicalFeature.ACRONYM_OF);
// keep all acronym full forms and set them up as wordElements
foreach (string fullForm in acronyms)
{
if (fullForm.Contains("|"))
{
// get the acronym id
string acronymID = fullForm.SubstringSpecial(fullForm.IndexOf("|", StringComparison.Ordinal) + 1, fullForm.Length);
// create the full form element
WordElement fullFormWE = getWordByID(acronymID);
if (fullForm != null)
{
// add as full form of this acronym
acronymOf.Add(fullFormWE);
// List<NLGElement> fullFormAcronyms = fullFormWE
// .getFeatureAsElementList(LexicalFeature.ACRONYMS);
// fullFormAcronyms.add(wordElement);
// fullFormWE.setFeature(LexicalFeature.ACRONYMS,
// fullFormAcronyms);
}
}
}
// set all the full forms for this acronym
wordElement.setFeature(LexicalFeature.ACRONYM_OF, acronymOf);
}
// if (!acronyms.isEmpty()) {
//
// String acronym = acronyms.get(0);
// // remove anything after a |, this will be an NIH ID
// if (acronym.contains("|"))
// acronym = acronym.substring(0, acronym.indexOf("|"));
// wordElement.setFeature(LexicalFeature.ACRONYM_OF, acronym);
// }
}
private IEnumerable <BaseElement> ProcessLine(string line)
{
var songTokens = Regex.Matches(line, @"([\s/]*)([^\s/]*)");
BaseElement element = null;
foreach (Match token in songTokens)
{
int index = 0;
foreach (Group g in token.Groups)
{
if (index != 0)
{
BaseElement previousElement = element;
if (!string.IsNullOrWhiteSpace(g.Value))
{
var rawChord = ParseExact(g.Value);
if (rawChord != null)
{
var chord = new Chord(rawChord);
element = new ChordElement(chord);
}
else
{
element = new WordElement(g.Value);
}
}
else
{
element = new WhitespaceElement(g.Value);
}
element.PreviousElement = previousElement;
if (previousElement != null)
{
previousElement.NextElement = element;
}
yield return(element);
}
index++;
}
}
}
private static bool NormalQuiz(Quiz q, out WordElement[] waitList)
{
int r = lastRand, max = 2 * Math.Max(DictService.WordsCount, DictService.MeansCount);
float ratio = DictService.WordsCount * 1.0f / DictService.MeansCount;
while (r == lastRand)
r = rand.Next(max);
lastRand = r;
bool isWord = (r % 2 == 1);
r /= 2;
//get basic data
if (isWord)
{
var word = DictService.WordAt(ratio < 1.0f ? (int)(r * ratio) : r);
q.quest = word.Letters;
waitList = DictService.GetMeansByWId(word.Id);
}
else
{
var mean = DictService.MeanAt(ratio > 1.0f ? (int)(r / ratio) : r);
q.quest = mean.Meaning;
waitList = DictService.GetWordsByMId(mean.Id);
}
return isWord;
}
private static bool AdaptQuiz(Quiz q, out WordElement[] waitList)
{
int r = lastRand;
while (r == lastRand)
r = rand.Next(DictService.WrongCount);
var stat = DictService.EleAt(lastRand = r);
q.quest = stat.str;
bool isWord = true;
waitList = DictService.GetMeansByWord(stat);
if (waitList == null)
{
isWord = false;
waitList = DictService.GetWordsByMean(stat);
}
return isWord;
}
