mirror of
https://git.savannah.gnu.org/git/coreutils.git
synced 2026-11-17 18:02:09 +03:00
.
This commit is contained in:
1 parent
0dd12bdc03
commit
4f081364fb
1 file changed
-735
-735
@@ -1,735 +0,0 @@
|
||||
/* spline.c -- Do spline interpolation. */
|
||||
|
||||
/******************************************************************************
|
||||
David L. Fox
|
||||
2140 Braun Dr.
|
||||
Golden, CO 80401
|
||||
|
||||
This program has been placed in the public domain by its author.
|
||||
|
||||
Version Date Change
|
||||
1.1 17 Dec 1985 Modify getdata() to realloc() more memory if needed.
|
||||
1.0 14 May 1985
|
||||
|
||||
spline [options] [file]
|
||||
|
||||
Spline reads pairs of numbers from file (or the standard input, if file is missing).
|
||||
The pairs are interpreted as abscissas and ordinates of a function. The output of
|
||||
spline consists of similar pairs generated from the input by interpolation with
|
||||
cubic splines. (See R. W. Hamming, Numerical Methods for Scientists and Engineers,
|
||||
2nd ed., pp. 349ff.) There are sufficiently many points in the output to appear
|
||||
smooth when plotted (e.g., by graph(1)). The output points are approximately evenly
|
||||
spaced and include the input points.
|
||||
|
||||
There may be one or more options of the form: -o [argument [arg2] ].
|
||||
|
||||
The available options are:
|
||||
|
||||
-a Generate abscissa values automatically. The input consists of a list of
|
||||
ordinates. The generated abscissas are evenly spaced with spacing given by
|
||||
the argument, or 1 if the next argument is not a number.
|
||||
|
||||
-f Set the first derivative of the spline function at the left and right end
|
||||
points to the first and second arguments following -f. If only one numerical
|
||||
argument follows -f then that value is used for both left and right end points.
|
||||
|
||||
-k The argument of the k option is the value of the constant used to calculate
|
||||
the boundary values by y''[0] = ky''[1] and y''[n] = ky''[n-1]. The default
|
||||
value is k = 0.
|
||||
|
||||
-m The argument gives the maximum number of input data points. The default is 1000.
|
||||
If the input contains more than this many points additional memory will be
|
||||
allocated. This option may be used to slightly increase efficiency for large
|
||||
data sets or reduce the amount of memory required for small data sets.
|
||||
|
||||
-n The number of output points is given by the argument. The default value is 100.
|
||||
|
||||
-p The splines used for interpolation are forced to be periodic, i.e. y'[0] = y'[n].
|
||||
The first and last ordinates should be equal.
|
||||
|
||||
-s Set the second derivative of the spline function at the left and right end
|
||||
points to the first and second arguments following -s. If only one numerical
|
||||
argument follows -s then that value is used for both left and right end points.
|
||||
|
||||
-x The argument (and arg2, if present) are the lower (and upper) limits on the
|
||||
abscissa values in the output. If the x option is not specified these limits
|
||||
are calculated from the data. Automatic abscissas start at the lower limit
|
||||
(default 0).
|
||||
|
||||
The data need not be monotonic in x but all the x values must be distinct.
|
||||
Non-numeric data in the input is ignored.
|
||||
******************************************************************************/
|
||||
|
||||
#include <a:stdio.h>
|
||||
#include <ctype.h>
|
||||
|
||||
/* The constant DOUBLE is a compile time switch.
|
||||
If #define DOUBLE appears here double pecision variables are
|
||||
used to store all data and parameters.
|
||||
Otherwise, float variables are used for the data.
|
||||
For most smoothing and and interpolation applications single
|
||||
precision is more than adequate.
|
||||
Double precision is used to solve the system of linear equations
|
||||
in either case.
|
||||
*/
|
||||
/* #define DOUBLE */
|
||||
|
||||
#ifdef DOUBLE
|
||||
# define double real; /* Type used for data storage. */
|
||||
# define IFMT "%F" /* Input format. */
|
||||
# define OFMT "%18.14g %18.14g\n" /* Output format. */
|
||||
#else
|
||||
# define float real; /* Type used for data storage. */
|
||||
# define IFMT "%f" /* Input format. */
|
||||
# define OFMT "%8.5g %8.5g\n" /* Output format. */
|
||||
#endif
|
||||
|
||||
/* Numerical constants: These may be machine and/or precision dependent. */
|
||||
#define HUGE (1.e38) /* Largest floating point number. */
|
||||
#define EPS 1.e-5 /* Test for zero when solving linear equations. */
|
||||
|
||||
/* Default parameters */
|
||||
#define NPTS 1000
|
||||
#define NINT 100
|
||||
#define DEFSTEP 1. /* Default step size for automatic abcissas. */
|
||||
#define DEFBVK 0. /* Default boundary value constant. */
|
||||
|
||||
/* Boundary condition types. */
|
||||
#define EXTRAP 0 /* Extrapolate second derivative:
|
||||
y''(0) = k * y''(1), y''(n) = k * y''(n-1) */
|
||||
#define FDERIV 1 /* Fixed first derivatives y'(0) and y'(n). */
|
||||
#define SDERIV 2 /* Fixed second derivatives y''(0) and y''(n). */
|
||||
#define PERIOD 3 /* Periodic: derivatives equal at end points. */
|
||||
|
||||
/* Token types for command line processing. */
|
||||
#define OPTION 1
|
||||
#define NUMBER 2
|
||||
#define OTHER 3
|
||||
|
||||
/* Define error numbers. */
|
||||
#define MEMERR 1
|
||||
#define NODATA 2
|
||||
#define BADOPT 4
|
||||
#define BADFILE 5
|
||||
#define XTRAARG 6
|
||||
#define XTRAPTS 7
|
||||
#define SINGERR 8
|
||||
#define DUPX 9
|
||||
#define BADBC 10
|
||||
#define RANGERR 11
|
||||
|
||||
/* Constants and flags are global. */
|
||||
int aflag = FALSE; /* Automatic abscissa flag. */
|
||||
real step = DEFSTEP; /* Spacing for automatic abscissas. */
|
||||
int bdcode = EXTRAP; /* Type of boundary conditions:
|
||||
0 extrapolate f'' with coeficient k.
|
||||
1 first derivatives given
|
||||
2 second derivatives given
|
||||
3 periodic */
|
||||
real leftd = 0., /* Boundary values of derivatives. */
|
||||
rightd = 0.;
|
||||
real k = DEFBVK; /* Boundary value constant. */
|
||||
int rflag = 0; /* 0: take range from data, 1: min. given, 2: min. & max. given. */
|
||||
real xmin = HUGE, xmax; /* Output range. */
|
||||
unsigned nint = NINT; /* Number of intervals in output. */
|
||||
unsigned maxpts = NPTS; /* Maximun number of points. */
|
||||
unsigned nknots = 0; /* Number of input points. */
|
||||
int sflag = FALSE; /* If TRUE data must be sorted. */
|
||||
char *datafile; /* Name of data file */
|
||||
|
||||
int xcompare(); /* Function to compare x values of two data points. */
|
||||
|
||||
struct pair {
|
||||
real x, y;
|
||||
} *data; /* Points to list of data points. */
|
||||
|
||||
struct bandm {
|
||||
double diag, upper, rhs;
|
||||
} *eqns; /* Points to elements of band matrix used to calculate
|
||||
coefficients of the splines. */
|
||||
|
||||
main(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
setup(argc, argv);
|
||||
if (nknots == 1) { /* Cannot interpolate with one data point. */
|
||||
printf(OFMT,data->x, data->y);
|
||||
exit(0);
|
||||
}
|
||||
if (sflag) /* Sort data if needed. */
|
||||
qsort(data, nknots, sizeof(struct pair), xcompare);
|
||||
calcspline();
|
||||
interpolate();
|
||||
}
|
||||
|
||||
/* xcompare -- Compare abcissas of two data points (for qsort). */
|
||||
xcompare(arg1, arg2)
|
||||
struct pair *arg1, *arg2;
|
||||
{
|
||||
if (arg1->x > arg2->x)
|
||||
return(1);
|
||||
else if (arg1->x < arg2->x)
|
||||
return(-1);
|
||||
else
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* error -- Print error message and abort fatal errors. */
|
||||
error(errno, auxmsg)
|
||||
int errno;
|
||||
char *auxmsg;
|
||||
{ char *msg;
|
||||
int fatal, usemsg;
|
||||
static char *usage =
|
||||
"usage: spline [options] [file]\noptions:\n",
|
||||
*options = "-a spacing\n-k const\n-n intervals\n-m points\n-p\n-x xmin xmax\n";
|
||||
|
||||
fatal = TRUE; /* Default is fatal error. */
|
||||
usemsg = FALSE; /* Default no usage message. */
|
||||
fprintf(stderr, "spline: ");
|
||||
switch(errno) {
|
||||
case MEMERR:
|
||||
msg = "not enough memory for %u data points\n";
|
||||
break;
|
||||
case NODATA:
|
||||
msg = "data file %s empty\n";
|
||||
break;
|
||||
case BADOPT:
|
||||
msg = "unknown option: %c\n";
|
||||
usemsg = TRUE;
|
||||
break;
|
||||
case BADFILE:
|
||||
msg = "cannot open file: %s\n";
|
||||
break;
|
||||
case XTRAARG:
|
||||
msg = "extra argument ignored: %s\n";
|
||||
fatal = FALSE;
|
||||
usemsg = TRUE;
|
||||
break;
|
||||
case XTRAPTS:
|
||||
fatal = FALSE;
|
||||
msg = "%s";
|
||||
break;
|
||||
case DUPX:
|
||||
msg = "duplicate abcissa value: %s\n";
|
||||
break;
|
||||
case RANGERR:
|
||||
msg = "xmax < xmin not allowed %s\n";
|
||||
break;
|
||||
/* The following errors "can't happen." */
|
||||
/* If they occur some sort of bug is indicated. */
|
||||
case SINGERR:
|
||||
msg = "singular matrix encountered %s\n";
|
||||
break;
|
||||
case BADBC:
|
||||
msg = "internal error: bad boundary value code %d\n";
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "unknown error number: %d\n", errno);
|
||||
exit(1);
|
||||
}
|
||||
fprintf(stderr, msg, auxmsg);
|
||||
if (usemsg)
|
||||
fprintf(stderr,"%s%s", usage, options);
|
||||
if (fatal)
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* setup -- Initalize all constants and read data. */
|
||||
setup(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{ char *malloc();
|
||||
FILE fdinp, /* Source of input. */
|
||||
doarg();
|
||||
|
||||
fdinp = doarg(argc, argv); /* Process command line arguments. */
|
||||
|
||||
/* Allocate memory for data and band matrix of coefficients. */
|
||||
if ((data = malloc(maxpts*sizeof(struct pair))) == NULL) {
|
||||
error(MEMERR, (char *)maxpts);
|
||||
}
|
||||
|
||||
getdata(fdinp); /* Read data from fdinp. */
|
||||
if (fdinp != stdin)
|
||||
fclose(fdinp); /* Close input data file. */
|
||||
if (nknots == 0) {
|
||||
error(NODATA, datafile);
|
||||
}
|
||||
/* Allocate memory for calculation of spline coefficients. */
|
||||
if ((eqns = malloc((nknots+1)*sizeof(struct bandm))) == NULL) {
|
||||
error(MEMERR, (char *)nknots);
|
||||
}
|
||||
}
|
||||
|
||||
/* doarg -- Process arguments. */
|
||||
FILE
|
||||
doarg(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{ int i, type;
|
||||
double atof();
|
||||
char *s, str[15];
|
||||
FILE fdinp;
|
||||
|
||||
s = argv[i=1];
|
||||
type = gettok(&i, &s, argv, str);
|
||||
do {
|
||||
if (type == OPTION) {
|
||||
switch(*str) {
|
||||
case 'a': /* Automatic abscissa. */
|
||||
aflag = TRUE;
|
||||
rflag = rflag < 2 ? 1 : rflag;
|
||||
if (xmin == HUGE) /* Initialize xmin, if needed. */
|
||||
xmin = 0.;
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
if ((step = atof(str)) <= 0.)
|
||||
error(RANGERR,"");
|
||||
type = gettok(&i, &s, argv, str);
|
||||
}
|
||||
break;
|
||||
case 'f': /* Fix first derivative at boundaries. */
|
||||
bdcode = FDERIV;
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
leftd = atof(str);
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
rightd = atof(str);
|
||||
type = gettok(&i, &s, argv, str);
|
||||
}
|
||||
else {
|
||||
rightd = leftd;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 'k': /* Set boundary value constant. */
|
||||
bdcode = EXTRAP;
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
k = atof(str);
|
||||
type = gettok(&i, &s, argv, str);
|
||||
}
|
||||
break;
|
||||
case 'm': /* Set number of intervals in output. */
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
maxpts = (unsigned)atoi(str);
|
||||
type = gettok(&i, &s, argv, str);
|
||||
}
|
||||
break;
|
||||
case 'n': /* Set number of intervals in output. */
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
nint = (unsigned)atoi(str);
|
||||
type = gettok(&i, &s, argv, str);
|
||||
}
|
||||
break;
|
||||
case 'p': /* Require periodic interpolation function. */
|
||||
bdcode = PERIOD;
|
||||
type = gettok(&i, &s, argv, str);
|
||||
break;
|
||||
case 's': /* Fix second derivative at boundaries. */
|
||||
bdcode = SDERIV;
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
leftd = atof(str);
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
rightd = atof(str);
|
||||
type = gettok(&i, &s, argv, str);
|
||||
}
|
||||
else {
|
||||
rightd = leftd;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 'x': /* Set range of x values. */
|
||||
rflag = 1;
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
xmin = atof(str);
|
||||
if ((type = gettok(&i, &s, argv, str)) == NUMBER) {
|
||||
xmax = atof(str);
|
||||
rflag = 2;
|
||||
type = gettok(&i, &s, argv, str);
|
||||
if (xmax <= xmin)
|
||||
error(RANGERR, "");
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
error(BADOPT, (char *)argv[i][1]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (argc > i) {
|
||||
datafile = argv[i];
|
||||
if ((fdinp = fopen(argv[i++], "r")) == NULL) {
|
||||
error(BADFILE, argv[i-1]);
|
||||
}
|
||||
if (argc > i)
|
||||
error(XTRAARG, argv[i]);
|
||||
}
|
||||
else
|
||||
fdinp = stdin;
|
||||
break;
|
||||
}
|
||||
} while (i < argc);
|
||||
return fdinp;
|
||||
}
|
||||
|
||||
/* gettok -- Get one token from command line, return type. */
|
||||
gettok(indexp, locp, argv, str)
|
||||
int *indexp; /* Pointer to index in argv array. */
|
||||
char **locp; /* Pointer to current location in argv[*indexp]. */
|
||||
char **argv;
|
||||
char *str;
|
||||
{ char *s;
|
||||
char *strcpy(), *strchr();
|
||||
int type;
|
||||
|
||||
s = *locp;
|
||||
while (isspace(*s) || *s == ',')
|
||||
++s;
|
||||
if (*s == '\0') /* Look at next element in argv. */
|
||||
s = argv[++*indexp];
|
||||
if (*s == '-' && isalpha(s[1])) {
|
||||
/* Found an option. */
|
||||
*str = *++s;
|
||||
str[1] = '\0';
|
||||
++s;
|
||||
type = OPTION;
|
||||
}
|
||||
else if (is_number(s)) {
|
||||
while (is_number(s))
|
||||
*str++ = *s++;
|
||||
*str = '\0';
|
||||
type = NUMBER;
|
||||
}
|
||||
else {
|
||||
strcpy(str, s);
|
||||
s = strchr(s, '\0');
|
||||
type = OTHER;
|
||||
}
|
||||
*locp = s;
|
||||
return(type);
|
||||
}
|
||||
|
||||
/* is_number -- Return TRUE if argument is the ASCII representation of a number. */
|
||||
is_number(string)
|
||||
char *string;
|
||||
{
|
||||
if (isdigit(*string) ||
|
||||
*string == '.' ||
|
||||
*string == '+' ||
|
||||
(*string == '-' && (isdigit(string[1]) || string[1] == '.')))
|
||||
return(TRUE);
|
||||
else
|
||||
return(FALSE);
|
||||
}
|
||||
|
||||
/* getdata -- Read data points from fdinp. */
|
||||
getdata(fdinp)
|
||||
FILE fdinp;
|
||||
{ int n, i;
|
||||
real lastx, min, max;
|
||||
struct pair *dp;
|
||||
char msg[60], *realloc();
|
||||
|
||||
nknots = 0;
|
||||
lastx = -HUGE;
|
||||
dp = data; /* Point to head of list of data. */
|
||||
min = HUGE;
|
||||
max = -HUGE;
|
||||
do {
|
||||
if (aflag) { /* Generate abcissa. */
|
||||
dp->x = xmin + nknots*step;
|
||||
n = 0;
|
||||
}
|
||||
else { /* Read abcissa. */
|
||||
while ((n = (fscanf(fdinp,IFMT,&dp->x))) == 0)
|
||||
; /* Skip non-numeric input. */
|
||||
}
|
||||
if (n == 1) {
|
||||
if (min > dp->x)
|
||||
min = dp->x;
|
||||
if (max < dp->x)
|
||||
max = dp->x;
|
||||
if (lastx > dp->x) { /* Check for monotonicity. */
|
||||
sflag = TRUE; /* Data must be sorted. */
|
||||
}
|
||||
lastx = dp->x;
|
||||
}
|
||||
/* Read ordinate. */
|
||||
while ((n = (fscanf(fdinp, IFMT, &dp->y))) == 0)
|
||||
; /* Skip non-numeric input. */
|
||||
if (++nknots >= maxpts) { /* Too many points, allocate more memory. */
|
||||
if ((data = realloc(data, (maxpts *= 2)*sizeof(struct pair))) == NULL) {
|
||||
error(MEMERR, (char *)maxpts);
|
||||
}
|
||||
dp = data + nknots;
|
||||
sprintf(msg, "more than %d input points, more memory allocated\n",
|
||||
maxpts/2);
|
||||
error(XTRAPTS,msg);
|
||||
}
|
||||
else
|
||||
++dp;
|
||||
} while (n == 1);
|
||||
--nknots;
|
||||
if (aflag) { /* Compute maximum ordinate. */
|
||||
max = xmin + (nknots-1)*step;
|
||||
}
|
||||
if (rflag < 2) {
|
||||
xmax = max;
|
||||
if (rflag < 1)
|
||||
xmin = min;
|
||||
}
|
||||
}
|
||||
|
||||
/* calcspline -- Calculate coeficients of spline functions. */
|
||||
calcspline()
|
||||
{
|
||||
calccoef();
|
||||
solvband();
|
||||
}
|
||||
|
||||
/* calccoef -- Calculate coefficients of linear equations determining spline functions. */
|
||||
calccoef()
|
||||
{ int i, j;
|
||||
struct bandm *ptr, tmp1, tmp2;
|
||||
double h, h1;
|
||||
char str[10];
|
||||
|
||||
ptr = eqns;
|
||||
/* Initialize first row of matrix. */
|
||||
if ((h1 = data[1].x - data[0].x) == 0.) {
|
||||
sprintf(str, "%8.5g", data[0].x);
|
||||
error(DUPX, str);
|
||||
}
|
||||
switch(bdcode) { /* First equation depends on boundary conditions. */
|
||||
case EXTRAP:
|
||||
ptr->upper = -k;
|
||||
ptr->diag = 1.;
|
||||
ptr->rhs = 0.;
|
||||
break;
|
||||
case FDERIV: /* Fixed first derivatives at ends. */
|
||||
ptr->upper = 1.;
|
||||
ptr->diag = 2.;
|
||||
h = data[1].x - data[0].x;
|
||||
ptr->rhs = 6.*((data[1].y - data[0].y)/(h*h) - leftd/h);
|
||||
break;
|
||||
case SDERIV:
|
||||
ptr->upper = 0.;
|
||||
ptr->diag = 1.;
|
||||
ptr->rhs = leftd;
|
||||
break;
|
||||
case PERIOD: /* Periodic splines. */
|
||||
ptr->upper = 1.;
|
||||
ptr->diag = 2.;
|
||||
break;
|
||||
default:
|
||||
error(BADBC, (char *) bdcode);
|
||||
}
|
||||
++ptr;
|
||||
|
||||
/* Initialize rows 1 to n-1, sub-diagonal band is assumed to be 1. */
|
||||
for (i=1; i < nknots-1; ++i, ++ptr) {
|
||||
h = h1;
|
||||
if ((h1 = data[i+1].x - data[i].x) == 0.) {
|
||||
sprintf(str, "%8.5g", data[i].x);
|
||||
error(DUPX, str);
|
||||
}
|
||||
ptr->diag = 2.*(h + h1)/h;
|
||||
ptr->upper = h1/h;
|
||||
ptr->rhs = 6.*((data[i+1].y-data[i].y)/(h*h1) -
|
||||
(data[i].y - data[i-1].y)/(h*h));
|
||||
}
|
||||
/* Initialize last row. */
|
||||
switch(bdcode) {
|
||||
case EXTRAP: /* Standard case. */
|
||||
ptr->diag = 1.;
|
||||
ptr->upper = -k; /* Upper holds actual sub-diagonal value. */
|
||||
ptr->rhs = 0.;
|
||||
break;
|
||||
case FDERIV: /* Fixed first derivatives at ends. */
|
||||
ptr->upper = 1.;
|
||||
ptr->diag = 2.;
|
||||
h = data[nknots-1].x - data[nknots-2].x;
|
||||
ptr->rhs = 6.*((data[nknots-2].y - data[nknots-1].y)/(h*h) + rightd/h);
|
||||
break;
|
||||
case SDERIV:
|
||||
ptr->upper = 0.;
|
||||
ptr->diag = 1.;
|
||||
ptr->rhs = rightd;
|
||||
break;
|
||||
case PERIOD: /* Use periodic boundary conditions. */
|
||||
/* First and last row are not in tridiagonal form. */
|
||||
h = data[1].x - data[0].x;
|
||||
h1 = data[nknots-1].x - data[nknots-2].x;
|
||||
ptr->diag = 1.;
|
||||
ptr->upper = 0.;
|
||||
tmp1.diag = -1.;
|
||||
tmp1.upper = 0;
|
||||
tmp1.rhs = 0.;
|
||||
tmp2.diag = 2.*h1/h;
|
||||
tmp2.upper = h1/h;
|
||||
tmp2.rhs = 6.*((data[1].y - data[0].y)/(h*h) -
|
||||
(data[nknots-1].y - data[nknots-2].y)/(h1*h));
|
||||
/* Transform periodic boundary equations to tri-diagonal form. */
|
||||
for (i = 1; i < nknots - 1; ++i) {
|
||||
tmp1.upper /= tmp1.diag;
|
||||
tmp1.rhs /= tmp1.diag;
|
||||
ptr->diag /= tmp1.diag;
|
||||
ptr->upper /= tmp1.diag;
|
||||
tmp1.diag = tmp1.upper - eqns[i].diag;
|
||||
tmp1.upper = -eqns[i].upper;
|
||||
tmp1.rhs -= eqns[i].rhs;
|
||||
tmp2.upper /= tmp2.diag;
|
||||
tmp2.rhs /= tmp2.diag;
|
||||
eqns->diag /= tmp2.diag;
|
||||
eqns->upper /= tmp2.diag;
|
||||
tmp2.diag = tmp2.upper - eqns[nknots-1-i].diag/eqns[nknots-1-i].upper;
|
||||
tmp2.upper = -1./eqns[nknots-1-i].upper;
|
||||
tmp2.rhs -= eqns[nknots-1-i].rhs/eqns[nknots-1-i].upper;
|
||||
}
|
||||
/* Add in remaining terms of boundary condition equation. */
|
||||
ptr->upper += tmp1.diag;
|
||||
ptr->diag += tmp1.upper;
|
||||
ptr->rhs = tmp1.rhs;
|
||||
eqns->diag += tmp2.upper;
|
||||
eqns->upper += tmp2.diag;
|
||||
eqns->rhs = tmp2.rhs;
|
||||
break;
|
||||
default:
|
||||
error(BADBC, (char *) bdcode);
|
||||
}
|
||||
}
|
||||
|
||||
/* solvband -- Solve band matrix for spline functions. */
|
||||
solvband()
|
||||
{ int i, flag;
|
||||
struct bandm *ptr;
|
||||
double k1;
|
||||
double fabs();
|
||||
int fcompare();
|
||||
|
||||
ptr = eqns;
|
||||
flag = FALSE;
|
||||
/* Make a pass to triangularize matrix. */
|
||||
for (i=1; i < nknots - 1; ++i, ++ptr) {
|
||||
if (fabs(ptr->diag) < EPS) {
|
||||
/* Near zero on diagonal, pivot. */
|
||||
if (fabs(ptr->upper) < EPS)
|
||||
error(SINGERR, "");
|
||||
flag = TRUE;
|
||||
ptr->diag = i; /* Keep row index in diag.
|
||||
Actual value of diag is always 1. */
|
||||
if (i == nknots - 2) {
|
||||
flag = 2;
|
||||
/* Exchange next to last and last rows. */
|
||||
k1 = ptr->rhs/ptr->upper;
|
||||
if (fabs((ptr+1)->upper) < EPS)
|
||||
error(SINGERR, "");
|
||||
ptr->rhs = (ptr+1)->rhs/(ptr+1)->upper;
|
||||
ptr->upper = (ptr+1)->diag/(ptr+1)->upper;
|
||||
(ptr+1)->upper = 0.;
|
||||
(ptr+1)->rhs = k1;
|
||||
}
|
||||
else {
|
||||
ptr->rhs = (ptr+1)->rhs - (k1 = ptr->rhs/ptr->upper)*(ptr+1)->diag;
|
||||
ptr->upper = (ptr+1)->upper; /* This isn't super-diagonal element
|
||||
but rather one to its right.
|
||||
Must watch for this when
|
||||
back substituting. */
|
||||
(++ptr)->diag = i-1;
|
||||
++i;
|
||||
ptr->upper = 0;
|
||||
ptr->rhs = k1;
|
||||
(ptr+1)->rhs -= ptr->rhs;
|
||||
}
|
||||
}
|
||||
else {
|
||||
ptr->upper /= ptr->diag;
|
||||
ptr->rhs /= ptr->diag;
|
||||
ptr->diag = i-1; /* Used to reorder solution if needed. */
|
||||
(ptr+1)->diag -= ptr->upper;
|
||||
(ptr+1)->rhs -= ptr->rhs;
|
||||
}
|
||||
}
|
||||
/* Last row is a special case. */
|
||||
if (flag != 2) {
|
||||
/* If flag == 2 last row is already computed. */
|
||||
ptr->upper /= ptr->diag;
|
||||
ptr->rhs /= ptr->diag;
|
||||
ptr->diag = ptr - eqns;
|
||||
++ptr;
|
||||
ptr->diag -= (ptr-1)->upper * ptr->upper;
|
||||
ptr->rhs -= (ptr-1)->rhs * ptr->upper;
|
||||
ptr->rhs /= ptr->diag;
|
||||
ptr->diag = ptr - eqns;
|
||||
}
|
||||
|
||||
/* Now make a pass back substituting for solution. */
|
||||
--ptr;
|
||||
for ( ; ptr >= eqns; --ptr) {
|
||||
if ((int)ptr->diag != ptr - eqns) {
|
||||
/* This row and one above have been exchanged in a pivot. */
|
||||
--ptr;
|
||||
ptr->rhs -= ptr->upper * (ptr+2)->rhs;
|
||||
}
|
||||
else
|
||||
ptr->rhs -= ptr->upper * (ptr+1)->rhs;
|
||||
}
|
||||
if (flag) { /* Undo reordering done by pivoting. */
|
||||
qsort(eqns, nknots, sizeof(struct bandm), fcompare);
|
||||
}
|
||||
}
|
||||
|
||||
/* fcompare -- Compare two floating point numbers. */
|
||||
fcompare(arg1, arg2)
|
||||
real *arg1, *arg2;
|
||||
{
|
||||
if (arg1 > arg2)
|
||||
return(1);
|
||||
else if (arg1 < arg2)
|
||||
return(-1);
|
||||
else
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* interpolate -- Do spline interpolation. */
|
||||
interpolate()
|
||||
{ int i;
|
||||
struct pair *dp;
|
||||
struct bandm *ep;
|
||||
real h, xi, yi, hi, xu, xl, limit;
|
||||
|
||||
h = (xmax - xmin)/nint;
|
||||
ep = eqns;
|
||||
dp = data + 1;
|
||||
for (xi = xmin; xi < xmax + 0.25*h; xi += h) {
|
||||
while (dp->x < xi && dp < data + nknots - 1) {
|
||||
++dp; /* Skip to correct interval. */
|
||||
++ep;
|
||||
}
|
||||
if (dp < data + nknots - 1 && dp->x < xmax)
|
||||
limit = dp->x;
|
||||
else
|
||||
limit = xmax;
|
||||
for ( ; xi < limit - 0.25*h; xi += h) {
|
||||
/* Do interpolation. */
|
||||
hi = dp->x - (dp-1)->x;
|
||||
xu = dp->x - xi;
|
||||
xl = xi - (dp-1)->x;
|
||||
yi = ((ep+1)->rhs*xl*xl/(6.*hi) + dp->y/hi - (ep+1)->rhs*hi/6.)*xl +
|
||||
(ep->rhs*xu*xu/(6.*hi) + (dp-1)->y/hi - ep->rhs*hi/6.)*xu;
|
||||
printf(OFMT, xi, yi);
|
||||
}
|
||||
if (limit != dp->x) { /* Interpolate. */
|
||||
hi = dp->x - (dp-1)->x;
|
||||
xu = dp->x - xmax;
|
||||
xl = xmax - (dp-1)->x;
|
||||
yi = ((ep+1)->rhs*xl*xl/(6.*hi) + dp->y/hi - (ep+1)->rhs*hi/6.)*xl +
|
||||
(ep->rhs*xu*xu/(6.*hi) + (dp-1)->y/hi - ep->rhs*hi/6.)*xu;
|
||||
printf(OFMT, xmax, yi);
|
||||
}
|
||||
else { /* Print knot. */
|
||||
printf(OFMT, dp->x, dp->y);
|
||||
xi = dp->x;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user