Test 2

Refer to errors in a method, which occur because some series (finite or infinite) is truncated to a fewer number of terms.

Such errors are essentially algorithmic errors and we can predict the extent of the error that will occur in the method.

(e.g. π ≠ 3.14 ≠ 3.14159 but they are approximate)

Round off error occurs because of the computing device's inability to deal with inexact numbers.

Such numbers need to be rounded off to some near approximation which is dependent on the space allotted by the device to represent the number

= true value - approximation

Shortcoming: an error of a micrometer is much more significant if we are measuring the size of a cell in comparison to the length of your arm.

So how do we account for the size of the error with respect to the magnitude of the measurement?

= (Absolute error/true value)*100%

The relative error gives an indication of how good the approximation is relative to the true value

These will be needed when we talk about propagating errors (i.e. combining multiple values that each have an error associated with it)

a measure of how data points differ from the mean

a measure of variation of scores about the mean

the average distance to the mean, although that's not numerically accurate, it's conceptually helpful. All ways of saying the same thing: higher standard deviation indicates higher spread, less consistency, and less clustering

Square root of variance

std() provides the sample standard deviation

use the “.” for element-by-element level

So use .* or ./ or .^ instead of * or / or ^

Use “.” before operator for array calculations

Enclosed in square bracket [ ]

Commas separate columns

Semicolons indicate a new row

Indexing can also be used to change values in a matrix or include additional values

Can be used to define evenly spaced vectors with a defined increment in the form:

first:increment:limit

Can be used to define evenly spaced vectors with a in the form

linspace(X1, X2, N)

generates N points between X1 and X2

changes all of the rows of an array to columns and all of the columns to rows, B=A’

Creating a new matrix out of two previous matrices added as separate rows, C=[A; B]

1. Create 2 vectors

2. Use the plot(x,y,’format’) command

3. Will create a plot of y vs x

4. Format examples in pic

5. To plot again of same plot use the hold on command

Allows for putting multiple graphs in one figure

subplot(m,n,p) divides graphing window into a grid of m rows and n columns, where p identifies the part of the window where the plot will be drawn

To plot polar coordinates (angle vs radius) use polar(angle,radius)

3 kinds:

• semilogx

• semilogy

• loglog

Replace linear scales with logarithmic scales

minimizes the squared distance between experimental data points and the modeled data points. This prevents positive and negative values from cancelling each other out

Use polyfit(x,y,polynomial degree) function with polyval() if necessary

“smart” command for plotting functions

Automatically analyzes the function to be plotted and decides number of plotting points to show all the features of the function

fplot(function,[xmin xmax])

plot3

graphs of 3 axes

meshgrid()

mesh(,,)

Create a rectangular grid out of an array of x values and an array of y values

To fill in the faces of the surface in color use

meshgrid()

surf(,,)

a 3-D surface by plotting lines that connect points with common z-values along a slice

• a title

• axis label with the name of quantity and units

• same symbol of each data point in a given data set

• grid

• a legend

• regularly spaced tick marks at convenient intervals along each axis.

Syntax errors are errors in a MATLAB statement itself, such as spelling or punctuation errors

• illegal operations

• exceeds the dimensions of that matrix

• when the program runs without displaying an error, but produces an unexpected result

• very difficult to find.

  • compare simple test cases with known correct results to find where errors occur

<

>

==

<=

>=

~=

Produces logical result (1 or 0), and &, not ~, or |

&

is true when all of its operands are true

~

is true when its operand is false

|

is true when one or more of its operands are true

1. Parentheses ()

2. Exponentiation (.^)

3. NOT operator (~)

4. Multiplication (.*) and division (./)

5. Addition (+) and subtraction (-)

6. Less than (<), less than or equal to (<=), greater than (>), greater than or equal to (>=), equal to (==), and not equal to (~=)

7. AND operator (&)

8. OR operator (|)

MuPAD, vpa(), variable precision

in between for time and accuracy

Alternatives:

• Rational MuPAD: more accurate, exact result, slowest

• Numeric MATLAB: less accurate, faster, floating point

ischar() input is character array

isfinite() input is finite

isinf() input isinfinite

isletter() input is alphabetic letter

