예제 #1
0
void test1836 ( )

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

    TEST1836 tests SPHERE_EXP2IMP_ND.

  Licensing:

    This code is distributed under the GNU LGPL license. 

  Modified:

    26 July 2011

  Author:

    John Burkardt
*/
{
# define N 3

  int n = N;
  double p[N*(N+1)] = {
    4.0, 2.0, 3.0, 
    1.0, 5.0, 3.0, 
    1.0, 2.0, 6.0, 
   -2.0, 2.0, 3.0 };
  double pc[N];
  double pc_true[N] = { 1.0, 2.0, 3.0 };
  double r;
  double r_true = 3.0;

  printf ( "\n" );
  printf ( "TEST1836\n" );
  printf ( "  SPHERE_EXP2IMP_ND: explicit sphere => implicit form;\n" );

  r8mat_transpose_print ( n, n + 1, p, "  Initial form of explicit sphere:" );

  sphere_exp2imp_nd ( n, p, &r, pc );

  printf ( "\n" );
  printf ( "  Computed form of implicit sphere:\n" );
  printf ( "\n" );
  printf ( "  Imputed radius = %f\n", r );
  printf ( "  True radius =    %f\n", r_true );

  r8vec_print ( n, pc, "  Imputed center" );

  r8vec_print ( n, pc_true, "  True center" );

  return;
# undef N
}
예제 #2
0
void test02 ( void )

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

    TEST02 prints the data for each problem.

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    06 February 2012

  Author:

    John Burkardt
*/
{
  int data_num;
  int dim_num;
  double *p;
  int prob;
  int prob_num;

  printf ( "\n" );
  printf ( "TEST02\n" );
  printf ( "  P00_DATA_NUM returns N, the number of data points.\n" );
  printf ( "  P00_DIM_NUM returns M, the dimension of data.\n" );
  printf ( "  P00_DATA returns the actual (MxN) data.\n" );

  prob_num = p00_prob_num ( );

  for ( prob = 1; prob <= prob_num; prob++ )
  {
    printf ( "\n" );
    printf ( "  Problem  %d\n", prob );

    data_num = p00_data_num ( prob );
    printf ( "  DATA_NUM %d\n", data_num );
    dim_num = p00_dim_num ( prob );
    printf ( "  DIM_NUM  %d\n", dim_num );

    p = p00_data ( prob, dim_num, data_num );

    r8mat_transpose_print ( dim_num, data_num, p, "  Data array:" );

    free ( p );
  }

  return;
}
예제 #3
0
void test171 ( )

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

    TEST171 tests QUAD_AREA_2D and QUAD_AREA2_2D;

  Licensing:

    This code is distributed under the GNU LGPL license. 

  Modified:

    09 May 2010

  Author:

    John Burkardt
*/
{
# define DIM_NUM 2

  double area;
  double quad[DIM_NUM*4] = {
    0.0, 0.0,
    1.0, 0.0,
    1.0, 1.0,
    0.0, 1.0 };

  printf ( "\n" );
  printf ( "TEST171\n" );
  printf ( "  For a quadrilateral in 2D:\n" );
  printf ( "  QUAD_AREA_2D finds the area;\n" );
  printf ( "  QUAD_AREA2_2D finds the area;\n" );

  r8mat_transpose_print ( DIM_NUM, 4, quad, "  The vertices:" );

  area = quad_area_2d ( quad );

  printf ( "\n" );
  printf ( "  QUAD_AREA_2D area is  %f\n", area );

  area = quad_area2_2d ( quad );

  printf ( "  QUAD_AREA2_2D area is %f\n", area );

  return;
# undef DIM_NUM
}
예제 #4
0
void test0478 ( )

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

    TEST0478 tests PARALLELOGRAM_AREA_3D.

  Licensing:

    This code is distributed under the GNU LGPL license. 

  Modified:

    09 May 2010

  Author:

    John Burkardt
