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

# include "polynomial_conversion.h"

int main ( );

void bernstein_legendre01_bernstein_test ( );
void bernstein_monomial_bernstein_test ( );
void bernstein_to_legendre01_test ( );
void bernstein_to_legendre01_matrix_test ( );
void bernstein_to_monomial_test ( );
void bernstein_to_monomial_matrix_test ( );
void chebyshev_monomial_chebyshev_test ( );
void chebyshev_to_monomial_test ( );
void gegenbauer_monomial_gegenbauer_test ( );
void gegenbauer_to_monomial_test ( );
void gegenbauer_to_monomial_matrix_test ( );
void hermite_monomial_hermite_test ( );
void hermite_to_monomial_test ( );
void hermite_to_monomial_matrix_test ( );
void laguerre_monomial_laguerre_test ( );
void laguerre_to_monomial_test ( );
void laguerre_to_monomial_matrix_test ( );
void legendre_monomial_legendre_test ( );
void legendre_to_monomial_test ( );
void legendre_to_monomial_matrix_test ( );
void legendre01_to_bernstein_test ( );
void legendre01_to_bernstein_matrix_test ( );
void monomial_to_bernstein_test ( );
void monomial_to_bernstein_matrix_test ( );
void monomial_to_chebyshev_test ( );
void monomial_to_gegenbauer_test ( );
void monomial_to_gegenbauer_matrix_test ( );
void monomial_to_hermite_test ( );
void monomial_to_hermite_matrix_test ( );
void monomial_to_laguerre_test ( );
void monomial_to_laguerre_matrix_test ( );
void monomial_to_legendre_test ( );
void monomial_to_legendre_matrix_test ( );
double r8vec_diff_norm_l2 ( int n, double a[], double b[] );
void timestamp ( );

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

int main ( )

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

    polynomial_conversion_test() tests polynomial_conversion().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    25 April 2024

  Author:

    John Burkardt
*/
{
  timestamp ( );
  printf ( "\n" );
  printf ( "polynomial_conversion_test ( )\n" );
  printf ( "  C version\n" );
  printf ( "  Test polynomial_conversion().\n" );

  bernstein_to_legendre01_test ( );
  bernstein_to_legendre01_matrix_test ( );
  legendre01_to_bernstein_test ( );
  legendre01_to_bernstein_matrix_test ( );
  bernstein_legendre01_bernstein_test ( );

  bernstein_to_monomial_test ( );
  bernstein_to_monomial_matrix_test ( );
  monomial_to_bernstein_test ( );
  monomial_to_bernstein_matrix_test ( );
  bernstein_monomial_bernstein_test ( );

  chebyshev_to_monomial_test ( );
  monomial_to_chebyshev_test ( );
  chebyshev_monomial_chebyshev_test ( );

  gegenbauer_to_monomial_test ( );
  gegenbauer_to_monomial_matrix_test ( );
  monomial_to_gegenbauer_test ( );
  monomial_to_gegenbauer_matrix_test ( );
  gegenbauer_monomial_gegenbauer_test ( );

  hermite_to_monomial_test ( );
  hermite_to_monomial_matrix_test ( );
  monomial_to_hermite_test ( );
  monomial_to_hermite_matrix_test ( );
  hermite_monomial_hermite_test ( );

  laguerre_to_monomial_test ( );
  laguerre_to_monomial_matrix_test ( );
  monomial_to_laguerre_test ( );
  monomial_to_laguerre_matrix_test ( );
  laguerre_monomial_laguerre_test ( );

  legendre_to_monomial_test ( );
  legendre_to_monomial_matrix_test ( );
  monomial_to_legendre_test ( );
  monomial_to_legendre_matrix_test ( );
  legendre_monomial_legendre_test ( );
/*
  Terminate.
*/
  printf ( "\n" );
  printf ( "polynomial_conversion_test():\n" );
  printf ( "  Normal end of execution.\n" );

  timestamp ( );

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

void bernstein_legendre01_bernstein_test ( )

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

    bernstein_legendre01_bernstein_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    24 February 2024

  Author:

    John Burkardt
*/
{
  double *bcoef;
  double *bcoef2;
  double e;
  int i;
  double *lcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "bernstein_legendre01_bernstein_test ( )\n" );
  printf ( "  Convert a polynomial from Bernstein form\n" );
  printf ( "  to Legendre01 form and back.\n" );

  srand48 ( seed );

  n = 10;
  bcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    bcoef[i] = drand48 ( );
  }
  lcoef = bernstein_to_legendre01 ( n, bcoef );
  bcoef2 = legendre01_to_bernstein ( n, lcoef );

  e = r8vec_diff_norm_l2 ( n + 1, bcoef, bcoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( bcoef );
  free ( bcoef2 );
  free ( lcoef );

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

void bernstein_monomial_bernstein_test ( )

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

    bernstein_monomial_bernstein_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double *bcoef;
  double *bcoef2;
  double e;
  int i;
  double *mcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "bernstein_monomial_bernstein_test ( )\n" );
  printf ( "  Convert a polynomial from Bernstein form\n" );
  printf ( "  to monomial form and back.\n" );

  srand48 ( seed );

  n = 10;
  bcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    bcoef[i] = drand48 ( );
  }
  mcoef = bernstein_to_monomial ( n, bcoef );
  bcoef2 = monomial_to_bernstein ( n, mcoef );

  e = r8vec_diff_norm_l2 ( n + 1, bcoef, bcoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( bcoef );
  free ( bcoef2 );
  free ( mcoef );

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

void bernstein_to_legendre01_test ( )

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

    bernstein_to_legendre01_test() tests bernstein_to_legendre01().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    24 February 2024

  Author:

    John Burkardt
*/
{
  double *bcoef;
  int k;
  double *lcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "bernstein_to_legendre01_test ( )\n" );
  printf ( "  bernstein_to_legendre01() converts a\n" );
  printf ( "  polynomial from Bernstein form\n" );
  printf ( "  to Legendre01 form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "P%d(X)     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    bcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      bcoef[k] = 0.0;
    }
    bcoef[n] = 1.0;
    lcoef = bernstein_to_legendre01 ( n, bcoef );
    printf ( "B%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", lcoef[k] );
    }
    printf ( "\n" );
    free ( bcoef );
    free ( lcoef );
  }

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

