Scilab08 PDF

Data Fitting and Interpolation with
SCILAB
By
Gilberto E. Urroz, Ph.D., P.E.
Distributed by
i nfoClearinghouse.com
©2001 Gilberto E. Urroz

All Rights Reserved
A "zip" file containing all of the programs in this document (and other
SCILAB documents at InfoClearinghouse.com) can be downloaded at the
following site:
http://www.engineering.usu.edu/cee/faculty/gurro/Software_Calculators/Scil
ab_Docs/ScilabBookFunctions.zip
The author's SCILAB web page can be accessed at:
http://www.engineering.usu.edu/cee/faculty/gurro/Scilab.html
Please report any errors in this document to: gurro@cc.usu.edu

DATA FITTING AND INTERPOLATION 2
Simple linear interpolation 2
Polynomials in SCILAB 4
Defining a polynomial variable 4
Identifying the polynomial variable, degree, and coefficients 4
Some operations with polynomials 5
Polynomial division 5
Polynomial long division 6
Polynomial fractions 7
Matrices with polynomial elements 8
Determinant of a polynomial matrix 8
Inverse of a polynomial matrix 8
Evaluating a polynomial or polynomial matrix 9
Characteristic matrix and characteristic equations 10
Polynomial functions applied to polynomial matrices 10
Derivatives of polynomials 11
Generating a polynomial given its coefficients 12
Generating a polynomial given its roots 13
Obtaining the roots of a polynomial 13
Indefinite integrals for polynomials 14
Numerical Methods with Polynomials 15

Polynomial deflation 15
Direct fitting of a polynomial 16
Lagrange polynomials 17
SCILAB function mtlb_diff 20
Difference Tables 22
A function to produce a forward-difference table 25
Newton Forward-Difference Polynomial 26
Newton Backward-Difference Polynomial 28
Stirling centered-difference polynomial 29
Bessel centered-difference polynomial 32
Least Squares Polynomial Approximation 34
Linear Data Fitting 36
Other Linearized Data Fittings 37
Interpolation with splines 39
Cubic splines 39
SCILAB functions for cubic splines 40
The function smooth 42
Obtaining the spline polynomials 44
Multi-variate data fitting 49

Successive univariate polynomial interpolation 49
Direct multivariate polynomial fitting 52
Least-square multivariate polynomial fitting 54
Bivariate quadratic fitting 56
SCILAB function datafit 58
Exercises 65
Download at InfoClearinghouse.com 1 © 2001 Gilberto E. Urroz

Data fitting and interpolation
In this chapter we present SCILAB polynomials and their applications, as well as presenting a
number of numerical methods for fitting data to polynomial and other non-linear functions.
Simple linear interpolation

Simple linear interpolation is typically applied to a table of values { (x1,y1), (x2,y2), …, (xn,yn) }
in order to obtain the value yk corresponding to a value xk located within the range of values of
x. It is assumed that the values of x are shown in increasing order in the table. Suppose that
the value of xk is such that xi < xk < xi+1 for a certain value of i. The situation is illustrated in
the table below:
x y
x1 y2
: :
xi yi
xk yk
xi+1 yi+2
: :
xn xn
Assuming a linear variation for y as function of x in the range [xi, xi+1] we can write the
following relationship involving values (xi,yi), (xk,yk), and (xi+1,yi+1):
y k − y i y i +1 − y i
= ,
x k − xi xi +1 − xi
from which,
y i +1 − y i
y k = yi + ⋅ ( x k − xi ).
xi +1 − xi
SCILAB provides function interpln to obtain linear interpolations out of a matrix of two rows
representing pairs of data values (xi,yi). The general call to this function is
[y]=interpln(xy_table,x)
where xy_table is a two-row matrix with the first row representing values of x and the second
row representing values of y from the table, and x is a vector of values. The function returns a
vector of values y corresponding to the linear interpolation of the table for the values in vector
x.

An example of application for function interpln follows. First, we define the table of values
for interpolation:
-->TableXY = [[1,2,3,4,5,6];[2,5,6,8,10,11]]
TableXY =
! 1. 2. 3. 4. 5. 6. !
! 2. 5. 6. 8. 10. 11. !
The following call to function interpln is used to obtain the value of y for x = 2.5:
-->interpln(TableXY,2.5)
ans =
5.5
Next, we use function interpln to interpolate a vector of values:
-->xx = [1.5, 2.5, 3.5, 4.5, 5.5]

xx =
! 1.5 2.5 3.5 4.5 5.5 !
-->yy = interpln(TableXY,xx)
yy =
! 3.5 5.5 7. 9. 10.5 !
To produce a plot of the data from the table and the interpolated data we use the following
SCILAB commands:
-->ymax1 = max(TableXY(2,:)) //Max & min values of y

ymax1 =
11.
-->ymax2 = max(yy)
ymax2 =
10.5
-->rect = [0,0,6,11]; // define the plot rectangle
-->plot2d(TableXY(1,:),TableXY(2,:),9,’011’,’y’,rect) //Plot table
-->xset('mark',-9,1)
-->plot2d(xx,yy,-9,'010','y',rect) //Plot interpolated data
-->xtitle('linear interpolation','x','y') //Place title

Polynomials in SCILAB
As indicated in previous chapters, SCILAB recognizes polynomials as a particular data type and
provides the function poly with the purpose of defining such data types. The simplest
polynomial that can be defined is a variable name, say, x, y, z, etc. By defining a variable
name as a polynomial type, simple algebraic manipulations, resulting in polynomial forms, can
be accomplished.
Defining a polynomial variable

In the following example, the variable s is defined as a polynomial and used in some simple
operations:
-->s=poly(0,'s') //Defining variable s as a polynomial

s =
-->s+2 //Simple algebraic operation

ans =
2 + s
-->y = (s+2)^2 //Defining a new polynomial (y)

y =
2
4 + 4s + s
Identifying the polynomial variable, degree, and coefficients

SCILAB function varn can be used to identify the variable in a polynomial, for example:
-->varn(y)

ans =
s
SCILAB function degree is used to determine the degree of a polynomial, for example:
-->degree(y)
ans =
2.
Function coeff can be used to obtain a vector with the coefficients of the polynomial listed in
increasing order of powers of the polynomial variable. For example,
-->x=poly(0,'x') //Define polynomial variable

x =
x
-->p = 3.5*x^2+2*x-5 //Create a polynomial

p =
2
- 5 + 2x + 3.5x
-->c = coeff(p) //Determine the coefficients of the polynomial

c = ! - 5. 2. 3.5 !
Some operations with polynomials

The next command defines a polynomial q in terms of polynomial variable s:
-->p = (s+1)^2
p =
2
1 + 2s + s
Polynomials in the same variable can be added:
-->p+y
ans =
2
5 + 6s + 2s
The next statement defines a polynomial q out of a multiplication of monomial expressions:
-->q = (s+1)*(s+3)
q =
2
3 + 4s + s
Polynomial division
The following example uses polynomial division resulting in the simplification of the result:
-->p/(s+1)
ans =
1 + s

-----
1
Function pdiv can be used to obtain the quotient and residual of a polynomial division, for
example:
-->[res,quo] = pdiv(p,q)
quo = 1
res = - 2 - 2s
The quotient quo and the residual res are such that p/q = quo + res/q. For the case under
consideration, in which p = s2+2s+1 and q = s2+4s +3, we can write:
s 2 + 2s + 1 − 2s − 2
= 1+ 2 .
s + 4s + 3
2
s + 4s + 3
Polynomial long division

A polynomial division, such as the one just performed, stops whenever the degree of the
residual is smaller than that of the divisor. (For the example shown above, the degree of the
residual is 1 while that of the divisor is 2.) Through the operation of long division we can
continue generating terms for the division allowing for negative powers of the polynomial
variable. SCILAB provides function ldiv to perform the polynomial long division. Since, in
general, one can obtain an infinite number of negative powers of the polynomial variable while
performing the long division, function ldiv requires that the user provides the number of
coefficients to be generated. For example, consider the following polynomial long division in
which 7 coefficients are generated:
-->ldiv(s^3+5,s+1,7)
ans =
! 1. !
! - 1. !
! 1. !
! 4. !
! - 4. !
! 4. !
! - 4. !
This result is to be interpreted in the following manner:
s3 + 5 4 4 4 4
= s2 − s +1+ − 2 + 3 − 4 +L
s +1 s s s s
Thus, the degree of the polynomial variable, s, in the first term of the quotient is equal to the
difference between the degree of the numerator and that of the denominator, i.e., 3-1 = 2.
The degree of subsequent terms decreases by one. [Note: An expression, such as the one
shown above, would be referred to as a Laurent series if the variable s represents the complex
variable x+iy, where i is the unit imaginary number.]
The following example uses the polynomials p and q defined earlier:
-->ldiv(p,q,5)
ans =

! 1. !
! - 2. !
! 6. !
! - 18. !
! 54. !
Since both p and q have the same degree (2), the first term in the expression resulting from
the long division of p by q is multiplied by s0 = 1. Subsequent terms will have increasing
negative powers of s:
s 2 + 2s + 1 2 6 18 54
= 1 − + 2 − 3 + 4 + L.
s + 4s + 3
2
s s s s
Polynomial fractions
SCILAB allows the construction of polynomial fractions, i.e., one in which both the numerator
and denominator are polynomials. For example, a SCILAB polynomial fraction is:
-->t = (s+1)*(s+2)/((s-2)*(s+3))
t =
2
2 + 3s + s
----------
2
- 6 + s + s
Functions numer and denom are used to extract the numerator and denominator of a
polynomial fraction, e.g.,
-->numer(t)
ans =
2
2 + 3s + s
-->denom(t)
ans =
2
- 6 + s + s
The function simp is used to simplify the ratio of two polynomials. For the following call to
function simp we seek two polynomials p1 and q1 so that p1/q1 = p/q, and p1 and q1 have no
common factors:
-->[p1,q1] = simp(p,q)
q1 =
3 + s
p1 =
1 + s

Matrices with polynomial elements
Polynomials can also be used as elements of a matrix, for example:
-->A = [ s+1 s-2; (s+1)^2 s^2/2]

A =
! 1 + s - 2 + s !
! !
! 2 2 !
! 1 + 2s + s .5s !
Determinant of a polynomial matrix
The determinant of matrix A can be calculated using either of functions determ, det, or detr:
-->determ(A)
ans =
2 3
2 + 3s + .5s - .5s
-->det(A)
ans =
2 3
2 + 3s + .5s - .5s
-->detr(A)
ans =
2 3
2 + 3s + .5s - .5s
Inverse of a polynomial matrix
The function inv can be used to obtain the inverse of a polynomial matrix:
-->inv(A)
ans =
! 2 !
! .5s 2 - s !
! -------------------- ------------------- !
! 2 3 2 3 !
! 2 + 3s + .5s - .5s 2 + 3s + .5s - .5s !
! !
! 2 + 2s - 2 !
! ---------- --------- !
! 2 2 !
! - 4 - 2s + s - 4 - 2s + s !
To check that the properties of inverses hold for polynomial matrices too use:
-->inv(A)*A

ans =
! 1 0 !
! - - !
! 1 1 !
! !
! 5.773E-15 + 6.217E-15s 1 !
! ---------------------- - !
! 2 !
! - 4 - 2s + s 1 !
The result is not exactly an identity matrix due to some small numerical error. The
coefficients shown in the term belonging to the second row and first column, however, are
negligible small. To eliminate such small coefficients we can use SCILAB function clean:
-->clean(ans)
ans =
! 1 0 !
! - - !
! 1 1 !
! !
! 0 1 !
! - - !
! 1 1 !
The result verifies that the matrix is indeed an identity matrix.
The inverse of a polynomial matrix can be written as A-1 = Ns/d, where Ns is a square matrix
and d is a polynomial. The matrix Ns and the polynomial d are returned as separate factors by
function coffg, for example:
-->[Ns,d] = coffg(A)
d =
2 3
2 + 3s + .5s - .5s
Ns =
! 2 !
! .5s 2 - s !
! !
! 2 !
! - 1 - 2s - s 1 + s !
Evaluating a polynomial or polynomial matrix

To evaluate a polynomial or polynomial matrix, say p(x), at a particular value of x use the
function horner, for example:
-->horner(p,2)
ans =
9.
-->horner(A,3)
ans =

! 4. 1. !
! 16. 4.5 !
Characteristic matrix and characteristic equations

Polynomial matrices can be used, for example, to write the characteristic matrix and the
characteristic equation of a square matrix (see chapter 5). To illustrate this applications, we
create a square random matrix B:
-->B = int(10*rand(3,3))
B =
! 2. 3. 8. !
! 7. 6. 6. !
! 0. 6. 8. !
The characteristic matrix is calculated as B-s⋅I3×3:
-->B-s*eye(3,3)
ans =
! 2 - s 3 8 !
! !
! 7 6 - s 6 !
! !
! 0 6 8 - s !
The determinant of the characteristic matrix is the characteristic polynomial of the matrix B:
-->det(B-s*eye(3,3))
ans =
2 3
192 - 19s + 16s - s
Polynomial functions applied to polynomial matrices

Many of the functions whose application was illustrated above for single polynomials apply as
well to matrices of polynomial elements as illustrated with the following examples:
-->M = [(2-s)/(s^2+s) s^2; 1/(s+1) (s+1)/(s+2)]

M =
! 2 !
! 2 - s s !
! ----- - !
! 2 !
! s + s 1 !
! !
! 1 1 + s !
! ----- ----- !
! 1 + s 2 + s !
-->denom(M)

ans =
! 2 !
! s + s 1 !
! !
! 1 + s 2 + s !
-->numer(M)
ans =
! 2 !
! 2 - s s !
! !
! 1 1 + s !
This introduction to polynomials in SCILAB is by no means a comprehensive one. Polynomials

and polynomial matrices are commonly used in signal processing and control system analysis.
The reader is invited to check extensive applications of polynomials and polynomial matrices in
the document Signals.pdf, available in the documentation section of SCILAB’s web page:
http://www-rocq.inria.fr/scilab/doc.html
Derivatives of polynomials
While SCILAB is basically a numerical environment, it allows a few symbolic operations using
polynomials. One of such functions is the function derivat which is used to calculate the
derivative of polynomials or rational expressions. In the next applications we define a
polynomial variable x and apply function derivat to it and to polynomial and rational
expressions involving variable x.
First, define the polynomial variable x:
-->x=poly(0,'x')
x =
Next, we obtain the derivatives of functions y = x, y = x2, y = 1/x, and y = 2x3-2x:
-->derivat(x)
ans =
-->derivat(x^2)
ans =
2x
-->derivat(1/x)
ans =
- 1
-
2
x

-->derivat(2*x^3-2*x)
ans =
2
- 2 + 6x
An attempt to obtain the derivative of function y = sin(x) fails since function derivat applies
only to polynomials and rational expressions:
-->derivat(sin(x))
!--error 4
undefined variable : %p_sin
A rational expression is simply a fraction or combination of fractions involving polynomials.

The following is an application of function derivat to a rational expression:
-->derivat((2*x^2-5*x)/(x^3-x^2+2))
ans =
2 3 4
- 10 + 8x - 5x + 10x - 2x
-----------------------
2 3 4 5 6
4 - 4x + 4x + x - 2x + x
Generating a polynomial given its coefficients

