Beispiel #1
0
 public NodeView(IComputedLengthNode <T> node, uint xlen, uint ylen, uint zlen)
 {
     this.node    = node;
     this.xLength = xlen;
     this.yLength = ylen;
     this.zLength = zlen;
 }
        public int GetHashCode(IComputedLengthNode <T> node)
        {
            NodeType nt = node.Type;

            if (nt == NodeType.Leaf)
            {
                var comparer = EqualityComparer <T> .Default;

                return(comparer.GetHashCode(node.Get(1, 1, 1, 0, 0, 0)));
            }
            else
            {
                unchecked
                {
                    int d = 31 * RuntimeHelpers.GetHashCode(node.Left) + 53 * RuntimeHelpers.GetHashCode(node.Right);

                    if (nt == NodeType.X)
                    {
                        return(67 * d);
                    }
                    else if (nt == NodeType.Y)
                    {
                        return(89 * d);
                    }
                    else
                    {
                        return(113 * d);
                    }
                }
            }
        }
        public override IComputedLengthNode <T> Get(Dimension dim, IComputedLengthNode <T> left, IComputedLengthNode <T> right)
        {
            if ((left.Type == NodeType.Leaf) && (right.Type == NodeType.Leaf))
            {
                // Both children are leaf nodes
                var comparer = EqualityComparer <T> .Default;

                var leftItem  = left.Get(1, 1, 1, 0, 0, 0);
                var rightItem = right.Get(1, 1, 1, 0, 0, 0);

                // Check if both leaf-children store the same value
                if (comparer.Equals(leftItem, rightItem))
                {
                    // They store the same value, this node and its children should be merged into one leaf node.
                    // Since the leaf nodes only store the value, we can just return either one of the children and have the same effect.
                    return(left);
                }
            }

            IComputedLengthNode <T> test = Create(dim, left, right);

            IComputedLengthNode <T> node;

            if (nodes.TryGetValue(test, out node))
            {
                return(node);
            }
            else
            {
                Cache(test);
                return(test);
            }
        }
        public override IComputedLengthNode <T> Get(Dimension dim, IComputedLengthNode <T> left, IComputedLengthNode <T> right)
        {
            if ((left.Type == NodeType.Leaf) && (right.Type == NodeType.Leaf))
            {
                // Both children are leaf nodes
                var comparer = EqualityComparer <T> .Default;

                var leftItem  = left.Get(1, 1, 1, 0, 0, 0);
                var rightItem = right.Get(1, 1, 1, 0, 0, 0);

                // Check if both leaf-children store the same value
                if (comparer.Equals(leftItem, rightItem))
                {
                    // They store the same value, this node and its children should be merged into one leaf node.
                    // Since the leaf nodes only store the value, we can just return either one of the children and have the same effect.
                    return(left);
                }
            }

            if (dim == Dimension.X)
            {
                return(new XNode <T>(left, right));
            }
            else if (dim == Dimension.Y)
            {
                return(new YNode <T>(left, right));
            }
            else
            {
                return(new ZNode <T>(left, right));
            }
        }
 public bool IsCached(IComputedLengthNode <T> node)
 {
     if (node.Type == NodeType.Leaf)
     {
         return(leaves.ContainsKey(node.Get(1, 1, 1, 0, 0, 0)));
     }
     else
     {
         return(heights.ContainsKey(node));
     }
 }
 private int GetHeight(IComputedLengthNode <T> node)
 {
     if (node.Type == NodeType.Leaf)
     {
         return(0);
     }
     else
     {
         return(heights[node]);
     }
 }
Beispiel #7
0
 // Create a new node split along the longest axis with leaf children of this leaf node
 protected virtual IComputedLengthNode <T> Split(IComputedLengthNode <T> node, uint xlen, uint ylen, uint zlen)
 {
     if (xlen >= ylen && xlen >= zlen)
     {
         return(new XNode <T>(node, node));
     }
     else if (ylen >= xlen && ylen >= zlen)
     {
         return(new YNode <T>(node, node));
     }
     else
     {
         return(new ZNode <T>(node, node));
     }
 }