void bernstein_to_legendre01_matrix_test ( )

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

    bernstein_to_legendre01_matrix_test() tests bernstein_to_legendre01_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    24 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "bernstein_to_legendre01_matrix_test ( )\n" );
  printf ( "  bernstein_to_legendre01_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Bernstein form\n" );
  printf ( "  to Legendre01 form.\n" );

  n = 5;
  A = bernstein_to_legendre01_matrix ( n );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void bernstein_to_monomial_test ( )

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

    bernstein_to_monomial_test() tests bernstein_to_monomial().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double *bcoef;
  int k;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "bernstein_to_monomial_test ( )\n" );
  printf ( "  bernstein_to_monomial() converts a\n" );
  printf ( "  polynomial from Bernstein form\n" );
  printf ( "  to monomial form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "X^%d     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    bcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      bcoef[k] = 0.0;
    }
    bcoef[n] = 1.0;
    mcoef = bernstein_to_monomial ( n, bcoef );
    printf ( "B%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", mcoef[k] );
    }
    printf ( "\n" );
    free ( bcoef );
    free ( mcoef );
  }

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

void bernstein_to_monomial_matrix_test ( )

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

    bernstein_to_monomial_matrix_test() tests bernstein_to_monomial_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "bernstein_to_monomial_matrix_test ( )\n" );
  printf ( "  bernstein_to_monomial_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Bernstein form\n" );
  printf ( "  to monomial form.\n" );

  n = 4;
  A = bernstein_to_monomial_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void chebyshev_monomial_chebyshev_test ( )

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

    chebyshev_monomial_chebyshev_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    19 February 2024

  Author:

    John Burkardt