We define the polynomial of order n as
Pn(x) = ao + a1x + a2x2 + …+ an-1x n-1

+ anxn
Using SCILAB we can obtain a polynomial expression by using the function poly. The general
form of the function is:
[p]=poly(a,"x", ["flag"])
where a is a vector, matrix or real number, x is a symbolic variable; and, "flag" is a string
(either "roots", "coeff" -- the default value is "roots") that determines whether the values in a
represent the roots of the polynomial or its coefficients. If a is a vector representing the
coefficients of the polynomial, the vector should be defined or entered as [ao a1 a2 … an-1 an].
(Note: If a is a matrix, p is the characteristic polynomial for the eigenvalues of the matrix, i.e.,
p = det(xI-a), x being the symbolic variable.)
For example, if you want to obtain the polynomial whose coefficients are given by a = [3. -5.
1.], use the following command:
-->p = poly([3. -5. 1.],"x","coeff")

p =
2
3 - 5x + x
The command above will store the polynomial expression '3-5x+x2' into variable p. You can also
define the vector of coefficients into a variable before calling poly. For example:
-->v = [4. -2. -1. 7.];

-->k = poly(v,"y","coeff")
k =
2 3
4 - 2y - y + 7y
will produce the polynomial '4-2y-y2+7y3 ' and store it into variable k.
Generating a polynomial given its roots

To obtain a polynomial given its roots use the same function poly as above, but replace "coeff"
for "roots" in the last argument of the function. For example, to generate the polynomial
whose roots are [1. 1. -1.], try:
-->q = poly([1. 1. -1.],"z","roots")

q =
2 3
1 - z - z + z
The result is the polynomial '1-z-z2+z3 ' stored into the variable q. Because "roots" is the
default value of the "flag" argument in the definition of poly, we could have use
-->q = poly([1. 1. -1.],"z")
to produce the polynomial.

The vector containing the roots of the polynomial can be stored into a variable and the variable
name used as the first argument in the call of function poly. For example, to obtain the
polynomial whose roots are [2. 3. -1.], we could use:
-->w = [2. 3. -1.];
-->r = poly(w,"n")
r =
2 3
6 + n - 4n + n
The variable r will now contain the polynomial ' 6+n-4n2+n3 '.
Obtaining the roots of a polynomial

To obtain the roots of a polynomial expression use the function roots. Some examples are
shown below, using the polynomials k, p, q, and r defined above :
-->roots(k)
-->roots(p)
-->roots(q)
-->roots(r)
Verify the following results using SCILAB: roots(k) =[ 0.5180404 + .6094027i, 0.5180404 -
.6094027i, - 0.8932236], and roots(p) = [0.6972244, 4.3027756]. The results roots(q) and
roots(r) should be pretty obvious.

Indefinite integrals for polynomials
Indefinite integrals for polynomials can be obtained using the following function intpoly:
function [pInt] = intpoly(p)
//This function calculates the indefinite integral

//of polynomial p
c = coeff(p);
n = length(c)-1;
d = [1];
for j=1:n+1
d = [d j];
end;
cc = [0 c];
cc = cc./d;
disp('Indefinite integral - Add integration constant');

printf(' \n');
pInt = poly(cc,varn(p),'coeff');
//end function intpoly
Some examples follow:
-->getf('intpoly')
-->p1 = poly([5 0 -2 3 1 0 2],'s','coeff')

p1 =
2 3 4 6
5 - 2s + 3s + s + 2s
-->intpoly(p1)
Indefinite integral - Add integration constant
ans =
3 4 5 7
5s - .6666667s + .75s + .2s + .2857143s
-->p2 = poly([-2 3 -5],'t','roots')

p2 =
2 3
- 30 - 11t + 4t + t
-->intpoly(p2)
Indefinite integral - Add integration constant
ans =
2 3 4
- 30t - 5.5t + 1.3333333t + .25t

Numerical Methods with Polynomials
In this section we present numerical methods used for evaluation of polynomials and of its first
derivative, as well as methods for fitting polynomials to tables of data.
Polynomial deflation
Polynomial deflation refers to the procedure by which a polynomial of degree n-1, say Qn-1(x),
is obtained from a polynomial of degree n, say Pn(x), by dividing out the factor (x-r).
Polynomials Pn(x) and Qn-1(x) and the value r are related by:
Pn(x) = (x-r)⋅Qn-1(x) + R,
Where R is a constant remainder, i.e., Pn(r) = R. If for a particular value of r, say r = r0, Pn(x)
= (x-r)⋅Qn-1(x), (i.e., R = 0) then r0 is a root of Pn(x).
The derivative of Pn(x), in terms of Qn(x) and r is:
P’n(x) = (x-r)⋅Q’n-1(x) + Qn-1(x).
Thus, P’n(r) = Qn-1(r).
The SCILAB commands shown below can be used for polynomial deflation, which in turn allows
us to calculate the first derivative of a polynomial at a given value. For example, using the
polynomial
P5(x) = -120 + 274x - 225x2 + 85x3 - 15x4 + x5,
we can evaluate P5(2.5) and P'5 (2.5), as follows:
-->P5 = poly([-120 274 -225 85 -15 1],'x','coeff') //Define P5(x)

P5 =
2 3 4 5
- 120 + 274x - 225x + 85x - 15x + x
-->R = horner(P5,2.5) //Evaluate P5(2.5)

R =
- 1.40625
-->d5 = x - 2.5 //Prepare factor (x-2.5)

d5 =
- 2.5 + x
-->[R4,Q4] = pdiv(P5,d5) //Deflate polynomial

Q4 =
2 3 4
47.4375 - 90.625x + 53.75x - 12.5x + x
R4 =

- 1.40625
-->P5prime = horner(Q4,2.5) //Evaluate derivative P5’(x) at x = 2.5

P5prime =
.5625
-->P5prime = derivat(P5) //Evaluate derivative P5’(x) with derivat
P5prime =
2 3 4
274 - 450x + 255x - 60x + 5x
-->horner(P5prime,2.5) //Evaluate derivative

ans =
.5625
For x=2, try the following SCILAB commands:
horner(P5,2)
d5=x-2
[R4,Q4]=pdiv(P5,d5)
horner(Q4,2)
Direct fitting of a polynomial

Suppose that we have a set of n+1 data values {(x0,y0), (x1,y1), (x2,y2), …, (xn,yn)} and we want
to fit a polynomial of degree n,
y = Pn(x) = a0 + a1x + a2x2 + … + anxn,
to these data. A direct fitting of the polynomial will involve the solution of the system of n+1
equations resulting from replacing each pair of data values (xi,yi), i = 0, 1, 2, …, n, into the
polynomial, i.e.,
a0 + a1x0 + a2x02 + … + anx0n = y0

a0 + a1x1 + a2x12 + … + anx1n = y1
.
.
.
a0 + a1xn + a2xn2 + … + anxnn = yn
The unknowns in this system are the coefficients of the polynomial a0, a1, …, an.
The following function, dfp, will produce a direct polynomial fitting given the sets of paired
data values (xi,yi), i = 0, 1, 2, …, n:
function [a]=dfp(x,f)
//Performs direct data fitting for a polynomial given

//data sets {(x0,f0), (x1,f1), ..., (xn,fn)}.
//check if x,f are of the same length

[m1,n1]=size(x);
[m2,n2]=size(f);
if((m1 <> m2) | (n1 <> n2)) then
error('x and f are not of the same size');
abort;
end;
m = m1;
n = m - 1; //define order of polynomial
B = ones(m,m); //fill matrix coefficients with 1.0
//Calculate rest of matrix
for i = 1:m
for j = 2:m
B(i,j) = x(i)^(j-1);
end;
end;
a = linsolve(B,-f); //solve for the coefficients
a=a'; //show result as a row vector
//end function dfp
The call to the function is simply dfp(x,f). Values of x and f need to be defined as column
vectors. Try the following example:
-->getf('dfp')
-->x = [3.4 3.5 3.6]; y = [0.294118, 0.285714, 0.277778];
-->a = dfp(x',y')
a =
! .858314 - .2455 .0234 !
To generate the polynomial, use:
-->p = poly(a,'x','coeff')
p =
2
.858314 - .2455x + .0234x
The evaluation of the polynomial for the values of x given above verifies the polynomial fitting:
-->horner(p,x)
ans =
! .294118 .285714 .277778 !
Lagrange polynomials
Lagrange polynomials are used to fit a data set {(x1,y1), (x2,y2), …, (xn,yn)}. A Lagrange
polynomial is expanded from the formula:

n
n ∏ (x − x k )
p n −1 ( x) = ∑
k =1, k ≠ j
n
⋅ yj.
j =1
∏ (x
k =1, k ≠ j
j − xk )
For example, for n = 2, we will write:
x − x2 x − x1 ( y − y 2 ) ⋅ x + ( y 2 ⋅ x1 − y1 ⋅ x 2 )
p1 ( x) = ⋅ y1 + ⋅ y2 = 1 .
x1 − x 2 x 2 − x1 x1 − x 2
The following function, LagPol, will evaluate the Lagrange polynomial of order n at x = x0,
using the data in column vectors x and f.
function [y]=lagpol(x0,x,f,n)
//Evaluates the Lagrange polynomial corresponding

//to the data set {(x1,f1), (x2,f2), ..., (xn,fn)}
//at point x = x0.
//check if x,f are of the same length

[m1,n1]=size(x);
[m2,n2]=size(f);
if((m1 <> m2) | (n1 <> n2)) then
error('x and f are not of the same size');
abort;
end;
m = n1;
if(n>m-1)then
disp(n,"polynomial degree =")
disp(m,"vector size=")
error('use smaller polynomial degree n');
abort
end;
m = n + 1;
N = ones(1,m);
D = N;
C = N;
y = 0.0;
for j = 1:m
for k = 1:m
if(k <> j) then
N(j) = N(j)*(x0-x(k));
D(j) = D(j)*(x(j)-x(k));
end;
end;
C(j) = N(j)/D(j);
y = y + C(j)*f(j);
end;
//end LagPol function
As an example, try the following SCILAB statements:
-->getf('lagpol')
-->x = [3.4 3.5 3.55 3.65]; y = [0.294118,0.285714,0.281690,0.273973];

-->lagpol(3.44,x,y,1)
ans =
.2907564
-->lagpol(3.44,x,y,2)
ans =
.2906994
-->lagpol(3.44,x,y,3)
ans =
.2906977
-->lagpol(3.44,x,y,4)
polynomial degree =
4.
vector size=
4.
!--error 9999
use smaller polynomial degree n
at line 18 of function lagpol called by :
lagpol(3.44,x,y,4)
The following example demonstrate the use of Lagrange polynomials of orders n = 1, 2, 3, 4, 5,

and 6 to the following data set.
x 0.0 1.2 3.5 4.2 6.2 8.1 11.2

y 15.0 29.0 13.3 -6.4 2.9 17.1 -8.0
The SCILAB commands that follow load the original data and produce Lagrange polynomials for
orders n = 1 to 6. A plot showing the different polynomials and the original data is also
produced.
-->getf('lagpol')
-->x = [0.0,1.2,3.5,4.2,6.2,8.1,11.2]; //Original x data
-->y = [15.0,29.0,13.3,-6.4,2.9,17.1,-8.0]; //Original y data
-->xx = [0.0:0.1:12.0]; //x data for fitting
-->yy1 = []; yy2 = []; yy3 =[]; yy4 = []; yy5 = []; yy6 =[];
-->for j = 1:n //Lagrange polynomial fittings

--> yy1 = [yy1 lagpol(xx(j),x,y,1)];
-->end;
The plot is produced with the following statements:
-->plot2d([xx',xx',xx',xx',xx',xx'],[yy1',yy2',yy3',yy4',yy5',yy6'],...
-->[1:1:6],'111','n=1@n=2@n=3@n=4@n=5@n=6',[0 -50 12 50])
-->plot2d(x,y,-9,'011','y',[0 -50 12 50])

-->xtitle('Lagrange polynomials', 'x', 'y')
SCILAB function mtlb_diff

SCILAB provides function mtlb_diff which we will use to generate tables of differences in
subsequent sections. This function can be used, for example, to calculate the differences
between consecutive elements in a vector. The following application uses a vector u with 7
elements:
-->u = [0, 1, 3, 6, 11, 15, 23]

u =
! 0. 1. 3. 6. 11. 15. 23. !
function mtlb_diff produces a vector of 6 elements representing the differences between

consecutive elements of the original vector:
-->Du = mtlb_diff(u)
Du = ! 1. 2. 3. 5. 4. 8. !
Consecutive applications of the function mtlb_diff produce vectors of differences with one less
element than the previous vector:
-->D2u = mtlb_diff(Du)
D2u = ! 1. 1. 2. - 1. 4. !
-->D3u = mtlb_diff(D2u)
D3u = ! 0. 1. - 3. 5. !
D4u = ! 1. - 4. 8. !
D5u = ! - 5. 12. !

D6u = 17.
The following example shows the application of function mtlb_diff to a column vector v of six
elements, and consecutive applications to the resulting vector until a single value is obtained:
-->v = [1;3;5;9;12;23]
v =
! 1. !
! 3. !
! 5. !
! 9. !
! 12. !
! 23. !
-->Dv = mtlb_diff(v)
Dv =
! 2. !
! 2. !
! 4. !
! 3. !
! 11. !
-->D2v = mtlb_diff(Dv)
D2v =
! 0. !
! 2. !
! - 1. !
! 8. !
-->D3v = mtlb_diff(D2v)
D3v =
! 2. !
! - 3. !
! 9. !
D4v =
! - 5. !
! 12. !
D5v =
17.
The following example shows the application of function mtlb_diff to a 5 4 matrix. The result
of mtlb_diff, when applied to matrices, is another matrix containing the differences between
consecutive rows of the original matrix:
-->A = int(10*rand(5,4))
A =
! 2. 9. 5. 4. !
! 2. 2. 4. 2. !
! 8. 3. 3. 6. !
! 6. 3. 5. 4. !
! 3. 2. 5. 9. !
-->DA = mtlb_diff(A)
DA =
! 0. - 7. - 1. - 2. !
! 6. 1. - 1. 4. !
! - 2. 0. 2. - 2. !

! - 3. - 1. 0. 5. !
Continuous application of function mtlb_diff to the resulting matrix continues until the matrix
is reduced to a row vector:
-->D2A = mtlb_diff(DA)
D2A =
! 6. 8. 0. 6. !
! - 8. - 1. 3. - 6. !
! - 1. - 1. - 2. 7. !
-->D3A = mtlb_diff(D2A)
D3A =
! - 14. - 9. 3. - 12. !
! 7. 0. - 5. 13. !
D4A =
! 21. 9. - 8. 25. !
From this point on, further applications of mtlb_diff will produce row vectors of smaller sizes
until a single value results:
D5A =
! - 12. - 17. 33. !
D6A =
! - 5. 50. !
D7A =
55.
Difference Tables
A difference table corresponding to a data set {(x0,y0), (x1,y1), (x2,y2), …, (xn,yn)} is illustrated
below:
x y ∆y ∆2 y ∆3 y ∆4 y
x0 y0
∆y0 = y1-y0
x1 y1 ∆2y0 = ∆y1-∆y0
∆y1 = y2-y1 ∆3y0 = ∆2y1-∆2y0

