# include <cmath>
# include <cstdlib>
# include <cstring>
# include <ctime>
# include <iomanip>
# include <iostream>

using namespace std;

# include "lebesgue.hpp"

int main ( );
void lebesgue_chebyshev1_test ( );
void lebesgue_chebyshev2_test ( );
void lebesgue_chebyshev3_test ( );
void lebesgue_chebyshev4_test ( );
void lebesgue_constant_test ( );
void test05 ( );
void test06 ( );
void test07 ( );
void test08 ( );
void test09 ( );
void timestamp ( );

//****************************************************************************80

int main ( )

//****************************************************************************80
//
//  Purpose:
//
//    lebesgue_test() tests lebesgue().
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    19 December 2025
//
//  Author:
//
//    John Burkardt
//
{
  timestamp ( );
  cout << "\n";
  cout << "lebesgue_test():\n";
  cout << "  C++ version\n";
  cout << "  Test lebesgue().\n";

  lebesgue_chebyshev1_test ( );
  lebesgue_chebyshev2_test ( );
  lebesgue_chebyshev3_test ( );
  lebesgue_chebyshev4_test ( );
  lebesgue_constant_test ( );
  test05 ( );
  test06 ( );
  test07 ( );
  test08 ( );
  test09 ( );
//
//  Terminate.
//
  cout << "\n";
  cout << "lebesgue_test():\n";
  cout << "  Normal end of execution.\n";
  cout << "\n";
  timestamp ( );

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

void lebesgue_chebyshev1_test ( )

//****************************************************************************80
//
//  Purpose:
//
//    lebesgue_chebyshev1_test() looks at Chebyshev1 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "chebyshev1";
  double *l;
  string label = "Chebyshev1 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "lebesgue_chebyshev1_test():\n";
  cout << "  Analyze Chebyshev1 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = chebyshev1 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l,
    "  Chebyshev1 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = chebyshev1 ( n );
  r8vec_print ( n, x, "  Chebyshev1 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void lebesgue_chebyshev2_test ( )

//****************************************************************************80
//
//  Purpose:
//
//    lebesgue_chebyshev2_test() looks at Chebyshev2 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "chebyshev2";
  double *l;
  string label = "Chebyshev2 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "lebesgue_chebyshev2_test():\n";
  cout << "  Analyze Chebyshev2 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = chebyshev2 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l,
    "  Chebyshev2 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = chebyshev2 ( n );
  r8vec_print ( n, x, "  Chebyshev2 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void lebesgue_chebyshev3_test ( )

//****************************************************************************80
//
//  Purpose:
//
//    lebesgue_chebyshev3_test() looks at Chebyshev3 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2014
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "chebyshev3";
  double *l;
  string label = "Chebyshev3 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "lebesgue_chebyshev3_test():\n";
  cout << "  Analyze Chebyshev3 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = chebyshev3 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l, 
    "  Chebyshev3 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = chebyshev3 ( n );
  r8vec_print ( n, x, "  Chebyshev3 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void lebesgue_chebyshev4_test ( )

//****************************************************************************80
//
//  Purpose:
//
//    lebesgue_chebyshev4_test() looks at Chebyshev4 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "chebyshev4";
  double *l;
  string label = "Chebyshev4 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "lebesgue_chebyshev4_test():\n";
  cout << "  Analyze Chebyshev4 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = chebyshev4 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l, 
    "  Chebyshev4 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = chebyshev4 ( n );
  r8vec_print ( n, x, "  Chebyshev4 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void lebesgue_constant_test ( )

//****************************************************************************80
//
//  Purpose:
//
//    lebesgue_constant_test() tests lebesgue_constant() for a simple case.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    19 December 2025
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double b;
  int i;
  double lmax;
  int nf;
  int ni;
  double *xf;
  double *xi;

  a = -1.0;
  b = +1.0;

  cout << "\n";
  cout << "lebesgue_constant_test()\n";
  cout << "  Test lebesgue_constant() for a simple case of\n";
  cout << "  equally spaced points in [ " << a << "," << b << "]\n";
  cout << "\n";
  cout << "  NI  = number of interpolating points.\n";
  cout << "  NF = number of sample points\n";
  cout << "\n";
  cout << "  Case 1: fix NI, try sequence of NF values\n";
  cout << "\n";

  ni = 11;
  xi = r8vec_linspace_new ( ni, a, b );

  nf = 2;
  for ( i = 1; i <= 10; i++ )
  {
    xf = r8vec_linspace_new ( nf, a, b );
    lmax = lebesgue_constant ( ni, xi, nf, xf );
    cout << "  " << setw(3) << ni
         << "  " << setw(4) << nf
         << "  " << setw(14) << lmax << "\n";
    nf = 2 * nf - 1;
    delete [] xf;
  }

  delete [] xi;

  cout << "\n";
  cout << "  Case 2: fix NF, try sequence of NI values\n";
  cout << "\n";

  nf = 1001;
  xf = r8vec_linspace_new ( nf, a, b );

  for ( ni = 1; ni <= 11; ni++ )
  {
    xi = r8vec_linspace_new ( ni, a, b );
    lmax = lebesgue_constant ( ni, xi, nf, xf );
    cout << "  " << setw(3) << ni
         << "  " << setw(4) << nf
         << "  " << setw(14) << lmax << "\n";
    delete [] xi;
  }

  delete [] xf;

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

void test05 ( )

//****************************************************************************80
//
//  Purpose:
//
//    LEBESGUE_TEST05 looks at Equidistant1 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "equidistant1";
  double *l;
  string label = "Equidistant1 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "LEBESGUE_TEST05:\n";
  cout << "  Analyze Equidistant1 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = equidistant1 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l, 
    "  Equidistant1 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = equidistant1 ( n );
  r8vec_print ( n, x, "  Equidistant1 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void test06 ( )

//****************************************************************************80
//
//  Purpose:
//
//    LEBESGUE_TEST06 looks at Equidistant2 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "equidistant2";
  double *l;
  string label = "Equidistant2 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "LEBESGUE_TEST06:\n";
  cout << "  Analyze Equidistant2 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = equidistant2 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l, 
    "  Equidistant2 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = equidistant2 ( n );
  r8vec_print ( n, x, "  Equidistant2 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void test07 ( )

//****************************************************************************80
//
//  Purpose:
//
//    LEBESGUE_TEST07 looks at Equidistant3 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "equidistant3";
  double *l;
  string label = "Equidistant3 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "LEBESGUE_TEST07:\n";
  cout << "  Analyze Equidistant3 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = equidistant3 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l,
    "  Equidistant3 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = equidistant3 ( n );
  r8vec_print ( n, x, "  Equidistant3 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void test08 ( )

//****************************************************************************80
//
//  Purpose:
//
//    LEBESGUE_TEST08 looks at Fejer 1 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "fejer1";
  double *l;
  string label = "Fejer1 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "LEBESGUE_TEST08:\n";
  cout << "  Analyze Fejer1 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = fejer1 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l,
    "  Fejer1 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = fejer1 ( n );
  r8vec_print ( n, x, "  Fejer1 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void test09 ( )

//****************************************************************************80
//
//  Purpose:
//
//    LEBESGUE_TEST09 looks at Fejer2 points.
//
//  Licensing:
//
//    This code is distributed under the MIT license.
//
//  Modified:
//
//    04 March 2015
//
//  Author:
//
//    John Burkardt
//
{
  string filename = "fejer2";
  double *l;
  string label = "Fejer2 points for N = 11";
  int n;
  int n_max = 11;
  int nfun = 501;
  double *x;
  double *xfun;

  cout << "\n";
  cout << "LEBESGUE_TEST09:\n";
  cout << "  Analyze Fejer2 points.\n";

  xfun = r8vec_linspace_new ( nfun, -1.0, +1.0 );

  l = new double[nfun];

  for ( n = 1; n <= n_max; n++ )
  {
    x = fejer2 ( n );
    l[n-1] = lebesgue_constant ( n, x, nfun, xfun );
    delete [] x;
  }

  r8vec_print ( n_max, l,
    "  Fejer2 Lebesgue constants for N = 1 to 11:" );
//
//  Examine one case more closely.
//
  n = 11;
  x = fejer2 ( n );
  r8vec_print ( n, x, "  Fejer2 points for N = 11" );

  lebesgue_plot ( n, x, nfun, xfun, label, filename );

  delete [] l;
  delete [] x;
  delete [] xfun;

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

void timestamp ( )

//****************************************************************************80
//
//  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 MIT license. 
//
//  Modified:
//
//    19 March 2018
//
//  Author:
//
//    John Burkardt
//
{
# define TIME_SIZE 40

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

  now = std::time ( NULL );
  tm_ptr = std::localtime ( &now );

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

  std::cout << time_buffer << "\n";

  return;
# undef TIME_SIZE
}