diff --git a/01_Introduction/octave-workspace b/01_Introduction/octave-workspace
index cded7e4..8c437bb 100644
Binary files a/01_Introduction/octave-workspace and b/01_Introduction/octave-workspace differ
diff --git a/03_Intro to matlab-octave/octave-workspace b/03_Intro to matlab-octave/octave-workspace
new file mode 100644
index 0000000..8ed7364
Binary files /dev/null and b/03_Intro to matlab-octave/octave-workspace differ
diff --git a/04_intro to m-files/octave-workspace b/04_intro to m-files/octave-workspace
index b841141..8c437bb 100644
Binary files a/04_intro to m-files/octave-workspace and b/04_intro to m-files/octave-workspace differ
diff --git a/06_roots and optimization/.ipynb_checkpoints/06_roots and optimization-checkpoint.ipynb b/06_roots and optimization/.ipynb_checkpoints/06_roots and optimization-checkpoint.ipynb
new file mode 100644
index 0000000..bcfbe7b
--- /dev/null
+++ b/06_roots and optimization/.ipynb_checkpoints/06_roots and optimization-checkpoint.ipynb
@@ -0,0 +1,913 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": true,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "%plot --format svg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Roots and Optimization\n",
+ "## Bracketing ch. 5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "source": [
+ "Given a function, numerical or analytical, it's not always possible a given variable. \n",
+ "\n",
+ "### Freefall example:\n",
+ "If an object, with drag coefficient of 0.25 kg/m reaches a velocity of 36 m/s after 4 seconds of freefalling, what is its mass?\n",
+ "\n",
+ "$v(t)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)$\n",
+ "\n",
+ "Cannot solve for m \n",
+ "\n",
+ "Instead, solve the problem by creating a new function f(m) where\n",
+ "\n",
+ "$f(m)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)-v(t)$. \n",
+ "\n",
+ "When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "setdefaults\n",
+ "g=9.81; % acceleration due to gravity\n",
+ "m=linspace(50, 200,100); % possible values for mass 50 to 200 kg\n",
+ "c_d=0.25; % drag coefficient\n",
+ "t=4; % at time = 4 seconds\n",
+ "v=36; % speed must be 36 m/s\n",
+ "f_m = @(m) sqrt(g*m/c_d).*tanh(sqrt(g*c_d./m)*t)-v; % anonymous function f_m\n",
+ "\n",
+ "plot(m,f_m(m),m,zeros(length(m),1))\n",
+ "axis([45 200 -5 1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ans = -0.056985\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "f_m(140)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0\n",
+ "\n",
+ "Better methods are the \n",
+ "1. Bracketing methods\n",
+ "2. Open methods\n",
+ "\n",
+ "Both need an initial guess. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Incremental method (Brute force)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "You know that for one value, m_lower, f_m is negative and for another value, m_upper, f_m is positive. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "^C\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "function xb = incsearch(func,xmin,xmax,ns)\n",
+ "% incsearch: incremental search root locator\n",
+ "% xb = incsearch(func,xmin,xmax,ns):\n",
+ "% finds brackets of x that contain sign changes\n",
+ "% of a function on an interval\n",
+ "% input:\n",
+ "% func = name of function\n",
+ "% xmin, xmax = endpoints of interval\n",
+ "% ns = number of subintervals (default = 50)\n",
+ "% output:\n",
+ "% xb(k,1) is the lower bound of the kth sign change\n",
+ "% xb(k,2) is the upper bound of the kth sign change\n",
+ "% If no brackets found, xb = [].\n",
+ "if nargin < 3, error('at least 3 arguments required'), end\n",
+ "if nargin < 4, ns = 50; end %if ns blank set to 50\n",
+ "% Incremental search\n",
+ "x = linspace(xmin,xmax,ns);\n",
+ "f = func(x);\n",
+ "nb = 0; xb = []; %xb is null unless sign change detected\n",
+ "for k = 1:length(x)-1\n",
+ " if sign(f(k)) ~= sign(f(k+1)) %check for sign change\n",
+ " nb = nb + 1;\n",
+ " xb(nb,1) = x(k);\n",
+ " xb(nb,2) = x(k+1);\n",
+ " end\n",
+ "end\n",
+ "if isempty(xb) %display that no brackets were found\n",
+ " fprintf('no brackets found\\n')\n",
+ " fprintf('check interval or increase ns\\n')\n",
+ "else\n",
+ " fprintf('number of brackets: %i\\n',nb) %display number of brackets\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'incsearch' is a function from the file /home/ryan/Documents/UConn/ME3255/me3255_S2017/course_git/lecture_06/incsearch.m\n",
+ "\n",
+ " incsearch: incremental search root locator\n",
+ " xb = incsearch(func,xmin,xmax,ns):\n",
+ " finds brackets of x that contain sign changes\n",
+ " of a function on an interval\n",
+ " input:\n",
+ " func = name of function\n",
+ " xmin, xmax = endpoints of interval\n",
+ " ns = number of subintervals (default = 50)\n",
+ " output:\n",
+ " xb(k,1) is the lower bound of the kth sign change\n",
+ " xb(k,2) is the upper bound of the kth sign change\n",
+ " If no brackets found, xb = [].\n",
+ "\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 incsearch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "number of brackets: 1\n",
+ "ans =\n",
+ "\n",
+ " 142.42 143.94\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "incsearch(f_m,50, 200,100)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Bisection method"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Divide interval in half until error is reduced to some level\n",
+ "\n",
+ "in previous example of freefall, choose x_l=50, x_u=200\n",
+ "\n",
+ "x_r = (50+200)/2 = 125\n",
+ "\n",
+ "f_m(125) = -0.408\n",
+ "\n",
+ "x_r= (125+200)/2 = 162.5\n",
+ "\n",
+ "f_m(162.5) = 0.3594\n",
+ "\n",
+ "x_r = (125+162.5)/2=143.75\n",
+ "\n",
+ "f_m(143.75)= 0.0206"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ans = 0.020577\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "f_m(143.75)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Bisect"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Much better root locator, with 4 iterations, our function is already close to zero\n",
+ "\n",
+ "Automate this with a function:\n",
+ "`bisect.m`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "^C\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)\n",
+ "% bisect: root location zeroes\n",
+ "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n",
+ "% uses bisection method to find the root of func\n",
+ "% input:\n",
+ "% func = name of function\n",
+ "% xl, xu = lower and upper guesses\n",
+ "% es = desired relative error (default = 0.0001%)\n",
+ "% maxit = maximum allowable iterations (default = 50)\n",
+ "% p1,p2,... = additional parameters used by func\n",
+ "% output:\n",
+ "% root = real root\n",
+ "% fx = function value at root\n",
+ "% ea = approximate relative error (%)\n",
+ "% iter = number of iterations\n",
+ "if nargin<3,error('at least 3 input arguments required'),end\n",
+ "test = func(xl,varargin{:})*func(xu,varargin{:});\n",
+ "if test>0,error('no sign change'),end\n",
+ "if nargin<4|isempty(es), es=0.0001;end\n",
+ "if nargin<5|isempty(maxit), maxit=50;end\n",
+ "iter = 0; xr = xl; ea = 100;\n",
+ "while (1)\n",
+ " xrold = xr;\n",
+ " xr = (xl + xu)/2;\n",
+ " iter = iter + 1;\n",
+ " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n",
+ " test = func(xl,varargin{:})*func(xr,varargin{:});\n",
+ " if test < 0\n",
+ " xu = xr;\n",
+ " elseif test > 0\n",
+ " xl = xr;\n",
+ " else\n",
+ " ea = 0;\n",
+ " end\n",
+ " if ea <= es | iter >= maxit,break,end\n",
+ "end\n",
+ "root = xr; fx = func(xr, varargin{:});"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'bisect' is a function from the file /home/ryan/Documents/UConn/ME3255/course_git_F2017/06_roots and optimization/bisect.m\n",
+ "\n",
+ " bisect: root location zeroes\n",
+ " [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n",
+ " uses bisection method to find the root of func\n",
+ " input:\n",
+ " func = name of function\n",
+ " xl, xu = lower and upper guesses\n",
+ " es = desired relative error (default = 0.0001%)\n",
+ " maxit = maximum allowable iterations (default = 50)\n",
+ " p1,p2,... = additional parameters used by func\n",
+ " output:\n",
+ " root = real root\n",
+ " fx = function value at root\n",
+ " ea = approximate relative error (%)\n",
+ " iter = number of iterations\n",
+ "\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 bisect"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## False position (linear interpolation)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Rather than bisecting each bracket (1/2 each time) we can calculate the slope between the two points and update the xr position in this manner\n",
+ "\n",
+ "$ x_{r} = x_{u} - \\frac{f(x_{u})(x_{l}-x_{u})}{f(x_{l})-f(x_{u})}$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%xl=50; xu=200; \n",
+ "xu=xr;\n",
+ "xl=xl;\n",
+ "xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu));\n",
+ "plot(m,f_m(m),xl,f_m(xl),'s',xu,f_m(xu),'s',xr,0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## False Position"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Much better root locator, with 4 iterations, our function is already close to zero\n",
+ "\n",
+ "Automate this with a function:\n",
+ "`falsepos.m`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "^C\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "function [root,fx,ea,iter]=falsepos(func,xl,xu,es,maxit,varargin)\n",
+ "% falsepos: root location zeroes\n",
+ "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n",
+ "% uses false position method to find the root of func\n",
+ "% input:\n",
+ "% func = name of function\n",
+ "% xl, xu = lower and upper guesses\n",
+ "% es = desired relative error (default = 0.0001%)\n",
+ "% maxit = maximum allowable iterations (default = 50)\n",
+ "% p1,p2,... = additional parameters used by func\n",
+ "% output:\n",
+ "% root = real root\n",
+ "% fx = function value at root\n",
+ "% ea = approximate relative error (%)\n",
+ "% iter = number of iterations\n",
+ "if nargin<3,error('at least 3 input arguments required'),end\n",
+ "test = func(xl,varargin{:})*func(xu,varargin{:});\n",
+ "if test>0,error('no sign change'),end\n",
+ "if nargin<4|isempty(es), es=0.0001;end\n",
+ "if nargin<5|isempty(maxit), maxit=50;end\n",
+ "iter = 0; xr = xl; ea = 100;\n",
+ "while (1)\n",
+ " xrold = xr;\n",
+ " % xr = (xl + xu)/2; % bisect method\n",
+ " xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu)); % false position method\n",
+ " iter = iter + 1;\n",
+ " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n",
+ " test = func(xl,varargin{:})*func(xr,varargin{:});\n",
+ " if test < 0\n",
+ " xu = xr;\n",
+ " elseif test > 0\n",
+ " xl = xr;\n",
+ " else\n",
+ " ea = 0;\n",
+ " end\n",
+ " if ea <= es | iter >= maxit,break,end\n",
+ "end\n",
+ "root = xr; fx = func(xr, varargin{:});"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Slideshow",
+ "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/06_roots and optimization/06_roots and optimization.ipynb b/06_roots and optimization/06_roots and optimization.ipynb
new file mode 100644
index 0000000..72dfcbf
--- /dev/null
+++ b/06_roots and optimization/06_roots and optimization.ipynb
@@ -0,0 +1,934 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": true,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "skip"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "%plot --format svg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Roots and Optimization\n",
+ "## Bracketing ch. 5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "source": [
+ "## Not always possible to solve for a given variable. \n",
+ "\n",
+ "### Freefall example:\n",
+ "If an object, with drag coefficient of 0.25 kg/m reaches a velocity of 36 m/s after 4 seconds of freefalling, what is its mass?\n",
+ "\n",
+ "$v(t)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)$\n",
+ "\n",
+ "Cannot solve for m \n",
+ "\n",
+ "Instead, solve the problem by creating a new function f(m) where\n",
+ "\n",
+ "$f(m)=\\sqrt{\\frac{gm}{c_{d}}}\\tanh(\\sqrt{\\frac{gc_{d}}{m}}t)-v(t)$. \n",
+ "\n",
+ "When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "setdefaults\n",
+ "g=9.81; % acceleration due to gravity\n",
+ "m=linspace(50, 200,100); % possible values for mass 50 to 200 kg\n",
+ "c_d=0.25; % drag coefficient\n",
+ "t=4; % at time = 4 seconds\n",
+ "v=36; % speed must be 36 m/s\n",
+ "f_m = @(m) sqrt(g*m/c_d).*tanh(sqrt(g*c_d./m)*t)-v; % anonymous function f_m\n",
+ "\n",
+ "plot(m,f_m(m),m,zeros(length(m),1))\n",
+ "axis([45 200 -5 1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ans = 0.0053580\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "f_m(143)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0\n",
+ "\n",
+ "Better methods are the \n",
+ "1. Bracketing methods\n",
+ "2. Open methods\n",
+ "\n",
+ "Both need an initial guess. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Incremental method (Brute force)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "You know that for one value, m_lower, f_m is negative and for another value, m_upper, f_m is positive. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "^C\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "function xb = incsearch(func,xmin,xmax,ns)\n",
+ "% incsearch: incremental search root locator\n",
+ "% xb = incsearch(func,xmin,xmax,ns):\n",
+ "% finds brackets of x that contain sign changes\n",
+ "% of a function on an interval\n",
+ "% input:\n",
+ "% func = name of function\n",
+ "% xmin, xmax = endpoints of interval\n",
+ "% ns = number of subintervals (default = 50)\n",
+ "% output:\n",
+ "% xb(k,1) is the lower bound of the kth sign change\n",
+ "% xb(k,2) is the upper bound of the kth sign change\n",
+ "% If no brackets found, xb = [].\n",
+ "if nargin < 3, error('at least 3 arguments required'), end\n",
+ "if nargin < 4, ns = 50; end %if ns blank set to 50\n",
+ "% Incremental search\n",
+ "x = linspace(xmin,xmax,ns);\n",
+ "f = func(x);\n",
+ "nb = 0; xb = []; %xb is null unless sign change detected\n",
+ "for k = 1:length(x)-1\n",
+ " if sign(f(k)) ~= sign(f(k+1)) %check for sign change\n",
+ " nb = nb + 1;\n",
+ " xb(nb,1) = x(k);\n",
+ " xb(nb,2) = x(k+1);\n",
+ " end\n",
+ "end\n",
+ "if isempty(xb) %display that no brackets were found\n",
+ " fprintf('no brackets found\\n')\n",
+ " fprintf('check interval or increase ns\\n')\n",
+ "else\n",
+ " fprintf('number of brackets: %i\\n',nb) %display number of brackets\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'incsearch' is a function from the file /home/ryan/Documents/UConn/ME3255/me3255_S2017/course_git/lecture_06/incsearch.m\n",
+ "\n",
+ " incsearch: incremental search root locator\n",
+ " xb = incsearch(func,xmin,xmax,ns):\n",
+ " finds brackets of x that contain sign changes\n",
+ " of a function on an interval\n",
+ " input:\n",
+ " func = name of function\n",
+ " xmin, xmax = endpoints of interval\n",
+ " ns = number of subintervals (default = 50)\n",
+ " output:\n",
+ " xb(k,1) is the lower bound of the kth sign change\n",
+ " xb(k,2) is the upper bound of the kth sign change\n",
+ " If no brackets found, xb = [].\n",
+ "\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 incsearch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "number of brackets: 1\n",
+ "ans =\n",
+ "\n",
+ " 142.42 143.94\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "incsearch(f_m,50, 200,100)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Bisection method"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Divide interval in half until error is reduced to some level\n",
+ "\n",
+ "in previous example of freefall, choose x_l=50, x_u=200\n",
+ "\n",
+ "x_r = (50+200)/2 = 125\n",
+ "\n",
+ "f_m(125) = -0.408\n",
+ "\n",
+ "x_r= (125+200)/2 = 162.5\n",
+ "\n",
+ "f_m(162.5) = 0.3594\n",
+ "\n",
+ "x_r = (125+162.5)/2=143.75\n",
+ "\n",
+ "f_m(143.75)= 0.0206"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "x_r = 125\n",
+ "interval left f(x_l)= -4.6,f(x_r)= -0.4\n",
+ "interval right f(x_r)= -0.4,f(x_u)= 0.9\n",
+ "ans = -0.40860\n"
+ ]
+ }
+ ],
+ "source": [
+ "x_l=50; x_u=200;\n",
+ "x_r=(x_l+x_u)/2\n",
+ "fprintf('interval left f(x_l)= %1.1f,f(x_r)= %1.1f\\n',f_m(x_l),f_m(x_r))\n",
+ "fprintf('interval right f(x_r)= %1.1f,f(x_u)= %1.1f\\n',f_m(x_r),f_m(x_u))\n",
+ "f_m(x_r)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## Bisect Function"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Much better root locator, with 4 iterations, our function is already close to zero\n",
+ "\n",
+ "Automate this with a function:\n",
+ "`bisect.m`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "^C\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)\n",
+ "% bisect: root location zeroes\n",
+ "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n",
+ "% uses bisection method to find the root of func\n",
+ "% input:\n",
+ "% func = name of function\n",
+ "% xl, xu = lower and upper guesses\n",
+ "% es = desired relative error (default = 0.0001%)\n",
+ "% maxit = maximum allowable iterations (default = 50)\n",
+ "% p1,p2,... = additional parameters used by func\n",
+ "% output:\n",
+ "% root = real root\n",
+ "% fx = function value at root\n",
+ "% ea = approximate relative error (%)\n",
+ "% iter = number of iterations\n",
+ "if nargin<3,error('at least 3 input arguments required'),end\n",
+ "test = func(xl,varargin{:})*func(xu,varargin{:});\n",
+ "if test>0,error('no sign change'),end\n",
+ "if nargin<4|isempty(es), es=0.0001;end\n",
+ "if nargin<5|isempty(maxit), maxit=50;end\n",
+ "iter = 0; xr = xl; ea = 100;\n",
+ "while (1)\n",
+ " xrold = xr;\n",
+ " xr = (xl + xu)/2;\n",
+ " iter = iter + 1;\n",
+ " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n",
+ " test = func(xl,varargin{:})*func(xr,varargin{:});\n",
+ " if test < 0\n",
+ " xu = xr;\n",
+ " elseif test > 0\n",
+ " xl = xr;\n",
+ " else\n",
+ " ea = 0;\n",
+ " end\n",
+ " if ea <= es | iter >= maxit,break,end\n",
+ "end\n",
+ "root = xr; fx = func(xr, varargin{:});"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "'bisect' is a function from the file /home/ryan/Documents/UConn/ME3255/course_git_F2017/06_roots and optimization/bisect.m\n",
+ "\n",
+ " bisect: root location zeroes\n",
+ " [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n",
+ " uses bisection method to find the root of func\n",
+ " input:\n",
+ " func = name of function\n",
+ " xl, xu = lower and upper guesses\n",
+ " es = desired relative error (default = 0.0001%)\n",
+ " maxit = maximum allowable iterations (default = 50)\n",
+ " p1,p2,... = additional parameters used by func\n",
+ " output:\n",
+ " root = real root\n",
+ " fx = function value at root\n",
+ " ea = approximate relative error (%)\n",
+ " iter = number of iterations\n",
+ "\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 bisect"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "# Thanks"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## False position (linear interpolation)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Rather than bisecting each bracket (1/2 each time) we can calculate the slope between the two points and update the xr position in this manner\n",
+ "\n",
+ "$ x_{r} = x_{u} - \\frac{f(x_{u})(x_{l}-x_{u})}{f(x_{l})-f(x_{u})}$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%xl=50; xu=200; \n",
+ "xu=xr;\n",
+ "xl=xl;\n",
+ "xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu));\n",
+ "plot(m,f_m(m),xl,f_m(xl),'s',xu,f_m(xu),'s',xr,0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ }
+ },
+ "source": [
+ "## False Position"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "source": [
+ "Much better root locator, with 4 iterations, our function is already close to zero\n",
+ "\n",
+ "Automate this with a function:\n",
+ "`falsepos.m`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "^C\r\n"
+ ]
+ }
+ ],
+ "source": [
+ "function [root,fx,ea,iter]=falsepos(func,xl,xu,es,maxit,varargin)\n",
+ "% falsepos: root location zeroes\n",
+ "% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):\n",
+ "% uses false position method to find the root of func\n",
+ "% input:\n",
+ "% func = name of function\n",
+ "% xl, xu = lower and upper guesses\n",
+ "% es = desired relative error (default = 0.0001%)\n",
+ "% maxit = maximum allowable iterations (default = 50)\n",
+ "% p1,p2,... = additional parameters used by func\n",
+ "% output:\n",
+ "% root = real root\n",
+ "% fx = function value at root\n",
+ "% ea = approximate relative error (%)\n",
+ "% iter = number of iterations\n",
+ "if nargin<3,error('at least 3 input arguments required'),end\n",
+ "test = func(xl,varargin{:})*func(xu,varargin{:});\n",
+ "if test>0,error('no sign change'),end\n",
+ "if nargin<4|isempty(es), es=0.0001;end\n",
+ "if nargin<5|isempty(maxit), maxit=50;end\n",
+ "iter = 0; xr = xl; ea = 100;\n",
+ "while (1)\n",
+ " xrold = xr;\n",
+ " % xr = (xl + xu)/2; % bisect method\n",
+ " xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu)); % false position method\n",
+ " iter = iter + 1;\n",
+ " if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end\n",
+ " test = func(xl,varargin{:})*func(xr,varargin{:});\n",
+ " if test < 0\n",
+ " xu = xr;\n",
+ " elseif test > 0\n",
+ " xl = xr;\n",
+ " else\n",
+ " ea = 0;\n",
+ " end\n",
+ " if ea <= es | iter >= maxit,break,end\n",
+ "end\n",
+ "root = xr; fx = func(xr, varargin{:});"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Slideshow",
+ "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/06_roots and optimization/bisect.m b/06_roots and optimization/bisect.m
new file mode 100644
index 0000000..c09ffbf
--- /dev/null
+++ b/06_roots and optimization/bisect.m
@@ -0,0 +1,37 @@
+function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)
+% bisect: root location zeroes
+% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):
+% uses bisection method to find the root of func
+% input:
+% func = name of function
+% xl, xu = lower and upper guesses
+% es = desired relative error (default = 0.0001%)
+% maxit = maximum allowable iterations (default = 50)
+% p1,p2,... = additional parameters used by func
+% output:
+% root = real root
+% fx = function value at root
+% ea = approximate relative error (%)
+% iter = number of iterations
+if nargin<3,error('at least 3 input arguments required'),end
+test = func(xl,varargin{:})*func(xu,varargin{:});
+if test>0,error('no sign change'),end
+if nargin<4|isempty(es), es=0.0001;end
+if nargin<5|isempty(maxit), maxit=50;end
+iter = 0; xr = xl; ea = 100;
+while (1)
+ xrold = xr;
+ xr = (xl + xu)/2;
+ iter = iter + 1;
+ if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end
+ test = func(xl,varargin{:})*func(xr,varargin{:});
+ if test < 0
+ xu = xr;
+ elseif test > 0
+ xl = xr;
+ else
+ ea = 0;
+ end
+ if ea <= es | iter >= maxit,break,end
+end
+root = xr; fx = func(xr, varargin{:});
\ No newline at end of file
diff --git a/06_roots and optimization/falsepos.m b/06_roots and optimization/falsepos.m
new file mode 100644
index 0000000..0a3477c
--- /dev/null
+++ b/06_roots and optimization/falsepos.m
@@ -0,0 +1,39 @@
+function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)
+% bisect: root location zeroes
+% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):
+% uses bisection method to find the root of func
+% input:
+% func = name of function
+% xl, xu = lower and upper guesses
+% es = desired relative error (default = 0.0001%)
+% maxit = maximum allowable iterations (default = 50)
+% p1,p2,... = additional parameters used by func
+% output:
+% root = real root
+% fx = function value at root
+% ea = approximate relative error (%)
+% iter = number of iterations
+if nargin<3,error('at least 3 input arguments required'),end
+test = func(xl,varargin{:})*func(xu,varargin{:});
+if test>0,error('no sign change'),end
+if nargin<4|isempty(es), es=0.0001;end
+if nargin<5|isempty(maxit), maxit=50;end
+iter = 0; xr = xl; ea = 100;
+while (1)
+ xrold = xr;
+ xr = (xl + xu)/2;
+ % xr = (xl + xu)/2; % bisect method
+ xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu)); % false position method
+ iter = iter + 1;
+ if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end
+ test = func(xl,varargin{:})*func(xr,varargin{:});
+ if test < 0
+ xu = xr;
+ elseif test > 0
+ xl = xr;
+ else
+ ea = 0;
+ end
+ if ea <= es | iter >= maxit,break,end
+end
+root = xr; fx = func(xr, varargin{:});
diff --git a/06_roots and optimization/incsearch.m b/06_roots and optimization/incsearch.m
new file mode 100644
index 0000000..bd82554
--- /dev/null
+++ b/06_roots and optimization/incsearch.m
@@ -0,0 +1,37 @@
+function xb = incsearch(func,xmin,xmax,ns)
+% incsearch: incremental search root locator
+% xb = incsearch(func,xmin,xmax,ns):
+% finds brackets of x that contain sign changes
+% of a function on an interval
+% input:
+% func = name of function
+% xmin, xmax = endpoints of interval
+% ns = number of subintervals (default = 50)
+% output:
+% xb(k,1) is the lower bound of the kth sign change
+% xb(k,2) is the upper bound of the kth sign change
+% If no brackets found, xb = [].
+if nargin < 3, error('at least 3 arguments required'), end
+if nargin < 4, ns = 50; end %if ns blank set to 50
+% Incremental search
+x = linspace(xmin,xmax,ns);
+f = func(x);
+nb = 0; xb = []; %xb is null unless sign change detected
+%for k = 1:length(x)-1
+% if sign(f(k)) ~= sign(f(k+1)) %check for sign change
+% nb = nb + 1;
+% xb(nb,1) = x(k);
+% xb(nb,2) = x(k+1);
+% end
+%end
+sign_change = diff(sign(f));
+[~,i_change] = find(sign_change~=0);
+nb=length(i_change);
+xb=[x(i_change)',x(i_change+1)'];
+
+if isempty(xb) %display that no brackets were found
+ fprintf('no brackets found\n')
+ fprintf('check interval or increase ns\n')
+else
+ fprintf('number of brackets: %i\n',nb) %display number of brackets
+end
diff --git a/06_roots and optimization/lecture_06.md b/06_roots and optimization/lecture_06.md
new file mode 100644
index 0000000..b3d2266
--- /dev/null
+++ b/06_roots and optimization/lecture_06.md
@@ -0,0 +1,373 @@
+
+
+```octave
+%plot --format svg
+```
+
+my_caller.m
+```matlab
+function [vx,vy] = my_caller(max_time)
+ N=100;
+ t=linspace(0,max_time,N);
+ [x,y]=my_function(max_time);
+ vx=diff(x)./diff(t);
+ vy=diff(y)./diff(t);
+end
+```
+
+my_function.m
+```matlab
+function [x,y] = my_function(max_time)
+ N=100;
+ t=linspace(0,max_time,N);
+ x=t.^2;
+ y=2*t;
+end
+```
+
+In order to use `my_caller.m` where does `my_function.m` need to be saved?
+
+
+
+What cool personal projects are you working on?
+While we delve deeper into Matlab functions, could we review some of the basic logic
+operators it uses and command codes.
+
+I still dont know when these forms are technically due.
+
+ -by the following lecture
+
+I'm having trouble interfacing Atom with GitHub. Is there a simple tutorial for this?
+
+ -Mac? Seems there could be a bug that folks are working on
+
+What are the bear necessities of life?
+please go over how to "submit" the homeworks because it is still confusing
+
+Do you prefer Matlab or Octave?
+
+ -octave is my preference, but Matlab has some benefits
+
+Would you consider a country to be open-source?
+
+ -??
+
+Is there a way to download matlab for free?
+
+ -not legally
+
+how do you add files to current folder in matlab?
+
+ -you can do this either through a file browser or cli
+
+How should Homework 2 be submitted? By simply putting the function into the homework_1
+repository?
+
+ -yes
+
+How can we tell that these forms are being received?
+
+ -when you hit submit, the form says "form received"
+
+can you save scripted outputs from matlab/octave as an excel file?
+
+ -yes, easy way is open a file with a .csv extension then fprintf and separate everything with commas, harder way is to use the `xlswrite`
+
+
+Also, can you update your notes to show what happens when these things are run, as you do
+in class?"
+
+ -I always update the lecture notes after class so they should display what we did in class
+
+I have a little difficulty following along in class on my laptop when you have programs
+pre-written. Maybe if you posted those codes on Github so I could copy them when you
+switch to different desktops I would be able to follow along better.
+
+Kirk or Picard?
+
+ -Kirk
+
+Who is our TA?
+
+ -Peiyu Zhang peiyu.zhang@uconn.edu
+
+Can we download libraries of data like thermodynamic tables into matlab?
+
+-YES! [Matlab Steam Tables](http://bit.ly/2kZygu8)
+
+Will we use the Simulink addition to Matlab? I found it interesting and useful for
+evaluating ODEs in Linear systems.
+
+ -not in this class, everything in simulink has a matlab script/function that can be substituted, but many times its hidden by the gui. Here we want to look directly at our solvers
+
+
+# Roots and Optimization
+## Bracketing ch. 5
+
+When you are given a function, numerical or analytical, it's not always possible to solve directly for a given variable.
+
+Even for the freefall example we first explored,
+
+$v(t)=\sqrt{\frac{gm}{c_{d}}}\tanh(\sqrt{\frac{gc_{d}}{m}}t)$
+
+There is no way to solve for m in terms of the other variables.
+
+Instead, we can solve the problem by creating a new function f(m) where
+
+$f(m)=\sqrt{\frac{gm}{c_{d}}}\tanh(\sqrt{\frac{gc_{d}}{m}}t)-v(t)$.
+
+When f(m) = 0, we have solved for m in terms of the other variables (e.g. for a given time, velocity, drag coefficient and acceleration due to gravity)
+
+
+```octave
+setdefaults
+g=9.81; % acceleration due to gravity
+m=linspace(50, 200,100); % possible values for mass 50 to 200 kg
+c_d=0.25; % drag coefficient
+t=4; % at time = 4 seconds
+v=36; % speed must be 36 m/s
+f_m = @(m) sqrt(g*m/c_d).*tanh(sqrt(g*c_d./m)*t)-v; % anonymous function f_m
+
+plot(m,f_m(m),m,zeros(length(m),1))
+axis([45 200 -5 1])
+```
+
+
+
+
+
+
+```octave
+f_m(145)
+```
+
+ ans = 0.045626
+
+
+Brute force method is plot f_m vs m and with smaller and smaller steps until f_m ~ 0
+
+Better methods are the
+1. Bracketing methods
+2. Open methods
+
+Both need an initial guess.
+
+
+## Incremental method (Brute force)
+
+You know that for one value, m_lower, f_m is negative and for another value, m_upper, f_m is positive.
+
+```matlab
+function xb = incsearch(func,xmin,xmax,ns)
+% incsearch: incremental search root locator
+% xb = incsearch(func,xmin,xmax,ns):
+% finds brackets of x that contain sign changes
+% of a function on an interval
+% input:
+% func = name of function
+% xmin, xmax = endpoints of interval
+% ns = number of subintervals (default = 50)
+% output:
+% xb(k,1) is the lower bound of the kth sign change
+% xb(k,2) is the upper bound of the kth sign change
+% If no brackets found, xb = [].
+if nargin < 3, error('at least 3 arguments required'), end
+if nargin < 4, ns = 50; end %if ns blank set to 50
+% Incremental search
+x = linspace(xmin,xmax,ns);
+f = func(x);
+nb = 0; xb = []; %xb is null unless sign change detected
+for k = 1:length(x)-1
+ if sign(f(k)) ~= sign(f(k+1)) %check for sign change
+ nb = nb + 1;
+ xb(nb,1) = x(k);
+ xb(nb,2) = x(k+1);
+ end
+end
+if isempty(xb) %display that no brackets were found
+ fprintf('no brackets found\n')
+ fprintf('check interval or increase ns\n')
+else
+ fprintf('number of brackets: %i\n',nb) %display number of brackets
+end
+```
+
+
+```octave
+help incsearch
+```
+
+ 'incsearch' is a function from the file /home/ryan/Documents/UConn/ME3255/me3255_S2017/lecture_06/incsearch.m
+
+ incsearch: incremental search root locator
+ xb = incsearch(func,xmin,xmax,ns):
+ finds brackets of x that contain sign changes
+ of a function on an interval
+ input:
+ func = name of function
+ xmin, xmax = endpoints of interval
+ ns = number of subintervals (default = 50)
+ output:
+ xb(k,1) is the lower bound of the kth sign change
+ xb(k,2) is the upper bound of the kth sign change
+ If no brackets found, xb = [].
+
+
+ Additional help for built-in functions and operators is
+ available in the online version of the manual. Use the command
+ 'doc ' to search the manual index.
+
+ Help and information about Octave is also available on the WWW
+ at http://www.octave.org and via the help@octave.org
+ mailing list.
+
+
+
+```octave
+incsearch(f_m,50, 200,55)
+```
+
+ no brackets found
+ check interval or increase ns
+ ans = [](1x0)
+
+
+## Bisection method
+
+Divide interval in half until error is reduced to some level
+
+in previous example of freefall, choose x_l=50, x_u=200
+
+x_r = (50+200)/2 = 125
+
+f_m(125) = -0.408
+
+x_r= (125+200)/2 = 162.5
+
+f_m(162.5) = 0.3594
+
+x_r = (125+162.5)/2=143.75
+
+f_m(143.75)= 0.0206
+
+
+```octave
+f_m(143.75)
+```
+
+ ans = 0.020577
+
+
+Much better root locator, with 4 iterations, our function is already close to zero
+
+Automate this with a function:
+`bisect.m`
+
+```matlab
+function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin)
+% bisect: root location zeroes
+% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):
+% uses bisection method to find the root of func
+% input:
+% func = name of function
+% xl, xu = lower and upper guesses
+% es = desired relative error (default = 0.0001%)
+% maxit = maximum allowable iterations (default = 50)
+% p1,p2,... = additional parameters used by func
+% output:
+% root = real root
+% fx = function value at root
+% ea = approximate relative error (%)
+% iter = number of iterations
+if nargin<3,error('at least 3 input arguments required'),end
+test = func(xl,varargin{:})*func(xu,varargin{:});
+if test>0,error('no sign change'),end
+if nargin<4|isempty(es), es=0.0001;end
+if nargin<5|isempty(maxit), maxit=50;end
+iter = 0; xr = xl; ea = 100;
+while (1)
+ xrold = xr;
+ xr = (xl + xu)/2;
+ iter = iter + 1;
+ if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end
+ test = func(xl,varargin{:})*func(xr,varargin{:});
+ if test < 0
+ xu = xr;
+ elseif test > 0
+ xl = xr;
+ else
+ ea = 0;
+ end
+ if ea <= es | iter >= maxit,break,end
+end
+root = xr; fx = func(xr, varargin{:});
+```
+
+## False position (linear interpolation)
+
+Rather than bisecting each bracket (1/2 each time) we can calculate the slope between the two points and update the xr position in this manner
+
+$ x_{r} = x_{u} - \frac{f(x_{u})(x_{l}-x_{u})}{f(x_{l})-f(x_{u})}$
+
+
+```octave
+xl=50; xu=200;
+xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu));
+
+plot(m,f_m(m),xl,f_m(xl),'s',xu,f_m(xu),'s',xr,0)
+```
+
+
+
+
+
+Much better root locator, with 4 iterations, our function is already close to zero
+
+Automate this with a function:
+`falsepos.m`
+
+```matlab
+function [root,fx,ea,iter]=falsepos(func,xl,xu,es,maxit,varargin)
+% falsepos: root location zeroes
+% [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,p1,p2,...):
+% uses false position method to find the root of func
+% input:
+% func = name of function
+% xl, xu = lower and upper guesses
+% es = desired relative error (default = 0.0001%)
+% maxit = maximum allowable iterations (default = 50)
+% p1,p2,... = additional parameters used by func
+% output:
+% root = real root
+% fx = function value at root
+% ea = approximate relative error (%)
+% iter = number of iterations
+if nargin<3,error('at least 3 input arguments required'),end
+test = func(xl,varargin{:})*func(xu,varargin{:});
+if test>0,error('no sign change'),end
+if nargin<4|isempty(es), es=0.0001;end
+if nargin<5|isempty(maxit), maxit=50;end
+iter = 0; xr = xl; ea = 100;
+while (1)
+ xrold = xr;
+ % xr = (xl + xu)/2; % bisect method
+ xr=xu - (f_m(xu)*(xl-xu))/(f_m(xl)-f_m(xu)); % false position method
+ iter = iter + 1;
+ if xr ~= 0,ea = abs((xr - xrold)/xr) * 100;end
+ test = func(xl,varargin{:})*func(xr,varargin{:});
+ if test < 0
+ xu = xr;
+ elseif test > 0
+ xl = xr;
+ else
+ ea = 0;
+ end
+ if ea <= es | iter >= maxit,break,end
+end
+root = xr; fx = func(xr, varargin{:});
+```
+
+
+```octave
+
+```
diff --git a/06_roots and optimization/octave-workspace b/06_roots and optimization/octave-workspace
new file mode 100644
index 0000000..0918300
Binary files /dev/null and b/06_roots and optimization/octave-workspace differ
diff --git a/HW1/.README.md.swp b/HW1/.README.md.swp
deleted file mode 100644
index e73eed8..0000000
Binary files a/HW1/.README.md.swp and /dev/null differ
diff --git a/HW1/README.md b/HW1/README.md
index 701a045..c1c93c6 100644
--- a/HW1/README.md
+++ b/HW1/README.md
@@ -64,7 +64,7 @@
of the two indices from 1 to 6 e.g. A_66(3,2)=6 and A_66(4,4)=16. Calculate the mean and
standard deviation of the values in A_66.
-3. Copy the data in
+4. Copy the data in
[US_energy_by_sector.csv](https://github.uconn.edu/rcc02007/ME3255F2017/blob/master/03_Intro%20to%20matlab-octave/US_energy_by_sector.csv)
to a file in you working directory in Matlab/Octave. Add these two plots to your
01_ME3255_repo with a heading of `#Problem 4`
@@ -78,7 +78,7 @@ to a file in you working directory in Matlab/Octave. Add these two plots to your
of Btu's (1 quintillion = 10$^6$ trillion). The cumulative energy is the area under
the curve in part a from 1949 to a given year.
-3. In this part, you will modify the function presented in lecture `freefall.m`. In
+5. In this part, you will modify the function presented in lecture `freefall.m`. In
lecture, the function required an input of `N` to divide the 12 second solution into
N-steps. Here, modify the input so that you can specify two inputs, step size-`h`, and
timespan-`timespan`.
@@ -92,7 +92,7 @@ timespan-`timespan`.
c. Save your work to a folder called 'problem_3' and add it to the '01_ME3255_repo'
repository
-4. In this part we will create functions that calculate velocity and acceleration in 3D
+6. In this part we will create functions that calculate velocity and acceleration in 3D
based upon x,y,z-coordinates and time.
a. Create a function that takes four vectors as input, x,y,z,t,(where x,y,z are
diff --git a/HW1/freefall.m b/HW1/freefall.m
new file mode 100644
index 0000000..c67501b
--- /dev/null
+++ b/HW1/freefall.m
@@ -0,0 +1,21 @@
+function [v_analytical,v_terminal,t]=freefall(N)
+ % help file for freefall.m
+ % N is number of timesteps between 0 and 12 sec
+ % v_an...
+ t=linspace(0,12,N)';
+ c=0.25; m=60; g=9.81; v_terminal=sqrt(m*g/c);
+
+ v_analytical = v_terminal*tanh(g*t/v_terminal);
+ v_numerical=zeros(length(t),1);
+ delta_time =diff(t);
+ for i=1:length(t)-1
+ v_numerical(i+1)=v_numerical(i)+(g-c/m*v_numerical(i)^2)*delta_time(i);
+ end
+ % Print values near 0,2,4,6,8,10,12 seconds
+ indices = round(linspace(1,length(t),7));
+ fprintf('time (s)|vel analytical (m/s)|vel numerical (m/s)\n')
+ fprintf('-----------------------------------------------\n')
+ M=[t(indices),v_analytical(indices),v_numerical(indices)];
+ fprintf('%7.1f | %18.2f | %15.2f\n',M(:,1:3)');
+ plot(t,v_analytical,'-',t,v_numerical,'o-')
+end