isnumeric() input is numeric array

Verbal description of your plan for writing a program

Written in English or as a combination of MATLAB code and English

graphical approach to creating a coding plan

Epecially appropriate for planning large or complicated programming tasks

allows us to execute a series of statements if a condition is true and to skip those steps if the condition is false

can add else statements and if else

If statements can be nested within each other

Allow you to choose 2 parameters of interest

repeat a block of commands for a specified matrix which is known before the loop is executed

indexed

one loop CAN be written inside another loop

Called a nested loop

Loops are MATLAB constructs that allow a sequence of MATLAB statements to be executed more than once

loops repeat a block of commands as long as an expression is true (1)

The loop ends when the expression is false (0) and any code following the loop (after the end) is then executed

useful for repeating a procedure an unknown number of times as long as a certain statement is true

can be used to acquire data in experiments

useful when a procedure needs to be repeated until a specific criterion is met

tic toc

tic starts the timer

time elapsed since the timer was started is given by the built-in function toc

• function [output1 output2] = function_name(input1, input2, input3)

  • output1 = equation using inputs

  • output2 = equation using inputs

• end

• uiimport(name)

• xlsread(‘filename.xls’) - in matlab folder, read excel

• xlswrite(‘filenamr.xls’, M) - writes array M into excel

• load <filename>

population & linear growth, compound interest

Increasing, asymptotic to the left

y=Ce^kt

radioactive decay, depreciation, fluorescent decay, learning, sales, stress

y=C(1-e^-kt)

y=Ce^-kt

population growth with limiting factors, acidity, sound, sigmodal curve

y=1/(1+be^-kt)

y=a+b*ln(t)

One can change any program written with a for loop into a program written using a while loop instead

Change the index matrix of the for loop into an expression or set of variables that can be used in the while loop

for index → i=0

while i<length(index);

commands;

i=i+1; end

while expression →

for index=data;

if expression break;

end;

commands;

end

1. Binary - fast, complicated, “native” format, .xls, .doc, .mat

2. ASCII - matlab, text editor, simple, .txt, .dat, .cvs

can be used to terminate a loop prematurely

cause termination of the smallest enclosing loop

pre-allocating space for a placeholder variable before entering the loop

fprintf()

Need in the format-string in order for variable to show up in your display on the command window

%d - integer notation

%f - fixed point notation (decimal)

%e - exponential notation

%g - whichever is shorter between %f or %e (insignificant zeros do not print)

%c - character information

%s - string of characters

a probability distribution that is symmetric about the mean, showing that data near the mean are more frequent in occurrence than data far from the mean. In graphical form, it appears as a "bell curve"

MATLAB function for trapezoidal area under the curve

x values vs. z values or normplot(x)

right skew - plot bends up and left

left skew - plot bends down and left

short tail - less variance than expected

long tail - more variance than expected

68%

95%

99.7%

f(x) = gaussmf(x, [std mu])

std is the standard deviation

mu is the mean

x is the parameter under scrutiny

All normal distributions can be converted into the standard normal curve by subtracting the mean and dividing by the standard deviation

The probabilities given the z is in a table

NOT ALL continuous random variables are normally distributed

1. Look at the histogram! Does it appear bell shaped?

2. Compute descriptive summary measures—are mean, median, and mode similar?

3. Do 2/3 of observations lay within 1 std dev of the mean? Do 95% of observations lay within 2 std dev of the mean?

4. Look at a normal probability plot—is it approximately linear?

A value or size

Uncertainty (or Error)

Units

numeric value +- error margin units

• floating point - scientific notation

• rational - exact result

• numeric - normal, general result

Those due to uncertainty in the formulation of the mathematical models and deliberate simplifications of the models

Caused by rounding, data uncertainty, and truncation

Results from using an approximation in place of an exact mathematical procedure

The difference between analytical and numerical solutions

1. Import meaning to data

2. Help obtain data

3. Help solve for specific conditions

full mathematical solution

Eulers, new value = old value + slope*step size, finite difference

0: no change

1st: Linear change with change in x

2nd: Quadratic change with change in x

Polynomial

As the degree of the polynomial approximation INCREASES the MORE accurate the approximation