*/
{
  double area;
  double p[3*4] = {
    1.0,       2.0,       3.0, 
    2.4142137, 3.4142137, 3.0, 
    1.7071068, 2.7071068, 4.0, 
    0.2928931, 0.2928931, 4.0 };

  printf ( "\n" );
  printf ( "TEST0478\n" );
  printf ( "  PARALLELOGRAM_AREA_3D finds the area of a\n" );
  printf ( "  parallelogram in 3D.\n" );

  r8mat_transpose_print ( 3, 4, p, "  Vertices:" );

  area = parallelogram_area_3d ( p );

  printf ( "\n" );
  printf ( "  AREA = %f\n", area );

  return;
}
예제 #5
0
void test0477 ( )

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

    TEST0477 tests PARALLELOGRAM_AREA_2D.

  Licensing:

    This code is distributed under the GNU LGPL license. 

  Modified:

    09 May 2010

  Author:

    John Burkardt
*/
{
  double area;
  double p[2*4] = {
    2.0, 7.0, 
    5.0, 7.0, 
    6.0, 9.0, 
    3.0, 9.0 };

  printf ( "\n" );
  printf ( "TEST0477\n" );
  printf ( "  PARALLELOGRAM_AREA_2D finds the area of a\n" );
  printf ( "  parallelogram in 2D.\n" );

  r8mat_transpose_print ( 2, 4, p, "  Vertices:" );

  area = parallelogram_area_2d ( p );

  printf ( "\n" );
  printf ( "  AREA = %f\n", area );

  return;
}
void test02 ( )

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

    TEST02 examines the sample points in the pyramid

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    14 April 2014

  Author:

    John Burkardt
*/
{
  int m = 3;
  int n = 20;
  int seed;
  double *x;

  printf ( "\n" );
  printf ( "TEST02\n" );
  printf ( "  Print sample points in the unit pyramid in 3D.\n" );
  seed = 123456789;
  x = pyramid01_sample ( n, &seed );
  r8mat_transpose_print ( 3, n, x, "  Unit pyramid points" );

  free ( x );

  return;
}
void test01 ( int prob )

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

    TEST01 tests CHEBYSHEV_VALUE_1D.

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    27 September 2012

  Author:

    John Burkardt
*/
{
  int i;
  double int_error;
  int nd;
  int ni;
  double *xd;
  double *xi;
  double *xy;
  double *yd;
  double *yi;

  printf ( "\n" );
  printf ( "CHEBYSHEV_INTERP_1D_TEST01:\n" );
  printf ( "  Interpolate data from TEST_INTERP problem #%d\n", prob );

  nd = p00_data_num ( prob );
  printf ( "  Number of data points = %d\n", nd );

  xy = p00_data ( prob, 2, nd );
  
  r8mat_transpose_print ( 2, nd, xy, "  Data array:" );

  xd = ( double * ) malloc ( nd * sizeof ( double ) );
  yd = ( double * ) malloc ( nd * sizeof ( double ) );
  
  for ( i = 0; i < nd; i++ )
  {
    xd[i] = xy[0+i*2];
    yd[i] = xy[1+i*2];
  }
/*
  #1:  Does interpolant match function at interpolation points?
*/
  ni = nd;

  xi = ( double * ) malloc ( ni * sizeof ( double ) );

  for ( i = 0; i < ni; i++ )
  {
    xi[i] = xd[i];
  }
  yi = chebyshev_interp_1d ( nd, xd, yd, ni, xi );

  int_error = r8vec_norm_affine ( ni, yi, yd ) / ( double ) ( ni );

  printf ( "\n" );
  printf ( "  L2 interpolation error averaged per interpolant node = %g\n", int_error );

  free ( xd );
  free ( xi );
  free ( xy );
  free ( yd );
  free ( yi );

  return;
}
예제 #8
0
void test1712 ( )

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

    TEST1712 tests QUAD_AREA_3D;

  Licensing:

    This code is distributed under the GNU LGPL license. 

  Modified:

    09 May 2010

  Author:

    John Burkardt