Beispiel #8
0
 protected virtual IComputedLengthNode <T> Create(Dimension dim, IComputedLengthNode <T> left, IComputedLengthNode <T> right)
 {
     if (dim == Dimension.X)
     {
         return(new XNode <T>(left, right));
     }
     else if (dim == Dimension.Y)
     {
         return(new YNode <T>(left, right));
     }
     else
     {
         return(new ZNode <T>(left, right));
     }
 }
        public bool Equals(IComputedLengthNode <T> x, IComputedLengthNode <T> y)
        {
            if (x.Type == y.Type)
            {
                if (x.Type == NodeType.Leaf)
                {
                    var comparer = EqualityComparer <T> .Default;

                    var xItem = x.Get(1, 1, 1, 0, 0, 0);
                    var yItem = y.Get(1, 1, 1, 0, 0, 0);

                    return(comparer.Equals(xItem, yItem));
                }
                else
                {
                    return(object.ReferenceEquals(x.Left, y.Left) && object.ReferenceEquals(x.Right, y.Right));
                }
            }
            else
            {
                return(false);
            }
        }
        private void Cache(IComputedLengthNode <T> node)
        {
            if (node.Type == NodeType.Leaf)
            {
                T item = node.Get(1, 1, 1, 0, 0, 0);
                leaves[item] = node;
            }
            else
            {
                bool bothCached = IsCached(node.Left) && IsCached(node.Right);

                if (bothCached)
                {
                    int newHeight = Math.Max(GetHeight(node.Left), GetHeight(node.Right)) + 1;

                    if (newHeight <= maxHeight)
                    {
                        nodes[node]   = node;
                        heights[node] = newHeight;
                    }
                }
            }
        }
Beispiel #11
0
 public YNode(IComputedLengthNode <T> left, IComputedLengthNode <T> right)
 {
     this.left  = left;
     this.right = right;
 }
Beispiel #12
0
        public INode <T> Get(T item, uint xlen, uint ylen, uint zlen)
        {
            IComputedLengthNode <T> node = this.simpleFactory.Get(item);

            return(new NodeView <T>(node, xlen, ylen, zlen));
        }
Beispiel #13
0
        // Return a new tree with {item} set at the specified position
        public virtual IComputedLengthNode <T> WithSet(IComputedLengthNode <T> node, uint xlen, uint ylen, uint zlen, uint x, uint y, uint z, T item)
        {
            NodeType type = node.Type;

            if (type == NodeType.Leaf)
            {
                var comparer = EqualityComparer <T> .Default;
                var nodeItem = node.Get(1, 1, 1, 0, 0, 0);

                if (comparer.Equals(nodeItem, item))
                {
                    // Trying to set the item to the same thing
                    return(node);
                }
                else if (xlen == 1 && ylen == 1 && zlen == 1)
                {
                    // We have exactly one position, set the new value
                    return(this.Get(item));
                }
                else
                {
                    // We need to set a new value somewhere in this node.  Split this leaf node and keep trying to find a spot
                    var splitNode = this.Split(node, xlen, ylen, zlen);
                    return(this.WithSet(splitNode, xlen, ylen, zlen, x, y, z, item));
                }
            }
            else
            {
                var left  = node.Left;
                var right = node.Right;

                var nl = left;
                var nr = right;

                uint leftLen  = node.LeftLength(xlen, ylen, zlen);
                uint rightLen = node.RightLength(xlen, ylen, zlen);

                Dimension dimension;

                if (type == NodeType.X)
                {
                    dimension = Dimension.X;

                    if (x < leftLen)
                    {
                        nl = this.WithSet(left, leftLen, ylen, zlen, x, y, z, item);
                    }
                    else
                    {
                        nr = this.WithSet(right, rightLen, ylen, zlen, x - leftLen, y, z, item);
                    }
                }
                else if (type == NodeType.Y)
                {
                    dimension = Dimension.Y;

                    if (y < leftLen)
                    {
                        nl = this.WithSet(left, xlen, leftLen, zlen, x, y, z, item);
                    }
                    else
                    {
                        nr = this.WithSet(right, xlen, rightLen, zlen, x, y - leftLen, z, item);
                    }
                }
                else
                {
                    dimension = Dimension.Z;

                    if (z < leftLen)
                    {
                        nl = this.WithSet(left, xlen, ylen, leftLen, x, y, z, item);
                    }
                    else
                    {
                        nr = this.WithSet(right, xlen, ylen, rightLen, x, y, z - leftLen, item);
                    }
                }

                if (object.ReferenceEquals(nl, left) && object.ReferenceEquals(nr, right))
                {
                    // There was no change
                    return(node);
                }

                // One of the children changed, transfer the changes up the tree
                return(this.Get(dimension, nl, nr));
            }
        }
Beispiel #14
0
 public abstract IComputedLengthNode <T> Get(Dimension dim, IComputedLengthNode <T> left, IComputedLengthNode <T> right);