# include <complex.h>
# include <math.h>
# include <stdio.h>
# include <stdlib.h>
# include <time.h>

# include "polyomino_enumerate.h"

/******************************************************************************/

void polyomino_enumerate_chiral ( int *n_data, int *order, 
  long long int *number )

/******************************************************************************/
/*
  Purpose:

    POLYOMINO_ENUMERATE_CHIRAL counts chiral polyominoes (allowing holes).

  Discussion:

    Polyominoes are connected planar shapes formed by adjoining unit squares.

    The number of unit squares in a polyomino is its order.

    If we do not ignore reflections, but ignore rotations when comparing 
    then we are considering the class of "chiral" polyominoes.  In that case,
    for instance, there are 18 chiral polyominoes of order 5.

    As the order increases, the number of polyominoes grows very rapidly.
    The list offered here goes no further than order 28, but the later
    numbers in the list are too large to represent as 32 byte integers. 

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    18 May 2018

  Author:

    John Burkardt

  Reference:

    Solomon Golomb,
    Polyominoes: Puzzles, Patterns, Problems, and Packings,
    Princeton University Press, 1996,
    ISBN: 9780691024448

  Parameters:

    Input/output, int *N_DATA.  The user sets N_DATA to 0 
    before the first call.  On each call, the routine increments N_DATA by 1, 
    and returns the corresponding data; when there is no more data, the
    output value of N_DATA will be 0 again.

    Output, int *ORDER, the order of a polyomino.

    Output, long long int *NUMBER, the number of chiral polyominos 
    of this order.
*/
{
# define N_MAX 31

  static long long int number_vec[N_MAX] = {
    1L, 
    1L,
    1L,
    2L,
    7L,
    18L, 
    60L,
    196L,
    704L,
    2500L,
    9189L, 
    33896L,
    126759L,
    476270L,
    1802312L,
    6849777L, 
    26152418L,
    100203194L,
    385221143L,
    1485200848L,
    5741256764L, 
    22245940545L,
    86383382827L,
    336093325058L,
    1309998125640L,
    5114451441106L, 
    19998172734786L,
    78306011677182L,
    307022182222506L,
    1205243866707468L,
    4736694001644862L };
  static int order_vec[N_MAX] = {
    0, 
    1,  2,  3,  4,  5, 
    6,  7,  8,  9, 10, 
   11, 12, 13, 14, 15, 
   16, 17, 18, 19, 20, 
   21, 22, 23, 24, 25, 
   26, 27, 28, 29, 30 };

  if ( *n_data < 0 )
  {
    *n_data = 0;
  }

  *n_data = *n_data + 1;

  if ( N_MAX < *n_data )
  {
    *n_data = 0;
    *order = 0;
    *number = 0;
  }
  else
  {
    *order = order_vec[*n_data-1];
    *number = number_vec[*n_data-1];
  }

  return;
# undef N_MAX
}
/******************************************************************************/

void polyomino_enumerate_fixed ( int *n_data, int *order, 
  long long int *number )

/******************************************************************************/
/*
  Purpose:

    POLYOMINO_ENUMERATE_FIXED counts fixed polyominoes (allowing holes).

  Discussion:

    Polyominoes are connected planar shapes formed by adjoining unit squares.

    The number of unit squares in a polyomino is its order.

    If we do not ignore reflections and rotations when comparing polyominoes,
    then we are considering the class of "fixed" polyominoes.  In that case,
    for instance, there are 65 fixed polyominoes of order 5.

    As the order increases, the number of polyominoes grows very rapidly.
    The list offered here goes no further than order 28, but the later
    numbers in the list are too large to represent as 32 byte integers. 

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    12 April 2018

  Author:

    John Burkardt

  Reference:

    Solomon Golomb,
    Polyominoes: Puzzles, Patterns, Problems, and Packings,
    Princeton University Press, 1996,
    ISBN: 9780691024448

  Parameters:

    Input/output, int *N_DATA.  The user sets N_DATA to 0 
    before the first call.  On each call, the routine increments N_DATA by 1, 
    and returns the corresponding data; when there is no more data, the
    output value of N_DATA will be 0 again.

    Output, int *ORDER, the order of a polyomino.

    Output, long long int *NUMBER, the number of fixed polyominos 
    of this order.
*/
{
# define N_MAX 29

  static long long int number_vec[N_MAX] = {  
    1L, 
    1L, 
    2L, 
    6L, 
    19L, 
    63L, 
    216L, 
    760L, 
    2725L, 
    9910L, 
    36446L, 
    135268L, 
    505861L, 
    1903890L, 
    7204874L, 
    27394666L, 
    104592937L, 
    400795844L, 
    1540820542L, 
    5940738676L, 
    22964779660L, 
    88983512783L, 
    345532572678L, 
    1344372335524L, 
    5239988770268L, 
    20457802016011L, 
    79992676367108L, 
    313224032098244L, 
    1228088671826973L };
  static int order_vec[N_MAX] = {
    0, 
    1,  2,  3,  4,  5, 
    6,  7,  8,  9, 10, 
   11, 12, 13, 14, 15, 
   16, 17, 18, 19, 20, 
   21, 22, 23, 24, 25, 
   26, 27, 28 };

  if ( *n_data < 0 )
  {
    *n_data = 0;
  }

  *n_data = *n_data + 1;

  if ( N_MAX < *n_data )
  {
    *n_data = 0;
    *order = 0;
    *number = 0;
  }
  else
  {
    *order = order_vec[*n_data-1];
    *number = number_vec[*n_data-1];
  }

  return;
# undef N_MAX
}
/******************************************************************************/