*/
{
  double *ccoef;
  double *ccoef2;
  double e;
  int i;
  double *mcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "chebyshev_monomial_chebyshev_test ( )\n" );
  printf ( "  Convert a polynomial from Chebyshev form\n" );
  printf ( "  to monomial form and back.\n" );

  srand48 ( seed );

  n = 10;
  ccoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    ccoef[i] = drand48 ( );
  }
  mcoef = chebyshev_to_monomial ( n, ccoef );
  ccoef2 = monomial_to_chebyshev ( n, mcoef );

  e = r8vec_diff_norm_l2 ( n + 1, ccoef, ccoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( ccoef );
  free ( ccoef2 );
  free ( mcoef );

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

void chebyshev_to_monomial_test ( )

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

    chebyshev_to_monomial_test() tests chebyshev_to_monomial().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    19 February 2024

  Author:

    John Burkardt
*/
{
  double *ccoef;
  int k;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "chebyshev_to_monomial_test ( )\n" );
  printf ( "  chebyshev_to_monomial() converts a\n" );
  printf ( "  polynomial from Chebyshev form\n" );
  printf ( "  to monomial form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "X^%d     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    ccoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      ccoef[k] = 0.0;
    }
    ccoef[n] = 1.0;
    mcoef = chebyshev_to_monomial ( n, ccoef );
    printf ( "T%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", mcoef[k] );
    }
    printf ( "\n" );
    free ( ccoef );
    free ( mcoef );
  }

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

void gegenbauer_monomial_gegenbauer_test ( )

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

    gegenbauer_monomial_gegenbauer_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    25 April 2024

  Author:

    John Burkardt
*/
{
  double alpha;
  double e;
  double *gcoef;
  double *gcoef2;
  int i;
  double *mcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "gegenbauer_monomial_gegenbauer_test ( )\n" );
  printf ( "  Convert a polynomial from Gegenbauer form\n" );
  printf ( "  to monomial form and back.\n" );

  srand48 ( seed );

  alpha = 0.5;
  printf ( "\n" );
  printf ( "  Using Gegenbauer parameter alpha = %g\n", alpha );

  n = 10;
  gcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    gcoef[i] = drand48 ( );
  }
  mcoef = gegenbauer_to_monomial ( n, alpha, gcoef );
  gcoef2 = monomial_to_gegenbauer ( n, alpha, mcoef );

  e = r8vec_diff_norm_l2 ( n + 1, gcoef, gcoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( gcoef );
  free ( gcoef2 );
  free ( mcoef );

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

void gegenbauer_to_monomial_test ( )

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

    gegenbauer_to_monomial_test() tests gegenbauer_to_monomial().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    25 April 2024

  Author:

    John Burkardt
*/
{
  double alpha;
  double *gcoef;
  int k;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "gegenbauer_to_monomial_test ( )\n" );
  printf ( "  gegenbauer_to_monomial() converts a\n" );
  printf ( "  polynomial from Gegenbauer form\n" );
  printf ( "  to monomial form.\n" );

  alpha = 0.5;
  printf ( "\n" );
  printf ( "  Using parameter alpha = %g\n", alpha );
  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "X^%d     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    gcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      gcoef[k] = 0.0;
    }
    gcoef[n] = 1.0;
    mcoef = gegenbauer_to_monomial ( n, alpha, gcoef );
    printf ( "C%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", mcoef[k] );
    }
    printf ( "\n" );
    free ( gcoef );
    free ( mcoef );
  }

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

void gegenbauer_to_monomial_matrix_test ( )

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

    gegenbauer_to_monomial_matrix_test() tests gegenbauer_to_monomial_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    16 April 2024

  Author:

    John Burkardt
*/
{
  double *A;
  double alpha;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "gegenbauer_to_monomial_matrix_test ( )\n" );
  printf ( "  gegenbauer_to_monomial_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Gegenbauer form\n" );
  printf ( "  to monomial form.\n" );

  n = 4;
  alpha = 0.5;
  A = gegenbauer_to_monomial_matrix ( n + 1, alpha );

  printf ( "\n" );
  printf ( "  alpha = %g\n", alpha );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%9.5f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void hermite_monomial_hermite_test ( )

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

    hermite_monomial_hermite_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    21 February 2024

  Author:

    John Burkardt
