public void TestBalanced()
        {
            var frequency = new MutableIntFrequency();
            frequency.DefaultValue = 0.0000001;
            frequency.Set(new IntArrow<double>(1, 520.0));
            frequency.Set(new IntArrow<double>(2, 49, 3.0));
            frequency.Set(new IntArrow<double>(50, 236.0));
            frequency.Set(new IntArrow<double>(51, 100, 2.0));

            const int DefaultValue = -1;
            var elementToAction = new MutableIntMap<int>();
            elementToAction.DefaultValue = DefaultValue;
            elementToAction.Set(new IntArrow<int>(1, 1));
            elementToAction.Set(new IntArrow<int>(2, 49, 2));
            elementToAction.Set(new IntArrow<int>(50, 3));
            elementToAction.Set(new IntArrow<int>(51, 100, 4));

            var target = new DecisionTreeBuilder(platformInfo);
            var bounds = new IntInterval(int.MinValue, int.MaxValue);
            var node = target.Build(elementToAction, bounds, frequency);
            PrintProgram(node, target.DefaultActionDecision);

            Assert.AreEqual(-1, node.Decide(int.MinValue) );
            Assert.AreEqual(-1, node.Decide(0) );
            Assert.AreEqual(1, node.Decide(1) );
            Assert.AreEqual(2, node.Decide(2) );
            Assert.AreEqual(2, node.Decide(49) );
            Assert.AreEqual(3, node.Decide(50) );
            Assert.AreEqual(4, node.Decide(51) );
            Assert.AreEqual(4, node.Decide(100) );
            Assert.AreEqual(-1, node.Decide(200) );
            Assert.AreEqual(-1, node.Decide(bounds.Last) );
        }
        public void WhenBoundsCoverMultipleArrowsEnumerateCoverage()
        {
            var target = new MutableIntMap <double>();

            target.DefaultValue = D;
            target.Set(new IntArrow <double>(0, 5, X));
            target.Set(new IntArrow <double>(9, 9, Y));
            target.Set(new IntArrow <double>(11, 14, Z));
            target.Set(new IntArrow <double>(20, 25, Y));

            var bounds = new IntInterval(3, 22);

            var expected = new[]
            {
                new IntArrow <double>(3, 5, X),
                new IntArrow <double>(6, 8, D),
                new IntArrow <double>(9, 9, Y),
                new IntArrow <double>(10, 10, D),
                new IntArrow <double>(11, 14, Z),
                new IntArrow <double>(15, 19, D),
                new IntArrow <double>(20, 22, Y),
            };

            var got = target.EnumerateCoverage(bounds).ToArray();

            Assert.AreEqual(expected, got);
        }
        public void TestElementaryChecks()
        {
            const int DefaultValue = -100;
            var elementToAction = new MutableIntMap<int>();
            elementToAction.DefaultValue = DefaultValue;
            var bounds = new IntInterval(0, 9);
            var frequency = new UniformIntFrequency(bounds);
            elementToAction.Set(new IntArrow<int>(2, 100));
            elementToAction.Set(new IntArrow<int>(5, 200));

            var target = new DecisionTreeBuilder(platformInfo);
            var node = target.Build(elementToAction, bounds, frequency);
            PrintProgram(node, target.DefaultActionDecision);
        }
        public void TestSameActionUnification()
        {
            var frequency = new UniformIntFrequency(new IntInterval(-100, 100));

            const int DefaultValue = -100;
            var elementToAction = new MutableIntMap<int>();
            elementToAction.DefaultValue = DefaultValue;
            elementToAction.Set(new IntArrow<int>(1, 1));
            elementToAction.Set(new IntArrow<int>(3, 49, 1));
            elementToAction.Set(new IntArrow<int>(51, 1));
            elementToAction.Set(new IntArrow<int>(54, 100, 1));

            var target = new DecisionTreeBuilder(platformInfo);
            var bounds = new IntInterval(0, 1000);
            var node = target.Build(elementToAction, bounds, frequency);
            PrintProgram(node);
        }
