/// <summary>
        /// Searches for the closest points in a hyper-sphere around the given center.
        /// </summary>
        /// <param name="center">The center of the hyper-sphere</param>
        /// <param name="radius">The radius of the hyper-sphere</param>
        /// <param name="neighboors">The number of neighbors to return.</param>
        /// <returns>The specified number of closest points in the hyper-sphere</returns>
        public List <TDimension> NearestNeighborsRadial(TDimension center, double radius, int neighboors = -1)
        {
            var nearestNeighbors = new BoundedPriorityListCoordinate <int, double>(neighboors == -1 ? this.Count : neighboors, false);
            var rect             = HyperRectCoordinate <TDimension> .Infinite(this.Dimensions, this.MaxValue, this.MinValue);

            this.SearchForNearestNeighbors(0, center, rect, 0, nearestNeighbors, radius);

            return(nearestNeighbors.ToResultSetRadial(this, neighboors));
        }
        /// <summary>
        /// Finds the nearest neighbors in the <see cref="KDTreeCoordinate{TDimension}"/> of the given <paramref name="point"/>.
        /// </summary>
        /// <param name="targetPoint">The point whose neighbors we search for.</param>
        /// <param name="neighbors">The number of neighbors to look for.</param>
        /// <returns>The</returns>
        public List <TDimension> NearestNeighborsLinear(TDimension targetPoint, int neighbors)
        {
            var nearestNeighbors = new BoundedPriorityListCoordinate <int, double>(neighbors, true);
            var rect             = HyperRectCoordinate <TDimension> .Infinite(this.Dimensions, this.MaxValue, this.MinValue);

            this.SearchForNearestNeighbors(0, targetPoint, rect, 0, nearestNeighbors, double.MaxValue);

            return(nearestNeighbors.ToResultSet(this));
        }
        public static List <TDimension> ToResultSet <TPriority, TDimension>(this BoundedPriorityListCoordinate <int, TPriority> listCoordinate, KDTreeCoordinate <TDimension> treeCoordinate)
            where TDimension : IComparable <TDimension>, ICoordinate, new() where TPriority : IComparable <TPriority>
        {
            var array = new List <TDimension>();

            for (var i = 0; i < listCoordinate.Count; i++)
            {
                array.Add(treeCoordinate.InternalTreeOfPoints[listCoordinate[i]]);
                treeCoordinate.InternalTreeOfPoints[listCoordinate[i]].Used = true;
            }

            return(array);
        }
        public static List <TDimension> ToResultSetRadial <TPriority, TDimension>(this BoundedPriorityListCoordinate <int, TPriority> listCoordinate, KDTreeCoordinate <TDimension> treeCoordinate, int pointsPerCluster)
            where TDimension : IComparable <TDimension>, ICoordinate, new() where TPriority : IComparable <TPriority>
        {
            if (listCoordinate.Count < pointsPerCluster)
            {
                return(null);
            }

            var clusterOfCoordinates = new List <TDimension>();

            foreach (int t in listCoordinate)
            {
                clusterOfCoordinates.Add(treeCoordinate.InternalTreeOfPoints[t]);
                treeCoordinate.InternalTreeOfPoints[t].Used = true;
            }

            return(clusterOfCoordinates);
        }
        /// <summary>
        /// A top-down recursive method to find the nearest neighbors of a given point.
        /// </summary>
        /// <param name="nodeIndex">The index of the node for the current recursion branch.</param>
        /// <param name="target">The point whose neighbors we are trying to find.</param>
        /// <param name="rectCoordinate">The <see cref="HyperRectCoordinate{TDimension}"/> containing the possible nearest neighbors.</param>
        /// <param name="dimension">The current splitting dimension for this recursion branch.</param>
        /// <param name="nearestNeighbors">The <see cref="BoundedPriorityListCoordinate{TElement,TPriority}"/> containing the nearest neighbors already discovered.</param>
        /// <param name="maxSearchRadiusSquared">The squared radius of the current largest distance to search from the <paramref name="target"/></param>
        private void SearchForNearestNeighbors(
            int nodeIndex,
            TDimension target,
            HyperRectCoordinate <TDimension> rectCoordinate,
            int dimension,
            BoundedPriorityListCoordinate <int, double> nearestNeighbors,
            double maxSearchRadiusSquared)
        {
            if (this.InternalTreeOfPoints.Length <= nodeIndex || nodeIndex < 0 || this.InternalTreeOfPoints[nodeIndex] == null)
            {
                return;
            }

            // Work out the current dimension
            var dim = dimension % this.Dimensions;

            var leftRect = rectCoordinate.Clone();

            var rightRect = rectCoordinate.Clone();

            if (dim == 0)
            {
                leftRect.MaxPoint.Latitude  = this.InternalTreeOfPoints[nodeIndex].Latitude;
                rightRect.MinPoint.Latitude = this.InternalTreeOfPoints[nodeIndex].Latitude;
            }
            if (dim == 1)
            {
                leftRect.MaxPoint.Longitude  = this.InternalTreeOfPoints[nodeIndex].Longitude;
                rightRect.MinPoint.Longitude = this.InternalTreeOfPoints[nodeIndex].Longitude;
            }

            // Determine which side the target resides in
            var compare = dim == 0 ? target.Latitude.CompareTo(this.InternalTreeOfPoints[nodeIndex].Latitude)
                                   : target.Longitude.CompareTo(this.InternalTreeOfPoints[nodeIndex].Longitude);

            var nearerRect  = compare <= 0 ? leftRect : rightRect;
            var furtherRect = compare <= 0 ? rightRect : leftRect;

            var nearerNode  = compare <= 0 ? BinaryTreeNavigationCoordinate.LeftChildIndex(nodeIndex) : BinaryTreeNavigationCoordinate.RightChildIndex(nodeIndex);
            var furtherNode = compare <= 0 ? BinaryTreeNavigationCoordinate.RightChildIndex(nodeIndex) : BinaryTreeNavigationCoordinate.LeftChildIndex(nodeIndex);

            // Move down into the nearer branch
            this.SearchForNearestNeighbors(
                nearerNode,
                target,
                nearerRect,
                dimension + 1,
                nearestNeighbors,
                maxSearchRadiusSquared);

            // Walk down into the further branch but only if our capacity hasn't been reached
            // OR if there's a region in the further rectangle that's closer to the target than our
            // current furtherest nearest neighbor
            var closestPointInFurtherRect = furtherRect.GetClosestPoint(target);
            var distanceSquaredToTarget   = this.Metric(closestPointInFurtherRect, target);

            if (distanceSquaredToTarget.CompareTo(maxSearchRadiusSquared) <= 0)
            {
                if (nearestNeighbors.IsFull)
                {
                    if (distanceSquaredToTarget.CompareTo(nearestNeighbors.MaxPriority) < 0)
                    {
                        this.SearchForNearestNeighbors(
                            furtherNode,
                            target,
                            furtherRect,
                            dimension + 1,
                            nearestNeighbors,
                            maxSearchRadiusSquared);
                    }
                }
                else
                {
                    this.SearchForNearestNeighbors(
                        furtherNode,
                        target,
                        furtherRect,
                        dimension + 1,
                        nearestNeighbors,
                        maxSearchRadiusSquared);
                }
            }

            // Try to add the current node to our nearest neighbors list
            distanceSquaredToTarget = this.Metric(this.InternalTreeOfPoints[nodeIndex], target);
            if (distanceSquaredToTarget.CompareTo(maxSearchRadiusSquared) <= 0 && this.InternalTreeOfPoints[nodeIndex].Used == false)
            {
                nearestNeighbors.Add(nodeIndex, distanceSquaredToTarget);
            }
        }