static public IntVarMatrix operator*(IntVarMatrix lhs, int[] rhs)
{
if (lhs.ColCount != rhs.Length)
{
throw new Exception("");
}
Solver solver = lhs.Solver;
IntVarList list = new IntVarList(solver);
for (int row = 0; row < lhs.RowCount; ++row)
{
IntVar[] rowList = new IntVar[lhs.ColCount];
for (int col = 0; col < lhs.ColCount; ++col)
{
rowList[col] = lhs.Cell(row, col);
}
IntVarListDotProduct dp = new IntVarListDotProduct(solver, rowList, rhs);
solver.Add(dp);
list.Add(dp.Var0);
}
return(new IntVarMatrix(solver, lhs.ColCount, 1, list));
}
private IntVarMatrix(Solver solver, int rowCount, int colCount, IntVarList list) :
base(solver)
{
m_VarList = list;
m_RowCount = rowCount;
m_ColCount = colCount;
}
// 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 MoreMoney()
: base(0, 1000000)
{
IntVar d = new IntVar( m_Solver, 0, 9, "d");
IntVar e = new IntVar( m_Solver, 0, 9, "e");
IntVar m = new IntVar( m_Solver, 1, 9, "m");
IntVar n = new IntVar( m_Solver, 0, 9, "n");
IntVar o = new IntVar( m_Solver, 0, 9, "o");
IntVar r = new IntVar( m_Solver, 0, 9, "r");
IntVar s = new IntVar( m_Solver, 1, 9, "s");
IntVar y = new IntVar( m_Solver, 0, 9, "y");
IntVarList list = new IntVarList( m_Solver, new IntVar[] { d, e, m, n, o, r, s, y } );
m_Solver.Add( list.AllDifferent() );
IntVarListDotProduct send = new IntVarListDotProduct( m_Solver,
new IntVar[] { s, e, n, d },
new int[] { 1000, 100, 10, 1 } );
IntVarListDotProduct more = new IntVarListDotProduct( m_Solver,
new IntVar[] { m, o, r, e },
new int[] { 1000, 100, 10, 1 } );
IntVarListDotProduct money = new IntVarListDotProduct( m_Solver,
new IntVar[] { m, o, n, e, y },
new int[] { 10000, 1000, 100, 10, 1 } );
m_Solver.Add( send );
m_Solver.Add( more );
m_Solver.Add( money );
IntVarExpr sendMore = send.Var0 + more.Var0;
m_Solver.Add( sendMore );
IntVarCmp cmp = sendMore.Var0 == money.Var0;
m_Solver.Add( cmp );
}
static public IntVarMatrix operator+(IntVarMatrix lhs, IntVarMatrix rhs)
{
if ((lhs.RowCount != rhs.RowCount) ||
(lhs.ColCount != rhs.ColCount))
{
throw new Exception("");
}
Solver solver = lhs.Solver;
int rowCount = lhs.RowCount;
int colCount = lhs.ColCount;
IntVarList list = new IntVarList(solver);
for (int row = 0; row < rowCount; ++row)
{
for (int col = 0; col < colCount; ++col)
{
IntVarExprVar expr = lhs[row, col] + rhs[row, col];
solver.Add(expr);
list.Add(expr.Var0);
}
}
return(new IntVarMatrix(solver, rowCount, colCount, list));
}
public IntVarList Col(int vcol, int rowStart, int rowStop)
{
IntVarList list = new IntVarList(m_Solver);
for (int row = rowStart; row < rowStop; ++row)
{
list.Add(Cell(row, vcol));
}
return(list);
}
public IntVarList Row(int vrow, int colStart, int colStop)
{
IntVarList list = new IntVarList(m_Solver);
for (int col = colStart; col < colStop; ++col)
{
list.Add(Cell(vrow, col));
}
return(list);
}
public Cover( Solver solver, int columns, IntVarList list )
: base(solver)
{
m_Columns = columns;
m_List = list;
m_Avail = new IntVar( solver, 0, list.Count - 1 );;
m_Index = new IntVar( solver, IntDomain.Empty, "" );
m_Union = new IntVar( solver, IntDomain.Empty, "" );
}
static public bool UpdateOnCount(IntVarList varList)
{
int min = varList.MinInterval.Min;
int max = varList.MaxInterval.Max;
int count = max - min + 1;
if (count < 256)
{
Value[] valList = new Value[count];
int valCount = 0;
foreach (IntVar var in varList)
{
foreach (int val in var)
{
int idx = val - min;
if (valList[idx].m_Value == 0)
{
++valCount;
valList[idx].m_Variable = var;
}
++valList[idx].m_Value;
}
}
if (valCount < varList.Count)
{
return(true);
}
for (int idx = 0; idx < count; ++idx)
{
if (valList[idx].m_Value == 1)
{
IntVar var = valList[idx].m_Variable;
if (!var.IsBound())
{
int val = min + idx;
var.Intersect(val);
}
}
}
}
return(false);
}
public IntVarMatrix Matrix(int rowOffset, int colOffset, int rowCount, int colCount)
{
IntVarList list = new IntVarList(m_Solver);
for (int row = 0; row < rowCount; ++row)
{
for (int col = 0; col < colCount; ++col)
{
list.Add(Cell(rowOffset + row, colOffset + col));
}
}
return(new IntVarMatrix(m_Solver, rowCount, colCount, list));
}
public Golomb( int n )
: base()
{
int maxLength = (int) Math.Pow( 2, (n-1) ) - 1;
m_Solver.Horizon = new IntInterval( 0, maxLength );
m_MarkList = new IntVarList( m_Solver );
for( int idx = 0; idx < n; ++idx )
{
m_MarkList.Add( new IntVar( m_Solver, idx, maxLength, "m" + ( idx + 1 ).ToString() ) );
}
int mark = 0;
int pos = 0;
m_DiffList = new IntVarList( m_Solver, n * ( n -1 ) );
for( int i = 0; i < n - 1; ++i )
{
for( int j = i + 1; j < n; ++j )
{
if( i == n/2 && j == n-1 )
mark = pos;
IntVarExpr exp = m_MarkList[ j ] - m_MarkList[ i ];
exp.Var0.Min = 1;
exp.Var0.Name = "#" + m_MarkList[ j ].Name + "-" + m_MarkList[ i ].Name;
m_Solver.Add( exp );
m_DiffList.Add( exp.Var0 );
++pos;
}
}
IntVarListAllDifferent ad = m_DiffList.AllDifferent();
//ad.Level = Constraint.PropagateLevel.High;
m_Solver.Add( ad );
// start mark at 0
m_MarkList[ 0 ].Value = 0;
// lower half should be less than the half difference
IntVarCmp cmp = m_MarkList[ (n-1)/2 ] < m_DiffList[ mark ];
m_Solver.Add( cmp );
Console.WriteLine( cmp.ToString() +", " + m_DiffList[ mark ].ToString() );
}
public void Test()
{
Solver solver = new Solver( -1000, 1000 );
IntVar i0 = new IntVar( solver, 0, 10 );
IntVar i1 = new IntVar( solver, 10, 20 );
IntVar i2 = new IntVar( solver, 20, 30 );
IntVar s = new IntVar( solver, 30, 60 );
IntVarList list = new IntVarList( solver, new IntVar[] { i0, i1, i2 } );
IntVarListSum sum = list.Sum();
solver.Add( sum );
solver.Propagate();
Assert.AreEqual( s.Domain, sum.Var0.Domain );
}
public IntVarList DiagRightTopToBottomLeft()
{
IntVarList list = new IntVarList(m_Solver);
if (m_RowCount == m_ColCount)
{
int size = m_RowCount;
for (int idx = 0; idx < size; ++idx)
{
list.Add(Cell(idx, (size - 1) - idx));
}
}
return(list);
}
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);
}
}
}
static public bool Update(IntVarList varList)
{
IntDomain[] domArray = varList.ToDomainArray();
for (int idx = 0; idx < domArray.Length; ++idx)
{
if (domArray[idx].Interval.IsBound())
{
if (Update(domArray, idx))
{
return(true);
}
}
}
varList.Update(domArray);
return(false);
}
public void Test()
{
Solver solver = new Solver( -1000, 1000 );
IntVar a = new IntVar( solver, -10, -5, "a" );
IntVar b = new IntVar( solver, -1, 1, "b" );
IntVar c = new IntVar( solver, 5, 10, "c" );
IntVarList list = new IntVarList( solver, new IntVar[] { a, b, c } );
IntVar index = new IntVar( solver );
IntVarListIndex cons = list.At( index );
IntVar result = cons.Var0;
solver.Add( cons );
solver.Propagate();
result.Intersect( -8, 8 );
result.Difference( -2, 6 );
cons.Index.Difference( 1 );
}
public IntVarList Col( int vcol, int rowStart, int rowStop )
{
IntVarList list = new IntVarList( m_Solver );
for( int row = rowStart; row < rowStop; ++row )
{
list.Add( Cell( row, vcol ) );
}
return list;
}
static void Test1()
{
Solver solver = new Solver( 0, 100 );
IntVar a = new IntVar( solver, 0, 10 );
IntVar b = new IntVar( solver, 0, 10 );
IntVar c = new IntVar( solver, 0, 10 );
IntVarList l = new IntVarList( a, b, c );
IntVarListSum sum = l.Sum();
solver.Add( sum );
solver.Propagate();
sum.Var0.Value = 6;
a.Value = 1;
b.Value = 2;
}
static void Test2()
{
Solver solver = new Solver( 0, 100 );
IntVar a = new IntVar( solver, 1, 3, "a" );
IntVar b = new IntVar( solver, 1, 3, "b" );
IntVar c = new IntVar( solver, 1, 3, "c" );
IntVarList l = new IntVarList( a, b, c );
IntVarListAllDifferent diff = l.AllDifferent();
solver.Add( diff );
solver.Propagate();
a.Value = 1;
b.Value = 2;
}
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 );
}
}
}
public IntVarMatrix Matrix( int rowOffset, int colOffset, int rowCount, int colCount )
{
IntVarList list = new IntVarList( m_Solver );
for( int row = 0; row < rowCount; ++row )
{
for( int col = 0; col < colCount; ++col )
{
list.Add( Cell( rowOffset + row, colOffset + col ) );
}
}
return new IntVarMatrix( m_Solver, rowCount, colCount, list );
}
public IntVarList Row( int vrow, int colStart, int colStop )
{
IntVarList list = new IntVarList( m_Solver );
for( int col = colStart; col < colStop; ++col )
{
list.Add( Cell( vrow, col ) );
}
return list;
}
public IntVarList DiagRightTopToBottomLeft()
{
IntVarList list = new IntVarList( m_Solver );
if( m_RowCount == m_ColCount )
{
int size = m_RowCount;
for( int idx = 0; idx < size; ++idx )
{
list.Add( Cell( idx, ( size - 1 ) - idx ) );
}
}
return list;
}
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 static IntVarMatrix operator +( IntVarMatrix lhs, IntVarMatrix rhs )
{
if( ( lhs.RowCount != rhs.RowCount )
|| ( lhs.ColCount != rhs.ColCount ) )
throw new Exception( "" );
Solver solver = lhs.Solver;
int rowCount = lhs.RowCount;
int colCount = lhs.ColCount;
IntVarList list = new IntVarList( solver );
for( int row = 0; row < rowCount; ++row )
{
for( int col = 0; col < colCount; ++col )
{
IntVarExprVar expr = lhs[ row, col ] + rhs[ row, col ];
solver.Add( expr );
list.Add( expr.Var0 );
}
}
return new IntVarMatrix( solver, rowCount, colCount, list );
}
public static IntVarMatrix operator *( IntVarMatrix lhs, int[] rhs )
{
if( lhs.ColCount != rhs.Length )
throw new Exception( "" );
Solver solver = lhs.Solver;
IntVarList list = new IntVarList( solver );
for( int row = 0; row < lhs.RowCount; ++row )
{
IntVar[] rowList = new IntVar[ lhs.ColCount ];
for( int col = 0; col < lhs.ColCount; ++col )
{
rowList[ col ] = lhs.Cell( row, col );
}
IntVarListDotProduct dp = new IntVarListDotProduct( solver, rowList, rhs );
solver.Add( dp );
list.Add( dp.Var0 );
}
return new IntVarMatrix( solver, lhs.ColCount, 1, list );
}
private IntVarMatrix( Solver solver, int rowCount, int colCount, IntVarList list )
: base(solver)
{
m_VarList = list;
m_RowCount = rowCount;
m_ColCount = colCount;
}
public IntVarMatrix( Solver solver, int rowCount, int colCount, IntDomain domain )
: base(solver)
{
m_VarList = null;
m_RowCount = rowCount;
m_ColCount = colCount;
InitMatrix( domain );
}
static void Mul1()
{
Solver solver = new Solver( 0, 10000 );
IntVarMatrix m1 = new IntVarMatrix( solver, 2, 2, new IntInterval( 0, 100 ) );
int[] v = new int[] { 1, 2 };
IntVarMatrix m2 = m1 * v;
solver.Propagate();
solver.PrintVariables( Console.Out );
Solver s1 = new Solver( -1000000, 1000000 );
IntVar a = new IntVar( s1, IntDomain.Random( -100, 100, 1 ), "a" );
IntVar b = new IntVar( s1, IntDomain.Random( -100, 100, 1 ), "b" );
IntVar c = new IntVar( s1, IntDomain.Random( -100, 100, 1 ), "c" );
IntVarList l = new IntVarList( s1, new IntVar[] { a, b, c } );
s1.Add( l.Mul() );
s1.Propagate();
s1.PrintVariables( Console.Out );
}
