private List <MBRModel <DataPoint> > expand(MBRModel <DataPoint> entries)
{
List <MBRModel <DataPoint> > result = new List <MBRModel <DataPoint> >();
result.AddRange(getChildBoundsAndPoints(entries));
return(result);
}
public double getScore(DataPoint point, MBRModel <WeightVector> mv)
{
double totalScore = 0;
totalScore = lv(mv, point);
return(totalScore);
}
private HashSet <MBRModel <WeightVector> > expand(MBRModel <WeightVector> e)
{
HashSet <MBRModel <WeightVector> > result = new HashSet <MBRModel <WeightVector> >();
foreach (var item in getChildBoundsAndPoints(e))
{
result.Add(item);
}
return(result);
}
public MBRModel <DataPoint> getPoint(Rectangle rectangle, bool isRetangle, Node <DataPoint> node)
{
MBRModel <DataPoint> result = new MBRModel <DataPoint>(new DataPoint(rectangle.min[0], rectangle.min[1]), new DataPoint(rectangle.max[0], rectangle.max[1]), node);
if (!isRetangle)
{
if (isDataPoint(result))
{
return(result);
}
return(null);
}
else
{
return(result);
}
}
public double IteratePoint(List <Rectangle> points, bool isMin, MBRModel <WeightVector> mv)
{
List <double> pointsScore = new List <double>();
foreach (var item in points)
{
if (item != null)
{
pointsScore.Add(getScore(new DataPoint(item), mv));
}
}
if (isMin)
{
return(pointsScore.Min());
}
else
{
return(pointsScore.Max());
}
}
public KeyValuePair <int, HashSet <WeightVector> > BBR(DataPoint data, int rank)
{
MBRModel <WeightVector> mbr = getRoot();
MBRModel <DataPoint> entries = intopkController.getRoot();
Queue <MBRModel <WeightVector> > heapW = new Queue <MBRModel <WeightVector> >();
HashSet <WeightVector> result = new HashSet <WeightVector>();
heapW.Enqueue(mbr);
int i, count = 0;
var watch = System.Diagnostics.Stopwatch.StartNew();
while (heapW.Count > 0)
{
MBRModel <WeightVector> e = heapW.Dequeue();
//TODO wating for Q to implement INTOPK, right now will create random result
i = intopkController.IntopK(entries, e, data, rank);
count++;
if (i == 0)
{
foreach (var item in expand(e))
{
heapW.Enqueue(item);
}
}
else
{
if (i == 1)
{
foreach (var item in expandAll(e))
{
result.Add(item);
}
}
}
}
return(new KeyValuePair <int, HashSet <WeightVector> >(count, result));
}
public double Iterate(Node <DataPoint> node, int depth, double alpha, double beta, bool isMin, MBRModel <WeightVector> mv)
{
//for leaf
if (node.isLeaf())
{
return(IteratePoint(node.entries.ToList(), !isMin, mv));
}
//for node
if (isMin == false)
{
foreach (Node <DataPoint> child in getChild(node))
{
alpha = Math.Max(alpha == Int32.MaxValue?Int32.MinValue:alpha, Iterate(child, depth - 1, alpha, beta, !isMin, mv));
if (beta < alpha)
{
break;
}
}
return(alpha);
}
else
{
foreach (Node <DataPoint> child in getChild(node))
{
beta = Math.Min(alpha == Int32.MinValue ? Int32.MaxValue : alpha, Iterate(child, depth - 1, alpha, beta, !isMin, mv));
if (beta < alpha)
{
break;
}
}
return(beta);
}
}
public static double lv(MBRModel <WeightVector> mv, DataPoint p)
{
return((double)(mv.lowerLeft.rating * p.rating) + (double)(mv.lowerLeft.star * p.star));
}
public static double uv(MBRModel <WeightVector> mv, DataPoint p)
{
return((double)(mv.upperRight.rating * p.rating) + (double)(mv.upperRight.star * p.star));
}
public List <MBRModel <DataPoint> > getChildBoundsAndPoints(MBRModel <DataPoint> entries)
{
HashSet <MBRModel <DataPoint> > result = new HashSet <MBRModel <DataPoint> >();
MBRModel <DataPoint> element = new MBRModel <DataPoint>();
Dictionary <int, Node <DataPoint> > node;
Dictionary <int, Node <DataPoint> > treeNode = tree.nodeMap;
//entries is root
if (tree.getBounds().Equals(new Rectangle((float)entries.lowerLeft.rating, (float)entries.lowerLeft.star, (float)entries.upperRight.rating, (float)entries.upperRight.star, 0, 0)))
{
node = treeNode;
}
//not root
else
{
if (!isDataPoint(entries))
{
node = new Dictionary <int, Node <DataPoint> >();
foreach (var nodeItem in treeNode)
{
if (nodeItem.Value.mbr.Equals(new Rectangle((float)entries.lowerLeft.rating, (float)entries.lowerLeft.star, (float)entries.upperRight.rating, (float)entries.upperRight.star, 0, 0)))
{
node.Add(0, nodeItem.Value);
break;
}
}
}
else
{
result.Add(entries);
return(result.ToList());
}
}
foreach (var item in node)
{
//add MBR
if (!item.Value.mbr.Equals(new Rectangle((float)entries.lowerLeft.rating, (float)entries.lowerLeft.star, (float)entries.upperRight.rating, (float)entries.upperRight.star, 0, 0)))
{
result.Add(getPoint(item.Value.mbr, true, item.Value));
}
}
if (result.Count == 0)
{
foreach (var item in node)
{
//add dataPoint
foreach (var child in item.Value.entries)
{
if (child != null)
{
element = getPoint(child, false, null);
if (element != null)
{
result.Add(element);
}
}
}
}
}
return(result.ToList());
}
public bool isDataPoint(MBRModel <WeightVector> point)
{
return(point.lowerLeft.rating == point.upperRight.rating && point.lowerLeft.star == point.upperRight.star);
}
public int IntopK(MBRModel <DataPoint> entries, MBRModel <WeightVector> mv, DataPoint q, int k)
{
//init value
int precincPoints = 0, precEntries = 0;
List <MBRModel <DataPoint> > C = new List <MBRModel <DataPoint> >();
Queue <MBRModel <DataPoint> > HeapS = new Queue <MBRModel <DataPoint> >();
if (uv(mv, q) > lv(mv, entries.lowerLeft))
{
HeapS.Enqueue(entries);
if (uv(mv, entries.upperRight) < lv(mv, q))
{
precEntries++;
}
}
//while heap not empty
while (HeapS.Count > 0)
{
entries = HeapS.Dequeue();
if (precincPoints >= k && lv(mv, entries.lowerLeft) >= lv(mv, q))
{
//if mv is single w
if (isDataPoint(mv))
{
return(-1);
}
else
{
return(0);
}
}
if (uv(mv, entries.upperRight) < lv(mv, q))
{
precEntries--;
}
//double test = treeHelper.Iterate(entries.node, entries.node.getLevel(), Int32.MinValue, Int32.MaxValue, entries.node.getLevel() % 2 != 0, mv);
//double uscore = uv(mv, q);
//if (test < uscore)
//{
C = expand(entries);
//}
foreach (MBRModel <DataPoint> ei in C)
{
if (uv(mv, q) > lv(mv, ei.lowerLeft))
{
if (uv(mv, ei.upperRight) < lv(mv, q))
{
precEntries++;
if (precEntries >= k)
{
return(-1);
}
}
if (isDataPoint(ei))
{
precincPoints++;
}
else
{
HeapS.Enqueue(ei);
}
}
}
}
if (precincPoints >= k)
{
return(0);
}
else
{
return(1);
}
}
private List <WeightVector> expandAll(MBRModel <WeightVector> e)
{
return(tree.Contains(new Rectangle((float)e.lowerLeft.rating, (float)e.lowerLeft.star, (float)e.upperRight.rating, (float)e.upperRight.star, 0, 0)));
}
public bool contains(MBRModel <WeightVector> e, MBRModel <WeightVector> MBR)
{
return(e.lowerLeft.star >= MBR.lowerLeft.star && e.upperRight.star <= MBR.upperRight.star && e.lowerLeft.rating >= MBR.lowerLeft.rating && e.upperRight.rating <= MBR.upperRight.rating);
}