*/
{
  double e;
  double *hcoef;
  double *hcoef2;
  int i;
  double *mcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "hermite_monomial_hermite_test ( )\n" );
  printf ( "  Convert a polynomial from Hermite form\n" );
  printf ( "  to monomial form and back.\n" );

  srand48 ( seed );

  n = 10;
  hcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    hcoef[i] = drand48 ( );
  }
  mcoef = hermite_to_monomial ( n, hcoef );
  hcoef2 = monomial_to_hermite ( n, mcoef );

  e = r8vec_diff_norm_l2 ( n + 1, hcoef, hcoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( hcoef );
  free ( hcoef2 );
  free ( mcoef );

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

void hermite_to_monomial_test ( )

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

    hermite_to_monomial_test() tests hermite_to_monomial().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    21 February 2024

  Author:

    John Burkardt
*/
{
  double *hcoef;
  int k;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "hermite_to_monomial_test ( )\n" );
  printf ( "  hermite_to_monomial() converts a\n" );
  printf ( "  polynomial from Hermite form\n" );
  printf ( "  to monomial form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "X^%d     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    hcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      hcoef[k] = 0.0;
    }
    hcoef[n] = 1.0;
    mcoef = hermite_to_monomial ( n, hcoef );
    printf ( "H%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", mcoef[k] );
    }
    printf ( "\n" );
    free ( hcoef );
    free ( mcoef );
  }

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

void hermite_to_monomial_matrix_test ( )

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

    hermite_to_monomial_matrix_test() tests hermite_to_monomial_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    21 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "hermite_to_monomial_matrix_test ( )\n" );
  printf ( "  hermite_to_monomial_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Hermite form\n" );
  printf ( "  to monomial form.\n" );

  n = 4;
  A = hermite_to_monomial_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%9.5f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void laguerre_monomial_laguerre_test ( )

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

    laguerre_monomial_laguerre_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    22 February 2024

  Author:

    John Burkardt
*/
{
  double e;
  int i;
  double *lcoef;
  double *lcoef2;
  double *mcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "laguerre_monomial_laguerre_test ( )\n" );
  printf ( "  Convert a polynomial from Laguerre form\n" );
  printf ( "  to monomial form and back.\n" );

  srand48 ( seed );

  n = 10;
  lcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    lcoef[i] = drand48 ( );
  }
  mcoef = laguerre_to_monomial ( n, lcoef );
  lcoef2 = monomial_to_laguerre ( n, mcoef );

  e = r8vec_diff_norm_l2 ( n + 1, lcoef, lcoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( lcoef );
  free ( lcoef2 );
  free ( mcoef );

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

void laguerre_to_monomial_test ( )

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

    laguerre_to_monomial_test() tests laguerre_to_monomial().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    22 February 2024

  Author:

    John Burkardt
*/
{
  int k;
  double *lcoef;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "laguerre_to_monomial_test ( )\n" );
  printf ( "  laguerre_to_monomial() converts a\n" );
  printf ( "  polynomial from Laguerre form\n" );
  printf ( "  to monomial form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "X^%d     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    lcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      lcoef[k] = 0.0;
    }
    lcoef[n] = 1.0;
    mcoef = laguerre_to_monomial ( n, lcoef );
    printf ( "L%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", mcoef[k] );
    }
    printf ( "\n" );
    free ( lcoef );
    free ( mcoef );
  }

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

void laguerre_to_monomial_matrix_test ( )

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

    laguerre_to_monomial_matrix_test() tests laguerre_to_monomial_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    22 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "laguerre_to_monomial_matrix_test ( )\n" );
  printf ( "  laguerre_to_monomial_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Laguerre form\n" );
  printf ( "  to monomial form.\n" );

  n = 4;
  A = laguerre_to_monomial_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void legendre_monomial_legendre_test ( )

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

    legendre_monomial_legendre_test() tests accuracy.

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double e;
  int i;
  double *lcoef;
  double *lcoef2;
  double *mcoef;
  int n;
  long long int seed = 123456789LL;

  printf ( "\n" );
  printf ( "legendre_monomial_legendre_test ( )\n" );
  printf ( "  Convert a polynomial from Legendre form\n" );
  printf ( "  to monomial form and back.\n" );

  srand48 ( seed );

  n = 10;
  lcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
  for ( i = 0; i <= n; i++ )
  {
    lcoef[i] = drand48 ( );
  }
  mcoef = legendre_to_monomial ( n, lcoef );
  lcoef2 = monomial_to_legendre ( n, mcoef );

  e = r8vec_diff_norm_l2 ( n + 1, lcoef, lcoef2 );
  printf ( "\n" );
  printf ( "  L2 difference = %g\n", e );

  free ( lcoef );
  free ( lcoef2 );
  free ( mcoef );

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

