private TpPredicate GeneratePredicate()
{
bool isTransitive = random.Next(0, 100) < 50;
VerbPhrase verbPhrase = RandomVerbPhrase(isTransitive ? "vt" : "vi");
ComplexChain nominal = RandomEnPiChain();
TpPredicate p;
if (random.Next(0, 100) < 75)
{
PrepositionalPhrase[] prepositionals = null;
if (random.Next(0, 100) < 35)
{
prepositionals = RandomPrepChain();
}
ComplexChain directs = null;
if (isTransitive)
{
directs = RandomEChain();
}
p = new TpPredicate(Particles.li, verbPhrase, directs, prepositionals);
}
else
{
p = new TpPredicate(Particles.li, nominal);
}
return(p);
}
public void VerbPhraseConstructorTest()
{
IEnumerable <Word> composedWords = new Word[] { new BaseVerb("run"), new Adverb("swiftly"), new Preposition("through") };
var target = new VerbPhrase(composedWords);
Check.That(target.Words).IsEqualTo(composedWords);
}
public static IEnumerable <Stack <Token> > ReductionOptions(this IEnumerable <Token> proposedStack)
{
var stack = proposedStack.ToArray();
for (var j = 1; j <= stack.Length && j <= 4; j++)
{
var head = stack.Subarray(0, j);
var tail = stack.Subarray(j, stack.Length - j);
if (Sentence.Propose(head))
{
var possibleStack = new List <Token>();
possibleStack.Add(new Sentence(head));
possibleStack.AddRange(tail);
yield return(possibleStack.ToStack());
}
if (VerbPhrase.Propose(head))
{
var possibleStack = new List <Token>();
possibleStack.Add(new VerbPhrase(head));
possibleStack.AddRange(tail);
yield return(possibleStack.ToStack());
}
if (NounPhrase.Propose(head))
{
var possibleStack = new List <Token>();
possibleStack.Add(new NounPhrase(head));
possibleStack.AddRange(tail);
yield return(possibleStack.ToStack());
}
}
}
private static Sentence EstablishAFact(KeyValuePair <string, string> pair)
{
string[] nameParts = pair.Key.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
Word jan = Words.jan;
Word name = new Word(nameParts[1]);
Word nanpa = Words.nanpa;
Word fiveEtc = new Word(pair.Value);
ComplexChain subject = ComplexChain.SinglePiEnChainFactory(new HeadedPhrase(jan, new WordSet {
name
}));
VerbPhrase verb = new VerbPhrase(Words.jo);
ComplexChain directs = ComplexChain.SingleEPiChainFactory(new HeadedPhrase(nanpa, new WordSet {
fiveEtc
}));
TpPredicate predicate = new TpPredicate(Particles.li, verb, directs);
Sentence fact = new Sentence(subject, new PredicateList {
predicate
}, SentenceDiagnostics.NotFromParser,
new SentenceOptionalParts
{
Punctuation = new Punctuation(".")
});
return(fact);
}
/// <summary>
/// Determines if the provided <see cref="Verb"/> is similar to the provided VerbPhrase.
/// </summary>
/// <param name="first">The Verb.</param>
/// <param name="second">The VerbPhrase.</param>
/// <returns> <c>true</c> if the provided Verb is similar to the provided VerbPhrase; otherwise, <c>false</c>.</returns>
private static Similarity IsSimilarTo(this Verb first, VerbPhrase second)
{
// TODO: This is rough and needs to be enhanced.
return(Similarity.FromBoolean(second.Words
.TakeWhile(w => !(w is ToLinker)) // Collect all words in the phrase cutting short when and if an infinitive precedent is found.
.OfVerb().Any(v => v.IsSimilarTo(first)))); // If an infinitive is found, it will be the local direct object of the verb phrase.
}
public void BindObjectOfPrepositionTest()
{
var target = CreatePrepositionPhrase();
ILexical prepositionalObject = new VerbPhrase(new BaseVerb("have"));
target.BindObject(prepositionalObject);
Assert.True(target.BoundObject == prepositionalObject);
}
public void IsClassifierTest()
{
var target = new VerbPhrase(
new Adverb("certainly"),
new PastTenseVerb("is")
);
Check.That(target.IsClassifier).IsTrue();
}
public void IsPossessiveTest1()
{
var target = new VerbPhrase(
new Adverb("certainly"),
new PastTenseVerb("was")
);
Check.That(target.IsPossessive).IsFalse();
}
public void SelectTest1()
{
var expectedWord = new BaseVerb("walk");
ILexical target = new VerbPhrase(expectedWord, new Adverb("briskly"));
var result = from word in target.Match()
.Case((VerbPhrase v) => v.Words.OfVerb().First())
select word;
Assert.Equal(expectedWord, result.Single());
}
public void MatchChangingMidwayToLessDerivedResultType1()
{
ILexical target = new VerbPhrase(new BaseVerb("walk"), new Adverb("briskly"));
var result = target.Match()
.Case((VerbPhrase v) => v.Words)
.Case((IVerbal v) => new[] { v }.OfType <ILexical>())
.Result();
Check.That(result).IsNotNull().And.Contains(((Phrase)target).Words).Only().InThatOrder();
}
public void IndirectObjectOfTest()
{
var target = new NounPhrase(new ProperPluralNoun("Americans"), new Conjunction("and"), new ProperPluralNoun("Canadians"));
IVerbal expected = new VerbPhrase(new BaseVerb("gave"), new Adverb("willingly"));
IVerbal actual;
target.BindAsIndirectObjectOf(expected);
actual = target.IndirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void WhereTest1()
{
ILexical target = new VerbPhrase(new BaseVerb("walk"), new Adverb("briskly"));
var result = from word in target.Match()
.Case((VerbPhrase v) => v.Words.OfVerb().First())
where word.Text == "run" // false
select word;
Check.That(result).IsEmpty();
}
public void OnRightSideTest()
{
var target = new PrepositionalPhrase(new Preposition("for"));
ILexical expected = new VerbPhrase(new PresentParticiple("slamming"));
ILexical actual;
target.ToTheRightOf = expected;
actual = target.ToTheRightOf;
Check.That(actual).IsEqualTo(expected);
}
public void IsPossessiveTest()
{
var target = new VerbPhrase(
new Adverb("certainly"),
new PastTenseVerb("had"),
new Quantifier("many")
);
Check.That(target.IsPossessive).IsTrue();
}
public void IsClassifierTest1()
{
var target = new VerbPhrase(
new Adverb("certainly"),
new PastTenseVerb("owned"),
new Quantifier("many")
);
Check.That(target.IsClassifier).IsFalse();
}
public void AttachObjectViaPrepositionTest()
{
var target = new VerbPhrase(new BaseVerb("consume"));
IPrepositional prepositional = new Preposition("with");
ILexical prepositionalObject = new NounPhrase(new Adjective("great"), new CommonSingularNoun("haste"));
prepositional.BindObject(prepositionalObject);
target.AttachObjectViaPreposition(prepositional);
Check.That(target.ObjectOfThePreposition).IsEqualTo(prepositionalObject);
}
public void OnLeftSideTest()
{
var text = "about";
var target = new Particle(text);
ILexical expected = new VerbPhrase(new[] { new PastTenseVerb("walked") });
ILexical actual;
target.ToTheLeftOf = expected;
actual = target.ToTheLeftOf;
Check.That(actual).IsEqualTo(expected);
}
public void VerbPhraseConstructorTest1()
{
var target = new VerbPhrase(new BaseVerb("run"), new Adverb("swiftly"), new Preposition("through"));
var words = target.Words.ToList();
Check.That(words[0].Text).IsEqualTo("run");
Check.That(words[0].GetType()).IsEqualTo(typeof(BaseVerb));
Check.That(words[1].Text).IsEqualTo("swiftly");
Check.That(words[1].GetType()).IsEqualTo(typeof(Adverb));
Check.That(words[2].Text).IsEqualTo("through");
Check.That(words[2].GetType()).IsEqualTo(typeof(Preposition));
}
public void BindObjectTest()
{
var target = new ParticlePhrase(new Particle("off"), new Preposition("of"));
ILexical prepositionalObject = new NounPhrase(new Determiner("the"), new CommonSingularNoun("world"));
target.BindObject(prepositionalObject);
Check.That(target.BoundObject).IsEqualTo(prepositionalObject);
IVerbal linkedVerbal = new VerbPhrase(new PastTenseVerb("jumped"));
linkedVerbal.AttachObjectViaPreposition(target);
Check.That(linkedVerbal.ObjectOfThePreposition).IsEqualTo(prepositionalObject);
}
public void SelectManyTest7()
{
var word = new BaseVerb("walk");
var verbPhrase = new VerbPhrase(word, new Adverb("briskly"));
var expected = new { Character = 'w', Word = word, Phrase = verbPhrase };
ILexical target = new Clause(verbPhrase);
var result = from phrase in target.Match()
.Case((Clause c) => c.Phrases.OfVerbPhrase().First())
from w in phrase.Words.OfVerb()
select new { Character = w.Text.First(), word = w, Phrase = phrase };
Assert.Equal(expected.Phrase, result.First().Phrase);
}
public void IndirectObjectOfTest()
{
var target = new AggregateEntity(
new CommonSingularNoun("spoon"),
new CommonSingularNoun("fork")
);
IVerbal expected = new VerbPhrase(new PastTenseVerb("were"), new PastParticiple("eaten"));
IVerbal actual;
target.BindAsIndirectObjectOf(expected);
actual = target.IndirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void ToStringTest()
{
Phrase.VerboseOutput = false;
var target = new VerbPhrase(
new BaseVerb("run"),
new Adverb("swiftly"),
new Preposition("through")
);
var expected = "VerbPhrase \"run swiftly through\"";
string actual;
actual = target.ToString();
Check.That(actual).IsEqualTo(expected);
}
public void DirectObjectOfTest()
{
var target = new AggregateEntity(
new NounPhrase(new CommonPluralNoun("cats")),
new NounPhrase(new CommonPluralNoun("dogs"))
);
var expected = new VerbPhrase(new BaseVerb("eat"));
target.BindAsDirectObjectOf(expected);
var actual = target.DirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void AdjectivalModifierTest()
{
var target = new VerbPhrase(new PastTenseVerb("grew"));
IEntity subject = new PersonalPronoun("he");
target.BindSubject(subject);
IDescriptor expected = new Adjective("tall");
IDescriptor actual;
target.PostpositiveDescriptor = expected;
actual = target.PostpositiveDescriptor;
Check.That(actual).IsEqualTo(expected);
Check.That(subject.Descriptors).Contains(expected);
}
/// <summary>
/// Intra Verb Phrase Binding
/// </summary>
/// <param name="vp">The VerbPhrase whose elements will be bound together.</param>
public static void Bind(VerbPhrase vp)
{
var LastVerb = vp.Words.OfType <Verb>().LastOrDefault();
if (vp.Words.Count() > 1 && LastVerb != null)
{
// Adverb linking to NEXT adverb
var adverbList = vp.Words.OfAdverb();
if (adverbList.Any())
{
foreach (var advrb in adverbList)
{
//////Output.WriteLine("adverb: {0}", advrb.Text);
var tempWrd = advrb.NextWord;
while (!(tempWrd is Verb))
{
tempWrd = tempWrd.NextWord;
}
var nextVerb = tempWrd as Verb;
nextVerb.ModifyWith(advrb);
//////Output.WriteLine("Next Verb: {0}", nextVerb.Text);
}
}
// "To" binding
var toLinkerList = vp.Words.OfToLinker();
if (toLinkerList.Any())
{
foreach (var toLink in toLinkerList)
{
//////Output.WriteLine("To Linker: {0}", toLink.Text);
if (toLink.PreviousWord is Verb prev && toLink.NextWord is Verb next)
{
toLink.BindObject(next);
prev.AttachObjectViaPreposition(toLink);
if (next != LastVerb)
{
toLink.BindObject(LastVerb);
}
//////Output.WriteLine("Prev: {0}, Next: {1}: , Last Verb: {2}", prevWord, nextWord, LastVerb);
}
else
{
toLink.BindObject(LastVerb);
}
}
}
public VerbPhrase RandomVerbPhrase(string pos)
{
VerbPhrase vp;
if (random.Next(0, 100) < 25)
{
vp = new VerbPhrase(RandomEnPiChain());
}
else
{
vp = new VerbPhrase(RandomWord(pos), RandomModals(), RandomAdverbs());
}
return(vp);
}
public void ToStringTest()
{
Phrase.VerboseOutput = true;
var target = new PrepositionalPhrase(new Preposition("for"));
var left = new NounPhrase(new PersonalPronoun("it"));
var right = new VerbPhrase(new PresentParticiple("slamming"));
target.ToTheLeftOf = left;
target.ToTheRightOf = right;
var expected = $"PrepositionalPhrase \"for\"\n\tleft linked: {left.Text}\n\tright linked: {right.Text}";
var actual = target.ToString();
Check.That(actual).IsEqualTo(expected);
}
/// <summary>
/// Determines if two <see cref="VerbPhrase"/>s are similar.
/// </summary>
/// <param name="first">The first VerbPhrase</param>
/// <param name="second">The second VerbPhrase</param>
/// <returns> <c>true</c> if the given VerbPhrases are similar; otherwise, <c>false</c>.</returns>
public static Similarity IsSimilarTo(this VerbPhrase first, VerbPhrase second)
{
//Look into refining this
var results = from v1 in first.Words.OfVerb()
from v2 in second.Words.OfVerb()
select(bool) v1.IsSimilarTo(v2);
var ratio = results.PercentTrue() / 100;
return(Similarity.FromRatio(ratio));
// TODO: make this fuzzier.
//return new Similarity(leftHandVerbs.Count == rightHandVerbs.Count &&
// leftHandVerbs.Zip(rightHandVerbs, (x, y) => x.IsSynonymFor(y)).All(areSyonyms => areSyonyms)
//);
}
private static Sentence CreateQuestion()
{
Word jan = Words.seme;
Word nanpa = Words.nanpa;
Word fiveEtc = new Word("555-1234");
ComplexChain subject = ComplexChain.SinglePiEnChainFactory(new HeadedPhrase(jan));
VerbPhrase verbs = new VerbPhrase(Words.jo);
ComplexChain directs = ComplexChain.SingleEPiChainFactory(new HeadedPhrase(nanpa, new WordSet {
fiveEtc
}));
TpPredicate predicate = new TpPredicate(Particles.li, verbs, directs);
Sentence fact = new Sentence(subject, new PredicateList {
predicate
}, SentenceDiagnostics.NotFromParser);
return(fact);
}
// jan li jo e soweli e kili e wawa lon anpa tawa anpa
// li jo e soweli e kili e wawa lon anpa tawa anpa
public TpPredicate ProcessPredicates(string liPart)
{
if (String.IsNullOrWhiteSpace(liPart))
{
throw new TpParseException("Missing argument, cannot continue");
}
if (liPart == "li")
{
throw new TpParseException("Cannot do anything with just li");
}
TokenParserUtils pu = new TokenParserUtils();
Particle verbPhraseParticle;
ComplexChain directObjectChain = null;
VerbPhrase verbPhrase = null;
PrepositionalPhrase[] prepositionalChain = null;
ComplexChain nominalPredicate = null;
PiPredicate piPredicate = null;
//Transitive Path.
if (liPart.Split(new[] { ' ', '\t' }).Contains("e"))
{
string[] eParts = Splitters.SplitOnE(liPart);
string[] verbPhraseParts = pu.WordsPunctuationAndCompounds(eParts[0]); //Could contain particles.
if (!Token.CheckIsParticle(verbPhraseParts[0]))
{
throw new TpSyntaxException("uh-oh not a particle: " + verbPhraseParts[0] + " from " + liPart);
}
verbPhraseParticle = new Particle(verbPhraseParts[0]);
//Only process preps in normalized sentences
string[] partsWithPreps = null;
if (verbPhraseParts.Length > 1)
{
if (verbPhraseParts.Any(x => x == "pi"))
{
//nominal predicate
nominalPredicate =
new ComplexChain(Particles.en,
new[] {
ProcessPiChain(String.Join(" ", ArrayExtensions.Tail(verbPhraseParts)))
});
}
else
{
verbPhrase = VerbPhraseParser(ArrayExtensions.Tail(verbPhraseParts));
}
}
string verbsMaybePrepositions = eParts[eParts.Length - 1];
if (verbsMaybePrepositions.ContainsCheck("~"))
{
partsWithPreps = Splitters.SplitOnPrepositions(verbsMaybePrepositions);
if (partsWithPreps.Length == 1)
{
//This is the last e phrase or 1st prep.
if (partsWithPreps[0].ContainsCheck("~"))
{
//That is a prep phrase (is this possible?)
}
else
{
eParts[eParts.Length - 1] = partsWithPreps[0];
//No prep phrases.
}
}
}
string[] directObjects = ArrayExtensions.Tail(eParts);
//List<HeadedPhrase> doNPs = new List<HeadedPhrase>();
List <Chain> doPiChains = new List <Chain>();
//Fancy foot work for when we have e ... ~... & that's all.
string[] toUse;
if (partsWithPreps != null)
{
toUse = partsWithPreps.Where(x => x.StartCheck("e ")).ToArray();
directObjects[directObjects.Length - 1] = toUse[0];
toUse = directObjects;
}
else
{
toUse = directObjects;
}
foreach (string directObject in toUse)
{
if (directObject.Length <= 2)
{
throw new TpParseException("This is a degenerate e phrase, i.e. it is only e or e space. Missing a ni, e.g. e ni: possibly. ref: " + liPart);
}
string eFree = directObject.Substring(2);
Chain phrase = ProcessPiChain(eFree);
doPiChains.Add(phrase);
}
directObjectChain = new ComplexChain(Particles.e, doPiChains.ToArray());
if (partsWithPreps != null)
{
prepositionalChain = ProcessPrepositionalPhrases(partsWithPreps).ToArray();
}
}
else
{
//Intransitives & Predictates
string[] ppParts = Splitters.SplitOnPrepositions(liPart);
if (ppParts.Length == 0) //Excect at least "li verb" or "li noun"
{
throw new TpParseException("Whoa, got " + ppParts.Length + " parts for " + liPart);
}
if (Punctuation.ContainsPunctuation(ppParts[0]))
{
throw new TpParseException("This has punctuation, may fail to parse : " + ppParts[0]);
}
string[] verbPhraseParts = pu.WordsPunctuationAndCompounds(ppParts[0]);
if (!Token.CheckIsParticle(verbPhraseParts[0]))
{
throw new TpSyntaxException("uh-oh not a particle: " + verbPhraseParts[0] + " from " + liPart);
}
verbPhraseParticle = new Particle(verbPhraseParts[0]);
if (verbPhraseParts.Length > 1)
{
//0:li 1:xxx 2:np...
if (verbPhraseParts[1].ContainsCheck("XXXXZiXXXX"))
{
//Make it go away. Confuses other parsers and will be picked up by container object.
verbPhraseParts = ArrayExtensions.Tail(verbPhraseParts);
//piPredicate
ComplexChain phrase = new ComplexChain(Particles.en,
new[] {
ProcessPiChain(String.Join(" ", ArrayExtensions.Tail(verbPhraseParts)))
});
piPredicate = new PiPredicate(Particles.pi, phrase);
}
else if (verbPhraseParts.Any(x => x == "pi"))
{
//nominal predicate
nominalPredicate = new ComplexChain(Particles.en,
new[] {
ProcessPiChain(String.Join(" ", ArrayExtensions.Tail(verbPhraseParts)))
}
);
}
else
{
verbPhrase = VerbPhraseParser(ArrayExtensions.Tail(verbPhraseParts));
}
}
string[] prepositions = ArrayExtensions.Tail(ppParts);
if (prepositions.Length != 0)
{
List <PrepositionalPhrase> pChains = new List <PrepositionalPhrase>();
foreach (string pp in prepositions)
{
string[] phraseParts = pu.WordsPunctuationAndCompounds(pp);//Could contain particles.
string preposition = phraseParts[0];
string[] tail = ArrayExtensions.Tail(phraseParts);
if (tail.Length == 0)
{
//uh oh. This is an intransitive verb, like "ni li lon"
//HACK: Oh, this is so ugly (still sort of ugly)
verbPhrase = new VerbPhrase(new Word(preposition.Replace("~", "")));
//or a noun phrase.
continue;
}
PrepositionalPhrase foundPrepositionalPhrase = new PrepositionalPhrase(new Word(preposition), ProcessEnPiChain(String.Join(" ", tail)));
pChains.Add(foundPrepositionalPhrase);
}
if (pChains.Count > 0)
{
prepositionalChain = pChains.ToArray();
}
else
{
//We changed our mind about a phrase being a prep phrase. Turned out to be verb phrase or predicate.
}
}
}
if (piPredicate != null)
{
return(new TpPredicate(verbPhraseParticle, piPredicate, prepositionalChain));
}
if (nominalPredicate == null)
{
return(new TpPredicate(verbPhraseParticle, verbPhrase, directObjectChain, prepositionalChain));
}
return(new TpPredicate(verbPhraseParticle, nominalPredicate, directObjectChain, prepositionalChain));
}
