Thu Sep 13 18:30:57 2018

UNICYCLE_TEST
  Python version: 3.6.5
  Test the UNICYCLE library.

I4_FACTORIAL_TEST
  Python version: 3.6.5
  I4_FACTORIAL evaluates the factorial function.

         N      Exact         I4_FACTORIAL(N)

         0             1             1
         1             1             1
         2             2             2
         3             6             6
         4            24            24
         5           120           120
         6           720           720
         7          5040          5040
         8         40320         40320
         9        362880        362880
        10       3628800       3628800
        11      39916800      39916800
        12     479001600     479001600

I4_FACTORIAL_TEST
  Normal end of execution.

I4_MODP_TEST
  Python version: 3.6.5
  I4_MODP factors a number
  into a multiple M and a positive remainder R.

    Number   Divisor  Multiple Remainder

       107        50         2         7
       107       -50        -2         7
      -107        50        -3        43
      -107       -50         3        43

  Repeat using Python % Operator:

       107        50         2         7
       107       -50        -3       -43
      -107        50        -3        43
      -107       -50         2        -7

I4_MODP_TEST
  Normal end of execution.

I4_UNIFORM_AB_TEST
  Python version: 3.6.5
  I4_UNIFORM_AB computes pseudorandom values
  in an interval [A,B].

  The lower endpoint A = -100
  The upper endpoint B = 200
  The initial seed is 123456789

         1       -35
         2       187
         3       149
         4        69
         5        25
         6       -81
         7       -23
         8       -67
         9       -87
        10        90
        11       -82
        12        35
        13        20
        14       127
        15       139
        16      -100
        17       170
        18         5
        19       -72
        20       -96

I4_UNIFORM_AB_TEST:
  Normal end of execution.

I4_WRAP_TEST
  Python version: 3.6.5
  I4_WRAP forces an integer to lie within given limits.

  ILO = 4
  IHI = 8

     I  I4_WRAP(I)

     -10       5
      -9       6
      -8       7
      -7       8
      -6       4
      -5       5
      -4       6
      -3       7
      -2       8
      -1       4
       0       5
       1       6
       2       7
       3       8
       4       4
       5       5
       6       6
       7       7
       8       8
       9       4
      10       5
      11       6
      12       7
      13       8
      14       4
      15       5
      16       6
      17       7
      18       8
      19       4
      20       5

I4_WRAP_TEST
  Normal end of execution.

I4VEC_INDICATOR1_TEST
  Python version: 3.6.5
  I4VEC_INDICATOR1 returns an indicator vector.

  The indicator1 vector:

     0       1
     1       2
     2       3
     3       4
     4       5
     5       6
     6       7
     7       8
     8       9
     9      10

I4VEC_INDICATOR1_TEST
  Normal end of execution.

I4VEC_PRINT_TEST
  Python version: 3.6.5
  I4VEC_PRINT prints an I4VEC.

  Here is an I4VEC:

     0      91
     1      92
     2      93
     3      94

I4VEC_PRINT_TEST:
  Normal end of execution.

I4VEC_REVERSE_TEST
  Python version: 3.6.5
  I4VEC_REVERSE reverses a list of integers.

  Original vector:

     0       6
     1      29
     2      25
     3      17
     4      12
     5       2
     6       7
     7       3
     8       1
     9      19

  Reversed:

     0      19
     1       1
     2       3
     3       7
     4       2
     5      12
     6      17
     7      25
     8      29
     9       6

I4VEC_REVERSE_TEST:
  Normal end of execution.

I4VEC_UNIFORM_AB_TEST
  Python version: 3.6.5
  I4VEC_UNIFORM_AB computes pseudorandom values
  in an interval [A,B].

  The lower endpoint A = -100
  The upper endpoint B = 200
  The initial seed is 123456789


  The random vector:

     0     -35
     1     187
     2     149
     3      69
     4      25
     5     -81
     6     -23
     7     -67
     8     -87
     9      90
    10     -82
    11      35
    12      20
    13     127
    14     139
    15    -100
    16     170
    17       5
    18     -72
    19     -96

I4VEC_UNIFORM_AB_TEST:
  Normal end of execution.

PERM1_CHECK_TEST
  Python version: 3.6.5
  PERM1_CHECK checks a permutation of 1,...,N.

  Permutation 1:

     1   2   3   4   5
     5   2   3   4   1
  This is a permutation.

  Permutation 2:

     1   2   3   4   5
     4   1   3   0   2
  This is not a permutation.

  Permutation 3:

     1   2   3   4   5
     0   2   1   3   2
  This is not a permutation.

PERM1_CHECK_TEST:
  Normal end of execution.

PERM1_ENUM_TEST
  Python version: 3.6.5
  PERM1_ENUM enumerates the permutations of 1,...,N.

         N      PERM1_ENUM

         1             1
         2             2
         3             6
         4            24
         5           120
         6           720
         7          5040
         8         40320
         9        362880
        10       3628800

PERM1_ENUM_TEST
  Normal end of execution.