void legendre_to_monomial_test ( )

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

    legendre_to_monomial_test() tests legendre_to_monomial().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  int k;
  double *lcoef;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "legendre_to_monomial_test ( )\n" );
  printf ( "  legendre_to_monomial() converts a\n" );
  printf ( "  polynomial from Legendre form\n" );
  printf ( "  to monomial form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "X^%d     ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    lcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      lcoef[k] = 0.0;
    }
    lcoef[n] = 1.0;
    mcoef = legendre_to_monomial ( n, lcoef );
    printf ( "P%d(x) = ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.3f", mcoef[k] );
    }
    printf ( "\n" );
    free ( lcoef );
    free ( mcoef );
  }

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

void legendre_to_monomial_matrix_test ( )

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

    legendre_to_monomial_matrix_test() tests legendre_to_monomial_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "legendre_to_monomial_matrix_test ( )\n" );
  printf ( "  legendre_to_monomial_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Legendre form\n" );
  printf ( "  to monomial form.\n" );

  n = 4;
  A = legendre_to_monomial_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.5f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void legendre01_to_bernstein_test ( )

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

    legendre01_to_bernstein_test() tests legendre01_to_bernstein().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    24 February 2024

  Author:

    John Burkardt
*/
{
  double *bcoef;
  int k;
  double *lcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "legendre01_to_bernstein_test ( )\n" );
  printf ( "  legendre01_to_bernstein() converts a\n" );
  printf ( "  polynomial from Legendre01 form to\n" );
  printf ( "  Bernstein form.\n" );

  printf ( "\n" );
  printf ( "        " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "B%d(x)   ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    lcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      lcoef[k] = 0.0;
    }
    lcoef[n] = 1.0;
    bcoef = legendre01_to_bernstein ( n, lcoef );
    printf ( "P%d(X) =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.5f", bcoef[k] );
    }
    printf ( "\n" );
    free ( bcoef );
    free ( lcoef );
  }

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

void legendre01_to_bernstein_matrix_test ( )

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

    legendre01_to_bernstein_matrix_test() tests legendre01_to_bernstein_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    24 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "legendre01_to_bernstein_matrix_test ( )\n" );
  printf ( "  legendre01_to_bernstein_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from Legendre01 form\n" );
  printf ( "  to Bernstein form.\n" );

  n = 5;
  A = legendre01_to_bernstein_matrix ( n );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void monomial_to_bernstein_test ( )

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

    monomial_to_bernstein_test() tests monomial_to_bernstein().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double *bcoef;
  int k;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "monomial_to_bernstein_test ( )\n" );
  printf ( "  monomial_to_bernstein() converts a\n" );
  printf ( "  polynomial from monomial form to\n" );
  printf ( "  Bernstein form.\n" );

  printf ( "\n" );
  printf ( "        " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "B%d(x)   ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    mcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      mcoef[k] = 0.0;
    }
    mcoef[n] = 1.0;
    bcoef = monomial_to_bernstein ( n, mcoef );
    printf ( "X^%d =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.5f", bcoef[k] );
    }
    printf ( "\n" );
    free ( bcoef );
    free ( mcoef );
  }

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

void monomial_to_bernstein_matrix_test ( )

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

    monomial_to_bernstein_matrix_test() tests monomial_to_bernstein_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "monomial_to_bernstein_matrix_test ( )\n" );
  printf ( "  monomial_to_bernstein_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from monomial form\n" );
  printf ( "  to Bernstein form.\n" );

  n = 4;
  A = monomial_to_bernstein_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void monomial_to_chebyshev_test ( )

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

    monomial_to_chebyshev_test() tests monomial_to_chebyshev().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    19 February 2024

  Author:

    John Burkardt