*/
{
  double area;
  double area1;
  double area2;
  int i;
  int j;
  double q[3*4] = {
    2.0, 2.0, 0.0, 
    0.0, 0.0, 0.0, 
    1.0, 1.0, 1.0, 
    3.0, 3.0, 1.0 };
  double t[3*3];

  printf ( "\n" );
  printf ( "TEST1712\n" );
  printf ( "  For a quadrilateral in 3D:\n" );
  printf ( "  QUAD_AREA_3D finds the area.\n" );

  r8mat_transpose_print ( 3, 4, q, "  The vertices:");

  area = quad_area_3d ( q );

  printf ( "\n" );
  printf ( "  QUAD_AREA_3D area is     %f\n", area );

  for ( j = 0; j < 3; j++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      t[i+j*3] = q[i+j*3];
    }
  }
  area1 = triangle_area_3d ( t );
  for ( j = 0; j < 2; j++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      t[i+j*3] = q[i+(j+2)*3];
    }
  }
  for ( i = 0; i < 3; i++ )
  {
    t[i+2*3] = q[i+0*3];
  }
  area2 = triangle_area_3d ( t );
  printf ( "  Sum of TRIANGLE_AREA_3D: %f\n", area1 + area2 );

  return;
}
예제 #9
0
void test2101 ( )

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

    TEST2101 tests TRIANGLE_CIRCUMCENTER_2D and others.

  Discussion:

    The functions tested include
    * TRIANGLE_CIRCUMCENTER_2D;
    * TRIANGLE_CIRCUMCENTER_2D_2;
    * TRIANGLE_CIRCUMCENTER.

  Licensing:

    This code is distributed under the GNU LGPL license. 

  Modified:

    28 October 2010

  Author:

    John Burkardt
*/
{
# define M 2
# define TEST_NUM 4

  int i;
  int j;
  int m = M;
  double *pc;
  double t[M*3];
  double t_test[M*3*TEST_NUM] = {
         10.0,  5.0, 
         11.0,  5.0, 
         10.0,  6.0, 
         10.0,  5.0, 
         11.0,  5.0, 
         10.5,  5.86602539, 
         10.0,  5.0, 
         11.0,  5.0, 
         10.5, 15.0, 
         10.0,  5.0, 
         11.0,  5.0, 
        20.0,   7.0 };
  int test;
  int test_num = TEST_NUM;

  printf ( "\n" );
  printf ( "TEST2101\n" );
  printf ( "  For a triangle in 2D, the circumenter can be computed by:\n" );
  printf ( "  TRIANGLE_CIRCUMCENTER_2D;\n" );
  printf ( "  TRIANGLE_CIRCUMCENTER_2D_2;\n" );
  printf ( "  TRIANGLE_CIRCUMCENTER (any dimension);\n" );

  for ( test = 0; test < test_num; test++ )
  {
    for ( j = 0; j < 3; j++ )
    {
      for ( i = 0; i < m; i++ )
      {
        t[i+j*m] = t_test[i+j*m+test*m*3];
      }
    }
    r8mat_transpose_print ( m, 3, t, "  Triangle vertices:" );

    pc = triangle_circumcenter_2d ( t );
    r8vec_print ( m, pc, "  Circumcenter by TRIANGLE_CIRCUMCENTER_2D:" );
    free ( pc );

    pc = triangle_circumcenter_2d_2 ( t );
    r8vec_print ( m, pc, "  Circumcenter by TRIANGLE_CIRCUMCENTER_2D_2:" );
    free ( pc );

    pc = triangle_circumcenter ( m, t );
    r8vec_print ( m, pc, "  Circumcenter by TRIANGLE_CIRCUMCENTER:" );
    free ( pc );
  }
  return;
# undef M
# undef TEST_NUM
}
예제 #10
0
void rbf_interp_nd_test01 ( void )

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

    RBF_INTERP_ND_TEST01 tests RBF_WEIGHTS and RBF_INTERP_ND with PHI1.

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    01 July 2012

  Author:

    John Burkardt
