protected MsgfGraph TouchNode(MSGF node)
{
if (!HasNode(node))
{
NodeDictionary.Add(node, new NodeEdges());
}
return(this);
}
public MsgfGraph PopNode(MSGF node)
{
foreach (var edge in NodeDictionary[node].IncomingEdges.ToList())
{
ClearEdge(edge.NodeFrom, edge.NodeTo);
}
NodeDictionary.Remove(node);
return(this);
}
public MsgfGraph AddEdge(MSGF nodeFrom, MSGF nodeTo, uint count = 1)
{
if (count == 0)
{
return(this);
}
TouchEdge(nodeFrom, nodeTo);
EdgeDictionary[new Edge(nodeFrom, nodeTo)] += count;
return(this);
}
public MsgfGraph SetEdge(MSGF nodeFrom, MSGF nodeTo, uint freq = 1)
{
if (freq == 0)
{
return(ClearEdge(nodeFrom, nodeTo));
}
TouchEdge(nodeFrom, nodeTo);
EdgeDictionary[new Edge(nodeFrom, nodeTo)] = freq;
return(this);
}
public MsgfGraph ClearEdge(MSGF nodeFrom, MSGF nodeTo)
{
if (HasEdge(nodeFrom, nodeTo))
{
EdgeDictionary.Remove(new Edge(nodeFrom, nodeTo));
NodeDictionary[nodeFrom].IncomingEdges.Remove(new Edge(nodeFrom, nodeTo));
NodeDictionary[nodeFrom].OutgoingEdges.Remove(new Edge(nodeFrom, nodeTo));
}
return(this);
}
public List <MSGF> GetIncomingNodes(MSGF node)
{
if (!HasNode(node))
{
return(new List <MSGF>());
}
return
(NodeDictionary[node].IncomingEdges
.Select(edge => edge.NodeFrom)
.ToList());
}
public List <MSGF> GetOutgoingNodes(MSGF node)
{
if (!HasNode(node))
{
return(new List <MSGF>());
}
return
(NodeDictionary[node].OutgoingEdges
.Select(edge => edge.NodeTo)
.ToList());
}
public uint GetEdgeFreq(MSGF nodeFrom, MSGF nodeTo)
{
if (HasEdge(nodeFrom, nodeTo))
{
return(EdgeDictionary[new Edge(nodeFrom, nodeTo)]);
}
else
{
return(0);
}
}
public static List <SGF> GenQueries(SGF sgf)
{
var list = sgf.Decompose();
var ret = new List <SGF>();
{//gen words
foreach (var msgf in list)
{
ret.Add(
new SGF().AggregateFrom(
new List <MSGF> {
msgf
}));
}
}
{//gen pairs
MSGF a1 = null;
foreach (var msgf in list)
{
if (a1 != null)
{
ret.Add(
new SGF().AggregateFrom(
new List <MSGF> {
a1, msgf
}.OrderBy(l => l.GetContent())
.ToList()));
}
a1 = msgf;
}
}
{//gen tripples
MSGF a1 = null, a2 = null;
foreach (var msgf in list)
{
if (a1 != null && a2 != null)
{
ret.Add(
new SGF().AggregateFrom(
new List <MSGF> {
a1, a2, msgf
}.OrderBy(l => l.GetContent())
.ToList()));
}
a1 = a2;
a2 = msgf;
}
}
var rnd = new Random();
return
(ret.OrderBy(x => rnd.Next())
.Take(Math.Max(3, (ret.Count + 9) / 10))
.ToList());
}
protected MsgfGraph TouchEdge(MSGF nodeFrom, MSGF nodeTo)
{
TouchNode(nodeFrom);
TouchNode(nodeTo);
if (!HasEdge(nodeFrom, nodeTo))
{
EdgeDictionary.Add(new Edge(nodeFrom, nodeTo), 0);
NodeDictionary[nodeFrom].OutgoingEdges.Add(new Edge(nodeFrom, nodeTo));
NodeDictionary[nodeTo].IncomingEdges.Add(new Edge(nodeFrom, nodeTo));
}
return(this);
}
public MsgfGraph PopEdge(MSGF nodeFrom, MSGF nodeTo, uint count = 1)
{
if (count == 0)
{
return(this);
}
TouchEdge(nodeFrom, nodeTo);
if (EdgeDictionary[new Edge(nodeFrom, nodeTo)] <= count)
{
return(ClearEdge(nodeFrom, nodeTo));
}
EdgeDictionary[new Edge(nodeFrom, nodeTo)] -= count;
return(this);
}
protected void DoWave()
{
TotalUpdates += 1;
MSGF currentNode = StartNodes.ToList()[Rnd.Next(StartNodes.Count)];
HashSet <MSGF> uniquePathsNodes = new HashSet <MSGF>(new MsgfEqualityComparer());
double rnd = Math.Min(0.999999, Rnd.NextDouble());
uint maxSteps = (uint)Math.Floor((TargetDistance + 1) * ((Math.Log(1 - rnd)) / (Math.Log(0.05))));
maxSteps = Math.Max(0, Math.Min(2 * TargetDistance, maxSteps));
for (uint i = 0; i < maxSteps; ++i)
{
uniquePathsNodes.Add(currentNode);
var nodesTo = MsgfGraph.GetOutgoingNodes(currentNode).FindAll(node => !uniquePathsNodes.Contains(node));
if (!nodesTo.Any())
{
break;
}
uint outputSum =
nodesTo.Select(node => MsgfGraph.GetEdgeFreq(currentNode, node))
.Aggregate((a, b) => a + b);
int pathNumber = Rnd.Next((int)outputSum);
foreach (var nodeTo in nodesTo)
{
pathNumber -= (int)MsgfGraph.GetEdgeFreq(currentNode, nodeTo);
if (pathNumber <= 0)
{
ProbabilityGraph.AddEdge(currentNode, nodeTo);
if (!StartNodes.Contains(nodeTo))
{
NodesProbability[nodeTo] += 1;
}
currentNode = nodeTo;
break;
}
}
}
}
public bool HasNode(MSGF node)
{
return(NodeDictionary.ContainsKey(node));
}
public MsgfGraph AddNode(MSGF node)
{
return(TouchNode(node));
}
public Edge(MSGF nodeFrom, MSGF nodeTo)
{
NodeFrom = nodeFrom;
NodeTo = nodeTo;
}
public bool HasEdge(MSGF nodeFrom, MSGF nodeTo)
{
return(EdgeDictionary.ContainsKey(new Edge(nodeFrom, nodeTo)));
}