x2 y2 ∆2y1 = ∆y2-∆y1 ∆4y0 = ∆3y1-∆3y0
∆y2 = y2-y1 ∆3y1 = ∆2y2-∆2y1
x3 y3 ∆2y2 = ∆y2-∆y1
∆y3 = y3-y2
x4 y4
This table corresponds to what is referred to as forward differences. The first two columns
are simply the data values. The third column is the difference of values of y, the fourth
column is the difference of values of the third column, and so forth. The table illustrated
above starts with five points and is able to calculate differences up to the fourth order.
Consider, for example, the following table of forward differences corresponding to the function
y = exp(x) in the range [2,3] with x increments of 0.1:
x y ∆y ∆2 y ∆3 y ∆4 y ∆5 y ∆6 y ∆7 y
2.00 7.389056
0.777114
2.10 8.16617 0.08173
0.858844 0.008596
2.20 9.025013 0.090325 0.000904
0.949169 0.0095 9.51E-05
2.30 9.974182 0.099825 0.000999 1E-05
1.048994 0.010499 0.000105 1.05E-06
2.40 11.02318 0.110324 0.001104 1.11E-05
1.159318 0.011603 0.000116 1.16E-06
2.50 12.18249 0.121926 0.00122 1.22E-05
1.281244 0.012823 0.000128 1.28E-06
2.60 13.46374 0.13475 0.001349 1.35E-05
1.415994 0.014172 0.000142 1.42E-06
2.70 14.87973 0.148921 0.00149 1.49E-05
1.564915 0.015662 0.000157
2.80 16.44465 0.164584 0.001647
1.729499 0.017309
2.90 18.17415 0.181893
1.911392
3.00 20.08554
The following SCILAB commands will generate the columns of the table of differences shown
above:
-->x=[3.0:0.1:4.0]'; y = exp(x);
-->Dy = mtlb_diff(y)
Dy =
! 2.1124144 !
! 2.3345789 !
! 2.5801087 !
! 2.8514611 !
! 3.1513519 !
! 3.4827825 !
! 3.8490699 !
! 4.2538801 !
! 4.7012646 !
! 5.1957009 !

-->x=[2.0:0.1:3.0]'; y = exp(x);
-->Dy = mtlb_diff(y)
Dy =
! .7771138 !
! .8588436 !
! .9491690 !
! 1.0489939 !
! 1.1593176 !
! 1.2812441 !
! 1.4159937 !
! 1.564915 !
! 1.7294986 !
! 1.9113916 !
-->D2y = mtlb_diff(Dy)
D2y =
! .0817298 !
! .0903254 !
! .0998250 !
! .1103237 !
! .1219265 !
! .1347496 !
! .1489214 !
! .1645836 !
! .1818930 !
-->D3y = mtlb_diff(D2y)
D3y =
! .0085956 !
! .0094996 !
! .0104987 !
! .0116028 !
! .0128231 !
! .0141717 !
! .0156622 !
! .0173094 !
D4y =
! .0009040 !
! .0009991 !
! .0011042 !
! .0012203 !
! .0013486 !
! .0014905 !
! .0016472 !
D5y =
! .0000951 !
! .0001051 !
! .0001161 !
! .0001283 !
! .0001418 !
! .0001568 !
-->D6y =mtlb_diff(D5y)
D6y =
! .0000100 !
! .0000111 !
! .0000122 !
! .0000135 !

! .0000149 !
D7y =
! .0000011 !
! .0000012 !
! .0000013 !
! .0000014 !
A function to produce a forward-difference table
The following function, called Difference_Table(f,n), where f is a column vector and n is the
highest order of the difference, is shown below:
function [Df]=Difference_Table(f,n)
//This function calculates a difference table starting with
//a column vector f
[m,nc]=size(f)
//check that it is indeed a column vector
if(nc<>1)then
error('f is not a column vector.');
abort
end;
//check the difference order
if(n > m)then
disp(n,"n=");
disp(m,"m=");
error('n must be less than or equal to m');
abort
end;
//
Df=zeros(m,n);
for i = 1:m
Df(i,1) = f(i,1);
end;
delf = f;
for j = 2:n
delf = mtlb_diff(delf)
[m,nc]=size(delf);
for i = 1:m
Df(i,j) = delf(i,1);
end;
end;
//end of function Difference_Table
The following SCILAB commands will generate a difference table for the values of y defined
previously. The resulting matrix contains the same information than the table of differences
shown earlier, except for the location of entries. However, the interpretation of the entries is
straightforward. The first column in the matrix is the vector y, the second is the first
difference, the third column is the second difference, and so on. Furthermore, the top row in
the table of differences contains the values y0, ∆y0, ∆2y0, and so on:
-->Difference_Table(y,5)
ans =
! 7.3890561 .7771138 .0817298 .0085956 .0009040 !

! 8.1661699 .8588436 .0903254 .0094996 .0009991 !
! 9.0250135 .9491690 .0998250 .0104987 .0011042 !
! 9.9741825 1.0489939 .1103237 .0116028 .0012203 !

! 11.023176 1.1593176 .1219265 .0128231 .0013486 !
! 12.182494 1.2812441 .1347496 .0141717 .0014905 !
! 13.463738 1.4159937 .1489214 .0156622 .0016472 !
! 14.879732 1.564915 .1645836 .0173094 0. !
! 16.444647 1.7294986 .1818930 0. 0. !
! 18.174145 1.9113916 0. 0. 0. !
! 20.085537 0. 0. 0. 0. !
Newton Forward-Difference Polynomial

A Newton forward-difference polynomial uses a table of forward differences to approximate
the function of interest, y = f(x), to a polynomial on the variable
s = (x-x0)/∆x,
where x is a particular value of the independent variable where the polynomial is evaluated, x0
is the first value of x in the table of differences, and ∆x is the increment in the independent
variable. The expression for the Newton forward-difference polynomial is
s s s

f ( x) ≈ Pn ( x) = y 0 +   ⋅ ∆y 0 +   ⋅ ∆2 y 0 +   ⋅ ∆3 y 0 + L ,
1  2  3
where the terms
n n!
  = ,
 r  r!(n − r )!
are binomial coefficients.
The following function calculates the Newton forward-difference polynomial of order n,

evaluated at x. The polynomial needs as input a column vector representing values of x (we
call the vector xL), and a second column vector representing the values of f. The first value of
xL represents xo. The function is called NFDP. Notice that in the listing of this function we
also include the listing of functions factorial and binomial, used to calculate, respectively,
factorials and binomial coefficients:
function [P]=NFDP(x,n,xL,f)
//This function calculates a Newton Forward-Difference Polynomial of
//order n, evaluated at x, using column vectors xL, f as the reference
//table. The first value of xL and of f, represent, respectively,
//xo and fo in the equation for the polynomial.
[m,nc]=size(f)
if(nc<>1)then
abort
end;
if(n >= m)then
disp(n,"n=");
disp(m,"m=");
error('n must be less than or equal to m-1');
abort
end;

//
xo = xL(1,1);
delx = mtlb_diff(xL);
h = delx(1,1);
s = (x-xo)/h;
P = f(1,1);
delf = f;
for i = 1:n
P = P + Binomial(s,i)*delf(1,1)
end;
//end of function NFDP
function[C]=Binomial(s,i)
C = 1.0;
for k = 0:i-1
C = C*(s-k);
end;
C = C/factorial(i)
//end of function Binomial
function[fact]=factorial(nn)
fact = 1.0
for k = nn:-1:1
fact=fact*k
end;
//end of function factorial
The following SCILAB commands will generate the third-order Newton forward-difference
polynomial evaluated at x = 3.44, for the function f(x) = 1/x, with xL a column vector with
values of x: 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0:
-->getf('NFDP.txt')
-->x = [3.4:0.1:4.0]; y = 1./x; //Note: y is a column vector
-->y
y =
! .0353761 !
! .0364166 !
! .0374571 !
! .0384976 !
! .0395380 !
! .0405785 !
-->NFDP(3.44,3,x',y)
ans =
.0357923
With the same values of x and f, the following command will show the Newton forward-
difference polynomial of degrees 0, 1, 2 and 3:
-->for n=0:3, NFDP(3.44,n,x',y), end

ans = .0353761
ans = .0357923
ans = .0357923
ans = .0357923

Newton Backward-Difference Polynomial
A backward-difference table is illustrated below. The reference value is the last value (x0,y0),
thus the table starts with a negative sub-index which increases in value until reaching the value
of zero at the bottom of the table. Backward differences are represented through the use of
the del or nabla operator ∇, i.e., ∇y for the first difference, ∇2y for the second, and so on.
x y ∇y ∇2y ∇3y ∇4y

x-4 y-4
∇y-3 = y-3-y-4
x-3 y-3 ∇2y-2 = ∆y-2-∆y-3
∇y-2 = y-2-y-3 ∇3y-1 = ∆2y-1-∆2y-2
x-2 y-2 ∇2y-1 = ∆y-1-∆y-2 ∇4y0 = ∆3y0-∆3y-1
∇y-1 = y-1-y-2 ∇3y0 = ∆2y0-∆2y-1
x-1 y-1 ∇2y0 = ∆y0-∆y-1
∇y0 = y0-y-1
x0 y0
A Sterling centered-difference polynomial uses a table of centered differences to approximate

the function of interest, y = f(x), to a polynomial on the variable
s = (x-x0)/∆x,
is the last value of x in the table of differences, and ∆x is the increment in the independent
variable. The expression for the Newton backward-difference polynomial is
s  s + 1 2  s + 2 3
f ( x) ≈ Pn ( x) = y 0 +   ⋅ ∇y 0 +   ⋅ ∇ y 0 +   ⋅ ∇ y 0 + L.
1  2   3 
The following function calculates the Newton backward-difference polynomial of order n,
call the vector xL), and a second column vector representing the values of f. The last value of
xL represents xo. The function is called NBDP and is stored in file NBDP.txt:
function [P]=NBDP(x,n,xL,f)
//This function calculates a Newton Backward-Difference Polynomial of
//table. The first value of xL and of f, represent, respectively,
//xo and fo in the equation for the polynomial.
[m,nc]=size(f)
if(nc<>1)then
abort
end;
if(n >= m)then
disp(n,"n=");
disp(m,"m=");
error('n must be less than or equal to m-1');

abort
end;
//
xo = xL(m,1);
h = delx(1,1);
s = (x-xo)/h;
P = f(m,1);
delf = f;
for i = 1:n
delf = mtlb_diff(delf);
[m,nc] = size(delf);
P = P + Binomial(s+i-1,i)*delf(m,1)
end;
//end of function NBDP
C = 1.0;
for k = 0:i-1
C = C*(s-k);
end;
C = C/factorial(i)
fact = 1.0
for k = nn:-1:1
fact=fact*k
end;
The following SCILAB commands will generate the third-order Newton backward-difference
polynomial evaluated at x = 3.44, for the function f(x) = 1/x, with xL a column vector with
values of x: 3.0, 3.1, 3.2, 3.3, 3.4, 3.5:
-->getf('NBDP.txt')
-->x = [3.0:0.1:3.5]'; y = x^(-1); //both x & y are column vectors
-->NBDP(3.44,3,x,y)
ans =
.2906979
With the same values of x and f, the following command will show the Newton forward-
difference polynomial of degrees 0, 1, 2 and 3:
-->for n=0:3, NBDP(3.44,n,x,y), end

ans = .2857143
ans = .2907563
ans = .2906952
ans = .2906979
Stirling centered-difference polynomial

A centered-difference table is illustrated below. The reference value is the middle value
(x0,y0), thus the table should contain an odd number of data points. Centered differences are
represented through the use of the δ symbol, i.e., δy for the first difference, δ2y for the
second, and so on.

x y δy δ2 y δ3y δ4y
x-2 y-2
δy-3/2 = y-1-y-2
x-1 y-1 δ2y-1 = δy-1/2-δy-3/2
δy-1/2 = y0-y-1 δ3y-1/2 = δ2y0-δ2y-1
x0 y0 δ2y0 = δy1/2-δy-1/2 δ4y0 = δ3y1/2-δ3y-1/2
δy1/2 = y1-y0 δ3y1/2 = δ2y1-δ2y0
x1 y1 δ2y1 = δy3/2-δy1/2
δy3/2 = y2-y1
x2 y2
A Stirling centered-difference polynomial uses a table of centered differences with an odd

number of data points to approximate the function of interest, y = f(x), to a polynomial on the
variable
s = (x-x0)/∆x,
is the middle value of x in the table of differences, and ∆x is the increment in the independent
variable. The expression for the Sterling centered-difference polynomial is
s 1 1   s + 1  s   2
f ( x) ≈ Pn ( x) = y 0 +   ⋅ (δy1 / 2 + δy −1 / 2 ) +    +    ⋅ δ y0
1 2 2   2   2  
 s + 1 1 3 1   s + 2   s + 1  4
+  ( )
 ⋅ δ y1 / 2 + δ 3 y −1 / 2 +   +
2   4   4  
 δ y o + L.
 3  2
The following function calculates the Stirling centered-difference polynomial of order n,

call the vector xL), and a second column vector representing the values of f. The length of the
vectors xL and f must be an odd number. The middle value of the vectors xL and f will
represent xo and fo. The function is called stirling and is stored in file stirling.txt:
function [P]=stirling(x,n,xL,f)
//This function calculates a Stirling-Difference Polynomial of
//table. The length of the vectors xL and f must be an odd number,
//with xo, fo being the middle value in the corresponding lists.
[m,nc]=size(f)
if(nc<>1)then
abort
end;
//check that the size of the lists xL and f is odd
if(modulo(m,2)==0)then
disp(m,"list size =")
error('list size must be an odd number');
abort
end;

if(n > (m-1)/2)then
disp(n,"n=");
disp(m,"m=");
error('n must be less than or equal to (m-1)/2');
abort
end;
//
i0 = floor(m/2)+1
xo = xL(i0,1);
h = delx(1,1);
s = (x-xo)/h;
P = f(i0,1);
delf = f;
for i = 1:n
[m,nc]=size(delf)
j = m/2
k = j+1
P = P + 0.5*Binomial(s+i-1,i)*(delf(j,1)+delf(k,1))
[m,nc]=size(delf)
j = floor(m/2)+1
P = P + 0.5*(Binomial(s+i,2*i)+Binomial(s+i-1,2*i))*delf(j,1)
end;
//end of function stirling
C = 1.0;
for k = 0:i-1
C = C*(s-k);
end;
C = C/factorial(i)
fact = 1.0
for k = nn:-1:1
fact=fact*k
end;
The following SCILAB commands will generate the third, fourth, and, if possible, the fifth-order
Stirling centered-difference polynomial evaluated at x = 3.44, for the function f(x) = 1/x, with
xL a column vector with values of x: 3.0, 3.1, 3.2, 3.3, 3.4, 3.5,3.6,3.7,3.8 (i.e., vector size =
9):
-->getf('stirling.txt')
-->x = [3.0:0.1:3.8]'; y = x^(-1);
-->stirling(3.44, 3, x, y)
ans =
.2906824
-->stirling(3.44, 4, x, y)
ans =
.2906823
-->stirling(3.44, 5, x, y)