*/
{
  double a;
  double app_error;
  double b;
  int debug = 0;
  double *fd;
  double *fe;
  double *fi;
  int i;
  double int_error;
  int j;
  int m = 2;
  int n1d = 5;
  int nd;
  int ni;
  double r0;
  int seed;
  double *w;
  double *x1d;
  double *xd;
  double *xi;

  printf ( "\n" );
  printf ( "RBF_INTERP_ND_TEST01:\n" );
  printf ( "  RBF_WEIGHT computes weights for RBF interpolation.\n" );
  printf ( "  RBF_INTERP_ND evaluates the RBF interpolant.\n" );
  printf ( "  Use the multiquadratic basis function PHI1(R).\n" );
  a = 0.0;
  b = 2.0;
  r0 = ( b - a ) / ( double ) ( n1d );
  printf ( "  Scale factor R0 = %g\n", r0 );

  x1d = r8vec_linspace_new ( n1d, a, b );
  nd = i4_power ( n1d, m );
  xd = ( double * ) malloc ( m * nd * sizeof ( double ) );

  for ( i = 0; i < m; i++ )
  {
    r8vec_direct_product ( i, n1d, x1d, m, nd, xd );
  }

  if ( debug )
  {
    r8mat_transpose_print ( m, nd, xd, "  The product points:" );
  }

  fd = ( double * ) malloc ( nd * sizeof ( double ) );
  for ( j = 0; j < nd; j++ )
  {
    fd[j] = xd[0+j*m] * xd[1+j*m] * exp ( - xd[0+j*m] * xd[1+j*m] );
  }
  if ( debug )
  {
    r8vec_print ( nd, fd, "  Function data:" );
  }

  w = rbf_weight ( m, nd, xd, r0, phi1, fd );
  if ( debug )
  {
    r8vec_print ( nd, w, "  Weight vector:" );
  }
/*
  #1: Interpolation test.  Does interpolant match function at interpolation points?
*/
  ni = nd;
  xi = r8mat_copy_new ( m, ni, xd );

  fi = rbf_interp_nd ( m, nd, xd, r0, phi1, w, ni, xi );

  int_error = r8vec_norm_affine ( nd, fd, fi ) / ( double ) ( nd );

  printf ( "\n" );
  printf ( "  L2 interpolation error averaged per interpolant node = %g\n", int_error );

  free ( fi );
  free ( xi );
/*
  #2: Approximation test.  Estimate the integral (f-interp(f))^2.
*/
  ni = 1000;
  seed = 123456789;

  xi = r8mat_uniform_ab_new ( m, ni, a, b, &seed );

  fi = rbf_interp_nd ( m, nd, xd, r0, phi1, w, ni, xi );

  fe = ( double * ) malloc ( ni * sizeof ( double ) );
  for ( j = 0; j < ni; j++ )
  {
    fe[j] = xi[0+j*m] * xi[1+j*m] * exp ( - xi[0+j*m] * xi[1+j*m] );
  }

  app_error = pow ( b - a, m ) * r8vec_norm_affine ( ni, fi, fe ) / ( double ) ( ni );

  printf ( "  L2 approximation error averaged per 1000 samples = %g\n", app_error );

  free ( fd );
  free ( fe );
  free ( fi );
  free ( w );
  free ( x1d );
  free ( xd );
  free ( xi );

  return;
}
예제 #11
0
void test005 ( )

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

    TEST005 tests DIAEDG.

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    23 October 2012

  Author:

    John Burkardt
