Chapter 5 1 An Engineer’s Guide to MATLAB Copyright © Edward B. Magrab 2009 AN ENGINEER’S GUIDE...

Copyright © Edward B. Magrab 2009

Chapter 5

1

An Engineer’s Guide to MATLAB

AN ENGINEER’S GUIDE TO MATLAB

3rd Edition

CHAPTER 5

FUNCTION CREATION AND SELECTED MATLAB FUNCTION


Chapter 5

2


Chapter 5 – Objectives

• Describe how functions are created and give numerous examples of MATLAB functions that are frequently used to obtain numerical solutions to engineering problems.


Chapter 5

3


Topics

• Introduction Why Use Functions Naming Functions Length of Functions Debugging Functions

• Creating Functions Introduction Function File Sub Functions Anonymous inline

• User Defined Functions, Function Handles, and feval


Chapter 5

4


• MATLAB Functions That Operate on Arrays of Data Fitting Data With Polynomials—polyfit/polyval Fitting Data With spline Interpolation of Data—interp1 Numerical Integration—trapz Area of a Polygon—polyarea Digital Signal Processing—fft and ifft


Chapter 5

5


• MATLAB Functions That Require User-Created Functions Zeros of Functions—fzero and roots/poly Numerical Integration—quadl and dblquad Numerical Solutions of Ordinary Differential Equations

—ode45 Numerical Solutions of Ordinary Differential Equations

—bvp4c Numerical Solutions of Delay Differential Equations—dde23 Numerical Solutions of One-dimensional Parabolic-

elliptic Partial Differential Equations—pdepe Local Minimum of a Function—fminbnd Numerical Solutions of Nonlinear Equations—fsolve

• Symbolic Toolbox and the Creation of Functions


Chapter 5

6


Introduction –

Function files are script files that create their own local and independent workspace within MATLAB.

Variables defined within a function are local to that function.

They neither affect nor are they affected by the same variable names being used in any script or other function.

All of MATLAB’s functions are of this type.

The exception is those variables that are designated global variables.

The first non-comment line of a function must follow a prescribed format.


Chapter 5

7


Why Use Functions –• Avoid duplicate code.

• Limit the effect of changes to specific sections of a program.

• Promote program reuse.

• Reduce the complexity of the overall program by making it more readable and manageable.

• Isolate complex operations.

• Improve portability.

• Make debugging and error isolation easier.

• Improve performance because each function can be “optimized”.


Chapter 5

8


Naming Functions

•The names of functions should be chosen so that they are meaningful and indicate what the function does.

•Typical lengths of function names are between 9 and 20 characters and should employ standard or consistent conventions.

•The proper choice of function names can also minimize the use of comments within the function itself.


Chapter 5

9


Length of Functions

• The length of a function can vary from two lines of code to hundreds of lines of code.

• The length of a function should be governed, in part, by its functional cohesion – The degree to which it does one thing and not

anything else.

• A function can be created with numerous highly cohesive functions to create another cohesive function.

• Highly cohesive functions are reliable – lower error rate

• When functions have a low degree of cohesion, one often encounters difficulty in isolating errors.


Chapter 5

10


• The compartmentalization brought about by the use of functions also tends to minimize the unintended use of data by portions of the program, because data to each function is provided only on a need-to-know basis.


Chapter 5

11


Four Ways to Create Functions

Function file

Created by the function command, saved in a file, and subsequently accessed by scripts and functions or from the command window.

Sub function

When the function keyword is used more than once in a function file, then all the additional functions created after the first function keyword are called sub functions.

The sub functions are only accessible by the main function of the function file and the other sub functions within the main function file.


Chapter 5

12


Sub function - continued

They are used to reduce function file proliferation while maintaining the features and uses of a function.

Anonymous function

A means of creating functions for simple expressions without having to create M-files or sub functions.

It is accessible only from the script or function in which it was created.

An anonymous function can appear in another anonymous function.

An anonymous function doesn't have to be saved in a separate file.


Chapter 5

13


inline function

Created with the inline command and limited to one MATLAB expression.

It is accessible only from the script or function in which it was created.

The MATLAB expression can not refer to other inline functions or sub functions.


Chapter 5

14


Function File –

• A function that is going to reside in a function file has at least two lines of program code.

The first line has a format required by MATLAB.

• There is no terminating character or expression for the function program such as the end statement.

• The name of the M-file should be the same as the name of the function, except that the file name has the extension “.m”.


Chapter 5

15


The number of variables and their type (scalar, vector, matrix, string, cell) that are brought in and out of the function are controlled by the function interface, which is the first non-comment line of the function program.

In general, a function file will consist of the interface line, some comments and one or more expressions as shown below.

The interface has the general form:


Chapter 5

16


function [OutputVariables] = FunctionName(InputVariables)% CommentsExpression(s)

where

OutputVariables is a comma-separated list of the names of the output variables.

InputVariables is a comma-separated list of the names of the input variables.

The function file may be stored in any directory and has the file name FunctionName.m

function [a, b, …] = FunctionName(V1, V2, V3, …)


Chapter 5

17


Special Case 1

Functions can be used to create a figure, to display annotated data to the command window, or to write data to files.

In these cases, no values are transferred back to the calling program, which is a script or another function that uses this function in one or more of its expressions.

In this case, the function interface line becomes

function FunctionName(InputVariables)



Chapter 5

18


Special Case 2

When a function is used only to store data in a prescribed manner, the function does not require any input arguments.

In this case, the function interface line has the form

function [OutputVariables] = FunctionName



Chapter 5

19


Special Case 3

When a function converts a script to a main function so that one can decrease the number of function M-files, the function interface line has the form

function FunctionName



Chapter 5

20


About Functions –

There are several concepts that must be understood to correctly create functions.

• The variable names used in the function definition do not have to match the corresponding names when the function is called from the command window, a script, or another function.

• It is the locations of the input variables within the argument list inside the parentheses that govern the transfer of information—that is, the first argument in the calling statement transfers its value(s) to the first argument in the function interface line, and so on.

function FunctionName(V1,V2,V3, …)


Chapter 5

21


• The names selected for each argument are local to the function program and have meaning only within the context of the function program.

• The same names can be used in an entirely different context in the script file that calls this function or in another function used by this function.

However, the names appearing for each input variable of the function statement must be the same type, either scalar, vector, matrix, cell, or string, in the calling program as in the function program in order for the function’s expressions to work as intended.

• The variable names are not local to the function only when they have been assigned as global variables using

globalfunction FunctionName(V1,V2,V3, …)


Chapter 5

22


Construction of a Function –

Consider the following two equations that are to be computed in a function.

= cos( ) +

= +

x at b

y x c

The values of x and y are to be returned by the function.

The function will be named ComputeXY and saved in a file named ComputeXY.m.


Chapter 5

23


function [x, y] = ComputeXY(t, a, b, c)% Computation of -% x = cos(at)+b% y = |x|+c% Scalars: a, b, c% Vectors: t, x, yx = cos(a*t)+b;y = abs(x)+c;

When one types in the MATLAB command window

help ComputeXY

the following is displayed Computation of - x = cos(at)+b y = |x|+cScalars: a, b, cVectors: t, x, y


Chapter 5

24


If we type in the MATLAB command window

[u, v] = ComputeXY(0:pi/4:pi, 1.4, 2, 0.75)

we obtain

u = 3.0000 2.4540 1.4122 1.0123 1.6910v= 3.7500 3.2040 2.1622 1.7623 2.4410

function [x, y] = ComputeXY(t, a, b, c)x = cos(a*t)+b;y = abs(x)+c;

= cos( ) +

= +

x at b

y x c


Chapter 5

25


Variations of the function statement -[u, v] = ComputeXY(t, a, b, c)

= cos( ) +

= +

x at b

y x c

Function

Accessing function from script or function

Comments

function z = ComputeXY(t, w)

x = cos(w(1)*t)+w(2); z = [x; abs(x)+w(3)];

t = 0:pi/4:pi; w = [1.4, 2, 0.75]; q = ComputeXY(t, w);

w(1) = a = 1.4; w(2) = b = 2; w(3) = c = 0.75; q (25) x(:) = q(1,1:5); y(:) = q(2,1:5)

function z = ComputeXY(t, w)

x = cos(w(1)*t)+w(2); z = [x abs(x)+w(3)];


w(1) = a = 1.4; w(2) = b = 2; w(3) = c = 0.75; q (110) x(:) = q(1:5); y(:) = q(6:10)

function [x, y] = ComputeXY(t, w)

x = cos(w(1)*t)+w(2); y = abs(x)+w(3);


w(1) = a = 1.4; w(2) = b = 2; w(3) = c = 0.75; q (15) x = q; y not available§

§ Many of the MATLAB functions make use of this form.