*/
{
  double *ccoef;
  int k;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "monomial_to_chebyshev_test ( )\n" );
  printf ( "  monomial_to_chebyshev() converts a\n" );
  printf ( "  polynomial from monomial form to\n" );
  printf ( "  Chebyshev form.\n" );

  printf ( "\n" );
  printf ( "        " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "T%d(x)   ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    mcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      mcoef[k] = 0.0;
    }
    mcoef[n] = 1.0;
    ccoef = monomial_to_chebyshev ( n, mcoef );
    printf ( "X^%d =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.5f", ccoef[k] );
    }
    printf ( "\n" );
    free ( ccoef );
    free ( mcoef );
  }

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

void monomial_to_gegenbauer_test ( )

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

    monomial_to_gegenbauer_test() tests monomial_to_gegenbauer().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    25 April 2024

  Author:

    John Burkardt
*/
{
  double alpha;
  int k;
  double *gcoef;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "monomial_to_gegenbauer_test ( )\n" );
  printf ( "  monomial_to_gegenbauer() converts a\n" );
  printf ( "  polynomial from monomial form to\n" );
  printf ( "  Gegenbauer form.\n" );

  alpha = 0.5;
  printf ( "\n" );
  printf ( "  Using parameter alpha = %g\n", alpha );
  printf ( "\n" );
  printf ( "        " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "C%d(x)   ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    mcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      mcoef[k] = 0.0;
    }
    mcoef[n] = 1.0;
    gcoef = monomial_to_gegenbauer ( n, alpha, mcoef );
    printf ( "X^%d =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.5f", gcoef[k] );
    }
    printf ( "\n" );
    free ( gcoef );
    free ( mcoef );
  }

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

void monomial_to_gegenbauer_matrix_test ( )

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

    monomial_to_gegenbauer_matrix_test() tests monomial_to_gegenbauer_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    25 April 2024

  Author:

    John Burkardt
*/
{
  double *A;
  double alpha;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "monomial_to_gegenbauer_matrix_test ( )\n" );
  printf ( "  monomial_to_gegenbauer_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from monomial form\n" );
  printf ( "  to Gegenbauer form.\n" );

  n = 4;
  alpha = 0.5;
  A = monomial_to_gegenbauer_matrix ( n + 1, alpha );

  printf ( "\n" );
  printf ( "  A (alpha = %g):\n", alpha );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void monomial_to_hermite_test ( )

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

    monomial_to_hermite_test() tests monomial_to_hermite().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    21 February 2024

  Author:

    John Burkardt
*/
{
  int k;
  double *hcoef;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "monomial_to_hermite_test ( )\n" );
  printf ( "  monomial_to_hermite() converts a\n" );
  printf ( "  polynomial from monomial form to\n" );
  printf ( "  Hermite form.\n" );

  printf ( "\n" );
  printf ( "        " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "H%d(x)   ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    mcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      mcoef[k] = 0.0;
    }
    mcoef[n] = 1.0;
    hcoef = monomial_to_hermite ( n, mcoef );
    printf ( "X^%d =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.5f", hcoef[k] );
    }
    printf ( "\n" );
    free ( hcoef );
    free ( mcoef );
  }

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

void monomial_to_hermite_matrix_test ( )

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

    monomial_to_hermite_matrix_test() tests monomial_to_hermite_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    21 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "monomial_to_hermite_matrix_test ( )\n" );
  printf ( "  monomial_to_hermite_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from monomial form\n" );
  printf ( "  to Hermite form.\n" );

  n = 4;
  A = monomial_to_hermite_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void monomial_to_laguerre_test ( )

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

    monomial_to_laguerre_test() tests monomial_to_laguerre().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    22 February 2024

  Author:

    John Burkardt
*/
{
  int k;
  double *lcoef;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "monomial_to_laguerre_test ( )\n" );
  printf ( "  monomial_to_laguerre() converts a\n" );
  printf ( "  polynomial from monomial form to\n" );
  printf ( "  Laguerre form.\n" );

  printf ( "\n" );
  printf ( "           " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "L%d(x)    ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    mcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      mcoef[k] = 0.0;
    }
    mcoef[n] = 1.0;
    lcoef = monomial_to_laguerre ( n, mcoef );
    printf ( "X^%d =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%9.1f", lcoef[k] );
    }
    printf ( "\n" );
    free ( lcoef );
    free ( mcoef );
  }

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

