diff --git a/lecture_17/in-class_regression.pdf b/lecture_17/in-class_regression.pdf
new file mode 100644
index 0000000..628b495
Binary files /dev/null and b/lecture_17/in-class_regression.pdf differ
diff --git a/lecture_17/lecture_17.ipynb b/lecture_17/lecture_17.ipynb
index 3159c42..35e61da 100644
--- a/lecture_17/lecture_17.ipynb
+++ b/lecture_17/lecture_17.ipynb
@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 65,
+ "execution_count": 4,
"metadata": {
"collapsed": true
},
@@ -13,7 +13,7 @@
},
{
"cell_type": "code",
- "execution_count": 66,
+ "execution_count": 5,
"metadata": {
"collapsed": true
},
@@ -2218,7 +2218,7 @@
},
{
"cell_type": "code",
- "execution_count": 93,
+ "execution_count": 6,
"metadata": {
"collapsed": false
},
@@ -2385,7 +2385,7 @@
},
{
"cell_type": "code",
- "execution_count": 94,
+ "execution_count": 7,
"metadata": {
"collapsed": false
},
@@ -2409,7 +2409,7 @@
},
{
"cell_type": "code",
- "execution_count": 95,
+ "execution_count": 8,
"metadata": {
"collapsed": false
},
diff --git a/lecture_17/octave-workspace b/lecture_17/octave-workspace
index 52eed6b..c9ec2aa 100644
Binary files a/lecture_17/octave-workspace and b/lecture_17/octave-workspace differ
diff --git a/lecture_18/.Newtint.m.swp b/lecture_18/.Newtint.m.swp
new file mode 100644
index 0000000..769fe2b
Binary files /dev/null and b/lecture_18/.Newtint.m.swp differ
diff --git a/lecture_18/.ipynb_checkpoints/lecture_18-checkpoint.ipynb b/lecture_18/.ipynb_checkpoints/lecture_18-checkpoint.ipynb
new file mode 100644
index 0000000..2fd6442
--- /dev/null
+++ b/lecture_18/.ipynb_checkpoints/lecture_18-checkpoint.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/lecture_18/Newtint.m b/lecture_18/Newtint.m
new file mode 100644
index 0000000..e4c6c83
--- /dev/null
+++ b/lecture_18/Newtint.m
@@ -0,0 +1,34 @@
+function yint = Newtint(x,y,xx)
+% Newtint: Newton interpolating polynomial
+% yint = Newtint(x,y,xx): Uses an (n - 1)-order Newton
+% interpolating polynomial based on n data points (x, y)
+% to determine a value of the dependent variable (yint)
+% at a given value of the independent variable, xx.
+% input:
+% x = independent variable
+% y = dependent variable
+% xx = value of independent variable at which
+% interpolation is calculated
+% output:
+% yint = interpolated value of dependent variable
+
+% compute the finite divided differences in the form of a
+% difference table
+n = length(x);
+if length(y)~=n, error('x and y must be same length'); end
+b = zeros(n,n);
+% assign dependent variables to the first column of b.
+b(:,1) = y(:); % the (:) ensures that y is a column vector.
+for j = 2:n
+ for i = 1:n-j+1
+ b(i,j) = (b(i+1,j-1)-b(i,j-1))/(x(i+j-1)-x(i));
+ end
+end
+%b
+% use the finite divided differences to interpolate
+xt = 1;
+yint = b(1,1);
+for j = 1:n-1
+ xt = xt*(xx-x(j));
+ yint = yint+b(1,j+1)*xt;
+end
diff --git a/lecture_18/challenger_oring.csv b/lecture_18/challenger_oring.csv
new file mode 100644
index 0000000..11d647e
--- /dev/null
+++ b/lecture_18/challenger_oring.csv
@@ -0,0 +1,24 @@
+Flight#,Temp,O-Ring Problem
+1,53,1
+2,57,1
+3,58,1
+4,63,1
+5,66,0
+6,66.8,0
+7,67,0
+8,67.2,0
+9,68,0
+10,69,0
+11,69.8,1
+12,69.8,0
+13,70.2,1
+14,70.2,0
+15,72,0
+16,73,0
+17,75,0
+18,75,1
+19,75.8,0
+20,76.2,0
+21,78,0
+22,79,0
+23,81,0
diff --git a/lecture_18/lecture_18.ipynb b/lecture_18/lecture_18.ipynb
new file mode 100644
index 0000000..bf7731c
--- /dev/null
+++ b/lecture_18/lecture_18.ipynb
@@ -0,0 +1,2193 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 146,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "setdefaults"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 107,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "%plot --format svg"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 115,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ans =\n",
+ "\n",
+ " 0.081014\n",
+ " 0.317493\n",
+ " 0.690279\n",
+ " 1.169170\n",
+ " 1.715370\n",
+ " 2.284630\n",
+ " 2.830830\n",
+ " 3.309721\n",
+ " 3.682507\n",
+ " 3.918986\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "N=10;\n",
+ "A_beam=diag(ones(N,1))*2+diag(ones(N-1,1)*-1,-1)+diag(ones(N-1,1)*-1,1);\n",
+ "[v,e]=eig(A_beam);\n",
+ "diag(e)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Nonlinear Regression\n",
+ "\n",
+ "We can define any function and minimize the sum of squares error even if the constants cannot be separated.\n",
+ "\n",
+ "$S_{r}=\\left[y-f(z_{1},z_{2},...)\\right]^{2}$\n",
+ "\n",
+ "Consider the function, \n",
+ "\n",
+ "$f(x) = a_{0}(1-e^{a_{1}x})$\n",
+ "\n",
+ "We can define the sum of squares error as a function of $a_{0}$ and $a_{1}$:\n",
+ "\n",
+ "$f_{SSE}(a_{0},a_{1})=\\sum_{i=1}^{n}\\left[y- a_{0}(1-e^{a_{1}x})\\right]^{2}$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "function [SSE,yhat] = sse_nonlin_exp(a,x,y)\n",
+ " % This is a sum of squares error function based on \n",
+ " % the two input constants a0 and a1 where a=[a0,a1]\n",
+ " % and the data is x (independent), y (dependent)\n",
+ " % and yhat is the model with the given a0 and a1 values\n",
+ " a0=a(1);\n",
+ " a1=a(2);\n",
+ " yhat=a0*(1-exp(a1*x));\n",
+ " SSE=sum((y-a0*(1-exp(a1*x))).^2);\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Where the data we are fitting is:\n",
+ "\n",
+ "| x | y |\n",
+ "|---|---|\n",
+ " | 0.0 | 0.41213|\n",
+ " | 1.0 | -2.65190|\n",
+ " | 2.0 | 15.04049|\n",
+ " | 3.0 | 5.19368|\n",
+ " | 4.0 | -0.71086|\n",
+ " | 5.0 | 12.69008|\n",
+ " | 6.0 | 29.20309|\n",
+ " | 7.0 | 58.68879|\n",
+ " | 8.0 | 91.61117|\n",
+ " | 9.0 | 173.75492|\n",
+ " | 10.0 | 259.04083|"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "data=[\n",
+ " 0.00000 0.41213\n",
+ " 1.00000 -2.65190\n",
+ " 2.00000 15.04049\n",
+ " 3.00000 5.19368\n",
+ " 4.00000 -0.71086\n",
+ " 5.00000 12.69008\n",
+ " 6.00000 29.20309\n",
+ " 7.00000 58.68879\n",
+ " 8.00000 91.61117\n",
+ " 9.00000 173.75492\n",
+ " 10.00000 259.04083\n",
+ "\n",
+ "];\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 116,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "the sum of squares for a0=-2.00 and a1=0.20 is 98118.4\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "[SSE,yhat]=sse_nonlin_exp([-2,0.2],data(:,1),data(:,2));\n",
+ "fprintf('the sum of squares for a0=%1.2f and a1=%1.2f is %1.1f',...\n",
+ "-2,0.2,SSE)\n",
+ "plot(data(:,1),data(:,2),'o',data(:,1),yhat)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 127,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a =\n",
+ "\n",
+ " -1.71891 0.50449\n",
+ "\n",
+ "fsse = 633.70\n"
+ ]
+ }
+ ],
+ "source": [
+ "[a,fsse]=fminsearch(@(a) sse_nonlin_exp(a,data(:,1),data(:,2)),[-2,0.2])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 128,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "[sse,yhat]=sse_nonlin_exp(a,data(:,1),data(:,2));\n",
+ "plot(data(:,1),data(:,2),'o',data(:,1),yhat)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 130,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "[sse,yhat]=sse_nonlin_exp(a,data(:,1),data(:,2));\n",
+ "plot(data(:,1),data(:,2)-yhat)\n",
+ "title('residuals of function')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Case Study: Logistic Regression\n",
+ "\n",
+ "Many times the variable you predict is a binary (or discrete) value, such as pass/fail, broken/not-broken, etc. \n",
+ "\n",
+ "One method to fit this type of data is called [**logistic regression**](https://en.wikipedia.org/wiki/Logistic_regression).\n",
+ "\n",
+ "[Logistic Regression link 2](http://www.holehouse.org/mlclass/06_Logistic_Regression.html)\n",
+ "\n",
+ "We use a function that varies from 0 to 1 called a logistic function:\n",
+ "\n",
+ "$\\sigma(t)=\\frac{1}{1+e^{-t}}$\n",
+ "\n",
+ "We can use this function to describe the likelihood of failure (1) or success (0). When t=0, the probability of failure is 50%. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 131,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "t=linspace(-10,10);\n",
+ "sigma=@(t) 1./(1+exp(-t));\n",
+ "plot(t,sigma(t))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we make the assumption that we can predict the boundary between the pass-fail criteria with a function of our independent variable e.g.\n",
+ "\n",
+ "$y=\\left\\{\\begin{array}{cc} \n",
+ "1 & a_{0}+a_{1}x +\\epsilon >0 \\\\\n",
+ "0 & else \\end{array} \\right\\}$\n",
+ "\n",
+ "so the logistic function is now:\n",
+ "\n",
+ "$\\sigma(x)=\\frac{1}{1+e^{-(a_{0}+a_{1}x)}}$\n",
+ "\n",
+ "Here, there is not a direct sum of squares error, so we minimize a cost function: \n",
+ "\n",
+ "$J(a_{0},a_{1})=\\sum_{i=1}^{n}\\left[-y_{i}\\log(\\sigma(x_{i}))-(1-y_{i})\\log((1-\\sigma(x_{i})))\\right]$\n",
+ "\n",
+ "y=0,1 \n",
+ "\n",
+ "So the cost function either sums the "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Example: Challenger O-ring failures\n",
+ "\n",
+ "The O-rings on the Challenger shuttles had problems when temperatures became low. We can look at the conditions when damage was observed to determine the likelihood of failure. \n",
+ "\n",
+ "[Challenger O-ring data powerpoint](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwjZvL7jkP3SAhUp04MKHXkXDkMQFggcMAA&url=http%3A%2F%2Fwww.stat.ufl.edu%2F~winner%2Fcases%2Fchallenger.ppt&usg=AFQjCNFyjwT7NmRthDkDEgch75Fc5dc66w&sig2=_qeteX6-ZEBwPW8SZN1mIA)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 132,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "oring =\n",
+ "\n",
+ " 1.00000 53.00000 1.00000\n",
+ " 2.00000 57.00000 1.00000\n",
+ " 3.00000 58.00000 1.00000\n",
+ " 4.00000 63.00000 1.00000\n",
+ " 5.00000 66.00000 0.00000\n",
+ " 6.00000 66.80000 0.00000\n",
+ " 7.00000 67.00000 0.00000\n",
+ " 8.00000 67.20000 0.00000\n",
+ " 9.00000 68.00000 0.00000\n",
+ " 10.00000 69.00000 0.00000\n",
+ " 11.00000 69.80000 1.00000\n",
+ " 12.00000 69.80000 0.00000\n",
+ " 13.00000 70.20000 1.00000\n",
+ " 14.00000 70.20000 0.00000\n",
+ " 15.00000 72.00000 0.00000\n",
+ " 16.00000 73.00000 0.00000\n",
+ " 17.00000 75.00000 0.00000\n",
+ " 18.00000 75.00000 1.00000\n",
+ " 19.00000 75.80000 0.00000\n",
+ " 20.00000 76.20000 0.00000\n",
+ " 21.00000 78.00000 0.00000\n",
+ " 22.00000 79.00000 0.00000\n",
+ " 23.00000 81.00000 0.00000\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "% read data from csv file \n",
+ "% col 1 = index\n",
+ "% col 2 = temperature\n",
+ "% col 3 = 1 if damaged, 0 if undamaged\n",
+ "oring=dlmread('challenger_oring.csv',',',1,0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 134,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot(oring(:,2),oring(:,3),'o')\n",
+ "xlabel('Temp (F)')\n",
+ "ylabel('failure (1)/ pass (0)')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 135,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "function J=sse_logistic(a,x,y)\n",
+ " % Create function to calculate cost of logistic function\n",
+ " % t = a0+a1*x\n",
+ " % sigma(t) = 1./(1+e^(-t))\n",
+ " sigma=@(t) 1./(1+exp(-t));\n",
+ " a0=a(1);\n",
+ " a1=a(2);\n",
+ " t=a0+a1*x;\n",
+ " J = 1/length(x)*sum(-y.*log(sigma(t))-(1-y).*log(1-sigma(t)));\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 142,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "J = 0.88822\n",
+ "a =\n",
+ "\n",
+ " 15.03501 -0.23205\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "J=sse_logistic([10,-0.2],oring(:,2),oring(:,3))\n",
+ "a=fminsearch(@(a) sse_logistic(a,oring(:,2),oring(:,3)),[0,-3])\n",
+ "\n",
+ "T=linspace(50,85);\n",
+ "plot(oring(:,2),oring(:,3),'o',T,sigma(a(1)+a(2)*T),T,a(1)+a(2)*T)\n",
+ "axis([50,85,-0.1,1.2])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 139,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "probability of failure when 70 degrees is 23.00% \n",
+ "probability of failure when 60 degrees is 75.25%\n",
+ "probability of failure when 36 degrees is 99.87%\n"
+ ]
+ }
+ ],
+ "source": [
+ "fprintf('probability of failure when 70 degrees is %1.2f%% ',100*sigma(a(1)+a(2)*70))\n",
+ "fprintf('probability of failure when 60 degrees is %1.2f%%',100*sigma(a(1)+a(2)*60))\n",
+ "fprintf('probability of failure when 36 degrees is %1.2f%%',100*sigma(a(1)+a(2)*36))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Interpolation\n",
+ "\n",
+ "Using regression (linear and nonlinear) you are faced with the problem, that you have lots of noisy data and you want to fit a physical model to it. \n",
+ "\n",
+ "You can use interpolation to solve the opposite problem, you have a little data with very little noise.\n",
+ "\n",
+ "## Linear interpolation\n",
+ "\n",
+ "If you are trying to find the value of f(x) for x between $x_{1}$ and $x_{2}$, then you can match the slopes\n",
+ "\n",
+ "$\\frac{f(x)-f(x_{1})}{x-x_{1}}=\\frac{f(x_{2})-f(x_{1})}{x_{2}-x_{1}}$\n",
+ "\n",
+ "or\n",
+ "\n",
+ "$f(x)=f(x_{1})+(x-x_{1})\\frac{f(x_{2})-f(x_{1})}{x_{2}-x_{1}}$\n",
+ "\n",
+ "### Example: Logarithms\n",
+ "\n",
+ "Engineers used to have to use interpolation in logarithm tables for calculations. Find ln(2) from \n",
+ "\n",
+ "a. ln(1) and ln(6)\n",
+ "\n",
+ "b. ln(1) and ln(4)\n",
+ "\n",
+ "c. just calculate it as ln(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 149,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ln(2)~0.358352\n",
+ "ln(2)~0.462098\n",
+ "ln(2)~0.549306\n",
+ "ln(2)=0.693147\n"
+ ]
+ }
+ ],
+ "source": [
+ "ln2_16=log(1)+(log(6)-log(1))/(6-1)*(2-1);\n",
+ "fprintf('ln(2)~%f\\n',ln2_16)\n",
+ "ln2_14=log(1)+(log(4)-log(1))/(4-1)*(2-1);\n",
+ "ln2_13=log(1)+(log(3)-log(1))/(3-1)*(2-1);\n",
+ "fprintf('ln(2)~%f\\n',ln2_14)\n",
+ "fprintf('ln(2)~%f\\n',ln2_13)\n",
+ "ln2=log(2);\n",
+ "fprintf('ln(2)=%f\\n',ln2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 147,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x=linspace(1,6);\n",
+ "plot(x,log(x),2,log(2),'*',...\n",
+ "[1,2,6],[log(1),ln2_16,log(6)],'o-',...\n",
+ "[1,2,4],[log(1),ln2_14,log(4)],'s-')\n",
+ "ylabel('ln(x)')\n",
+ "xlabel('x')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Quadratic interpolation (intro curvature)\n",
+ "\n",
+ "Assume function is parabola between 3 points. The function is can be written as:\n",
+ "\n",
+ "$f_{2}(x)=b_{1}+b_{2}(x-x_{1})+b_{3}(x-x_{1})(x-x_{2})$\n",
+ "\n",
+ "When $x=x_{1}$\n",
+ "\n",
+ "$f(x_{1})=b_{1}$\n",
+ "\n",
+ "when $x=x_{2}$\n",
+ "\n",
+ "$b_{2}=\\frac{f(x_{2})-f(x_{1})}{x_{2}-x_{1}}$\n",
+ "\n",
+ "when $x=x_{3}$\n",
+ "\n",
+ "$b_{3}=\\frac{\\frac{f(x_{3})-f(x_{2})}{x_{3}-x_{2}}\n",
+ "-\\frac{f(x_{2})-f(x_{1})}{x_{2}-x_{1}}}{x_{3}-x_{1}}$\n",
+ "\n",
+ "#### Reexamining the ln(2) with ln(1), ln(4), and ln(6):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 154,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Z =\n",
+ "\n",
+ " 1 1 1\n",
+ " 1 4 16\n",
+ " 1 600 360000\n",
+ "\n",
+ "ans = 5.1766e+05\n",
+ "ans =\n",
+ "\n",
+ " -4.6513e-01\n",
+ " 4.6589e-01\n",
+ " -7.5741e-04\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=[1,4,600]';\n",
+ "Z=[x.^0,x.^1,x.^2]\n",
+ "cond(Z)\n",
+ "Z\\log(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 155,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "b1 = 0\n",
+ "b2 = 0.46210\n",
+ "b3 = -0.051873\n"
+ ]
+ }
+ ],
+ "source": [
+ "x1=1;\n",
+ "x2=4;\n",
+ "x3=6;\n",
+ "f1=log(x1);\n",
+ "f2=log(x2);\n",
+ "f3=log(x3);\n",
+ "\n",
+ "b1=f1\n",
+ "b2=(f2-b1)/(x2-x1)\n",
+ "b3=(f3-f2)/(x3-x2)-b2;\n",
+ "b3=b3/(x3-x1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 157,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ans = 0.56584\r\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x=linspace(1,6);\n",
+ "f=@(x) b1+b2*(x-x1)+b3*(x-x1).*(x-x2);\n",
+ "plot(x,log(x),2,log(2),'*',...\n",
+ "[1,4,6],[log(1),log(4),log(6)],'ro',...\n",
+ "x,f(x),'r-',2,f(2),'s')\n",
+ "f(2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Newton's Interpolating Polynomials\n",
+ "\n",
+ "For n-data points, we can fit an (n-1)th-polynomial\n",
+ "\n",
+ "$f_{n-1}(x)=b_{1}+b_{2}(x-x_{1})+\\cdots+b_{n}(x-x_{1})(x-x_{2})\\cdots(x-x_{n})$\n",
+ "\n",
+ "where \n",
+ "\n",
+ "$b_{1}=f(x_{1})$\n",
+ "\n",
+ "$b_{2}=\\frac{f(x_{2})-f(x_{1})}{x_{2}-x_{1}}$\n",
+ "\n",
+ "$b_{3}=\\frac{\\frac{f(x_{3})-f(x_{2})}{x_{3}-x_{2}}\n",
+ "-b_{2}}{x_{3}-x_{1}}$\n",
+ "\n",
+ "$\\vdots$\n",
+ "\n",
+ "$b_{n}=f(x_{n},x_{n-1},...,x_{2},x_{1})\n",
+ "=\\frac{f(x_{n},x_{n-1},...x_{2})-f(x_{n-1},x_{n-2},...,x_{1})}{x_{n}-x_{1}}$\n",
+ "\n",
+ "**e.g. for 4 data points:**\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 160,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "b =\n",
+ "\n",
+ " 0.00000 0.54931 -0.08721 0.01178\n",
+ " 1.09861 0.28768 -0.02832 0.00000\n",
+ " 1.38629 0.20273 0.00000 0.00000\n",
+ " 1.79176 0.00000 0.00000 0.00000\n",
+ "\n",
+ "ans = 0.66007\n",
+ "ans =\n",
+ "\n",
+ " 0.00000\n",
+ " 1.09861\n",
+ " 1.38629\n",
+ " 1.79176\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "Newtint([1,3,4,6],log([1,3,4,6]),2)\n",
+ "log([1,3,4,6]')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 162,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ln(2)=0.693147\n",
+ "ln(2)~0.366349\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "\n",
+ "\n",
+ "x=[0.2,3,10,20,50,60]; % define independent var's\n",
+ "y=log(x); % define dependent var's\n",
+ "xx=linspace(min(x),max(x));\n",
+ "yy=zeros(size(xx));\n",
+ "for i=1:length(xx)\n",
+ " yy(i)=Newtint(x,y,xx(i));\n",
+ "end\n",
+ "plot(xx,log(xx),2,log(2),'*',...\n",
+ "x,y,'ro',...\n",
+ "xx,yy,'r-')\n",
+ "\n",
+ "fprintf('ln(2)=%f',log(2))\n",
+ "fprintf('ln(2)~%f',Newtint(x,y,2))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Octave",
+ "language": "octave",
+ "name": "octave"
+ },
+ "language_info": {
+ "file_extension": ".m",
+ "help_links": [
+ {
+ "text": "MetaKernel Magics",
+ "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
+ }
+ ],
+ "mimetype": "text/x-octave",
+ "name": "octave",
+ "version": "0.19.14"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/lecture_18/newton_interpolation.png b/lecture_18/newton_interpolation.png
new file mode 100644
index 0000000..5990cb5
Binary files /dev/null and b/lecture_18/newton_interpolation.png differ
diff --git a/lecture_18/octave-workspace b/lecture_18/octave-workspace
new file mode 100644
index 0000000..c651696
Binary files /dev/null and b/lecture_18/octave-workspace differ
diff --git a/lecture_19/.ipynb_checkpoints/lecture 19-checkpoint.ipynb b/lecture_19/.ipynb_checkpoints/lecture 19-checkpoint.ipynb
new file mode 100644
index 0000000..2911efe
--- /dev/null
+++ b/lecture_19/.ipynb_checkpoints/lecture 19-checkpoint.ipynb
@@ -0,0 +1,497 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "setdefaults"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "%plot --format svg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Splines (Brief introduction before next section)\n",
+ "\n",
+ "Following interpolation discussion, instead of estimating 9 data points with an eighth-order polynomial, it makes more sense to fit sections of the curve to lower-order polynomials:\n",
+ "\n",
+ "0. zeroth-order (nearest neighbor)\n",
+ "\n",
+ "1. first-order (linear interpolation)\n",
+ "\n",
+ "2. third-order (cubic interpolation)\n",
+ "\n",
+ "Matlab and Octave have built-in functions for 1D and 2D interpolation:\n",
+ "\n",
+ "`interp1`\n",
+ "\n",
+ "`interp2`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'interp1' is a function from the file /usr/share/octave/4.0.0/m/general/interp1.m\n",
+ "\n",
+ " -- Function File: YI = interp1 (X, Y, XI)\n",
+ " -- Function File: YI = interp1 (Y, XI)\n",
+ " -- Function File: YI = interp1 (..., METHOD)\n",
+ " -- Function File: YI = interp1 (..., EXTRAP)\n",
+ " -- Function File: YI = interp1 (..., \"left\")\n",
+ " -- Function File: YI = interp1 (..., \"right\")\n",
+ " -- Function File: PP = interp1 (..., \"pp\")\n",
+ "\n",
+ " One-dimensional interpolation.\n",
+ "\n",
+ " Interpolate input data to determine the value of YI at the points\n",
+ " XI. If not specified, X is taken to be the indices of Y ('1:length\n",
+ " (Y)'). If Y is a matrix or an N-dimensional array, the\n",
+ " interpolation is performed on each column of Y.\n",
+ "\n",
+ " The interpolation METHOD is one of:\n",
+ "\n",
+ " \"nearest\"\n",
+ " Return the nearest neighbor.\n",
+ "\n",
+ " \"previous\"\n",
+ " Return the previous neighbor.\n",
+ "\n",
+ " \"next\"\n",
+ " Return the next neighbor.\n",
+ "\n",
+ " \"linear\" (default)\n",
+ " Linear interpolation from nearest neighbors.\n",
+ "\n",
+ " \"pchip\"\n",
+ " Piecewise cubic Hermite interpolating\n",
+ " polynomial--shape-preserving interpolation with smooth first\n",
+ " derivative.\n",
+ "\n",
+ " \"cubic\"\n",
+ " Cubic interpolation (same as \"pchip\").\n",
+ "\n",
+ " \"spline\"\n",
+ " Cubic spline interpolation--smooth first and second\n",
+ " derivatives throughout the curve.\n",
+ "\n",
+ " Adding '*' to the start of any method above forces 'interp1' to\n",
+ " assume that X is uniformly spaced, and only 'X(1)' and 'X(2)' are\n",
+ " referenced. This is usually faster, and is never slower. The\n",
+ " default method is \"linear\".\n",
+ "\n",
+ " If EXTRAP is the string \"extrap\", then extrapolate values beyond\n",
+ " the endpoints using the current METHOD. If EXTRAP is a number,\n",
+ " then replace values beyond the endpoints with that number. When\n",
+ " unspecified, EXTRAP defaults to 'NA'.\n",
+ "\n",
+ " If the string argument \"pp\" is specified, then XI should not be\n",
+ " supplied and 'interp1' returns a piecewise polynomial object. This\n",
+ " object can later be used with 'ppval' to evaluate the\n",
+ " interpolation. There is an equivalence, such that 'ppval (interp1\n",
+ " (X, Y, METHOD, \"pp\"), XI) == interp1 (X, Y, XI, METHOD, \"extrap\")'.\n",
+ "\n",
+ " Duplicate points in X specify a discontinuous interpolant. There\n",
+ " may be at most 2 consecutive points with the same value. If X is\n",
+ " increasing, the default discontinuous interpolant is\n",
+ " right-continuous. If X is decreasing, the default discontinuous\n",
+ " interpolant is left-continuous. The continuity condition of the\n",
+ " interpolant may be specified by using the options \"left\" or \"right\"\n",
+ " to select a left-continuous or right-continuous interpolant,\n",
+ " respectively. Discontinuous interpolation is only allowed for\n",
+ " \"nearest\" and \"linear\" methods; in all other cases, the X-values\n",
+ " must be unique.\n",
+ "\n",
+ " An example of the use of 'interp1' is\n",
+ "\n",
+ " xf = [0:0.05:10];\n",
+ " yf = sin (2*pi*xf/5);\n",
+ " xp = [0:10];\n",
+ " yp = sin (2*pi*xp/5);\n",
+ " lin = interp1 (xp, yp, xf);\n",
+ " near = interp1 (xp, yp, xf, \"nearest\");\n",
+ " pch = interp1 (xp, yp, xf, \"pchip\");\n",
+ " spl = interp1 (xp, yp, xf, \"spline\");\n",
+ " plot (xf,yf,\"r\", xf,near,\"g\", xf,lin,\"b\", xf,pch,\"c\", xf,spl,\"m\",\n",
+ " xp,yp,\"r*\");\n",
+ " legend (\"original\", \"nearest\", \"linear\", \"pchip\", \"spline\");\n",
+ "\n",
+ " See also: pchip, spline, interpft, interp2, interp3, interpn.\n",
+ "\n",
+ "Additional help for built-in functions and operators is\n",
+ "available in the online version of the manual. Use the command\n",
+ "'doc ' to search the manual index.\n",
+ "\n",
+ "Help and information about Octave is also available on the WWW\n",
+ "at http://www.octave.org and via the help@octave.org\n",
+ "mailing list.\n"
+ ]
+ }
+ ],
+ "source": [
+ "help interp1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'interp2' is a function from the file /usr/share/octave/4.0.0/m/general/interp2.m\n",
+ "\n",
+ " -- Function File: ZI = interp2 (X, Y, Z, XI, YI)\n",
+ " -- Function File: ZI = interp2 (Z, XI, YI)\n",
+ " -- Function File: ZI = interp2 (Z, N)\n",
+ " -- Function File: ZI = interp2 (Z)\n",
+ " -- Function File: ZI = interp2 (..., METHOD)\n",
+ " -- Function File: ZI = interp2 (..., METHOD, EXTRAP)\n",
+ "\n",
+ " Two-dimensional interpolation.\n",
+ "\n",
+ " Interpolate reference data X, Y, Z to determine ZI at the\n",
+ " coordinates XI, YI. The reference data X, Y can be matrices, as\n",
+ " returned by 'meshgrid', in which case the sizes of X, Y, and Z must\n",
+ " be equal. If X, Y are vectors describing a grid then 'length (X)\n",
+ " == columns (Z)' and 'length (Y) == rows (Z)'. In either case the\n",
+ " input data must be strictly monotonic.\n",
+ "\n",
+ " If called without X, Y, and just a single reference data matrix Z,\n",
+ " the 2-D region 'X = 1:columns (Z), Y = 1:rows (Z)' is assumed.\n",
+ " This saves memory if the grid is regular and the distance between\n",
+ " points is not important.\n",
+ "\n",
+ " If called with a single reference data matrix Z and a refinement\n",
+ " value N, then perform interpolation over a grid where each original\n",
+ " interval has been recursively subdivided N times. This results in\n",
+ " '2^N-1' additional points for every interval in the original grid.\n",
+ " If N is omitted a value of 1 is used. As an example, the interval\n",
+ " [0,1] with 'N==2' results in a refined interval with points at [0,\n",
+ " 1/4, 1/2, 3/4, 1].\n",
+ "\n",
+ " The interpolation METHOD is one of:\n",
+ "\n",
+ " \"nearest\"\n",
+ " Return the nearest neighbor.\n",
+ "\n",
+ " \"linear\" (default)\n",
+ " Linear interpolation from nearest neighbors.\n",
+ "\n",
+ " \"pchip\"\n",
+ " Piecewise cubic Hermite interpolating\n",
+ " polynomial--shape-preserving interpolation with smooth first\n",
+ " derivative.\n",
+ "\n",
+ " \"cubic\"\n",
+ " Cubic interpolation (same as \"pchip\").\n",
+ "\n",
+ " \"spline\"\n",
+ " Cubic spline interpolation--smooth first and second\n",
+ " derivatives throughout the curve.\n",
+ "\n",
+ " EXTRAP is a scalar number. It replaces values beyond the endpoints\n",
+ " with EXTRAP. Note that if EXTRAPVAL is used, METHOD must be\n",
+ " specified as well. If EXTRAP is omitted and the METHOD is\n",
+ " \"spline\", then the extrapolated values of the \"spline\" are used.\n",
+ " Otherwise the default EXTRAP value for any other METHOD is \"NA\".\n",
+ "\n",
+ " See also: interp1, interp3, interpn, meshgrid.\n",
+ "\n",
+ "Additional help for built-in functions and operators is\n",
+ "available in the online version of the manual. Use the command\n",
+ "'doc ' to search the manual index.\n",
+ "\n",
+ "Help and information about Octave is also available on the WWW\n",
+ "at http://www.octave.org and via the help@octave.org\n",
+ "mailing list.\n"
+ ]
+ }
+ ],
+ "source": [
+ "help interp2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x=linspace(-pi,pi,9);\n",
+ "xi=linspace(-pi,pi,100);\n",
+ "y=sin(x);\n",
+ "yi_lin=interp1(x,y,xi,'linear');\n",
+ "yi_spline=interp1(x,y,xi,'spline'); \n",
+ "yi_cubic=interp1(x,y,xi,'cubic');\n",
+ "plot(x,y,'o',xi,yi_lin,xi,yi_spline,xi,yi_cubic)\n",
+ "axis([-pi,pi,-1.5,1.5])\n",
+ "legend('data','linear','cubic spline','piecewise cubic','Location','NorthWest')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Example: Accelerate then hold velocity\n",
+ "\n",
+ "Here the time is given as vector t in seconds and the "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "t=[0 2 40 56 68 80 84 96 104 110]';\n",
+ "v=[0 20 20 38 80 80 100 100 125 125]';\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Octave",
+ "language": "octave",
+ "name": "octave"
+ },
+ "language_info": {
+ "file_extension": ".m",
+ "help_links": [
+ {
+ "text": "MetaKernel Magics",
+ "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
+ }
+ ],
+ "mimetype": "text/x-octave",
+ "name": "octave",
+ "version": "0.19.14"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/lecture_19/Newtint.m b/lecture_19/Newtint.m
new file mode 100644
index 0000000..e4c6c83
--- /dev/null
+++ b/lecture_19/Newtint.m
@@ -0,0 +1,34 @@
+function yint = Newtint(x,y,xx)
+% Newtint: Newton interpolating polynomial
+% yint = Newtint(x,y,xx): Uses an (n - 1)-order Newton
+% interpolating polynomial based on n data points (x, y)
+% to determine a value of the dependent variable (yint)
+% at a given value of the independent variable, xx.
+% input:
+% x = independent variable
+% y = dependent variable
+% xx = value of independent variable at which
+% interpolation is calculated
+% output:
+% yint = interpolated value of dependent variable
+
+% compute the finite divided differences in the form of a
+% difference table
+n = length(x);
+if length(y)~=n, error('x and y must be same length'); end
+b = zeros(n,n);
+% assign dependent variables to the first column of b.
+b(:,1) = y(:); % the (:) ensures that y is a column vector.
+for j = 2:n
+ for i = 1:n-j+1
+ b(i,j) = (b(i+1,j-1)-b(i,j-1))/(x(i+j-1)-x(i));
+ end
+end
+%b
+% use the finite divided differences to interpolate
+xt = 1;
+yint = b(1,1);
+for j = 1:n-1
+ xt = xt*(xx-x(j));
+ yint = yint+b(1,j+1)*xt;
+end
diff --git a/lecture_19/lecture 19.ipynb b/lecture_19/lecture 19.ipynb
new file mode 100644
index 0000000..e6f9f76
--- /dev/null
+++ b/lecture_19/lecture 19.ipynb
@@ -0,0 +1,1488 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "setdefaults"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "%plot --format svg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Questions from last class\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "#### Other:\n",
+ "\n",
+ "Twice the amount of points needed\n",
+ "\n",
+ "depends on what order polynomial it is and how far the data needs to be extrapolated \n",
+ "\n",
+ "As man you as possible \n",
+ "\n",
+ "Never extrapolate unless linear interpolation.\n",
+ "\n",
+ "You shouldn't. 2 if the linear is a good fit for the region, and you absolutely have to.\n",
+ "\n",
+ "Wait can you do that?\n",
+ "\n",
+ "Don't use extrapolation\n",
+ "\n",
+ "do not extrapolate\n",
+ "\n",
+ "As many data points as you have\n",
+ "\n",
+ "the more the better so that the best polynomial can be made through the data points\n",
+ "\n",
+ "Twice the amount of points needed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Questions from you\n",
+ "\n",
+ "- when will the project assignment be finalized? Also do you pronounce it \"jiff\" or \"gif\"?\n",
+ "\n",
+ "- If blue is red and red is blue, then what is purple? \n",
+ "\n",
+ "- How do we open the .ipynb lecture files? Or will the lectures continue to be also saved in pdf (last few have not).\n",
+ "\n",
+ "- When will we be put on teams for the final project?\n",
+ "\n",
+ "- What is the grading rubric for the project?\n",
+ "\n",
+ "- How to sync repository with files from laptop like hw without using Github desktop \n",
+ "\n",
+ "- Are there any upcoming deadlines for the project?\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Splines (Brief introduction before next section)\n",
+ "\n",
+ "Following interpolation discussion, instead of estimating 9 data points with an eighth-order polynomial, it makes more sense to fit sections of the curve to lower-order polynomials:\n",
+ "\n",
+ "0. zeroth-order (nearest neighbor)\n",
+ "\n",
+ "1. first-order (linear interpolation)\n",
+ "\n",
+ "2. third-order (cubic interpolation)\n",
+ "\n",
+ "Matlab and Octave have built-in functions for 1D and 2D interpolation:\n",
+ "\n",
+ "`interp1`\n",
+ "\n",
+ "`interp2`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'interp1' is a function from the file /usr/share/octave/4.0.0/m/general/interp1.m\n",
+ "\n",
+ " -- Function File: YI = interp1 (X, Y, XI)\n",
+ " -- Function File: YI = interp1 (Y, XI)\n",
+ " -- Function File: YI = interp1 (..., METHOD)\n",
+ " -- Function File: YI = interp1 (..., EXTRAP)\n",
+ " -- Function File: YI = interp1 (..., \"left\")\n",
+ " -- Function File: YI = interp1 (..., \"right\")\n",
+ " -- Function File: PP = interp1 (..., \"pp\")\n",
+ "\n",
+ " One-dimensional interpolation.\n",
+ "\n",
+ " Interpolate input data to determine the value of YI at the points\n",
+ " XI. If not specified, X is taken to be the indices of Y ('1:length\n",
+ " (Y)'). If Y is a matrix or an N-dimensional array, the\n",
+ " interpolation is performed on each column of Y.\n",
+ "\n",
+ " The interpolation METHOD is one of:\n",
+ "\n",
+ " \"nearest\"\n",
+ " Return the nearest neighbor.\n",
+ "\n",
+ " \"previous\"\n",
+ " Return the previous neighbor.\n",
+ "\n",
+ " \"next\"\n",
+ " Return the next neighbor.\n",
+ "\n",
+ " \"linear\" (default)\n",
+ " Linear interpolation from nearest neighbors.\n",
+ "\n",
+ " \"pchip\"\n",
+ " Piecewise cubic Hermite interpolating\n",
+ " polynomial--shape-preserving interpolation with smooth first\n",
+ " derivative.\n",
+ "\n",
+ " \"cubic\"\n",
+ " Cubic interpolation (same as \"pchip\").\n",
+ "\n",
+ " \"spline\"\n",
+ " Cubic spline interpolation--smooth first and second\n",
+ " derivatives throughout the curve.\n",
+ "\n",
+ " Adding '*' to the start of any method above forces 'interp1' to\n",
+ " assume that X is uniformly spaced, and only 'X(1)' and 'X(2)' are\n",
+ " referenced. This is usually faster, and is never slower. The\n",
+ " default method is \"linear\".\n",
+ "\n",
+ " If EXTRAP is the string \"extrap\", then extrapolate values beyond\n",
+ " the endpoints using the current METHOD. If EXTRAP is a number,\n",
+ " then replace values beyond the endpoints with that number. When\n",
+ " unspecified, EXTRAP defaults to 'NA'.\n",
+ "\n",
+ " If the string argument \"pp\" is specified, then XI should not be\n",
+ " supplied and 'interp1' returns a piecewise polynomial object. This\n",
+ " object can later be used with 'ppval' to evaluate the\n",
+ " interpolation. There is an equivalence, such that 'ppval (interp1\n",
+ " (X, Y, METHOD, \"pp\"), XI) == interp1 (X, Y, XI, METHOD, \"extrap\")'.\n",
+ "\n",
+ " Duplicate points in X specify a discontinuous interpolant. There\n",
+ " may be at most 2 consecutive points with the same value. If X is\n",
+ " increasing, the default discontinuous interpolant is\n",
+ " right-continuous. If X is decreasing, the default discontinuous\n",
+ " interpolant is left-continuous. The continuity condition of the\n",
+ " interpolant may be specified by using the options \"left\" or \"right\"\n",
+ " to select a left-continuous or right-continuous interpolant,\n",
+ " respectively. Discontinuous interpolation is only allowed for\n",
+ " \"nearest\" and \"linear\" methods; in all other cases, the X-values\n",
+ " must be unique.\n",
+ "\n",
+ " An example of the use of 'interp1' is\n",
+ "\n",
+ " xf = [0:0.05:10];\n",
+ " yf = sin (2*pi*xf/5);\n",
+ " xp = [0:10];\n",
+ " yp = sin (2*pi*xp/5);\n",
+ " lin = interp1 (xp, yp, xf);\n",
+ " near = interp1 (xp, yp, xf, \"nearest\");\n",
+ " pch = interp1 (xp, yp, xf, \"pchip\");\n",
+ " spl = interp1 (xp, yp, xf, \"spline\");\n",
+ " plot (xf,yf,\"r\", xf,near,\"g\", xf,lin,\"b\", xf,pch,\"c\", xf,spl,\"m\",\n",
+ " xp,yp,\"r*\");\n",
+ " legend (\"original\", \"nearest\", \"linear\", \"pchip\", \"spline\");\n",
+ "\n",
+ " See also: pchip, spline, interpft, interp2, interp3, interpn.\n",
+ "\n",
+ "Additional help for built-in functions and operators is\n",
+ "available in the online version of the manual. Use the command\n",
+ "'doc ' to search the manual index.\n",
+ "\n",
+ "Help and information about Octave is also available on the WWW\n",
+ "at http://www.octave.org and via the help@octave.org\n",
+ "mailing list.\n"
+ ]
+ }
+ ],
+ "source": [
+ "help interp1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'interp2' is a function from the file /usr/share/octave/4.0.0/m/general/interp2.m\n",
+ "\n",
+ " -- Function File: ZI = interp2 (X, Y, Z, XI, YI)\n",
+ " -- Function File: ZI = interp2 (Z, XI, YI)\n",
+ " -- Function File: ZI = interp2 (Z, N)\n",
+ " -- Function File: ZI = interp2 (Z)\n",
+ " -- Function File: ZI = interp2 (..., METHOD)\n",
+ " -- Function File: ZI = interp2 (..., METHOD, EXTRAP)\n",
+ "\n",
+ " Two-dimensional interpolation.\n",
+ "\n",
+ " Interpolate reference data X, Y, Z to determine ZI at the\n",
+ " coordinates XI, YI. The reference data X, Y can be matrices, as\n",
+ " returned by 'meshgrid', in which case the sizes of X, Y, and Z must\n",
+ " be equal. If X, Y are vectors describing a grid then 'length (X)\n",
+ " == columns (Z)' and 'length (Y) == rows (Z)'. In either case the\n",
+ " input data must be strictly monotonic.\n",
+ "\n",
+ " If called without X, Y, and just a single reference data matrix Z,\n",
+ " the 2-D region 'X = 1:columns (Z), Y = 1:rows (Z)' is assumed.\n",
+ " This saves memory if the grid is regular and the distance between\n",
+ " points is not important.\n",
+ "\n",
+ " If called with a single reference data matrix Z and a refinement\n",
+ " value N, then perform interpolation over a grid where each original\n",
+ " interval has been recursively subdivided N times. This results in\n",
+ " '2^N-1' additional points for every interval in the original grid.\n",
+ " If N is omitted a value of 1 is used. As an example, the interval\n",
+ " [0,1] with 'N==2' results in a refined interval with points at [0,\n",
+ " 1/4, 1/2, 3/4, 1].\n",
+ "\n",
+ " The interpolation METHOD is one of:\n",
+ "\n",
+ " \"nearest\"\n",
+ " Return the nearest neighbor.\n",
+ "\n",
+ " \"linear\" (default)\n",
+ " Linear interpolation from nearest neighbors.\n",
+ "\n",
+ " \"pchip\"\n",
+ " Piecewise cubic Hermite interpolating\n",
+ " polynomial--shape-preserving interpolation with smooth first\n",
+ " derivative.\n",
+ "\n",
+ " \"cubic\"\n",
+ " Cubic interpolation (same as \"pchip\").\n",
+ "\n",
+ " \"spline\"\n",
+ " Cubic spline interpolation--smooth first and second\n",
+ " derivatives throughout the curve.\n",
+ "\n",
+ " EXTRAP is a scalar number. It replaces values beyond the endpoints\n",
+ " with EXTRAP. Note that if EXTRAPVAL is used, METHOD must be\n",
+ " specified as well. If EXTRAP is omitted and the METHOD is\n",
+ " \"spline\", then the extrapolated values of the \"spline\" are used.\n",
+ " Otherwise the default EXTRAP value for any other METHOD is \"NA\".\n",
+ "\n",
+ " See also: interp1, interp3, interpn, meshgrid.\n",
+ "\n",
+ "Additional help for built-in functions and operators is\n",
+ "available in the online version of the manual. Use the command\n",
+ "'doc ' to search the manual index.\n",
+ "\n",
+ "Help and information about Octave is also available on the WWW\n",
+ "at http://www.octave.org and via the help@octave.org\n",
+ "mailing list.\n"
+ ]
+ }
+ ],
+ "source": [
+ "help interp2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x=linspace(-pi,pi,9);\n",
+ "xi=linspace(-pi,pi,100);\n",
+ "y=sin(x);\n",
+ "yi_lin=interp1(x,y,xi,'linear');\n",
+ "yi_spline=interp1(x,y,xi,'spline'); \n",
+ "yi_cubic=interp1(x,y,xi,'cubic');\n",
+ "plot(x,y,'o',xi,yi_lin,xi,yi_spline,xi,yi_cubic)\n",
+ "axis([-pi,pi,-1.5,1.5])\n",
+ "legend('data','linear','cubic spline','piecewise cubic','Location','NorthWest')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Example: Accelerate then hold velocity\n",
+ "\n",
+ "Here the time is given as vector t in seconds and the velocity is in mph. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "t=[0 20 40 56 68 80 84 96 104 110]';\n",
+ "v=[0 20 20 38 80 80 100 100 125 125]';\n",
+ "tt=linspace(0,110)';\n",
+ "v_lin=interp1(t,v,tt);\n",
+ "v_spl=interp1(t,v,tt,'spline');\n",
+ "v_cub=interp1(t,v,tt,'cubic');\n",
+ "\n",
+ "plot(t,v,'o',tt,v_lin,tt,v_spl,tt,v_cub)\n",
+ "xlabel('t (s)')\n",
+ "ylabel('v (mph)')\n",
+ "legend('data','linear','cubic spline','piecewise cubic','Location','NorthWest')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "t=[0 20 40 56 68 80 84 96 104 110]';\n",
+ "v=[0 20 20 38 80 80 100 100 125 125]';\n",
+ "tt=linspace(0,110)';\n",
+ "v_lin=interp1(t,v,tt);\n",
+ "v_spl=interp1(t,v,tt,'spline');\n",
+ "v_cub=interp1(t,v,tt,'cubic');\n",
+ "\n",
+ "\n",
+ "plot(tt(2:end),diff(v_lin)./diff(tt),tt(2:end),diff(v_spl)./diff(tt),tt(2:end),diff(v_cub)./diff(tt))\n",
+ "xlabel('t (s)')\n",
+ "ylabel('dv/dt (mph/s)')\n",
+ "legend('linear','cubic spline','piecewise cubic','Location','NorthWest')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Choose spline wisely\n",
+ "\n",
+ "For example of sin(x), not very important\n",
+ "\n",
+ "For stop-and-hold examples, the $C^{2}$-continuity should not be preserved. You don't need smooth curves.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Numerical Integration\n",
+ "\n",
+ "A definite integral is defined by \n",
+ "\n",
+ "$I=\\int_{a}^{b}f(x)dx$\n",
+ "\n",
+ "To determine the mass of an object with varying density, you can perform a summation\n",
+ "\n",
+ "mass=$\\sum_{i=1}^{n}\\rho_{i}\\Delta V_{i}$\n",
+ "\n",
+ "or taking the limit as $\\Delta V \\rightarrow dV=dxdydz$\n",
+ "\n",
+ "mass=$\\int_{0}^{h}\\int_{0}^{w}\\int_{0}^{l}\\rho(x,y,z)dxdydz$\n",
+ "\n",
+ "## Newton-Cotes Formulas\n",
+ "\n",
+ "$I=\\int_{a}^{b}f(x)dx=\\int_{a}^{b}f_{n}(x)dx$\n",
+ "\n",
+ "where $f_{n}$ is an n$^{th}$-order polynomial approximation of f(x)\n",
+ "\n",
+ "## First-Order: Trapezoidal Rule\n",
+ "\n",
+ "$I=\\int_{a}^{b}f(x)dx\\approx \\int_{a}^{b}\\left(f(a)+\\frac{f(b)-f(a)}{b-a}(x-a)\\right)dx$\n",
+ "\n",
+ "$I\\approx(b-a)\\frac{f(a)+f(b)}{2}$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "I_trap = 0.78540\n",
+ "I_act = 1.00000\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x=linspace(0,pi)';\n",
+ "plot(x,sin(x),[0,pi/2],sin([0,pi/2]))\n",
+ "I_trap=mean(sin(([0,pi/2]))*(diff([0,pi/2])))\n",
+ "I_act = -(cos(pi/2)-cos(0))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Improve estimate with more points\n",
+ "\n",
+ "$I=\\int_{a}^{b}f(x)dx=\\int_{a}^{a+\\Delta x}f(x)dx+\\int_{a+\\Delta x}^{a+2\\Delta x}f(x)dx+ \\cdots \\int_{b-\\Delta x}^{b}f(x)dx$\n",
+ "\n",
+ "$I\\approx\\Delta x\\frac{f(a)+f(a+\\Delta x)}{2}+\\Delta x\\frac{f(a+\\Delta x)+f(a+2\\Delta x)}{2}\n",
+ "+\\cdots \\Delta x\\frac{f(b-\\Delta x)+f(b)}{2}$\n",
+ "\n",
+ "$I\\approx \\frac{\\Delta x}{2}\\left(f(a)+2\\sum_{i=1}^{n-1}f(a+i\\Delta x) +f(b)\\right)$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "For 5 steps\n",
+ "trapezoid approximation of integral is 0.79 \n",
+ " actual integral is 1.00\n"
+ ]
+ }
+ ],
+ "source": [
+ "N=5;\n",
+ "I_trap=trap(@(x) sin(x),0,pi/2,N);\n",
+ "fprintf('For %i steps\\ntrapezoid approximation of integral is %1.2f \\n actual integral is %1.2f',N,I_trap,I_act)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "\n",
+ "plot(x,sin(x),linspace(0,pi/2,N),sin(linspace(0,pi/2,N)),'o')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Increase accuracy = Increase polynomial order\n",
+ "\n",
+ "### Simpson's Rules\n",
+ "\n",
+ "When integrating f(x) and using a second order polynomial, this is known as **Simpson's 1/3 Rule**\n",
+ "\n",
+ "$I=\\frac{h}{3}(f(x_{0})+4f(x_{1})+f(x_{2}))$\n",
+ "\n",
+ "where a=$x_{0}$, b=$x_{2}$, and $x_{1}=\\frac{a+b}{2}$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This can be used with n=3 or multiples of 2 intervals\n",
+ "\n",
+ "$I=\\int_{x_{0}}^{x_{2}}f(x)dx+\\int_{x_{2}}^{x_{4}}f(x)dx+\\cdots +\\int_{x_{n-2}}^{x_{n}}f(x)dx$\n",
+ "\n",
+ "$I=(b-a)\\frac{f(x_{0})+4\\sum_{i=1,3,5}^{n-1}f(x_{i})+2\\sum_{i=2,4,6}^{n-2}f(x_{i})+f(x_{n})}{3n}$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ans = 1.6235\n",
+ "Is_1_3 = 1.0023\n"
+ ]
+ }
+ ],
+ "source": [
+ "f=@(x) 0.2+25*x-200*x.^2+675*x.^3-900*x.^4+400*x.^5;\n",
+ "simpson3(f,0,0.8,4)\n",
+ "Is_1_3=simpson3(@(x) sin(x),0,pi/2,2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## General Newton-Cotes formulae\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Octave",
+ "language": "octave",
+ "name": "octave"
+ },
+ "language_info": {
+ "file_extension": ".m",
+ "help_links": [
+ {
+ "text": "MetaKernel Magics",
+ "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
+ }
+ ],
+ "mimetype": "text/x-octave",
+ "name": "octave",
+ "version": "0.19.14"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/lecture_19/newton_cotes.png b/lecture_19/newton_cotes.png
new file mode 100644
index 0000000..b734d11
Binary files /dev/null and b/lecture_19/newton_cotes.png differ
diff --git a/lecture_19/q1.png b/lecture_19/q1.png
new file mode 100644
index 0000000..44ec9da
Binary files /dev/null and b/lecture_19/q1.png differ
diff --git a/lecture_19/q2.png b/lecture_19/q2.png
new file mode 100644
index 0000000..fb27a54
Binary files /dev/null and b/lecture_19/q2.png differ
diff --git a/lecture_19/q3.png b/lecture_19/q3.png
new file mode 100644
index 0000000..62c4402
Binary files /dev/null and b/lecture_19/q3.png differ
diff --git a/lecture_19/q4.png b/lecture_19/q4.png
new file mode 100644
index 0000000..5457483
Binary files /dev/null and b/lecture_19/q4.png differ
diff --git a/lecture_19/simpson3.m b/lecture_19/simpson3.m
new file mode 100644
index 0000000..2ae0c81
--- /dev/null
+++ b/lecture_19/simpson3.m
@@ -0,0 +1,23 @@
+function I = simpson3(func,a,b,n,varargin)
+% simpson3: composite simpson's 1/3 rule
+% I = simpson3(func,a,b,n,pl,p2,...):
+% composite trapezoidal rule
+% input:
+% func = name of function to be integrated
+% a, b = integration limits
+% n = number of segments (default = 100)
+% pl,p2,... = additional parameters used by func
+% output:
+% I = integral estimate
+if nargin<3,error('at least 3 input arguments required'),end
+if ~(b>a),error('upper bound must be greater than lower'),end
+if nargin<4|isempty(n),n=100;end
+x = a; h = (b - a)/n;
+
+xvals=linspace(a,b,n+1);
+fvals=func(xvals,varargin{:});
+s=fvals(1);
+s = s + 4*sum(fvals(2:2:end-1));
+s = s + 2*sum(fvals(3:2:end-2));
+s = s + fvals(end);
+I = (b - a) * s/(3*n);
diff --git a/lecture_19/trap.m b/lecture_19/trap.m
new file mode 100644
index 0000000..85b8685
--- /dev/null
+++ b/lecture_19/trap.m
@@ -0,0 +1,22 @@
+function I = trap(func,a,b,n,varargin)
+% trap: composite trapezoidal rule quadrature
+% I = trap(func,a,b,n,pl,p2,...):
+% composite trapezoidal rule
+% input:
+% func = name of function to be integrated
+% a, b = integration limits
+% n = number of segments (default = 100)
+% pl,p2,... = additional parameters used by func
+% output:
+% I = integral estimate
+if nargin<3,error('at least 3 input arguments required'),end
+if ~(b>a),error('upper bound must be greater than lower'),end
+if nargin<4|isempty(n),n=100;end
+
+x = a; h = (b - a)/n;
+xvals=linspace(a,b,n);
+fvals=func(xvals,varargin{:});
+s=func(a,varargin{:});
+s = s + 2*sum(fvals(2:n-1));
+s = s + func(b,varargin{:});
+I = (b - a) * s/(2*n);