# include <stdint.h>
# include <stdio.h>
# include <stdlib.h>

# include "ziggurat_inline.h"

int main ( );
void ziggurat_inline_test01 ( );
void ziggurat_inline_test02 ( );
void ziggurat_inline_test03 ( );
void ziggurat_inline_test04 ( );
void ziggurat_inline_test05 ( int sample_num );
void ziggurat_inline_test06 ( int sample_num );
void ziggurat_inline_test07 ( int sample_num );
void ziggurat_inline_test08 ( int sample_num );
void ziggurat_inline_test09 ( );
void ziggurat_inline_test10 ( );
void ziggurat_inline_test11 ( );
void ziggurat_inline_test12 ( );

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

int main ( )

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

    ziggurat_inline_test() tests ziggurat_inline().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  int sample_num = 1000000;

  timestamp ( );
  printf ( "\n" );
  printf ( "ziggurat_inline_test():\n" );
  printf ( "  C version:\n" );
  printf ( "  Test ziggurat_inline().\n" );
/*
  Make sure that SEED controls the sequence, and can restart it.
*/
  ziggurat_inline_test01 ( );
  ziggurat_inline_test02 ( );
  ziggurat_inline_test03 ( );
  ziggurat_inline_test04 ( );
/*
  Measure the time it takes to generate 10,000 variables.
*/
  ziggurat_inline_test05 ( sample_num );
  ziggurat_inline_test06 ( sample_num );
  ziggurat_inline_test07 ( sample_num );
  ziggurat_inline_test08 ( sample_num );
/*
  List 10 successive values of the unsigned int 32 bit generators.
*/
  ziggurat_inline_test09 ( );
  ziggurat_inline_test10 ( );
  ziggurat_inline_test11 ( );
  ziggurat_inline_test12 ( );
/*
  Terminate.
*/
  printf ( "\n" );
  printf ( "ziggurat_inline_test():\n" );
  printf ( "  Normal end of execution.\n" );
  printf ( "\n" );
  timestamp ( );

  return 0;
}
/******************************************************************************/