Chapter 5

26


global

In some instances, the number of different variables that are transferred to a function can become large.

In these cases, it may be beneficial for the function to share the global memory of the script or function or to create access to global variables for use by various functions.

This access is provided by

global


Chapter 5

27


Example –

Let us transfer the values of a, b, and c in the function ComputeXY as global variables

The script is modified as follows

function [x, y] = ComputeXY(t)global A B Cx = cos(A*t)+B;y = abs(x)+C;

The blank spaces between the global variable names must be used instead of commas.


Chapter 5

28


The script to call this function becomes

global A B CA = 1.4; B = 2; C = 0.75;[u, v] = ComputeXY(0:pi/4:pi)


Chapter 5

29


Example –

Since the arguments in the function definition are placeholders for the numerical values that will reside in their respective places when the function is executed, we can insert any correctly constructed MATLAB expression in the calling statement.

To illustrate this, let us use ComputeXY to determine the values of x and y for

31.8

= = 1, ...,1 +

a k nk

when t varies from 0 to in increments of /4, c = 1/0.85, b has k values that range from 1 to 1.4 and n = 3.


Chapter 5

30


Without global variables –

If

function [x, y] = ComputeXY(t, a, b, c)x = cos(a*t)+b;y=abs(x)+c;

then the script without global variables is

n = 3; b = linspace(1, 1.4, n); c = 1/.85;for k = 1:n [u, v] = ComputeXY(0:pi/4:pi, sqrt(1.8/(1+k)^3), b(k), c)end

31.8

= = 1, ...,1 +

a k nk


Chapter 5

31


With global variables –

If

function [x, y] = ComputeXY(t)global A B C x = cos(A*t)+B;y=abs(x)+C;

then the script with global variables is

global A B C n = 3; C = 1/.85; b = linspace(1, 1.4, n);for k = 1:n B=b(k); A = sqrt(1.8/(1+k)^3); [u, v] = ComputeXY(0:pi/4:pi)end


Chapter 5

32


Sub Functions

• When the function keyword is used more than once in a function file, all the additional functions created after the first function key word are called sub functions.

• The expressions comprising the first use of the function keyword is called the main function.

It is the only function that is accessible from the command window, scripts, and other function files.

• The sub functions are accessible only to the main function and to other sub functions within the main function file.


Chapter 5

33


Example –

Compute the mean and standard deviation of a vector of numerical values.

We shall compute these quantities in a relatively inefficient manner in order to illustrate the properties and use of sub functions.

The mean m and the standard deviation s are given by

=1

1/2

2 2

=1

1

1

-1

n

kk

n

kk

m = xn

s = x - nmn


Chapter 5

34


function [m, s] = MeanStdDev(dat) % Main functionn = length(dat);m = meen(dat, n);s = stdev(dat, n);

function m = meen(v, n) % Sub functionm = sum(v)/n;

function sd = stdev(v, n) % Sub functionm = meen(v, n); % Calls a sub functionsd = sqrt((sum(v.^2)-n*m^2)/(n-1));

A script that uses this function and sub functions is

v = [1, 2 , 3, 4];[m, s] = MeanStdDev(v)

1/2

2 2

=1

1

-1

n

kk

s = x - nmn

=1

1 n

kk

m = xn


Chapter 5

35


Anonymous Function –

The general form of an anonymous function is

functionhandle = @(arguments)(expression)

where

functionhandle is the function handle

arguments is a comma-separated list of variable names

expression is a valid MATLAB expression

Any parameters that appear in expression and do not appear in arguments must be given a numerical value prior to this statement.


Chapter 5

36


A function handle is a way of referencing a function and is used as a means of invoking the anonymous function and as a means to pass the function as an argument in functions, which then evaluates it using feval.

Example –

Let us create an anonymous function that evaluates the expression

cos( )xc x

at = /3 and x = 4.1.


Chapter 5

37


Example continued –

The anonymous function is created with the following script.

bet = pi/3; % Reminder: parameter must be defined prior to anonymous function definition

cx = @(x) (abs(cos(bet*x)));disp(cx(4.1))

which, upon execution, gives

0.4067

This anonymous function could have also been created as having two arguments: and x. In this case,

cx = @(x, bet) (abs(cos(bet*x)));disp(cx(4.1, pi/3))


Chapter 5

38



We can also use this anonymous function directly in another anonymous function.

Let us create an anonymous function that determines the cube root.

Then

cx = @(x, bet) (abs(cos(bet*x)));crt = @(x) (x^(1/3));disp(crt(cx(4.1, pi/3)))

which, upon execution, results in

0.7409


Chapter 5

39


Example –

Consider the creation of an anonymous function that evaluates a two-element column vector v where

2 211

221

/ 4 1

4 3

v x y

v y x

In this case, the anonymous function can be created two ways. The first way is

v = @(x, y) ([0.25*x.^2+y.^2-1; y-4*x.^2+3]);a = v(1, 2);disp(['v(1,1) = ' num2str(a(1)) ' v(2,1) = '

num2str(a(2))])


v(1,1) = 3.25 v(2,1) = 1


Chapter 5

40



The second way is

v = @(xy) ([0.25*xy(1).^2+xy(2).^2-1; xy(2)-

4*xy(1).^2+3]);a = v([1, 2]);disp(['v(1,1) = ' num2str(a(1)) ' v(2,1) = '

num2str(a(2))])

where xy(1) = x = 1 and xy(2) = y = 2.

Execution of this program produces the previous results.


Chapter 5

41


inline• Can be created either in the command window, a

script, or a function.

• Is not saved in a separate file.

• Limitations Cannot call another inline function, but it can

use a user-created function existing as a function file.

Is composed of only one expression. It can bring back only one variable—that is, the

form [u, v] is not allowed. Any function requiring logic or multiple operations

to arrive at the result cannot employ inline.


Chapter 5

42


The general form of inline is

FunctionName = inline('expression', 'p1','p2',…)

where expression is any valid MATLAB expression converted to a string and p1, p2, … are the names of all the variables appearing in expression.

All single quotes are required as shown.


Chapter 5

43


Example –

Let us create a function FofX that evaluates

2( ) = cos( ) -f x x ax b

where a and b are scalars and x is a vector.

Then typing in the command window

FofX = inline('x.^2.*cos(a*x)-b', 'x', 'a', 'b')

displays

FofX = Inline function: FofX(x,a,b) = x.^2.*cos(a*x)-b


Chapter 5

44


When we type the following expression in the command window

g = FofX([pi/3, pi/3.5], 4, 1) % FofX(x,a,b)

the system responds with

g = -1.5483 -1.7259

2( ) = cos( ) -f x x ax b

FofX = inline('x.^2.*cos(a*x)-b', 'x', 'a', 'b')


Chapter 5

45


Comparison of the Usage of Sub Functions, Anonymous Functions, and Inline Functions

Sub functions Anonymous functions inline

function Example dat = 1:3:52; n = length(dat); m = meen(dat, n) s = stdev(dat, n)

function m = meen(v, n) m = sum(v)/n;

function sd = stdev(v, n) m = meen(v, n); sd = sqrt((sum(v.^2)- n*m^2)/(n-1));

function Example dat = 1:3:52; n = length(dat); meen = @(dat, n) (sum(dat)/n); stdev = @(dat, n, m)

(sqrt((sum(dat.^2) -n*m^2)/(n-1))); m = meen(dat, n) s = stdev(dat, n, m)

function Example dat = 1:3:52; n = length(dat); meen = inline ('sum(dat)/n ', 'dat', 'n'); stdev = inline ('sqrt((sum(dat.^2)-n*m^2)/(n-1))',

'dat', 'n', 'm'); m = meen(dat, n) s = stdev(dat, n, m)


Chapter 5

46


User-defined Functions, Function Handles, and feval

Many MATLAB functions require the user to create functions in a form specified by that MATLAB function.

These functions use

feval(FunctionHandle, p1, p2,…, pn)

where FunctionHandle is the function handle and p1, p2, … are parameters that are to be passed to the function represented by FunctionHandle.

A function handle is a means of referencing a function and is used so that it can be passed as an argument in functions, which then evaluate it using feval.

A function handle is constructed by placing an ‘@’ in front of the function name.


Chapter 5

47


Example – Interval Halving for an Arbitrary Function

We shall modify the interval halving root finding program that was presented in Chapter 4 so that it is able to determine the first n roots of an arbitrary function.

Let us assume that the function to be analyzed is

and that it resides in a function called CosBeta that is saved in a file CosBeta.m.

Thus,

function d = CosBeta(x, w)% beta = w(1); alpha = w(2)d = cos(x*w(1))-w(2);

( ) = cos( ) - < 1f x βx α α


Chapter 5

48