*/
{
  int node_num = 4;
  int triangle_num = 2;
  int triangle_order = 3;

  double alpha_area;
  double alpha_ave;
  double alpha_min_swapped;
  double alpha_min_unswapped;
  double node_xy[2*4];
  int seed = 123456789;
  int swap;
  int test;
  int test_num = 10;
  int triangle_node[3*2];
  int value;

  printf ( "\n" );
  printf ( "TEST005\n" );
  printf ( "  DIAEDG determines whether two triangles\n" );
  printf ( "  with a common edge need to \"swap\" diagonals.\n" );
  printf ( "  If swapping is indicated, then ALPHA_MIN should increase.\n" );
  printf ( "\n" );
  printf ( "  Swap   ALPHA_MIN   ALPHA_MIN\n" );
  printf ( "         Unswapped   Swapped\n" );
  printf ( "\n" );

  for ( test = 1; test <= test_num; test++ )
  {
/*
  Generate a random quadrilateral (1,2,3,4).
*/
    quad_convex_random ( &seed, node_xy );
/*
  Does it need swapping?
*/
    value = diaedg (
      node_xy[0+0*2], node_xy[1+0*2],
      node_xy[0+1*2], node_xy[1+1*2],
      node_xy[0+2*2], node_xy[1+2*2],
      node_xy[0+3*2], node_xy[1+3*2] );

    if ( value == +1 )
    {
      swap = 0;
    }
    else
    {
      swap = 1;
    }
/*
  Compute ALPHA_MIN unswapped.
*/
    triangle_node[0+0*3] = 1;
    triangle_node[1+0*3] = 2;
    triangle_node[2+0*3] = 3;
    triangle_node[0+1*3] = 1;
    triangle_node[1+1*3] = 3;
    triangle_node[2+1*3] = 4;

    alpha_measure ( node_num, node_xy, triangle_order, triangle_num,
      triangle_node, &alpha_min_unswapped, &alpha_ave, &alpha_area );
/*
  Compute ALPHA_MIN swapped.
*/
    triangle_node[0+0*3] = 1;
    triangle_node[1+0*3] = 2;
    triangle_node[2+0*3] = 4;
    triangle_node[0+1*3] = 2;
    triangle_node[1+1*3] = 3;
    triangle_node[2+1*3] = 4;

    alpha_measure ( node_num, node_xy, triangle_order, triangle_num,
      triangle_node, &alpha_min_swapped, &alpha_ave, &alpha_area );

    if ( 0 )
    {
      r8mat_transpose_print ( 2, node_num, node_xy, "  Quadrilateral" );
    }

    printf ( "     %1d  %10g  %10g\n", 
      swap, alpha_min_unswapped, alpha_min_swapped );
  }

  return;
}
예제 #12
0
void test06 ( )

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

    TEST06 tests TRIANGLE_CIRCUMCENTER_2D;

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    23 October 2012

  Author:

    John Burkardt
*/
{
# define DIM_NUM 2

  double *center;
  int i;
  int ntest = 4;
  double t[DIM_NUM*3];

  printf ( "\n" );
  printf ( "TEST06\n" );
  printf ( "  For a triangle in 2D:\n" );
  printf ( "  TRIANGLE_CIRCUMCENTER_2D computes the circumcenter.\n" );

  for ( i = 1; i <= ntest; i++ )
  {
    if ( i == 1 )
    {
      t[0+0*2] = 0.0;
      t[1+0*2] = 0.0;
      t[0+1*2] = 1.0;
      t[1+1*2] = 0.0;
      t[0+2*2] = 0.0;
      t[1+2*2] = 1.0;
    }
    else if ( i == 2 )
    {
      t[0+0*2] = 0.0;
      t[1+0*2] = 0.0;
      t[0+1*2] = 1.0;
      t[1+1*2] = 0.0;
      t[0+2*2] = 0.5;
      t[1+2*2] = sqrt ( 3.0 ) / 2.0;
    }
    else if ( i == 3 )
    {
      t[0+0*2] = 0.0;
      t[1+0*2] = 0.0;
      t[0+1*2] = 1.0;
      t[1+1*2] = 0.0;
      t[0+2*2] = 0.5;
      t[1+2*2] = 10.0;
    }
    else if ( i == 4 )
    {
      t[0+0*2] = 0.0;
      t[1+0*2] = 0.0;
      t[0+1*2] = 1.0;
      t[1+1*2] = 0.0;
      t[0+2*2] = 10.0;
      t[1+2*2] = 2.0;
    }

    r8mat_transpose_print ( DIM_NUM, 3, t, "  The triangle" );

    center = triangle_circumcenter_2d ( t );

    r8vec_print ( DIM_NUM, center, "  Circumcenter" );

    free ( center );
  }

  return;
# undef DIM_NUM
}
예제 #13
0
void test03 ( )

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

    TEST03 tests R82VEC_SORT_QUICK_A.

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    23 October 2012

  Author:

    John Burkardt
