public string Generate(int order)
{
if (order > ModelOrder)
{
throw new ApplicationException("Cannot generate higher order than was built.");
}
StringBuilder rslt = new StringBuilder();
rslt.Append(StartChar, order);
int iStart = 0;
char ch = StartChar;
do
{
MarkovNode node = Root.Children[rslt[iStart]];
for (int i = 1; i < order; ++i)
{
node = node.Children[rslt[i + iStart]];
}
ch = SelectChildChar(node);
if (ch != EndChar)
{
rslt.Append(ch);
}
++iStart;
} while (ch != EndChar);
// remove start characters from the string
return(rslt.ToString().Substring(order));
}
public string ToString(int order)
{
StringBuilder result = new StringBuilder();
result.Append(StartChar, order);
int iStart = 0;
char ch = StartChar;
do
{
MarkovNode node = Root.Children[result[iStart]];
for (int i = 1; i < order; i++)
{
node = node.Children[result[i + iStart]];
}
ch = ChildGet(node);
if (ch != StopChar)
{
result.Append(ch);
}
++iStart;
}while (ch != StopChar);
string clean = result.ToString().Substring(order);
if (clean.Contains(StartChar))
{
clean = clean.Replace(StartChar.ToString(), "");
}
return(clean);
}
public void AddDescendent(MarkovNode n)
{
var current = root.descendents.SingleOrDefault(descendent => descendent.Value == n.Value);
if (current == null)
descendents.Add(n);
else
current.AddHit();
}
public MarkovChain(int order = 0)
{
ModelOrder = order;
Root = new MarkovNode(StartChar);
//foreach (char c in text)
//{
// ++Root.Count;
// Root.AddNode(c);
//}
//Root.AddNode(StopChar);
}
public MarkovTextModel(string text, int order)
{
Root = new MarkovNode(StartChar);
// Currently building only an order 0 model
foreach (char c in text)
{
++Root.Count;
Root.AddChild(c);
}
// Add the stop character
Root.AddChild(EndChar);
}
public MarkovTextModel(string text, int order)
{
Root = new MarkovNode(StartChar);
// Currently building only an order 0 model
foreach (char c in text)
{
++Root.Count;
Root.AddChild(c);
}
// Add the stop character
Root.AddChild(EndChar);
}
public MarkovNode AddNode(char c)
{
++FollowCount;
MarkovNode child;
if (Children.TryGetValue(c, out child))
{
++child.Count;
}
else
{
child = new MarkovNode(c);
Children.Add(c, child);
}
return(child);
}
private char ChildGet(MarkovNode node)
{
int roll = StatePicker.Next(node.FollowCount);
int frequency = 0;
foreach (var kvp in node.Children)
{
frequency += kvp.Value.Count;
if (frequency > roll)
{
return(kvp.Key);
}
}
throw new Exception("I shit the bed!");
}
private MarkovChain <MapPixel> GetMarkovChain(MapPixel startValue)
{
var landNode = new MarkovNode <MapPixel>(MapPixel.LAND);
var waterNode = new MarkovNode <MapPixel>(MapPixel.WATER);
landNode.AddConnection(waterNode, _landWaterConnectionWeight);
waterNode.AddConnection(landNode, _waterLandConnectionWeight);
var nodeList = new List <MarkovNode <MapPixel> >
{
landNode,
waterNode
};
return(new MarkovChain <MapPixel>(nodeList, nodeList.FirstOrDefault(node => node.NodeValue == startValue)));
}
private MarkovChain <MapPixel> GetMarkovChain()
{
var landNode = new MarkovNode <MapPixel>(MapPixel.LAND);
var waterNode = new MarkovNode <MapPixel>(MapPixel.WATER);
landNode.AddConnection(waterNode, _landWaterConnectionWeight);
waterNode.AddConnection(landNode, _waterLandConnectionWeight);
var nodeList = new List <MarkovNode <MapPixel> >
{
landNode,
waterNode
};
return(new MarkovChain <MapPixel>(nodeList));
}
private char SelectChildChar(MarkovNode node)
{
// Generate a random number in the range 0..(node.Count-1)
int rnd = RandomSelector.Next(node.Count);
// Go through the children to select the node
int cnt = 0;
foreach (var kvp in node.Children)
{
cnt += kvp.Value.Count;
if (cnt > rnd)
{
return(kvp.Key);
}
}
throw new ApplicationException("This can't happen!");
}
public void AddString(string s)
{
StringBuilder builder = new StringBuilder(s.Length + 2 * ModelOrder);
builder.Append(StartChar, ModelOrder);
builder.Append(s);
builder.Append(StopChar, ModelOrder);
for (int iStart = 0; iStart < builder.Length; ++iStart)
{
MarkovNode parent = Root.AddNode(builder[iStart]);
for (int i = 1; i <= ModelOrder && i + iStart < builder.Length; i++)
{
MarkovNode child = parent.AddNode(builder[iStart + i]);
parent = child;
}
}
}
public MarkovNode AddChild(char c)
{
if (Children == null)
{
Children = new Dictionary <char, MarkovNode>();
}
++FollowCount;
MarkovNode child;
if (Children.TryGetValue(c, out child))
{
++child.Count;
}
else
{
child = new MarkovNode(c);
Children.Add(c, child);
}
return(child);
}
public MarkovNode AddChild(string w)
{
if (Children == null)
{
Children = new Dictionary <string, MarkovNode>();
}
++FollowCount;
MarkovNode child;
if (Children.TryGetValue(w, out child))
{
++child.Count;
}
else
{
child = new MarkovNode(w);
Children.Add(w, child);
}
return(child);
}
private string OutputNode(MarkovNode node, int parentCount, string pad)
{
//Console.WriteLine("{0}{1} - {2:N0} ({3:P2})", pad, node.Ch, node.Count, (double)node.Count / parentCount);
var sb = new StringBuilder();
sb.AppendLine(String.Format("{0}{1} - {2:N0} ({3:P2})",
pad, node.Ch, node.Count, (double)node.Count / parentCount));
if (node.Children != null)
{
int cnt = 0;
foreach (var kvp in node.Children)
{
sb.AppendLine(OutputNode(kvp.Value, node.Count, pad + " "));
cnt += kvp.Value.Count;
}
if (cnt != node.Count)
{
Console.WriteLine("ERROR: child count doesn't match.");
}
}
return(sb.ToString());
}
public void AddString(string s)
{
var input = s.Split(' ');
// Naive method
for (int iStart = 0; iStart < input.Length; ++iStart)
{
// Get the order 0 node
MarkovNode parent = Root.AddChild(input[iStart]);
// Now add N-grams starting with this node
for (int i = 1; i <= ModelOrder && i + iStart < input.Length; ++i)
{
MarkovNode child = parent.AddChild(input[iStart + i]);
parent = child;
if (parent.word.Last() == '.')
{
parent.AddChild(EndChar.ToString());
}
}
}
}
public void AddString(string s)
{
// Construct the string that will be added.
StringBuilder sb = new StringBuilder(s.Length + 2 * (ModelOrder));
// Order+1 Start characters. The string to add. Order+1 Stop characters.
sb.Append(StartChar, ModelOrder);
sb.Append(s);
sb.Append(EndChar, ModelOrder);
// Naive method
for (int iStart = 0; iStart < sb.Length; ++iStart)
{
// Get the order 0 node
MarkovNode parent = Root.AddChild(sb[iStart]);
// Now add N-grams starting with this node
for (int i = 1; i <= ModelOrder && i + iStart < sb.Length; ++i)
{
MarkovNode child = parent.AddChild(sb[iStart + i]);
parent = child;
}
}
}
public string Generate(int order)
{
if (order > ModelOrder)
{
throw new ApplicationException("Cannot generate higher order than was built.");
}
List <String> rslt = new List <string>();
// Trying to add one start char per order 'level', have to do it in a loop because we
// don't have a method that adds a given number like we do with StringBuilder.Append()
for (var i = 0; i < order; ++i)
{
rslt.Add(StartChar.ToString());
}
int iStart = 0;
string w = StartChar.ToString();
do
{ //TODO: Fix this garbage
MarkovNode node = Root.Children[rslt[iStart]];
for (int i = 1; i < order; ++i)
{
node = node.Children[rslt[i + iStart]];
}
w = SelectChildWord(node);
if (w.Equals(EndChar.ToString()))
{
rslt.Add(" " + w);
}
++iStart;
} while (!w.Equals(EndChar.ToString()));
// remove start characters from the string
return(rslt.ToString().Substring(order));
}
public MarkovNode(String value, MarkovNode root)
{
this.root = root;
MarkovNode(value);
}
public MarkovTextModel(int order)
{
ModelOrder = order;
Root = new MarkovNode(StartChar);
}
public MarkovTextModelWord(int order)
{
ModelOrder = order;
Root = new MarkovNode(StartChar.ToString());
}
private char SelectChildChar(MarkovNode node)
{
// Generate a random number in the range 0..(node.Count-1)
int rnd = RandomSelector.Next(node.Count);
// Go through the children to select the node
int cnt = 0;
foreach (var kvp in node.Children)
{
cnt += kvp.Value.Count;
if (cnt > rnd)
{
return kvp.Key;
}
}
throw new ApplicationException("This can't happen!");
}
public MarkovNode AddChild(char c)
{
if (Children == null)
{
Children = new Dictionary<char, MarkovNode>();
}
++FollowCount;
MarkovNode child;
if (Children.TryGetValue(c, out child))
{
++child.Count;
}
else
{
child = new MarkovNode(c);
Children.Add(c, child);
}
return child;
}
private string OutputNode(MarkovNode node, int parentCount, string pad)
{
//Console.WriteLine("{0}{1} - {2:N0} ({3:P2})", pad, node.Ch, node.Count, (double)node.Count / parentCount);
var sb = new StringBuilder();
sb.AppendLine(String.Format("{0}{1} - {2:N0} ({3:P2})",
pad, node.Ch, node.Count, (double)node.Count / parentCount));
if (node.Children != null)
{
int cnt = 0;
foreach (var kvp in node.Children)
{
sb.AppendLine(OutputNode(kvp.Value, node.Count, pad + " "));
cnt += kvp.Value.Count;
}
if (cnt != node.Count)
{
Console.WriteLine("ERROR: child count doesn't match.");
}
}
return sb.ToString();
}
public MarkovTextModelWord(int order)
{
ModelOrder = order;
Root = new MarkovNode(StartChar.ToString());
}
public MarkovNode AddChild(string w)
{
if (Children == null)
{
Children = new Dictionary<string, MarkovNode>();
}
++FollowCount;
MarkovNode child;
if (Children.TryGetValue(w, out child))
{
++child.Count;
}
else
{
child = new MarkovNode(w);
Children.Add(w, child);
}
return child;
}
// adds a child node
public void AddNode(MarkovNode node)
{
children.Add(node);
}
public MarkovTextModel(int order)
{
ModelOrder = order;
Root = new MarkovNode(StartChar);
}