n=
5.
m=
9.
!--error 9999
n must be less than or equal to (m-1)/2
at line 22 of function stirling called by :
stirling(3.44, 5, x, y)
With the same values of x and f, the following command will show the Stirling centered-
difference polynomial of degrees 0 through 4:
-->for n = 0:4, stirling(3.44, n, x, y), end

ans = .2941176
ans = .2906952
ans = .2906825
ans = .2906824
ans = .2906823
Bessel centered-difference polynomial

A Bessel centered-difference polynomial uses a table of centered differences with an even
number of data points to approximate the function of interest, y = f(x), to a polynomial on the
variable
s = (x-x0)/∆x,
is a middle value of x in the table of differences, and ∆x is the increment in the independent
variable. Bessel centered differences are based on a point between x0 and x1. The expression
for the Bessel centered-difference polynomial is
1   s   s − 1  s 1
f ( x) ≈ Pn ( x) =
1
( y 0 + y1 ) +    + 
2  1  1  
(
  ⋅ δy1 / 2 +   ⋅ δ 2 y 0 + δ 2 y1 )
2  2 2
1   s + 1  s   3  s + 1 1 4
+    +    ⋅ δ y1 / 2 + 
2   3   3 
( )
 δ y o + δ 4 y1 + L.
 4 2
The following function calculates the Bessel centered-difference polynomial of order n,

call the vector xL), and a second column vector representing the values of f. The length of the
vectors xL and f must be an odd number. The middle value of the vectors xL and f will
represent xo and fo. The function is called stirling and is stored in file stirling.txt:
function [P]=bessel(x,n,xL,f)
//This function calculates a Bessel Centered-Difference Polynomial of

//table. The length of the vectors xL and f must be an even number (m),
//with xo, fo being the value number m/2 in the corresponding lists.
[m,nc]=size(f)
if(nc<>1)then
abort
end;
//check that the size of the lists xL and f is odd
if(modulo(m,2)<>0)then
disp(m,"list size =")
error('list size must be an even number');
abort
end;
if(n > (m-1)/2)then
disp(n,"n=");
disp(m,"m=");
error('n must be less than or equal to (m-1)/2');
abort
end;
//
i0 = floor(m/2)
xo = xL(i0,1);
h = delx(1,1);
s = (x-xo)/h;
P = 0.5*(f(i0,1)+f(i0+1,1));
delf = f;
for i = 1:n
[m,nc]=size(delf)
j = (m+1)/2;
P = P + 0.5*(Binomial(s+i-1,i)+Binomial(s+i-2,i))*delf(j,1)
[m,nc]=size(delf)
j = m/2;
k = j+1
P = P + 0.5*Binomial(s+i-1,2*i)*(delf(j,1)+delf(k,1))
end;
//end of function bessel
C = 1.0;
for k = 0:i-1
C = C*(s-k);
end;
C = C/factorial(i)
fact = 1.0
for k = nn:-1:1
fact=fact*k
end;
The following SCILAB commands will generate the third, fourth, and, if possible, the fifth-order
Bessel centered-difference polynomial evaluated at x = 3.44, for the function f(x) = 1/x, with
xL a column vector with values of x: 3.0, 3.1, 3.2, 3.3, 3.4, 3.5,3.6,3.7,3.8 (i.e., vector size =
9):
-->x = [3.0:0.1:3.9]'; y = x^(-1);

-->getf('bessel.txt')
-->bessel(3.44,3,x,y)
ans = .2906944
-->bessel(3.44,4,x,y)
ans = .2906944
With the same values of x and f, the following command will show the Bessel centered-
difference polynomial of degrees 0 through 4:
-->for n = 0:4, bessel(3.44,n,x,y), end

ans = .2899160
ans = .2906977
ans = .2906944
ans = .2906944
ans = .2906944
Least Squares Polynomial Approximation

Given a set of N data points (x1,Y1), (x2, Y2), …, (xN,YN), we try to obtain a polynomial
y = bo + b1x + b2x2 + …+ bn-1x n-1