Exemple #5
0
        public void TestElementaryChecks()
        {
            const int DefaultValue    = -100;
            var       elementToAction = new MutableIntMap <int>();

            elementToAction.DefaultValue = DefaultValue;
            var bounds    = new IntInterval(0, 9);
            var frequency = new UniformIntFrequency(bounds);

            elementToAction.Set(new IntArrow <int>(2, 100));
            elementToAction.Set(new IntArrow <int>(5, 200));

            var target = new DecisionTreeBuilder(platformInfo);
            var node   = target.Build(elementToAction, bounds, frequency);

            PrintProgram(node, target.DefaultActionDecision);
        }
Exemple #6
0
        public void TestSameActionUnification()
        {
            var frequency = new UniformIntFrequency(new IntInterval(-100, 100));

            const int DefaultValue    = -100;
            var       elementToAction = new MutableIntMap <int>();

            elementToAction.DefaultValue = DefaultValue;
            elementToAction.Set(new IntArrow <int>(1, 1));
            elementToAction.Set(new IntArrow <int>(3, 49, 1));
            elementToAction.Set(new IntArrow <int>(51, 1));
            elementToAction.Set(new IntArrow <int>(54, 100, 1));

            var target = new DecisionTreeBuilder(platformInfo);
            var bounds = new IntInterval(0, 1000);
            var node   = target.Build(elementToAction, bounds, frequency);

            PrintProgram(node);
        }
        public void WhenBoundsAreInsideSingleArrowEnumerateCoverage()
        {
            var target = new MutableIntMap <double>();

            target.DefaultValue = D;
            target.Set(new IntArrow <double>(0, 5, X));
            target.Set(new IntArrow <double>(9, 9, Y));
            target.Set(new IntArrow <double>(11, 14, Z));
            target.Set(new IntArrow <double>(20, 25, Y));

            var bounds = new IntInterval(21, 24);

            var expected = new[]
            {
                new IntArrow <double>(21, 24, Y),
            };

            var got = target.EnumerateCoverage(bounds).ToArray();

            Assert.AreEqual(expected, got);
        }
