public void EmptyIntersect()
{
IntDomain a = new IntDomain( 8, 55 );
Assert.AreEqual( a.Intersect( a ), a );
Assert.IsTrue( a.Intersect( new IntDomain() ).IsEmpty() );
}
public void EmptyIntersect()
{
IntDomain a = new IntDomain(8, 55);
Assert.AreEqual(a.Intersect(a), a);
Assert.IsTrue(a.Intersect(new IntDomain()).IsEmpty());
}
static private bool Update(IntDomain[] domArray, int index)
{
int val = domArray[index].Interval.Min;
for (int idx = 0; idx < domArray.Length; ++idx)
{
IntDomain dom = domArray[idx];
if (idx != index &&
dom.Contains(val))
{
dom = dom.Difference(val);
if (dom.IsEmpty())
{
return(true);
}
domArray[idx] = dom;
if (dom.Interval.IsBound())
{
if (Update(domArray, idx))
{
return(true);
}
}
}
}
return(false);
}
public void EmptyDifference()
{
IntDomain a = new IntDomain( 8, 55 );
Assert.IsTrue( a.Difference( a ).IsEmpty() );
Assert.AreEqual( a.Difference( new IntDomain() ), a );
}
public void Add(bool[] row, string name)
{
IntDomain domain = new IntDomain(row);
IntVar var = new IntVar(m_Solver, domain, name);
m_List.Add(var);
}
public void Difference6()
{
IntDomain c = new IntDomain( 16, 47 );
IntDomain a = new IntDomain( c );
IntDomain r = a.Difference( new IntDomain( 48, 63 ) );
Assert.AreEqual( r, c );
}
public override void Update()
{
IntDomain tmp = Var0.Domain.Intersect(Var1.Domain);
Var0.Update(tmp);
Var1.Update(tmp);
}
public void EmptyUnion()
{
IntDomain a = new IntDomain(8, 55);
Assert.AreEqual(a.Union(a), a);
Assert.AreEqual(a.Union(new IntDomain()), a);
}
public void EmptyDifference()
{
IntDomain a = new IntDomain(8, 55);
Assert.IsTrue(a.Difference(a).IsEmpty());
Assert.AreEqual(a.Difference(new IntDomain()), a);
}
// Count the number of times each domain occurs in the variable list
// If the number times is equal to the cardinality of the domain, then we know
// that that domain can only be used by those variables that it's used by.
static public void UpdateOnDomain(IntVarList varList)
{
Dictionary <IntDomain, List <IntVar> > map = new Dictionary <IntDomain, List <IntVar> >();
foreach (IntVar var in varList)
{
IntDomain dom = var.Domain;
List <IntVar> list;
if (!map.TryGetValue(dom, out list))
{
list = new List <IntVar>(varList.Count);
map[dom] = list;
}
list.Add(var);
}
if (map.Count > 1)
{
foreach (KeyValuePair <IntDomain, List <IntVar> > kv in map)
{
if (kv.Key.Cardinality == kv.Value.Count)
{
UpdateOnDomain(map, kv.Key);
}
}
}
}
public void EmptyUnion()
{
IntDomain a = new IntDomain( 8, 55 );
Assert.AreEqual( a.Union( a ), a );
Assert.AreEqual( a.Union( new IntDomain() ), a );
}
public void Intersect2()
{
IntDomain a = new IntDomain( 8, 55 );
IntDomain b = new IntDomain( 40, 63 );
IntDomain c = b.Intersect( a );
Validate( c, 40, 55 );
}
public void Intersect5()
{
IntDomain a = new IntDomain( 8, 55 );
IntDomain b = new IntDomain( 40, 63 );
IntDomain c = a.Intersect( b );
Validate( c, 40, 55 );
}
public void Union1()
{
IntDomain a = new IntDomain(-20, -1);
IntDomain b = new IntDomain(0, 19);
IntDomain c = a.Union(b);
Validate(c, -20, 19);
}
public void Union6()
{
IntDomain a = new IntDomain(-20, -1);
IntDomain b = new IntDomain(0, 19);
IntDomain c = b.Union(a);
Validate(c, -20, 19);
}
public void Difference6()
{
IntDomain c = new IntDomain(16, 47);
IntDomain a = new IntDomain(c);
IntDomain r = a.Difference(new IntDomain(48, 63));
Assert.AreEqual(r, c);
}
public void Intersect2()
{
IntDomain a = new IntDomain(8, 55);
IntDomain b = new IntDomain(40, 63);
IntDomain c = b.Intersect(a);
Validate(c, 40, 55);
}
public void Intersect5()
{
IntDomain a = new IntDomain(8, 55);
IntDomain b = new IntDomain(40, 63);
IntDomain c = a.Intersect(b);
Validate(c, 40, 55);
}
protected IntVarExprVal(IntVar var0, IntVar var1, int val) :
base(var0.Solver, new Variable[] { var0, var1 })
{
m_Var0 = var0;
m_Var1 = var1;
m_Value = val;
m_Domain = new IntDomain(val);
}
public IntVarMatrix(Solver solver, int rowCount, int colCount, IntDomain domain) :
base(solver)
{
m_VarList = null;
m_RowCount = rowCount;
m_ColCount = colCount;
InitMatrix(domain);
}
public IntVar(Solver solver, IntDomain domain, string name) :
base(solver, name)
{
m_Domain = domain;
m_DomainPrev = domain;
m_DomainPrevInvalid = false;
m_Solver.IntVarList.Add(this);
}
private void Validate(IntDomain domain, int min, int max)
{
Assert.AreEqual(domain.Interval, new IntInterval(min, max));
for (int val = min; val <= max; ++val)
{
Assert.IsTrue(domain.Contains(val));
}
}
protected void UpdateVar0()
{
IntDomain domain = new IntDomain();
foreach (FltInterval flt_iset in FltVar.Domain)
{
domain = domain.Union((int)Math.Floor(flt_iset.Min), (int)Math.Ceiling(flt_iset.Max));
}
IntVar.Intersect(domain);
}
public void Enumerator()
{
List<IntInterval> l1 = new List<IntInterval>( 3 );
l1.Add( new IntInterval( 8, 23 ) );
l1.Add( new IntInterval( 40, 55 ) );
l1.Add( new IntInterval( 72, 87 ) );
IntDomain a = new IntDomain( l1 );
List<IntInterval> list = new List<IntInterval>( a );
}
public void IntersectsWith4()
{
IntDomain a = new IntDomain(new int[] { 0, 15, 48, 63 });
Assert.IsFalse(a.IntersectsWith(new IntInterval(-10, -1)));
Assert.IsFalse(a.IntersectsWith(new IntInterval(16, 47)));
Assert.IsFalse(a.IntersectsWith(new IntInterval(64, 80)));
Assert.IsTrue(a.IntersectsWith(new IntInterval(15, 47)));
Assert.IsTrue(a.IntersectsWith(new IntInterval(16, 48)));
}
private void UpdateVar0()
{
IntDomain domain = new IntDomain();
foreach( int idx in Var1 )
{
domain = domain.Union( VarList[ idx ].Domain );
}
Var0.Intersect( domain );
}
public IntDomain Union()
{
IntDomain domain = new IntDomain();
foreach (IntVar var in this)
{
domain = domain.Union(var.Domain);
}
return(domain);
}
private void UpdateVar0()
{
IntDomain domain = IntDomain.Empty;
foreach (int idx in Var1)
{
domain = domain.Union(m_DomainList[idx]);
}
Var0.Intersect(domain);
}
public IntDomain[] ToDomainArray()
{
IntDomain[] list = new IntDomain[Count];
for (int idx = 0; idx < Count; ++idx)
{
list[idx] = At(idx).Domain;
}
return(list);
}
public void Enumerator()
{
List <IntInterval> l1 = new List <IntInterval>(3);
l1.Add(new IntInterval(8, 23));
l1.Add(new IntInterval(40, 55));
l1.Add(new IntInterval(72, 87));
IntDomain a = new IntDomain(l1);
List <IntInterval> list = new List <IntInterval>(a);
}
public override void Update()
{
int sum_min = 0;
int sum_max = 0;
for (int idx = 0; idx < VarList.Count; ++idx)
{
IntDomain dom = VarList[idx].Domain;
sum_min += dom.Min;
sum_max += dom.Max;
}
Var0.Intersect(sum_min, sum_max);
if (Var0.Domain.IsEmpty())
{
return;
}
for (int idx = 0; idx < VarList.Count; ++idx)
{
IntVar var = VarList[idx];
int min = Var0.Min - (sum_max - var.Max);
int max = Var0.Max - (sum_min - var.Min);
if (min > var.Min || max < var.Max)
{
sum_min -= var.Min;
sum_max -= var.Max;
var.Intersect(min, max);
if (var.Domain.IsEmpty())
{
break;
}
sum_min += var.Min;
sum_max += var.Max;
Var0.Intersect(sum_min, sum_max);
if (Var0.Domain.IsEmpty())
{
break;
}
idx = -1;
}
}
}
internal void Update(IntDomain result)
{
if (!ReferenceEquals(m_Domain, result))
{
Store();
m_DomainPrevInvalid = false;
m_DomainPrev = m_Domain;
m_Domain = result;
OnDomainChange();
}
}
private void Update2()
{
int sum_min = 0;
int sum_max = 0;
for (int i = 0; i < VarList.Count; ++i)
{
IntDomain dom = VarList[i].Domain;
sum_min += dom.Min;
sum_max += dom.Max;
}
if (m_Value < sum_min || m_Value > sum_max)
{
Violate();
return;
}
for (int idx = 0; idx < VarList.Count; ++idx)
{
IntVar var = VarList[idx];
int min = m_Value - (sum_max - var.Max);
int max = m_Value - (sum_min - var.Min);
if (min > var.Min || max < var.Max)
{
sum_min -= var.Min;
sum_max -= var.Max;
var.Intersect(min, max);
if (var.Domain.IsEmpty())
{
return;
}
sum_min += var.Min;
sum_max += var.Max;
if (m_Value < sum_min || m_Value > sum_max)
{
Violate();
return;
}
idx = -1;
}
}
}
private void UpdateVar0()
{
if (VarList.Count > 0)
{
IntDomain domain = VarList.Front().Domain *m_IntArray[0];
for (int idx = 1; idx < VarList.Count; ++idx)
{
domain += VarList[idx].Domain * m_IntArray[idx];
}
Var0.Intersect(domain);
}
}
public void PreviousState()
{
Solver p = new Solver(-10000, 10000);
IntVar a = new IntVar(p, 0, 100, "a");
p.StateStack.Begin();
a.Max = 60;
p.StateStack.Begin();
a.Max = 30;
p.StateStack.Begin();
p.StateStack.Begin();
a.Max = 10;
IntDomain d1 = a.DomainPrev;
Assert.AreEqual(d1, new IntDomain(0, 30));
int c1 = d1.Cardinality - a.Domain.Cardinality;
Assert.AreEqual(c1, 20);
p.StateStack.Cancel();
p.StateStack.Cancel();
IntDomain d2 = a.DomainPrev;
Assert.AreEqual(d2, new IntDomain(0, 60));
int c2 = d2.Cardinality - a.Domain.Cardinality;
Assert.AreEqual(c2, 30);
p.StateStack.Cancel();
IntDomain d3 = a.DomainPrev;
Assert.AreEqual(d3, new IntDomain(0, 100));
int c3 = d3.Cardinality - a.Domain.Cardinality;
Assert.AreEqual(c3, 40);
p.StateStack.Cancel();
Assert.AreEqual(a.Domain, new IntDomain(0, 100));
}
public override void Update()
{
if (VarList.Count == 0)
{
return;
}
IntDomain domain = VarList.Front().Domain;
for (int idx = 1; idx < VarList.Count; ++idx)
{
domain *= VarList[idx].Domain;
}
Var0.Intersect(domain);
}
private void UpdateVar1()
{
IntDomain diff = new IntDomain();
foreach (int idx in Index)
{
FltVar var = VarList[idx];
if (!Var0.Domain.IntersectsWith(var.Domain))
{
diff = diff.Union(idx);
}
}
Index.Difference(diff);
}
private void InitMatrix( IntDomain domain )
{
m_VarList = new IntVarList( m_Solver, m_RowCount * m_ColCount );
for( int row = 0; row < m_RowCount; ++row )
{
for( int col = 0; col < m_ColCount; ++col )
{
string name = row.ToString() + "." + col.ToString();
IntVar cell = new IntVar( m_Solver, domain, name );
m_VarList.Add( cell );
}
}
}
private void Validate( IntDomain domain, int min, int max )
{
Assert.AreEqual( domain.Interval, new IntInterval( min, max ) );
for( int val = min; val <= max; ++val )
{
Assert.IsTrue( domain.Contains( val ) );
}
}
public void IntersectsWith4()
{
IntDomain a = new IntDomain( new int[] { 0, 15, 48, 63 } );
Assert.IsFalse( a.IntersectsWith( new IntInterval( -10, -1 ) ) );
Assert.IsFalse( a.IntersectsWith( new IntInterval( 16, 47 ) ) );
Assert.IsFalse( a.IntersectsWith( new IntInterval( 64, 80 ) ) );
Assert.IsTrue( a.IntersectsWith( new IntInterval( 15, 47 ) ) );
Assert.IsTrue( a.IntersectsWith( new IntInterval( 16, 48 ) ) );
}
public IntVarMatrix( Solver solver, int rowCount, int colCount, IntDomain domain )
: base(solver)
{
m_VarList = null;
m_RowCount = rowCount;
m_ColCount = colCount;
InitMatrix( domain );
}
public void Update( IntDomain[] list )
{
if( list.Length == Count )
{
for( int idx = 0; idx < list.Length; ++idx )
{
At( idx ).Update( list[ idx ] );
}
}
}
public IntDomain Union()
{
IntDomain domain = new IntDomain();
foreach( IntVar var in this )
{
domain = domain.Union( var.Domain );
}
return domain;
}
public void Union1()
{
IntDomain a = new IntDomain( -20, -1 );
IntDomain b = new IntDomain( 0, 19 );
IntDomain c = a.Union( b );
Validate( c, -20, 19 );
}
public void Union6()
{
IntDomain a = new IntDomain( -20, -1 );
IntDomain b = new IntDomain( 0, 19 );
IntDomain c = b.Union( a );
Validate( c, -20, 19 );
}
protected IntVarExprVal( IntVar var0, IntVar var1, int val )
: base(var0.Solver, new Variable[] { var0, var1 })
{
m_Var0 = var0;
m_Var1 = var1;
m_Value = val;
m_Domain = new IntDomain( val );
}
static void Mul2()
{
IntDomain v = new IntDomain();
for( int idx = 0; idx < 100000; ++idx )
{
Solver s = new Solver( -1000, 1000 );
IntVar a = new IntVar( s, IntDomain.Random( -100, 100, 1 ), "a" );
IntVar b = new IntVar( s, IntDomain.Random( -100, 100, 1 ), "b" );
IntVar c = new IntVar( s, IntDomain.Random( -100, 100, 1 ), "c" );
IntVar d = new IntVar( s, IntDomain.Random( -100, 100, 1 ), "d" );
IntVarList l = new IntVarList( s, new IntVar[] { a, b, c, d } );
//p.Add( a + b + c + d );
s.Add( l.Sum() );
s.Propagate();
s.PrintVariables();
s.PrintConstraints();
}
}
public IntDomain[] ToDomainArray()
{
IntDomain[] list = new IntDomain[ Count ];
for( int idx = 0; idx < Count; ++idx )
{
list[ idx ] = At( idx ).Domain;
}
return list;
}