PERM1_INVERSE_TEST
  Python version: 3.6.5
  PERM1_INVERSE inverts a permutation of (1,...,N)

  The original permutation:

     1   2   3   4   5   6   7
     4   3   5   1   7   6   2

  The inverted permutation:

     1   2   3   4   5   6   7
     4   7   2   1   3   6   5

PERM1_INVERSE_TEST:
  Normal end of execution.

PERM1_LEX_NEXT_TEST
  Python version: 3.6.5
  PERM1_LEX_NEXT generates 1-based permutations in lexicographic order.

   0:   1   2   3   4
   1:   1   2   4   3
   2:   1   3   2   4
   3:   1   3   4   2
   4:   1   4   2   3
   5:   1   4   3   2
   6:   2   1   3   4
   7:   2   1   4   3
   8:   2   3   1   4
   9:   2   3   4   1
  10:   2   4   1   3
  11:   2   4   3   1
  12:   3   1   2   4
  13:   3   1   4   2
  14:   3   2   1   4
  15:   3   2   4   1
  16:   3   4   1   2
  17:   3   4   2   1
  18:   4   1   2   3
  19:   4   1   3   2
  20:   4   2   1   3
  21:   4   2   3   1
  22:   4   3   1   2
  23:   4   3   2   1

PERM1_LEX_NEXT_TEST:
  Normal end of execution.

PERM1_LEX_RANK_TEST
  Python version: 3.6.5
  PERM1_LEX_RANK returns the lexicographic rank of
  a permutation of (1,...,N).

  A 1-based permutation:

     1   2   3   4
     4   1   3   2

  Rank = 19

PERM1_LEX_RANK_TEST
  Normal end of execution.

PERM1_LEX_UNRANK_TEST
  Python version: 3.6.5
  PERM1_LEX_UNRANK returns the 1-based permutation
  of given lexicographic rank.

  Rank = 5

  The corresponding permutation:

     1   2   3   4
     1   4   3   2

PERM1_LEX_UNRANK_TEST
  Normal end of execution.

PERM1_PRINT_TEST
  Python version: 3.6.5
  PERM1_PRINT prints a permutation of (1,...,N).

  A 1-based permutation:

     1   2   3   4   5   6   7
     7   2   4   1   5   3   6

PERM1_PRINT_TEST
  Normal end of execution.

PERM1_RANDOM_TEST
  Python version: 3.6.5
  PERM1_RANDOM randomly selects a 1-based permutation.

     3  10   9   7   4   6   8   5   1   2
     7   2   6   3   9   5   1  10   4   8
     1   2   9   3   5   6   8  10   4   7
     4   9   5   8   1  10   3   6   7   2
     2   8   6   5   1   7   9   3   4  10

PERM1_RANDOM_TEST
  Normal end of execution.

PERM1_IS_UNICYCLE_TEST
  Python version: 3.6.5
  PERM1_IS_UNICYCLE determines whether a 1-based permutation
  is a unicyle

  This permutation is a unicycle

     1   2   3   4   5
     2   5   1   3   4

  The permutation in sequence form

     1     2     5     4     3

  This permutation is NOT a unicycle

     1   2   3   4   5
     3   2   1   4   5

  This permutation is NOT a unicycle

     1   2   3   4   5
     1   4   3   2   5

  This permutation is NOT a unicycle

     1   2   3   4   5
     3   5   2   4   1

  This permutation is NOT a unicycle

     1   2   3   4   5
     5   3   2   4   1

  This permutation is NOT a unicycle

     1   2   3   4   5
     5   1   3   4   2

  This permutation is NOT a unicycle

     1   2   3   4   5
     2   5   3   4   1

  This permutation is a unicycle

     1   2   3   4   5
     5   3   1   2   4

  The permutation in sequence form

     1     5     4     2     3

  This permutation is a unicycle

     1   2   3   4   5
     5   3   1   2   4

  The permutation in sequence form

     1     5     4     2     3

  This permutation is NOT a unicycle

     1   2   3   4   5
     1   5   4   3   2

PERM1_IS_UNICYCLE_TEST
  Normal end of execution.

UNICYCLE_CHECK_TEST
  Python version: 3.6.5
  UNICYCLE_CHECK checks a unicycle.

  Candidate 1:

     5     2     3     4     1
  This is not a unicycle.

  Candidate 2:

     4     1     3     0     2
  This is not a unicycle.

  Candidate 3:

     4     2     1     3     2
  This is not a unicycle.

  Candidate 4:

     2     1     4     3     5
  This is not a unicycle.

  Candidate 5:

     3     4     5     1     2
  This is a unicycle!

UNICYCLE_CHECK_TEST:
  Normal end of execution.

UNICYCLE_ENUM_TEST
  Python version: 3.6.5
  UNICYCLE_ENUM enumerates the unicycles of N objects.

  N    Number

    0         1
    1         1
    2         1
    3         2
    4         6
    5        24
    6       120
    7       720
    8      5040
    9     40320
   10    362880

UNICYCLE_ENUM_TEST
  Normal end of execution.