Exemple #8
0
        public void TestBalanced()
        {
            var frequency = new MutableIntFrequency();

            frequency.DefaultValue = 0.0000001;
            frequency.Set(new IntArrow <double>(1, 520.0));
            frequency.Set(new IntArrow <double>(2, 49, 3.0));
            frequency.Set(new IntArrow <double>(50, 236.0));
            frequency.Set(new IntArrow <double>(51, 100, 2.0));

            const int DefaultValue    = -1;
            var       elementToAction = new MutableIntMap <int>();

            elementToAction.DefaultValue = DefaultValue;
            elementToAction.Set(new IntArrow <int>(1, 1));
            elementToAction.Set(new IntArrow <int>(2, 49, 2));
            elementToAction.Set(new IntArrow <int>(50, 3));
            elementToAction.Set(new IntArrow <int>(51, 100, 4));

            var target = new DecisionTreeBuilder(platformInfo);
            var bounds = new IntInterval(int.MinValue, int.MaxValue);
            var node   = target.Build(elementToAction, bounds, frequency);

            PrintProgram(node, target.DefaultActionDecision);

            Assert.AreEqual(-1, node.Decide(int.MinValue));
            Assert.AreEqual(-1, node.Decide(0));
            Assert.AreEqual(1, node.Decide(1));
            Assert.AreEqual(2, node.Decide(2));
            Assert.AreEqual(2, node.Decide(49));
            Assert.AreEqual(3, node.Decide(50));
            Assert.AreEqual(4, node.Decide(51));
            Assert.AreEqual(4, node.Decide(100));
            Assert.AreEqual(-1, node.Decide(200));
            Assert.AreEqual(-1, node.Decide(bounds.Last));
        }
        public void WhenBoundsAreInsideSingleArrowEnumerateCoverage()
        {
            var target = new MutableIntMap<double>();
            target.DefaultValue = D;
            target.Set(new IntArrow<double>(0, 5, X));
            target.Set(new IntArrow<double>(9, 9, Y));
            target.Set(new IntArrow<double>(11, 14, Z));
            target.Set(new IntArrow<double>(20, 25, Y));

            var bounds = new IntInterval(21, 24);

            var expected = new[]
            {
                new IntArrow<double>(21, 24, Y),
            };

            var got = target.EnumerateCoverage(bounds).ToArray();

            Assert.AreEqual(expected, got);
        }
        public void Test()
        {
            var target = new MutableIntMap<double>();
            target.DefaultValue = D;
            Assert.AreEqual(D, target.DefaultValue);
            Assert.AreEqual(D, target.Get(0));

            target.Set(new IntArrow<double>(0, 5, X));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(5));

            target.Set(new IntArrow<double>(4, 5, Y));
            Assert.AreEqual(Y, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(-1));
            Assert.AreEqual(D, target.Get(1000));

            target.Clear(new IntInterval(3, 4));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(1));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(3));
            Assert.AreEqual(D, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(D, target.Get(6));

            // No change:
            target.Clear(new IntInterval(int.MinValue, -1));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(1));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(3));
            Assert.AreEqual(D, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(D, target.Get(6));

            // No change:
            target.Clear(new IntInterval(6, int.MaxValue));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(1));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(3));
            Assert.AreEqual(D, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(D, target.Get(6));

            Assert.AreEqual(
                new []
                {
                    new IntArrow<double>(0, 2, X),
                    new IntArrow<double>(5, 5, Y),
                },
                target.Enumerate());

            target.Clear();
            for (int i = 0; i != 10; ++i)
            {
                Assert.AreEqual(D, target.Get(i), "context #" + i);
            }
        }
        public void WhenBoundsCoverMultipleArrowsEnumerateCoverage()
        {
            var target = new MutableIntMap<double>();
            target.DefaultValue = D;
            target.Set(new IntArrow<double>(0, 5, X));
            target.Set(new IntArrow<double>(9, 9, Y));
            target.Set(new IntArrow<double>(11, 14, Z));
            target.Set(new IntArrow<double>(20, 25, Y));

            var bounds = new IntInterval(3, 22);

            var expected = new[]
            {
                new IntArrow<double>(3, 5, X),
                new IntArrow<double>(6, 8, D),
                new IntArrow<double>(9, 9, Y),
                new IntArrow<double>(10, 10, D),
                new IntArrow<double>(11, 14, Z),
                new IntArrow<double>(15, 19, D),
                new IntArrow<double>(20, 22, Y),
            };

            var got = target.EnumerateCoverage(bounds).ToArray();

            Assert.AreEqual(expected, got);
        }
        public void BuildBody(
            EmitSyntax emit, 
            LanguageData data,
            Ref<Args> tokenId,
            Ref<Args> oldValue,
            Ref<Args> newValue,
            Ref<Args> ctx,
            Ref<Args> lookbackStart)
        {
            var mergers = data.Grammar.Mergers;

            if (mergers.Count == 0)
            {
                emit
                    .Ldarg(oldValue)
                    .Ret();

                return;
            }

            var contextResolverCode = new ContextCode(
                                            emit,
                                            il => il.Ldarg(ctx),
                                            il => il.Ldarg(lookbackStart),
                                            data,
                                            data.Grammar.GlobalContextProvider,
                                            data.LocalParseContexts);

            IActionCode code = new MergeCode(emit, contextResolverCode)
            {
                LoadOldValue = il => il.Ldarg(oldValue),
                LoadNewValue = il => il.Ldarg(newValue),
            };

            var tokenToRuleIndex = new MutableIntMap<int>(
                                        mergers.Select(
                                            merger =>
                                                new IntArrow<int>(merger.Symbol.Index, merger.Index)));
            tokenToRuleIndex.DefaultValue = -1;

            var ids = mergers.Select(m => m.Symbol.Index);
            IntInterval possibleBounds = new IntInterval(ids.Min(), ids.Max());
            var switchGenerator = SwitchGenerator.Sparse(tokenToRuleIndex, possibleBounds);
            switchGenerator.Build(
                emit,
                il => il.Ldarg(tokenId),
                (il, value) =>
                {
                    if (value < 0)
                    {
                        emit
                            .Ldarg(newValue)
                            .Ret();
                    }
                    else
                    {
                        var merger = mergers[value];
                        var binding = merger.Joint.The<CilMerger>();
                        code = code
                            .Do(binding.Context.Load)
                            .Do(binding.ActionBuilder)
                            .Emit(il2 => il2.Ret())
                            ;
                    }
                });

            emit
                .Ret();
        }
