Example #1
0
        static public void WeightedSetTest()
        {
            System.Random r = new System.Random(600);

            WeightedSet <char> set = new WeightedSet <char>().Add('a', 3).Add('b', 4).Add('c', 5).Add('d', 6);

            set.Remove('b');

            Assert.AreEqual(0, set.GetWeight('b'));
            Assert.AreEqual(5, set.GetWeight('c'));

            set.SetWeight('c', 7);
            Assert.AreEqual(7, set.GetWeight('c'));

            float newWeight = set.ChangeWeight('d', -10);

            Assert.AreEqual(0, newWeight);
            Assert.AreEqual(0, set.GetWeight('d'));

            set.ChangeWeight('d', 15);
            Assert.AreEqual(15, set.GetWeight('d'));

            set.ChangeWeight('a', 10);
            Assert.AreEqual(13, set.GetWeight('a'));

            int a = 0, b = 0, c = 0, d = 0;

            int iter = 100000;

            for (int i = 0; i < iter; ++i)
            {
                switch (r.Choose(set))
                {
                case 'a':
                    ++a;
                    break;

                case 'b':
                    ++b;
                    break;

                case 'c':
                    ++c;
                    break;

                case 'd':
                    ++d;
                    break;
                }
            }

            Debug.LogFormat("a={0}%, b={1}%, c={2}%, d={3}%, ({4} samples)",
                            100f * a / iter,
                            100f * b / iter,
                            100f * c / iter,
                            100f * d / iter,
                            iter);
        }
Example #2
0
        public static int[][] RandomTree_Edges(Random rnd, int verticesCount, int maxChildCount, bool doPermutation = true)
        {
            var vertices = new int[verticesCount];

            for (var i = 0; i < verticesCount; i++)
            {
                vertices[i] = i;
            }

            var edges = new List <int[]>();

            var childCount = new int[verticesCount];

            var added = new WeightedSet <int>();

            added.Add(0, 1d);

            for (var i = 1; i < verticesCount; i++)
            {
                if (added.Count == 0)
                {
                    break;
                }

                var parent = added.RandomElement(rnd);

                edges.Add(new[] { parent, i });
                childCount[parent]++;

                added.Add(i, 1d);
                added.MultiplyWeight(parent, 0.5);

                if (childCount[parent] == maxChildCount)
                {
                    added.Remove(parent);
                }
            }

            if (doPermutation)
            {
                var permutation = vertices.ToArray().Shuffle(rnd);
                foreach (var edge in edges)
                {
                    edge[0] = permutation[edge[0]];
                    edge[1] = permutation[edge[1]];
                }
            }

            return(edges.ToArray());
        }