/// <summary>
/// Scores the specified entry.
/// </summary>
/// <param name="entry">The entry.</param>
/// <param name="context">The context.</param>
/// <param name="log">The log.</param>
/// <returns></returns>
public override double Score(DocumentSelectResultEntry entry, DocumentSelectResult context, ILogBuilder log)
{
Double score = 0;
WebSiteGraph webSiteGraph = context.domainNameToGraph[entry.DomainID]; // GraphRegistry[entry.DomainID];
freeGraphNodeAndLinks outLinks = webSiteGraph.GetLinks(entry.AssignedID, true, false);
freeGraphNodeAndLinks inLinks = webSiteGraph.GetLinks(entry.AssignedID, false, true);
if (functionFlags.HasFlag(GraphFactorFunctionEnum.count_outbound))
{
score += outLinks.Count;
}
if (functionFlags.HasFlag(GraphFactorFunctionEnum.count_inbound))
{
score += inLinks.Count;
}
if (score == 0)
{
return(score);
}
if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_graphlinks))
{
score = score / webSiteGraph.CountLinks();
}
if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_graphnodes))
{
score = score / webSiteGraph.CountNodes();
}
if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_inbound))
{
score = score / inLinks.Count;
}
if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_outbound))
{
score = score / outLinks.Count;
}
if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_linkCount))
{
score = score / (inLinks.Count + outLinks.Count);
}
return(score);
}
internal void AddOrUpdateNode(freeGraphNodeBase node, freeGraphLink link, freeGraphNodeAndLinks links, Boolean typeToMin, lemmaExpansionOptions options)
{
if (ContainsNode(node.name, true))
{
var nd = GetNode(node.name, true);
if (options.HasFlag(lemmaExpansionOptions.divideWeightByNumberOfSynonims))
{
nd.weight = nd.weight + (node.weight.GetRatio(links.linkedNodeClones.Count));
}
else if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceThatIsSumOfLinkWeights))
{
nd.weight = nd.weight + node.weight.GetRatio(node.distance);
if (nd.distance > 1)
{
nd.distance = Math.Min(nd.distance, node.distance + link.linkBase.weight);
}
else
{
nd.distance = node.distance + link.linkBase.weight;
}
}
else
{
nd.weight = nd.weight + node.weight;
}
if (typeToMin)
{
nd.type = Math.Min(nd.type, node.type);
}
else
{
nd.type = Math.Max(nd.type, node.type);
}
}
else
{
if (options.HasFlag(lemmaExpansionOptions.divideWeightByNumberOfSynonims))
{
AddNode(node.name, node.weight.GetRatio(links.linkedNodeClones.Count), node.type);
}
else if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceThatIsSumOfLinkWeights))
{
AddNode(node.name, node.weight.GetRatio(node.distance), node.type).distance = node.distance + link.linkBase.weight;
}
else
{
AddNode(node.name, node.weight, node.type);
}
}
}
public freeGraphTypedResultSet <IObjectWithNameWeightAndType> GetLinked(TNode node)
{
freeGraphTypedResultSet <IObjectWithNameWeightAndType> output = new freeGraphTypedResultSet <IObjectWithNameWeightAndType>();
freeGraphNodeAndLinks res = graph.GetLinks(GetID(node), true);
foreach (var r in res)
{
var n = new freeGraphTypedResultEntry <IObjectWithNameWeightAndType>(r.linkBase);
n.TNodeA = source[t][r.nodeA.name];
n.TNodeB = source[t][r.nodeB.name];
output.Add(n);
}
return(output);
}
public freeGraphTypedResultSet <TNodeB> GetLinkedNodesOfType <TNodeB>(TNode node) where TNodeB : IObjectWithNameWeightAndType
{
freeGraphTypedResultSet <TNodeB> output = new freeGraphTypedResultSet <TNodeB>();
Type t_B = typeof(TNodeB);
Type t_A = typeof(TNode);
freeGraphNodeAndLinks res = graph.GetLinks(GetID(node), true);
foreach (freeGraphLink r in res)
{
var n = new freeGraphTypedResultEntry <TNodeB>(r.linkBase);
n.TNodeA = (TNodeB)source[t_A][r.nodeA.name];
n.TNodeB = (TNodeB)source[t_B][r.nodeB.name];
output.Add(n);
}
return(output);
}
/// <summary>
/// Returns expanded cloud from given lemma list - only for matched lemmas
/// </summary>
/// <param name="lemmas">The lemmas.</param>
/// <param name="expansionSteps">The expansion steps.</param>
/// <param name="options">The options.</param>
/// <param name="typeToMin">todo: describe typeToMin parameter on ExpandTermsToCloud</param>
/// <returns></returns>
public lemmaSemanticCloud ExpandTermsToCloud(IEnumerable <String> lemmas, Int32 expansionSteps, Boolean typeToMin = true, lemmaExpansionOptions options = lemmaExpansionOptions.initialWeightFromParent | lemmaExpansionOptions.weightAsSemanticDistanceFromParent)
{
lemmaSemanticCloud output = new lemmaSemanticCloud();
output.name = name + "_subset_exp" + expansionSteps;
output.DisableCheck = true;
StringBuilder sb = new StringBuilder();
sb.Append("Subset expanded from matched query lemmas [");
List <String> nextTerms = new List <string>();
List <String> allTerms = new List <string>();
foreach (String t in lemmas)
{
if (ContainsNode(t))
{
sb.Append(t + " ");
var l = GetNode(t);
output.AddNode(l.name, l.weight, 0).distance = 1;
nextTerms.Add(t);
allTerms.Add(t);
}
}
sb.Append("] using cloud [" + name + "]");
output.description = sb.ToString();
Int32 exp_i = 1;
while (nextTerms.Any())
{
List <String> newNextTerms = new List <string>();
foreach (String t in nextTerms)
{
freeGraphNodeAndLinks links = new freeGraphNodeAndLinks();
if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceFromParent))
{
links = GetLinks(t, true, false, 1.GetRatio(exp_i), exp_i, true, options.HasFlag(lemmaExpansionOptions.initialWeightFromParent));
}
else if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceThatIsSumOfLinkWeights))
{
var nd = output.GetNode(t, true);
links = GetLinks(t, true, false, 1, exp_i, true, options.HasFlag(lemmaExpansionOptions.initialWeightFromParent));
}
else
{
links = GetLinks(t, true, false, 1, exp_i, true, options.HasFlag(lemmaExpansionOptions.initialWeightFromParent));
}
foreach (freeGraphLink link in links)
{
if (!allTerms.Contains(link.nodeA.name))
{
newNextTerms.Add(link.nodeA.name);
allTerms.Add(link.nodeA.name);
}
if (link.nodeA.name != t)
{
output.AddOrUpdateNode(link.nodeA, link, links, typeToMin, options);
}
if (!allTerms.Contains(link.nodeB.name))
{
newNextTerms.Add(link.nodeB.name);
allTerms.Add(link.nodeB.name);
}
if (link.nodeB.name != t)
{
output.AddOrUpdateNode(link.nodeB, link, links, typeToMin, options);
}
}
foreach (freeGraphLink link in links)
{
if (!output.ContainsLink(link.linkBase.nodeNameA, link.linkBase.nodeNameB))
{
output.AddLink(link.linkBase.nodeNameA, link.linkBase.nodeNameB, Math.Max(link.linkBase.weight, 1), link.linkBase.type);
//var nd = output.GetNode(link.nodeB.name);
//nd.weight = nd.weight + (link.nodeB.weight.GetRatio(links.linkedNodeClones.Count));
//nd.type = Math.Max(nd.type, link.nodeB.type);
}
else
{
var lnk = output.GetLink(link.linkBase.nodeNameA, link.linkBase.nodeNameB);
lnk.weight += link.linkBase.weight;
if (typeToMin)
{
lnk.type = Math.Min(link.linkBase.type, lnk.type);
}
else
{
lnk.type = Math.Max(link.linkBase.type, lnk.type);
}
}
}
}
nextTerms = newNextTerms;
exp_i++;
if (exp_i > expansionSteps)
{
break;
}
}
output.DisableCheck = false;
output.RebuildIndex();
return(output);
}
