private static void polyomino_embed_number_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_EMBED_NUMBER_TEST tests POLYOMINO_EMBED_NUMBER.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 May 2018
//
// Author:
//
// John Burkardt
//
{
const int mp = 3;
const int mr = 4;
const int np = 2;
const int nr = 4;
int[] p =
{
0, 0, 1,
1, 1, 1
};
int[] r =
{
0, 1, 1, 1,
1, 1, 1, 0,
1, 0, 1, 1,
1, 1, 1, 1
};
Console.WriteLine("");
Console.WriteLine("POLYOMINO_EMBED_NUMBER_TEST:");
Console.WriteLine(" POLYOMINO_EMBED_NUMBER reports the number of ways a");
Console.WriteLine(" fixed polyomino can be embedded in a region.");
Polyomino.polyomino_print(mr, nr, r, " The given region R:");
Polyomino.polyomino_print(mp, np, p, " The given polyomino P:");
int number = Polyomino.polyomino_embed_number(mr, nr, r, mp, np, p);
Console.WriteLine("");
Console.WriteLine(" As a fixed polyomino, P can be embedded in R in " + number + " ways");
}
private static void polyomino_condense_demo(int mp, int np, int[] p)
//****************************************************************************80
//
// Purpose:
//
// polyomino_condense_demo demonstrates POLYOMINO_CONDENSE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 29 April 2018
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int MP, NP, the number of rows and columns in the representation
// of the polyomino P.
//
// Input, int P[MP*NP], a matrix representing the polyomino.
//
// Local, int MQ, NQ, the number of rows and columns in the representation
// of the condensed polyomino Q.
//
// Local, int Q[MQ*NQ], a matrix representing the condensed polyomino.
//
{
int mq = 0;
int nq = 0;
int[] q = null;
string label = " The initial (" + mp + "," + np + ") polynomino P:";
Polyomino.polyomino_print(mp, np, p, label);
Polyomino.polyomino_condense(mp, np, p, ref mq, ref nq, ref q);
label = " The condensed (" + mq + "," + nq + ") polynomino Q:";
Polyomino.polyomino_print(mq, nq, q, label);
}
private static void polyomino_transform_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_TRANSFORM_TEST tests POLYOMINO_TRANSFORM.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 28 April 2018
//
// Author:
//
// John Burkardt
//
// Local parameters:
//
// Local, int M, N, the number of rows and columns in the representation
// of the polyomino P.
//
// Local, int P[M*N], a matrix of 0"s and 1"s representing the
// polyomino. The matrix should be "tight", that is, there should be a
// 1 in row 1, and in column 1, and in row M, and in column N.
//
{
const int m = 3;
int mq = 0;
const int n = 3;
int nq = 0;
//
// P is given by columns, not rows.
//
int[] p =
{
0, 1, 0,
1, 1, 1,
1, 0, 0
};
int[] q = null;
int reflect;
Console.WriteLine("");
Console.WriteLine("POLYOMINO_TRANSFORM_TEST:");
Console.WriteLine(" POLYOMINO_TRANSFORM can transform a polyomino.");
Console.WriteLine(" Generate all 8 combinations of rotation and reflection");
Console.WriteLine(" applied to a polyomino represented by a binary matrix.");
Polyomino.polyomino_print(m, n, p, " The given polyomino P:");
for (reflect = 0; reflect <= 1; reflect++)
{
int rotate;
for (rotate = 0; rotate <= 3; rotate++)
{
Polyomino.polyomino_transform(m, n, p, rotate, reflect, ref mq, ref nq, ref q);
string label = " P after " + reflect + " reflections and " + rotate + " rotations:";
Polyomino.polyomino_print(mq, nq, q, label);
}
}
Console.WriteLine("");
Console.WriteLine("POLYOMINO_TRANSFORM_TEST:");
Console.WriteLine(" Normal end of execution.");
}
private static void polyomino_index_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_INDEX_TEST tests POLYOMINO_INDEX.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 April 2018
//
// Author:
//
// John Burkardt
//
{
int i;
const int m = 3;
const int n = 4;
//
// P is listed in column-major order;
//
int[] p =
{
1, 1, 0,
0, 1, 1,
1, 1, 1,
1, 0, 0
};
Console.WriteLine("");
Console.WriteLine("POLYOMINO_INDEX_TEST");
Console.WriteLine(" POLYOMINO_INDEX assigns an index to each nonzero entry");
Console.WriteLine(" of a polyomino.");
Polyomino.polyomino_print(m, n, p, " The polyomino P:");
int[] pin = Polyomino.polyomino_index(m, n, p);
Console.WriteLine("");
Console.WriteLine(" PIN: Index vector for P:");
Console.WriteLine("");
for (i = 0; i < m; i++)
{
string cout = "";
int j;
for (j = 0; j < n; j++)
{
cout += " " + pin[i + j * m];
}
Console.WriteLine(cout);
}
Console.WriteLine("");
Console.WriteLine("POLYOMINO_INDEX_TEST");
Console.WriteLine(" Normal end of execution.");
}
private static void polyomino_embed_list_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_EMBED_LIST_TEST tests POLYOMINO_EMBED_LIST.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 May 2018
//
// Author:
//
// John Burkardt
//
{
int k;
const int mp = 3;
const int mr = 4;
const int np = 2;
const int nr = 4;
int[] p =
{
0, 0, 1,
1, 1, 1
};
int[] q = new int[4 * 4];
int[] r =
{
0, 1, 1, 1,
1, 1, 1, 0,
1, 0, 1, 1,
1, 1, 1, 1
};
Console.WriteLine("");
Console.WriteLine("POLYOMINO_EMBED_LIST_TEST:");
Console.WriteLine(" POLYOMINO_EMBED_LIST lists the offsets used");
Console.WriteLine(" to embed a fixed polyomino in a region.");
Polyomino.polyomino_print(mr, nr, r, " The given region R:");
Polyomino.polyomino_print(mp, np, p, " The given polyomino P:");
//
// Get the number of embeddings.
//
int number = Polyomino.polyomino_embed_number(mr, nr, r, mp, np, p);
Console.WriteLine("");
Console.WriteLine(" As a fixed polyomino, P can be embedded in R in " + number + " ways");
/*
* Get the list of embeddings.
*/
int[] list = Polyomino.polyomino_embed_list(mr, nr, r, mp, np, p, number);
for (k = 0; k < number; k++)
{
int mk = list[k + 0 * number];
int nk = list[k + 1 * number];
int i;
int j;
for (j = 0; j < nr; j++)
{
for (i = 0; i < mr; i++)
{
q[i + j * mr] = r[i + j * mr];
}
}
for (j = 0; j < np; j++)
{
for (i = 0; i < mp; i++)
{
q[i + mk + (j + nk) * mr] += p[i + j * mp];
}
}
Console.WriteLine("");
Console.WriteLine(" Embedding number " + k + ":");
Console.WriteLine("");
for (i = 0; i < mr; i++)
{
string cout = "";
for (j = 0; j < nr; j++)
{
cout += " " + q[i + j * mr];
}
Console.WriteLine(cout);
}
}
}
