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 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);
}
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 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 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);
}
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 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);
}
}