UNICYCLE_INDEX_TEST
  Python version: 3.6.5
  UNICYCLE_INDEX converts a unicycle to index form.

  The unicycle:

     1     3     6     2     4     5

  The index form:

     1   2   3   4   5   6
     3   4   6   5   1   2

  The unicycle recovered:

     1     3     6     2     4     5

  The unicycle:

     1     2     4     3     5     6

  The index form:

     1   2   3   4   5   6
     2   4   5   3   6   1

  The unicycle recovered:

     1     2     4     3     5     6

  The unicycle:

     1     2     4     5     6     3

  The index form:

     1   2   3   4   5   6
     2   4   1   5   6   3

  The unicycle recovered:

     1     2     4     5     6     3

  The unicycle:

     1     2     6     5     4     3

  The index form:

     1   2   3   4   5   6
     2   6   1   3   4   5

  The unicycle recovered:

     1     2     6     5     4     3

  The unicycle:

     1     6     2     4     5     3

  The index form:

     1   2   3   4   5   6
     6   4   1   5   3   2

  The unicycle recovered:

     1     6     2     4     5     3

UNICYCLE_INDEX_TEST
  UNICYCLE_INDEX converts a unicycle to index form.

UNICYCLE_INDEX_PRINT_TEST
  Python version: 3.6.5
  UNICYCLE_INDEX_PRINT prints a unicyle given in index form;


  The unicycle in index form:

     1   2   3   4   5   6   7
     7   1   4   5   2   3   6

UNICYCLE_INDEX_PRINT_TEST
  Normal end of execution.

UNICYCLE_INDEX_TO_SEQUENCE_TEST
  Python version: 3.6.5
  UNICYCLE_INDEX_TO_SEQUENCE converts an index to unicycle form.

  The unicycle:

     1     3     6     2     4     5

  The index form:

     1   2   3   4   5   6
     3   4   6   5   1   2

  The unicycle recovered:

     1     3     6     2     4     5

  The unicycle:

     1     2     4     3     5     6

  The index form:

     1   2   3   4   5   6
     2   4   5   3   6   1

  The unicycle recovered:

     1     2     4     3     5     6

  The unicycle:

     1     2     4     5     6     3

  The index form:

     1   2   3   4   5   6
     2   4   1   5   6   3

  The unicycle recovered:

     1     2     4     5     6     3

  The unicycle:

     1     2     6     5     4     3

  The index form:

     1   2   3   4   5   6
     2   6   1   3   4   5

  The unicycle recovered:

     1     2     6     5     4     3

  The unicycle:

     1     6     2     4     5     3

  The index form:

     1   2   3   4   5   6
     6   4   1   5   3   2

  The unicycle recovered:

     1     6     2     4     5     3

UNICYCLE_INDEX_TO_SEQUENCE_TEST
  Normal end of execution.

UNICYCLE_INVERSE_TEST
  Python version: 3.6.5
  UNICYCLE_INVERSE inverts a unicycle

  The original unicycle:

     1     7     6     2     4     3     5

  The inverse unicycle:

     1     5     3     4     2     6     7

UNICYCLE_INVERSE_TEST
  Normal end of execution.

UNICYCLE_NEXT_TEST
  Python version: 3.6.5
  UNICYCLE_NEXT generates unicycles in lex order.

    0:   1 2 3 4 5
    1:   1 2 3 5 4
    2:   1 2 4 3 5
    3:   1 2 4 5 3
    4:   1 2 5 3 4
    5:   1 2 5 4 3
    6:   1 3 2 4 5
    7:   1 3 2 5 4
    8:   1 3 4 2 5
    9:   1 3 4 5 2
   10:   1 3 5 2 4
   11:   1 3 5 4 2
   12:   1 4 2 3 5
   13:   1 4 2 5 3
   14:   1 4 3 2 5
   15:   1 4 3 5 2
   16:   1 4 5 2 3
   17:   1 4 5 3 2
   18:   1 5 2 3 4
   19:   1 5 2 4 3
   20:   1 5 3 2 4
   21:   1 5 3 4 2
   22:   1 5 4 2 3
   23:   1 5 4 3 2

UNICYCLE_NEXT_TEST
  Normal end of execution.

UNICYCLE_RANDOM_TEST
  Python version: 3.6.5
  UNICYCLE_RANDOM produces a random unicyle;
  For this test, N = 5

     1     2     5     3     4
     1     3     2     4     5
     1     2     4     3     5
     1     3     5     2     4
     1     5     4     3     2

UNICYCLE_RANDOM_TEST
  Normal end of execution.

UNICYCLE_RANK_TEST
  Python version: 3.6.5
  UNICYCLE_RANK ranks a unicycle.

  The unicycle:

     1     5     2     3     4

  The rank is: 18

UNICYCLE_RANK_TEST
  Normal end of execution.

UNICYCLE_UNRANK_TEST
  Python version: 3.6.5
  UNICYCLE_UNRANK, given a rank, computes the
  corresponding unicycle.

  The requested rank is 6

  The unicycle:

     1     3     2     4     5

UNICYCLE_UNRANK_TEST
  Normal end of execution.

UNICYCLE_TEST:
  Normal end of execution.
Thu Sep 13 18:30:57 2018