public static ProbableStrength Max(ProbableStrength one, ProbableStrength two)
{
if (one.strength * one.weight > two.strength * two.weight)
return one;
else
return two;
}
// Guess whether or not a phrase is plural
public static ProbableStrength SeemsPlural(InformedPhrase phrase)
{
ProbableStrength result = new ProbableStrength(0, 0);
double strengthFactor = result.ImproveStrengthStart();
// Noun count is well determined by ending in s
ProbableStrength nounness = PartOSAttribute.SeemsA(phrase, SpeechPart.Noun);
ProbableStrength nisplural;
if (phrase.Name.ToLower().EndsWith("s"))
nisplural = new ProbableStrength(1.0, 0.8);
else
nisplural = new ProbableStrength(0.0, 0.5);
result.ImproveStrength(nounness.Relative(nisplural), ref strengthFactor);
// Verbs that end in s are probably not plural
ProbableStrength verbness = PartOSAttribute.SeemsA(phrase, SpeechPart.Verb);
if (phrase.Name.ToLower().EndsWith("s"))
{
ProbableStrength visplural = new ProbableStrength(0.0, 0.8);
result.ImproveStrength(verbness.Relative(visplural), ref strengthFactor);
}
result.ImproveStrengthFinish(strengthFactor);
return result;
}
public ProbableStrength Relative(ProbableStrength other)
{
double newstrength = other.strength * strength; // <- use instead of RelativeStrength(other.strength, strength), because only used for strength [0, 1]
double newweight = RelativeWeight(other.weight, weight);
return(new ProbableStrength(newstrength, newweight));
}
public ProbableStrength Better(ProbableStrength other)
{
if (strength * weight < other.strength * other.weight)
return other;
return this;
}
public ProbableStrength Combine(ProbableStrength other)
{
double newstrength = (strength * weight + other.strength * other.weight) / (weight + other.weight);
double newweight = weight + other.weight - weight * other.weight;
return(new ProbableStrength(newstrength, newweight));
}
public virtual ProbableStrength Describes(PhraseSense sense)
{
ProbableStrength total = new ProbableStrength(0, 0);
double strengthFactor = total.ImproveStrengthStart();
foreach (PhraseAttribute attribute in sense.Attributes)
total.ImproveStrength(Match(attribute), ref strengthFactor);
if (strengthFactor == 0)
{
// do we match subphrases then?
foreach (InformedPhrase subphrase in sense.Phrases)
total.ImproveStrength(Describes(subphrase).DownWeight(1.0 / sense.Phrases.Count), ref strengthFactor);
}
if (strengthFactor == 0)
{
// We never found an appropriate attribute-- so guess!
List<KeyValuePair<PhraseSense, double>> senses = new List<KeyValuePair<PhraseSense, double>>();
senses.Add(new KeyValuePair<PhraseSense,double>(sense, 1.0));
InformedPhrase dummy = new InformedPhrase(sense.Name(), senses);
ProbableStrength result = Match(Guess(dummy));
total.ImproveStrength(result, ref strengthFactor);
}
total.ImproveStrengthFinish(strengthFactor);
return total;
}
public static ProbableStrength SeemsReferee(InformedPhrase phrase, IWordLookup informer, ProbableStrength anaphora)
{
List<string> words = phrase.Generate();
double weight = 0;
foreach (string word in words)
weight += informer.GetWeight(word, false);
/* words weight result
* 1 0 0
* 1 1 1
* 2 0 0
* 2 .5 .4
* 2 1 2/3
* 2 1.5 .86
* 2 2 1
* 3 .5 .3
* 3 1 .5
* 3 2 .8
*/
double myweight = 2.0 * weight / (words.Count + weight);
if (words.Count == 1)
myweight /= 2.0; // down-score 1-word answers
if (words.Count > 2)
myweight /= Math.Log(words.Count);
ProbableStrength notanaphora = anaphora.InverseProbability();
return new ProbableStrength(Math.Sqrt(myweight * notanaphora.strength), notanaphora.weight + .5 - notanaphora.weight * .5);
}
// Does this appear to be a reference for something?
// Checks the part of our senses, and our sub-parts
public static ProbableStrength SeemsAnaphora(InformedPhrase phrase)
{
ProbableStrength total = new ProbableStrength(0, 0);
double strengthFactor = total.ImproveStrengthStart();
foreach (KeyValuePair<PhraseSense, double> sense in phrase.Senses)
{
if (sense.Key.Phrases.Count == 1)
total.ImproveStrength(SeemsAnaphora(sense.Key.Phrases[0]), ref strengthFactor);
else
{
ProbableStrength singletotal = sense.Key.SpeechPart().SeemsAnaphora().DownWeight(1.0 / (sense.Key.Phrases.Count + 1));
// Combine together results from subphrases
ProbableStrength phrasetotal = new ProbableStrength(0, 0);
double phraseFactor = phrasetotal.ImproveStrengthStart();
foreach (InformedPhrase subphrase in sense.Key.Phrases)
phrasetotal.ImproveStrength(SeemsAnaphora(subphrase).DownWeight(1.0 / sense.Key.Phrases.Count), ref phraseFactor);
phrasetotal.ImproveStrengthFinish(phraseFactor);
// Use both our and the recursive result
total.ImproveStrength(singletotal.Combine(phrasetotal), ref strengthFactor);
}
}
total.ImproveStrengthFinish(strengthFactor);
return total;
}
public ProbableStrength Better(ProbableStrength other)
{
if (strength * weight < other.strength * other.weight)
{
return(other);
}
return(this);
}
public static ProbableStrength Max(ProbableStrength one, ProbableStrength two)
{
if (one.strength * one.weight > two.strength * two.weight)
{
return(one);
}
else
{
return(two);
}
}
public ProbableStrength Improve(ProbableStrength other)
{
if (other.strength > strength)
{
double newstrength = strength + (other.strength - strength) * other.weight / (weight + other.weight);
double newweight = (weight + other.weight) / 2;
return(new ProbableStrength(newstrength, newweight));
}
else
{
return(this);
}
}
// Could this be an anaphora for the given phrase? Check the attributes
public static ProbableStrength AnaphoraOf(InformedPhrase anaphora, PhraseSense prime)
{
if (anaphora.IsContained(prime) || prime.IsContained(anaphora))
return ProbableStrength.Zero; // can't refer to included structure
ProbableStrength total = new ProbableStrength(0, 0);
double strengthFactor = total.ImproveStrengthStart();
foreach (KeyValuePair<PhraseSense, double> sense in anaphora.Senses)
{
ProbableStrength match = AnaphoraOf(sense.Key, prime);
total.ImproveStrength(match.DownWeight(sense.Value), ref strengthFactor);
}
total.ImproveStrengthFinish(strengthFactor);
return total;
}
public static ProbableStrength AnaphoraOf(PhraseSense anaphora, PhraseSense prime)
{
ProbableStrength total = new ProbableStrength(0, 0);
double strengthFactor = total.ImproveStrengthStart();
// Check if each attribute could describe the phrase
foreach (PhraseAttribute attribute in anaphora.Attributes)
{
if (attribute is PartOSAttribute)
continue; // ignore
total.ImproveStrength(attribute.Describes(prime), ref strengthFactor);
}
// Check if subphrases could be anaphors for the given phrase
foreach (InformedPhrase subphrase in anaphora.Phrases)
total.ImproveStrength(AnaphoraOf(subphrase, prime).DownWeight(1.0 / anaphora.Phrases.Count), ref strengthFactor);
total.ImproveStrengthFinish(strengthFactor);
return total;
}
public void ImproveStrength(ProbableStrength addStrength, ref double strengthFactor)
{
ImproveStrength(addStrength.strength, addStrength.weight, ref strengthFactor);
}
public ProbableStrength Relative(ProbableStrength other)
{
double newstrength = other.strength * strength; // <- use instead of RelativeStrength(other.strength, strength), because only used for strength [0, 1]
double newweight = RelativeWeight(other.weight, weight);
return new ProbableStrength(newstrength, newweight);
}
public ProbableStrength Improve(ProbableStrength other)
{
if (other.strength > strength) {
double newstrength = strength + (other.strength - strength) * other.weight / (weight + other.weight);
double newweight = (weight + other.weight) / 2;
return new ProbableStrength(newstrength, newweight);
} else
return this;
}
// Does this attribute describe the word? Consider overriding this
public ProbableStrength Describes(InformedPhrase word)
{
ProbableStrength total = new ProbableStrength(0, 0);
double strengthFactor = total.ImproveStrengthStart();
foreach (KeyValuePair<PhraseSense, double> sense in word.Senses)
total.ImproveStrength(Describes(sense.Key).DownWeight(sense.Value), ref strengthFactor);
if (strengthFactor == 0)
{
// We never found an appropriate attribute-- so guess!
ProbableStrength result = Match(Guess(word));
total.ImproveStrength(result, ref strengthFactor);
}
total.ImproveStrengthFinish(strengthFactor);
return total;
}
public void ImproveStrength(ProbableStrength addStrength, ref double strengthFactor)
{
ImproveStrength(addStrength.strength, addStrength.weight, ref strengthFactor);
}
// Base constructor: just stores "how strong" the attribute is
public PhraseAttribute(double strength, double weight)
{
this.strength = new ProbableStrength(strength, weight);
}
public void Deserialize(SerializationReader reader)
{
strength = (ProbableStrength) reader.ReadPointer();
}
public ProbableStrength Combine(ProbableStrength other)
{
double newstrength = (strength * weight + other.strength * other.weight) / (weight + other.weight);
double newweight = weight + other.weight - weight * other.weight;
return new ProbableStrength(newstrength, newweight);
}
public static ProbableStrength SeemsReferencePhrase(InformedPhrase phrase, bool not)
{
ProbableStrength total = new ProbableStrength(0, 0);
double strengthFactor = total.ImproveStrengthStart();
foreach (KeyValuePair<PhraseSense, double> sense in phrase.Senses)
{
if (sense.Key.Phrases.Count == 1)
total.ImproveStrength(SeemsReferencialVerb(sense.Key.Phrases[0]), ref strengthFactor);
else
{
// Is this a "helper" verb followed by an anaphora?
ProbableStrength foundHelper = ProbableStrength.None, foundBoth = ProbableStrength.None;
foreach (InformedPhrase subphr in sense.Key.Phrases)
{
if (!not)
{
foundHelper = foundHelper.Better(SeemsReferencialVerb(subphr));
foundBoth = foundBoth.Better(foundHelper.Relative(SeemsAnaphora(subphr)));
}
else
{
foundHelper = foundHelper.Better(SeemsReferencialVerb(subphr).InverseProbability());
foundBoth = foundBoth.Better(foundHelper.Relative(SeemsAnaphora(subphr).InverseProbability()));
}
}
foundBoth.weight = foundBoth.weight + .5 - foundBoth.weight * .5;
// Use both our and the recursive result
total.ImproveStrength(foundBoth, ref strengthFactor);
}
}
total.ImproveStrengthFinish(strengthFactor);
return total;
}