public void Chain_WithRestrictiveMaximumOrder_DoesntAlwaysQuoteCorpus()
        {
            var chainWithBackoff = new MarkovChainWithBackoff <char>(5, 2);

            chainWithBackoff.Add("fool");
            var deterministicRand = new Random(0);
            var resultWithBackoff = string.Join("", chainWithBackoff.Chain(deterministicRand));

            Assert.Equal("fol", resultWithBackoff);
        }
        public void Add_WhenEmpty_AddsTheValuesToTheState(string sample, int maximumOrder, string serialized)
        {
            var chain = new MarkovChainWithBackoff <char>(maximumOrder, 2);

            chain.Add(sample);

            var result = Serialize(chain);

            Assert.Equal(serialized, result);
        }
示例#3
0
        static MarkovChainWithBackoff <string> GetChainWithBackoff(int maxOrder, int desiredNumNextStates)
        {
            MarkovChainWithBackoff <string> chain = new MarkovChainWithBackoff <string>(maxOrder, desiredNumNextStates);

            foreach (string sourceQuote in GetQuotes())
            {
                string[] words = sourceQuote.Split(' ');
                chain.Add(words);
            }

            return(chain);
        }
        public void GetNextStates_WithoutRestrictiveDesiredNextStatesValue_DoesntBackOff()
        {
            var chainWithBackoff = new MarkovChainWithBackoff <char>(5, 1);

            chainWithBackoff.Add("fool");

            var nextStates = chainWithBackoff.GetNextStates("foo");

            Assert.Equal(nextStates, new Dictionary <char, int> {
                { 'l', 1 }
            });
        }
        public void Add_WithOppositeWeight_ResetsInternalsToInitialState(string word, int maximumOrder)
        {
            var chain = new MarkovChainWithBackoff <char>(maximumOrder, 2);

            chain.Add(word, 1);

            chain.Add(word, -1);

            var result = Serialize(chain);

            Assert.Equal(EmptySample, result);
        }
        public void GetNextStates_WithOverRestrictiveDesiredNextStatesValue_PicksBestPossibleOrder()
        {
            var chainWithBackoff = new MarkovChainWithBackoff <char>(5, 3);

            chainWithBackoff.Add("fool");

            var nextStates = chainWithBackoff.GetNextStates("foo");

            Assert.Equal(nextStates, new Dictionary <char, int> {
                { 'o', 1 }, { 'l', 1 }
            });
        }
示例#7
0
        static string GenerateQuoteWithBackoff()
        {
            Random rand = new Random();

            // Order 3 is the highest order that actually makes a meaningful difference.
            // Targeting 2 next states seems like it hits a balance of high and low orders.
            MarkovChainWithBackoff <string> chain = GetChainWithBackoff(3, 2);

            IEnumerable <string> result = chain.Chain(rand);
            string generatedQuote       = string.Join(" ", result);

            return(TruncateQuote(generatedQuote));
        }