public GrammarParser.ParaphraseOptions SubMoveToFront(GrammarParser.ParaphraseOptions options)
        {
            if ((options & GrammarParser.ParaphraseOptions.IsStayingStart) != GrammarParser.ParaphraseOptions.NoOptions)
            {
                return(options | GrammarParser.ParaphraseOptions.MoveToStart);
            }

            return(options);
        }
示例#2
0
        public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            if (IsComposed(typeof(VerbPhrase), typeof(Conjunction), typeof(VerbPhrase)))
            {
                if (RemoveImprobability(.5, ref prob))
                {
                    Phrase first  = constituents[2].Parapharse(verbs, nouns, wordnet, SubMoveToFront(options), emphasizes, ref prob);
                    Phrase and    = constituents[1].Parapharse(verbs, nouns, wordnet, SubNotMoved(options), emphasizes, ref prob);
                    Phrase second = constituents[0].Parapharse(verbs, nouns, wordnet, SubMoveOffFront(options), emphasizes, ref prob);

                    return(new PrepositionalPhrase(first, and, second));
                }
            }

            return(base.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
        }
示例#3
0
        public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            Phrase synonym = SynonymParaphrase(WordNetAccess.PartOfSpeech.Verb, verbs, nouns, wordnet, options, emphasizes, ref prob);

            if (synonym == null)
            {
                return(base.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
            }
            else
            {
                return(synonym);
            }
        }
示例#4
0
 public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double inprob)
 {
     return((Phrase)MemberwiseClone());
 }
示例#5
0
        public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            if (this is PronounPersonal)
            {
                if (word == "I")
                {
                    return(new PronounPersonal("I"));
                }
                else
                {
                    return(base.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
                }
            }

            Phrase synonym = SynonymParaphrase(WordNetAccess.PartOfSpeech.Noun, verbs, nouns, wordnet, options, emphasizes, ref prob);

            if (synonym == null)
            {
                return(base.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
            }
            else
            {
                return(synonym);
            }
        }
示例#6
0
        public Phrase SynonymParaphrase(WordNetAccess.PartOfSpeech part, Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            if (word == "not" || word == "non")
            {
                return(null);    // we don't replace these!
            }
            // Can we use a synonym?
            List <string> synonyms = wordnet.GetExactSynonyms(word, part);

            if (synonyms != null)
            {
                synonyms.Remove(word);
                synonyms.Remove(word.ToLower());
                // remove any synonyms more than twice as long, or half as long as the original
                List <string> onlygoods = new List <string>();
                foreach (string synonym in synonyms)
                {
                    if (synonym.Length <= 2 * word.Length && synonym.Length >= word.Length / 2)
                    {
                        onlygoods.Add(synonym);
                    }
                }
                synonyms = onlygoods;

                if (synonyms.Count > 0 && RemoveUnemphasizedImprobability(.75, emphasizes, this, ref prob))
                {
                    string newword = synonyms[ImprobabilityToInt(synonyms.Count, ref prob)];
                    if (IsStart(options))
                    {
                        newword = nouns.StartCap(newword);
                    }

                    POSPhrase clone = (POSPhrase)MemberwiseClone();
                    clone.word = newword;

                    return(clone);
                }
            }

            return(null);
        }
示例#7
0
        public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            POSPhrase phrase = (POSPhrase)MemberwiseClone();

            if ((options & GrammarParser.ParaphraseOptions.MoveToStart) != GrammarParser.ParaphraseOptions.NoOptions)
            {
                phrase.word = nouns.StartCap(phrase.word);
            }
            else if ((options & GrammarParser.ParaphraseOptions.MoveOffStart) != GrammarParser.ParaphraseOptions.NoOptions)
            {
                phrase.word = nouns.UnStartCap(phrase.word);
            }

            return(phrase);
        }
        public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            Paragraph paragraph = new Paragraph();

            foreach (Phrase constituent in constituents)
            {
                paragraph.constituents.Add(constituent.Parapharse(verbs, nouns, wordnet, options | GrammarParser.ParaphraseOptions.IsStayingStart, emphasizes, ref prob));
            }

            return(paragraph);
        }
 public GrammarParser.ParaphraseOptions SubNotMoved(GrammarParser.ParaphraseOptions options)
 {
     return(options & ~(GrammarParser.ParaphraseOptions.MoveToStart | GrammarParser.ParaphraseOptions.MoveOffStart));
 }