function nRoots = ManyZeros(zname, n, xs, toler, dxx, [b, a])x = xs;dx = dxx;for m = 1:n s1 = sign(feval(zname, x, w)); while dx/x >toler if s1 ~= sign(feval(zname, x+dx, w)) dx = dx/2; else x = x+dx; end end nRoots(m) = x; dx = dxx; x = 1.05*x;end

s1 = sign(cos(a*x));while dx/x > tolerance

if s1 ~= sign(cos(a*(x+dx)))dx = dx/2;

elsex = x+dx;

endend

function d = CosBeta(x, w)d = cos(x*w(1))-w(2);


Chapter 5

49


The program that uses these functions is

NoRoots = 5; xStart = 0.2;tolerance = 1e-6; increment = 0.3;beta = pi/3; a = 0.5;c = ManyZeros(@CosBeta, NoRoots, xStart, … tolerance, increment, beta, a)

The execution of the script displays to the command window

c = 1.0000 5.0000 7.0000 11.0000 13.0000

function d = CosBeta(x, w)d = cos(x*w(1))-w(2);

ManyZeros(zname, n, xs, toler, dxx, b, a)


Chapter 5

50


function nRoots = ManyZeros(zname, n, xs, toler, dxx, w) x = xs; dx = dxx; ... for m = 1:n s1 = … while dx/x >toler if s1 ~= sign(feval(zname, x+dx, w)) … end … end … end

function f = CosBeta(x, w) f = cos(w(1)*x)-w(2)

function ExampleFeval NoRoots = 5; xStart = 0.2; tolerance = 1e-6; increment = 0.3; beta = pi/3; a = 0.5; c = ManyZeros(@CosBeta, NoRoots, xStart, tolerance, increment, [beta, a])


Chapter 5

51


MATLAB Functions That Operate on Arrays of Data –

polyfit Fits a polynomial to an array of values.

polyval Evaluates a polynomial at an array of values.

spline Applies cubic spline interpolation to arrays of coordinate values.

interp1 Interpolates between pairs of coordinate values.

trapz Approximates an integral from an array ofamplitude values.

polyarea Determines the area of a polygon.

fft/ifft Determines the Fourier transform and itsinverse from sampled data.


Chapter 5

52


Fitting Data with Polynomials—polyfit/polyval

Consider the polynomial -1

1 2 +1( ) = + +…+ +n nn ny x c x c x c x c

The coefficients ck are determined from

c = polyfit(x, y, n)

where

n is the order of the polynomial

c = [c1 c2 … cn cn+1] is a vector of length n+1 representing the coefficients of the polynomial

x and y are each vectors of length m n + 1:

They are the data to which the polynomial is fitted.


Chapter 5

53


To evaluate the polynomial once we have determined c, we use

y = polyval(c, xnew)

where

c is a vector of length n+1 that has been determined from polyfit

xnew is either a scalar or a vector of points at which the polynomial will be evaluated

In general, the values of xnew in polyval can be arbitrarily selected and may or may not be the same as those values given by x.


Chapter 5

54


These expressions can be combined as

y = polyval(polyfit(x, y, n), xnew)

if the coefficients ck are not of interest.

0 2 4 6 8 10 12-40

-30

-20

-10

0

10

20

x & y arraysxnew & polyval(polyfit(x, y, n), xnew) array


Chapter 5

55


Example - Neuber’s Constant for the Notch Sensitivity of Steel

A notch sensitivity factor q for metals can be defined in terms of a Neuber’s constant a and the notch radius r as

-1

= 1+a

qr

The value of a is different for different metals, and is a function of the ultimate strength Su of the material.

The a can be estimated by fitting a polynomial to experimentally obtained data of a as a function of Su for a given metal.

Once we have this polynomial, we can determine the value of q for a given value of r and Su.


Chapter 5

56


Some Data

We create a function to store these data

function nd = NeuberDatand = [0.34, 0.66; 0.48, 0.46; 0.62, 0.36; 0.76, 0.29; …

0.90, 0.23; 1.03, 0.19; 1.17, 0.14; 1.31, 0.10; …

1.45, 0.075; 1.59, 0.050; 1.72, 0.036];

where nd(:,1) = Su and nd(:,2) = a

Su (GPa) a ( mm ) Su (GPa) a ( mm ) 0.34 0.48 0.62 0.76 0.90 1.03

0.66 0.46 0.36 0.29 0.23 0.19

1.17 1.31 1.45 1.59 1.72

0.14 0.10 0.075 0.050 0.036


Chapter 5

57


