# include # include # include # include # include "test_approx.h" /******************************************************************************/ void p00_dat ( int prob, int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P00_DAT returns the data vector for any problem. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Input, int PROB, the number of the desired test problem. Input, int DATA_NUM, the number of data points, as specified by P00_DATA_NUM. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { if ( prob == 1 ) { p01_dat ( data_num, x, y ); } else if ( prob == 2 ) { p02_dat ( data_num, x, y ); } else if ( prob == 3 ) { p03_dat ( data_num, x, y ); } else if ( prob == 4 ) { p04_dat ( data_num, x, y ); } else if ( prob == 5 ) { p05_dat ( data_num, x, y ); } else if ( prob == 6 ) { p06_dat ( data_num, x, y ); } else if ( prob == 7 ) { p07_dat ( data_num, x, y ); } else if ( prob == 8 ) { p08_dat ( data_num, x, y ); } else if ( prob == 9 ) { p09_dat ( data_num, x, y ); } else if ( prob == 10 ) { p10_dat ( data_num, x, y ); } else { fprintf ( stderr, "\n" ); fprintf ( stderr, "P00_DAT - Fatal error!\n" ); fprintf ( stderr, " Illegal problem number = %d\n", prob ); exit ( 1 ); } return; } /******************************************************************************/ int p00_data_num ( int prob ) /******************************************************************************/ /* Purpose: P00_DATA_NUM returns the dimension of the data vector for any problem. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, int P00_DATA_NUM, the dimension of the data vector. */ { int data_num; if ( prob == 1 ) { data_num = p01_data_num ( ); } else if ( prob == 2 ) { data_num = p02_data_num ( ); } else if ( prob == 3 ) { data_num = p03_data_num ( ); } else if ( prob == 4 ) { data_num = p04_data_num ( ); } else if ( prob == 5 ) { data_num = p05_data_num ( ); } else if ( prob == 6 ) { data_num = p06_data_num ( ); } else if ( prob == 7 ) { data_num = p07_data_num ( ); } else if ( prob == 8 ) { data_num = p08_data_num ( ); } else if ( prob == 9 ) { data_num = p09_data_num ( ); } else if ( prob == 10 ) { data_num = p10_data_num ( ); } else { fprintf ( stderr, "\n" ); fprintf ( stderr, "P00_DATA_NUM - Fatal error!\n" ); fprintf ( stderr, " Illegal problem number = %d\n", prob ); exit ( 1 ); } return data_num; } /******************************************************************************/ int p00_prob_num ( ) /******************************************************************************/ /* Purpose: P00_PROB_NUM returns the number of test problems. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Output, int PROB_NUM, the number of test problems. */ { int prob_num; prob_num = 10; return prob_num; } /******************************************************************************/ void p00_story ( int prob ) /******************************************************************************/ /* Purpose: P00_STORY prints the "story" for any problem. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: None */ { if ( prob == 1 ) { p01_story ( ); } else if ( prob == 2 ) { p02_story ( ); } else if ( prob == 3 ) { p03_story ( ); } else if ( prob == 4 ) { p04_story ( ); } else if ( prob == 5 ) { p05_story ( ); } else if ( prob == 6 ) { p06_story ( ); } else if ( prob == 7 ) { p07_story ( ); } else if ( prob == 8 ) { p08_story ( ); } else if ( prob == 9 ) { p09_story ( ); } else if ( prob == 10 ) { p10_story ( ); } else { fprintf ( stderr, "\n" ); fprintf ( stderr, "P00_STORY - Fatal error!\n" ); fprintf ( stderr, " Unexpected input value of PROB.\n" ); exit ( 1 ); } return; } /******************************************************************************/ void p00_title ( int prob, char *title ) /******************************************************************************/ /* Purpose: P00_TITLE returns the title of any problem. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Input, int PROB, the number of the desired test problem. Output, char *TITLE, the title of the problem. */ { if ( prob == 1 ) { p01_title ( title ); } else if ( prob == 2 ) { p02_title ( title ); } else if ( prob == 3 ) { p03_title ( title ); } else if ( prob == 4 ) { p04_title ( title ); } else if ( prob == 5 ) { p05_title ( title ); } else if ( prob == 6 ) { p06_title ( title ); } else if ( prob == 7 ) { p07_title ( title ); } else if ( prob == 8 ) { p08_title ( title ); } else if ( prob == 9 ) { p09_title ( title ); } else if ( prob == 10 ) { p10_title ( title ); } else { fprintf ( stderr, "\n" ); fprintf ( stderr, "P00_TITLE - Fatal error!\n" ); fprintf ( stderr, " Illegal problem number = %d\n", prob ); exit ( 1 ); } return; } /******************************************************************************/ void p01_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P01_DAT returns the data vector for problem 1. Discussion: The X data is measured in days, and the Y data represents the observed position of Mars in a heliocentric coordinate system. The X data is equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Reference: Samuel Conte, Carl deBoor, Elementary Numerical Analysis, McGraw Hill, 1972, page 217. Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[10] = { 1250.5, 1260.5, 1270.5, 1280.5, 1290.5, 1300.5, 1310.5, 1320.5, 1330.5, 1340.5 }; double y_save[10] = { 1.39140, 1.37696, 1.34783, 1.30456, 1.24787, 1.17862, 1.09776, 1.00636, 0.90553, 0.79642 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p01_data_num ( ) /******************************************************************************/ /* Purpose: P01_DATA_NUM returns the dimension of the data vector for problem 1. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 10; return data_num; } /******************************************************************************/ void p01_story ( ) /******************************************************************************/ /* Purpose: P01_STORY prints the "story" for problem 1. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This example is due to deBoor.\n" ); printf ( " For this example, X is measured in days,\n" ); printf ( " and Y records the observed position of Mars in a heliocentric\n" ); printf ( " coordinate system.\n" ); return; } /******************************************************************************/ void p01_title ( char *title ) /******************************************************************************/ /* Purpose: P01_TITLE returns the title of problem 1. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "DeBoor example, Mars position" ); return; } /******************************************************************************/ void p02_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P02_DAT returns the data vector for problem 2. Discussion: The data lies roughly along a straight line. Polynomial interpolation is inappropriate. Instead, a least squares approximation should be sought, of the form: F(X) = A + B * X The X data is equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Reference: Samuel Conte, Carl deBoor, Elementary Numerical Analysis, McGraw Hill, 1972, page 217. Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[11] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 }; double y_save[11] = { 0.00, 0.60, 1.77, 1.92, 3.31, 3.52, 4.59, 5.31, 5.79, 7.06, 7.17 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p02_data_num ( ) /******************************************************************************/ /* Purpose: P02_DATA_NUM returns the dimension of the data vector for problem 2. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 11; return data_num; } /******************************************************************************/ void p02_story ( ) /******************************************************************************/ /* Purpose: P02_STORY prints the "story" for problem 2. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This example is due to deBoor.\n" ); printf ( " The data lies roughly along a straight line. Polynomial\n" ); printf ( " interpolation is inappropriate. Instead, a least squares\n" ); printf ( " approximation should be sought, of the form:\n" ); printf ( " F(X) = A + B * X\n" ); return; } /******************************************************************************/ void p02_title ( char *title ) /******************************************************************************/ /* Purpose: P02_TITLE returns the title of problem 2. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "DeBoor example, roughly linear data" ); return; } /******************************************************************************/ void p03_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P03_DAT returns the data vector for problem 3. Discussion: The data is all zero except for a single value of 1 in the center. This data set is interesting because an interpolation method that is "local" will produce an interpolating curve that is exactly zero over most of the outlying intervals, whereas a nonlocal interpolation method may produce a curve that "wiggles" over the entire interpolation interval. The X data is equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[11] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 }; double y_save[11] = { 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p03_data_num ( ) /******************************************************************************/ /* Purpose: P03_DATA_NUM returns the dimension of the data vector for problem 3. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 11; return data_num; } /******************************************************************************/ void p03_story ( ) /******************************************************************************/ /* Purpose: P03_STORY prints the "story" for problem 3. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " The data is all zero except for a single value of 1 in the center.\n" ); printf ( " This data set is interesting because an interpolation method that\n" ); printf ( " is \"local\" will produce an interpolating curve that is exactly\n" ); printf ( " zero over most of the outlying intervals, whereas a nonlocal\n" ); printf ( " interpolation method may produce a curve that \"wiggles\" over the\n" ); printf ( " entire interpolation interval.\n" ); return; } /******************************************************************************/ void p03_title ( char *title ) /******************************************************************************/ /* Purpose: P03_TITLE returns the title of problem 3. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "The pulse data, 0 0 0 0 0 1 0 0 0 0 0" ); return; } /******************************************************************************/ void p04_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P04_DAT returns the data vector for problem 4. Discussion: Theoretically, the data is a step, 0 to the left of 5, and 1 to the right. To keep things simple, the data is defined to be 0 up to 5 - RADIUS, 1/2 at 5, 1 at 5 + RADIUS and beyond, with RADIUS set to a "small" value, currently 0.01. Some interpolation methods will violently overreact to this jump. The X data is NOT equally spaced because of the handling of the pulse. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[13] = { 0.0, 1.0, 2.0, 3.0, 4.0, 4.99, 5.00, 5.01, 6.0, 7.0, 8.0, 9.0, 10.0 }; double y_save[13] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p04_data_num ( ) /******************************************************************************/ /* Purpose: P04_DATA_NUM returns the dimension of the data vector for problem 4. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 13; return data_num; } /******************************************************************************/ void p04_story ( ) /******************************************************************************/ /* Purpose: P04_STORY prints the "story" for problem 4. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " Theoretically, the data is a step, 0 to the left of 5, and 1\n" ); printf ( " to the right. To keep things simple, the data is defined\n" ); printf ( " to be 0 up to 5 - RADIUS, 1/2 at 5, 1 at 5 + RADIUS and beyond,\n" ); printf ( " with RADIUS set to a \"small\" value, currently 0.01.\n" ); printf ( " Some interpolation methods will violently overreact to this jump.\n" ); return; } /******************************************************************************/ void p04_title ( char *title ) /******************************************************************************/ /* Purpose: P04_TITLE returns the title of problem 4. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "The jump data, 0 0 0 0 0 1/2 1 1 1 1 1" ); return; } /******************************************************************************/ void p05_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P05_DAT returns the data vector for problem 5. Discussion: This example is due to deBoor. This data represents a property of titanium as a function of temperature. The X data is equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Reference: Carl deBoor, A Practical Guide to Splines, Springer Verlag. Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[49] = { 595.0, 605.0, 615.0, 625.0, 635.0, 645.0, 655.0, 665.0, 675.0, 685.0, 695.0, 705.0, 715.0, 725.0, 735.0, 745.0, 755.0, 765.0, 775.0, 785.0, 795.0, 805.0, 815.0, 825.0, 835.0, 845.0, 855.0, 865.0, 875.0, 885.0, 895.0, 905.0, 915.0, 925.0, 935.0, 945.0, 955.0, 965.0, 975.0, 985.0, 995.0, 1005.0, 1015.0, 1025.0, 1035.0, 1045.0, 1055.0, 1065.0, 1075.0 }; double y_save[49] = { 0.644, 0.622, 0.638, 0.649, 0.652, 0.639, 0.646, 0.657, 0.652, 0.655, 0.644, 0.663, 0.663, 0.668, 0.676, 0.676, 0.686, 0.679, 0.678, 0.683, 0.694, 0.699, 0.710, 0.730, 0.763, 0.812, 0.907, 1.044, 1.336, 1.881, 2.169, 2.075, 1.598, 1.211, 0.916, 0.746, 0.672, 0.627, 0.615, 0.607, 0.606, 0.609, 0.603, 0.601, 0.603, 0.601, 0.611, 0.601, 0.608 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p05_data_num ( ) /******************************************************************************/ /* Purpose: P05_DATA_NUM returns the dimension of the data vector for problem 5. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 49; return data_num; } /******************************************************************************/ void p05_story ( ) /******************************************************************************/ /* Purpose: P05_STORY prints the "story" for problem 5. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This example is due to deBoor.\n" ); printf ( " This data represents a temperature dependent property of titanium.\n" ); return; } /******************************************************************************/ void p05_title ( char *title ) /******************************************************************************/ /* Purpose: P05_TITLE returns the title of problem 5. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "DeBoor's Titanium property data" ); return; } /******************************************************************************/ void p06_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P06_DAT returns the data vector for problem 6. Discussion: The X data is equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { int i; int j; int n; int num_int = 5; n = 0; x[n] = 0.0; y[n] = 0.0; for ( i = 1; i <= num_int; i++ ) { for ( j = 1; j <= i; j++ ) { n = n + 1; x[n] = ( double ) ( i - 1 ) + 0.5 * ( double ) ( j ) / ( double ) ( i ); y[n] = ( double ) ( j ) / ( double ) ( i ); } for ( j = 1; j <= i; j++ ) { n = n + 1; x[n] = ( double ) ( i - 1 ) + 0.5 + 0.5 * ( double ) ( j ) / ( double ) ( i ); y[n] = 1.0 - ( double ) ( j ) / ( double ) ( i ); } } return; } /******************************************************************************/ int p06_data_num ( ) /******************************************************************************/ /* Purpose: P06_DATA_NUM returns the dimension of the data vector for problem 6. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; int num_int = 5; data_num = 1 + num_int * ( num_int + 1 ); return data_num; } /******************************************************************************/ void p06_story ( ) /******************************************************************************/ /* Purpose: P06_STORY prints the "story" for problem 6. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This is a data vector.\n" ); return; } /******************************************************************************/ void p06_title ( char *title ) /******************************************************************************/ /* Purpose: P06_TITLE returns the title of problem 6. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "The Sawtooth data" ); return; } /******************************************************************************/ void p07_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P07_DAT returns the data vector for problem 7. Discussion: The X data is NOT equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[9] = { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0 }; double y_save[9] = { 0.0, 0.9, 0.95, 0.9, 0.1, 0.05, 0.05, 0.2, 1.0 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p07_data_num ( ) /******************************************************************************/ /* Purpose: P07_DATA_NUM returns the dimension of the data vector for problem 7. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 9; return data_num; } /******************************************************************************/ void p07_story ( ) /******************************************************************************/ /* Purpose: P07_STORY prints the "story" for problem 7 Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This is a data vector.\n" ); return; } /******************************************************************************/ void p07_title ( char *title ) /******************************************************************************/ /* Purpose: P07_TITLE returns the title of problem 7. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "Concavity test data" ); return; } /******************************************************************************/ void p08_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P08_DAT returns the data vector for problem 8. Discussion: This example is due to Pierre Blais. Data is only available over the interval [0, 238], but extrapolation is to be used to extend the approximate function to a maximum argument of 1023. The behavior of the extrapolated curve is of great interest. The X data is NOT equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[12] = { 0.0, 71.0, 104.0, 135.0, 145.0, 160.0, 181.0, 193.0, 205.0, 215.0, 225.0, 238.0 }; double y_save[12] = { 0.0000, 7.7554, 19.7062, 35.53786, 42.91537, 54.7752, 66.75865, 78.49286, 89.76833, 101.746, 113.4824, 135.4566 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p08_data_num ( ) /******************************************************************************/ /* Purpose: P08_DATA_NUM returns the dimension of the data vector for problem 8. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 12; return data_num; } /******************************************************************************/ void p08_story ( ) /******************************************************************************/ /* Purpose: P08_STORY prints the "story" for problem 8. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This example is due to Pierre Blais.\n" ); printf ( " Data is only available over the interval [0, 238], but extrapolation\n" ); printf ( " is to be used to extend the approximate function to a maximum argument\n" ); printf ( " of 1023. The behavior of the extrapolated curve is of great interest.\n" ); return; } /******************************************************************************/ void p08_title ( char *title ) /******************************************************************************/ /* Purpose: P08_TITLE returns the title of problem 8. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "Extrapolation test data" ); return; } /******************************************************************************/ void p09_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P09_DAT returns the data vector for problem 9. Discussion: This example is due to Max Waldmeier. This data represents a measure of sunspot activity over the years 1700 to 1960. The X value is the year, and the Y value is a measure of the sunspot activity, which is usually, but not always, an integer. The X data is equally spaced. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Reference: Max Waldmeier, The Sunspot-Activity in the Years 1610-1960, Shulthess, Zurich, 1961. Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { int i; double y_save[261] = { 5.0, 11.0, 16.0, 23.0, 36.0, 58.0, 29.0, 20.0, 10.0, 8.0, 3.0, 0.0, 0.0, 2.0, 11.0, 27.0, 47.0, 63.0, 60.0, 39.0, 28.0, 26.0, 22.0, 11.0, 21.0, 40.0, 78.0, 122.0, 103.0, 73.0, 47.0, 35.0, 11.0, 5.0, 16.0, 34.0, 70.0, 81.0, 111.0, 101.0, 73.0, 40.0, 20.0, 16.0, 5.0, 11.0, 22.0, 40.0, 60.0, 80.9, 83.4, 47.7, 47.8, 30.7, 12.2, 9.6, 10.2, 32.4, 47.6, 54.0, 62.9, 85.9, 61.2, 45.1, 36.4, 20.9, 11.4, 37.8, 69.8, 106.1, 100.8, 81.6, 66.5, 34.8, 30.6, 7.0, 19.8, 92.5, 154.4, 125.9, 84.8, 68.1, 38.5, 22.8, 10.2, 24.1, 82.9, 132.0, 130.9, 118.1, 89.9, 66.6, 60.0, 46.9, 41.0, 21.3, 16.0, 6.4, 4.1, 6.8, 14.5, 34.0, 45.0, 43.1, 47.5, 42.2, 28.1, 10.1, 8.1, 2.5, 0.0, 1.4, 5.0, 12.2, 13.9, 35.4, 45.8, 41.1, 30.1, 23.9, 15.6, 6.6, 4.0, 1.8, 8.5, 16.6, 36.3, 49.6, 64.2, 67.0, 70.9, 47.8, 27.5, 8.5, 13.2, 56.9, 121.5, 138.3, 103.2, 85.7, 64.6, 36.7, 24.2, 10.7, 15.0, 40.1, 61.5, 98.5, 124.7, 96.3, 66.6, 64.5, 54.1, 39.0, 20.6, 6.7, 4.3, 22.7, 54.8, 93.8, 95.8, 77.2, 59.1, 44.0, 47.0, 30.5, 16.3, 7.3, 37.6, 74.0, 139.0, 111.2, 101.6, 66.2, 44.7, 17.0, 11.3, 12.4, 3.4, 6.0, 32.3, 54.3, 59.7, 63.7, 63.5, 52.2, 25.4, 13.1, 6.8, 6.3, 7.1, 35.6, 73.0, 85.1, 78.0, 64.0, 41.8, 26.2, 26.7, 12.1, 9.5, 2.7, 5.0, 24.4, 42.0, 63.5, 53.8, 62.0, 48.5, 43.9, 18.6, 5.7, 3.6, 1.4, 9.6, 47.4, 57.1, 103.9, 80.6, 63.6, 37.6, 26.1, 14.2, 5.8, 16.7, 44.3, 63.9, 69.0, 77.8, 64.9, 35.7, 21.2, 11.1, 5.7, 8.7, 36.1, 79.7, 114.4, 109.6, 88.8, 67.8, 47.5, 30.6, 16.3, 9.6, 33.2, 92.6, 151.6, 136.3, 134.7, 83.9, 69.4, 31.5, 13.9, 4.4, 38.0, 141.7, 190.2, 184.8, 159.0, 112.3 }; for ( i = 0; i < 261; i++ ) { x[i] = ( double ) ( 1700 + i ); } r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p09_data_num ( ) /******************************************************************************/ /* Purpose: P09_DATA_NUM returns the dimension of the data vector for problem 9. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 261; return data_num; } /******************************************************************************/ void p09_story ( ) /******************************************************************************/ /* Purpose: P09_STORY prints the "story" for problem 09 Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " This example is due to Max Waldmeier.\n" ); printf ( " This data represents a measure of sunspot activity over the\n" ); printf ( " years 1700 to 1960. The X value is the year, and the Y value\n" ); printf ( " is a measure of the sunspot activity, which is usually, but\n" ); printf ( " not always, an integer.\n" ); return; } /******************************************************************************/ void p09_title ( char *title ) /******************************************************************************/ /* Purpose: P09_TITLE returns the title of problem 09. Licensing: This code is distributed under the MIT license. Modified: 25 August 2011 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "Sunspot data, 1700-1960." ); return; } /******************************************************************************/ void p10_dat ( int data_num, double x[], double y[] ) /******************************************************************************/ /* Purpose: P10_DAT returns the data vector for problem 10. Discussion: 100 uniformly random X values between -2 and 5 were selected, and the formula Y = 2 + 5 * X + 10 * N(0,1) was evaluated, where N(0,1) represents random normal values with 0 mean and unit variance. The original data was unsorted, but this caused problems for various approximation codes, so the data has now been sorted. Licensing: This code is distributed under the MIT license. Modified: 08 February 2012 Author: John Burkardt Parameters: Input, int DATA_NUM, the dimension of the data vector. Output, double X[DATA_NUM], the abscissa data. Output, double Y[DATA_NUM], the ordinate data. */ { double x_save[100] = { -1.9935, -1.8884, -1.8813, -1.8786, -1.8714, -1.8108, -1.6614, -1.5991, -1.4423, -1.3441, -1.1730, -1.1575, -0.9886, -0.8196, -0.7771, -0.7706, -0.7270, -0.7243, -0.7228, -0.6235, -0.6023, -0.1650, -0.1117, -0.0570, 0.0923, 0.1132, 0.3157, 0.3343, 0.3356, 0.3827, 0.4019, 0.4570, 0.4866, 0.6041, 0.6803, 0.8395, 0.8734, 0.9115, 0.9190, 1.0716, 1.1649, 1.2261, 1.3118, 1.3484, 1.3698, 1.5721, 1.6258, 1.7749, 1.8234, 1.9732, 1.9784, 2.0022, 2.0231, 2.0398, 2.0401, 2.0757, 2.0824, 2.2051, 2.2634, 2.3076, 2.3660, 2.3931, 2.4175, 2.5928, 2.6235, 2.8109, 2.8898, 2.9561, 2.9669, 3.1161, 3.1430, 3.1749, 3.2373, 3.4166, 3.6131, 3.6635, 3.6669, 3.7486, 3.7530, 3.7862, 3.8021, 3.8298, 3.8696, 3.9051, 3.9509, 4.0678, 4.1038, 4.1557, 4.2456, 4.2564, 4.3228, 4.3403, 4.4157, 4.4998, 4.5767, 4.6312, 4.7029, 4.7717, 4.8424, 4.8915 }; double y_save[261] = { -1.8918, -8.6202, -0.4152, -4.6967, -2.4144, -21.8853, -16.5097, -10.4657, -4.1150, 6.5665, -6.7649, 8.8276, 1.8109, 9.6428, -0.6165, -8.4213, -16.4491, -0.0667, 6.5713, -4.0436, -6.4194, -1.9114, -9.5246, -3.2154, 0.6541, 3.0247, 2.9410, 9.7848, 4.7713, 22.0539, 7.1301, 22.3302, -2.7979, 10.2864, 2.7993, 12.1989, 12.3065, -15.3026, -6.6749, -7.0521, 11.8429, 22.8325, 5.2912, 16.8654, 14.3045, -0.6553, 14.1038, 3.3556, 26.2797, 11.5406, 28.2522, 7.7605, 18.0102, 11.5710, -8.0188, 2.5576, 18.5371, 12.4771, 2.1298, 7.2745, 16.3256, 4.0354, 23.8374, 8.5572, 33.2063, 5.2561, 18.4409, 1.5702, 9.5982, 11.6483, 21.7285, 27.2958, 21.1916, 15.3527, 28.2207, 28.3065, 21.5368, 26.4556, 24.8933, 11.0617, 28.6064, 14.5770, 15.3088, 23.2952, 18.6796, 21.0208, 28.4730, 33.2469, 21.2484, 26.5592, 21.2314, 25.9979, 28.4785, 18.3307, 27.6318, 31.1673, 26.4379, 43.1573, 20.1264, 19.0873 }; r8vec_copy ( data_num, x_save, x ); r8vec_copy ( data_num, y_save, y ); return; } /******************************************************************************/ int p10_data_num ( ) /******************************************************************************/ /* Purpose: P10_DATA_NUM returns the dimension of the data vector for problem 10. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Output, int DATA_NUM, the dimension of the data vector. */ { int data_num; data_num = 100; return data_num; } /******************************************************************************/ void p10_story ( ) /******************************************************************************/ /* Purpose: P10_STORY prints the "story" for problem 10. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: None */ { printf ( "\n" ); printf ( " 100 uniformly random X values between -2 and 5 were selected, and\n" ); printf ( " the formula Y = 2 + 5 * X + 10 * N(0,1) was evaluated, where N(0,1)\n" ); printf ( " represents random normal values with 0 mean and unit variance.\n" ); return; } /******************************************************************************/ void p10_title ( char *title ) /******************************************************************************/ /* Purpose: P10_TITLE returns the title of problem 10. Licensing: This code is distributed under the MIT license. Modified: 06 February 2012 Author: John Burkardt Parameters: Output, char *TITLE, the title of the problem. */ { strcpy ( title, "Y = 2 + 5*X + 10*N(0,1)." ); return; } /******************************************************************************/ void r8vec_copy ( int n, double a1[], double a2[] ) /******************************************************************************/ /* Purpose: R8VEC_COPY copies an R8VEC. Discussion: An R8VEC is a vector of R8's. Licensing: This code is distributed under the MIT license. Modified: 03 July 2005 Author: John Burkardt Parameters: Input, int N, the number of entries in the vectors. Input, double A1[N], the vector to be copied. Input, double A2[N], the copy of A1. */ { int i; for ( i = 0; i < n; i++ ) { a2[i] = a1[i]; } return; } /******************************************************************************/ void r8vec2_print ( int n, double a1[], double a2[], char *title ) /******************************************************************************/ /* Purpose: R8VEC2_PRINT prints an R8VEC2. Discussion: An R8VEC2 is a dataset consisting of N pairs of real values, stored as two separate vectors A1 and A2. Licensing: This code is distributed under the MIT license. Modified: 26 March 2009 Author: John Burkardt Parameters: Input, int N, the number of components of the vector. Input, double A1[N], double A2[N], the vectors to be printed. Input, char *TITLE, a title. */ { int i; fprintf ( stdout, "\n" ); fprintf ( stdout, "%s\n", title ); fprintf ( stdout, "\n" ); for ( i = 0; i < n; i++ ) { fprintf ( stdout, " %4d: %14f %14f\n", i, a1[i], a2[i] ); } return; } /******************************************************************************/ void r8vec2_write ( char *output_filename, int n, double x[], double y[] ) /******************************************************************************/ /* Purpose: R8VEC2_WRITE writes an R8VEC2 file. Discussion: An R8VEC2 is a pair of vectors of R8's. Licensing: This code is distributed under the MIT license. Modified: 10 July 2011 Author: John Burkardt Parameters: Input, char *OUTPUT_FILENAME, the output filename. Input, int N, the number of points. Input, double X[N], Y[N], the data. */ { int j; FILE *output; /* Open the file. */ output = fopen ( output_filename, "wt" ); if ( !output ) { fprintf ( stderr, "\n" ); fprintf ( stderr, "R8VEC2_WRITE - Fatal error!\n" ); fprintf ( stderr, " Could not open the output file.\n" ); exit ( 1 ); } /* Write the data. */ for ( j = 0; j < n; j++ ) { fprintf ( output, " %24.16g %24.16g\n", x[j], y[j] ); } /* Close the file. */ fclose ( output ); return; }