示例#10
0
 public bool IsStart(GrammarParser.ParaphraseOptions options)
 {
     return((options & GrammarParser.ParaphraseOptions.IsStayingStart) != GrammarParser.ParaphraseOptions.NoOptions ||
            (options & GrammarParser.ParaphraseOptions.MoveToStart) != GrammarParser.ParaphraseOptions.NoOptions);
 }
示例#11
0
        public virtual Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            List <Phrase> newconsts = new List <Phrase>();

            foreach (Phrase constituent in constituents)
            {
                newconsts.Add(constituent.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
                options &= ~(GrammarParser.ParaphraseOptions.MoveToStart | GrammarParser.ParaphraseOptions.MoveOffStart | GrammarParser.ParaphraseOptions.IsStayingStart);
            }

            return(new Phrase(part, newconsts));
        }
        public override Phrase Parapharse(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            // Can we change to passive voice?
            VerbPhrase verbphrase = FindConsituent <VerbPhrase>();
            NounPhrase subjphrase = FindConsituent <NounPhrase>();

            if (verbphrase != null && subjphrase != null)
            {
                Verb verb = verbphrase.FindConsituent <Verb>();
                if (verb.Word == "had" || verb.Word == "have" || verb.Word == "has")
                {
                    verb = null;    // never do passive transformations to this
                }
                if (verb != null && verbs.IsTransitive(verb.Word))
                {
                    bool isToBe = Verbs.IsToBe(verb.Word);
                    if (!isToBe && verbphrase.IsComposed(typeof(Verb), typeof(NounPhrase)))
                    {  // Like "The dog ate the bone."
                        if (RemoveEmphasizedImprobability(.75, emphasizes, subjphrase, ref prob))
                        {
                            NounPhrase objphrase     = verbphrase.FindConsituent <NounPhrase>();
                            Phrase     newobjphrase  = subjphrase.ParaphraseAsObject(verbs, nouns, wordnet, SubMoveOffFront(options), emphasizes, ref prob);
                            Phrase     newsubjphrase = objphrase.ParaphraseAsSubject(verbs, nouns, wordnet, SubMoveToFront(options), emphasizes, ref prob);

                            return(new SimpleDeclarativePhrase(newsubjphrase, new VerbPhrase(new Verb(Verbs.ComposeToBe(nouns.GetPerson(objphrase.Text), verbs.GetInflection(verb.Word))), new VerbPastParticiple(verbs.InflectVerb(verb.Word, Verbs.Convert.ext_Ven)), new PrepositionalPhrase(new Preposition("by"), newobjphrase)), new Period(" .")));
                        }
                    }
                    else if (!isToBe && verbphrase.IsComposed(typeof(Verb), typeof(NounPhrase), typeof(PrepositionalPhrase)))
                    { // Like "Joe gave a ring to Mary."
                        if (RemoveEmphasizedImprobability(.75, emphasizes, subjphrase, ref prob))
                        {
                            NounPhrase dirobjphrase    = verbphrase.FindConsituent <NounPhrase>();
                            Phrase     newsubjphrase   = dirobjphrase.ParaphraseAsSubject(verbs, nouns, wordnet, SubMoveToFront(options), emphasizes, ref prob);
                            Phrase     newdirobjphrase = subjphrase.ParaphraseAsObject(verbs, nouns, wordnet, SubMoveOffFront(options), emphasizes, ref prob);

                            PrepositionalPhrase indobjphrase = verbphrase.FindConsituent <PrepositionalPhrase>();
                            Phrase newindobjphrase           = indobjphrase.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob);

                            return(new SimpleDeclarativePhrase(newsubjphrase, new VerbPhrase(new Verb(Verbs.ComposeToBe(nouns.GetPerson(dirobjphrase.Text), verbs.GetInflection(verb.Word))), new VerbPastParticiple(verbs.InflectVerb(verb.Word, Verbs.Convert.ext_Ven)), newindobjphrase, new PrepositionalPhrase(new Preposition("by"), newdirobjphrase)), new Period(" .")));
                        }
                    }
                    else if (!isToBe && verbphrase.IsComposed(typeof(Verb), typeof(VerbPastParticiple), typeof(PrepositionalPhrase)))
                    { // Like "The bone was eaten by the dog."
                        PrepositionalPhrase byphrase = verbphrase.FindConsituent <PrepositionalPhrase>();
                        if (byphrase.IsComposed(typeof(Preposition), typeof(NounPhrase)) && byphrase.Constituents[0].Text == "by")
                        {
                            if (RemoveEmphasizedImprobability(.4, emphasizes, subjphrase, ref prob))
                            {
                                Phrase             newsubjphrase = byphrase.FindConsituent <NounPhrase>().ParaphraseAsSubject(verbs, nouns, wordnet, SubMoveToFront(options), emphasizes, ref prob);
                                Phrase             newobjphrase  = subjphrase.ParaphraseAsObject(verbs, nouns, wordnet, SubMoveOffFront(options), emphasizes, ref prob);
                                VerbPastParticiple oldverb       = verbphrase.FindConsituent <VerbPastParticiple>();
                                Verb newverb = new Verb(verbs.InflectVerb(oldverb.Word, verbs.GetInflection(verb.Word)));

                                return(new SimpleDeclarativePhrase(newsubjphrase, new VerbPhrase(newverb, newobjphrase), new Period(" .")));
                            }
                        }
                    }
                    else if (!isToBe && verbphrase.IsComposed(typeof(Verb), typeof(VerbPastParticiple), typeof(PrepositionalPhrase), typeof(PrepositionalPhrase)))
                    { // Like "A ring was given to Mary by Joe."
                        PrepositionalPhrase indobjphrase = verbphrase.FindConsituent <PrepositionalPhrase>(0);
                        PrepositionalPhrase byphrase     = verbphrase.FindConsituent <PrepositionalPhrase>(1);
                        if (byphrase.IsComposed(typeof(Preposition), typeof(NounPhrase)) && byphrase.Constituents[0].Text == "by")
                        {
                            if (RemoveEmphasizedImprobability(.4, emphasizes, subjphrase, ref prob))
                            {
                                Phrase             newsubjphrase = byphrase.FindConsituent <NounPhrase>().ParaphraseAsSubject(verbs, nouns, wordnet, SubMoveToFront(options), emphasizes, ref prob);
                                Phrase             newobjphrase  = subjphrase.ParaphraseAsObject(verbs, nouns, wordnet, SubMoveOffFront(options), emphasizes, ref prob);
                                VerbPastParticiple oldverb       = verbphrase.FindConsituent <VerbPastParticiple>();
                                Verb newverb = new Verb(verbs.InflectVerb(oldverb.Word, verbs.GetInflection(verb.Word)));

                                return(new SimpleDeclarativePhrase(newsubjphrase, new VerbPhrase(newverb, newobjphrase, indobjphrase), new Period(" .")));
                            }
                        }
                    }
                    else if (isToBe && verbphrase.IsComposed(typeof(Verb), typeof(PrepositionalPhrase)))
                    { // Like "The fly is on the wall."
                        if (RemoveEmphasizedImprobability(.6, emphasizes, subjphrase, ref prob))
                        {
                            Phrase newobjphrase  = subjphrase.ParaphraseAsObject(verbs, nouns, wordnet, SubMoveOffFront(options), emphasizes, ref prob);
                            Phrase newprepphrase = verbphrase.FindConsituent <PrepositionalPhrase>().Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob);
                            return(new SimpleDeclarativePhrase(new ExistentialThere("There"), new VerbPhrase(verb, newobjphrase, newprepphrase), new Period(" .")));
                        }
                    }
                }
            }

            ExistentialThere there = FindConsituent <ExistentialThere>();

            if (verbphrase != null && there != null)
            {
                Verb verb = verbphrase.FindConsituent <Verb>();
                if (Verbs.IsToBe(verb.Word) && verbphrase.IsComposed(typeof(Verb), typeof(NounPhrase), typeof(PrepositionalPhrase)))
                { // Like "There is a fly on the wall."
                    if (RemoveUnemphasizedImprobability(.4, emphasizes, verbphrase.Constituents[1], ref prob))
                    {
                        Phrase newsubjphrase = verbphrase.FindConsituent <NounPhrase>().ParaphraseAsSubject(verbs, nouns, wordnet, SubMoveToFront(options), emphasizes, ref prob);
                        Phrase newprepphrase = verbphrase.FindConsituent <PrepositionalPhrase>().Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob);
                        return(new SimpleDeclarativePhrase(newsubjphrase, new VerbPhrase(verb, newprepphrase), new Period(" .")));
                    }
                }
            }

            return(base.Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
        }
        public Phrase ParaphraseAsSubject(Verbs verbs, Nouns nouns, WordNetAccess wordnet, GrammarParser.ParaphraseOptions options, List <Phrase> emphasizes, ref double prob)
        {
            string asSubject = Nouns.AsSubject(Text);

            if (asSubject == Text)
            {
                return(Parapharse(verbs, nouns, wordnet, options, emphasizes, ref prob));
            }
            else
            {
                return(new NounPhrase(new Noun(asSubject)));
            }
        }