+ bnxn,
such that the sum of the squares of the estimation errors, ei = Yi - yi, i.e.,
N N
S (bo , b1 ,..., bn ) = ∑ ei2 = ∑ (Yi − y i ) 2
i =1 i =1
is minimized.
The following method (e.g., Johnson, R.A., 1994, "Miller & Freund's Probability and Statistics
for Engineers," Prentice Hall, Englewood Cliffs, New Jersey) uses matrices to obtain the vector
of coefficients b = [bo b1 b2 … bn-1 bn], by creating the matrix X,
1 x1 x12 K x1n 
 
1 x 2 x 22 K x 2n 
X = 1 x3 x32 K x3n ,
 
M M M M M 
1 x x N2 K x Nn 
 N
and solving for b, from

b = (XTX)-1 XTy,
where y is the column vector, y = [ y1 y2 … yn-1 yN]T. For implementation in SCILAB, we use
two column vectors, x = [ x1 x2 … xN-1 xN]T, and y = [ y1 y2 … yN-1 yN]T, as well as the
polynomial degree, n, as input to a function PolyFit, listed below.
function [b]=PolyFit(x,y,n)
//Least-square method fitting a polynomial equation

//x and y are column vectors
//Check that x and y have the same size
[nrx,ncx]=size(x)
[nry,ncy]=size(y)
if((ncx<>1)|(ncy<>1))then
error('x or y, or both, not column vector(s)');
abort;
end;
if((nrx<>nry))then
error('x and y have not the same length');
abort;
end;
N = nrx;
X = ones(N,n+1);
for j = 2:n+1
for i = 1:N
X(i,j) = x(i,1)^(j-1)
end;
end;
XT = X';
M = XT*X;
M = inv(M);
M = M*XT;
b = M*y;
//end PolyFit function
For example, to fit a second-order polynomial to the following data, use the SCILAB commands
shown below:
x y
0 12.0
1 10.5
2 10.0
3 8.0
4 7.0
5 8.0
6 7.5
7 8.5
8 9.0
-->getf('PolyFit.txt')
-->x = [0:1:8]
x =
! 0. 1. 2. 3. 4. 5. 6. 7. 8. !
-->Y = [12,10.5,10,8,7,8,7.5,8.5,9]
Y =
! 12. 10.5 10. 8. 7. 8. 7.5 8.5 9. !
-->b = PolyFit(x',Y',2)
b =
! 12.184848 !
! - 1.8465368 !
! .1829004 !
The vector b now can be used in the function poly to generate the polynomial y = f(x), which
can be evaluated at x = 6.5 by using the function horner, as shown below:

-->y = poly(b,'x','coeff')
y =
2
12.184848 - 1.8465368x + .1829004x
-->horner(y,6.5)
ans =
7.9099026
Linear Data Fitting
The function PolyFit, when called with n = 1, can be used to fit a linear function to the data,
namely,
y = bo +b1x.
For example, fit a linear relationship to the following data using PolyFit:
x y
20 0.18
60 0.37
100 0.35
140 0.78
180 0.56
220 0.75
260 1.18
300 1.36
340 1.17
380 1.65
The SCILAB commands to use are:
-->x = [20:40:380]';
-->Y = [0.18, 0.37, 0.35, 0.78, 0.56, 0.75, 1.18, 1.36, 1.17, 1.65]';
-->b = PolyFit(x,Y,1)
b =
! .0692424 !
! .0038288 !
y =
.0692424 + .0038288x
To evaluate y = f(x) at, say, x = 190, use:
-->horner(y,190)

ans =
.7967121
We can also obtain the errors for the original data by using the following commands:
-->yh = horner(y,x)
yh =
! .1458182 !
! .2989697 !
! .4521212 !
! .6052727 !
! .7584242 !
! .9115758 !
! 1.0647273 !
! 1.2178788 !
! 1.3710303 !
! 1.5241818 !
-->e = Y-yh
e =
! .0341818 !
! .0710303 !
! - .1021212 !
! .1747273 !
! - .1984242 !
! - .1615758 !
! .1152727 !
! .1421212 !
! - .2010303 !
! .1258182 !
Other Linearized Data Fittings
The table below shows other functions that can easily be linearized and their coefficients
obtained by using the PolyFit function with n = 1.
Independent Dependent
Type of Actual Linearized variable Variable
Fitting Model Model ξ η
Linear y = a + bx y = a + bx [same] x y
Logarithmic y = a + b ln(x) y = a + b ln(x) [same] ln(x) y
Exponential y = a ebx ln(y) = ln(a) + bx x ln(y)
Power y = a xb ln(y) = ln(a) + b ln(x) ln(x) ln(y)
Simplified polynom. y = a + bxm y = a + bxm [same] xm y
Reciprocal linear y = 1/(a+bx) 1/y = a + bx x 1/y
The functions listed can be re-written as
η = a + bξ,

by using the variable transformation shown above. Other combinations of variables can also be
linearized, for example, y = 1/(a+bxm), and y = a + b (lnx)m.
For example, fit an expression of the form y = a + bx2, to the following data:
___________
x Y
___________
0 100
110 90
180 80
250 60
300 40
340 20
___________
Use the variables ξ = x2 and η = y. The following SCILAB commands will perform the linear
fitting:
-->x = [0;110;180;250;300;340]
x =
! 0. !
! 110. !
! 180. !
! 250. !
! 300. !
! 340. !
-->Y = [100;90;80;60;40;20]
Y =
! 100. !
! 90. !
! 80. !
! 60. !
! 40. !
! 20. !
-->x2 = x^2
x2 =
! 0. !
! 12100. !
! 32400. !
! 62500. !
! 90000. !
! 115600. !
-->b = PolyFit(x2,Y,1)
b =
! 100.35736 !
! - .0006786 !
y =
100.35736 - .0006786x

Interpolation with splines
The term splines or spline curves refers to a technique by which a set of points { (x1,y1), (x2,y2),
…, (xn,yn)} are fitted with a series of functions (typically, cubic polynomials) that satisfy
continuity of the functions and some of their derivatives at the points being fitted. The term
spline is borrowed from instruments used to fit a continuous smooth shape through a number of
points in drafting. A spline or French curve consists of a flexible ruler that a draftsman can
mold to fit points in paper.
Cubic splines
The method of cubic splines consists in fitting a number of cubic polynomials of the form
y = fk(x) = b0 + b1x + b2x2 + b3x3,
through the data set {(x1,y1), (x2,y2), …, (xn,yn)}, requiring that not only the functions fk(x) but
also their first and second derivatives,
s = fk’(x) = b1 + 2b2x + 3b3x2,

and
κ = fk”(x) = 2b2+6b3x,
be continuous at the “interior” points (x2,y2), (x3,y3), …, (xn-1,yn-1). The first derivatives f’(x)
are referred to as the slope and the second derivatives as the curvature of the data fitting.
Suppose that we seek n-1 cubic polynomials to fit the n data points {(x1,y1), (x2,y2), …, (xn,yn)}.
Because each cubic polynomial requires 4 coefficients to be determined, we have a total of
4(n-1) = 4n-4 unknowns. To satisfy continuity of the fitting function, we let polynomial
number 1, f1(x), fit the data through points x1, and x2, polynomial number 2, f2(x), through
points x2, and x3, and so on. Thus, there are two data values that satisfy each of the n-1
polynomials, i.e., y1 = f1(x1), y2 = f1(x1), y2 = f2(x2), y3 = f2(x3), …, yn-1 = fn-2(xn-1), yn-1 = fn-1(xn-1),
and yn = fn-1(xn). These results constitute a total of 2(n-1) equations.
Continuity of the slope at the interior points requires that f’1(x2) = f’2(x2), f’2(x2) = f’3(x2),…,
f’n-2(xn-1) = f’n-1(xn-1), which adds an additional n-2 equations to the system. An additional set
of n-2 equations result from continuity of curvature at the interior points, i.e., f”1(x2) = f”2(x2),
f”2(x2) = f”3(x2),…, f”n-2(xn-1) = f”n-1(xn-1). At this point, we count with 2(n-1) + 2(n-2) = 4n-6
equations for the 4n-4 unknown coefficients. Therefore, we need to come up with two
additional equations to uniquely solve for all the unknown coefficients.
There are several options for the additional two equations including:
• Set the slope of the fitting curve at the extreme points x = x1 and x = xn to fixed values,
i.e., f’1(x1) = h1 and f’n-1(xn) = hn.
• Use zero curvature at the extreme points, i.e., f”1(x1) = f”n-1(xn) = 0.
• Make the curvature at the extreme points equal to that of the closest points, i.e.,
f”1(x1) = f”1(x2) and f”n-1(xn-1) = f”n-1(xn).

• Use a linear extrapolation of the curvature at points x2 and x3 to get the curvature at
point x1, and a linear extrapolation of the curvature at points xn-2 and xn-1 to get the
curvature at point xn.
• Make the third derivative of the cubic polynomials, fk’’’(x) = 6b3, continuous at points
x2 and xn-1, i.e., f1’’’(x2) = f2’’’(x2), and fn-2’’’(xn-1) = fn-1’’’(xn-1). This condition ensures
continuity of the fitting function and all its derivatives not only at the interior points
but also at the extreme points, making the fitting function, in fact, periodic.
SCILAB functions for cubic splines

SCILAB provides functions splin and interp to obtain the spline fitting of a set of data and to
interpolate data after the spline fitting is completed. Function splin requires as input data
vectors x and y, and returns a vector of derivatives of the fitting function d. The general form
of the function call is
d=splin(x,y [,"periodic"]
The optional argument “periodic” is used when a periodic spline function is sought.
Function interp is used after function splin has been invoked to produce values of the fitted
function y, as well as values of the first, second, and third derivatives, if needed, for a vector
of values xd. The general call to the function is:
[y0 [,y1 [,y2 [,y3]]]]=interp(xd,x,y,d)
Notice that all the terms in the left-hand side of the call are optional. These terms represent
the data fitting (y0), first derivatives (y1), second derivatives (y2), and third derivatives (y3).
An example of application of functions splin and interp is shown next using the data in the
following table:
x 0.0 1.2 3.5 4.2 6.2 8.1 11.2
y 15.0 29.0 13.3 -6.4 2.9 17.1 -8.0
First, we define the data vectors and use function splin to get the derivatives of the fitting
functions:
-->x = [0.0,1.2,3.5,4.2,6.2,8.1,11.2]
x =
! 0. 1.2 3.5 4.2 6.2 8.1 11.2 !
-->y = [15.0,29.0,13.3,-6.4,2.9,17.1,-8.0]
y =
! 15. 29. 13.3 - 6.4 2.9 17.1 - 8. !
-->//simple spline
-->d = splin(x,y)
d =
column 1 to 5
! 13.47637 8.3035909 - 27.66225 - 21.025873 13.960103 !
column 6 to 7

! 1.2037304 - 16.821038 !
To produce the curve representing the fitting spline curve we generate x data in the range
(0,11.2) and use function interp to generate the fitted data:
-->xx = [0:0.1:11.2];
-->[y0,y1,y2,y3] = interp(xx,x,y,d);
To produce the plot we need to know about the minimum and maximum values in the
plotting rectangle:
-->min(y),max(y)
ans = - 8.
ans = 29.
-->min(y0), max(y0)
ans = - 11.862191
ans = 32.468457
Based on the minimum and maximum values of the original data x,y and of the fitted data y0
we select the following plotting rectangle:
-->rect = [0 -12 12 40]

rect =
! 0. - 12. 12. 40. !
A plot of the fitted spline and the original data follows:
-->plot2d(xx,y0,9,'011','y',rect)
-->plot2d(x,y,-9,'010','y',rect)
-->xtitle('Cubic spline fitting','x','y')
If we want to fit a periodic spline to the original data we need to have the first and last values
in the y data set be the same:
-->y

y =
! 15. 29. 13.3 - 6.4 2.9 17.1 - 8. !
-->y(7) = y(1)
y =
! 15. 29. 13.3 - 6.4 2.9 17.1 15. !
The following SCILAB commands produce the spline fitting and the corresponding graph:
-->d = splin(x,y,'periodic')
d =
column 1 to 5
! 8.6838537 9.9142635 - 27.872184 - 20.968424 14.116738 !
column 6 to 7
! .5382762 8.6838537 !
-->xx = [0:0.1:11.2];
-->[y0,y1,y2,y3] = interp(xx,x,y,d);
-->plot2d(xx,y0,9,'011','y',rect)
-->plot2d(x,y,-9,'010','y',rect)
-->xtitle('Periodic cubic spline fitting','x','y')
The function smooth

Function smooth is used to generate a data set {(x1,ys1), (x2 = x1+∆x,ys2), (x2 = x1+2∆x,ys3), …,
(xn,ysn)} from a cubic spline fitting ys = f(x) based on the data set {(x1,y1), (x2,y2), …, (xn,yn)}.
The general call to the function is
[xy_Fitted_Data]=smooth(xy_Original_Table [,step])

xy_Original_Table is a two-row matrix with the first row containing the values of x and the
second row containing the values of y from the original data set, step is the value of ∆x that
generates a set of values of x for the fitted data. The x data generated consists of values x1 +
∆x, x2 + ∆x, …, etc. If no value of step is provided, SCILAB uses a default value that generates
100 data points for x. The y data generated by function smooth follows a cubic spline fitting.
The (x,y) data generated by function smooth is returned in the form of a two-row matrix with
the first row corresponding to values of x and the second row corresponding to values of y.
The application of function smooth is equivalent to the application of functions splin and
interp for the range of values of x in the original data table. The following example shows
how to fit the following data through cubic splines by applying function smooth:
x 1.2 4.2 6.2 11.2 12.5 13.9 14.1 15.6 16.5 18.4
y 32.3 -4.2 13.6 -1.7 2.8 22.1 29.7 11.5 14.3 18.5
First, we enter the data for x and y:
-->x = [1.2,4.2,6.2,11.2,12.5,13.9,14.1,15.6,16.5,18.4];
-->y = [32.3,-4.2,13.6,-1.7,2.8,22.1,29.7,11.5,14.3,18.5];
Next, we put together the matrix xy_Original_Table as a two-row matrix:
-->xy_Original_Table = [x;y]
xy_Original_Table =
column 1 to 8
! 1.2 4.2 6.2 11.2 12.5 13.9 14.1 15.6 !

! 32.3 - 4.2 13.6 - 1.7 2.8 22.1 29.7 11.5 !
column 9 to 10
! 16.5 18.4 !
! 14.3 18.5 !
To generate the fitted data use:
-->xy_Fitted_Data = smooth(xy_Original_Table,0.1);
Next, we separate the rows of data into vectors xx and yy:
-->xx=xy_Fitted_Data(1,:); yy = xy_Fitted_Data(2,:);
To determine the plot rectangle to use, we get information on the minimum and maximum
values of xx and yy:
-->min(xx),max(xx),min(yy),max(yy)
ans = .2
ans = 18.4
ans = - 7.8229563
ans = 34.685766
-->rect = [0 -10 20 40]

rect = ! 0. - 10. 20. 40. !
The following commands plot the original and the fitted data in the same set of axes:
-->plot2d(x,y,-9,'011',' ',rect)
-->plot2d(xx,yy,1,'010',' ',rect)
-->xtitle('Spline through use of function smooth','x','y')
Obtaining the spline polynomials
The user-defined function splinepol, listed below, can be used to generate the n-1 cubic
polynomials that constitute the spline fitting for a data set {(x1,y1), (x2,y2),…,(xn,yn)}. The
function requires as input the vectors x and y containing the data set, as well as the vector of
derivatives d obtained from function splin, i.e., d = splin(x,y) or d = splin(x,y,’periodic’). Also,
the user must provide a polynomial variable (var), say ‘x’,’s’, etc., to generate the
polynomials.
The general call to this function is
[ps] = splinepol(x,y,d,var)
A listing of the function is provided next:
function [ps] = splinepol(x,y,d,var)
//Produces the (n-1) cubic splines that fit the

//data set [(x1,y1),(x2,y2),...,(xn,yn)] of size n.
//Input to the function consists of vectors x, y, d
//and polynomial variable var, where
// x = [x1,x2,...,xn], y = [y1,y2,...,yn].
//Vector d results from the application of function
//splin: d = splin(x,y) or d = splin(x,y,'periodic')
[y0,y1,y2,y3] = interp(x,x,y,d);
n = length(x);
yy0=y0(2:n);yy1=y1(2:n);yy2=y2(2:n);yy3=y3(2:n);
xx = x(2:n);

a = zeros(n-1,4);
a(:,4) = yy3./6;
a(:,3) = (yy2-6.*a(:,4).*xx')./2;
a(:,2) = yy1-2.*a(:,3).*xx'-3.*a(:,4).*xx'.^2;
a(:,1) = yy0'-a(:,2).*xx'-a(:,3).*xx'.^2-a(:,4).*xx'.^3;
ps = zeros(n-1,1);
for j = 1:n-1
ps(j) = poly(a(j,:),var,'coeff');
end;
//end of function splinepol
To accompany function splinepol we also create the following function, intersplin, to

interpolate data out of the polynomials ps generated with splinepol. The general call to
function intersplin is
[yy] = intersplin(xx,x,ps)
where xx is a vector containing the values of x for the interpolation, x is a vector of n elements
representing the original x data used in generating the n-1 cubic polynomials listed in vector
ps. The function returns values of y in vector yy of length n.
A listing of function intersplin follows:
function [yy] = intersplin(xx,x,ps)
//interpolates spline polynomials in the range given

//by vector xx. The spline polynomials are
//passed to the function as a column vector
//of polynomials (as generated by function
//splinepol). Vector x represents the original
//x data from which the polynomials were generated.
n = length(x);
m = length(xx);
yy = [];
for i = 1:m
if xx(i) <= x(1) | xx(i) >= x(n) then
yy = [yy 0];
else
for j = 1:n-1
if xx(i)>x(j) & xx(i)<=x(j+1) then
yy = [yy horner(ps(j),xx(i))];
end;
end;
end;
end;
The purpose of including functions splinpol is to provide a way to list the cubic polynomials for
a given spline data fitting. The purpose of function intersplin is to be able to interpolate
those polynomials to check the data fitting. The results out of function intersplin are not
different of those generated with SCILAB function interp, as will be demonstrated in the
following examples.

In the examples that follow, we take vectors x and y, of the same length, and generate the
vector of derivatives d from function splin. Next, we interpolate data for y (vector yy) using
function interp given a vector xx. We also use function splinpol to generate the cubic
polynomials corresponding to the spline fitting, and interpolate values of y (vector yyy) using
function intersplin. Finally, we produce a joint plot of the original data (circles), the data
from interp (continuous line), and the data from intersplin (crosses), to verify that the results
provided by the polynomials generated with splinpol coincide with those generated through
SCILAB functions interp. Two examples are presented, one for a non-periodic spline and one
for a periodic spline.
First, we load functions splinepol and intersplin:
-->getf('splinepol')
-->getf('intersplin')
The (x,y) data used for a non-periodic spline fitting are generated with
-->x = [0.5:0.5:5]
x = ! .5 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. !
-->y = [0.2 1.4 2.3 1.0 0.4 -0.6 -1.0 -0.5 0.2 1.2]
y = ! .2 1.4 2.3 1. .4 - .6 - 1. - .5 .2 1.2 !
Next, we produce the spline fitting and generate information for the plot:
-->d = splin(x,y); //vector of derivatives
-->xx = [0:0.1:5]; //values of x for interpolation
-->yy = interp(xx,x,y,d); //values of y from interp
-->ps = splinepol(x,y,d,'x') //cubic spline polynomials

ps =
! 2 3 !
! 2.2156991 - 9.5908966x + 13.462796x - 4.6875988x !
! !
! 2 3 !
! 2.2156991 - 9.5908966x + 13.462796x - 4.6875988x !
! !
! 2 3 !
! - 41.408176 + 77.656853x - 44.70237x + 8.2379938x !
! !
! 2 3 !
! 65.010787 - 81.971591x + 35.111852x - 5.0643765x !
! !
! 2 3 !
! - 64.424974 + 73.351323x - 27.017314x + 3.2195122x !
! !
! 2 3 !
! 17.471007 - 8.5446582x + .2813466x + .1863277x !
! !
! 2 3 !
! 92.551597 - 72.89945x + 18.66843x - 1.5648231x !
! !
! 2 3 !
! - 37.866816 + 24.914359x - 5.7850223x + .4729646x !
! !
! 2 3 !
! - 37.866816 + 24.914359x - 5.7850223x + .4729646x !

-->yyy = intersplin(xx,x,ps); //interpolating using polynomials
-->min([y yy yyy]), max([y yy yyy]) //determining values for plot

ans = - 1.0050396
ans = 2.3127536
-->rect = [0 -2 5 4]; //define plot rectangle
The next SCILAB commands produce the required plot:
-->plot2d(xx,yy,1,'011',' ',rect)
-->plot2d(x,y,-9,'011',' ',rect)
-->plot2d(xx,yyy,-1,'011',' ',rect)
-->xtitle('Spline fittin -- interp + interspline','x','y')
Next, we modify the data in y to produce a periodic spline fitting:
-->x
x = ! .5 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. !
-->y
y = ! .2 1.4 2.3 1. .4 - .6 - 1. - .5 .2 1.2 !

-->y(10) = y(1)
y = ! .2 1.4 2.3 1. .4 - .6 - 1. - .5 .2 .2 !
Next, we generate the vector of derivatives using splin, and interpolate data using interp,
splinepol, and intersplin:
-->d = splin(x,y,'periodic');
-->xx = [0:0.1:5];
-->yy = interp(xx,x,y,d);
-->ps = splinepol(x,y,d,'x')
ps =
! 2 3 !
! 1.2431373 - 5.8509804x + 9.0509804x - 3.0431373x !
! !
! 2 3 !
! 3.3294118 - 12.109804x + 15.309804x - 5.1294118x !
! !
! 2 3 !
! - 42.2 + 78.94902x - 45.396078x + 8.3607843x !
! !
! 2 3 !
! 65.596078 - 82.745098x + 35.45098x - 5.1137255x !
! !
! 2 3 !
! - 65.776471 + 74.901961x - 27.607843x + 3.2941176x !
! !
! 2 3 !
! 24.858824 - 15.733333x + 2.6039216x - .0627451x !
! !
! 2 3 !
! 49.743137 - 37.062745x + 8.6980392x - .6431373x !
! !
! 2 3 !
! 198.32353 - 148.49804x + 36.556863x - 2.9647059x !
! !
! 2 3 !
! - 554.97647 + 353.70196x - 75.043137x + 5.3019608x !
-->yyy = intersplin(xx,x,ps);
The following SCILAB commands produce the comparative plot:
-->plot2d(xx,yy,1,'011',' ',rect)
-->plot2d(x,y,-9,'011',' ',rect)
-->plot2d(xx,yyy,-1,'011',' ',rect)
-->xtitle('Spline fitting/periodic function -- interp + interspline','x','y')

Multi-variate data fitting
In this section we consider interpolation and fitting of the data in a table of values (x i,yj,zij),
for i=1,2,…,n; j=1,2,…,m, through a function z = f(x,y). A typical table will look as follows:
x\y y1 y2 … yj … ym
x1 z11 z12 … z1j … z1m
x2 z21 z22 … z2j … z2m
: : : : : :
xi zi1 zi2 … zij … zim
: : : : : :
xn zn1 zn2 … znj … znm
Successive univariate polynomial interpolation

By successive univariate polynomial interpolation we mean to interpolate data by columns of
the table first, and then by rows using a univariate polynomial in each direction. For example,
we can select polynomials of order k to fit data for the columns of the table, i.e.,
ZCj(x) = a0j + a1jx + a2jx2 +… + akjxk,
for j = 1,2,…,m. Quadratic polynomials to fit data for the rows of the table would have the
form
ZRj(y) = ai0 + ai1y + ai2y2 +… + aikyk,
for i = 1,2,…,n.
If we are interested in interpolating the value of the function z = f(x,y) for x = xr and y = ys, we
can start by first generating the polynomial fittings ZCj(x) = a0j + a1jx + a2jx2 +… + akjxk, for j =
1,2,…,m. From these fittings we can get the data set {zc1, zc2, …,zcm}, where zcj = ZCj(xr).
Next, we attempt a fitting of the form ZR(y) = = ai0 + ai1y + ai2y2 +… + aikyk, using the data set
{(y1,zc1), (y2,zc2),…,(ym,zcm)}. The value we are searching for is z = f(xr,ys) = ZR(ys).

Consider, for example, the following table of values z = f(x,y):
x \ y 12.00 13.00 14.00

2.00 71.09 76.94 81.70
3.00 77.07 82.13 87.34
4.00 85.22 91.63 96.67
Suppose that we want to interpolate the value of z for x = 2.5, y = 13.2, using quadratic
polynomials in both directions. We start by loading the vectors x and y and the table of values
z:
-->x = [2,3,4];y=[12,13,14];
-->z = [71.09,76.94,81.70;77.07,82.13,87.34;85.22,91.63,96.67];
A plot of the z data can be obtained by using:

-->plot3d(x,y,z)
The first step in the successive univariate polynomial fitting requires using function dfp (direct
polynomial fitting) to fit quadratic equations by columns. The polynomials corresponding to
rows 1, 2, and 3 are called p1(x), p2(x), and p3(x), respectively. The coefficients of each of
these polynomials results from the use of function dfp for the data in vector x (passed on to
the function as a column vector, i.e., x’) and the data in the corresponding columns of the
table, i.e., z(:,1), z(:,2), and z(:,3).
-->[a1] = dfp(x',z(:,1)), p1 = poly(a1,'xx','coeff')

a1 =
! 65.64 .555 1.085 !

p1 =
2
65.64 + .555xx + 1.085xx

a2 =
! 79.49 - 5.585 2.155 !

p2 =
2
79.49 - 5.585xx + 2.155xx

a3 =
! 81.49 - 3.585 1.845 !

p3 =
2
81.49 - 3.585xx + 1.845xx
After obtaining the polynomial fittings per column, we proceed to generate the data zc
corresponding to x = 2.5, by using:
-->zc(1)=horner(p1,2.5);zc(2)=horner(p2,2.5);zc(3)=horner(p3,2.5); zc
zc =
! 73.80875 78.99625 84.05875 !
These data are next fit to a quadratic polynomial on y:
-->b = dfp(y',zc'), zz = poly(b,'yy','coeff')

b =
! 1.80875 6.75 - .0625 !

zz =
2
1.80875 + 6.75yy - .0625yy
The evaluation of the resulting polynomial, zz(y), for y = 13.2, will produce the required
interpolation:
-->zfit = horner(zz,13.2)
zfit =
80.01875
The interpolation performed above can be repeated by first fitting data by rows, i.e.,
generating polynomials p1(y), p2(y), and p3(y) corresponding to the rows of the table. A data
set zc is then generated by evaluating these polynomials for y = 13.2. Fitting data to the data
sets x and zc produces a polynomial zz(x) which is then evaluated at x = 2.5 to obtain the
desired result. The corresponding SCILAB commands are shown next:
-->x = [2,3,4];y=[12,13,14];
-->z = [71.09,76.94,81.70;77.07,82.13,87.34;85.22,91.63,96.67];
-->[b1] = dfp(y',z(1,:)'), p1 = poly(b1,'yy','coeff')

b1 =
! - 84.13 19.475 - .545 !

p1 =
2
- 84.13 + 19.475yy - .545yy

b2 =
! 28.05 3.185 .075 !

p2 =

2
28.05 + 3.185yy + .075yy
b3 =
! - 98.56 23.535 - .685 !

p3 =
2
- 98.56 + 23.535yy - .685yy
-->zc(1)=horner(p1,13.2);zc(2)=horner(p2,13.2);zc(3)=horner(p3,13.);zc
zc =
! 77.9792 83.16 91.63 !
-->a = dfp(x',zc'), zz = poly(a,'xx','coeff')

a =
! 77.4852 - 3.0422 1.6446 !

zz =
2
77.4852 - 3.0422xx + 1.6446xx
-->z_fit = horner(zz,2.5)
z_fit =
80.15845
The interpolation results obtained through the two approaches shown above are z = 80.01875
and z = 80.15845. Although they are very close to each other, they are not exactly the same as
expected. You may report as the final interpolation the average of these two results, namely,
z = (80.01875 +80.15845)/2 = 80.0886.
Notes:
[1] Function dfp requires that the vectors of data used in the direct polynomial fitting be
passed to the function as column vectors.
[2] The degree of the polynomial whose coefficients are returned by function dfp is n-1 where
n is the length of the vectors x or y passed to the function. Therefore, the 3x3 table of data
used in the examples above had the right size for quadratic polynomial fittings.
[3] Polynomial fittings for any polynomial order can be obtained if we use function polyfit
instead of dfp.
Direct multivariate polynomial fitting

Direct multivariate polynomial fitting is a generalization of the direct (univariate) polynomial
fitting presented earlier in the chapter. We will use a very general multivariate polynomial
function of degree n given by:
z = f(x,y) = a0 + a1x + a2y + a3x2 + a4xy + a5y2 + a6x3 + a7x2y + a8xy2 + a9y3 + …
The degree of the polynomial for direct fitting is determined by the number of data values
available. For example, for the table used in the previous example:

x \ y 12.00 13.00 14.00
2.00 71.09 76.94 81.70
3.00 77.07 82.13 87.34
4.00 85.22 91.63 96.67
which contains nine entries, we can, in principle, fit a function with nine coefficients. One
possibility is to use:
z = f(x,y) = a0 + a1x + a2y + a3x2 + a4xy + a5y2 + a6x3 + a7x2y + a9y3
However, the matrix of data for the linear system that results from replacing values of x and y
in the equation, is an ill-conditioned matrix (i.e., a singular matrix or a matrix close to
singularity). Thus, direct multivariate polynomial fitting fails for this case.
One alternative is to try to fit a simpler function, say,
z = f(x,y) = a0 + a1x + a2y + a3xy ,
using only four data points from the table. Suppose that we use the following data points:
1. x = 2, y = 12, z = 71.09, a0 + 2a1 + 12a2 + 24a3 = 71.09

2. x = 3, y = 12, z = 85.22, a0 + 3a1 + 12a2 + 36a3 = 77.07
3. x = 2, y = 14, z = 81.70, a0 + 2a1 + 14a2 + 28a3 = 81.70
4. x = 4, y = 14, z = 96.67, a0 + 4a1 + 14a2 + 56a3 = 71.09
The solution to the linear system that results is obtained using SCILAB as follows:
-->A = [1,2,12,24;1,3,12,36;1,2,14,28;1,4,14,56] //Matrix of coefficients

A =
! 1. 2. 12. 24. !
! 1. 3. 12. 36. !
! 1. 2. 14. 28. !
! 1. 4. 14. 56. !
-->det(A) //Verifying that the matrix is not singular

ans = 8.
-->b = [71.09;77.07;81.70;71.09]
b =
! 71.09 !
! 77.07 !
! 81.7 !
! 71.09 !
-->a = A\b //Function coefficients

a =
! - 139.95 !
! 73.69 !
! 16.59 !
! - 5.6425 !
-->deff('[z]=f(x,y)','z=a(1)+a(2)*x+a(3)*y+a(4)*x*y') //Defining function
-->[f(2,12),f(3,12),f(2,14),f(4,14)]' //Verifying solution

ans =
! 71.09 !
! 77.07 !
! 81.7 !
! 71.09 !
Least-square multivariate polynomial fitting

The method of least-squares presented earlier for univariate polynomials can be generalized
for a multivariate polynomial fitting. For example, a simple multivariate linear fitting given
by
z = a0 + a1x + a2y,
produces a sum-of-squared-errors given by
n
SSE (a 0 , a1 , a 2 ) = ∑ ( z i − a 0 − a1 x − a 2 y ) 2 .
i =1
To minimize function SSE, we set up the equations ∂(SSE)/∂a0 = 0, ∂(SSE)/∂a1 = 0, and

∂(SSE)/∂a2 = 0, which result in the set of equations:
a0n + a1Σxi + a2Σyi = Σzi

a0Σxi + a1Σxi2 + a2Σxiyi = Σxizi
a0Σyi + a1Σxiyi + a2Σyi2 = Σyizi
The solution to the resulting linear system provides the coefficients of the function, a0, a1, and
a2.
For example, to fit the data in the bivariate table presented earlier, namely,
x \ y 12.00 13.00 14.00

2.00 71.09 76.94 81.70
3.00 77.07 82.13 87.34
4.00 85.22 91.63 96.67
to the proposed bivariate function, z = a0 + a1x + a2y, using SCILAB, we proceed as follows:
First, we define the x,y, and z data:

-->x = [2,3,4]; y = [12,13,14];
-->z = [71.09,76.94,81.70;77.07,82.13,87.34;85.22,91.63,96.67];
To calculate the summations in the set of linear equations presented above, we need to create
matrices of values of x and y corresponding to the entries in the bivariate table. These
matrices, called xx and yy, respectively, are determined as follows:
-->xx = [x',x',x']
xx =
! 2. 2. 2. !
! 3. 3. 3. !
! 4. 4. 4. !

-->yy = [y;y;y]
yy =
! 12. 13. 14. !

! 12. 13. 14. !
! 12. 13. 14. !
The next step is to produce the matrix of coefficients for the system:
-->A = zeros(3,3)
A =
! 0. 0. 0. !
! 0. 0. 0. !
! 0. 0. 0. !
-->A(1,1) = n; A(1,2) = sum(xx); A(1,3) = sum(yy);
-->A(2,1) = sum(xx); A(2,2)=sum(xx^2); A(2,3) = sum(xx.*yy);
-->A(3,1) = sum(yy); A(3,2)=sum(xx.*yy); A(3,3) = sum(yy^2);
-->A
A =
! 9. 27. 117. !
! 27. 243. 351. !
! 117. 351. 4563. !
The vector of right-hand side terms in the system of equations is:
-->b = [sum(z);sum(xx.*z);sum(yy.*z)]
b =
! 749.79 !
! 2293.16 !
! 9779.6 !
Before solving the linear system we check that the matrix is not singular:
-->det(A)
ans = 4435236.
The coefficients of the function are obtained by using left division:
-->a = A\b
a =
! 82.360912 !
! .2703086 !
! .0106279 !
The following is the definition of the function:
-->deff('[z]=f(x,y)','z=a(1)+a(2)*x+a(2)*y')
To evaluate the function in a grid we can use function feval as follows:
-->feval(x,y,f)

ans =
! 86.145233 86.415541 86.68585 !

! 86.415541 86.68585 86.956159 !
! 86.68585 86.956159 87.226467 !
Compared with the original values of z we find that the simple linear fitting does not
reproduces those original values very well.
-->z
z =
! 71.09 76.94 81.7 !

! 77.07 82.13 87.34 !
! 85.22 91.63 96.67 !
Bivariate quadratic fitting
To improve the fitting we may want to try using a bivariate quadratic fitting given by the
expression
z = a0 + a1x + a2y + a3x2 + a4xy + a5y2,
whose sum of squared errors is given by
n
SSE (a0 , a1 , a 2 ) = ∑ ( z i − a 0 − a1 x − a 2 y − a 3 x 2 − a 4 xy − a5 y 2 ) 2 .
i =1
To minimize the function SSE, we set up the equations: ∂(SSE)/∂a0 = 0, ∂(SSE)/∂a1 = 0,

∂(SSE)/∂a2 = 0, ∂(SSE)/∂a3 = 0, ∂(SSE)/∂a4 = 0, and ∂(SSE)/∂a5 = , which result in the system:
a0n + a1Σxi + a2Σyi + a3Σxi2 + a4Σyi2 + a5Σxiyi = Σzi

2
a0Σxi + a1Σxi + a2Σxiyi + a3Σxi3 + a4Σxiyi2 + a5Σxi2yi = Σxizi
a0Σyi + a1Σxiyi + a2Σyi2 + a3Σxi2yi + a4Σyi3 + a5Σxiyi2 = Σyizi
a0Σxi2 + a1Σxi3 + a2Σxi2yi + a3Σxi4 + a4Σxi2yi2 + a5Σxi3yi = Σxi2zi
a0Σyi2 + a1Σxiyi2 + a2Σyi3 + a3Σxi2yi2 + a4Σyi4 + a5Σxiyi3 = Σyi2zi
a0Σxiyi + a1Σxi2yi + a2Σxiyi2 + a3Σxi3yi + a4Σxiyi3 + a5Σxi2yi2 = Σxiyizi
We will use the data from the table presented above to generate the coefficients for this
matrix. Considering the number of evaluations involved we are going to prepare a function,
multiquad, to produce the coefficients of the function:
function [a] = multiquad(xyzMatrix)
//produces the coefficients a = [a1 a2 a3 ... a6]

//from the function
// f(x,y) = a1+a2*x+a3*y+a4*x^2+a5*x*y+a6*y^3
//xyzMatrix = [x(col1) y(col2) z(col3)]
xx = xyzMatrix(:,1);
yy = xyzMatrix(:,2);
zz = xyzMatrix(:,3);
n = length(xx);
A=zeros(6,6);
A(1,1)=n; A(1,2)=sum(xx);A(1,3)=sum(yy);A(1,4)=sum(xx^2);

A(1,5)=sum(yy^2);A(1,6)=sum(xx.*yy);
A(2,1)=A(1,2);A(2,2)=sum(xx^2);A(2,3)=sum(xx.*yy);
A(2,4)=sum(xx^3);A(2,5)=sum(xx.*(yy^2));A(2,6)=sum((xx^2).*yy);
A(3,1)=A(1,3);A(3,2)=A(2,3);A(3,3)=sum(yy^2);
A(3,4)=sum((xx^2).*yy);A(3,5)=sum(yy^3);A(3,6)=sum(xx.*(yy^2));
A(4,1)=A(1,4);A(4,2)=A(2,4);A(4,3)=A(3,4);
A(4,4)=sum(xx^4);A(4,5)=sum((xx^2).*(yy^2
A(5,4)=A(4,5);A(5,5)=sum(yy^4);A(5,6)=sum(xx.*(yy^3));
A(6,1)=A(1,6);A(6,2)=A(2,6);A(6,3)=A(3,6);
A(6,4)=A(4,6);A(6,5)=A(5,6);A(6,6)=sum((xx^2).*(yy^2));
b=[sum(zz);sum(xx.*zz);sum(yy.*zz);sum((xx^2).*zz);sum((yy^2).*zz);sum(xx.*yy.*
zz)];
a=A\b;
disp('Coefficients in the function z = f(x,y)')
disp('z=a(1)+a(2)*x+a(3)*y+a(4)*x^2+a(5)*x*y+a(6)*y^2')
//end function multiquad
The function requires as input a matrix of three columns where the columns correspond to
values of x, y, and z.
In the following example, we use function multiquad to produce a fitting of the form
z = a0 + a1x + a2y + a3x2 + a4xy + a5y2,
for the data in the table below:
x\y 700 800 900

9000 0.031980 0.037948 0.043675
10000 0.028345 0.033827 0.039053
11000 0.025360 0.030452 0.035270
First, we prepare the matrix of data:
-->x = [9000,10000,11000]; y = [700,800,900];
-->z = [.031980,.037948,.4675;.028345,.033827,.039053;.025360,.030452,.035270]
z =
! .03198 .037948 .4675 !

! .028345 .033827 .039053 !
! .02536 .030452 .03527 !
-->xx = [x';x';x']; yy = [y(1) y(1) y(1) y(2) y(2) y(2) y(3) y(3) y(3)]';
-->zz = [z(:,1);z(:,2);z(:,3)];
-->M = [xx yy zz]

M =
! 900. 700. .03198 !

! 1000. 700. .028345 !
! 1100. 700. .02536 !
! 900. 800. .037948 !
! 1000. 800. .033827 !
! 1100. 800. .030452 !
! 900. 900. .4675 !
! 1000. 900. .039053 !
! 1100. 900. .03527 !

To obtain the coefficients of the data fitting, we use:
-->a = multiquad(M)
warning
matrix is close to singular or badly scaled.
results may be inaccurate. rcond = 1.1496E-21
Coefficients in the function z = f(x,y)
z=a(1)+a(2)*x+a(3)*y+a(4)*x^2+a(5)*x*y+a(6)*y^2
a =
! 3.2238377 !
! - .0006434 !
! .0001190 !
! 7.101E-08 !
! .0000071 !
! - .0000011 !
To check how well the fitting reproduces the data we use:
-->deff('[z]=f(x,y)','z=a(1)+a(2)*x+a(3)*y+a(4)*x^2+a(5)*x*y+a(6)*y^2')
-->feval(x,y,f)
ans =
! 47.167934 53.366045 59.542874 !

! 52.809383 59.712584 66.594503 !
! 58.592852 66.201143 73.788152 !
Obviously, the proposed data fitting does not work very well with this data set. The reader
should be advised that there is no guarantee that a given function will fit a particular data set.
The purpose of using the least-square method is to minimize the sum of square errors, SSE,
which is a measure of the overall error involved in the data fitting. However, this procedure
does not ensure that the fitting will be acceptable. There are statistical inference techniques
that can be used as guidelines for the goodness of fit of a particular function to a given data
set. These techniques are covered in a separate chapter.
SCILAB function datafit

Function datafit is used for fitting data to a model by defining an error function e = G(p,z)
where p is a column vector of m rows representing the parameters of the model, and z is a
column vector of n rows representing the variables involved in the model. Function datafit
finds a solution to the set of k equations
ei = G(p,zi) = 0,
by minimizing the functional
GT(p,z1)⋅W⋅G(p,z1) + GT(p,z2)⋅W⋅G(p,z2) + … + GT(p,zn)⋅W⋅G(p,zn),

where zi, i = 1,2, …, n, are specific values of the vector of variables z, and W is a k×k weight
matrix (default value W = Ikxk, the identity matrix).
The simplest call to function datafit is
[p,err]=datafit(G,Z,p0)
where G is the name of the error function G(p,z), Z is a matrix whose rows consists of the
different vectors of variables, i.e., Z = [z1; z2; …;zn], and p0 is a column vector representing
initial guesses of the parameters p sought.
Example 1 - quadratic polynomial
As an example, we will generate data using the function y = a1 + a2x + a3x2 + 100r, where a1 =
20, a2 = 30, a3 = 50, and r is a random component to be generated in SCILAB through the
expression r = 100*(rand()-0.5). Because function rand generates uniform random numbers
in the range (0,1), the values of r will be random numbers uniformly distributed in the range (-
50,50). Thus, the data generated for y is based on the quadratic function a 1 + a2x + a3x2, but
modified by a random number in the range (-50,50). We will generate data for x in the range
(0,10) with increments of 0.1, and calculate the corresponding values of y. Then, the data will
be placed in a matrix Z with values of x in the first row and values of y in the second row. This
matrix Z will be used in the call to function datafit.
The function to fit will be defined as G(a,z) = z(2) - a(1)-a(2)*z(1)-a(3)*z(1)^2, and

we will provide an initial value for the vector of parameters a as a0 = [10;20;30] for the call to
function datafit.
The following SCILAB commands will take care of generating the data and finding the
parameters a that produce the best fitting. The process by which the best fitting for the
model is obtained is an iterative procedure and may take some time to produce a result.
Therefore, be patient if SCILAB does not produce a result right away. Depending on the
complexity of the function to be fitted or on the number data points involved, datafit may take
up to 10 minutes to return a result.
For this example we start by defining the values of x and y that we want to fit. These are
stored in vectors X and Y, which then get put together into matrix Z:
-->X = [0:0.1:10]; Y=20+30.*X+50.*X^2+100*(rand()-0.5); Z = [X;Y];
Next, we define a function G(a,z) = y - a1 - a2x - a3x2, that will be used to obtain the
parameters a = [a1 a2 a3] that define the expression y = a1 + a2x + a3x2, with z = [x y]T.
-->deff('[e]=G(a,z)','e=z(2)-a(1)-a(2)*z(1)-a(3)*z(1)^2')
Initial values of the parameters a are given by:
-->a0 = [10;20;30];
Application of function datafit produces, after a few minutes, the following results for the
coefficients ai:
-->[aa,er] = datafit(G,Z,a0)
er =
3.161E-10

aa =
! 20.644345 !
! 30.000002 !
! 50. !
To verify the fitting of the data we define function f(x), and produce data YY = f(X) to plot the
original and fitted data:
-->deff('[yy]=f(x)','yy=aa(1)+aa(2)*x+aa(3)*x^2')
-->YY = f(X);
-->min([Y YY]), max([Y YY])

ans =
20.644345
ans =
5320.6443
-->rect = [0 0 10 5500]
rect =
! 0. 0. 10. 5500. !
-->plot2d(X,YY,1,'011',' ',rect)
-->plot2d(X,Y,-9,'011',' ',rect)
-->xtitle('datafit for y = a1+a2*x+a3*x^3','x','y')
Example 2 - cubic polynomial
Suppose that we want to fit the data to a cubic polynomial, i.e., y = a 1 + a2x + a3x2 + a4x3, we
can use the following SCILAB commands to obtain the coefficients:
-->deff('[e]=G(a,z)','e=z(2)-a(1)-a(2)*z(1)-a(3)*z(1)^2-a(4)*z(1)^3')
Warning :redefining function: G
-->a0 = [10;20;30;10];

-->[aa,er] = datafit(G,Z,a0)
er =
2.012E-07
aa =
! 20.644456 !
! 29.999865 !
! 50.000034 !
! - .0000023 !
The results indicates that the last coefficient a4 ≈ 0, thus, confirming that the quadratic fitting
is sufficient to reproduce the data. Notice also that the error is relatively small, er =
2.012×10-7, indicating a very good fitting of the data. Such a good fitting is to be expected
since the data was originated from a quadratic function
Example 3 - exponential function
In this example we try to fit an exponential function of the form y = f(x) = a1 + a2 exp(a3x) to
data generated out of a quadratic function. The data is obtained as follows:
-->X=[0:0.1:5];Y = 2.3+5.8.*X+3.2.*X^2;Z=[X;Y];
The next two function definitions are used to specify functions G(a,z) = y - a1 + a2 exp(a3x),
with a = [a1;a2;a3], z = [x;y], and a vector of derivatives corresponding to s = [∂G/∂a1, ∂G/∂a2,
∂G/∂a3] = [-1, -exp(a3x),-a2xexp(a3x)]:
-->deff('[e]=G(a,z)','e=z(2)-a(1)-a(2).*exp(a(3).*z(1))')
-->deff('[s]=DG(a,z)','s=[-1,-exp(a(3).*z(1)),-a(2).*z(1).*exp(a(3).*z(1))]')
Using this vector of derivatives, the call to function datafit is now:
-->[aa,er] = datafit(G,DG,Z,a0)
er =
2606.3157
aa =
! 5. !
! 4.7859729 !
! .6494727 !
To verify the fitting we define the function y = a1 + a2 exp(a3x), and obtain data points
corresponding to the values of x stored in X:
-->deff('[y]=f(x)','y=aa(1)+aa(2)*exp(aa(3)*x)')
-->YY = f(X);
A plot of the original data (symbols) along with the fitted data (continuous line) is obtained as
follows:
-->plot2d(X,YY,1,'011',' ',rect)
-->plot2d(X,Y,-1,'011',' ',rect)
-->xtitle('Function data fit - y = a1+a2*exp(a3*x)','x','y')

Example 4 - fitting data to a function r = f(x,y)
In this example we will attempt fitting a data set (x,y,r) to a function of the form
r = a1 + a2x + a3y + a4x2 + a5xy + a6y2.
The function G(a,z), defined below, represents e = r - (a1 + a2x + a3y + a4x2 + a5xy + a6y2).
-->deff('[e]=G(a,z)',...
--> 'e=a(1)+a(2)*z(1)+a(3)*z(2)+a(4)*z(1)^2+a(5)*z(1)*z(2)+a(6)*z(2)^2-z(3)')
The data is generated from the function f1(x,y) = exp(0.1x)+exp(0.2y), as shown next:
--> xx = [0:0.1:10]; yy = [0:0.1:10];

-->n = length(X), m = length(Y)
n = 121.
m = 121.
The following commands creates vectors of data X, Y, and R, which are then put together into
matrix Z:
-->X = []; Y = []; R = [];
-->for i = 1:n
--> for j = 1:m
--> X = [X xx(i)]; Y = [Y yy(j)];
--> R = [R exp(0.1*xx(i))+exp(0.2*yy(j))];
--> end;
-->end;
-->Z = [X;Y;R];
The initial value of the function parameters is given (arbitrarily) as:

-->a0=10*ones(6,1)
a0 =
! 10. !
! 10. !
! 10. !
! 10. !
! 10. !
! 10. !

The following call to function datafit, which took about 5 minutes in produce a result, provides
the best fitting for the parameters. Notice that the overall error is relatively small.
-->[a,err]=datafit(G,Z,a0)
err =
1.0343445
a =
! 2.1356627 !
! .0856497 !
! .0204965 !
! .0084165 !
! - 6.695E-08 !
! .0590437 !
Next, we will attempt the same calculation using derivatives of the function G(a,z) with
respect to the parameters ai:
-->deff('[s]=DG(a,z)',...
-->'s=[1,z(1),z(2),z(1)^2,z(1)*z(2),z(2)^2]')
Using the derivatives the call to function datafit takes only about 1.5 minutes:
-->[a,err]=datafit(G,DG,Z,a0)
err =
1.0343445
a =
! 2.1356698 !
! .0856476 !
! .0204943 !
! .0084167 !
! 0. !
! .0590439 !
Notice the difference in value of a(5) in the two results. The next commands are used to
reproduce the original data and the fitted data as three-dimensional plots:
-->deff('[z]=ff(x,y)','z=exp(0.1.*x)+exp(0.2.*y)')
-->deff('[r]=f(x,y)',...
-->'r=a(1)+a(2).*x+a(3).*y+a(4).*x.^2+a(5).*x.*y+a(6).*y.^2')
-->zz = feval(xx,yy,ff); zzz = feval(xx,yy,f);
-->plot3d(xx,yy,zz)
-->xtitle('original function')

-->plot3d(xx,yy,zzz)
-->xtitle('fitted function')
Function datafit provides other options for calculation which are not presented in this book.
For more information use:
--> help datafit

Exercises
The following table shows values of the discharge Q(cfs) of a 1.75-ft long spillway as a function
of stage (i.e., water surface elevation) above spillway crest, h(ft) for a weir. The table also
shows the storage available in the reservoir, S(cu.ft), for the different stages.
h(ft) Q(cfs) S(cu.ft)

0.0 0.0 0
0.5 1.9 16641
1.0 5.4 33911
1.5 10.0 51246
2.0 15.3 69103
2.5 21.4 86901
3.0 28.2 104796
3.5 35.5 122772
4.0 43.4 140817
4.5 51.8 158924
5.0 60.7 177085
5.5 70.0 195296
6.0 79.7 213551
Use the data in this table to solve problems [1] through [14].
[1]. Use simple linear interpolation, through function interpln, to obtain the values of the
discharge Q for stage values of h = 0.25, 0.75, 1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25, 4.75,
5.25, and 5.75 ft.
[2]. Use simple linear interpolation, through function interpln, to obtain the values of the
storage S for stage values of h = 0.25, 0.75, 1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25, 4.75, 5.25,
and 5.75 ft.
[3]. Solve problem [1] using Lagrange polynomials of order n = 2,3, and 4.
[4]. Solve problem [2] using Lagrange polynomials of order n = 2, 3, and 4.
[5]. Produce a forward difference table for the Q-h data.
[6]. Produce a forward difference table for the S-h data.
[7]. Solve problem [1] using a Newton forward-difference polynomial.
[8]. Solve problem [2] using a Newton forward-difference polynomial.
[9]. Solve problem [1] using a Newton backward-difference polynomial.
[10]. Solve problem [2] using a Newton backward-difference polynomial.
[11]. Solve problem [1] using a Sterling centered-difference polynomial.

[12]. Solve problem [2] using a Sterling centered-difference polynomial.
[13]. Solve problem [1] using a Bessel centered-difference polynomial.
[14]. Solve problem [2] using a Bessel centered-difference polynomial.
Use the following SCILAB polynomials in the solution of problems [15] through [21]:
p = x3 + 3x - 2, q = x+2, r = x4-x3-x2-x-1, s = (2x+2)3-(5x+3)
[15]. Calculate the following polynomial operations:

(a) p+q (b) q+r (c) r+s (d) p+s (e)p-q (f) q-2r
(g) p+q+r (h) p-2r+q (i) q+2p-r (j) pq (k)pqr (l) pq + rs
(m) 2pq-r2 (n) (p+q)(r+s) (o) q3-x3 (p) p/q (q)r/q (r) q+2/p
[16]. Determine the quotient and residual of the following polynomial divisions
(a) p/q (b) r/q (c) s/q (d) (p+2s)/q (e) (s+q2)/q (f) r/p
[17]. Obtain an expression for the polynomial long division defined by the following
expressions. Use 5 terms in the expansion.
(a) 1/p (b) 1/q (c) 1/r (d) 1/s (e) p/q (f) q/p
(g) p/s (h) s/p (i) r/q (j) q/r (k) s/p (l) q/p2
[18]. Use function horner to evaluate the polynomials calculated in problem [15] at values of x
= 0, 2, 6, 10, and 20.
[19]. Determine the derivative of the polynomials obtained in problem [15] and evaluate those
derivatives at values of x = 0, 2, 6, 10, and 20.
[20]. Obtain the roots of the polynomials obtained in problem [15].
[21]. Use user-defined function intpoly to obtain the indefinite integrals of the polynomials
obtained in problem [15].
The following data shows the elevation of the bed surface in a flume, y(ft), against the
distance from one of the flume walls, x(ft). The data is to be used in problems [22] - [26].
x(ft) 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0

y(ft) 0.23 0.45 0.48 0.40 0.31 0.40 0.59 0.37
[22]. Use the 8 data points to generate a direct-fit polynomial of order 7 that fits the data.
Plot the original data and the fitted polynomial.
[23]. Fit Lagrange polynomials of orders 2, 3, 4, 5, and 6 to the bed profile data. Plot the
original data and the fitted polynomials.
[24]. Produce a forward difference table out of the bed profile data.

[24]. Use (a) a Newton forward-difference polynomial; (b) a Newton backward-difference
polynomial; (c) a Stirling centered-difference polynomial; and (d) a Bessel centered-difference
polynomial to obtain the bed elevation at points x = 2.75 ft and x = 3.65 ft.
[25]. Fit polynomials of order 2, 3, 4, 5, and 6 for the bed profile data, using a least-square
method.
[26]. Use cubic spline curves to fit the bed profile data. (a) Plot the original data and the
fitted splines. (b) Produce the equations of the cubic spline curves that fit the data.
The following data shows the peak monthly concentration of a certain hydrocarbon component,
C(ppm), measured in a monitoring well throughout the past year.
t(month) 0 1 2 3 4 5 6 7 8 9 10 11
C(ppm) 450 420 150 180 430 620 610 520 320 106 110 190
Use these data in problems [27] through [32].
[27]. Use the 12 data points to generate a direct-fit polynomial of order 11 that fits the data.
Plot the original data and the fitted polynomial.
[28]. Fit Lagrange polynomials of orders 2, 3, 4, 5, and 6 to the concentration-vs-time data.

Plot the original data and the fitted polynomials.
[29]. Produce a forward difference table out of the concentration-vs-time data.
[30]. Use (a) a Newton forward-difference polynomial; (b) a Newton backward-difference

polynomial; (c) a Stirling centered-difference polynomial; and (d) a Bessel centered-difference
polynomial to estimate the hydrocarbon concentration at times t = 2.5 months and t = 6.2
months.
[31]. Fit polynomials of order 2, 3, 4, 5, and 6 for the concentration-vs-time data, using a
least-square method.
[32]. Use cubic spline curves to fit the concentration-vs-time data. (a) Plot the original data
and the fitted splines. (b) Produce the equations of the cubic spline curves that fit the data.
[33]. Develop a SCILAB function to produce successive univariate polynomial approximation for
a function z = f(x,y) based on nine data points as illustrated in the following table:
x\y yk-1 yk yk+1

xm-1 z m-1,k-1 z m-1,k z m-1,k+1
xm z m,k-1 z m,k z m,k+1
xm+1 z m+1,k-1 z m+1,k z m+1,k+1
The table entries are values of zm,k = f(xm,yk). The function should use quadratic polynomials to
obtain the value of z0 = f(x0,y0), for xm-1 < x0 < xm+1, yk-1 < y0 < yk+1, along rows and then
columns, and vice versa. The function should return the values produced by the two
approaches for interpolation, as well as the average.

The following table represents the entropy, s(kJ/(kg K)), for superheated steam.
s(kJ/(kg K))
o
T( C)\P(kPa) 20 40 60 80 101.33
100 8.126 7.801 7.608 7.470 7.607
150 8.367 8.045 7.855 7.719 7.828
200 8.584 8.262 8.074 7.939 8.028
250 8.780 8.460 8.271 8.131 8.210
300 8.961 8.641 8.454 8.320 8.380
350 9.130 8.810 8.622 8.489 8.538
400 9.288 8.968 8.780 8.647 8.687
Use this table for problems [33] through [].
[33]. Using successive univariate polynomial interpolation with quadratic equations calculate
the value of the superheated steam entropy for the following cases:
(a) T = 156 oC, P = 42 kPa (b) T = 310 oC, P = 63 kPa

(c) T = 116 oC, P = 22 kPa (d) T = 156 oC, P = 42 kPa
(e) T = 210 oC, P = 92 kPa (f) T = 343 oC, P = 25 kPa
(g) T = 107 oC, P = 58 kPa (h) T = 280 oC, P = 88 kPa
(i) T = 155 oC, P = 42 kPa (j) T = 306 oC, P = 21 kPa
[34]. Solve problem [33] by fitting the given data to a function of the form
s(T,P) = b0 + b1T + b2P.
s(T,P) = b0 + b1T + b2P + b3S⋅P
s(T,P) = b0 + b1T + b2P + b3S⋅P + b4S2 + b5P2.
[37]. Data from radiation counts of a radioactive material is shown in the table below.
t, months 0 2 4 5.5 6 9 10 14 18
N, counts/hour 1260 794 500 454 315 158 125 50 20
The equation for the radiation count as a function of time is N(t) = N0 exp(-λt). Using the data
in the table above determine the values of the parameters N0 and λ, (a) using a simple linear
fitting of the linearized equation: ln(N) = -λt + ln(N0); and (b) using SCILAB function datafit for
the original equation, N = N0 exp(-λt). (c) Plot the original data against the data generated
from the fittings in (a) and (b). (d) The half-life of the radioactive material is that value of
time t for which the mass (or radiation count) falls by one half, i.e., N = N0/2. Determine the
half-life for this material.
[38]. The table below shows the flow velocity, v(fps), and suspended sediment concentration,
C(mg/l), as functions of the distance from the channel bed, y(ft), measured at a cross-section
of a 800-ft-wide (b = 800 ft), 7.8-ft-deep (h = 7.8 ft) river cross-section that can be
approximated by a rectangle.

y(ft) v(ft/s) C(mg/l)
0.7 4.30 411
0.9 4.50 380
1.2 4.64 305
1.4 4.77 299
1.7 4.83 277
2.2 5.12 238
2.7 5.30 217
2.9 5.40 211
3.2 5.42 196
3.4 5.42 188
3.7 5.50 184
4.2 5.60 165
4.8 5.60 148
5.8 5.70 130
6.8 5.95 80
(a) Fit the velocity data, v(y), to a logarithmic function, i.e., v(y) = b0 + b1ln(y). Plot the
original data and the fitted data in the same set of axes.
(b) Fit the concentration data, C(y), to a function of the form ln(C) = b0 + b1 ln((h-y)/y).
Plot the original data and the fitted data in the same set of axes.
[39]. For the data in problem [38], the flow discharge, Q(cfs), is defined by the integral
h
Q = ∫ v( y )dA = ∫ v( y ) ⋅ bdy,
A 0
with the mean flow velocity calculated as V = Q/A, where A = b⋅h being the cross-sectional
area. The total flux of suspended sediment through the cross-section is defined as
h
Qs = ∫ v( y ) ⋅ C ( y ) ⋅ dA = ∫ v( y ) ⋅ C ( y ) ⋅ bdy,
A 0
with the flux-averaged concentration given by Cf = Qs/Q.
The terms used in the definitions above are illustrated in the figure below:
(a) Determine the flow discharge, mean velocity, sediment flux, and flux averaged
concentration for the data given using for the integration the functions for v(y) and
C(y) obtained in problem [38]. Compare the results with those obtained in problem
[94], Chapter 7.

REFERENCES (for all SCILAB documents at InfoClearinghouse.com)
Abramowitz, M. and I.A. Stegun (editors), 1965,"Handbook of Mathematical Functions with Formulas, Graphs, and
Mathematical Tables," Dover Publications, Inc., New York.
Arora, J.S., 1985, "Introduction to Optimum Design," Class notes, The University of Iowa, Iowa City, Iowa.
Asian Institute of Technology, 1969, "Hydraulic Laboratory Manual," AIT - Bangkok, Thailand.
Berge, P., Y. Pomeau, and C. Vidal, 1984,"Order within chaos - Towards a deterministic approach to turbulence," John
Wiley & Sons, New York.
Bras, R.L. and I. Rodriguez-Iturbe, 1985,"Random Functions and Hydrology," Addison-Wesley Publishing Company,
Reading, Massachussetts.
Brogan, W.L., 1974,"Modern Control Theory," QPI series, Quantum Publisher Incorporated, New York.
Browne, M., 1999, "Schaum's Outline of Theory and Problems of Physics for Engineering and Science," Schaum's
outlines, McGraw-Hill, New York.
Farlow, Stanley J., 1982, "Partial Differential Equations for Scientists and Engineers," Dover Publications Inc., New
York.
Friedman, B., 1956 (reissued 1990), "Principles and Techniques of Applied Mathematics," Dover Publications Inc., New
York.
Gomez, C. (editor), 1999, “Engineering and Scientific Computing with Scilab,” Birkhäuser, Boston.
Gullberg, J., 1997, "Mathematics - From the Birth of Numbers," W. W. Norton & Company, New York.
Harman, T.L., J. Dabney, and N. Richert, 2000, "Advanced Engineering Mathematics with MATLAB® - Second edition,"
Brooks/Cole - Thompson Learning, Australia.
Harris, J.W., and H. Stocker, 1998, "Handbook of Mathematics and Computational Science," Springer, New York.
Hsu, H.P., 1984, "Applied Fourier Analysis," Harcourt Brace Jovanovich College Outline Series, Harcourt Brace
Jovanovich, Publishers, San Diego.
Journel, A.G., 1989, "Fundamentals of Geostatistics in Five Lessons," Short Course Presented at the 28th International
Geological Congress, Washington, D.C., American Geophysical Union, Washington, D.C.
Julien, P.Y., 1998,”Erosion and Sedimentation,” Cambridge University Press, Cambridge CB2 2RU, U.K.
Keener, J.P., 1988, "Principles of Applied Mathematics - Transformation and Approximation," Addison-Wesley
Publishing Company, Redwood City, California.
Kitanidis, P.K., 1997,”Introduction to Geostatistics - Applications in Hydogeology,” Cambridge University Press,

Cambridge CB2 2RU, U.K.
Koch, G.S., Jr., and R. F. Link, 1971, "Statistical Analysis of Geological Data - Volumes I and II," Dover Publications,
Inc., New York.
Korn, G.A. and T.M. Korn, 1968, "Mathematical Handbook for Scientists and Engineers," Dover Publications, Inc., New
York.
Kottegoda, N. T., and R. Rosso, 1997, "Probability, Statistics, and Reliability for Civil and Environmental Engineers,"
The Mc-Graw Hill Companies, Inc., New York.
Kreysig, E., 1983, "Advanced Engineering Mathematics - Fifth Edition," John Wiley & Sons, New York.
Lindfield, G. and J. Penny, 2000, "Numerical Methods Using Matlab®," Prentice Hall, Upper Saddle River, New Jersey.
Magrab, E.B., S. Azarm, B. Balachandran, J. Duncan, K. Herold, and G. Walsh, 2000, "An Engineer's Guide to
MATLAB®", Prentice Hall, Upper Saddle River, N.J., U.S.A.
McCuen, R.H., 1989,”Hydrologic Analysis and Design - second edition,” Prentice Hall, Upper Saddle River, New Jersey.

Middleton, G.V., 2000, "Data Analysis in the Earth Sciences Using Matlab®," Prentice Hall, Upper Saddle River, New
Jersey.
Montgomery, D.C., G.C. Runger, and N.F. Hubele, 1998, "Engineering Statistics," John Wiley & Sons, Inc.
Newland, D.E., 1993, "An Introduction to Random Vibrations, Spectral & Wavelet Analysis - Third Edition," Longman
Scientific and Technical, New York.
Nicols, G., 1995, “Introduction to Nonlinear Science,” Cambridge University Press, Cambridge CB2 2RU, U.K.
Parker, T.S. and L.O. Chua, , "Practical Numerical Algorithms for Chaotic Systems,” 1989, Springer-Verlag, New York.
Peitgen, H-O. and D. Saupe (editors), 1988, "The Science of Fractal Images," Springer-Verlag, New York.
Peitgen, H-O., H. Jürgens, and D. Saupe, 1992, "Chaos and Fractals - New Frontiers of Science," Springer-Verlag, New
York.
Press, W.H., B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, 1989, “Numerical Recipes - The Art of Scientific
Computing (FORTRAN version),” Cambridge University Press, Cambridge CB2 2RU, U.K.
Raghunath, H.M., 1985, "Hydrology - Principles, Analysis and Design," Wiley Eastern Limited, New Delhi, India.
Recktenwald, G., 2000, "Numerical Methods with Matlab - Implementation and Application," Prentice Hall, Upper
Saddle River, N.J., U.S.A.
Rothenberg, R.I., 1991, "Probability and Statistics," Harcourt Brace Jovanovich College Outline Series, Harcourt Brace
Jovanovich, Publishers, San Diego, CA.
Sagan, H., 1961,"Boundary and Eigenvalue Problems in Mathematical Physics," Dover Publications, Inc., New York.
Spanos, A., 1999,"Probability Theory and Statistical Inference - Econometric Modeling with Observational Data,"
Cambridge University Press, Cambridge CB2 2RU, U.K.
Spiegel, M. R., 1971 (second printing, 1999), "Schaum's Outline of Theory and Problems of Advanced Mathematics for
Engineers and Scientists," Schaum's Outline Series, McGraw-Hill, New York.
Tanis, E.A., 1987, "Statistics II - Estimation and Tests of Hypotheses," Harcourt Brace Jovanovich College Outline
Series, Harcourt Brace Jovanovich, Publishers, Fort Worth, TX.
Tinker, M. and R. Lambourne, 2000, "Further Mathematics for the Physical Sciences," John Wiley & Sons, LTD.,
Chichester, U.K.
Tolstov, G.P., 1962, "Fourier Series," (Translated from the Russian by R. A. Silverman), Dover Publications, New York.
Tveito, A. and R. Winther, 1998, "Introduction to Partial Differential Equations - A Computational Approach," Texts in
Applied Mathematics 29, Springer, New York.
Urroz, G., 2000, "Science and Engineering Mathematics with the HP 49 G - Volumes I & II", www.greatunpublished.com,
Charleston, S.C.
Urroz, G., 2001, "Applied Engineering Mathematics with Maple", www.greatunpublished.com, Charleston, S.C.
Winnick, J., , "Chemical Engineering Thermodynamics - An Introduction to Thermodynamics for Undergraduate

Engineering Students," John Wiley & Sons, Inc., New York.

Scilab08 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Scilab08 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Data Fitting and Interpolation with

Gilberto E. Urroz, Ph.D., P.E.

©2001 Gilberto E. Urroz

The author's SCILAB web page can be accessed at:

Please report any errors in this document to: gurro@cc.usu.edu

Simple linear interpolation 2

Numerical Methods with Polynomials 15

Multi-variate data fitting 49

Download at InfoClearinghouse.com 1 © 2001 Gilberto E. Urroz

Simple linear interpolation

Download at InfoClearinghouse.com 2 © 2001 Gilberto E. Urroz

Next, we use function interpln to interpolate a vector of values:

-->xx = [1.5, 2.5, 3.5, 4.5, 5.5]

! 1.5 2.5 3.5 4.5 5.5 !

! 3.5 5.5 7. 9. 10.5 !

-->ymax1 = max(TableXY(2,:)) //Max & min values of y

-->rect = [0,0,6,11]; // define the plot rectangle

-->plot2d(TableXY(1,:),TableXY(2,:),9,’011’,’y’,rect) //Plot table

-->plot2d(xx,yy,-9,'010','y',rect) //Plot interpolated data

-->xtitle('linear interpolation','x','y') //Place title

Download at InfoClearinghouse.com 3 © 2001 Gilberto E. Urroz

Defining a polynomial variable

-->s=poly(0,'s') //Defining variable s as a polynomial

-->s+2 //Simple algebraic operation

-->y = (s+2)^2 //Defining a new polynomial (y)

Identifying the polynomial variable, degree, and coefficients

Download at InfoClearinghouse.com 4 © 2001 Gilberto E. Urroz

-->x=poly(0,'x') //Define polynomial variable

-->p = 3.5*x^2+2*x-5 //Create a polynomial

-->c = coeff(p) //Determine the coefficients of the polynomial

Some operations with polynomials

Polynomials in the same variable can be added:

The next statement defines a polynomial q out of a multiplication of monomial expressions:

Download at InfoClearinghouse.com 5 © 2001 Gilberto E. Urroz

Polynomial long division

This result is to be interpreted in the following manner:

The following example uses the polynomials p and q defined earlier:

Download at InfoClearinghouse.com 6 © 2001 Gilberto E. Urroz

Download at InfoClearinghouse.com 7 © 2001 Gilberto E. Urroz

-->A = [ s+1 s-2; (s+1)^2 s^2/2]

Determinant of a polynomial matrix

Inverse of a polynomial matrix

Download at InfoClearinghouse.com 8 © 2001 Gilberto E. Urroz

The result verifies that the matrix is indeed an identity matrix.

Evaluating a polynomial or polynomial matrix

Download at InfoClearinghouse.com 9 © 2001 Gilberto E. Urroz

Characteristic matrix and characteristic equations

The characteristic matrix is calculated as B-s⋅I3×3:

Polynomial functions applied to polynomial matrices

-->M = [(2-s)/(s^2+s) s^2; 1/(s+1) (s+1)/(s+2)]

Download at InfoClearinghouse.com 10 © 2001 Gilberto E. Urroz

This introduction to polynomials in SCILAB is by no means a comprehensive one. Polynomials

First, define the polynomial variable x:

Next, we obtain the derivatives of functions y = x, y = x2, y = 1/x, and y = 2x3-2x:

Download at InfoClearinghouse.com 11 © 2001 Gilberto E. Urroz

A rational expression is simply a fraction or combination of fractions involving polynomials.

Generating a polynomial given its coefficients

Pn(x) = ao + a1x + a2x2 + …+ an-1x n-1

-->p = poly([3. -5. 1.],"x","coeff")

-->v = [4. -2. -1. 7.];

Download at InfoClearinghouse.com 12 © 2001 Gilberto E. Urroz

Generating a polynomial given its roots

-->q = poly([1. 1. -1.],"z","roots")

-->p = 3.5x^2+2x-5 //Create a polynomial