ncs = NeuberData;c = polyfit(ncs(:,1), ncs(:,2), 4);r = input('Enter notch radius (0 < r < 5 mm) ');Su = input('Enter ultimate strength of steel

(0.3 < Su < 1.7 GPa) ');q = 1/(1+polyval(c, Su)/sqrt(r));disp(['Notch sensitivity = ' num2str(q)])

Executing this script yields

Enter notch radius (0 < r < 5 mm) 2.5Enter ultimate strength of steel (0.3 < Su < 1.7 GPa) 0.93Notch sensitivity = 0.879

nd(:,1) = Su

nd(:,2) = a

-1

= 1+a

qr


Chapter 5

58


Fitting Data with spline -

To generate smooth curves that pass through a set of discrete data values we use splines.

The function that performs this curve generation is

Y = spline(x, y, X)

where

y is y(x)

x and y are vectors of the same length that are used to create the functional relationship y(x)

X is a scalar or vector for which the values of Y = y(X) are desired

In general, x X.


Chapter 5

59


Example - Fitting Data to an Exponentially Decaying Sine Wave

We shall generate some exponentially decaying oscillatory data and then fit these data with a series of splines.

The data will be generated by sampling the following function over a range of non-dimensional times for < 1.0

2

2( , ) sin 1

1

ef

where2

1 1tan


Chapter 5

60


We create the following function M file to generate the data.

function f = DampedSineWave(tau, xi)r = sqrt(1-xi^2);phi = atan(r/xi);f = exp(-xi*tau).*sin(tau*r+phi)/r;

Let us sample 12 equally-spaced points of f(,) over the range 0 20 and plot the resulting piece-wise polynomial using 200 equally-spaced values of .

We shall also plot the original waveform and assume that = 0.1.

2

2

21

( , ) sin 11

1tan

ef


Chapter 5

61


n = 12; xi = 0.1;tau = linspace(0, 20, n);data = DampedSineWave(tau, xi);newtau = linspace(0, 20, 200);yspline = spline(tau, data, newtau);yexact = DampedSineWave(newtau, xi);plot(newtau, yspline, 'r--', newtau, yexact, 'k-')

Y = spline(x, y, X)

0 2 4 6 8 10 12 14 16 18 20-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1


Chapter 5

62


Interpolation of Data—interp1

To approximate the location of a value that lies between a pair of data points, we must interpolate.

The function that does this interpolation is

V = interp1(u, v, U)

where the array V will have the same length as U,

v is v(u)

u and v are vectors of the same length

U is a scalar or vector of values for u for which V desired

In general, u U.


Chapter 5

63


0 0.5 1 1.5 2 2.5 3 3.5-1.5

-1

-0.5

0

0.5

1

x

y

y = interp1(x, y, 1.15) = -0.113

x = interp1(y, x, -1) = 2.04

Data valuesInterpolated values


Chapter 5

64


Example - First Zero Crossing of an Exponentially Decaying Sine Wave

We shall create 15 pairs of data values for the exponentially decaying sine wave in the range 0 4.5 by using DampedSineWave with = 0.1 and use interp1 to approximate the value of for whichf(,) 0.

The script is

xi = 0.1;tau = linspace(0, 4.5, 15);data = DampedSineWave(tau, xi);TauZero = interp1(data, tau, 0)

0 1 2 3 4 5 6 7-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1


Chapter 5

65


The execution of the script gives

TauZero = 1.6817

The exact answer is obtained from

21

2

11tan 1.6794

1o

22 1

2

1( , ) sin 1 tan 0

1

ef

or


Chapter 5

66


Numerical Integration—trapz

One can obtain an approximation to a single integral using trapz, whose form is

Area = trapz(x, y)

where

x and the corresponding values of y are arrays

The function performs the summation of the product of the average of adjacent y values and the corresponding x interval separating them.


Chapter 5

67


Example - Area of an Exponentially Decaying Sine Wave

We shall determine the net area about the x-axis of the exponentially decaying sine wave in the region 0 20 for = 0.1 and for 200 data points.

xi = 0.1; N = 200;tau = linspace(0, 20, N);ftau = DampedSineWave(tau, xi);Area = trapz(tau, ftau)

Execution of this script gives

Area = 0.3021

0 5 10 15 20-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1


Chapter 5

68



To determine the area of the positive and negative portions of the waveform, we use logical functions to isolate the negative and positive portions of the waveform as follows.

xi = 0.1; tau = linspace(0, 20, 200);ftau = DampedSineWave(tau, xi);Logicp = (ftau >= 0);PosArea = trapz(tau, ftau.*Logicp);Logicn = (ftau < 0);NegArea = trapz(tau, ftau.*Logicn);disp(['Positive area = ' num2str(PosArea)])disp(['Negative area = ' num2str(NegArea)])disp([['Net area = ' num2str(PosArea+NegArea)]])


Chapter 5

69


Upon execution, we obtain

Positive area = 2.9549Negative area = -2.6529Net area = 0.30207


Chapter 5

70


Example - Length of a Line in Space

Consider the following integral from which the length of a line in space can be approximated

2 2 2

2 2 2

=1

= + + Δ + Δ + Δb N

i i iia

dx dy dzL dt x y z

dt dt dt

where+1

+1

+1

Δ = ( ) - ( )

Δ = ( ) - ( )

Δ = ( ) - ( )

i i i

i i i

i i i

x x t x t

y y t y t

z z t z t

and t1 = a and tN+1 = b


Chapter 5

71


We shall employ the function

diff

which computes the difference between successive elements of a vector; that is, for a vector

x = [x1 x2 … xn]

diff creates a vector q with n 1 elements of the form

q = [x2x1, x3x2, … , xnxn-1]

For a vector x, diff is simply

q = x(2:end)-x(1:end-1);


Chapter 5

72


Let

2

2

ln

x = t

y = t

z = t

for 1 t 2 and assume that N = 25.

We see that the quantities ix, iy, and iz, can each be evaluated with diff.

The script is

t = linspace(1, 2, 25);L = sum(sqrt(diff(2*t).^2+diff(t.^2).^2+diff(log(t)).^2))

which, upon execution, yields L = 3.6931


Chapter 5

73


Area of a Polygon—polyarea

One can obtain the area of an n-sided polygon, where each side of the polygon is represented by its end points, with the use of

polyarea(x, y)

where x and y are vectors of the same length that contain the (x, y) coordinates of the endpoints of each side of the polygon.

Each (x, y) coordinate pair is the end point of two adjacent sides of the polygon; hence, for an n-sided polygon, we need n + 1 pairs of end points.


Chapter 5

74


Example – Polygon Whose Vertices Lie on an Ellipse

We shall determine the area of a polygon whose vertices lie on the ellipse given by the parametric equations

cos

sin

x a

y b

If we let a = 2, b = 5, and we create a polygon with 10 sides, then the script is

a = 2; b = 5; t = linspace(0, 2*pi, 11);x = a*cos(t); y = b*sin(t);disp(['Area = ' num2str(polyarea(x, y))])


Area = 29.3893

(Aellipse = ab = 31.416)


Chapter 5

75


Digital Signal Processing—fft and ifft

The Fourier transform of a real function g(t) that is sampled every t over an interval 0 t T can be approximated by its discrete Fourier transform

0 5 10 15 20 25 30 350

0.2

0.4

0.6

0.8

1

1.2

1.4

1.6

1.8

t = kt

t = T/N<1/(2fh)

g0

g1

g2

gN-1

gN-2

gk

t

g k = g

(k t

)

1,...,1,0 )(1

0

/2

NnegtfnGGN

k

Nnkjkn

gk = g(kt)

f = 1/T

N = 2m (m = positive integer)

T = Nt

t = 1/(fh) ( >2)

fh = highest frequency in g(t)


Chapter 5

76


The inverse Fourier transform is approximated by1

2 /

0

0,1,..., 1N

j nk Nk n

n

g f G e k N

In order to estimate the magnitude of the amplitude An corresponding to each Gn at its corresponding frequency nf, one multiplies Gn by f. Thus,

n nA fG

1,...,1,0 1 1

0

/2

NnegN

AN

k

Nnkjkn

and, therefore,

One often plots |An| as a function of nf to obtain an amplitude spectral plot. In this case, we have that

2 0,1,..., / 2 1n nsA A n N


Chapter 5

77


These expressions are best evaluated using the fast Fourier transform (FFT), which is most effective when N = 2m, where m is a positive integer.

The FFT algorithm is implemented with

G = fft(g, N)

and its inverse with

g = ifft(G, N)

where G = Gn/t and g = gk/f.


Chapter 5

78


Example - Fourier Transform of a Sine Wave

Let us determine an amplitude spectral plot of a sampled sine wave of duration T under the following conditions.

( ) sin(2 ) 0 2 2 0,1,2,...K Ko o o hg t B f t t T f f K

and

2 and 1mt T m K

We assume that Bo = 2.5, fo = 10 Hz, K = 5, and m = 10 (N = 1024). The script is


Chapter 5

79


k = 5; m = 10; fo = 10; Bo = 2.5;N = 2^m; T = 2^k/fo;ts = (0:N-1)*T/N;df = (0:N/2-1)/T;SampledSignal = Bo*sin(2*pi*fo*ts);An = abs(fft(SampledSignal, N))/N;plot(df, 2*An(1:N/2))

0 20 40 60 80 100 120 140 1600

0.5

1

1.5

2

2.5


Chapter 5

80


MATLAB Functions That Require User-Created Functions

fzero Finds one root of f(x) = 0.

roots Finds the roots of a polynomial

quadl Numerically integrates f(x) in a specified interval.

dblquad Numerically integrates f(x,y) in a specified region.

ode45 Solves a system of ordinary differential equations with prescribed initial conditions.

bvp4c Solves a system of ordinary differential equations with prescribed boundary conditions.

dde23 Solves delay differential equations with constantdelays and with prescribed initial conditions.

pdepe Numerical solutions of one-dimensional parabolic-elliptic partial differential equations.

fminbnd Finds a local minimum of f(x) in a specified interval.

fsolve Solves numerically a system of nonlinearequations (from the Optimization toolbox).


Chapter 5

81


Zeros of Functions—fzero and roots/poly

fzero

The are many equations for which an explicit algebraic solution to f(x) = 0 cannot be found.

In these cases, one uses

fzero

to find numerically one solution to the real function f(x) = 0 within a tolerance to in either the neighborhood of xo or within the range [x1, x2].

The function can also transfer pj, j = 1, 2, …, parameters to the function defining f(x).


Chapter 5

82


The general expression is

z = fzero(@FunctionName, x0, options, p1, p2,…)

where

z is the value of x for which f(x) 0.

FunctionName is the name of the function file without the extension “.m” or the name of the sub function.

x0 = xo or x0 = [x1 x2]

p1, p2, etc., are the parameters pj required by FunctionName.

options is set using

optimset


Chapter 5

83


The function optimset is a general parameter-adjusting function that is used by several MATLAB functions, primarily from the Optimization toolbox.


Chapter 5

84


The interface for the function required by fzero has the form

function z = FunctionName(x, p1, p2,...)Expression(s)z = …

where x is the independent variable that fzero is changing in order to find a value such that f(x) 0.

fzero(@FunctionName, x0, options, p1, p2,…)

The independent variable must always appear in the first location.


Chapter 5

85


The function fzero can also be used with the inline function as

InlineFunctName = inline('Expression', 'x', 'p1','p2', …);z = fzero(InlineFunctName, x0, options, p1, p2,…)

and with an anonymous function as

fhandle = @(x, p1, p2, …) (Expression);z = fzero(fhandle, x0, options, p1, p2,…)


Chapter 5

86


Warning – Care must be exercised when using fzero with some of MATLAB’s functions

Let us determine the root of J1(x) = 0 near 3, where J1(x) is the Bessel function of the first kind of order 1.

The Bessel function is a oscillatory function similar to trigonometric functions.

The Bessel function is obtained from

besselj(n, x)

where n is the order (= 1 in this case) and x is the independent variable.


Chapter 5

87


We cannot use this function directly because the independent variable x is not the first variable in the function, n is.

Hence, we create a new function using inline as follows

besseljx = inline('besselj(n, x)', 'x', 'n');a = fzero(besseljx, 3, [], 1)


a = 3.8317

Notice that in order to transfer the parameter p1 = n = 1 to the function besseljx, we had to place a value of 1 in the fourth location of fzero.


Chapter 5

88


If we were to use an anonymous function instead of inline, the script is

n = 1;B =@(x) (besselj(n, x));a = fzero(B, 3)


Chapter 5

89


Extension: Finding Multiple Zeros of a Function –

For multi-valued functions whose properties are not known a priori, one could use the following method as one way to determine the search regions for fzero automatically.

This method determines the approximate locations of the change in signs in f(x) in a given range of x, and thereby obtains the regions [x1, x2] for which fzero conducts its search.

This method is presented as an M-file so that it may be used with an arbitrary f(x).


Chapter 5

90


function Rt = FindZeros(FunName, Nroot, x, w)f = feval(FunName, x, w); indx = find(f(1:end-1).*f(2:end)<0);L = length(indx);if L<Nroot Nroot = L;endRt = zeros(Nroot, 1);for k = 1:Nroot Rt(k) = fzero(FunName, [x(indx(k)), x(indx(k)+1)], [], w);end


Chapter 5

91


Example - Lowest Five Natural Frequency Coefficients of a Clamped Beam

The characteristic equation from which the natural frequency coefficients of a thin beam clamped at each end is given by

(Ω) = cos(Ω)cosh(Ω) -1f

The script using inline is

qcc = inline('cos(x).*cosh(x)-1', 'x','w');Nroot = 5; w = [];x = linspace(0, 20, 100);Rt = FindZeros(qcc, Nroot, x, w)disp('Lowest five natural frequency coefficients are:')disp(num2str(Rt'))


Chapter 5

92



Lowest five natural frequency coefficients are:4.73004 7.8532 10.9956 14.1372 17.2788

The script using an anonymous function is

qcc = @(x, w) (cos(x).*cosh(x)-1);x = linspace(0.1, 20, 50); q = FindZeros(qcc, 5, x, []);disp('Lowest five natural frequency coefficients are:')disp(num2str(q'))


Chapter 5

93


roots

When f(x) is a polynomial of the form

-11 2 +1( ) = + +…+ +n n

n nf x c x c x c x c

its roots can more easily be found by using

r = roots(c)

where

c = [c1, c2, …, cn+1]


Chapter 5

94


poly

The inverse of roots is

c = poly(r)

which returns c, the polynomial’s coefficients, and r is a vector of roots.

In the general case, r is a vector of real and/or complex numbers.


Chapter 5

95


Example –

Let

The script to find all the roots of the polynomial is

r = roots([1, 0, -35, 50, 24])

Executing this script gives

r = -6.4910 4.8706 2.0000 -0.3796

Note: Whenever one of the coefficients is zero, a zero is placed in that location in the vector.

4 2( ) 35 50 24f x x x x


Chapter 5

96


Notice that the roots do not come out in any particular order.

To order them, one uses sort. Thus,

r = sort(roots([1, 0, -35, 50, 24]))


r = -6.4910 -0.3796 2.0000 4.8706


Chapter 5

97


To determine the coefficients of a polynomial with these roots, the script is

r = roots([1, 0, -35, 50, 24]);c = poly(r)

which, upon execution, displays

c = 1.0000 0.0000 -35.0000 50.0000 24.0000

c = [c1, c2, …, cn+1]

-11 2 1( ) n n

n nf x c x c x c x c

4 2( ) 35 50 24f x x x x


Chapter 5

98


Numerical Integration—quadl and dblquad

quadl

The function quadl numerically integrates a user-provided function f(x) from a lower limit a to an upper limit b to within a tolerance to.

It can also transfer pj parameters to the function defining f(x).

The general expression for quadl, when f(x) is represented by a function file or a sub function, is


Chapter 5

99


A = quadl(@FunctionName, a, b, t0, tc, p1, p2,…)

where

FunctionName is the name of the function or a sub function

a = a

b = b

t0 = to (when omitted, the default value is used)

p1, p2, etc., are the parameters pj,

tc [] quadl provides intermediate output


Chapter 5

100


The general expression for quadl, when f(x) is represented by an inline function or an anonymous function, is

A = quadl(IorAFunctionName, a, b, t0, tc, p1, p2,…)

The interface for the function has the form

function z = FunctionName(x, p1, p2, ...)Expression(s)

where x is the independent variable that quadl is integrating over.

The interface for inline is

IorAFunctionName = inline('Expression', 'x', 'p1', ...)


Chapter 5

101


The interface for an anonymous function is

IorAFunctionName = @(x, p1, p2, …) (Expression)

The independent variable must always appear in the first location of a function interface.


Chapter 5

102


Example – Area of an Exponentially Decaying Sine Wave Revisited

The damped sine wave is represented by the function DampedSineWave.

If we again let = 0.1 and integrate from 0 20, then the script is

xi = 0.1;Area = quadl(@DampedSineWave, 0, 20, [], [], xi)


Area = 0.3022

From trapz – Area = 0.3021

A = quadl(@FunctionName, a, b, t0, tc, p1, p2,…)


Chapter 5

103


dblquad

The function dblquad numerically integrates a user-provided function f(x,y) from a lower limit xl to an upper limit xu in the x-direction and from a lower limit yl to an upper limit yu in the y-direction to within a tolerance to.

It can also transfer pj parameters to the function defining f(x,y).


Chapter 5

104


The general expression for dblquad, when f(x,y) is represented by a function or a sub function, is

dblquad(@FunctionName, xl, xu, yl, yu, t0, meth, p1, p2,…)

where

FunctionName is the name of the function or sub function

xl = xl xu = xu

yl = yl yu = yu

t0 = to (when omitted, the default value is used)

p1, p2, etc., are the parameters pj

when meth = [], quadl is the method used


Chapter 5

105


When the function is created by inline or an anonymous function, then

dblquad(IorAFunctionName, xl, xu, yl, yu, t0, meth, p1, p2,…)

where

IorAFunctionName is the name of the inline function or anonymous function

The interface for the function file has the form

function z = FunctionName(x, y, p1, p2, ...)Expression(s)z = …


Chapter 5

106


Example – Probability of Two Correlated Variables

We shall numerically integrate the following expression for the probability of two random variables that are normally distributed over the region indicated.

2 2

2 3-( -2 + )/2

2-2 -3

1=

2 1-

x rxy yV e dxdyπ r


Chapter 5

107


If we assume that r = 0.5, then the script is

r = 0.5;Arg = @(x, y) (exp(-(x.^2-2*r*x.*y+y.^2))); P = dblquad(Arg, -3, 3, -2, 2, [], [], r)/2/pi/sqrt(1-r^2)


P = 0.6570

dblquad(IorAFunctionName, xl, xu, yl, yu, t0, meth, p1, p2,…)

2 2

2 3-( -2 + )/2

2-2 -3

1=

2 1-

x rxy yV e dxdyπ r


Chapter 5

108


Numerical Solutions of Ordinary Differential Equations

Some preliminaries –

We must be able to put a system of differential equations as a function of the dependent variables wk , k = 1, …, K into a set of first order differential equations of the form

( ), 1, 2,...j

j j

dyg y j N

d

and to convert the initial conditions or the boundary conditions to functions of yj.

Example –

To illustrate the method, consider the following system of non-dimensional equations


Chapter 5

109


23 2*

3 2

2* * *

2

3 2 0

3Pr 0

d f d f dff T

d d d

d T dTf

d d

*

*

0 : 0, 0, and 1

8 : 0 and 0

dff T

d

dfT

d

where Pr is the Prandtl number. The boundary conditions are

Note: The number of first order equations that we will have and the number of boundary or initial conditions that we will have is each equal to the sum of the highest order of each dependent variable: 3 + 2 = 5 in this case.


Chapter 5

110


*1 4

*

2 5

2

3 2

y f y T

df dTy y

d d

d fy

d

We let Then

1 42 5

523 1 5

232 1 3 4

3Pr

2 3

dy dyy y

d d

dydyy y y

d d

dyy y y y

d

Since,23 2 2 * *

*3 2 2

22 2 * **

2 2

23 51 3 2 4 1 5

3 2 0 3Pr 0

3 2 0 3Pr 0

3 2 0 3Pr 0

d f d f df d T dTf T f

d d d d d

d d f d f df d dT dTf T f

d d d d d d d

dy dyy y y y y y

d d


Chapter 5

111


and the boundary conditions become

1 2

*2 4

*4

0 0 0 0

0 0 0 0

1 1

dff y y

d

dfy T y

d

T y

*

1 4

*

2 5

2

3 2

y f y T

df dTy y

d d

d fy

d

at = 0 at = 8


Chapter 5

112


Numerical Solutions of Ordinary Differential Equations—ode45

The function ode45 returns the numerical solution to a system of n first-order ordinary differential equation

1 2= ( , , ..., ) = 1,2, ...,jj n

dyf t, y y y j n

dt

over the interval t0 t tf subject to the initial conditions yj(t0) = aj, j = 1, 2, …, n, where aj are constants.


Chapter 5

113


The arguments and outputs of ode45 are

[t, y] = ode45(@FunctionName, [t0, tf], [a1, a2, …, an], options, p1, p2,

…)

where

The output t is a column vector of the times t0 t tf that are determined by ode45.

The output y is the matrix of solutions such that the rows correspond to the times t and the columns correspond to the solutions

y(:, 1) = y1(t)y(:, 2) = y2(t)…y(:, n) = yn(t)


Chapter 5

114


The first argument of ode45 is @FunctionName, which is a handle to the function or sub function FunctionName.

Its form must be

function yprime = FunctionName(t, y, p1, p2,…)

where

t is the independent variable

y is a column vector whose elements correspond to yj

p1, p2, … are parameters passed to FunctionName

yprime is a column vector of length n whose elements are

1 2( , , ..., ) = 1,2, ...,j nf t, y y y j n

1 2= ( , , ..., ) = 1,2, ...,jj n

dyf t, y y y j n

dt

[t, y] = ode45(@FunctionName, [t0, tf], [a1, a2, …, an], options, p1, p2, …)


Chapter 5

115


that is,

yprime = [f1; f2; ... ; fn] % [f1, f2, ... , fn]'

The variable names yprime, FunctionName, etc. are assigned by the programmer

The second argument of ode45 is a two-element vector giving the starting and ending times over which the numerical solution will be obtained.

This quantity can, instead, be a vector of the times [t0 t1 t2 … tf] at which the solutions will be given.

The third argument is a vector of initial conditions yj(to) = aj.



Chapter 5

116


The fourth argument, options, is usually set to null ([]).

If some of the solution method tolerances are to be changed, one does this with odeset (see the odeset Help file).

The remaining arguments are those that are passed to FunctionName.



Chapter 5

117


Example –

Consider the non-dimensional second-order ordinary differential equation

2

22 ( )

d y dy+ ξ + y = h t

dt dt

which is subjected to the initial conditions y(0) = a and dy(0)/dt = b.

We rewrite the above equation as a system of two first-order equations with the substitution

1

2

y = y

dyy =

dt


Chapter 5

118


Then, the system of first order equations is

12

22 1

dy= y

dtdy

= -2ξy - y + hdt

with the initial conditions y1(0) = a and y2(0) = b.

Let us consider the case where = 0.15, y(0) = 1, dy(0)/dt = 0,

( ) = sin( /5) 0 5

= 0 > 5

h t πt t

t

and we are interested in the solution over the region 0 t 35.

1

2

y = y

dyy =

dt

2

22 ( )

d y dy+ ξ + y = h t

dt dt


Chapter 5

119


Then, y1(0) = 1, y2(0) = 0, t0 = 0, and tf = 35.

We solve this system by creating a main function called Exampleode and a sub function called HalfSine. Then,

function Exampleode[t, yy] = ode45(@HalfSine, [0 35], [1 0], [], 0.15);plot(t, yy(:,1))

function y = HalfSine(t, y, z)h = sin(pi*t/5).*(t<=5);y = [y(2); -2*z*y(2)-y(1)+h];

It should be realized that

yy(:,1) = y1(t) = y(t) yy(:,2) = y2(t) = dy/dt

function yprime = FunctionName(t, y, p1, p2,…)


( ) = sin( /5) 0 5

= 0 > 5

h t πt t

t

12

22 1

dy= y

dtdy

= -2ξy - y + hdt

yj(t0) = aj


Chapter 5

120


0 5 10 15 20 25 30 35-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

1.2


Chapter 5

121


Numerical Solutions of Ordinary Differential Equations—bvp4c

The function bvp4c obtains numerical solutions to the two-point boundary value problem.

Unlike ode45, bvp4c requires the use of several additional MATLAB functions that were specifically created:

bvpinit – initializing function

deval – output smoothing function for plotting

Several additional user function files must be created.


Chapter 5

122


The function bvp4c returns the numerical solution to a system of n first-order ordinary differential equations

1 2( ) 1,2, ...,jj n

dy= f x, y , y , ..., y ,q j = n

dx

over the interval a x b subject to the boundary conditions yj(a) = aj and yj(b) = bj j = 1, 2, …, n/2, where aj and bj are constants and q is a vector of unknown parameters.


Chapter 5

123


The arguments and outputs of bvp4c are as follows.

sol = bvp4c(@FunctionName, @BCFunction, …solinit, options, p1, p2...)

The function FunctionName requires the following interface

function dydx = FunctionName(x, y, p1, p2, ...)

where

x is a scalar corresponding to x

y is a column vector of fj

p1, p2, etc., are known parameters that are needed to define fj

The output dxdy is a column vector.


Chapter 5

124


The output sol is a structure with the following values –

sol.x Mesh selected by bvp4c

sol.y Approximation to y(x) at the meshpoints of sol.x

sol.yp Approximation to dy(x)/dx at themesh points of sol.x

sol.parametersValues Returned by bvp4c for theunknown parameters, if any

sol.solver 'bvp4c'


Chapter 5

125


The function BCFunction contains the boundary conditions yj(a) = aj and yj(b) = bj j = 1, 2, … and requires the following interface:

function Res = BCFunction(ya, yb , p1, p2, ...)

where

ya is a column vector of yj(a)

yb is a column vector of yj(b)

The known parameters p1, p2, etc., must appear in this interface, even if the boundary conditions do not require them.

The output Res is a column vector.


Chapter 5

126


The variable solinit is a structure obtained from the function bvpinit as

solinit = bvpinit(x, y)

where

The vector x is a guess for the initial mesh points.

The vector y is a guess of the magnitude of each of the yj.

The lengths of x and y are independent of each other.

The structure solinit is –

x Ordered nodes of the initial mesh

y Initial guess for the solution withsolinit.y(:,i) a guess for the solution at thenode solinit.x(i)


Chapter 5

127


The output of bvp4c, sol, is a structure that contains the solution at a specific number of points.

In order to obtain a smooth curve, values at additional intermediate points are needed.

To provide these additional points, we use

sxint = deval(sol, xint)

where

xint is a vector of points at which the solution is to be evaluated.

sol is the output (structure) of bcp4c.


Chapter 5

128


The output sxint is an array containing the values of yj

at the spatial locations xint; that is,

y1(xint) = sxint(1,:)

y2(xint) = sxint (2,:)

…

yn(xint) = sxint (n,:)



Chapter 5

129


Example –

Consider the following equation2

20 0 1

d ykxy x

dx

subject to the boundary conditions

(0) 0.1

(1) 0.05

y

y

First, we transform the equation into a pair of first order differential equations with the substitution

1

2

y = y

dyy =

dt


Chapter 5

130


12

21

dyy

dxdy

kxydx

to obtain

Then, the boundary conditions for this formulation are

1

1

(0) 0.1

(1) 0.05

y

y

We select five points between 0 and 1 and assume that the solution for y1 has a constant magnitude of 0.05 and that for y2 has a constant magnitude of 0.1.

Then, assuming that k = 100, the script is

(0) 0.1

(1) 0.05

y

y


Chapter 5

131


function bvpExamplek = 100;solinit = bvpinit(linspace(0, 1, 5), [-0.05, 0.1]);exmpsol = bvp4c(@OdeBvp, @OdeBC, solinit, [], k);x = linspace(0, 1, 50);y = deval(exmpsol, x);plot(x, y(1,:))

function dydx = OdeBvp(x, y, k)dydx = [y(2); k*x*y(1)];

function res = OdeBC(ya, yb, k)res = [ya(1)-0.1; yb(1)-0.05];

sol = bvp4c(@FunctionName, @BCFunction, solinit, options, p1, p2...)

solinit = bvpinit(x, y)


function Res = BCFunction(ya, yb , p1, p2, ...)

function dydx = FunctionName(x, y, p1, p2, ...)

12

21

dyy

dxdy

kxydx

1

1

(0) 0.1

(1) 0.05

y

y


Chapter 5

132



Chapter 5

133


bvp4c and the Static Analysis of Euler Beams

The beam equation is given by

where

w = w(x) is the transverse displacement

L = length of the beam

E = Young’s modulus

I = moment of inertia of the cross section

Po = magnitude of the applied load per unit length

q(x) = shape of the load along the length of the beam

4

4( ) 0o

d wEI P q x x L

dx


Chapter 5

134


We will consider the following three different boundary conditions at each end of the beam:

Simply supported (hinged)

Clamped

Free

2

20 and 0

d ww M EI

dx

0 and 0dw

wdx

3 2

3 20 and 0

d w d wV EI M EI

dx dx


Chapter 5

135


If we introduce the following definitions, 4

/ ( ) / and oo o

P Lx L y y w h h

EI

The governing equation becomes4

4( ) 0 1

d yq

d

and the boundary conditions are –

Clamped:

Free:

Simply supported:2

2 20 and 0nd

o

M d yy M

P L d

0 and 0dy

yd

3 2

3 2 20 and 0nd nd

o

d y M d yV M

d P L d


Chapter 5

136


We transform this equation to a series of first order ordinary differential equations through the relations

2

1 3 2

3

2 4 3

d yy y y

d

dy d yy y

d d

to obtain

312 4

2 43

( )

dydyy y

d d

dy dyy q

d d


Chapter 5

137


The boundary conditions become

1 30 and 0y y

1 20 and 0y y

3 40 and 0y y

Clamped:

Free:

Simply supported:


Chapter 5

138


Example – Uniformly Loaded Hinged Beam

Let us consider a beam that is hinged at each end and has a non-dimensional external moment Mr at the end = 1.

This means that the displacements at both ends are zero and the moment at = 0 is zero; thus,

1 1 3(0) (1) (0) 0y y y

and at = 13 (1) r ndy M M

If we apply a uniform load along the length of the beam, then q() = 1.


Chapter 5

139


Let us assume that Mr = 0.8 and we have previously assumed that q = 1.

We take 10 mesh points as our guess and guess that the magnitudes of the displacement, slope, moment, and shear force each have the value of 0.5.

The function that is used to represent the system of first order equations is called BeamODEqo and the function that represents the boundary conditions is called BeamHingedBC.

Then the script is


Chapter 5

140


function BeamUniformLoadMr = 0.8; q = 1;solinit = bvpinit(linspace(0, 1, 10), [0.5, 0.5, 0.5, 0.5]);beamsol = bvp4c(@BeamODEqo, @BeamHingedBC, …

solinit, [], q, Mr);eta = linspace(0, 1, 50);y = deval(beamsol, eta);plot(eta, y(1,:)) % + 3 additional plot commands

function dydx = BeamODEqo(x, y, q, Mr)dydx = [y(2); y(3); y(4); q];

function bc = BeamHingedBC(y0, y1, q, Mr)bc = [y0(1); y0(3); y1(1); y1(3)-Mr];

1 1 3 3(0) (1) (0) 0 and (1) ry y y y M

312 4

2 43

( )

dydyy y

d d

dy dyy q

d d


Chapter 5

141


0 0.2 0.4 0.6 0.8 1-0.04

-0.03

-0.02

-0.01

0

0 0.2 0.4 0.6 0.8 1-0.1

-0.05

0

0.05

0.1

0.15

0.2

0.25

0 0.2 0.4 0.6 0.8 10

0.2

0.4

0.6

0.8

0 0.2 0.4 0.6 0.8 10.2

0.4

0.6

0.8

1

1.2

1.4

1.6

Displacement - y(1,:)

Moment - y(3,:) Shear - y(4,:)

Slope - y(2,:)


Chapter 5

142


Example - Point Load on a Simply-Supported Euler Beam

The non dimensional equation becomes 4

4( )o

d y

d

where () is the delta function.

To solve this equation, we will have to approximate the point load with a uniform load that is distributed over a very small portion of the beam; that is, we will assume that Po is constant over the region

o o + << 1

and in this small region Po Po/(2).


Chapter 5

143


In addition, in order for the numerical procedure to ‘know’ that the inhomogeneous term of the equation is non zero over a very small region, we must ensure that our initial guess includes this region.

To do this, we specifically include as part of our initial guess the three locations o , o, and o + .

To illustrate this procedure, we assume that the beam is simply supported at both ends and that o = 0.5 and = 0.005.

Then the program is

o

o

o

o +

P

P P/(2)


Chapter 5

144


function BeamPointLoade = 0.005; etao = 0.5;pts = [linspace(0, etao-2*e, 4), etao-e, etao, etao+e, ...

linspace(etao+2*e, 1, 4)];solinit = bvpinit(pts, [0.5, 0.5, 0.5, 0.5]);beamsol = bvp4c(@BeamODEqo, @BeamHingedBC, solinit, [], etao, e);eta = linspace(0, 1, 100);y = deval(beamsol, eta);for k = 1:4 subplot(2, 2, k) plot(eta, y(k,:), 'k-') hold on plot([0 1], [0 0], 'k--')end

function dydx = BeamODEqo(x, y, etao, e)q = ((x > etao-e) & (x < etao+e))/(2*e);dydx = [y(2); y(3); y(4); q];

function bc = BeamHingedBC(yL, yR, etao, e)bc = [yL(1); yL(3); yR(1); yR(3)];


Chapter 5

145


0 0.2 0.4 0.6 0.8 10

0.005

0.01

0.015

0.02

0.025

0 0.2 0.4 0.6 0.8 1-0.1

-0.05

0

0.05

0.1

0 0.2 0.4 0.6 0.8 1-0.25

-0.2

-0.15

-0.1

-0.05

0

0 0.2 0.4 0.6 0.8 1-0.5

0

0.5

Displacement - y(1,:)

Moment - y(3,:) Shear - y(4,:)

Slope - y(2,:)


Chapter 5

146


Example – Lowest Natural Frequency Beam Clamped atBoth Ends

The governing equation of an Euler beam of length L undergoing harmonic oscillations at frequency rad/s is

44

40 0 1

d ww

d

where4 2

4/ and AL

x LEI

For a beam clamped at both ends, the boundary conditions are

(0) (1)(0) 0 and (1) 0

dw dww w

d d


Chapter 5

147


Making the appropriate substitutions, we obtain

312 4

42 43 1

dwdww w

d d

dw dww w

d d

and1 1

2 2

(0) 0 (1) 0

(0) 0 (1) 0

w w

w w

Five conditions must be specified: four homogeneous boundary conditions and a fifth condition that will permit the unknown parameter to be determined.

We shall choose the fifth condition as the non zero boundary condition y4(0) = 0.05. (The magnitude 0.05 is not critical, but it should be ‘small’.)


Chapter 5

148


bvp4c requires a guess for the parameter (the solution is sensitive to this value).

It is also necessary to provide a guess that reasonably approximates the expected spatial shapes of the solutions, yj.

In this example, the function that provides these spatial distributions is EulerBeamInit.

The spatial distribution selected is w1 = sin() –

wj, j = 2, 3, 4 are determined by differentiation of w1.

The value of is obtained by selecting the appropriate structure of the solution; in our case, it is called beamsol.parameters.


Chapter 5

149


function ClampedBeamFreqOmguess = 4.0;solinit = bvpinit(linspace(0,1,6), @EulerBeamInit, Omguess);beamsol = bvp4c(@EulerBeamODE, @EulerBeamBC, solinit);Omega = beamsol.parameters;eta = linspace(0, 1, 50);y = deval(beamsol, eta);ModeShape = y(1,:)/max(abs(y(1,:))); % Not plotted disp([' Omega/pi = ' num2str(Omega/pi,6)])

function yinit = EulerBeamInit(x)yinit = [sin(pi*x); cos(pi*x); -sin(pi*x); -cos(pi*x)];

function bc = EulerBeamBC(w0, w1, Om)bc = [w0(1); w0(4)-0.05; w0(2); w1(1); w1(2)];

function dydx = EulerBeamODE(x, w, Om)dydx = [w(2); w(3); w(4); Om^4*w(1) ];


Chapter 5

150



Omega/pi = 1.50567


Chapter 5

151


Numerical Solutions of One-dimensional Parabolic-elliptic Partial Differential Equations—pdepe

The function pdepe obtains the numerical solution to the partial differential equation

m muc x x f s

t x

( , , , ), ( , , , ),

( , , , )

c c x t u u x f f x t u u x

s s x t u u x

where u = u(x,t), a x b, to t tend,

m = 0 indicating a Cartesian system, m = 1 a cylindrical system, and m = 2 a spherical system.


Chapter 5

152


The initial condition is

and the boundary conditions are

( , , ) ( , ) 0

( , , ) ( , ) 0a a

b b

p a t u q a t f

p b t u q b t f

( , ) ( )o ou x t u x

The function pdepe is invoked with

sol = pdepe(m, @pdeID, @pdeIC, @pdeBC, x, t, … options, p1, p2, …)


Chapter 5

153


where

x is a vector of values for which pdepe will provide the corresponding values of u such that x(1) = a and x(end) = b.

t is a vector of values for which pdepe will provide the corresponding values of u such that t(1) = to

and t(end) = tend.

p1, p2, ..., are parameters that are passed to pdeID, pdeIC, and pdeBC (they must appear in each of these functions whether or not they are used by that function).

options is set by odeset.


Chapter 5

154


The quantity sol (= u(t,x)) is an array sol(i,j), where i is the element number of the temporal mesh and j is the element number of the spatial mesh.

Thus, sol(i,:) approximates u(t,x) at time ti at all mesh

points from x(1) = a to x(end) = b.

The function pde1D specifies c, f, and s as follows:

function [c, f, s] = pde1D(x, t, u, dudx, p1, p2, ... )c = ;f = ;s = ;

where dudx is the partial derivative of u with respect to x and is provided by pdepe.


Chapter 5

155


The function pdeIC specifies uo(x) as follows:

function uo = pdeIC(x, p1, p2, ... )uo = ;

The function pdeBC specifies the elements pa, qa, pb, and

qb, of the boundary conditions as follows:

function [pa, qa, qb, pb] = pdeBC(xa, ua, xb, ub, …t, p1, p2, ... )

pa = ;qa = ;pb = ;qb = ;

where ua is the current solution at xa = a and ub is the current solution at xb = b.


Chapter 5

156


Example - One-dimensional Heat Conduction in a Slab with a Heat Source

The governing nondimensional equation is

2

2

The initial condition is

and the boundary conditions are

( ,0) 1 0.45

0

1

(0, )

(1, )

Bi


Chapter 5

157


We see that m = 0,

c = 1f = /s =

and the initial condition is

uo() 1 0.45

We note that the boundary conditions are specified at a = 0 and b = 1; therefore, we have that

qa = 1 and pa = Bi(0,)

qb = 0 and pb = (1,) 1

2

2

m muc x x f s

t x

0

1

( , , ) ( , ) 0

(0, ) 0

( , , ) ( , ) 0

(1, ) 0

a a

b b

p a t u q a t f

Bi

p b t u q b t f


Chapter 5

158


We assume that Bi = 0.1, 1 = 0.55, and = 1.

We also note that in the arguments of pdeBC, ua = (0,) and ub = (1,), which are provided by pdepe.

The program is


Chapter 5

159


function pdepeHeatSlabBi = 0.1; T1 = 0.55; Sigma = 1; xi = linspace(0, 1, 25); tau = linspace(0, 1, 101); theta = pdepe(0, @pde1D, @pdeIC, @pdeBC, xi, tau, [], …

Bi, T1, Sigma); hold onfor kk = 1:5:length(zi) plot(tau, theta(:, kk), 'k-')end

function [c, f, s] = pde1D(x, t, u, DuDx, Bi, Tr, Sigma)c = 1; f = DuDx; s = Sigma;

function u0 = pdeIC(x, Bi, Tr, Sigma)u0 = 1-0.45*x;

function [pl, ql, pr, qr] = pdeBC(xl, ul, xr, ur, t, Bi, Tr, Sigma)pr = ur-Tr; qr = 0; pl = -Bi*ul; ql = 1;


Chapter 5

160



Chapter 5

161


Local Minimum of a Function—fminbnd

The function fminbnd finds a local minimum of the real function f(x) in the interval a x b within a tolerance to.

It can also transfer pj parameters to the function defining f(x).

The general expression for fminbnd is

[xmin fmin] = fminbnd(@FunctionName, a, b, …options, p1,

p2, …)


Chapter 5

162


where

FunctionName is the name of the function or sub function.

a = a, b = b

options is an optional vector whose parameters are set with optimset.

p1, etc., are the parameters pj.

The quantity xmin is the value of x that minimizes the function given in FunctionName and fmin is the value of FunctionName at xmin.


Chapter 5

163


The interface for FunctionName has the form

function z = FunctionName(x, p1, p2,...)

where x is the independent variable that fminbnd is varying in order to minimize f(x).

When f(x) is an expression that is represented by inline or an anonymous function with the name IorAFunctionName, fminbnd is accessed as

[xmin, fmin] = fminbnd(IorAFunctionName, a, b, … options, p1, p2, …)

The independent variable must always appear in the first location.


Chapter 5

164


-1 -0.5 0 0.5 1 1.5 2-20

0

20

40

60

80

100

x

hum

ps(x

)

humps = 0at x= -0.13162

humps = 0 at x= 1.2995

Local min =11.2528at x= 0.63701

Max = 96.5014 at x= 0.30038

2nd max = 21.7346 at x= 0.89273

Total area = 26.345

Example – Using demonstration function humps

2 2

1 1( ) = + - 6

- 0.3 + 0.01 - 0.9 + 0.04x

x xhumps


Chapter 5

165


The minimum value of the function between 0.5 x 0.8 is determined from

[xmin, fmin] = fminbnd(@humps, 0.5, 0.8)


xmin = 0.6370fmin = 11.2528

[xmin, fmin] = fminbnd(@FunctionName, a, b, options, p1, p2, …)

-1 -0.5 0 0.5 1 1.5 2-20

0

20

40

60

80

100

x

hum

ps(x

)humps = 0at x= -0.13162

humps = 0 at x= 1.2995

Local min =11.2528at x= 0.63701

Max = 96.5014 at x= 0.30038

2nd max = 21.7346 at x= 0.89273

Total area = 26.345


Chapter 5

166


To determine the maximum value of humps in the interval 0 x 0.5 and where it occurs, we have to recognize that fminbnd must operate on the negative or the reciprocal of the function humps.

Thus, we use inline to create a function that computes the negative of humps in this region.

The script is


Chapter 5

167


[xmax, fmax] = fminbnd(inline('-humps(x)', 'x '), 0, 0.5);disp(['Maximum value of humps in the interval 0 <= x

<= 0.5 is ' num2str(-fmax)])disp(['which occurs at x = ' num2str(xmax)])

which, upon execution, displays

Maximum value of humps in the interval 0 <= x <= 0.5 is 96.50 which occurs at x = 0.30039

[xmin, fmin] = fminbnd(IorAFunctionName, a, b, options, p1, p2, …)

-1 -0.5 0 0.5 1 1.5 2-20

0

20

40

60

80

100

x

hum

ps(x

)

humps = 0at x= -0.13162

humps = 0 at x= 1.2995

Local min =11.2528at x= 0.63701

Max = 96.5014 at x= 0.30038

2nd max = 21.7346 at x= 0.89273

Total area = 26.345


Chapter 5

168


Symbolic Solutions and Converting Symbolic Expressions into Functions

One way to convert a symbolic expression f into a function, we employ inline and

vectorize(f)

which converts its argument to a string and converts the multiplication, division, and exponentiation operators to their dot operator counterparts.


Chapter 5

169


A second way is to use

matlabFunction

to create an anonymous function.

If f = f(x, y, z) is a symbolic expression with symbolic variables x, y, and z, then

fnct = matlabFunction(f, 'vars', [x, y, z])

where 'vars' (apostrophes required) indicates that an anonymous function will be created with the parameters x, y, z of the form

fnct = @(x, y, z) (f)

where f is a Matlab expression with the *, /, and ^ operators replaced by their dot operation counterpart; that is, by .*, ./, and .^.


Chapter 5

170


Example –

Consider the equation

The Laplace transform of this equation, when y(0) = 0 and dy(0)/dt = 0, is

2

22 ( )

d y dyy h t

dt dt

2

( )( )

2 1

H sY s

s s

where

Y(s) is the Laplace transform of y(t)

H(s) is the Laplace transform of h(t)

< 1 is a real constant


Chapter 5

171


If we assume that

h(t) = u(t)

where u(t) is the unit step function, then

H(s) = 1/s

The script to determine y(t) is

syms ssyms xi t realden = s*(s^2+2*xi*s+1);yt = ilaplace(1/den, s, t);yt=simple(yt)

where simple put yt in its simplest form.

2

2

( )( )

2 1

1

2 1

H sY s

s s

s s s


Chapter 5

172


The execution of this script gives

yt =1-cosh(t*(xi^2-1)^(1/2))/exp(t*xi)-xi/(xi^2-1)^(1/2)*sinh(t*(xi^2-1)^(1/2))/exp(t*xi)

To convert this symbolic expression to a function, we use the following script.

syms s syms xi t realden = s*(s^2+2*xi*s+1);yt = ilaplace(1/den, s, t);yt=simple(yt)yoft = inline(vectorize(yt), 't', 'xi');t = linspace(0, 20, 200);plot(t, real(yoft(t, 0.15)))


Chapter 5

173


An examination of the numerical results indicates that the imaginary part of the solution is virtually zero.

Therefore, we use real to remove any residual imaginary part due to numerical round off errors.

0 5 10 15 200

0.2

0.4

0.6

0.8

1

1.2

1.4

1.6

1.8


Chapter 5

174


Repeating the above solution using matlabFunction, we have that

syms s tsyms xi realden = s*(s^2+2*xi*s+1);yt = ilaplace(1/den, s, t);yoft = matlabFunction(yt, 'vars', [t, xi]);t = linspace(0, 20, 200); xi = 0.15;plot(t, real(yoft(t, xi)))

Chapter 5 1 An Engineer’s Guide to MATLAB Copyright © Edward B. Magrab 2009 AN ENGINEER’S GUIDE...

Documents

Transcript of Chapter 5 1 An Engineer’s Guide to MATLAB Copyright © Edward B. Magrab 2009 AN ENGINEER’S GUIDE...