public SamplingWithReplacement(CompositionCategory cat, PatchNames instrument)
{
this.MaxIterations = 200;
this.MaxLength = 100;
this.instrument = instrument;
this.category = cat;
random = new SimpleRNG();
random.SetSeedFromSystemTime();
model = new MarkovChain<Note>(1);
foreach(var comp in cat.Compositions)
{
foreach(var track in comp.Tracks)
{
if (!IsValidTrack(track))
continue;
var mel = (track.GetMainSequence() as MelodySequence).Clone() as MelodySequence;
mel.StandardizeDuration();
model.Add(mel.ToArray());
break;//only first track
}
}
CalculateStats();
}
/// <summary>
/// Evaluates a list of genomes. Here we decode each genome in using the contained IGenomeDecoder
/// and evaluate the resulting TPhenome using the contained IPhenomeEvaluator.
/// </summary>
public void EvaluateNeat(IList <NeatGenome> genomeList)
{
//Console.WriteLine("Number of genomes right before EvaluateNeat: " + genomeList.Count);
Parallel.ForEach(genomeList, delegate(NeatGenome genome)
{
MarkovChain phenome = _genomeDecoder.Decode(genome);
if (null == phenome)
{
genome.EvaluationInfo.SetFitness(0.0);
genome.EvaluationInfo.AlternativeFitness = 0.0;
}
if (null == phenome)
{ // Non-viable genome.
genome.EvaluationInfo.SetFitness(0.0);
genome.EvaluationInfo.AlternativeFitness = 0.0;
}
else
{
FitnessInfo fitnessInfo = _passwordCrackingEvaluator.Evaluate(phenome);
genome.EvaluationInfo.SetFitness(fitnessInfo._fitness);
genome.EvaluationInfo.AlternativeFitness = fitnessInfo._alternativeFitness;
}
});
foreach (string p in _passwordCrackingEvaluator.FoundPasswords)
{
//PasswordCrackingEvaluator.Passwords.Remove(p);
double val = PasswordCrackingEvaluator.Passwords[p].Reward;
PasswordCrackingEvaluator.Passwords[p].Reward = val * 0.75;
}
}
public MarkoVerse(bool country)
{
MarkovChain <string> chain = new MarkovChain <string>(2);
List <string> allBars = new List <string> {
};
foreach (Song song in Song.GetAll())
{
string withoutBracketedText = Regex.Replace(song.Lyrics, @"\[.*?\]", "");
string withoutPunctuation = Regex.Replace(withoutBracketedText, @"[^a-zA-Z' \-.\r\n]", " ");
string nWordRemoved = Regex.Replace(withoutPunctuation, "(N|n)igg", "fell");
string sWordRemoved = Regex.Replace(nWordRemoved, "(S|s)hit", "toot");
string fWordRemoved = Regex.Replace(sWordRemoved, "(F|f)uck", "hoot");
string pWordRemoved = Regex.Replace(fWordRemoved, "(P|p)ussy", "truck");
string dWordRemoved = Regex.Replace(pWordRemoved, "(D|d)ick", "dog");
string bWordPluralsRemoved = Regex.Replace(dWordRemoved, "(B|b)itches", "hussies");
string bWordRemoved = Regex.Replace(bWordPluralsRemoved, "(B|b)itch", "hussy");
string girlGal = Regex.Replace(bWordRemoved, "(G|g)irl", "gal");
string youYall = Regex.Replace(girlGal, "(Y|y)ou ", "y'all ");
string goneDone = Regex.Replace(youYall, "(G|g)one", "done gone");
string ingIn = Regex.Replace(goneDone, "ing ", "in' ");
string fixIm = Regex.Replace(ingIn, "(I|i) m", "I'm");
string fixCant = Regex.Replace(fixIm, "n t ", "n't ");
string noMun = Regex.Replace(fixCant, "(M|m)un", "YEEHAW");
string[] lyricSplit = noMun.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lyricSplit)
{
allBars.Add(line);
chain.Add(line.Split(new string[] { " ", "—" }, StringSplitOptions.RemoveEmptyEntries), 1);
}
}
AllBars = allBars;
Corpus = chain;
}
private static void Main( )
{
// Initialize the command manager
commandManager = new CommandManager( );
commandManager.LoadCommands <Program> (null);
commandManager.AddHelpCommand( );
// Timer to save me from myself :v
timer.Elapsed += Timer_Elapsed;
timer.Start( );
chain = new MarkovChain( );
while (true)
{
Console.Write("markov> ");
var line = Console.ReadLine( );
try
{
using (new StackingArea($"executing: {line}"))
commandManager.Execute(line);
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e.Message);
Console.ResetColor( );
}
}
}
private void FeeDText(MarkovChain model)
{
StringBuilder Feeder = new StringBuilder();
string line;
using (StreamReader reader = new StreamReader(Server.MapPath(Url.Content("~/Content/TextFiles/BenFranklin.txt"))))
{
while ((line = reader.ReadLine()) != null)
{
var l = line.Trim();
if (l.Length > 3)
{
Feeder.AppendLine(l);
}
else if (Feeder.Length > 0)
{
model.AddString(Feeder.ToString());
Feeder.Length = 0;
}
}
if (Feeder.Length > 0)
{
model.AddString(Feeder.ToString());
}
}
}
static void Main(string[] args)
{
var docs = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var dir = new DirectoryInfo(docs);
var chain = new MarkovChain <string>(3);
var nameChain = new MarkovChain <char>(3);
foreach (var file in dir.EnumerateFiles())
{
chain.Add(File.ReadAllText(file.FullName).Split(' '));
nameChain.Add(file.Name);
}
var rand = new Random();
Directory.CreateDirectory(docs + "\\ImportantFiles");
for (int i = 0; i < 10; i++)
{
var filePath = (docs + "\\ImportantFiles\\" + new String(nameChain.Chain(rand).ToArray()));
Console.WriteLine(filePath);
using (FileStream fs = File.Create(filePath))
{
Byte[] info = new UTF8Encoding(true).GetBytes(chain.Chain(rand).Aggregate((a, b) => a + " " + b));
// Add some information to the file.
fs.Write(info, 0, info.Length);
}
}
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
async Task <MarkovChain <string> > GenerateChainFromChannels(IEnumerable <IMessageChannel> channels, int messagesFromEach)
{
var chain = new MarkovChain <string>(1);
int totalUsed = 0;
foreach (var channel in channels)
{
Console.WriteLine($"Loading {messagesFromEach} messages from #{channel.Name}");
int channelWeight = 2019 - channel.CreatedAt.Year;
var messages =
(await channel.GetMessagesAsync(messagesFromEach).FlattenAsync())
.Where(m => string.IsNullOrWhiteSpace(m.Content) == false);
int used = 0;
foreach (var msg in messages)
{
var parts = msg.Content
.Split(' ')
.Where(d => !d.Contains('<'));
chain.Add(parts, channelWeight);
used++;
}
Console.WriteLine($"Added {used} messages from #{channel.Name} to the corpus, at weight {channelWeight}");
totalUsed += used;
}
Console.WriteLine($"Done loading corpus. Total corpus size: {totalUsed} messages.");
return(chain);
}
private List <MarkovChain> GetMarkovChains()
{
var sessionObject = System.Web.HttpContext.Current.Application["MarkovChain"];
if (sessionObject is List <MarkovChain> )
{
return(sessionObject as List <MarkovChain>);
}
var allDishes = _repository.GetAllDishes();
var markovChains = new List <MarkovChain>();
foreach (var dishesGroupedByRestaurant in allDishes.GroupBy(d => d.RestaurantId).OrderBy(g => g.Key))
{
var dishes = dishesGroupedByRestaurant.Select(d => d.Description);
var markov = new MarkovChain();
dishes.ForEach(txt =>
{
markov.AddMultipleWords(txt);
markov.AddWord(".");
});
markovChains.Add(markov);
}
System.Web.HttpContext.Current.Application.Lock();
System.Web.HttpContext.Current.Application["MarkovChain"] = markovChains;
System.Web.HttpContext.Current.Application.UnLock();
return(markovChains);
}
static string GenerateQuote()
{
Random rand = new Random();
int order = 1;
if (rand.NextDouble() > 0.5)
{
// Add a small chance of a higher order chain. The higher order chains
// produce output that is a lot closer to the source text. Too close
// to have on all the time.
order = 2;
}
Console.WriteLine("order " + order);
MarkovChain <string> chain = GetChain(order);
string generatedQuote = string.Join(" ", chain.Chain(rand));
if (generatedQuote.Length > 280)
{
return(GenerateQuote());
}
else
{
return(generatedQuote);
}
}
/// <summary>
/// Returns a single name with no regard for how many times that name may have been generated before.
/// </summary>
/// <returns>A single Markov-generated name</returns>
public string GenerateWord(int wordLength = 0)
{
string nextName = GetRandomKey();
// get a random name from the input samples
// then generate a word length to aim at
int minLength = tokenLength + nextName.Length;
int nameLength = wordLength;
if (wordLength <= 0)
{
wordLength = RandomNumber.Next(minLength + tokenLength, GetRandomSampleWord().Length + minLength);
nameLength = RandomNumber.Next(minLength, wordLength);
}
// generate the next name: a random substring of the random sample name
// then get a random next letter based on the previous ngram
while (nextName.Length < nameLength)
{
string token = nextName.Substring(nextName.Length - tokenLength, tokenLength);
if (MarkovChain.ContainsKey(token))
{
nextName += NextLetter(token);
}
else
{
break;
}
}
nextName = textInfo.ToTitleCase(nextName.ToLower());
return(nextName);
}
public async Task TalkAsync([Summary("The user to make talk")] string user)
{
var messages = _messageRepository
.Where(x => x.User.ToLower() == user.ToLower())
.ToArray();
if (messages.Length < 25)
{
await ReplyAsync($"{user} hasn't said enough to make them talk yet");
return;
}
var chain = new MarkovChain <string>(1);
foreach (var message in messages)
{
var split = message.Content.Split(' ');
if (split.Length >= 5)
{
chain.Add(split);
}
}
await ReplyAsync(string.Join(" ", chain.Chain()));
}
public MarkoVerse()
{
MarkovChain <string> chain = new MarkovChain <string>(2);
List <string> allBars = new List <string> {
};
foreach (Song song in Song.GetAll())
{
string withoutBracketedText = Regex.Replace(song.Lyrics, @"\[.*?\]", "");
string withoutPunctuation = Regex.Replace(withoutBracketedText, @"[^a-zA-Z' \-.\r\n]", " ");
string nWordRemoved = Regex.Replace(withoutPunctuation, "(N|n)igg", "n*gg");
string sWordRemoved = Regex.Replace(nWordRemoved, "(S|s)hit", "sh*t");
string fWordRemoved = Regex.Replace(sWordRemoved, "(F|f)uck", "f*ck");
string pWordRemoved = Regex.Replace(fWordRemoved, "(P|p)uss", "p*ss");
string dWordRemoved = Regex.Replace(pWordRemoved, "(D|d)ick", "d*ck");
string bWordRemoved = Regex.Replace(dWordRemoved, "(B|b)itch", "b*tch");
string fixIm = Regex.Replace(bWordRemoved, "(I|i) m", "I'm");
string fixCant = Regex.Replace(fixIm, "n t ", "n't ");
string[] lyricSplit = fixCant.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lyricSplit)
{
allBars.Add(line);
chain.Add(line.Split(new string[] { " ", "—" }, StringSplitOptions.RemoveEmptyEntries), 1);
}
}
AllBars = allBars;
Corpus = chain;
}
public static MarkovChain<AutomatonNode> GetExampleFig101()
{
var p1 = new Proposition ("start");
var p2 = new Proposition ("try");
var p3 = new Proposition ("lost");
var p4 = new Proposition ("delivered");
var np1 = new Negation (p1);
var np2 = new Negation (p2);
var np3 = new Negation (p3);
var np4 = new Negation (p4);
var mc = new MarkovChain<AutomatonNode> (new AutomatonNodeFactory ());
var start = mc.AddNode ("start", new ILiteral[] { p1, np2, np3, np4 });
var ntry = mc.AddNode ("try", new ILiteral[] { np1, p2, np3, np4 });
var lost = mc.AddNode ("lost", new ILiteral[] { np1, p2, p3, np4 });
var delivered = mc.AddNode ("delivered", new ILiteral[] { np1, np2, np3, p4 });
mc.SetInitial (start, 1);
mc.AddTransition (start, ntry);
mc.AddTransition (ntry, .1d, lost);
mc.AddTransition (lost, ntry);
mc.AddTransition (ntry, .9d, delivered);
mc.AddTransition (delivered, start);
return mc;
}
private void button1_Click(object sender, EventArgs e)
{
dataGridView1.Rows.Clear();
MarkovChain chain = new MarkovChain();
Generator generator = new Generator(Convert.ToDouble(txtBoxP.Text), true, chain.Listener);
HandlerNode handlerNode1 = new HandlerNode(Convert.ToDouble(txtBoxPI1.Text), true, chain.Listener);
QueueNode queue = new QueueNode(false, 2, chain.Listener);
HandlerNode handlerNode2 = new HandlerNode(Convert.ToDouble(txtBoxPI2.Text), false, chain.Listener);
chain.IntializeChain(generator, handlerNode1, queue, handlerNode2);
chain.TiksCount = Convert.ToInt32(txtBoxTiksCount.Text);
chain.Work();
txtBoxDenyvalue.Text = chain.Statistics.DenyChanceValue.ToString();
txtBoxAvgQueueLen.Text = chain.Statistics.AverageQueueLength.ToString();
txtBoxAverageReqCountInQueue.Text = chain.Statistics.AvgRequestsCountInSystem.ToString();
txtBoxQ.Text = chain.Statistics.RelativePassAbility.ToString();
txtBoxA.Text = chain.Statistics.AbsolutePassAbility.ToString();
txtBoxAvgReqTimeInQueue.Text = chain.Statistics.AvgTimeRequestInQueue.ToString();
txtBoxAvgReqTimeInSystem.Text = chain.Statistics.AvgTimeRequestInSystem.ToString();
txtBoxLoadCoef1.Text = chain.Statistics.CanalLoadCoef[1].ToString();
txtBoxLoadCoef2.Text = chain.Statistics.CanalLoadCoef[0].ToString();
int i = 0;
foreach (var item in chain.Statistics.StatesFrequency)
{
dataGridView1.Rows.Add("P" + item.Key, chain.Statistics.StatesChances[i]);
i++;
}
}
public ActionResult UpdateRoBenFranklin()
{
List <string> model = new List <string>();
MarkovChain chain = new MarkovChain(100);
FeeDText(chain);
var service = new TwitterService("K47rQlImnCUoRFTnVtB2yJfaN", "5Wv4cjWfRsWZO5LuWLxldCh0AU8GBYQVAyfODnhzhkGEp5r1BG");
service.AuthenticateWith("722475012255563776-Ukvwm59B9U94AGo014K0TJA2h5zUWot", "v1qWB8Bs9KPZHyQccHozpsGb85wHrRGYW76lJEsdCd6Y9");
for (int i = 0; i < 15; i++)
{
string generate = chain.ToString(25);
while (generate.Length < 140)
{
generate += " " + chain.ToString(25);
}
string msg = generate.Substring(0, 140);
var tweet = new SendTweetOptions {
Status = msg
};
service.SendTweet(tweet);
model.Add(msg);
}
return(View(model));
}
public static MarkovChain BuildCrapsGame()
{
var sm = new MarkovChain ();
var start = sm.Add (new State ("start", true));
var won = sm.Add (new State ("won"));
var lost = sm.Add (new State ("lost"));
var s4 = sm.Add (new State ("4"));
var s10 = sm.Add (new State ("10"));
var s5 = sm.Add (new State ("5"));
var s9 = sm.Add (new State ("9"));
var s6 = sm.Add (new State ("6"));
var s8 = sm.Add (new State ("8"));
won.ValidPropositions.Add (new Proposition ("b"));
start.ValidPropositions.Add (new Proposition ("c"));
s4.ValidPropositions.Add (new Proposition ("c"));
s5.ValidPropositions.Add (new Proposition ("c"));
s6.ValidPropositions.Add (new Proposition ("c"));
sm.Add (new Transition (2d/9, start, won));
sm.Add (new Transition (1d/12, start, s4));
sm.Add (new Transition (1d/12, start, s10));
sm.Add (new Transition (1d/9, start, s5));
sm.Add (new Transition (1d/9, start, s9));
sm.Add (new Transition (5d/36, start, s6));
sm.Add (new Transition (5d/36, start, s8));
sm.Add (new Transition (1d/9, start, lost));
sm.Add (new Transition (3d/4, s4, s4));
sm.Add (new Transition (1d/12, s4, won));
sm.Add (new Transition (1d/6, s4, lost));
sm.Add (new Transition (3d/4, s10, s10));
sm.Add (new Transition (1d/12, s10, won));
sm.Add (new Transition (1d/6, s10, lost));
sm.Add (new Transition (13d/18, s5, s5));
sm.Add (new Transition (1d/9, s5, won));
sm.Add (new Transition (1d/6, s5, lost));
sm.Add (new Transition (13d/18, s9, s9));
sm.Add (new Transition (1d/9, s9, won));
sm.Add (new Transition (1d/6, s9, lost));
sm.Add (new Transition (25d/36, s6, s6));
sm.Add (new Transition (5d/36, s6, won));
sm.Add (new Transition (1d/6, s6, lost));
sm.Add (new Transition (25d/36, s8, s8));
sm.Add (new Transition (5d/36, s8, won));
sm.Add (new Transition (1d/6, s8, lost));
sm.Add (new Transition (1d, won, won));
sm.Add (new Transition (1d, lost, lost));
return sm;
}
public void ForEachCircularGraph_DoesNotEnd()
{
var chain = new MarkovChain();
chain.AddWord("A");
chain.AddWord("B");
chain.AddWord("A");
chain.AddWord("C");
chain.AddWord("A");
int iterations = 0;
foreach (var word in chain)
{
Debug.Write(string.Concat(word, " "));
iterations++;
if (iterations > 100)
{
break;
}
}
Assert.AreEqual(101, iterations);
}
private static string MarkovResponse(int order, IEnumerable <string> lines)
{
var chain = new MarkovChain <string>(order);
foreach (var line in lines)
{
chain.Add(line.Split());
}
var response = string.Join(" ", chain.Chain());
if (response != "")
{
return(response);
}
var count = 0;
while (response == "")
{
response = string.Join(" ", chain.Chain());
if (count++ > 10)
{
return("Chaining failed!");
}
}
return(response);
}
private double CalculateProbabilityToReachStateFormula(Formula psi)
{
// calculate P [true U psi]
var psiEvaluator = MarkovChain.CreateFormulaEvaluator(psi);
var precalculatedStates = CreateEmptyPrecalculatedStatesArray();
CalculateSatisfiedStates(precalculatedStates, psiEvaluator);
//CalculateExcludedStates(precalculatedStates); // change for \phi Until \psi
// calculate probabilityExactlyZero (prob0)
ProbabilityExactlyZero(precalculatedStates);
// calculate probabilityExactlyOne (prob1)
ProbabilityExactlyOne(precalculatedStates);
//TODO: Do not calculate exact state probabilities, when _every_ initial state>0 is either in probabilityExactlyZero or in probabilityExactlyOne
var derivedMatrix = CreateDerivedMatrix(precalculatedStates);
var derivedVector = CreateDerivedVector(precalculatedStates, PrecalculatedState.ExaclyOneForFinally);
var resultVector = GaussSeidel(derivedMatrix, derivedVector, 50);
var finalProbability = CalculateFinalProbability(resultVector);
return(finalProbability);
}
static void PopulateChain(MarkovChain <string> chain)
{
var handler = new HttpClientHandler
{
AllowAutoRedirect = false,
AutomaticDecompression = DecompressionMethods.GZip
};
using (var httpClient = new HttpClient(handler))
{
var watch = new Stopwatch();
var downloads = 0;
urls
.AsParallel()
.Select(url => httpClient.GetStreamAsync(url))
.Select(stream => AliveChat(stream.Result))
.ForAll(result =>
{
Console.Clear();
Console.WriteLine($"Download Complete: {++downloads}/{urls.Length}"); //Not thread safe, i know
foreach (var sentence in result)
{
watch.Start();
chain.Add(sentence);
watch.Stop();
}
});
Console.WriteLine($"Creating the chain took: {watch.ElapsedMilliseconds}ms");
}
}
/// <summary>
/// Evaluates a list of genomes. Here we decode each genome in using the contained IGenomeDecoder
/// and evaluate the resulting TPhenome using the contained IPhenomeEvaluator.
/// </summary>
public void Evaluate(IList <NeatGenome> genomeList)
{
Parallel.ForEach(genomeList, delegate(NeatGenome genome)
{
MarkovChain phenome = _genomeDecoder.Decode(genome);
if (null == phenome)
{
genome.EvaluationInfo.SetFitness(0.0);
genome.EvaluationInfo.AlternativeFitness = 0.0;
}
if (null == phenome)
{ // Non-viable genome.
genome.EvaluationInfo.SetFitness(0.0);
genome.EvaluationInfo.AlternativeFitness = 0.0;
}
else
{
FitnessInfo fitnessInfo = _passwordCrackingEvaluator.Evaluate(phenome);
genome.EvaluationInfo.SetFitness(fitnessInfo._fitness);
genome.EvaluationInfo.AlternativeFitness = fitnessInfo._alternativeFitness;
}
});
foreach (string p in _passwordCrackingEvaluator.FoundPasswords)
{
//PasswordCrackingEvaluator.Passwords.Remove(p);
double val = PasswordCrackingEvaluator.Passwords[p];
PasswordCrackingEvaluator.Passwords[p] = val * 0.75;
}
}
public async Task LoadSeeds(string fileName, bool forceLoad = false)
{
if (forceLoad || !fileSeeds.ContainsKey(fileName))
{
await seedLock.WaitAsync();
try
{
if (forceLoad || !fileSeeds.ContainsKey(fileName))
{
var chain = new MarkovChain <Char>(Order);
var seeds = await this.ReadSeedsFromFile(fileName);
foreach (var seed in seeds)
{
chain.Add(seed);
}
fileSeeds[fileName] = chain;
}
}
finally
{
seedLock.Release();
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Hashing devices found ::");
foreach (var AcceleratorDevice in AcceleratorDevice.All)
{
Console.WriteLine($" {AcceleratorDevice}");
}
Console.WriteLine("");
if (args == null || args.Length == 0)
{
throw new ArgumentException("No arguments supplied");
}
IHash hash;
switch (args[0].ToLowerInvariant())
{
case "salsa":
hash = new Salsa20();
break;
case "jenkins":
hash = new Jenkins96();
break;
case "benchmark":
BenchmarkJenkins(args);
return;
case "wordlist":
hash = new Wordlist();
break;
case "variation":
hash = new VarientGen();
break;
case "mix":
hash = new MixMatch();
break;
case "markov":
hash = new MarkovChain();
break;
default:
throw new ArgumentException("Invalid hash type");
}
// override console exit event
CleanExitHandler.Attach();
hash.LoadParameters(args);
hash.Start();
Console.ReadLine();
}
public async Task InitTweetViewModel()
{
_auth = _linqToTwitterAuthorizer.GetAuthorizer(consumerKey, consumerSecret);
await _auth.AuthorizeAsync();
//ht--tps://github.com/JoeMayo/LinqToTwitter/wiki/Querying-the-User-Timeline
using (var ctx = new TwitterContext(_auth))
{
List <Status> tweets =
await
(from tweet in ctx.Status
where tweet.Type == StatusType.User &&
tweet.ScreenName == "realDonaldTrump" &&
tweet.Count == 200 /*MaxTweetsToReturn*/ &&
tweet.SinceID == 1 /*sinceID*/ &&
tweet.TweetMode == TweetMode.Extended
select tweet)
.ToListAsync();
Tweets =
(from tweet in tweets
select new Tweet
{
StatusID = tweet.StatusID,
ScreenName = tweet.User.ScreenNameResponse,
Text = tweet.FullText,
ImageUrl = tweet.User.ProfileImageUrl
})
.ToList();
}
var chain = new MarkovChain <string>(1);
foreach (var t in Tweets)
{
chain.Add(t.Text.Split(' '), 1);
//foreach(var s in t.Text.Split(' '))
//{
// chain.Add(s, 1);
//}
}
Tweets.Add(new Tweet()
{
Text = "--------------"
});
//String testOutput = String.Empty;
var rand = new Random();
for (int i = 0; i < 10; i++)
{
//var word = new string(chain.Chain(rand).ToArray());
//testOutput += " " + word;
var sentence = string.Join(" ", chain.Chain(rand));
Tweets.Add(new Tweet()
{
Text = sentence
});
}
//Tweets.Add(new Tweet() { Text = testOutput });
}
public void MarkovChainTest1()
{
MarkovChain <int> chains = new MarkovChain <int>(4);
Assert.That(chains.GeneratorMatrix, Is.EqualTo(Matrix <double> .Build.DenseOfArray(new double[, ] {
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
})));
}
public DrumGenerator(int order)
{
this.chain = new DotNetLearn.Markov.MarkovChain<Note>(order);
IsInitialized = false;
this.MaxNotes = 100;
}
static void ValidateModel(MarkovChain model, Dictionary <string, double> passwords, int guesses, bool hashed) //passwords here is not used...
{
Console.Write("Validating on {0} guesses... ", guesses);
PasswordCrackingEvaluator eval = new PasswordCrackingEvaluator(guesses, hashed);
var results = eval.Validate(model);
Console.WriteLine("Accounts: {0} Uniques: {1}", results._fitness, results._alternativeFitness);
}
static void Main(string[] args)
{
var chain = new MarkovChain <string>(2);
PopulateChain(chain);
Console.WriteLine();
Generate(chain);
}
static string GetName()
{
MarkovChain <char> chain = GetChain();
string name = new string(chain.Chain().ToArray());
return(name);
}
public void InitializeChain()
{
_chain = new MarkovChain <string>(1);
foreach (var t in Tweets)
{
_chain.Add(t.Text.Split(' '), 1);
}
}
// GET: CodeExamples
public ActionResult MarkovChain()
{
MarkovChain chain = new MarkovChain(100);
FeeDText(chain);
return(View("MarkovChain", chain));
}
public SentenceGenerator()
{
_chain = new MarkovChain <string>(1);
foreach (var sentence in _sentenceBase.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries))
{
_chain.Add((sentence + ".").Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToArray(), 1);
}
}
static void Main(string[] args)
{
MarkovChain mm = new MarkovChain(8);
Console.WriteLine(mm);
Console.Read();
}
public MarkovChainTextBot()
: base()
{
this.markovChain = new MarkovChain<string>();
this.launchTime = DateTime.Now;
this.numTrainingMessagesReceived = 0;
this.numTrainingWordsReceived = 0;
}
static MarkovChain <char> GetChain()
{
MarkovChain <char> chain = new MarkovChain <char>(2);
foreach (string name in names)
{
chain.Add(name);
}
return(chain);
}
public static MarkovChain BuildChain()
{
var sm = new MarkovChain ();
var s1 = sm.Add (new State ("s1", true));
var s2 = sm.Add (new State ("s2"));
sm.Add (new Transition ("t1", 1, s1, s2));
sm.Add (new Transition ("t2", 1, s2, s2));
return sm;
}
private static void Main(string[] args)
{
var testString = "The background generator is intended to remove the creative pressure that can sometimes frustrate players as they try to flesh out the murky details of their characters' backgrounds. This generator provides these details with either a simple roll of the die or the players deliberately selecting from options on the furnished tables and lists.";
Console.WriteLine("Input String: {0}", testString);
MarkovChain chain = new MarkovChain();
chain.ParseText(testString, 3);
Console.WriteLine(chain.GenerateChain(10));
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public static MarkovChain<AutomatonNode> GetExampleFig102()
{
var mc = new MarkovChain<AutomatonNode> (new AutomatonNodeFactory ());
var s0 = mc.AddNode ("s0");
var s123 = mc.AddNode ("s123");
var s456 = mc.AddNode ("s456");
var ss123 = mc.AddNode ("s'123");
var s23 = mc.AddNode ("s23");
var s45 = mc.AddNode ("s45");
var ss456 = mc.AddNode ("s'456");
var t1 = mc.AddNode ("1");
var t2 = mc.AddNode ("2");
var t3 = mc.AddNode ("3");
var t4 = mc.AddNode ("4");
var t5 = mc.AddNode ("5");
var t6 = mc.AddNode ("6");
mc.SetInitial (s0, 1);
mc.AddTransition (s0, 1d/2, s123);
mc.AddTransition (s0, 1d/2, s456);
mc.AddTransition (s123, 1d/2, ss123);
mc.AddTransition (s123, 1d/2, s23);
mc.AddTransition (ss123, 1d/2, s123);
mc.AddTransition (ss123, 1d/2, t1);
mc.AddTransition (s23, 1d/2, t2);
mc.AddTransition (s23, 1d/2, t3);
mc.AddTransition (s45, 1d/2, t4);
mc.AddTransition (s45, 1d/2, t5);
mc.AddTransition (s456, 1d/2, s45);
mc.AddTransition (s456, 1d/2, ss456);
mc.AddTransition (ss456, 1d/2, s456);
mc.AddTransition (ss456, 1d/2, t6);
mc.AddTransition (t1, t1);
mc.AddTransition (t2, t2);
mc.AddTransition (t3, t3);
mc.AddTransition (t4, t4);
mc.AddTransition (t5, t5);
mc.AddTransition (t6, t6);
return mc;
}
/// <summary>
/// Generates a new text variation based on the given sample.
/// </summary>
/// <param name="sample">The sample on which the variation will be based..</param>
/// <param name="size">The size of the text to generate.</param>
/// <param name="windowSize">Size of the window.</param>
/// <returns></returns>
public static string Generate(string sample, int size = 1000, int windowSize=5)
{
// tokenise the input string
var seedList = new List<string>(Split(Cleanup(sample)));
var chain = new MarkovChain<string>(seedList, windowSize);
// generate a new sequence using a starting word, and maximum return size
var generated = new List<string>(chain.Generate(size));
// output the results to the console
var sb = new StringBuilder();
generated.ForEach(item => sb.Append(item));
var goodcase = ToSentenceCase(sb.ToString().Trim());
if(!goodcase.EndsWith(".")) goodcase += ".";
return goodcase;
}
public static MarkovChain BuildSimpleCommunicationProtocol()
{
var sm = new MarkovChain ();
var start = sm.Add (new State ("start", true));
var @try = sm.Add (new State ("try"));
var delivered = sm.Add (new State ("delivered"));
var lost = sm.Add (new State ("lost"));
start.ValidPropositions.Add (new Proposition ("start"));
@try.ValidPropositions.Add (new Proposition ("try"));
delivered.ValidPropositions.Add (new Proposition ("delivered"));
lost.ValidPropositions.Add (new Proposition ("lost"));
sm.Add (new Transition (1, start, @try));
sm.Add (new Transition (.9, @try, delivered));
sm.Add (new Transition (.1, @try, lost));
sm.Add (new Transition (1, lost, @try));
sm.Add (new Transition (1, delivered, start));
return sm;
}
void Start()
{
markov = new MarkovChain();
markov.Load(text);
}
static void Main(string[] args)
{
#region Markov Chain
#region Create Variables
MarkovNode<string> hi = node("Hello"), howU = node("How are you?"),
ok = node("Okay"), gr8 = node("Great!"),
sup = node("Anything new?"),
nutn = node("Nothin'"), _code = node("Code!"), math = node("Maths :("),
sux = node("Sux!"), cool = node("Cool!"), fun = node("That's fun"),
bye = node("Bye!");
var chain = new MarkovChain<string>(hi);
hi.AddChild(1, hi); hi.AddChild(3, howU);
howU.AddChild(1, howU); howU.AddChild(3, gr8); howU.AddChild(4, ok);
ok.AddChild(2, ok); ok.AddChild(4, sup);
gr8.AddChild(1, gr8); gr8.AddChild(4, sup); gr8.AddChild(2, ok);
sup.AddChild(4, nutn); sup.AddChild(5, _code); sup.AddChild(1, math);
nutn.AddChild(1, sux); nutn.AddChild(2, cool);
_code.AddChild(10, cool); _code.AddChild(1, sux);
math.AddChild(1, cool); math.AddChild(10, sux);
sux.AddChild(10, sup); sux.AddChild(10, bye);
cool.AddChild(5, sup); cool.AddChild(5, fun); cool.AddChild(1, bye);
fun.AddChild(10, bye);
#endregion
while (true)
{
if (chain.current == null) Console.ReadKey();
var text = chain.current.value;
Console.WriteLine(text);
Thread.Sleep(500);
chain.Next();
}
return;
#endregion
#region BFI
Console.WriteLine("Enter BF code, or nothing for \"Hello World\" print code:");
var code = Console.ReadLine();
if (code == null || code.Length == 0)
{
code = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++";
Console.WriteLine("Code = " + code);
}
Console.WriteLine("Enter input:");
var input = Console.ReadLine();
int index = 0;
var output = BFInterpreter.Output(input, code, null, ref index);
Console.WriteLine("Output:");
Console.WriteLine(output);
Console.ReadLine();
return;
#endregion
#region Weighted RNG
var rng = new WeightedRNG<string>();
rng.AddWeight(5, "hey world");
rng.AddWeight(6, "greetings world");
rng.AddWeight(10, "hello world");
rng.AddWeight(1, "yo world");
int hey = 0, greetings = 0, hello = 0, yo = 0;
for (int i = 0; i < 70000; i++)
{
var rand = rng.GetRandom();
if (rand.StartsWith("hey")) hey++;
else if (rand.StartsWith("greetings")) greetings++;
else if (rand.StartsWith("hello")) hello++;
else if (rand.StartsWith("yo")) yo++;
if (i % 7000 == 0)
Console.WriteLine("{0}% done...", i / 700);
//Console.WriteLine(rand);
}
Console.WriteLine("Heys (5) | Greet (6) | Hello (10) | Yo's (1)");
Console.WriteLine("{0} | {1} | {2} | {3}", hey, greetings, hello, yo);
Console.WriteLine(); float weightsSum = 5 + 6 + 10 + 1;
Console.WriteLine("{0} | {1} | {2} | {3}", hey / weightsSum, greetings / weightsSum, hello / weightsSum, yo / weightsSum);
#endregion
#region Binary Search
#endregion
Console.ReadLine();
}
public static MarkovChain BuildTwoStatesSMWithSelfLoop()
{
var sm = new MarkovChain ();
var s1 = sm.Add (new State ("s1", true));
var s2 = sm.Add (new State ("s2"));
s1.ValidPropositions.Add (new Predicate { Name = "state_one" });
s2.ValidPropositions.Add (new Predicate { Name = "state_two" });
sm.Add (new Transition ("t1", .5, s1, s2));
sm.Add (new Transition ("t2", .5, s1, s1));
sm.Add (new Transition ("t3", 1, s2, s1));
return sm;
}
public void LoadFromFile()
{
DrumGenerator gen = new DrumGenerator();
ProtoBuf.Serializer.PrepareSerializer<DrumGenerator>();
System.IO.FileStream fs = new System.IO.FileStream(SavePath, System.IO.FileMode.Open);
gen = ProtoBuf.Serializer.Deserialize<DrumGenerator>(fs);
chain = gen.chain;
fs.Close();
}
public static MarkovChain BuildSingleStateSM()
{
var sm = new MarkovChain ();
var s1 = sm.Add (new State ("s1", true));
s1.ValidPropositions.Add (new Predicate () { Name = "state_one" });
sm.Add (new Transition ("t1", 1, s1, s1));
return sm;
}
public static MarkovChain BuildThreeStatesSM()
{
var sm = new MarkovChain ();
var s1 = sm.Add (new State ("s1", true));
var s2 = sm.Add (new State ("s2"));
var s3 = sm.Add (new State ("s3"));
s1.ValidPropositions.Add (new Proposition ("state_one"));
s2.ValidPropositions.Add (new Proposition ("state_two"));
s3.ValidPropositions.Add (new Proposition ("state_three"));
sm.Add (new Transition ("t12", .5, s1, s2));
sm.Add (new Transition ("t13", .5, s1, s3));
sm.Add (new Transition ("t21", .7, s2, s1));
sm.Add (new Transition ("t23", .3, s2, s3));
sm.Add (new Transition ("t31", .9, s3, s1));
sm.Add (new Transition ("t32", .1, s3, s2));
return sm;
}
public double Satisfy (State currentState, Until until)
{
if (caching.ContainsKey (until)) {
return caching[until][currentState];
}
caching[until] = new Dictionary<State, double> ();
var B = until.Left;
var C = until.Right;
// Compute SO
var s0 = States.Except (ComputeNotS0 (States.Where (s => Satisfy (s, B) == 1), C));
Console.WriteLine ("S0 : " + string.Join (",", s0.Select (s => s.Identifier)));
foreach (var s in s0)
caching[until].Add (s, 0);
// Compute S1
var s1 = ComputeS1 (B, C);
Console.WriteLine ("S1 : " + string.Join (",", s1.Select (s => s.Identifier)));
foreach (var s in s1)
caching[until].Add (s, 1);
// Compute S?
var spending = States.Except (s0.Union(s1));
Console.WriteLine ("S? : " + string.Join (",", spending.Select (s => s.Identifier)));
if (spending.Count() > 0) {
// Build a SM with only states from S?
var sm = new MarkovChain ();
foreach (var s in spending) {
sm.Add (s);
foreach (var t in spending) {
var transition = Transitions.Where (trans => trans.From.Equals (s)
& trans.To.Equals (t)).SingleOrDefault ();
if (transition != null)
sm.Add (transition);
}
}
var table = sm.BuildConversionTable ();
var A = sm.GetTransitionMatrix (table);
var b = new DenseVector (
sm.States.Select (x =>
Transitions.Where (y => y.From.Equals (x))
.Where (y => s1.Contains (y.To))
.Select (y => y.Probability).Sum ()
).ToArray ()
);
Console.WriteLine ("---------- [Conversion Table]");
Console.WriteLine (string.Join ("\n", table.Select (x => x.Key + ":" + x.Value)));
Console.WriteLine ("----------");
Console.WriteLine ("---------- [A]");
Console.WriteLine (A);
Console.WriteLine ("----------");
Console.WriteLine ("---------- [b]");
Console.WriteLine (b);
Console.WriteLine ("----------");
var epsilon = 0.001;
MathNet.Numerics.LinearAlgebra.Generic.Vector<double> prevsol = new DenseVector (b.Count, 0);
MathNet.Numerics.LinearAlgebra.Generic.Vector<double> currentsol = new DenseVector (b.Count, 0);
do {
prevsol = currentsol;
currentsol = A.Multiply (prevsol) + b;
} while ((prevsol - currentsol).AbsoluteMaximum() > epsilon);
Console.WriteLine ("---------- [solution]");
Console.WriteLine (currentsol);
Console.WriteLine ("----------");
foreach (var s in spending)
caching[until].Add(s, currentsol[table[s.Identifier]]);
Console.WriteLine ("---------- [Final result]");
Console.WriteLine (string.Join ("\n", caching[until].Select (x => x.Key.Identifier + " : " + x.Value)));
Console.WriteLine ("----------");
}
return caching[until][currentState];
}
public DrumGenerator()
{
IsInitialized = false;
this.chain = new DotNetLearn.Markov.MarkovChain<Note>(4);
this.MaxNotes = 100;
}
private IEnumerable<State> ComputeS1 (LTLFormula b, LTLFormula c)
{
var B = States.Where (s => Satisfy (s, b) == 1);
var C = States.Where (s => Satisfy (s, c) == 1);
var buscub = B.Union (States.Except (C.Union (B)));
var newSM = new MarkovChain ();
foreach (var s in States) {
newSM.Add (s);
foreach (var t in States) {
if (buscub.Contains (s)) {
newSM.Add (new Transition (1, s, t));
} else {
var transition = Transitions.Where (trans => trans.From.Equals (s)
& trans.To.Equals (t)).SingleOrDefault ();
if (transition != null)
newSM.Add (transition);
}
}
}
return newSM.States.Where (s => Satisfy (s, new Finally(b)) == 1);
}
public double Satisfy (State s, Finally @finally)
{
// Search states such that enclosed in finally is true
var validStates = States.Where (x => Satisfy(x, @finally.Enclosed) > 0);
if (validStates.Contains (s))
return 1;
else if (validStates.Count () == 0)
return 0;
Console.WriteLine ("---------- [States satisfying enclosed]");
Console.WriteLine (string.Join (", ", validStates.Select (x => x.Identifier)));
Console.WriteLine ("----------");
var smToValidStates = new MarkovChain ();
foreach (var state in validStates) {
DFS (validStates, smToValidStates);
}
Console.WriteLine ("---------- [States in S tilde]");
Console.WriteLine (string.Join (", ", smToValidStates.States.Select (x => x.Identifier)));
Console.WriteLine ("----------");
var table = smToValidStates.BuildConversionTable ();
var transitions = smToValidStates.GetTransitionMatrix(table);
/*
Console.WriteLine ("---------- [Conversion Table]");
Console.WriteLine (string.Join ("\n", table.Select (x => x.Key + ":" + x.Value)));
Console.WriteLine ("----------");
Console.WriteLine ("---------- [Transitions]");
Console.WriteLine (transitions);
Console.WriteLine ("----------");
*/
// Build the transition matrix for this sub state-machine
var system = new DiagonalMatrix (transitions.RowCount, transitions.ColumnCount, 1)
- transitions;
/*
Console.WriteLine ("---------- [System]");
Console.WriteLine (system);
Console.WriteLine ("----------");
*/
var vector = new DenseVector (
smToValidStates.States.Select (x =>
Transitions.Where (y => y.From.Equals (x))
.Where (y => validStates.Contains (y.To))
.Select (y => y.Probability).Sum ()
).ToArray ()
);
/*
Console.WriteLine ("---------- [Vector]");
Console.WriteLine (vector);
Console.WriteLine ("----------");
*/
var result = system.LU ().Solve (vector);
/*
Console.WriteLine ("---------- [Result]");
Console.WriteLine (result);
Console.WriteLine ("----------");
*/
return table.ContainsKey (s.Identifier) ? result[table[s.Identifier]] : 0;
}
public FcmMc(double[,] obs)
{
_fcm = new Fcm(obs);
_mc = new MarkovChain();
}
private void DFS (IEnumerable<State> B, MarkovChain sm)
{
var prestarb = PreStar (B).Except (B);
foreach (var s in prestarb) {
sm.Add (s);
foreach (var t in prestarb) {
var transition = Transitions.Where (trans => trans.From.Equals (s)
& trans.To.Equals (t)).SingleOrDefault ();
if (transition != null)
sm.Add (transition);
}
}
}
public MarkovChainGenerator(PatchNames instrument, int order = 3, int length = 150)
{
this.instrument = instrument;
this.chain = new MarkovChain<Note>(order);
this.MaxLength = length;
}
public static MarkovChain<AutomatonNode> GetExampleFig103()
{
var mc = new MarkovChain<AutomatonNode> (new AutomatonNodeFactory ());
var start = mc.AddNode ("start", new Proposition ("start"));
var s4 = mc.AddNode ("4", new Proposition ("4"));
var s10 = mc.AddNode ("10", new Proposition ("10"));
var s5 = mc.AddNode ("5", new Proposition ("5"));
var s9 = mc.AddNode ("9", new Proposition ("9"));
var s6 = mc.AddNode ("6", new Proposition ("6"));
var s8 = mc.AddNode ("8", new Proposition ("8"));
var won = mc.AddNode ("won", new Proposition ("won"));
var lost = mc.AddNode ("lost", new Proposition ("lost"));
mc.SetInitial (start, 1);
mc.AddTransition (start, 2d/9, won);
mc.AddTransition (start, 1d/12, s4);
mc.AddTransition (start, 1d/12, s10);
mc.AddTransition (start, 1d/9, s5);
mc.AddTransition (start, 1d/9, s9);
mc.AddTransition (start, 5d/36, s6);
mc.AddTransition (start, 5d/36, s8);
mc.AddTransition (start, 1d/9, lost);
mc.AddTransition (s4, 3d/4, s4);
mc.AddTransition (s4, 1d/12, won);
mc.AddTransition (s4, 1d/6, lost);
mc.AddTransition (s10, 3d/4, s10);
mc.AddTransition (s10, 1d/12, won);
mc.AddTransition (s10, 1d/6, lost);
mc.AddTransition (s5, 13d/18, s5);
mc.AddTransition (s5, 1d/9, won);
mc.AddTransition (s5, 1d/6, lost);
mc.AddTransition (s9, 13d/18, s9);
mc.AddTransition (s9, 1d/9, won);
mc.AddTransition (s9, 1d/6, lost);
mc.AddTransition (s6, 25d/36, s6);
mc.AddTransition (s6, 5d/36, won);
mc.AddTransition (s6, 1d/6, lost);
mc.AddTransition (s8, 25d/36, s8);
mc.AddTransition (s8, 5d/36, won);
mc.AddTransition (s8, 1d/6, lost);
mc.AddTransition (won, won);
mc.AddTransition (lost, lost);
return mc;
}
public static MarkovChain<AutomatonNode> GetExamplePMCLecture1513()
{
var mc = new MarkovChain<AutomatonNode> (new AutomatonNodeFactory ());
var s0 = mc.AddNode ("s0");
var s1 = mc.AddNode ("s1");
var s2 = mc.AddNode ("s2");
var s3 = mc.AddNode ("s3");
var s4 = mc.AddNode ("s4");
var s5 = mc.AddNode ("s5");
mc.AddTransition (s0, .5, s1);
mc.AddTransition (s0, .5, s3);
mc.AddTransition (s1, .5, s0);
mc.AddTransition (s1, .25, s4);
mc.AddTransition (s1, .25, s2);
mc.AddTransition (s2, s5);
mc.AddTransition (s5, s2);
mc.AddTransition (s3, s3);
mc.AddTransition (s4, s4);
mc.SetInitial (s0, 1);
return mc;
}