void polyomino_enumerate_free ( int *n_data, int *order, 
  long long int *number )

/******************************************************************************/
/*
  Purpose:

    POLYOMINO_ENUMERATE_FREE counts free polyominoes (allowing holes).

  Discussion:

    Polyominoes are connected planar shapes formed by adjoining unit squares.

    The number of unit squares in a polyomino is its order.

    If we ignore reflections and rotations when comparing polyominoes,
    then we are considering the class of "free" polyominoes.  In that case,
    for instance, there are just 12 free polyominoes of order 5, the
    so called "pentominoes".

    As the order increases, the number of polyominoes grows very rapidly.
    The list offered here goes no further than order 28, but the later
    numbers in the list are too large to represent as 32 byte integers. 

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    12 April 2018

  Author:

    John Burkardt

  Reference:

    Solomon Golomb,
    Polyominoes: Puzzles, Patterns, Problems, and Packings,
    Princeton University Press, 1996,
    ISBN: 9780691024448

  Parameters:

    Input/output, int *N_DATA.  The user sets N_DATA to 0 
    before the first call.  On each call, the routine increments N_DATA by 1, 
    and returns the corresponding data; when there is no more data, the
    output value of N_DATA will be 0 again.

    Output, int *ORDER, the order of a polyomino.

    Output, long long int *NUMBER, the number of free polyominos of 
    this order.
*/
{
# define N_MAX 29

  static long long int number_vec[N_MAX] = {  
    1L,   
    1L, 
    1L, 
    2L, 
    5L, 
    12L, 
    35L, 
    108L, 
    369L, 
    1285L, 
    4655L, 
    17073L, 
    63600L, 
    238591L, 
    901971L, 
    3426576L, 
    13079255L, 
    50107909L, 
    192622052L, 
    742624232L, 
    2870671950L, 
    11123060678L, 
    43191857688L, 
    168047007728L, 
    654999700403L, 
    2557227044764L, 
    9999088822075L, 
    39153010938487L, 
    153511100594603L };
  static int order_vec[N_MAX] = {  
    0, 
    1,  2,  3,  4,  5, 
    6,  7,  8,  9, 10, 
   11, 12, 13, 14, 15, 
   16, 17, 18, 19, 20, 
   21, 22, 23, 24, 25, 
   26, 27, 28 };

  if ( *n_data < 0 )
  {
    *n_data = 0;
  }

  *n_data = *n_data + 1;

  if ( N_MAX < *n_data )
  {
    *n_data = 0;
    *order = 0;
    *number = 0;
  }
  else
  {
    *order = order_vec[*n_data-1];
    *number = number_vec[*n_data-1];
  }

  return;
# undef N_MAX
}
/******************************************************************************/

void timestamp ( )

/******************************************************************************/
/*
  Purpose:

    TIMESTAMP prints the current YMDHMS date as a time stamp.

  Example:

    31 May 2001 09:45:54 AM

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    24 September 2003

  Author:

    John Burkardt

  Parameters:

    None
*/
{
# define TIME_SIZE 40

  static char time_buffer[TIME_SIZE];
  const struct tm *tm;
  time_t now;

  now = time ( NULL );
  tm = localtime ( &now );

  strftime ( time_buffer, TIME_SIZE, "%d %B %Y %I:%M:%S %p", tm );

  printf ( "%s\n", time_buffer );

  return;
# undef TIME_SIZE
}