void ziggurat_inline_test01 ( )

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

    ziggurat_inline_test01() tests kiss_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  int i;
  int j;
  uint32_t jcong_value;
  uint32_t jsr_value;
  uint32_t value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test01()\n" );
  printf ( "  kiss_value() is an inline generator of pseudorandom uniformly\n" );
  printf ( "  distributed uint32_t's.\n" );

  for ( j = 0; j < 3; j++ )
  {
    if ( ( j % 2 ) == 0 )
    {
      jsr_value = 123456789;
      jcong_value = 234567891;
      w_value = 345678912;
      z_value = 456789123;
    }
    else
    {
      jsr_value = 987654321;
      jcong_value = 198765432;
      w_value = 219876543;
      z_value = 321987654;
    }

    printf ( "\n" );
    printf ( "  Call zigset() with these seeds:\n" );
    printf ( "\n" );
    printf ( "  jsr_value   = %u\n", jsr_value );
    printf ( "  jcong_value = %u\n", jcong_value );
    printf ( "  w_value     = %u\n", w_value );
    printf ( "  z_value     = %u\n", z_value );
    printf ( "\n" );
/*
  Call zigset() to set the seed.
*/
    zigset ( jsr_value, jcong_value, w_value, z_value );

    for ( i = 1; i <= 10; i++ )
    {
      value = kiss_value ( );
      printf ( "  %6d  %12u\n", i, value );
    }
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test02 ( )

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

    ziggurat_inline_test02() tests r4_uni_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  int i;
  int j;
  uint32_t jcong_value;
  uint32_t jsr_value;
  float value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test02()\n" );
  printf ( "  r4_uni_value() is an inline generator of pseudorandom uniformly\n" );
  printf ( "  distributed floats between 0 and 1.\n" );

  for ( j = 0; j < 3; j++ )
  {
    if ( ( j % 2 ) == 0 )
    {
      jsr_value = 123456789;
      jcong_value = 234567891;
      w_value = 345678912;
      z_value = 456789123;
    }
    else
    {
      jsr_value = 987654321;
      jcong_value = 198765432;
      w_value = 219876543;
      z_value = 321987654;
    }

    printf ( "\n" );
    printf ( "  Call zigset() with these seeds:\n" );
    printf ( "\n" );
    printf ( "  jsr_value   = %u\n", jsr_value );
    printf ( "  jcong_value = %u\n", jcong_value );
    printf ( "  w_value     = %u\n", w_value );
    printf ( "  z_value     = %u\n", z_value );
    printf ( "\n" );
/*
  Call zigset() to set the seed.
*/
    zigset ( jsr_value, jcong_value, w_value, z_value );

    for ( i = 1; i <= 10; i++ )
    {
      value = r4_uni_value ( );
      printf ( "  %6d  %14f\n", i, value );
    }
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test03 ( )

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

    ziggurat_inline_test03() tests r4_nor_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  int i;
  int j;
  uint32_t jcong_value;
  uint32_t jsr_value;
  float value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test03():\n" );
  printf ( "  r4_nor_value() is an inline generator of pseudorandom normally\n" );
  printf ( "  distributed floats.\n" );

  for ( j = 0; j < 3; j++ )
  {
    if ( ( j % 2 ) == 0 )
    {
      jsr_value = 123456789;
      jcong_value = 234567891;
      w_value = 345678912;
      z_value = 456789123;
    }
    else
    {
      jsr_value = 987654321;
      jcong_value = 198765432;
      w_value = 219876543;
      z_value = 321987654;
    }

    printf ( "\n" );
    printf ( "  Call zigset() with these seeds:\n" );
    printf ( "\n" );
    printf ( "  jsr_value   = %u\n", jsr_value );
    printf ( "  jcong_value = %u\n", jcong_value );
    printf ( "  w_value     = %u\n", w_value );
    printf ( "  z_value     = %u\n", z_value );
    printf ( "\n" );
/*
  Call zigset() to set the seed.
*/
    zigset ( jsr_value, jcong_value, w_value, z_value );

    for ( i = 1; i <= 10; i++ )
    {
      value = r4_nor_value ( );
      printf ( "  %6d  %14f\n", i, value );
    }
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test04 ( )

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

    ziggurat_inline_test04() tests r4_exp_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  int i;
  int j;
  uint32_t jcong_value;
  uint32_t jsr_value;
  float value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test04():\n" );
  printf ( "  r4_exp_value() is an inline generator of pseudorandom exponentially\n" );
  printf ( "  distributed floats.\n" );

  for ( j = 0; j < 3; j++ )
  {
    if ( ( j % 2 ) == 0 )
    {
      jsr_value = 123456789;
      jcong_value = 234567891;
      w_value = 345678912;
      z_value = 456789123;
    }
    else
    {
      jsr_value = 987654321;
      jcong_value = 198765432;
      w_value = 219876543;
      z_value = 321987654;
    }

    printf ( "\n" );
    printf ( "  Call zigset() with these seeds:\n" );
    printf ( "\n" );
    printf ( "  jsr_value   = %u\n", jsr_value );
    printf ( "  jcong_value = %u\n", jcong_value );
    printf ( "  w_value     = %u\n", w_value );
    printf ( "  z_value     = %u\n", z_value );
    printf ( "\n" );
/*
  Call zigset() to set the seed.
*/
    zigset ( jsr_value, jcong_value, w_value, z_value );

    for ( i = 1; i <= 10; i++ )
    {
      value = r4_exp_value ( );
      printf ( "  %6d  %14f\n", i, value );
    }
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test05 ( int sample_num )

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

    ziggurat_inline_test05() times kiss_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  double ctime;
  uint32_t jcong_value;
  uint32_t jsr_value;
  int sample;
  uint32_t value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test05():\n" );
  printf ( "  Measure the time it takes kiss_value() to generate\n" );
  printf ( "  %d uint32_t values.\n", sample_num );
/*
  Call zigset() to set the seed.
*/
  jsr_value = 123456789;
  jcong_value = 234567891;
  w_value = 345678912;
  z_value = 456789123;
  zigset ( jsr_value, jcong_value, w_value, z_value );

  ctime = cpu_time ( );

  for ( sample = 0; sample < sample_num; sample++ )
  {
    value = kiss_value ( );
  }
  ctime = cpu_time ( ) - ctime;

  printf ( "\n" );
  printf ( "  Final value of kiss_value() is %d\n", value );
  printf ( "  %f seconds.\n", ctime );

  return;
}
/******************************************************************************/

void ziggurat_inline_test06 ( int sample_num )

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

    ziggurat_inline_test06() times r4_uni_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  double ctime;
  uint32_t jcong_value;
  uint32_t jsr_value;
  int sample;
  float value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test06():\n" );
  printf ( "  Measure the time it takes r4_uni_value() to generate\n" );
  printf ( "  %d uniformly random float values.\n", sample_num );
/*
  Call zigset() to set the seed.
*/
  jsr_value = 123456789;
  jcong_value = 234567891;
  w_value = 345678912;
  z_value = 456789123;
  zigset ( jsr_value, jcong_value, w_value, z_value );

  ctime = cpu_time ( );

  for ( sample = 0; sample < sample_num; sample++ )
  {
    value = r4_uni_value ( );
  }
  ctime = cpu_time ( ) - ctime;

  printf ( "\n" );
  printf ( "  Final value of r4_uni_value() is %f\n", value );
  printf ( "  %f seconds.\n", ctime );

  return;
}
/******************************************************************************/

void ziggurat_inline_test07 ( int sample_num )

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

    ziggurat_inline_test07() times r4_nor_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  double ctime;
  uint32_t jcong_value;
  uint32_t jsr_value;
  int sample;
  float value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test07():\n" );
  printf ( "  Measure the time it takes r4_nor_value() to generate\n" );
  printf ( "  %d normal random float values.\n", sample_num );
/*
  Call zigset() to set the seed.
*/
  jsr_value = 123456789;
  jcong_value = 234567891;
  w_value = 345678912;
  z_value = 456789123;
  zigset ( jsr_value, jcong_value, w_value, z_value );

  ctime = cpu_time ( );

  for ( sample = 0; sample < sample_num; sample++ )
  {
    value = r4_nor_value ( );
  }
  ctime = cpu_time ( ) - ctime;

  printf ( "\n" );
  printf ( "  Final value of r4_nor_value() is %f\n", value );
  printf ( "  %f seconds.\n", ctime );

  return;
}
/******************************************************************************/

void ziggurat_inline_test08 ( int sample_num )

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

    ziggurat_inline_test08() times r4_exp_value().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    04 October 2013

  Author:

    John Burkardt
*/
{
  double ctime;
  uint32_t jcong_value;
  uint32_t jsr_value;
  int sample;
  float value;
  uint32_t w_value;
  uint32_t z_value;

  printf ( "\n" );
  printf ( "ziggurat_inline_test08()\n" );
  printf ( "  Measure the time it takes r4_exp_value() to generate\n" );
  printf ( "  %d exponential random float values.\n", sample_num );
/*
  Call zigset() to set the seeds.
*/
  jsr_value = 123456789;
  jcong_value = 234567891;
  w_value = 345678912;
  z_value = 456789123;
  zigset ( jsr_value, jcong_value, w_value, z_value );

  ctime = cpu_time ( );

  for ( sample = 0; sample < sample_num; sample++ )
  {
    value = r4_exp_value ( );
  }
  ctime = cpu_time ( ) - ctime;

  printf ( "\n" );
  printf ( "  Final value of r4_exp_value() is %f\n", value );
  printf ( "  %f seconds.\n", ctime );

  return;
}
/******************************************************************************/

void ziggurat_inline_test09 ( )

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

    ziggurat_inline_test09() tests cong_seeded().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    16 October 2013

  Author:

    John Burkardt
*/
{
  int j;
  uint32_t jcong_new;
  uint32_t jcong_in;
  uint32_t jcong_old;

  printf ( "\n" );
  printf ( "ziggurat_inline_test09():\n" );
  printf ( "  cong_seeded() is a generator of pseudorandom uniformly\n" );
  printf ( "  distributed unsigned 32 bit integers.\n" );
  printf ( "\n" );
  printf ( "    Input Seed   Output Seed  Output Value\n" );
  printf ( "\n" );

  jcong_new = 234567891;

  for ( j = 1; j <= 10; j++ )
  {
    jcong_old = jcong_new;
    jcong_in = jcong_new;
    jcong_new = cong_seeded ( &jcong_in );
    printf ( "  %12u  %12u  %12u\n", jcong_old, jcong_in, jcong_new );
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test10 ( )

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

    ziggurat_inline_test10() tests kiss_seeded().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    16 October 2013

  Author:

    John Burkardt
*/
{
  int j;
  uint32_t jcong_in;
  uint32_t jcong_old;
  uint32_t jsr_in;
  uint32_t jsr_old;
  uint32_t w_in;
  uint32_t w_old;
  uint32_t value;
  uint32_t z_in;
  uint32_t z_old;

  printf ( "\n" );
  printf ( "ziggurat_inline_test10()\n" );
  printf ( "  kiss_seeded() is a generator of pseudorandom uniformly\n" );
  printf ( "  distributed unsigned 32 bit integers.\n" );
  printf ( "\n" );
  printf ( "              JCONG           JSR             W             Z         Value\n" );
  printf ( "\n" );

  jcong_in = 234567891;
  jsr_in = 123456789;
  w_in = 345678912;
  z_in = 456789123;

  for ( j = 1; j <= 10; j++ )
  {
    jcong_old = jcong_in;
    jsr_old = jsr_in;
    w_old = w_in;
    z_old = z_in;
    value = kiss_seeded ( &jcong_in, &jsr_in, &w_in, &z_in );
    printf ( "  In   %12u  %12u  %12u  %12u\n", jcong_old, jsr_old, w_old, z_old );
    printf ( "  Out  %12u  %12u  %12u  %12u  %12u\n", jcong_in, jsr_in, w_in, z_in, value );
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test11 ( )

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

    ziggurat_inline_test11() tests mwc_seeded().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    16 October 2013

  Author:

    John Burkardt
*/
{
  int j;
  uint32_t w_in;
  uint32_t w_old;
  uint32_t value;
  uint32_t z_in;
  uint32_t z_old;

  printf ( "\n" );
  printf ( "ziggurat_inline_test11()\n" );
  printf ( "  mwc_seeded() is a generator of pseudorandom uniformly\n" );
  printf ( "  distributed unsigned 32 bit integers.\n" );
  printf ( "\n" );
  printf ( "       Input W       Input Z      Output W      Output Z  Output Value\n" );
  printf ( "\n" );

  w_in = 345678912;
  z_in = 456789123;

  for ( j = 1; j <= 10; j++ )
  {
    w_old = w_in;
    z_old = z_in;
    value = mwc_seeded ( &w_in, &z_in );
    printf ( "  %12u  %12u  %12u  %12u  %12u\n", w_old, z_old, w_in, z_in, value );
  }

  return;
}
/******************************************************************************/

void ziggurat_inline_test12 ( )

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

    ziggurat_inline_test12() tests shr3_seeded().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    16 October 2013

  Author:

    John Burkardt
*/
{
  int j;
  uint32_t jsr_new;
  uint32_t jsr_in;
  uint32_t jsr_old;

  printf ( "\n" );
  printf ( "ziggurat_inline_test12()\n" );
  printf ( "  shr3_seeded() is a generator of pseudorandom uniformly\n" );
  printf ( "  distributed unsigned 32 bit integers.\n" );
  printf ( "\n" );
  printf ( "    Input Seed   Output Seed  Output Value\n" );
  printf ( "\n" );

  jsr_new = 123456789;

  for ( j = 1; j <= 10; j++ )
  {
    jsr_old = jsr_new;
    jsr_in = jsr_new;
    jsr_new = shr3_seeded ( &jsr_in );
    printf ( "  %12u  %12u  %12u\n", jsr_old, jsr_in, jsr_new );
  }

  return;
}