(adding more terms reduce truncation error)

Incomplete mathematical models

e.g: E=mc²

1. Graphically - rough and inaccurate

2. Trial and Error (using excel) - long winded

3. Automated methods (require an initial guess)

   1. Bracketing Methods - Robust

      • 2 initial guesses that “bracket” the root

   2. Open methods - Faster

      • 1 guess or more but no need to bracket

1. Implicit (cyclic)

2. Explicit (one specific solution)

1. Incremental Search

   • Can work

   • Very inefficient

2. Bisection Method

3. False Position Method

• Given upper and lower bounds (xl and xu)

• [ determine xr, value halfway between xl and xu

• Calculate f(xr)*f(xl) and f(xr)*f(xu), or only one if a root is guaranteed

• A negative value determines the side the root is on. 

• f(xr)*f(xl) = -#, root on the left; f(xr)*f(xu) = -#, root on the right

• Left: xr becomes xu. Right: xr becomes xl ]

• Repeat bracketed until required degree of precision is met

• Linear interpolation, root finding

• Joins F(xl) and F(xu), intersection of line with x-axis = root estimate

• Slope = [ F(xu) - F(xl) ] / [ xu - xl ] =>  [ F(xr) - F(xl) ] / [ xr- xl ]  or xl -> xr

  • xu-xr = [ F(xu)*(xu-xl) ] / [ F(xu) - F(xl) ]

• Issues: multiple roots, one fixed point, poor convergence for high curvature

• faster than other bracketing methods, robust

1. Start with 2 values that bracket a singular root, L and U

2. Calculate slope between the to points (draw line)

3. Where the line crosses the x axis is the x value for R (slope line y=0)

4. Find the correlating y value for the X_r on the function line

5. Last step:

   • If Y_r = 0 done

   • If Y_r * Y_l = pos replace L with R and repeat

   • If Y_r*Y_l = neg replace U with R and repeat

• fast

• divergence issues sometimes

• when they do converge they do so more quickly

• require 1 starting value

• 3 possible results

  • Diverge

  • Converge Overdamped

  • Converge Underdamped

• Types

  • Fixed point iteration

  • Newton Raphson

logarithmic like plot gradually approaching actual value

oscillate around actual value with slowly decreasing amplitude

points away from actual value and gets further away over time

• Root finding open method

• Rearranges function f(x)=0 to x=g(x)

  • done with algebraic manipulation or log or simply adding x to both sides

• We use this to create a formula that predicts a new value of x as a function of a previous value

  • x(i+1) = g(xi)

• Relative error = Ea = | [ x(i+1) - xi ] / x(i+1) | * 100%

• Plot the x vs. g(x). Point of intersection = root

• Spiral convergence or divergence

• x0 -> g(x0) -> x=g(0) at x1 -> x1 -> etc.

Plot the x vs. g(x). Point of intersection = root

• Most widely used root finding method

• Initial guess xi, extend tangent from the point [xi, F(xi)]

• Point where tangent line crosses x-axis becomes improved estimate

• F’(xi) = F(xi) / [ xi - x(i+1) ]

• Fastest convergence, very efficient

• Bad for: multiple roots, high curvature, local minima, sigmodal curves

  • Can have divergence or jumping between roots

  • Local min / max send estimate to - or + infinity lkk

• x(i+1) = xi - F(xi)/F’(xi)

• Backwards/Secant: x(i+1) = xi - F(xi) * [ xj - x(j-1) ] / [ F(xj) - F(xj-1) ]

• fzero(function, guess) → fzero( @x x²-9, 4)

  • Combo of bisection, secant, and inverse quadratic interpolation

  • can have guess as an interval [0 4] for positive roots

• Polynomial - r=roots(c)  being a row matrix of the coefficients of the equation

• Opp: poly(r) = coefficients

• Forward Difference 

  • Slope = [ F(i+1) - F(i) ] / [ x(i+1) - x(i) ]

• Backwards Difference 

  • Slope = [ F(i) - F(i+1) ] / [ x(i) - x(i+1) ]

• Centered Difference

  • Slope = [ F(i+1) - F(i-1) ] / [ x(i+1) - x(i-1) ]