public void ClusterTest()
        {
            var points3D = new List <IPointIdFloat>()
            {
                new PointIdFloat(new List <float>()
                {
                    1, 2, 55
                }),
                new PointIdFloat(new List <float>()
                {
                    0, 1, 0.1f
                }),
                new PointIdFloat(new List <float>()
                {
                    3, 3, 0.01f
                }),
                new PointIdFloat(new List <float>()
                {
                    1.5f, 2, -0.03f
                }),
                new PointIdFloat(new List <float>()
                {
                    5, -1, 44
                }),
                new PointIdFloat(new List <float>()
                {
                    15, -51, 73
                }),
                new PointIdFloat(new List <float>()
                {
                    0.5f, -21, 144
                })
            };

            PointIdFloat.SetIds(points3D);
            var ids = points3D.Select(p => p.id).ToList();

            ids.Sort();

            var epsilon      = 100;
            var epsilonPrime = 10;
            var minPoints    = 3;

            Optics algo  = new Optics(points3D);
            var    seeds = new PriorityQueue <float, IPointIdFloat>();

            OpticsOrdering oo      = algo.Ordering(epsilon, minPoints);
            var            results = oo.Cluster(epsilonPrime);

            Assert.AreEqual(points3D.Count, results.Count);
            var keys = results.Keys.ToList();

            keys.Sort();
            Assert.IsTrue(keys.SequenceEqual(ids));
        }
        public void OrderingTest()
        {
            IReadOnlyDictionary <long, long>    orderingMapping;
            IReadOnlyCollection <IPointIdFloat> ordering;

            var points3D = new List <IPointIdFloat>()
            {
                new PointIdFloat(new List <float>()
                {
                    1, 2, 55
                }),
                new PointIdFloat(new List <float>()
                {
                    0, 1, 0.1f
                }),
                new PointIdFloat(new List <float>()
                {
                    3, 3, 0.01f
                }),
                new PointIdFloat(new List <float>()
                {
                    1.5f, 2, -0.03f
                }),
                new PointIdFloat(new List <float>()
                {
                    5, -1, 44
                }),
                new PointIdFloat(new List <float>()
                {
                    15, -51, 73
                }),
                new PointIdFloat(new List <float>()
                {
                    0.5f, -21, 144
                })
            };

            PointIdFloat.SetIds(points3D);
            var epsilon   = 10;
            var minPoints = 3;

            Optics algo  = new Optics(points3D);
            var    seeds = new PriorityQueue <float, IPointIdFloat>();

            OpticsOrdering oo = algo.Ordering(epsilon, minPoints);

            ordering        = oo.ordering;
            orderingMapping = oo.orderingMapping;

            Assert.AreEqual(points3D.Count, ordering.Count);
            Assert.IsTrue(SequenceEquivalent(points3D, ordering.ToList(), PointIdFloat.PointsComparison));
            Assert.AreEqual(points3D.Count, orderingMapping.Count);

            for (long i = 0; i < orderingMapping.Count; i++)
            {
                Assert.IsTrue(orderingMapping.Values.Contains(i));
            }
            foreach (var p in points3D)
            {
                Assert.IsTrue(orderingMapping.ContainsKey(p.id));
            }
            Assert.IsTrue(oo.reachabilityDistances.Count > 0);
            foreach (var p in points3D)
            {
                Assert.IsTrue(oo.coreDistancesCache.ContainsKey(p.id));
            }
        }