void monomial_to_laguerre_matrix_test ( )

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

    monomial_to_laguerre_matrix_test() tests monomial_to_laguerre_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    22 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "monomial_to_laguerre_matrix_test ( )\n" );
  printf ( "  monomial_to_laguerre_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from monomial form\n" );
  printf ( "  to Laguerre form.\n" );

  n = 5;
  A = monomial_to_laguerre_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%9.1f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

void monomial_to_legendre_test ( )

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

    monomial_to_legendre_test() tests monomial_to_legendre().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    20 February 2024

  Author:

    John Burkardt
*/
{
  int k;
  double *lcoef;
  double *mcoef;
  int n;
  int nmax = 6;

  printf ( "\n" );
  printf ( "monomial_to_legendre_test ( )\n" );
  printf ( "  monomial_to_legendre() converts a\n" );
  printf ( "  polynomial from monomial form to\n" );
  printf ( "  Legendre form.\n" );

  printf ( "\n" );
  printf ( "        " );
  for ( k = 0; k <= nmax; k++ )
  {
    printf ( "P%d(x)   ", k );
  }
  printf ( "\n" );
  printf ( "\n" );
  for ( n = 0; n <= nmax; n++ )
  {
    mcoef = ( double * ) malloc ( ( n + 1 ) * sizeof ( double ) );
    for ( k = 0; k <= n - 1; k++ )
    {
      mcoef[k] = 0.0;
    }
    mcoef[n] = 1.0;
    lcoef = monomial_to_legendre ( n, mcoef );
    printf ( "X^%d =  ", n );
    for ( k = 0; k <= n; k++ )
    {
      printf ( "%8.5f", lcoef[k] );
    }
    printf ( "\n" );
    free ( lcoef );
    free ( mcoef );
  }

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

void monomial_to_legendre_matrix_test ( )

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

    monomial_to_legendre_matrix_test() tests monomial_to_legendre_matrix().

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    21 February 2024

  Author:

    John Burkardt
*/
{
  double *A;
  int i;
  int j;
  int n;

  printf ( "\n" );
  printf ( "monomial_to_legendre_matrix_test ( )\n" );
  printf ( "  monomial_to_legendre_matrix() returns the matrix\n" );
  printf ( "  which converts a polynomial from monomial form\n" );
  printf ( "  to Legendre form.\n" );

  n = 4;
  A = monomial_to_legendre_matrix ( n + 1 );

  printf ( "\n" );
  printf ( "  A:\n" );
  printf ( "\n" );
  for ( i = 0; i <= n; i++ )
  {
    for ( j = 0; j <= n; j++ )
    {
      printf ( "%8.4f", A[i+j*(n+1)] );
    }
    printf ( "\n" );
  }

  free ( A );

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

double r8vec_diff_norm_l2 ( int n, double a[], double b[] )

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

    r8vec_diff_norm_l2() returns the L2 norm of the difference of R8VEC's.

  Discussion:

    An R8VEC is a vector of R8's.

    The vector L2 norm is defined as:

      R8VEC_NORM_L2 = sqrt ( sum ( 1 <= I <= N ) A(I)^2 ).

  Licensing:

    This code is distributed under the MIT license.

  Modified:

    01 March 2003

  Author:

    John Burkardt

  Input:

    int N, the number of entries in A.

    double A[N], B[N], the vectors.

  Output:

    double R8VEC_DIFF_NORM_L2, the L2 norm of A - B.
*/
{
  int i;
  double value;

  value = 0.0;

  for ( i = 0; i < n; i++ )
  {
    value = value + ( a[i] - b[i] ) * ( a[i] - b[i] );
  }
  value = sqrt ( value );

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

void timestamp ( )

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

    timestamp() prints the current YMDHMS date as a time stamp.

  Example:

    17 June 2014 09:45:54 AM

  Licensing:

    This code is distributed under the MIT license. 

  Modified:

    01 May 2021

  Author:

    John Burkardt
*/
{
# 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
}