*/
{
# define N 12
# define DIM_NUM 2

  double *a;
  double b = 0.0;
  double c = 10.0;
  int i;
  int j;
  int seed = 123456789;

  printf ( "\n" );
  printf ( "TEST03\n" );
  printf ( "  R82VEC_SORT_QUICK_A sorts a vector\n" );
  printf ( "    as part of a quick sort.\n" );
  printf ( "  Using initial random number seed = %d", seed );

  a = r8mat_uniform_01_new ( DIM_NUM, N, &seed );

  for ( j = 0; j < N; j++ )
  {
    for ( i = 0; i < DIM_NUM; i++ )
    {
      a[i+j*DIM_NUM] = 10.0 * a[i+j*DIM_NUM];
    }
  }
/*
  For better testing, give a few elements the same first component.
*/
  a[0+2*(3-1)] = a[0+2*(5-1)];
  a[0+2*(4-1)] = a[0+2*(12-1)];
/*
  Make two entries equal.
*/
  a[0+2*(7-1)] = a[0+2*(11-1)];
  a[1+2*(7-1)] = a[1+2*(11-1)];

  r8mat_transpose_print ( DIM_NUM, N, a, "  Before sorting:" );

  r82vec_sort_quick_a ( N, a );

  r8mat_transpose_print ( DIM_NUM, N, a, "  Sorted array:" );

  free ( a );

  return;
# undef N
# undef DIM_NUM
}
예제 #14
0
void test02 ( )

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

    TEST02 tests R82VEC_PART_QUICK_A.

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    23 October 2012

  Author:

    John Burkardt
*/
{
# define N 12
# define DIM_NUM 2

  double *a;
  int i;
  int j;
  int l;
  int r;
  int seed = 123456789;

  printf ( "\n" );
  printf ( "TEST02\n" );
  printf ( "  D2VEC_PART_QUICK_A reorders a D2 vector\n" );
  printf ( "    as part of a quick sort.\n" );
  printf ( "  Using initial random number seed = %d\n", seed );

  a = r8mat_uniform_01_new ( DIM_NUM, N, &seed );

  for ( j = 0; j < N; j++ )
  {
    for ( i = 0; i < DIM_NUM; i++ )
    {
      a[i+j*DIM_NUM] = 10.0 * a[i+j*DIM_NUM];
    }
  }

  r8mat_transpose_print ( DIM_NUM, N, a, "  Before rearrangment:" );

  r82vec_part_quick_a ( N, a, &l, &r );

  printf ( "\n" );
  printf ( "  Rearranged array\n" );
  printf ( "  Left index =  %d\n", l );
  printf ( "  Key index =   %d\n", l + 1 );
  printf ( "  Right index = %d\n", r );

  r8mat_transpose_print ( DIM_NUM, l,     a,         "  Left half:" );
  r8mat_transpose_print ( DIM_NUM, 1,     a+2*l,     "  Key:" );
  r8mat_transpose_print ( DIM_NUM, N-l-1, a+2*(l+1), "  Right half:" );

  free ( a );

  return;
# undef N
# undef DIM_NUM
}
예제 #15
0
void test01 ( )

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

    TEST01 tests POINTS_DELAUNAY_NAIVE_2D.

  Diagram:

   !....3&11....
   !............
   !............
   X..9.........
   !.....5......
   !...........6
   !.4.2...10...
   !.....8...12.
   V............
   !..7.........
   !......1.....
   !............
   !............
   !----V----X--

  Licensing:

    This code is distributed under the GNU LGPL license.

  Modified:

    23 October 2012

  Author:

    John Burkardt
*/
# define N 12
# define DIM_NUM 2
{
  int i;
  int ntri;
  int *tri;
  double p[DIM_NUM*N] = {
     7.0, 3.0,
     4.0,  7.0,
     5.0, 13.0,
     2.0,  7.0,
     6.0,  9.0,
    12.0, 10.0,
     3.0,  4.0,
     6.0,  6.0,
     3.0, 10.0,
     8.0,  7.0,
     5.0, 13.0,
    10.0,  6.0 };

  printf ( "\n" );
  printf ( "TEST01\n" );
  printf ( "  POINTS_DELAUNAY_NAIVE_2D computes the Delaunay\n" );
  printf ( "  triangulation of a set of points.\n" );

  r8mat_transpose_print ( DIM_NUM, N, p, "  The points:" );

  tri = points_delaunay_naive_2d ( N, p, &ntri );

  printf ( "\n" );
  printf ( "  Number of triangles is NTRI = %d\n", ntri );

  i4mat_transpose_print ( 3, ntri, tri, "  The Delaunay triangles:" );

  free ( tri );

  return;
# undef N
# undef DIM_NUM
}