Exemple #13
0
        public void BuildBody(
            EmitSyntax emit,
            LanguageData data,
            Ref <Args> tokenId,
            Ref <Args> oldValue,
            Ref <Args> newValue,
            Ref <Args> ctx,
            Ref <Args> lookbackStart)
        {
            var mergers = data.Grammar.Mergers;

            if (mergers.Count == 0)
            {
                emit
                .Ldarg(oldValue)
                .Ret();

                return;
            }

            var contextResolverCode = new ContextCode(
                emit,
                il => il.Ldarg(ctx),
                il => il.Ldarg(lookbackStart),
                data,
                data.Grammar.GlobalContextProvider,
                data.LocalParseContexts);

            IActionCode code = new MergeCode(emit, contextResolverCode)
            {
                LoadOldValue = il => il.Ldarg(oldValue),
                LoadNewValue = il => il.Ldarg(newValue),
            };

            var tokenToRuleIndex = new MutableIntMap <int>(
                mergers.Select(
                    merger =>
                    new IntArrow <int>(merger.Symbol.Index, merger.Index)));

            tokenToRuleIndex.DefaultValue = -1;

            var         ids             = mergers.Select(m => m.Symbol.Index);
            IntInterval possibleBounds  = new IntInterval(ids.Min(), ids.Max());
            var         switchGenerator = SwitchGenerator.Sparse(tokenToRuleIndex, possibleBounds);

            switchGenerator.Build(
                emit,
                il => il.Ldarg(tokenId),
                (il, value) =>
            {
                if (value < 0)
                {
                    emit
                    .Ldarg(newValue)
                    .Ret();
                }
                else
                {
                    var merger  = mergers[value];
                    var binding = merger.Joint.The <CilMerger>();
                    code        = code
                                  .Do(binding.Context.Load)
                                  .Do(binding.ActionBuilder)
                                  .Emit(il2 => il2.Ret())
                    ;
                }
            });

            emit
            .Ret();
        }
        public void Test()
        {
            var target = new MutableIntMap <double>();

            target.DefaultValue = D;
            Assert.AreEqual(D, target.DefaultValue);
            Assert.AreEqual(D, target.Get(0));

            target.Set(new IntArrow <double>(0, 5, X));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(5));

            target.Set(new IntArrow <double>(4, 5, Y));
            Assert.AreEqual(Y, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(-1));
            Assert.AreEqual(D, target.Get(1000));

            target.Clear(new IntInterval(3, 4));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(1));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(3));
            Assert.AreEqual(D, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(D, target.Get(6));

            // No change:
            target.Clear(new IntInterval(int.MinValue, -1));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(1));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(3));
            Assert.AreEqual(D, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(D, target.Get(6));

            // No change:
            target.Clear(new IntInterval(6, int.MaxValue));
            Assert.AreEqual(X, target.Get(0));
            Assert.AreEqual(X, target.Get(1));
            Assert.AreEqual(X, target.Get(2));
            Assert.AreEqual(D, target.Get(3));
            Assert.AreEqual(D, target.Get(4));
            Assert.AreEqual(Y, target.Get(5));
            Assert.AreEqual(D, target.Get(6));

            Assert.AreEqual(
                new []
            {
                new IntArrow <double>(0, 2, X),
                new IntArrow <double>(5, 5, Y),
            },
                target.Enumerate());

            target.Clear();
            for (int i = 0; i != 10; ++i)
            {
                Assert.AreEqual(D, target.Get(i), "context #" + i);
            }
        }