public void Merge_ShouldThrow_GivenInvalidRanges()
{
var intervalOne = new IntInterval(5, EndPoint <int> .Open(7));
var intervalTwo = new IntInterval(8, 10);
Assert.That(() => intervalOne.Merge(intervalTwo), Throws.InvalidOperationException);
}
public Solver(IntInterval horizon)
{
m_PropagationQueue = new PropagationQueueVar();
m_IntObjective = new IntObjective(this);
Init(horizon);
}
public void Union()
{
IntInterval a = new IntInterval(-100, 50);
IntInterval b = new IntInterval(-50, 100);
Assert.AreEqual(new IntInterval(-100, 100), a.Union(b));
}
public void IntersectsDisjoint()
{
// simple overlap
var a = new IntInterval(7, 42);
var b = new IntInterval(10, 100);
Assert.IsTrue(a.IntersectsWith(b));
Assert.IsTrue(b.IntersectsWith(a));
Assert.IsTrue(a.IntersectsWith(a));
Assert.IsFalse(a.IsDisjointFrom(b));
Assert.IsFalse(b.IsDisjointFrom(a));
Assert.IsFalse(a.IsDisjointFrom(a));
// "touching", inclusive
var c = new IntInterval(42, 100);
Assert.IsTrue(a.IntersectsWith(c));
Assert.IsTrue(c.IntersectsWith(a));
Assert.IsFalse(a.IsDisjointFrom(c));
Assert.IsFalse(c.IsDisjointFrom(a));
// "touching", but non-inclusive
var d = new IntInterval(42, false, 100, true);
Assert.IsFalse(a.IntersectsWith(d));
Assert.IsFalse(d.IntersectsWith(a));
Assert.IsTrue(a.IsDisjointFrom(d));
Assert.IsTrue(d.IsDisjointFrom(a));
var e = new IntInterval(0, true, 7, false);
Assert.IsFalse(a.IntersectsWith(e));
Assert.IsFalse(e.IntersectsWith(a));
Assert.IsTrue(a.IsDisjointFrom(e));
Assert.IsTrue(e.IsDisjointFrom(a));
// simple disjoint
var f = new IntInterval(0, 3);
Assert.IsFalse(a.IntersectsWith(f));
Assert.IsFalse(f.IntersectsWith(a));
Assert.IsTrue(a.IsDisjointFrom(f));
Assert.IsTrue(f.IsDisjointFrom(a));
// negative interval
var g = new IntInterval(8, 0);
Assert.IsTrue(a.IntersectsWith(g));
Assert.IsTrue(g.IntersectsWith(a));
Assert.IsFalse(a.IsDisjointFrom(g));
Assert.IsFalse(g.IsDisjointFrom(a));
// containment
var h = new IntInterval(7, 42);
var i = new IntInterval(10, 40);
Assert.IsTrue(h.IntersectsWith(i));
Assert.IsTrue(i.IntersectsWith(h));
Assert.IsFalse(h.IsDisjointFrom(i));
Assert.IsFalse(i.IsDisjointFrom(h));
}
private static CharRange MakeCharRange(IntInterval interval)
{
checked
{
return(new CharRange((char)interval.First, (char)interval.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 Addition()
{
IntInterval a = new IntInterval(-10, 5);
IntInterval b = new IntInterval(-5, 10);
Assert.AreEqual(new IntInterval(-15, 15), a + b);
}
public EmitSyntax Build(EmitSyntax emit)
{
int rows = table.RowCount;
int columns = table.ColumnCount;
Ref <Labels> END = emit.Labels.Generate().GetRef();
Ref <Labels>[] labels = new Ref <Labels> [rows];
for (int i = 0; i != rows; ++i)
{
labels[i] = emit.Labels.Generate().GetRef();
}
emit
.Do(LdRow)
.Switch(labels)
.Ldc_I4(-1)
.Br(END)
;
var columnRange = new IntInterval(0, columns - 1);
var columnFrequency = new UniformIntFrequency(columnRange);
for (int i = 0; i != rows; ++i)
{
var switchEmitter = SwitchGenerator.Sparse(table.GetRow(i), columnRange, columnFrequency);
emit.Label(labels[i].Def);
switchEmitter.Build(emit, LdCol, SwitchGenerator.LdValueAction(END));
}
return(emit.Label(END.Def));
}
public void Addition()
{
IntInterval a = new IntInterval( -10, 5 );
IntInterval b = new IntInterval( -5, 10 );
Assert.AreEqual( new IntInterval( -15, 15 ), a + b );
}
public void Substraction()
{
IntInterval a = new IntInterval(-10, 5);
IntInterval b = new IntInterval(-5, 10);
Assert.AreEqual(new IntInterval(-20, 10), a - b);
}
public void Difference3()
{
IntInterval a = new IntInterval(-100, 100);
IntInterval b = new IntInterval(-150, 150);
Assert.AreEqual(IntInterval.Empty, a.Difference(b));
}
public void Difference4()
{
IntInterval a = new IntInterval(-100, 100);
IntInterval b = new IntInterval(-50, 50);
Assert.AreEqual(new IntInterval(-100, 100), a.Difference(b));
}
public void Difference25()
{
IntInterval a = new IntInterval( -100, 100 );
IntInterval b = new IntInterval( -150, -50 );
IntInterval c = new IntInterval( 50, 150 );
Assert.AreEqual( new IntInterval( -49, 100 ), a.Difference( b ) );
Assert.AreEqual( new IntInterval( -100, 49 ), a.Difference( c ) );
}
public void Negate()
{
IntInterval a = new IntInterval(-10, 5);
IntInterval b = new IntInterval(-5, 10);
Assert.AreEqual(new IntInterval(-5, 10), -a);
Assert.AreEqual(new IntInterval(-10, 5), -b);
}
public void Intersect25()
{
IntInterval a = new IntInterval(-100, 50);
IntInterval b = new IntInterval(-50, 100);
Assert.AreEqual(new IntInterval(-50, 50), a.Intersect(b));
Assert.AreEqual(new IntInterval(-50, 50), b.Intersect(a));
}
public void ContainsInterval()
{
IntInterval a = new IntInterval( -100, 100 );
IntInterval b = new IntInterval( -50, 50 );
Assert.IsTrue( a.Contains( a ) );
Assert.IsTrue( a.Contains( b ) );
Assert.IsFalse( b.Contains( a ) );
}
public void Negative()
{
var pos = new IntInterval(7, 42);
Assert.IsFalse(pos.IsNegative);
var neg = new IntInterval(42, 7);
Assert.IsFalse(pos.IsNegative);
}
public SectionInfo
(string sectionName, IEnumerable <string> section, IEnumerable <string> body, IntInterval sectionLocation, IntInterval sectionBodyLocation)
{
Section = new Section(sectionName);
FullSection = section;
Body = body;
SectionLocation = sectionLocation;
SectionBodyLocation = sectionBodyLocation;
}
public void Difference25()
{
IntInterval a = new IntInterval(-100, 100);
IntInterval b = new IntInterval(-150, -50);
IntInterval c = new IntInterval(50, 150);
Assert.AreEqual(new IntInterval(-49, 100), a.Difference(b));
Assert.AreEqual(new IntInterval(-100, 49), a.Difference(c));
}
public void Intersect16()
{
IntInterval a = new IntInterval(-150, -100);
IntInterval b = new IntInterval(-50, 50);
IntInterval c = new IntInterval(100, 150);
Assert.AreEqual(IntInterval.Empty, b.Intersect(a));
Assert.AreEqual(IntInterval.Empty, b.Intersect(c));
}
public static SwitchGenerator Sparse(
IIntMap <int> arrows,
IntInterval possibleBounds,
IIntFrequency frequency = null)
{
var result = new SparseSwitchGenerator(arrows, possibleBounds, frequency);
return(result);
}
public void Merge_ShouldReturnIntInterval()
{
var intervalOne = new IntInterval(5, 7);
var intervalTwo = new IntInterval(7, 10);
var result = intervalOne.Merge(intervalTwo);
Assert.That(result, Is.TypeOf <IntInterval>());
}
private void WriteInterval(IntInterval interval)
{
WriteChar(interval.First);
if (interval.First != interval.Last)
{
writer.Write("..");
WriteChar(interval.Last);
}
}
public void ContainsInterval()
{
IntInterval a = new IntInterval(-100, 100);
IntInterval b = new IntInterval(-50, 50);
Assert.IsTrue(a.Contains(a));
Assert.IsTrue(a.Contains(b));
Assert.IsFalse(b.Contains(a));
}
public void ContainsValue()
{
IntInterval i = new IntInterval(-100, 100);
Assert.IsFalse(i.Contains(-101));
Assert.IsTrue(i.Contains(-100));
Assert.IsTrue(i.Contains(0));
Assert.IsTrue(i.Contains(100));
Assert.IsFalse(i.Contains(101));
}
public SparseSwitchGenerator(
IIntMap <int> intMap,
IntInterval possibleBounds,
IIntFrequency frequency)
{
this.strategy = new InlineFirstDTStrategy(this);
this.intMap = intMap;
this.possibleBounds = possibleBounds;
this.frequency = frequency ?? new UniformIntFrequency(possibleBounds);
}
public static SwitchGenerator Sparse(
IntArrow <int>[] intervalToValue,
int defaultValue,
IntInterval possibleBounds,
IIntFrequency frequency = null)
{
var result = new SparseSwitchGenerator(intervalToValue, defaultValue, possibleBounds, frequency);
return(result);
}
public void ContainsValue()
{
IntInterval i = new IntInterval( -100, 100 );
Assert.IsFalse( i.Contains( -101 ) );
Assert.IsTrue( i.Contains( -100 ) );
Assert.IsTrue( i.Contains( 0 ) );
Assert.IsTrue( i.Contains( 100 ) );
Assert.IsFalse( i.Contains( 101 ) );
}
public void TestIntervalPosition(IntInterval interval, int value)
{
int first = interval.First;
int last = interval.Last;
checked
{
IntIntervalPosition position = interval.PositionOf(value);
switch (position)
{
case IntIntervalPosition.Less:
Assert.Less(value, first);
break;
case IntIntervalPosition.First:
Assert.AreEqual(value, first);
break;
case IntIntervalPosition.StrictlyInside:
Assert.IsTrue(last > value && value > first);
break;
case IntIntervalPosition.Last:
Assert.AreEqual(value, last);
break;
case IntIntervalPosition.Greater:
Assert.Greater(value, last);
break;
case IntIntervalPosition.Undefined:
Assert.IsTrue(interval.IsEmpty);
break;
default:
Assert.Fail("Invalid interval position result");
break;
}
if (position != IntIntervalPosition.Undefined)
{
Assert.AreEqual(
last >= value && value >= first,
(position & IntIntervalPosition.InsideMask) != 0);
Assert.AreEqual(
last < value || value < first,
(position & IntIntervalPosition.OutsideMask) != 0);
Assert.AreEqual(
last == value || value == first,
(position & IntIntervalPosition.EdgeMask) != 0);
}
}
}
public void Equals()
{
IntInterval i = new IntInterval(-100, 100);
IntInterval a = new IntInterval(-100, 100);
IntInterval b = new IntInterval(-99, 100);
IntInterval c = new IntInterval(-100, 99);
Assert.IsTrue(i.Equals(a));
Assert.IsFalse(i.Equals(b));
Assert.IsFalse(i.Equals(c));
}
public void Equals()
{
IntInterval i = new IntInterval( -100, 100 );
IntInterval a = new IntInterval( -100, 100 );
IntInterval b = new IntInterval( -99, 100 );
IntInterval c = new IntInterval( -100, 99 );
Assert.IsTrue( i.Equals( a ) );
Assert.IsFalse( i.Equals( b ) );
Assert.IsFalse( i.Equals( c ) );
}
public SparseSwitchGenerator(
IntArrow <int>[] intArrows,
int defaultValue,
IntInterval possibleBounds,
IIntFrequency frequency = null)
: this(
new MutableIntMap <int>(intArrows, defaultValue),
possibleBounds,
frequency)
{
}
public void Merge_ShouldMerge()
{
var intervalOne = new IntInterval(5, 7);
var intervalTwo = new IntInterval(8, 10);
var result = intervalOne.Merge(intervalTwo);
var expected = new IntInterval(5, 10);
Assert.That(result, Is.EqualTo(expected));
}
public double Sum(IntInterval bounds)
{
double sum = 0;
foreach (var arrow in EnumerateCoverage(bounds))
{
sum += arrow.Value * arrow.Key.LongSize;
}
return(sum);
}
public void IntIntervalCoverage()
{
var a = new IntInterval(7, 42);
var b = new IntInterval(40, 50);
var c = new IntInterval(200, 100); // negative
var e = IntInterval.Empty;
var empty = IntInterval.Coverage(new IntInterval[] { });
var single = IntInterval.Coverage(new IntInterval[] { a });
var ab = IntInterval.Coverage(new IntInterval[] { a, b });
var ba = IntInterval.Coverage(new IntInterval[] { b, a });
var ac = IntInterval.Coverage(new IntInterval[] { a, c });
var ca = IntInterval.Coverage(new IntInterval[] { c, a });
var ae = IntInterval.Coverage(new IntInterval[] { a, e });
var ea = IntInterval.Coverage(new IntInterval[] { e, a });
var bc = IntInterval.Coverage(new IntInterval[] { b, c });
var cb = IntInterval.Coverage(new IntInterval[] { c, b });
var be = IntInterval.Coverage(new IntInterval[] { b, e });
var eb = IntInterval.Coverage(new IntInterval[] { e, b });
var ce = IntInterval.Coverage(new IntInterval[] { c, e });
var ec = IntInterval.Coverage(new IntInterval[] { e, c });
Assert.IsTrue(c.IsNegative);
Assert.AreEqual(0, empty.Right);
Assert.AreEqual(0, empty.Left);
Assert.AreEqual(a.Left, single.Left);
Assert.AreEqual(a.Right, single.Right);
Assert.AreEqual(ab.Left, a.Left);
Assert.AreEqual(ab.Right, b.Right);
Assert.AreEqual(ba.Left, a.Left);
Assert.AreEqual(ba.Right, b.Right);
Assert.AreEqual(ac.Left, a.Left);
Assert.AreEqual(ac.Right, c.Left); // c is negative
Assert.AreEqual(ae.Left, a.Left);
Assert.AreEqual(ae.Right, a.Right);
Assert.AreEqual(ea.Left, a.Left);
Assert.AreEqual(ea.Right, a.Right);
Assert.AreEqual(ca.Left, a.Left);
Assert.AreEqual(ca.Right, c.Left); // c is negative
Assert.AreEqual(bc.Left, b.Left);
Assert.AreEqual(bc.Right, c.Left); // c is negative
Assert.AreEqual(cb.Left, b.Left);
Assert.AreEqual(cb.Right, c.Left); // c is negative
Assert.AreEqual(be.Left, b.Left);
Assert.AreEqual(be.Right, b.Right);
Assert.AreEqual(eb.Left, b.Left);
Assert.AreEqual(eb.Right, b.Right);
Assert.AreEqual(ce.Left, c.Right); // c is negative
Assert.AreEqual(ec.Right, c.Left); // c is negative
Assert.IsTrue(IntInterval.Coverage(new IntInterval[] { }).IsEmpty); // empty sequence -> empty interval
Assert.IsTrue(IntInterval.Coverage(new IntInterval[] { e }).IsEmpty); // sequence of only empty intervals -> empty interval
}
public void Substraction()
{
IntInterval a = new IntInterval( -10, 5 );
IntInterval b = new IntInterval( -5, 10 );
Assert.AreEqual( new IntInterval( -20, 10 ), a - b );
}
public void IntersectsWith()
{
IntInterval a0 = new IntInterval( -100, -51 );
IntInterval a = new IntInterval( -100, -50 );
IntInterval b = new IntInterval( -50, 50 );
IntInterval c = new IntInterval( 50, 100 );
IntInterval c0 = new IntInterval( 51, 100 );
Assert.IsFalse( a0.IntersectsWith( b ) );
Assert.IsFalse( b.IntersectsWith( a0 ) );
Assert.IsFalse( b.IntersectsWith( c0 ) );
Assert.IsFalse( c0.IntersectsWith( b ) );
Assert.IsTrue( a.IntersectsWith( b ) );
Assert.IsTrue( b.IntersectsWith( a ) );
Assert.IsTrue( b.IntersectsWith( c ) );
Assert.IsTrue( c.IntersectsWith( b ) );
}
public void Difference4()
{
IntInterval a = new IntInterval( -100, 100 );
IntInterval b = new IntInterval( -50, 50 );
Assert.AreEqual( new IntInterval( -100, 100 ), a.Difference( b ) );
}
public IntVarMatrix( Solver solver, int rowCount, int colCount, IntInterval interval )
: this(solver, rowCount, colCount, new IntDomain( interval ))
{
}
public DecisionTest(IntInterval interval, int action, double elementProbability)
{
Interval = interval;
Probability = elementProbability * Interval.LongSize;
Action = action;
}
public void Intersect16()
{
IntInterval a = new IntInterval( -150, -100 );
IntInterval b = new IntInterval( -50, 50 );
IntInterval c = new IntInterval( 100, 150 );
Assert.AreEqual( IntInterval.Empty, b.Intersect( a ) );
Assert.AreEqual( IntInterval.Empty, b.Intersect( c ) );
}
public void Multiply()
{
IntInterval a = new IntInterval( -10, -5 );
IntInterval b = new IntInterval( -10, 5 );
IntInterval c = new IntInterval( -5, 10 );
IntInterval d = new IntInterval( 5, 10 );
Assert.AreEqual( new IntInterval( 25, 100 ), a * a );
Assert.AreEqual( new IntInterval( -50, 100 ), a * b );
Assert.AreEqual( new IntInterval( -100, 50 ), a * c );
Assert.AreEqual( new IntInterval( -100, -25 ), a * d );
Assert.AreEqual( new IntInterval( -50, 100 ), b * b );
Assert.AreEqual( new IntInterval( -100, 50 ), b * c );
Assert.AreEqual( new IntInterval( -100, 50 ), b * d );
Assert.AreEqual( new IntInterval( -50, 100 ), c * c );
Assert.AreEqual( new IntInterval( -50, 100 ), c * d );
Assert.AreEqual( new IntInterval( 25, 100 ), d * d );
}
public void Negate()
{
IntInterval a = new IntInterval( -10, 5 );
IntInterval b = new IntInterval( -5, 10 );
Assert.AreEqual( new IntInterval( -5, 10 ), -a );
Assert.AreEqual( new IntInterval( -10, 5 ), -b );
}
public void Difference3()
{
IntInterval a = new IntInterval( -100, 100 );
IntInterval b = new IntInterval( -150, 150 );
Assert.AreEqual( IntInterval.Empty, a.Difference( b ) );
}
public Problem( IntInterval horizon )
{
m_Solver = new Solver( horizon );
}
public void Union()
{
IntInterval a = new IntInterval( -100, 50 );
IntInterval b = new IntInterval( -50, 100 );
Assert.AreEqual( new IntInterval( -100, 100 ), a.Union( b ) );
}
public Solver( IntInterval horizon )
{
m_PropagationQueue = new PropagationQueueVar();
m_IntObjective = new IntObjective( this );
Init( horizon );
}
private void Init( IntInterval horizon )
{
m_Horizon = horizon;
m_VarList = new List<Variable>();
m_IntVarList = new List<IntVar>();
m_FltVarList = new List<FltVar>();
m_ConstraintList = new List<Constraint>();
m_StateStack = new StateStack();
m_GoalStack = new GoalStack( m_IntObjective );
m_Out = Console.Out;
m_Time = DateTime.Now;
}
public void Intersect25()
{
IntInterval a = new IntInterval( -100, 50 );
IntInterval b = new IntInterval( -50, 100 );
Assert.AreEqual( new IntInterval( -50, 50 ), a.Intersect( b ) );
Assert.AreEqual( new IntInterval( -50, 50 ), b.Intersect( a ) );
}
