private HashList <T> RangeTraversal(IHashItem query, int range, Node <T> tNode, HashList <T> results)
{
if (tNode != null)
{
int sortdistance = query.CalculateDistance(tNode.HashItem);
if (sortdistance < range)
{
results.Add(tNode.HashItem);
tNode.HashItem.SortDistance = sortdistance;
}
if (sortdistance + range < tNode.Distance)
{
RangeTraversal(query, range, tNode.Left, results);
}
else if (sortdistance - range > tNode.Distance)
{
RangeTraversal(query, range, tNode.Right, results);
}
else
{
RangeTraversal(query, range, tNode.Left, results);
RangeTraversal(query, range, tNode.Right, results);
}
}
return(results);
}
public int CalculateDistance(IHashItem dist)
{
ulong x = ((Hash256Item <T>)dist).Hash1 ^ Hash1;
ulong y = ((Hash256Item <T>)dist).Hash2 ^ Hash2;
ulong u = ((Hash256Item <T>)dist).Hash3 ^ Hash3;
ulong v = ((Hash256Item <T>)dist).Hash4 ^ Hash4;
ulong m1 = 0x5555555555555555;
ulong m2 = 0x3333333333333333;
ulong m3 = 0x0F0F0F0F0F0F0F0F;
ulong m4 = 0x000000FF000000FF;
x = x - ((x >> 1) & m1);
y = y - ((y >> 1) & m1);
u = u - ((u >> 1) & m1);
v = v - ((v >> 1) & m1);
x = (x & m2) + ((x >> 2) & m2);
y = (y & m2) + ((y >> 2) & m2);
u = (u & m2) + ((u >> 2) & m2);
v = (v & m2) + ((v >> 2) & m2);
x = x + y;
u = u + v;
x = (x & m3) + ((x >> 4) & m3);
u = (u & m3) + ((u >> 4) & m3);
x = x + u;
x = x + (x >> 8);
x = x + (x >> 16);
x = x & m4;
x = x + (x >> 32);
return((int)(x & 0x000001FF));
}
private Node AddNode(int begin, int end)
{
if (begin == end)
{
return(null);
}
Node node = new Node();
node.HashItem = _items[begin];
if (end - begin > 1)
{
int i = generator.Next(end - begin) + begin;
IHashItem tmp = _items[begin];
_items[begin] = _items[i];
_items[i] = tmp;
int median = (end + begin) / 2;
node.HashItem = _items[begin];
CalculateDistances(node, begin + 1, end);
OrderDistances(begin + 1, end);
node.Distance = _items[begin].CalculateDistance(_items[median]);
node.Left = AddNode(begin + 1, median);
node.Right = AddNode(median, end);
}
return(node);
}
public virtual HashList Range(IHashItem query, int range)
{
HashList r = RangeTraversal(query, range, Root, new HashList());
r.CustomSort(0, r.Count - 1);
return(r);
}
public void Add(IHashItem item)
{
if (_root == null)
{
_root = new Node(item);
return;
}
var curNode = _root;
var dist = curNode.HashItem.CalculateDistance(item);
while (curNode.ContainsKey(dist))
{
if (dist == 0)
{
return;
}
curNode = curNode[dist];
dist = curNode.HashItem.CalculateDistance(item);
}
curNode.AddChild(dist, item);
}
public void AddChild(int key, IHashItem item)
{
if (Children == null)
{
Children = new HybridDictionary();
}
Children[key] = new Node(item);
}
public HashList Range(IHashItem item, int d)
{
HashList rtn = new HashList();
RecursiveSearch(_root, rtn, item, d);
rtn.CustomSort(0, rtn.Count - 1);
return(rtn);
}
public int CalculateDistance(IHashItem dist)
{
ulong x = ((Hash64Item)dist).Hash ^ Hash;
x -= (x >> 1) & 0x5555555555555555;
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f;
x += x >> 8;
x += x >> 16;
x += x >> 32;
return((int)(x & 0x7f));
}
private void RecursiveSearch(Node node, HashList rtn, IHashItem item, int d)
{
var curDist = node.HashItem.CalculateDistance(item);
var minDist = curDist - d;
var maxDist = curDist + d;
if (curDist <= d)
{
rtn.Add(node.HashItem);
}
foreach (var key in node.Keys.Cast <int>().Where(key => minDist <= key && key <= maxDist))
{
RecursiveSearch(node[key], rtn, item, d);
}
}
public int CalculateDistance(IHashItem dist)
{
Hash256LookUpItem l = (Hash256LookUpItem)dist;
int val = Table[l.Hashes[0] ^ Hashes[0]];
val += Table[l.Hashes[1] ^ Hashes[1]];
val += Table[l.Hashes[2] ^ Hashes[2]];
val += Table[l.Hashes[3] ^ Hashes[3]];
val += Table[l.Hashes[4] ^ Hashes[4]];
val += Table[l.Hashes[5] ^ Hashes[5]];
val += Table[l.Hashes[6] ^ Hashes[6]];
val += Table[l.Hashes[7] ^ Hashes[7]];
val += Table[l.Hashes[8] ^ Hashes[8]];
val += Table[l.Hashes[9] ^ Hashes[9]];
val += Table[l.Hashes[10] ^ Hashes[10]];
val += Table[l.Hashes[11] ^ Hashes[11]];
val += Table[l.Hashes[12] ^ Hashes[12]];
val += Table[l.Hashes[13] ^ Hashes[13]];
val += Table[l.Hashes[14] ^ Hashes[14]];
val += Table[l.Hashes[15] ^ Hashes[15]];
return(val);
}
public Node(IHashItem item)
{
HashItem = item;
}
