public static void pord_check_test( )
//****************************************************************************80
//
// Purpose:
//
// PORD_CHECK_TEST tests PORD_CHECK.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 May 2015
//
// Author:
//
// John Burkardt
//
{
int[] a =
{
1, 0, 1, 0, 1, 0, 1, 0, 0, 1,
0, 1, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 1, 0, 1, 0, 0, 1,
0, 1, 1, 1, 1, 1, 1, 1, 0, 1,
0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 1, 0, 0, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 0, 1, 1, 1, 1, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0, 0, 1
};
const int n = 10;
Console.WriteLine("");
Console.WriteLine("PORD_CHECK_TEST");
Console.WriteLine(" PORD_CHECK checks a partial ordering.");
typeMethods.i4mat_print(n, n, a, " The partial ordering matrix:");
bool ierror = PartialOrdering.pord_check(n, a);
Console.WriteLine("");
Console.WriteLine(" CHECK FLAG = " + ierror + "");
Console.WriteLine(" 0 means no error.");
Console.WriteLine(" 1 means illegal value of N.");
Console.WriteLine(" 2 means some A(I,J) and A(J,I) are both nonzero.");
}
public static void triang(int n, int[] zeta, ref int[] p)
//****************************************************************************80
//
// Purpose:
//
// TRIANG renumbers elements in accordance with a partial ordering.
//
// Discussion:
//
// TRIANG is given a partially ordered set. The partial ordering
// is defined by a matrix ZETA, where element I is partially less than
// or equal to element J if and only if ZETA(I,J) = 1.
//
// TRIANG renumbers the elements with a permutation P so that if
// element I is partially less than element J in the partial ordering,
// then P(I) < P(J) in the usual, numerical ordering.
//
// In other words, the elements are relabeled so that their labels
// reflect their ordering. This is equivalent to relabeling the
// matrix so that, on unscrambling it, the matrix would be upper
// triangular.
//
// Calling I4MAT_2PERM0 or R8MAT_2PERM0 with P used for both the row
// and column permutations applied to matrix ZETA will result in
// an upper triangular matrix.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 11 June 2015
//
// Author:
//
// Original FORTRAN77 version by Albert Nijenhuis, Herbert Wilf.
// C++ version by John Burkardt.
//
// Reference:
//
// Albert Nijenhuis, Herbert Wilf,
// Combinatorial Algorithms for Computers and Calculators,
// Second Edition,
// Academic Press, 1978,
// ISBN: 0-12-519260-6,
// LC: QA164.N54.
//
// Parameters:
//
// Input, int N, the number of elements in the set.
//
// Input, int ZETA[N*N], describes the partial ordering.
// ZETA[I,J] =:
// 0, for diagonal elements (I = J), or
// for unrelated elements, or
// if J << I.
// 1, if I << J.
//
// Output, int P[N], a permutation of the elements that reflects
// their partial ordering. P[I] is the new label of element I, with
// the property that if ZETA[I,J] = 1, that is, I << J,
// then P[I] < P[J] (in the usual ordering).
//
{
int i;
//
// Make sure ZETA represents a partially ordered set. In other words,
// if ZETA(I,J) = 1, then ZETA(J,I) must NOT be 1.
//
bool error = PartialOrdering.pord_check(n, zeta);
switch (error)
{
case true:
Console.WriteLine("");
Console.WriteLine("TRIANG - Fatal error!");
Console.WriteLine(" The matrix ZETA does not represent a");
Console.WriteLine(" partial ordering.");
return;
}
int m = 1;
int l = 0;
for (i = 0; i < n; i++)
{
p[i] = 0;
}
int it = m + 1;
int ir = m + 1;
for (;;)
{
if (ir <= n)
{
switch (p[ir - 1])
{
case 0 when zeta[ir - 1 + (m - 1) * n] != 0: